6502/6502_65C02_functional_tests
1
0
Fork 0
mirror of https://github.com/Klaus2m5/6502_65C02_functional_tests.git synced 2024-12-30 10:29:34 +00:00
Code Issues Projects Releases Wiki Activity
a06e3b95d6
6502_65C02_functional_tests/bin_files/65C02_extended_opcodes_test.lst
Klaus2m5 a06e3b95d6 added binaries 
Added pre-configured binaries with listing. Loadable from $0000 for full
64k
2013-12-18 11:19:08 +01:00

11308 lines
563 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

AS65 Assembler for R6502 [1.42]. Copyright 1994-2007, Frank A. Kingswood Page 1
------------------------------------------------ 65C02_extended_opcodes_test.a65c ------------------------------------------------
2748 lines read, no errors in pass 1.
;
; 6 5 C 0 2 E X T E N D E D O P C O D E S T E S T
;
; Copyright (C) 2013 Klaus Dormann
;
; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version.
;
; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>.
; This program is designed to test all additional 65C02 opcodes, addressing
; modes and functionality not available in the NMOS version of the 6502.
; The 6502_functional_test is a prerequisite to this test.
; NMI, IRQ, BRK, STP & WAI are covered in the 6502_interrupt_test.
;
; version 16-aug-2013
; edited to provide a pre-configured bin file loadable at $0000 for full 64k
; contact info at http://2m5.de or email K@2m5.de
;
; assembled with AS65 from http://www.kingswood-consulting.co.uk/assemblers/
; command line switches: -l -m -s2 -w -x -h0
; | | | | | no page headers in listing
; | | | | 65C02 extensions
; | | | wide listing (133 char/col)
; | | write intel hex file instead of binary
; | expand macros in listing
; generate pass2 listing
;
; No IO - should be run from a monitor with access to registers.
; To run load intel hex image with a load command, than alter PC to 400 hex
; (code_segment) and enter a go command.
; Loop on program counter determines error or successful completion of test.
; Check listing for relevant traps (jump/branch *).
; Please note that in early tests some instructions will have to be used before
; they are actually tested!
;
; RESET, NMI or IRQ should not occur and will be trapped if vectors are enabled.
; Tests documented behavior of the original 65C02 only!
; Decimal ops will only be tested with valid BCD operands and the V flag will
; be ignored as it is absolutely useless in decimal mode.
;
; Debugging hints:
; Most of the code is written sequentially. if you hit a trap, check the
; immediately preceeding code for the instruction to be tested. Results are
; tested first, flags are checked second by pushing them onto the stack and
; pulling them to the accumulator after the result was checked. The "real"
; flags are no longer valid for the tested instruction at this time!
; If the tested instruction was indexed, the relevant index (X or Y) must
; also be checked. Opposed to the flags, X and Y registers are still valid.
;
; versions:
; 19-jul-2013 1st version distributed for testing
; 23-jul-2013 fixed BRA out of range due to larger trap macros
; added RAM integrity check
; 16-aug-2013 added error report to standard output option
; C O N F I G U R A T I O N
;ROM_vectors writable (0=no, 1=yes)
;if ROM vectors can not be used interrupts will not be trapped
;as a consequence BRK can not be tested but will be emulated to test RTI
0001 = ROM_vectors = 1
;load_data_direct (0=move from code segment, 1=load directly)
;loading directly is preferred but may not be supported by your platform
;0 produces only consecutive object code, 1 is not suitable for a binary image
0001 = load_data_direct = 1
;I_flag behavior (0=force enabled, 1=force disabled, 2=prohibit change, 3=allow
;change) 2 requires extra code and is not recommended.
0003 = I_flag = 3
;configure memory - try to stay away from memory used by the system
;zero_page memory start address, $4e (78) consecutive Bytes required
; add 2 if I_flag = 2
000a = zero_page = $a
;data_segment memory start address, $5D (93) consecutive Bytes required
; + 12 Bytes at data_segment + $f9 (JMP indirect page cross test)
0200 = data_segment = $200
if (data_segment & $ff) != 0
ERROR ERROR ERROR low byte of data_segment MUST be $00 !!
endif
;code_segment memory start address, 10kB of consecutive space required
; add 1 kB if I_flag = 2
;parts of the code are self modifying and must reside in RAM
0400 = code_segment = $400
;added WDC only opcodes WAI & STP (0=test as NOPs, >0=no test)
0001 = wdc_op = 1
;added Rockwell & WDC opcodes BBR, BBS, RMB & SMB
;(0=test as NOPs, 1=full test, >1=no test)
0001 = rkwl_wdc_op = 1
;report errors through I/O channel (0=use standard self trap loops, 1=include
;report.i65 as I/O channel, add 3 kB)
0000 = report = 0
;RAM integrity test option. Checks for undesired RAM writes.
;set lowest non RAM or RAM mirror address page (-1=disable, 0=64k, $40=16k)
;leave disabled if a monitor, OS or background interrupt is allowed to alter RAM
ffff = ram_top = -1
noopt ;do not take shortcuts
;macros for error & success traps to allow user modification
;example:
;trap macro
; jsr my_error_handler
; endm
;trap_eq macro
; bne skip\?
; trap ;failed equal (zero)
;skip\?
; endm
;
; my_error_handler should pop the calling address from the stack and report it.
; putting larger portions of code (more than 3 bytes) inside the trap macro
; may lead to branch range problems for some tests.
if report = 0
trap macro
jmp * ;failed anyway
endm
trap_eq macro
beq * ;failed equal (zero)
endm
trap_ne macro
bne * ;failed not equal (non zero)
endm
trap_cs macro
bcs * ;failed carry set
endm
trap_cc macro
bcc * ;failed carry clear
endm
trap_mi macro
bmi * ;failed minus (bit 7 set)
endm
trap_pl macro
bpl * ;failed plus (bit 7 clear)
endm
trap_vs macro
bvs * ;failed overflow set
endm
trap_vc macro
bvc * ;failed overflow clear
endm
; please observe that during the test the stack gets invalidated
; therefore a RTS inside the success macro is not possible
success macro
jmp * ;test passed, no errors
endm
endif
if report = 1
trap macro
jsr report_error
endm
trap_eq macro
bne skip\?
trap ;failed equal (zero)
skip\?
endm
trap_ne macro
beq skip\?
trap ;failed not equal (non zero)
skip\?
endm
trap_cs macro
bcc skip\?
trap ;failed carry set
skip\?
endm
trap_cc macro
bcs skip\?
trap ;failed carry clear
skip\?
endm
trap_mi macro
bpl skip\?
trap ;failed minus (bit 7 set)
skip\?
endm
trap_pl macro
bmi skip\?
trap ;failed plus (bit 7 clear)
skip\?
endm
trap_vs macro
bvc skip\?
trap ;failed overflow set
skip\?
endm
trap_vc macro
bvs skip\?
trap ;failed overflow clear
skip\?
endm
; please observe that during the test the stack gets invalidated
; therefore a RTS inside the success macro is not possible
success macro
jsr report_success
endm
endif
0001 = carry equ %00000001 ;flag bits in status
0002 = zero equ %00000010
0004 = intdis equ %00000100
0008 = decmode equ %00001000
0010 = break equ %00010000
0020 = reserv equ %00100000
0040 = overfl equ %01000000
0080 = minus equ %10000000
0001 = fc equ carry
0002 = fz equ zero
0003 = fzc equ carry+zero
0040 = fv equ overfl
0042 = fvz equ overfl+zero
0080 = fn equ minus
0081 = fnc equ minus+carry
0082 = fnz equ minus+zero
0083 = fnzc equ minus+zero+carry
00c0 = fnv equ minus+overfl
0030 = fao equ break+reserv ;bits always on after PHP, BRK
0034 = fai equ fao+intdis ;+ forced interrupt disable
00ff = m8 equ $ff ;8 bit mask
00fb = m8i equ $ff&~intdis ;8 bit mask - interrupt disable
;macros to allow masking of status bits.
;masking of interrupt enable/disable on load and compare
;masking of always on bits after PHP or BRK (unused & break) on compare
if I_flag = 0
load_flag macro
lda #\1&m8i ;force enable interrupts (mask I)
endm
cmp_flag macro
cmp #(\1|fao)&m8i ;I_flag is always enabled + always on bits
endm
eor_flag macro
eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits
endm
endif
if I_flag = 1
load_flag macro
lda #\1|intdis ;force disable interrupts
endm
cmp_flag macro
cmp #(\1|fai)&m8 ;I_flag is always disabled + always on bits
endm
eor_flag macro
eor #(\1|fai) ;invert expected flags + always on bits + I
endm
endif
if I_flag = 2
load_flag macro
lda #\1
ora flag_I_on ;restore I-flag
and flag_I_off
endm
cmp_flag macro
eor flag_I_on ;I_flag is never changed
cmp #(\1|fao)&m8i ;expected flags + always on bits, mask I
endm
eor_flag macro
eor flag_I_on ;I_flag is never changed
eor #(\1&m8i|fao) ;mask I, invert expected flags + always on bits
endm
endif
if I_flag = 3
load_flag macro
lda #\1 ;allow test to change I-flag (no mask)
endm
cmp_flag macro
cmp #(\1|fao)&m8 ;expected flags + always on bits
endm
eor_flag macro
eor #\1|fao ;invert expected flags + always on bits
endm
endif
;macros to set (register|memory|zeropage) & status
set_stat macro ;setting flags in the processor status register
load_flag \1
pha ;use stack to load status
plp
endm
set_a macro ;precharging accu & status
load_flag \2
pha ;use stack to load status
lda #\1 ;precharge accu
plp
endm
set_x macro ;precharging index & status
load_flag \2
pha ;use stack to load status
ldx #\1 ;precharge index x
plp
endm
set_y macro ;precharging index & status
load_flag \2
pha ;use stack to load status
ldy #\1 ;precharge index y
plp
endm
set_ax macro ;precharging indexed accu & immediate status
load_flag \2
pha ;use stack to load status
lda \1,x ;precharge accu
plp
endm
set_ay macro ;precharging indexed accu & immediate status
load_flag \2
pha ;use stack to load status
lda \1,y ;precharge accu
plp
endm
set_z macro ;precharging indexed zp & immediate status
load_flag \2
pha ;use stack to load status
lda \1,x ;load to zeropage
sta zpt
plp
endm
set_zx macro ;precharging zp,x & immediate status
load_flag \2
pha ;use stack to load status
lda \1,x ;load to indexed zeropage
sta zpt,x
plp
endm
set_abs macro ;precharging indexed memory & immediate status
load_flag \2
pha ;use stack to load status
lda \1,x ;load to memory
sta abst
plp
endm
set_absx macro ;precharging abs,x & immediate status
load_flag \2
pha ;use stack to load status
lda \1,x ;load to indexed memory
sta abst,x
plp
endm
;macros to test (register|memory|zeropage) & status & (mask)
tst_stat macro ;testing flags in the processor status register
php ;save status
pla ;use stack to retrieve status
pha
cmp_flag \1
trap_ne
plp ;restore status
endm
tst_a macro ;testing result in accu & flags
php ;save flags
cmp #\1 ;test result
trap_ne
pla ;load status
pha
cmp_flag \2
trap_ne
plp ;restore status
endm
tst_as macro ;testing result in accu & flags, save accu
pha
php ;save flags
cmp #\1 ;test result
trap_ne
pla ;load status
pha
cmp_flag \2
trap_ne
plp ;restore status
pla
endm
tst_x macro ;testing result in x index & flags
php ;save flags
cpx #\1 ;test result
trap_ne
pla ;load status
pha
cmp_flag \2
trap_ne
plp ;restore status
endm
tst_y macro ;testing result in y index & flags
php ;save flags
cpy #\1 ;test result
trap_ne
pla ;load status
pha
cmp_flag \2
trap_ne
plp ;restore status
endm
tst_ax macro ;indexed testing result in accu & flags
php ;save flags
cmp \1,x ;test result
trap_ne
pla ;load status
eor_flag \3
cmp \2,x ;test flags
trap_ne ;
endm
tst_ay macro ;indexed testing result in accu & flags
php ;save flags
cmp \1,y ;test result
trap_ne ;
pla ;load status
eor_flag \3
cmp \2,y ;test flags
trap_ne
endm
tst_z macro ;indexed testing result in zp & flags
php ;save flags
lda zpt
cmp \1,x ;test result
trap_ne
pla ;load status
eor_flag \3
cmp \2,x ;test flags
trap_ne
endm
tst_zx macro ;testing result in zp,x & flags
php ;save flags
lda zpt,x
cmp \1,x ;test result
trap_ne
pla ;load status
eor_flag \3
cmp \2,x ;test flags
trap_ne
endm
tst_abs macro ;indexed testing result in memory & flags
php ;save flags
lda abst
cmp \1,x ;test result
trap_ne
pla ;load status
eor_flag \3
cmp \2,x ;test flags
trap_ne
endm
tst_absx macro ;testing result in abs,x & flags
php ;save flags
lda abst,x
cmp \1,x ;test result
trap_ne
pla ;load status
eor_flag \3
cmp \2,x ;test flags
trap_ne
endm
; RAM integrity test
; verifies that none of the previous tests has altered RAM outside of the
; designated write areas.
; uses zpt word as indirect pointer, zpt+2 word as checksum
if ram_top > -1
check_ram macro
cld
lda #0
sta zpt ;set low byte of indirect pointer
sta zpt+3 ;checksum high byte
ldx #11 ;reset modifiable RAM
ccs1\? sta jxi_tab,x ;JMP indirect page cross area
dex
bpl ccs1\?
sta chkdadi ;self modifying code
sta chkdsbi
clc
ldx #zp_bss-zero_page ;zeropage - write test area
ccs3\? adc zero_page,x
bcc ccs2\?
inc zpt+3 ;carry to high byte
clc
ccs2\? inx
bne ccs3\?
ldx #hi(data_segment) ;set high byte of indirect pointer
stx zpt+1
ldy #lo(data_bss) ;data after write test area
ccs5\? adc (zpt),y
bcc ccs4\?
inc zpt+3 ;carry to high byte
clc
ccs4\? iny
bne ccs5\?
inx ;advance RAM high address
stx zpt+1
cpx #ram_top
bne ccs5\?
sta zpt+2 ;checksum low is
cmp ram_chksm ;checksum low expected
trap_ne ;checksum mismatch
lda zpt+3 ;checksum high is
cmp ram_chksm+1 ;checksum high expected
trap_ne ;checksum mismatch
endm
else
check_ram macro
;RAM check disabled - RAM size not set
endm
endif
next_test macro ;make sure, tests don't jump the fence
lda test_case ;previous test
cmp #test_num
trap_ne ;test is out of sequence
test_num = test_num + 1
lda #test_num ;*** next tests' number
sta test_case
;check_ram ;uncomment to find altered RAM after each test
endm
if load_data_direct = 1
data
else
bss ;uninitialized segment, copy of data at end of code!
endif
; org zero_page
0000 = org 0 ;edited to provide binaries loading from 0
0000 : 00000000000000.. ds zero_page
if I_flag = 2
;masking for I bit in status
flag_I_on ds 1 ;or mask to load flags
flag_I_off ds 1 ;and mask to load flags
endif
000a : zpt ;5 bytes store/modify test area
;add/subtract operand generation and result/flag prediction
000a : 00 adfc ds 1 ;carry flag before op
000b : 00 ad1 ds 1 ;operand 1 - accumulator
000c : 00 ad2 ds 1 ;operand 2 - memory / immediate
000d : 00 adrl ds 1 ;expected result bits 0-7
000e : 00 adrh ds 1 ;expected result bit 8 (carry)
000f : 00 adrf ds 1 ;expected flags NV0000ZC (-V in decimal mode)
0010 : 00 sb2 ds 1 ;operand 2 complemented for subtract
0011 : zp_bss
0011 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
0015 : 7f zp7f db $7f ;test pattern for compare
;logical zeropage operands
0016 : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR
001a : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND
001e : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR
;indirect addressing pointers
0022 : 0a02 ind1 dw abs1 ;indirect pointer to pattern in absolute memory
0024 : 0b02 dw abs1+1
0026 : 0c02 dw abs1+2
0028 : 0d02 dw abs1+3
002a : 0e02 dw abs7f
002c : 1201 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern
002e : 0502 indt dw abst ;indirect pointer to store area in absolute memory
0030 : 0602 dw abst+1
0032 : 0702 dw abst+2
0034 : 0802 dw abst+3
0036 : 0d01 inwt dw abst-$f8 ;indirect pointer for wrap-test store
0038 : 4102 indAN dw absAN ;indirect pointer to AND pattern in absolute memory
003a : 4202 dw absAN+1
003c : 4302 dw absAN+2
003e : 4402 dw absAN+3
0040 : 4502 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory
0042 : 4602 dw absEO+1
0044 : 4702 dw absEO+2
0046 : 4802 dw absEO+3
0048 : 3d02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory
004a : 3e02 dw absOR+1
004c : 3f02 dw absOR+2
004e : 4002 dw absOR+3
;add/subtract indirect pointers
0050 : 0502 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory
0052 : 0602 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC)
0054 : 0601 adiy2 dw ada2-$ff ;with offset for indirect indexed
0056 : 0701 sbiy2 dw sba2-$ff
0058 : zp_bss_end
0200 = org data_segment
0200 : 0000 pg_x ds 2 ;high JMP indirect address for page cross bug
0202 : 00 test_case ds 1 ;current test number
0203 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test
;add/subtract operand copy - abs tests write area
0205 : abst ;5 bytes store/modify test area
0205 : 00 ada2 ds 1 ;operand 2
0206 : 00 sba2 ds 1 ;operand 2 complemented for subtract
0207 : 000000 ds 3 ;fill remaining bytes
020a : data_bss
020a : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
020e : 7f abs7f db $7f ;test pattern for compare
;loads
020f : 80800002 fLDx db fn,fn,0,fz ;expected flags for load
;shifts
0213 : rASL ;expected result ASL & ROL -carry
0213 : 86048200 rROL db $86,$04,$82,0 ; "
0217 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry
021b : rLSR ;expected result LSR & ROR -carry
021b : 61412000 rROR db $61,$41,$20,0 ; "
021f : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry
0223 : fASL ;expected flags for shifts
0223 : 81018002 fROL db fnc,fc,fn,fz ;no carry in
0227 : 81018000 fROLc db fnc,fc,fn,0 ;carry in
022b : fLSR
022b : 01000102 fROR db fc,0,fc,fz ;no carry in
022f : 81808180 fRORc db fnc,fn,fnc,fn ;carry in
;increments (decrements)
0233 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC
0238 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC
;logical memory operand
023d : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR
0241 : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND
0245 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR
;logical accu operand
0249 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR
024d : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND
0251 : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR
;logical results
0255 : 00ff7f80 absrlo db 0,$ff,$7f,$80
0259 : 02800080 absflo db fz,fn,0,fn
025d : data_bss_end
;define area for page crossing JMP (abs) & JMP (abs,x) test
02f9 = jxi_tab equ data_segment + $100 - 7 ;JMP (jxi_tab,x) x=6
02fd = ji_tab equ data_segment + $100 - 3 ;JMP (ji_tab+2)
0300 = jxp_tab equ data_segment + $100 ;JMP (jxp_tab-255) x=255
code
0400 = org code_segment
0400 : d8 start cld
0401 : a2ff ldx #$ff
0403 : 9a txs
0404 : a900 lda #0 ;*** test 0 = initialize
0406 : 8d0202 sta test_case
0000 = test_num = 0
;stop interrupts before initializing BSS
if I_flag = 1
sei
endif
;initialize I/O for report channel
if report = 1
jsr report_init
endif
;initialize BSS segment
if load_data_direct != 1
ldx #zp_end-zp_init-1
ld_zp lda zp_init,x
sta zp_bss,x
dex
bpl ld_zp
ldx #data_end-data_init-1
ld_data lda data_init,x
sta data_bss,x
dex
bpl ld_data
if ROM_vectors = 1
ldx #5
ld_vect lda vec_init,x
sta vec_bss,x
dex
bpl ld_vect
endif
endif
;retain status of interrupt flag
if I_flag = 2
php
pla
and #4 ;isolate flag
sta flag_I_on ;or mask
eor #lo(~4) ;reverse
sta flag_I_off ;and mask
endif
;generate checksum for RAM integrity test
if ram_top > -1
lda #0
sta zpt ;set low byte of indirect pointer
sta ram_chksm+1 ;checksum high byte
ldx #11 ;reset modifiable RAM
gcs1 sta jxi_tab,x ;JMP indirect page cross area
dex
bpl gcs1
sta chkdadi ;self modifying code
sta chkdsbi
clc
ldx #zp_bss-zero_page ;zeropage - write test area
gcs3 adc zero_page,x
bcc gcs2
inc ram_chksm+1 ;carry to high byte
clc
gcs2 inx
bne gcs3
ldx #hi(data_segment) ;set high byte of indirect pointer
stx zpt+1
ldy #lo(data_bss) ;data after write test area
gcs5 adc (zpt),y
bcc gcs4
inc ram_chksm+1 ;carry to high byte
clc
gcs4 iny
bne gcs5
inx ;advance RAM high address
stx zpt+1
cpx #ram_top
bne gcs5
sta ram_chksm ;checksum complete
endif
next_test
0409 : ad0202 > lda test_case ;previous test
040c : c900 > cmp #test_num
> trap_ne ;test is out of sequence
040e : d0fe > bne * ;failed not equal (non zero)
>
0001 = >test_num = test_num + 1
0410 : a901 > lda #test_num ;*** next tests' number
0412 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;testing stack operations PHX PHY PLX PLY
0415 : a999 lda #$99 ;protect a
0417 : a2ff ldx #$ff ;initialize stack
0419 : 9a txs
041a : a255 ldx #$55
041c : da phx
041d : a2aa ldx #$aa
041f : da phx
0420 : ecfe01 cpx $1fe ;on stack ?
trap_ne
0423 : d0fe > bne * ;failed not equal (non zero)
0425 : ba tsx
0426 : e0fd cpx #$fd ;sp decremented?
trap_ne
0428 : d0fe > bne * ;failed not equal (non zero)
042a : 7a ply
042b : c0aa cpy #$aa ;successful retreived from stack?
trap_ne
042d : d0fe > bne * ;failed not equal (non zero)
042f : 7a ply
0430 : c055 cpy #$55
trap_ne
0432 : d0fe > bne * ;failed not equal (non zero)
0434 : ccff01 cpy $1ff ;remains on stack?
trap_ne
0437 : d0fe > bne * ;failed not equal (non zero)
0439 : ba tsx
043a : e0ff cpx #$ff ;sp incremented?
trap_ne
043c : d0fe > bne * ;failed not equal (non zero)
043e : a0a5 ldy #$a5
0440 : 5a phy
0441 : a05a ldy #$5a
0443 : 5a phy
0444 : ccfe01 cpy $1fe ;on stack ?
trap_ne
0447 : d0fe > bne * ;failed not equal (non zero)
0449 : ba tsx
044a : e0fd cpx #$fd ;sp decremented?
trap_ne
044c : d0fe > bne * ;failed not equal (non zero)
044e : fa plx
044f : e05a cpx #$5a ;successful retreived from stack?
trap_ne
0451 : d0fe > bne * ;failed not equal (non zero)
0453 : fa plx
0454 : e0a5 cpx #$a5
trap_ne
0456 : d0fe > bne * ;failed not equal (non zero)
0458 : ecff01 cpx $1ff ;remains on stack?
trap_ne
045b : d0fe > bne * ;failed not equal (non zero)
045d : ba tsx
045e : e0ff cpx #$ff ;sp incremented?
trap_ne
0460 : d0fe > bne * ;failed not equal (non zero)
0462 : c999 cmp #$99 ;unchanged?
trap_ne
0464 : d0fe > bne * ;failed not equal (non zero)
next_test
0466 : ad0202 > lda test_case ;previous test
0469 : c901 > cmp #test_num
> trap_ne ;test is out of sequence
046b : d0fe > bne * ;failed not equal (non zero)
>
0002 = >test_num = test_num + 1
046d : a902 > lda #test_num ;*** next tests' number
046f : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; test PHX does not alter flags or X but PLX does
0472 : a0aa ldy #$aa ;protect y
set_x 1,$ff ;push
> load_flag $ff
0474 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0476 : 48 > pha ;use stack to load status
0477 : a201 > ldx #1 ;precharge index x
0479 : 28 > plp
047a : da phx
tst_x 1,$ff
047b : 08 > php ;save flags
047c : e001 > cpx #1 ;test result
> trap_ne
047e : d0fe > bne * ;failed not equal (non zero)
>
0480 : 68 > pla ;load status
0481 : 48 > pha
> cmp_flag $ff
0482 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0484 : d0fe > bne * ;failed not equal (non zero)
>
0486 : 28 > plp ;restore status
set_x 0,0
> load_flag 0
0487 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0489 : 48 > pha ;use stack to load status
048a : a200 > ldx #0 ;precharge index x
048c : 28 > plp
048d : da phx
tst_x 0,0
048e : 08 > php ;save flags
048f : e000 > cpx #0 ;test result
> trap_ne
0491 : d0fe > bne * ;failed not equal (non zero)
>
0493 : 68 > pla ;load status
0494 : 48 > pha
> cmp_flag 0
0495 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0497 : d0fe > bne * ;failed not equal (non zero)
>
0499 : 28 > plp ;restore status
set_x $ff,$ff
> load_flag $ff
049a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
049c : 48 > pha ;use stack to load status
049d : a2ff > ldx #$ff ;precharge index x
049f : 28 > plp
04a0 : da phx
tst_x $ff,$ff
04a1 : 08 > php ;save flags
04a2 : e0ff > cpx #$ff ;test result
> trap_ne
04a4 : d0fe > bne * ;failed not equal (non zero)
>
04a6 : 68 > pla ;load status
04a7 : 48 > pha
> cmp_flag $ff
04a8 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
04aa : d0fe > bne * ;failed not equal (non zero)
>
04ac : 28 > plp ;restore status
set_x 1,0
> load_flag 0
04ad : a900 > lda #0 ;allow test to change I-flag (no mask)
>
04af : 48 > pha ;use stack to load status
04b0 : a201 > ldx #1 ;precharge index x
04b2 : 28 > plp
04b3 : da phx
tst_x 1,0
04b4 : 08 > php ;save flags
04b5 : e001 > cpx #1 ;test result
> trap_ne
04b7 : d0fe > bne * ;failed not equal (non zero)
>
04b9 : 68 > pla ;load status
04ba : 48 > pha
> cmp_flag 0
04bb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
04bd : d0fe > bne * ;failed not equal (non zero)
>
04bf : 28 > plp ;restore status
set_x 0,$ff
> load_flag $ff
04c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
04c2 : 48 > pha ;use stack to load status
04c3 : a200 > ldx #0 ;precharge index x
04c5 : 28 > plp
04c6 : da phx
tst_x 0,$ff
04c7 : 08 > php ;save flags
04c8 : e000 > cpx #0 ;test result
> trap_ne
04ca : d0fe > bne * ;failed not equal (non zero)
>
04cc : 68 > pla ;load status
04cd : 48 > pha
> cmp_flag $ff
04ce : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
04d0 : d0fe > bne * ;failed not equal (non zero)
>
04d2 : 28 > plp ;restore status
set_x $ff,0
> load_flag 0
04d3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
04d5 : 48 > pha ;use stack to load status
04d6 : a2ff > ldx #$ff ;precharge index x
04d8 : 28 > plp
04d9 : da phx
tst_x $ff,0
04da : 08 > php ;save flags
04db : e0ff > cpx #$ff ;test result
> trap_ne
04dd : d0fe > bne * ;failed not equal (non zero)
>
04df : 68 > pla ;load status
04e0 : 48 > pha
> cmp_flag 0
04e1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
04e3 : d0fe > bne * ;failed not equal (non zero)
>
04e5 : 28 > plp ;restore status
set_x 0,$ff ;pull
> load_flag $ff
04e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
04e8 : 48 > pha ;use stack to load status
04e9 : a200 > ldx #0 ;precharge index x
04eb : 28 > plp
04ec : fa plx
tst_x $ff,$ff-zero
04ed : 08 > php ;save flags
04ee : e0ff > cpx #$ff ;test result
> trap_ne
04f0 : d0fe > bne * ;failed not equal (non zero)
>
04f2 : 68 > pla ;load status
04f3 : 48 > pha
> cmp_flag $ff-zero
04f4 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
04f6 : d0fe > bne * ;failed not equal (non zero)
>
04f8 : 28 > plp ;restore status
set_x $ff,0
> load_flag 0
04f9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
04fb : 48 > pha ;use stack to load status
04fc : a2ff > ldx #$ff ;precharge index x
04fe : 28 > plp
04ff : fa plx
tst_x 0,zero
0500 : 08 > php ;save flags
0501 : e000 > cpx #0 ;test result
> trap_ne
0503 : d0fe > bne * ;failed not equal (non zero)
>
0505 : 68 > pla ;load status
0506 : 48 > pha
> cmp_flag zero
0507 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0509 : d0fe > bne * ;failed not equal (non zero)
>
050b : 28 > plp ;restore status
set_x $fe,$ff
> load_flag $ff
050c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
050e : 48 > pha ;use stack to load status
050f : a2fe > ldx #$fe ;precharge index x
0511 : 28 > plp
0512 : fa plx
tst_x 1,$ff-zero-minus
0513 : 08 > php ;save flags
0514 : e001 > cpx #1 ;test result
> trap_ne
0516 : d0fe > bne * ;failed not equal (non zero)
>
0518 : 68 > pla ;load status
0519 : 48 > pha
> cmp_flag $ff-zero-minus
051a : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
051c : d0fe > bne * ;failed not equal (non zero)
>
051e : 28 > plp ;restore status
set_x 0,0
> load_flag 0
051f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0521 : 48 > pha ;use stack to load status
0522 : a200 > ldx #0 ;precharge index x
0524 : 28 > plp
0525 : fa plx
tst_x $ff,minus
0526 : 08 > php ;save flags
0527 : e0ff > cpx #$ff ;test result
> trap_ne
0529 : d0fe > bne * ;failed not equal (non zero)
>
052b : 68 > pla ;load status
052c : 48 > pha
> cmp_flag minus
052d : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
052f : d0fe > bne * ;failed not equal (non zero)
>
0531 : 28 > plp ;restore status
set_x $ff,$ff
> load_flag $ff
0532 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0534 : 48 > pha ;use stack to load status
0535 : a2ff > ldx #$ff ;precharge index x
0537 : 28 > plp
0538 : fa plx
tst_x 0,$ff-minus
0539 : 08 > php ;save flags
053a : e000 > cpx #0 ;test result
> trap_ne
053c : d0fe > bne * ;failed not equal (non zero)
>
053e : 68 > pla ;load status
053f : 48 > pha
> cmp_flag $ff-minus
0540 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0542 : d0fe > bne * ;failed not equal (non zero)
>
0544 : 28 > plp ;restore status
set_x $fe,0
> load_flag 0
0545 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0547 : 48 > pha ;use stack to load status
0548 : a2fe > ldx #$fe ;precharge index x
054a : 28 > plp
054b : fa plx
tst_x 1,0
054c : 08 > php ;save flags
054d : e001 > cpx #1 ;test result
> trap_ne
054f : d0fe > bne * ;failed not equal (non zero)
>
0551 : 68 > pla ;load status
0552 : 48 > pha
> cmp_flag 0
0553 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0555 : d0fe > bne * ;failed not equal (non zero)
>
0557 : 28 > plp ;restore status
0558 : c0aa cpy #$aa ;Y unchanged
trap_ne
055a : d0fe > bne * ;failed not equal (non zero)
next_test
055c : ad0202 > lda test_case ;previous test
055f : c902 > cmp #test_num
> trap_ne ;test is out of sequence
0561 : d0fe > bne * ;failed not equal (non zero)
>
0003 = >test_num = test_num + 1
0563 : a903 > lda #test_num ;*** next tests' number
0565 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; test PHY does not alter flags or Y but PLY does
0568 : a255 ldx #$55 ;x & a protected
set_y 1,$ff ;push
> load_flag $ff
056a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
056c : 48 > pha ;use stack to load status
056d : a001 > ldy #1 ;precharge index y
056f : 28 > plp
0570 : 5a phy
tst_y 1,$ff
0571 : 08 > php ;save flags
0572 : c001 > cpy #1 ;test result
> trap_ne
0574 : d0fe > bne * ;failed not equal (non zero)
>
0576 : 68 > pla ;load status
0577 : 48 > pha
> cmp_flag $ff
0578 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
057a : d0fe > bne * ;failed not equal (non zero)
>
057c : 28 > plp ;restore status
set_y 0,0
> load_flag 0
057d : a900 > lda #0 ;allow test to change I-flag (no mask)
>
057f : 48 > pha ;use stack to load status
0580 : a000 > ldy #0 ;precharge index y
0582 : 28 > plp
0583 : 5a phy
tst_y 0,0
0584 : 08 > php ;save flags
0585 : c000 > cpy #0 ;test result
> trap_ne
0587 : d0fe > bne * ;failed not equal (non zero)
>
0589 : 68 > pla ;load status
058a : 48 > pha
> cmp_flag 0
058b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
058d : d0fe > bne * ;failed not equal (non zero)
>
058f : 28 > plp ;restore status
set_y $ff,$ff
> load_flag $ff
0590 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0592 : 48 > pha ;use stack to load status
0593 : a0ff > ldy #$ff ;precharge index y
0595 : 28 > plp
0596 : 5a phy
tst_y $ff,$ff
0597 : 08 > php ;save flags
0598 : c0ff > cpy #$ff ;test result
> trap_ne
059a : d0fe > bne * ;failed not equal (non zero)
>
059c : 68 > pla ;load status
059d : 48 > pha
> cmp_flag $ff
059e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05a0 : d0fe > bne * ;failed not equal (non zero)
>
05a2 : 28 > plp ;restore status
set_y 1,0
> load_flag 0
05a3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
05a5 : 48 > pha ;use stack to load status
05a6 : a001 > ldy #1 ;precharge index y
05a8 : 28 > plp
05a9 : 5a phy
tst_y 1,0
05aa : 08 > php ;save flags
05ab : c001 > cpy #1 ;test result
> trap_ne
05ad : d0fe > bne * ;failed not equal (non zero)
>
05af : 68 > pla ;load status
05b0 : 48 > pha
> cmp_flag 0
05b1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05b3 : d0fe > bne * ;failed not equal (non zero)
>
05b5 : 28 > plp ;restore status
set_y 0,$ff
> load_flag $ff
05b6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
05b8 : 48 > pha ;use stack to load status
05b9 : a000 > ldy #0 ;precharge index y
05bb : 28 > plp
05bc : 5a phy
tst_y 0,$ff
05bd : 08 > php ;save flags
05be : c000 > cpy #0 ;test result
> trap_ne
05c0 : d0fe > bne * ;failed not equal (non zero)
>
05c2 : 68 > pla ;load status
05c3 : 48 > pha
> cmp_flag $ff
05c4 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05c6 : d0fe > bne * ;failed not equal (non zero)
>
05c8 : 28 > plp ;restore status
set_y $ff,0
> load_flag 0
05c9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
05cb : 48 > pha ;use stack to load status
05cc : a0ff > ldy #$ff ;precharge index y
05ce : 28 > plp
05cf : 5a phy
tst_y $ff,0
05d0 : 08 > php ;save flags
05d1 : c0ff > cpy #$ff ;test result
> trap_ne
05d3 : d0fe > bne * ;failed not equal (non zero)
>
05d5 : 68 > pla ;load status
05d6 : 48 > pha
> cmp_flag 0
05d7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05d9 : d0fe > bne * ;failed not equal (non zero)
>
05db : 28 > plp ;restore status
set_y 0,$ff ;pull
> load_flag $ff
05dc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
05de : 48 > pha ;use stack to load status
05df : a000 > ldy #0 ;precharge index y
05e1 : 28 > plp
05e2 : 7a ply
tst_y $ff,$ff-zero
05e3 : 08 > php ;save flags
05e4 : c0ff > cpy #$ff ;test result
> trap_ne
05e6 : d0fe > bne * ;failed not equal (non zero)
>
05e8 : 68 > pla ;load status
05e9 : 48 > pha
> cmp_flag $ff-zero
05ea : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05ec : d0fe > bne * ;failed not equal (non zero)
>
05ee : 28 > plp ;restore status
set_y $ff,0
> load_flag 0
05ef : a900 > lda #0 ;allow test to change I-flag (no mask)
>
05f1 : 48 > pha ;use stack to load status
05f2 : a0ff > ldy #$ff ;precharge index y
05f4 : 28 > plp
05f5 : 7a ply
tst_y 0,zero
05f6 : 08 > php ;save flags
05f7 : c000 > cpy #0 ;test result
> trap_ne
05f9 : d0fe > bne * ;failed not equal (non zero)
>
05fb : 68 > pla ;load status
05fc : 48 > pha
> cmp_flag zero
05fd : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
05ff : d0fe > bne * ;failed not equal (non zero)
>
0601 : 28 > plp ;restore status
set_y $fe,$ff
> load_flag $ff
0602 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0604 : 48 > pha ;use stack to load status
0605 : a0fe > ldy #$fe ;precharge index y
0607 : 28 > plp
0608 : 7a ply
tst_y 1,$ff-zero-minus
0609 : 08 > php ;save flags
060a : c001 > cpy #1 ;test result
> trap_ne
060c : d0fe > bne * ;failed not equal (non zero)
>
060e : 68 > pla ;load status
060f : 48 > pha
> cmp_flag $ff-zero-minus
0610 : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0612 : d0fe > bne * ;failed not equal (non zero)
>
0614 : 28 > plp ;restore status
set_y 0,0
> load_flag 0
0615 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0617 : 48 > pha ;use stack to load status
0618 : a000 > ldy #0 ;precharge index y
061a : 28 > plp
061b : 7a ply
tst_y $ff,minus
061c : 08 > php ;save flags
061d : c0ff > cpy #$ff ;test result
> trap_ne
061f : d0fe > bne * ;failed not equal (non zero)
>
0621 : 68 > pla ;load status
0622 : 48 > pha
> cmp_flag minus
0623 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0625 : d0fe > bne * ;failed not equal (non zero)
>
0627 : 28 > plp ;restore status
set_y $ff,$ff
> load_flag $ff
0628 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
062a : 48 > pha ;use stack to load status
062b : a0ff > ldy #$ff ;precharge index y
062d : 28 > plp
062e : 7a ply
tst_y 0,$ff-minus
062f : 08 > php ;save flags
0630 : c000 > cpy #0 ;test result
> trap_ne
0632 : d0fe > bne * ;failed not equal (non zero)
>
0634 : 68 > pla ;load status
0635 : 48 > pha
> cmp_flag $ff-minus
0636 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0638 : d0fe > bne * ;failed not equal (non zero)
>
063a : 28 > plp ;restore status
set_y $fe,0
> load_flag 0
063b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
063d : 48 > pha ;use stack to load status
063e : a0fe > ldy #$fe ;precharge index y
0640 : 28 > plp
0641 : 7a ply
tst_y 1,0
0642 : 08 > php ;save flags
0643 : c001 > cpy #1 ;test result
> trap_ne
0645 : d0fe > bne * ;failed not equal (non zero)
>
0647 : 68 > pla ;load status
0648 : 48 > pha
> cmp_flag 0
0649 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
064b : d0fe > bne * ;failed not equal (non zero)
>
064d : 28 > plp ;restore status
064e : e055 cpx #$55 ;x unchanged?
trap_ne
0650 : d0fe > bne * ;failed not equal (non zero)
next_test
0652 : ad0202 > lda test_case ;previous test
0655 : c903 > cmp #test_num
> trap_ne ;test is out of sequence
0657 : d0fe > bne * ;failed not equal (non zero)
>
0004 = >test_num = test_num + 1
0659 : a904 > lda #test_num ;*** next tests' number
065b : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; PC modifying instructions (BRA, BBR, BBS, 1, 2, 3 byte NOPs, JMP(abs,x))
; testing unconditional branch BRA
065e : a281 ldx #$81 ;protect unused registers
0660 : a07e ldy #$7e
set_a 0,$ff
> load_flag $ff
0662 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0664 : 48 > pha ;use stack to load status
0665 : a900 > lda #0 ;precharge accu
0667 : 28 > plp
0668 : 8003 bra br1 ;branch should always be taken
trap
066a : 4c6a06 > jmp * ;failed anyway
066d : br1
tst_a 0,$ff
066d : 08 > php ;save flags
066e : c900 > cmp #0 ;test result
> trap_ne
0670 : d0fe > bne * ;failed not equal (non zero)
>
0672 : 68 > pla ;load status
0673 : 48 > pha
> cmp_flag $ff
0674 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0676 : d0fe > bne * ;failed not equal (non zero)
>
0678 : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
0679 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
067b : 48 > pha ;use stack to load status
067c : a9ff > lda #$ff ;precharge accu
067e : 28 > plp
067f : 8003 bra br2 ;branch should always be taken
trap
0681 : 4c8106 > jmp * ;failed anyway
0684 : br2
tst_a $ff,0
0684 : 08 > php ;save flags
0685 : c9ff > cmp #$ff ;test result
> trap_ne
0687 : d0fe > bne * ;failed not equal (non zero)
>
0689 : 68 > pla ;load status
068a : 48 > pha
> cmp_flag 0
068b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
068d : d0fe > bne * ;failed not equal (non zero)
>
068f : 28 > plp ;restore status
0690 : e081 cpx #$81
trap_ne
0692 : d0fe > bne * ;failed not equal (non zero)
0694 : c07e cpy #$7e
trap_ne
0696 : d0fe > bne * ;failed not equal (non zero)
next_test
0698 : ad0202 > lda test_case ;previous test
069b : c904 > cmp #test_num
> trap_ne ;test is out of sequence
069d : d0fe > bne * ;failed not equal (non zero)
>
0005 = >test_num = test_num + 1
069f : a905 > lda #test_num ;*** next tests' number
06a1 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
06a4 : a000 ldy #0 ;branch range test
06a6 : 8061 bra bra0
06a8 : c001 bra1 cpy #1
trap_ne ;long range backward
06aa : d0fe > bne * ;failed not equal (non zero)
06ac : c8 iny
06ad : 8053 bra bra2
06af : c003 bra3 cpy #3
trap_ne ;long range backward
06b1 : d0fe > bne * ;failed not equal (non zero)
06b3 : c8 iny
06b4 : 8045 bra bra4
06b6 : c005 bra5 cpy #5
trap_ne ;long range backward
06b8 : d0fe > bne * ;failed not equal (non zero)
06ba : c8 iny
06bb : a000 ldy #0
06bd : 8004 bra brf0
06bf : c8 iny
06c0 : c8 iny
06c1 : c8 iny
06c2 : c8 iny
06c3 : 8003 brf0 bra brf1
06c5 : c8 iny
06c6 : c8 iny
06c7 : c8 iny
06c8 : c8 brf1 iny
06c9 : 8002 bra brf2
06cb : c8 iny
06cc : c8 iny
06cd : c8 brf2 iny
06ce : c8 iny
06cf : 8001 bra brf3
06d1 : c8 iny
06d2 : c8 brf3 iny
06d3 : c8 iny
06d4 : c8 iny
06d5 : 8000 bra brf4
06d7 : c8 brf4 iny
06d8 : c8 iny
06d9 : c8 iny
06da : c8 iny
06db : c00a cpy #10
trap_ne ;short range forward
06dd : d0fe > bne * ;failed not equal (non zero)
06df : 8012 bra brb0
06e1 : 88 brb4 dey
06e2 : 88 dey
06e3 : 88 dey
06e4 : 88 dey
06e5 : 800e bra brb5
06e7 : 88 brb3 dey
06e8 : 88 dey
06e9 : 88 dey
06ea : 80f5 bra brb4
06ec : 88 brb2 dey
06ed : 88 dey
06ee : 80f7 bra brb3
06f0 : 88 brb1 dey
06f1 : 80f9 bra brb2
06f3 : 80fb brb0 bra brb1
06f5 : c000 brb5 cpy #0
trap_ne ;short range backward
06f7 : d0fe > bne * ;failed not equal (non zero)
06f9 : 8015 bra bra6
06fb : c004 bra4 cpy #4
trap_ne ;long range forward
06fd : d0fe > bne * ;failed not equal (non zero)
06ff : c8 iny
0700 : 80b4 bra bra5
0702 : c002 bra2 cpy #2
trap_ne ;long range forward
0704 : d0fe > bne * ;failed not equal (non zero)
0706 : c8 iny
0707 : 80a6 bra bra3
0709 : c000 bra0 cpy #0
trap_ne ;long range forward
070b : d0fe > bne * ;failed not equal (non zero)
070d : c8 iny
070e : 8098 bra bra1
0710 : bra6
next_test
0710 : ad0202 > lda test_case ;previous test
0713 : c905 > cmp #test_num
> trap_ne ;test is out of sequence
0715 : d0fe > bne * ;failed not equal (non zero)
>
0006 = >test_num = test_num + 1
0717 : a906 > lda #test_num ;*** next tests' number
0719 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
if rkwl_wdc_op = 1
; testing BBR & BBS
bbt macro ;\1 = bitnum
lda #(1<<\1) ;testing 1 bit on
sta zpt
set_a $33,0 ;with flags off
bbr \1,zpt,fail1\?
bbs \1,zpt,ok1\?
trap ;bbs branch not taken
fail1\?
trap ;bbr branch taken
ok1\?
tst_a $33,0
set_a $cc,$ff ;with flags on
bbr \1,zpt,fail2\?
bbs \1,zpt,ok2\?
trap ;bbs branch not taken
fail2\?
trap ;bbr branch taken
ok2\?
tst_a $cc,$ff
lda zpt
cmp #(1<<\1)
trap_ne ;zp altered
lda #$ff-(1<<\1) ;testing 1 bit off
sta zpt
set_a $33,0 ;with flags off
bbs \1,zpt,fail3\?
bbr \1,zpt,ok3\?
trap ;bbr branch not taken
fail3\?
trap ;bbs branch taken
ok3\?
tst_a $33,0
set_a $cc,$ff ;with flags on
bbs \1,zpt,fail4\?
bbr \1,zpt,ok4\?
trap ;bbr branch not taken
fail4\?
trap ;bbs branch taken
ok4\?
tst_a $cc,$ff
lda zpt
cmp #$ff-(1<<\1)
trap_ne ;zp altered
endm
071c : a211 ldx #$11 ;test bbr/bbs integrity
071e : a022 ldy #$22
bbt 0
0720 : a901 > lda #(1<<0) ;testing 1 bit on
0722 : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0724 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0726 : 48 > pha ;use stack to load status
0727 : a933 > lda #$33 ;precharge accu
0729 : 28 > plp
>
072a : 0f0a06 > bbr 0,zpt,fail10196
072d : 8f0a06 > bbs 0,zpt,ok10196
> trap ;bbs branch not taken
0730 : 4c3007 > jmp * ;failed anyway
>
0733 : >fail10196
> trap ;bbr branch taken
0733 : 4c3307 > jmp * ;failed anyway
>
0736 : >ok10196
> tst_a $33,0
0736 : 08 > php ;save flags
0737 : c933 > cmp #$33 ;test result
> trap_ne
0739 : d0fe > bne * ;failed not equal (non zero)
>
073b : 68 > pla ;load status
073c : 48 > pha
> cmp_flag 0
073d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
073f : d0fe > bne * ;failed not equal (non zero)
>
0741 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0742 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0744 : 48 > pha ;use stack to load status
0745 : a9cc > lda #$cc ;precharge accu
0747 : 28 > plp
>
0748 : 0f0a06 > bbr 0,zpt,fail20196
074b : 8f0a06 > bbs 0,zpt,ok20196
> trap ;bbs branch not taken
074e : 4c4e07 > jmp * ;failed anyway
>
0751 : >fail20196
> trap ;bbr branch taken
0751 : 4c5107 > jmp * ;failed anyway
>
0754 : >ok20196
> tst_a $cc,$ff
0754 : 08 > php ;save flags
0755 : c9cc > cmp #$cc ;test result
> trap_ne
0757 : d0fe > bne * ;failed not equal (non zero)
>
0759 : 68 > pla ;load status
075a : 48 > pha
> cmp_flag $ff
075b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
075d : d0fe > bne * ;failed not equal (non zero)
>
075f : 28 > plp ;restore status
>
0760 : a50a > lda zpt
0762 : c901 > cmp #(1<<0)
> trap_ne ;zp altered
0764 : d0fe > bne * ;failed not equal (non zero)
>
0766 : a9fe > lda #$ff-(1<<0) ;testing 1 bit off
0768 : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
076a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
076c : 48 > pha ;use stack to load status
076d : a933 > lda #$33 ;precharge accu
076f : 28 > plp
>
0770 : 8f0a06 > bbs 0,zpt,fail30196
0773 : 0f0a06 > bbr 0,zpt,ok30196
> trap ;bbr branch not taken
0776 : 4c7607 > jmp * ;failed anyway
>
0779 : >fail30196
> trap ;bbs branch taken
0779 : 4c7907 > jmp * ;failed anyway
>
077c : >ok30196
> tst_a $33,0
077c : 08 > php ;save flags
077d : c933 > cmp #$33 ;test result
> trap_ne
077f : d0fe > bne * ;failed not equal (non zero)
>
0781 : 68 > pla ;load status
0782 : 48 > pha
> cmp_flag 0
0783 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0785 : d0fe > bne * ;failed not equal (non zero)
>
0787 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0788 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
078a : 48 > pha ;use stack to load status
078b : a9cc > lda #$cc ;precharge accu
078d : 28 > plp
>
078e : 8f0a06 > bbs 0,zpt,fail40196
0791 : 0f0a06 > bbr 0,zpt,ok40196
> trap ;bbr branch not taken
0794 : 4c9407 > jmp * ;failed anyway
>
0797 : >fail40196
> trap ;bbs branch taken
0797 : 4c9707 > jmp * ;failed anyway
>
079a : >ok40196
> tst_a $cc,$ff
079a : 08 > php ;save flags
079b : c9cc > cmp #$cc ;test result
> trap_ne
079d : d0fe > bne * ;failed not equal (non zero)
>
079f : 68 > pla ;load status
07a0 : 48 > pha
> cmp_flag $ff
07a1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07a3 : d0fe > bne * ;failed not equal (non zero)
>
07a5 : 28 > plp ;restore status
>
07a6 : a50a > lda zpt
07a8 : c9fe > cmp #$ff-(1<<0)
> trap_ne ;zp altered
07aa : d0fe > bne * ;failed not equal (non zero)
>
bbt 1
07ac : a902 > lda #(1<<1) ;testing 1 bit on
07ae : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
07b0 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
07b2 : 48 > pha ;use stack to load status
07b3 : a933 > lda #$33 ;precharge accu
07b5 : 28 > plp
>
07b6 : 1f0a06 > bbr 1,zpt,fail10231
07b9 : 9f0a06 > bbs 1,zpt,ok10231
> trap ;bbs branch not taken
07bc : 4cbc07 > jmp * ;failed anyway
>
07bf : >fail10231
> trap ;bbr branch taken
07bf : 4cbf07 > jmp * ;failed anyway
>
07c2 : >ok10231
> tst_a $33,0
07c2 : 08 > php ;save flags
07c3 : c933 > cmp #$33 ;test result
> trap_ne
07c5 : d0fe > bne * ;failed not equal (non zero)
>
07c7 : 68 > pla ;load status
07c8 : 48 > pha
> cmp_flag 0
07c9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07cb : d0fe > bne * ;failed not equal (non zero)
>
07cd : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
07ce : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
07d0 : 48 > pha ;use stack to load status
07d1 : a9cc > lda #$cc ;precharge accu
07d3 : 28 > plp
>
07d4 : 1f0a06 > bbr 1,zpt,fail20231
07d7 : 9f0a06 > bbs 1,zpt,ok20231
> trap ;bbs branch not taken
07da : 4cda07 > jmp * ;failed anyway
>
07dd : >fail20231
> trap ;bbr branch taken
07dd : 4cdd07 > jmp * ;failed anyway
>
07e0 : >ok20231
> tst_a $cc,$ff
07e0 : 08 > php ;save flags
07e1 : c9cc > cmp #$cc ;test result
> trap_ne
07e3 : d0fe > bne * ;failed not equal (non zero)
>
07e5 : 68 > pla ;load status
07e6 : 48 > pha
> cmp_flag $ff
07e7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07e9 : d0fe > bne * ;failed not equal (non zero)
>
07eb : 28 > plp ;restore status
>
07ec : a50a > lda zpt
07ee : c902 > cmp #(1<<1)
> trap_ne ;zp altered
07f0 : d0fe > bne * ;failed not equal (non zero)
>
07f2 : a9fd > lda #$ff-(1<<1) ;testing 1 bit off
07f4 : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
07f6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
07f8 : 48 > pha ;use stack to load status
07f9 : a933 > lda #$33 ;precharge accu
07fb : 28 > plp
>
07fc : 9f0a06 > bbs 1,zpt,fail30231
07ff : 1f0a06 > bbr 1,zpt,ok30231
> trap ;bbr branch not taken
0802 : 4c0208 > jmp * ;failed anyway
>
0805 : >fail30231
> trap ;bbs branch taken
0805 : 4c0508 > jmp * ;failed anyway
>
0808 : >ok30231
> tst_a $33,0
0808 : 08 > php ;save flags
0809 : c933 > cmp #$33 ;test result
> trap_ne
080b : d0fe > bne * ;failed not equal (non zero)
>
080d : 68 > pla ;load status
080e : 48 > pha
> cmp_flag 0
080f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0811 : d0fe > bne * ;failed not equal (non zero)
>
0813 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0814 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0816 : 48 > pha ;use stack to load status
0817 : a9cc > lda #$cc ;precharge accu
0819 : 28 > plp
>
081a : 9f0a06 > bbs 1,zpt,fail40231
081d : 1f0a06 > bbr 1,zpt,ok40231
> trap ;bbr branch not taken
0820 : 4c2008 > jmp * ;failed anyway
>
0823 : >fail40231
> trap ;bbs branch taken
0823 : 4c2308 > jmp * ;failed anyway
>
0826 : >ok40231
> tst_a $cc,$ff
0826 : 08 > php ;save flags
0827 : c9cc > cmp #$cc ;test result
> trap_ne
0829 : d0fe > bne * ;failed not equal (non zero)
>
082b : 68 > pla ;load status
082c : 48 > pha
> cmp_flag $ff
082d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
082f : d0fe > bne * ;failed not equal (non zero)
>
0831 : 28 > plp ;restore status
>
0832 : a50a > lda zpt
0834 : c9fd > cmp #$ff-(1<<1)
> trap_ne ;zp altered
0836 : d0fe > bne * ;failed not equal (non zero)
>
bbt 2
0838 : a904 > lda #(1<<2) ;testing 1 bit on
083a : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
083c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
083e : 48 > pha ;use stack to load status
083f : a933 > lda #$33 ;precharge accu
0841 : 28 > plp
>
0842 : 2f0a06 > bbr 2,zpt,fail10266
0845 : af0a06 > bbs 2,zpt,ok10266
> trap ;bbs branch not taken
0848 : 4c4808 > jmp * ;failed anyway
>
084b : >fail10266
> trap ;bbr branch taken
084b : 4c4b08 > jmp * ;failed anyway
>
084e : >ok10266
> tst_a $33,0
084e : 08 > php ;save flags
084f : c933 > cmp #$33 ;test result
> trap_ne
0851 : d0fe > bne * ;failed not equal (non zero)
>
0853 : 68 > pla ;load status
0854 : 48 > pha
> cmp_flag 0
0855 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0857 : d0fe > bne * ;failed not equal (non zero)
>
0859 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
085a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
085c : 48 > pha ;use stack to load status
085d : a9cc > lda #$cc ;precharge accu
085f : 28 > plp
>
0860 : 2f0a06 > bbr 2,zpt,fail20266
0863 : af0a06 > bbs 2,zpt,ok20266
> trap ;bbs branch not taken
0866 : 4c6608 > jmp * ;failed anyway
>
0869 : >fail20266
> trap ;bbr branch taken
0869 : 4c6908 > jmp * ;failed anyway
>
086c : >ok20266
> tst_a $cc,$ff
086c : 08 > php ;save flags
086d : c9cc > cmp #$cc ;test result
> trap_ne
086f : d0fe > bne * ;failed not equal (non zero)
>
0871 : 68 > pla ;load status
0872 : 48 > pha
> cmp_flag $ff
0873 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0875 : d0fe > bne * ;failed not equal (non zero)
>
0877 : 28 > plp ;restore status
>
0878 : a50a > lda zpt
087a : c904 > cmp #(1<<2)
> trap_ne ;zp altered
087c : d0fe > bne * ;failed not equal (non zero)
>
087e : a9fb > lda #$ff-(1<<2) ;testing 1 bit off
0880 : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0882 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0884 : 48 > pha ;use stack to load status
0885 : a933 > lda #$33 ;precharge accu
0887 : 28 > plp
>
0888 : af0a06 > bbs 2,zpt,fail30266
088b : 2f0a06 > bbr 2,zpt,ok30266
> trap ;bbr branch not taken
088e : 4c8e08 > jmp * ;failed anyway
>
0891 : >fail30266
> trap ;bbs branch taken
0891 : 4c9108 > jmp * ;failed anyway
>
0894 : >ok30266
> tst_a $33,0
0894 : 08 > php ;save flags
0895 : c933 > cmp #$33 ;test result
> trap_ne
0897 : d0fe > bne * ;failed not equal (non zero)
>
0899 : 68 > pla ;load status
089a : 48 > pha
> cmp_flag 0
089b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
089d : d0fe > bne * ;failed not equal (non zero)
>
089f : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
08a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
08a2 : 48 > pha ;use stack to load status
08a3 : a9cc > lda #$cc ;precharge accu
08a5 : 28 > plp
>
08a6 : af0a06 > bbs 2,zpt,fail40266
08a9 : 2f0a06 > bbr 2,zpt,ok40266
> trap ;bbr branch not taken
08ac : 4cac08 > jmp * ;failed anyway
>
08af : >fail40266
> trap ;bbs branch taken
08af : 4caf08 > jmp * ;failed anyway
>
08b2 : >ok40266
> tst_a $cc,$ff
08b2 : 08 > php ;save flags
08b3 : c9cc > cmp #$cc ;test result
> trap_ne
08b5 : d0fe > bne * ;failed not equal (non zero)
>
08b7 : 68 > pla ;load status
08b8 : 48 > pha
> cmp_flag $ff
08b9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
08bb : d0fe > bne * ;failed not equal (non zero)
>
08bd : 28 > plp ;restore status
>
08be : a50a > lda zpt
08c0 : c9fb > cmp #$ff-(1<<2)
> trap_ne ;zp altered
08c2 : d0fe > bne * ;failed not equal (non zero)
>
bbt 3
08c4 : a908 > lda #(1<<3) ;testing 1 bit on
08c6 : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
08c8 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
08ca : 48 > pha ;use stack to load status
08cb : a933 > lda #$33 ;precharge accu
08cd : 28 > plp
>
08ce : 3f0a06 > bbr 3,zpt,fail10301
08d1 : bf0a06 > bbs 3,zpt,ok10301
> trap ;bbs branch not taken
08d4 : 4cd408 > jmp * ;failed anyway
>
08d7 : >fail10301
> trap ;bbr branch taken
08d7 : 4cd708 > jmp * ;failed anyway
>
08da : >ok10301
> tst_a $33,0
08da : 08 > php ;save flags
08db : c933 > cmp #$33 ;test result
> trap_ne
08dd : d0fe > bne * ;failed not equal (non zero)
>
08df : 68 > pla ;load status
08e0 : 48 > pha
> cmp_flag 0
08e1 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
08e3 : d0fe > bne * ;failed not equal (non zero)
>
08e5 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
08e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
08e8 : 48 > pha ;use stack to load status
08e9 : a9cc > lda #$cc ;precharge accu
08eb : 28 > plp
>
08ec : 3f0a06 > bbr 3,zpt,fail20301
08ef : bf0a06 > bbs 3,zpt,ok20301
> trap ;bbs branch not taken
08f2 : 4cf208 > jmp * ;failed anyway
>
08f5 : >fail20301
> trap ;bbr branch taken
08f5 : 4cf508 > jmp * ;failed anyway
>
08f8 : >ok20301
> tst_a $cc,$ff
08f8 : 08 > php ;save flags
08f9 : c9cc > cmp #$cc ;test result
> trap_ne
08fb : d0fe > bne * ;failed not equal (non zero)
>
08fd : 68 > pla ;load status
08fe : 48 > pha
> cmp_flag $ff
08ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0901 : d0fe > bne * ;failed not equal (non zero)
>
0903 : 28 > plp ;restore status
>
0904 : a50a > lda zpt
0906 : c908 > cmp #(1<<3)
> trap_ne ;zp altered
0908 : d0fe > bne * ;failed not equal (non zero)
>
090a : a9f7 > lda #$ff-(1<<3) ;testing 1 bit off
090c : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
090e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0910 : 48 > pha ;use stack to load status
0911 : a933 > lda #$33 ;precharge accu
0913 : 28 > plp
>
0914 : bf0a06 > bbs 3,zpt,fail30301
0917 : 3f0a06 > bbr 3,zpt,ok30301
> trap ;bbr branch not taken
091a : 4c1a09 > jmp * ;failed anyway
>
091d : >fail30301
> trap ;bbs branch taken
091d : 4c1d09 > jmp * ;failed anyway
>
0920 : >ok30301
> tst_a $33,0
0920 : 08 > php ;save flags
0921 : c933 > cmp #$33 ;test result
> trap_ne
0923 : d0fe > bne * ;failed not equal (non zero)
>
0925 : 68 > pla ;load status
0926 : 48 > pha
> cmp_flag 0
0927 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0929 : d0fe > bne * ;failed not equal (non zero)
>
092b : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
092c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
092e : 48 > pha ;use stack to load status
092f : a9cc > lda #$cc ;precharge accu
0931 : 28 > plp
>
0932 : bf0a06 > bbs 3,zpt,fail40301
0935 : 3f0a06 > bbr 3,zpt,ok40301
> trap ;bbr branch not taken
0938 : 4c3809 > jmp * ;failed anyway
>
093b : >fail40301
> trap ;bbs branch taken
093b : 4c3b09 > jmp * ;failed anyway
>
093e : >ok40301
> tst_a $cc,$ff
093e : 08 > php ;save flags
093f : c9cc > cmp #$cc ;test result
> trap_ne
0941 : d0fe > bne * ;failed not equal (non zero)
>
0943 : 68 > pla ;load status
0944 : 48 > pha
> cmp_flag $ff
0945 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0947 : d0fe > bne * ;failed not equal (non zero)
>
0949 : 28 > plp ;restore status
>
094a : a50a > lda zpt
094c : c9f7 > cmp #$ff-(1<<3)
> trap_ne ;zp altered
094e : d0fe > bne * ;failed not equal (non zero)
>
bbt 4
0950 : a910 > lda #(1<<4) ;testing 1 bit on
0952 : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0954 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0956 : 48 > pha ;use stack to load status
0957 : a933 > lda #$33 ;precharge accu
0959 : 28 > plp
>
095a : 4f0a06 > bbr 4,zpt,fail10336
095d : cf0a06 > bbs 4,zpt,ok10336
> trap ;bbs branch not taken
0960 : 4c6009 > jmp * ;failed anyway
>
0963 : >fail10336
> trap ;bbr branch taken
0963 : 4c6309 > jmp * ;failed anyway
>
0966 : >ok10336
> tst_a $33,0
0966 : 08 > php ;save flags
0967 : c933 > cmp #$33 ;test result
> trap_ne
0969 : d0fe > bne * ;failed not equal (non zero)
>
096b : 68 > pla ;load status
096c : 48 > pha
> cmp_flag 0
096d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
096f : d0fe > bne * ;failed not equal (non zero)
>
0971 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0972 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0974 : 48 > pha ;use stack to load status
0975 : a9cc > lda #$cc ;precharge accu
0977 : 28 > plp
>
0978 : 4f0a06 > bbr 4,zpt,fail20336
097b : cf0a06 > bbs 4,zpt,ok20336
> trap ;bbs branch not taken
097e : 4c7e09 > jmp * ;failed anyway
>
0981 : >fail20336
> trap ;bbr branch taken
0981 : 4c8109 > jmp * ;failed anyway
>
0984 : >ok20336
> tst_a $cc,$ff
0984 : 08 > php ;save flags
0985 : c9cc > cmp #$cc ;test result
> trap_ne
0987 : d0fe > bne * ;failed not equal (non zero)
>
0989 : 68 > pla ;load status
098a : 48 > pha
> cmp_flag $ff
098b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
098d : d0fe > bne * ;failed not equal (non zero)
>
098f : 28 > plp ;restore status
>
0990 : a50a > lda zpt
0992 : c910 > cmp #(1<<4)
> trap_ne ;zp altered
0994 : d0fe > bne * ;failed not equal (non zero)
>
0996 : a9ef > lda #$ff-(1<<4) ;testing 1 bit off
0998 : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
099a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
099c : 48 > pha ;use stack to load status
099d : a933 > lda #$33 ;precharge accu
099f : 28 > plp
>
09a0 : cf0a06 > bbs 4,zpt,fail30336
09a3 : 4f0a06 > bbr 4,zpt,ok30336
> trap ;bbr branch not taken
09a6 : 4ca609 > jmp * ;failed anyway
>
09a9 : >fail30336
> trap ;bbs branch taken
09a9 : 4ca909 > jmp * ;failed anyway
>
09ac : >ok30336
> tst_a $33,0
09ac : 08 > php ;save flags
09ad : c933 > cmp #$33 ;test result
> trap_ne
09af : d0fe > bne * ;failed not equal (non zero)
>
09b1 : 68 > pla ;load status
09b2 : 48 > pha
> cmp_flag 0
09b3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09b5 : d0fe > bne * ;failed not equal (non zero)
>
09b7 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
09b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
09ba : 48 > pha ;use stack to load status
09bb : a9cc > lda #$cc ;precharge accu
09bd : 28 > plp
>
09be : cf0a06 > bbs 4,zpt,fail40336
09c1 : 4f0a06 > bbr 4,zpt,ok40336
> trap ;bbr branch not taken
09c4 : 4cc409 > jmp * ;failed anyway
>
09c7 : >fail40336
> trap ;bbs branch taken
09c7 : 4cc709 > jmp * ;failed anyway
>
09ca : >ok40336
> tst_a $cc,$ff
09ca : 08 > php ;save flags
09cb : c9cc > cmp #$cc ;test result
> trap_ne
09cd : d0fe > bne * ;failed not equal (non zero)
>
09cf : 68 > pla ;load status
09d0 : 48 > pha
> cmp_flag $ff
09d1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09d3 : d0fe > bne * ;failed not equal (non zero)
>
09d5 : 28 > plp ;restore status
>
09d6 : a50a > lda zpt
09d8 : c9ef > cmp #$ff-(1<<4)
> trap_ne ;zp altered
09da : d0fe > bne * ;failed not equal (non zero)
>
bbt 5
09dc : a920 > lda #(1<<5) ;testing 1 bit on
09de : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
09e0 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
09e2 : 48 > pha ;use stack to load status
09e3 : a933 > lda #$33 ;precharge accu
09e5 : 28 > plp
>
09e6 : 5f0a06 > bbr 5,zpt,fail10371
09e9 : df0a06 > bbs 5,zpt,ok10371
> trap ;bbs branch not taken
09ec : 4cec09 > jmp * ;failed anyway
>
09ef : >fail10371
> trap ;bbr branch taken
09ef : 4cef09 > jmp * ;failed anyway
>
09f2 : >ok10371
> tst_a $33,0
09f2 : 08 > php ;save flags
09f3 : c933 > cmp #$33 ;test result
> trap_ne
09f5 : d0fe > bne * ;failed not equal (non zero)
>
09f7 : 68 > pla ;load status
09f8 : 48 > pha
> cmp_flag 0
09f9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09fb : d0fe > bne * ;failed not equal (non zero)
>
09fd : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
09fe : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0a00 : 48 > pha ;use stack to load status
0a01 : a9cc > lda #$cc ;precharge accu
0a03 : 28 > plp
>
0a04 : 5f0a06 > bbr 5,zpt,fail20371
0a07 : df0a06 > bbs 5,zpt,ok20371
> trap ;bbs branch not taken
0a0a : 4c0a0a > jmp * ;failed anyway
>
0a0d : >fail20371
> trap ;bbr branch taken
0a0d : 4c0d0a > jmp * ;failed anyway
>
0a10 : >ok20371
> tst_a $cc,$ff
0a10 : 08 > php ;save flags
0a11 : c9cc > cmp #$cc ;test result
> trap_ne
0a13 : d0fe > bne * ;failed not equal (non zero)
>
0a15 : 68 > pla ;load status
0a16 : 48 > pha
> cmp_flag $ff
0a17 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a19 : d0fe > bne * ;failed not equal (non zero)
>
0a1b : 28 > plp ;restore status
>
0a1c : a50a > lda zpt
0a1e : c920 > cmp #(1<<5)
> trap_ne ;zp altered
0a20 : d0fe > bne * ;failed not equal (non zero)
>
0a22 : a9df > lda #$ff-(1<<5) ;testing 1 bit off
0a24 : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0a26 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0a28 : 48 > pha ;use stack to load status
0a29 : a933 > lda #$33 ;precharge accu
0a2b : 28 > plp
>
0a2c : df0a06 > bbs 5,zpt,fail30371
0a2f : 5f0a06 > bbr 5,zpt,ok30371
> trap ;bbr branch not taken
0a32 : 4c320a > jmp * ;failed anyway
>
0a35 : >fail30371
> trap ;bbs branch taken
0a35 : 4c350a > jmp * ;failed anyway
>
0a38 : >ok30371
> tst_a $33,0
0a38 : 08 > php ;save flags
0a39 : c933 > cmp #$33 ;test result
> trap_ne
0a3b : d0fe > bne * ;failed not equal (non zero)
>
0a3d : 68 > pla ;load status
0a3e : 48 > pha
> cmp_flag 0
0a3f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a41 : d0fe > bne * ;failed not equal (non zero)
>
0a43 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0a44 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0a46 : 48 > pha ;use stack to load status
0a47 : a9cc > lda #$cc ;precharge accu
0a49 : 28 > plp
>
0a4a : df0a06 > bbs 5,zpt,fail40371
0a4d : 5f0a06 > bbr 5,zpt,ok40371
> trap ;bbr branch not taken
0a50 : 4c500a > jmp * ;failed anyway
>
0a53 : >fail40371
> trap ;bbs branch taken
0a53 : 4c530a > jmp * ;failed anyway
>
0a56 : >ok40371
> tst_a $cc,$ff
0a56 : 08 > php ;save flags
0a57 : c9cc > cmp #$cc ;test result
> trap_ne
0a59 : d0fe > bne * ;failed not equal (non zero)
>
0a5b : 68 > pla ;load status
0a5c : 48 > pha
> cmp_flag $ff
0a5d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a5f : d0fe > bne * ;failed not equal (non zero)
>
0a61 : 28 > plp ;restore status
>
0a62 : a50a > lda zpt
0a64 : c9df > cmp #$ff-(1<<5)
> trap_ne ;zp altered
0a66 : d0fe > bne * ;failed not equal (non zero)
>
bbt 6
0a68 : a940 > lda #(1<<6) ;testing 1 bit on
0a6a : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0a6c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0a6e : 48 > pha ;use stack to load status
0a6f : a933 > lda #$33 ;precharge accu
0a71 : 28 > plp
>
0a72 : 6f0a06 > bbr 6,zpt,fail10406
0a75 : ef0a06 > bbs 6,zpt,ok10406
> trap ;bbs branch not taken
0a78 : 4c780a > jmp * ;failed anyway
>
0a7b : >fail10406
> trap ;bbr branch taken
0a7b : 4c7b0a > jmp * ;failed anyway
>
0a7e : >ok10406
> tst_a $33,0
0a7e : 08 > php ;save flags
0a7f : c933 > cmp #$33 ;test result
> trap_ne
0a81 : d0fe > bne * ;failed not equal (non zero)
>
0a83 : 68 > pla ;load status
0a84 : 48 > pha
> cmp_flag 0
0a85 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a87 : d0fe > bne * ;failed not equal (non zero)
>
0a89 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0a8a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0a8c : 48 > pha ;use stack to load status
0a8d : a9cc > lda #$cc ;precharge accu
0a8f : 28 > plp
>
0a90 : 6f0a06 > bbr 6,zpt,fail20406
0a93 : ef0a06 > bbs 6,zpt,ok20406
> trap ;bbs branch not taken
0a96 : 4c960a > jmp * ;failed anyway
>
0a99 : >fail20406
> trap ;bbr branch taken
0a99 : 4c990a > jmp * ;failed anyway
>
0a9c : >ok20406
> tst_a $cc,$ff
0a9c : 08 > php ;save flags
0a9d : c9cc > cmp #$cc ;test result
> trap_ne
0a9f : d0fe > bne * ;failed not equal (non zero)
>
0aa1 : 68 > pla ;load status
0aa2 : 48 > pha
> cmp_flag $ff
0aa3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0aa5 : d0fe > bne * ;failed not equal (non zero)
>
0aa7 : 28 > plp ;restore status
>
0aa8 : a50a > lda zpt
0aaa : c940 > cmp #(1<<6)
> trap_ne ;zp altered
0aac : d0fe > bne * ;failed not equal (non zero)
>
0aae : a9bf > lda #$ff-(1<<6) ;testing 1 bit off
0ab0 : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0ab2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0ab4 : 48 > pha ;use stack to load status
0ab5 : a933 > lda #$33 ;precharge accu
0ab7 : 28 > plp
>
0ab8 : ef0a06 > bbs 6,zpt,fail30406
0abb : 6f0a06 > bbr 6,zpt,ok30406
> trap ;bbr branch not taken
0abe : 4cbe0a > jmp * ;failed anyway
>
0ac1 : >fail30406
> trap ;bbs branch taken
0ac1 : 4cc10a > jmp * ;failed anyway
>
0ac4 : >ok30406
> tst_a $33,0
0ac4 : 08 > php ;save flags
0ac5 : c933 > cmp #$33 ;test result
> trap_ne
0ac7 : d0fe > bne * ;failed not equal (non zero)
>
0ac9 : 68 > pla ;load status
0aca : 48 > pha
> cmp_flag 0
0acb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0acd : d0fe > bne * ;failed not equal (non zero)
>
0acf : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0ad0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0ad2 : 48 > pha ;use stack to load status
0ad3 : a9cc > lda #$cc ;precharge accu
0ad5 : 28 > plp
>
0ad6 : ef0a06 > bbs 6,zpt,fail40406
0ad9 : 6f0a06 > bbr 6,zpt,ok40406
> trap ;bbr branch not taken
0adc : 4cdc0a > jmp * ;failed anyway
>
0adf : >fail40406
> trap ;bbs branch taken
0adf : 4cdf0a > jmp * ;failed anyway
>
0ae2 : >ok40406
> tst_a $cc,$ff
0ae2 : 08 > php ;save flags
0ae3 : c9cc > cmp #$cc ;test result
> trap_ne
0ae5 : d0fe > bne * ;failed not equal (non zero)
>
0ae7 : 68 > pla ;load status
0ae8 : 48 > pha
> cmp_flag $ff
0ae9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0aeb : d0fe > bne * ;failed not equal (non zero)
>
0aed : 28 > plp ;restore status
>
0aee : a50a > lda zpt
0af0 : c9bf > cmp #$ff-(1<<6)
> trap_ne ;zp altered
0af2 : d0fe > bne * ;failed not equal (non zero)
>
bbt 7
0af4 : a980 > lda #(1<<7) ;testing 1 bit on
0af6 : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0af8 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0afa : 48 > pha ;use stack to load status
0afb : a933 > lda #$33 ;precharge accu
0afd : 28 > plp
>
0afe : 7f0a06 > bbr 7,zpt,fail10441
0b01 : ff0a06 > bbs 7,zpt,ok10441
> trap ;bbs branch not taken
0b04 : 4c040b > jmp * ;failed anyway
>
0b07 : >fail10441
> trap ;bbr branch taken
0b07 : 4c070b > jmp * ;failed anyway
>
0b0a : >ok10441
> tst_a $33,0
0b0a : 08 > php ;save flags
0b0b : c933 > cmp #$33 ;test result
> trap_ne
0b0d : d0fe > bne * ;failed not equal (non zero)
>
0b0f : 68 > pla ;load status
0b10 : 48 > pha
> cmp_flag 0
0b11 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b13 : d0fe > bne * ;failed not equal (non zero)
>
0b15 : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0b16 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0b18 : 48 > pha ;use stack to load status
0b19 : a9cc > lda #$cc ;precharge accu
0b1b : 28 > plp
>
0b1c : 7f0a06 > bbr 7,zpt,fail20441
0b1f : ff0a06 > bbs 7,zpt,ok20441
> trap ;bbs branch not taken
0b22 : 4c220b > jmp * ;failed anyway
>
0b25 : >fail20441
> trap ;bbr branch taken
0b25 : 4c250b > jmp * ;failed anyway
>
0b28 : >ok20441
> tst_a $cc,$ff
0b28 : 08 > php ;save flags
0b29 : c9cc > cmp #$cc ;test result
> trap_ne
0b2b : d0fe > bne * ;failed not equal (non zero)
>
0b2d : 68 > pla ;load status
0b2e : 48 > pha
> cmp_flag $ff
0b2f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b31 : d0fe > bne * ;failed not equal (non zero)
>
0b33 : 28 > plp ;restore status
>
0b34 : a50a > lda zpt
0b36 : c980 > cmp #(1<<7)
> trap_ne ;zp altered
0b38 : d0fe > bne * ;failed not equal (non zero)
>
0b3a : a97f > lda #$ff-(1<<7) ;testing 1 bit off
0b3c : 850a > sta zpt
> set_a $33,0 ;with flags off
> load_flag 0
0b3e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0b40 : 48 > pha ;use stack to load status
0b41 : a933 > lda #$33 ;precharge accu
0b43 : 28 > plp
>
0b44 : ff0a06 > bbs 7,zpt,fail30441
0b47 : 7f0a06 > bbr 7,zpt,ok30441
> trap ;bbr branch not taken
0b4a : 4c4a0b > jmp * ;failed anyway
>
0b4d : >fail30441
> trap ;bbs branch taken
0b4d : 4c4d0b > jmp * ;failed anyway
>
0b50 : >ok30441
> tst_a $33,0
0b50 : 08 > php ;save flags
0b51 : c933 > cmp #$33 ;test result
> trap_ne
0b53 : d0fe > bne * ;failed not equal (non zero)
>
0b55 : 68 > pla ;load status
0b56 : 48 > pha
> cmp_flag 0
0b57 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b59 : d0fe > bne * ;failed not equal (non zero)
>
0b5b : 28 > plp ;restore status
>
> set_a $cc,$ff ;with flags on
> load_flag $ff
0b5c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0b5e : 48 > pha ;use stack to load status
0b5f : a9cc > lda #$cc ;precharge accu
0b61 : 28 > plp
>
0b62 : ff0a06 > bbs 7,zpt,fail40441
0b65 : 7f0a06 > bbr 7,zpt,ok40441
> trap ;bbr branch not taken
0b68 : 4c680b > jmp * ;failed anyway
>
0b6b : >fail40441
> trap ;bbs branch taken
0b6b : 4c6b0b > jmp * ;failed anyway
>
0b6e : >ok40441
> tst_a $cc,$ff
0b6e : 08 > php ;save flags
0b6f : c9cc > cmp #$cc ;test result
> trap_ne
0b71 : d0fe > bne * ;failed not equal (non zero)
>
0b73 : 68 > pla ;load status
0b74 : 48 > pha
> cmp_flag $ff
0b75 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b77 : d0fe > bne * ;failed not equal (non zero)
>
0b79 : 28 > plp ;restore status
>
0b7a : a50a > lda zpt
0b7c : c97f > cmp #$ff-(1<<7)
> trap_ne ;zp altered
0b7e : d0fe > bne * ;failed not equal (non zero)
>
0b80 : e011 cpx #$11
trap_ne ;x overwritten
0b82 : d0fe > bne * ;failed not equal (non zero)
0b84 : c022 cpy #$22
trap_ne ;y overwritten
0b86 : d0fe > bne * ;failed not equal (non zero)
next_test
0b88 : ad0202 > lda test_case ;previous test
0b8b : c906 > cmp #test_num
> trap_ne ;test is out of sequence
0b8d : d0fe > bne * ;failed not equal (non zero)
>
0007 = >test_num = test_num + 1
0b8f : a907 > lda #test_num ;*** next tests' number
0b91 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
bbrc macro ;\1 = bitnum
bbr \1,zpt,skip\?
eor #(1<<\1)
skip\?
endm
bbsc macro ;\1 = bitnum
bbs \1,zpt,skip\?
eor #(1<<\1)
skip\?
endm
0b94 : a900 lda #0 ;combined bit test
0b96 : 850a sta zpt
0b98 : a900 bbcl lda #0
bbrc 0
0b9a : 0f0a02 > bbr 0,zpt,skip0480
0b9d : 4901 > eor #(1<<0)
0b9f : >skip0480
bbrc 1
0b9f : 1f0a02 > bbr 1,zpt,skip0481
0ba2 : 4902 > eor #(1<<1)
0ba4 : >skip0481
bbrc 2
0ba4 : 2f0a02 > bbr 2,zpt,skip0482
0ba7 : 4904 > eor #(1<<2)
0ba9 : >skip0482
bbrc 3
0ba9 : 3f0a02 > bbr 3,zpt,skip0483
0bac : 4908 > eor #(1<<3)
0bae : >skip0483
bbrc 4
0bae : 4f0a02 > bbr 4,zpt,skip0484
0bb1 : 4910 > eor #(1<<4)
0bb3 : >skip0484
bbrc 5
0bb3 : 5f0a02 > bbr 5,zpt,skip0485
0bb6 : 4920 > eor #(1<<5)
0bb8 : >skip0485
bbrc 6
0bb8 : 6f0a02 > bbr 6,zpt,skip0486
0bbb : 4940 > eor #(1<<6)
0bbd : >skip0486
bbrc 7
0bbd : 7f0a02 > bbr 7,zpt,skip0487
0bc0 : 4980 > eor #(1<<7)
0bc2 : >skip0487
0bc2 : 450a eor zpt
trap_ne ;failed bbr bitnum in accu
0bc4 : d0fe > bne * ;failed not equal (non zero)
0bc6 : a9ff lda #$ff
bbsc 0
0bc8 : 8f0a02 > bbs 0,zpt,skip0489
0bcb : 4901 > eor #(1<<0)
0bcd : >skip0489
bbsc 1
0bcd : 9f0a02 > bbs 1,zpt,skip0490
0bd0 : 4902 > eor #(1<<1)
0bd2 : >skip0490
bbsc 2
0bd2 : af0a02 > bbs 2,zpt,skip0491
0bd5 : 4904 > eor #(1<<2)
0bd7 : >skip0491
bbsc 3
0bd7 : bf0a02 > bbs 3,zpt,skip0492
0bda : 4908 > eor #(1<<3)
0bdc : >skip0492
bbsc 4
0bdc : cf0a02 > bbs 4,zpt,skip0493
0bdf : 4910 > eor #(1<<4)
0be1 : >skip0493
bbsc 5
0be1 : df0a02 > bbs 5,zpt,skip0494
0be4 : 4920 > eor #(1<<5)
0be6 : >skip0494
bbsc 6
0be6 : ef0a02 > bbs 6,zpt,skip0495
0be9 : 4940 > eor #(1<<6)
0beb : >skip0495
bbsc 7
0beb : ff0a02 > bbs 7,zpt,skip0496
0bee : 4980 > eor #(1<<7)
0bf0 : >skip0496
0bf0 : 450a eor zpt
trap_ne ;failed bbs bitnum in accu
0bf2 : d0fe > bne * ;failed not equal (non zero)
0bf4 : e60a inc zpt
0bf6 : d0a0 bne bbcl
next_test
0bf8 : ad0202 > lda test_case ;previous test
0bfb : c907 > cmp #test_num
> trap_ne ;test is out of sequence
0bfd : d0fe > bne * ;failed not equal (non zero)
>
0008 = >test_num = test_num + 1
0bff : a908 > lda #test_num ;*** next tests' number
0c01 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
endif
; testing NOP
nop_test macro ;\1 = opcode, \2 = # of bytes
ldy #$42
ldx #4-\2
db \1 ;test nop length
if \2 = 1
dex
dex
endif
if \2 = 2
iny
dex
endif
if \2 = 3
iny
iny
endif
dex
trap_ne ;wrong number of bytes
set_a $ff-\1,0
db \1 ;test nop integrity - flags off
nop
nop
tst_a $ff-\1,0
set_a $aa-\1,$ff
db \1 ;test nop integrity - flags on
nop
nop
tst_a $aa-\1,$ff
cpy #$42
trap_ne ;y changed
cpx #0
trap_ne ;x changed
endm
nop_test $02,2
0c04 : a042 > ldy #$42
0c06 : a202 > ldx #4-2
0c08 : 02 > db $02 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0c09 : c8 > iny
0c0a : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0c0b : ca > dex
> trap_ne ;wrong number of bytes
0c0c : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$02,0
> load_flag 0
0c0e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c10 : 48 > pha ;use stack to load status
0c11 : a9fd > lda #$ff-$02 ;precharge accu
0c13 : 28 > plp
>
0c14 : 02 > db $02 ;test nop integrity - flags off
0c15 : ea > nop
0c16 : ea > nop
> tst_a $ff-$02,0
0c17 : 08 > php ;save flags
0c18 : c9fd > cmp #$ff-$02 ;test result
> trap_ne
0c1a : d0fe > bne * ;failed not equal (non zero)
>
0c1c : 68 > pla ;load status
0c1d : 48 > pha
> cmp_flag 0
0c1e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c20 : d0fe > bne * ;failed not equal (non zero)
>
0c22 : 28 > plp ;restore status
>
> set_a $aa-$02,$ff
> load_flag $ff
0c23 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0c25 : 48 > pha ;use stack to load status
0c26 : a9a8 > lda #$aa-$02 ;precharge accu
0c28 : 28 > plp
>
0c29 : 02 > db $02 ;test nop integrity - flags on
0c2a : ea > nop
0c2b : ea > nop
> tst_a $aa-$02,$ff
0c2c : 08 > php ;save flags
0c2d : c9a8 > cmp #$aa-$02 ;test result
> trap_ne
0c2f : d0fe > bne * ;failed not equal (non zero)
>
0c31 : 68 > pla ;load status
0c32 : 48 > pha
> cmp_flag $ff
0c33 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c35 : d0fe > bne * ;failed not equal (non zero)
>
0c37 : 28 > plp ;restore status
>
0c38 : c042 > cpy #$42
> trap_ne ;y changed
0c3a : d0fe > bne * ;failed not equal (non zero)
>
0c3c : e000 > cpx #0
> trap_ne ;x changed
0c3e : d0fe > bne * ;failed not equal (non zero)
>
nop_test $22,2
0c40 : a042 > ldy #$42
0c42 : a202 > ldx #4-2
0c44 : 22 > db $22 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0c45 : c8 > iny
0c46 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0c47 : ca > dex
> trap_ne ;wrong number of bytes
0c48 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$22,0
> load_flag 0
0c4a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c4c : 48 > pha ;use stack to load status
0c4d : a9dd > lda #$ff-$22 ;precharge accu
0c4f : 28 > plp
>
0c50 : 22 > db $22 ;test nop integrity - flags off
0c51 : ea > nop
0c52 : ea > nop
> tst_a $ff-$22,0
0c53 : 08 > php ;save flags
0c54 : c9dd > cmp #$ff-$22 ;test result
> trap_ne
0c56 : d0fe > bne * ;failed not equal (non zero)
>
0c58 : 68 > pla ;load status
0c59 : 48 > pha
> cmp_flag 0
0c5a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c5c : d0fe > bne * ;failed not equal (non zero)
>
0c5e : 28 > plp ;restore status
>
> set_a $aa-$22,$ff
> load_flag $ff
0c5f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0c61 : 48 > pha ;use stack to load status
0c62 : a988 > lda #$aa-$22 ;precharge accu
0c64 : 28 > plp
>
0c65 : 22 > db $22 ;test nop integrity - flags on
0c66 : ea > nop
0c67 : ea > nop
> tst_a $aa-$22,$ff
0c68 : 08 > php ;save flags
0c69 : c988 > cmp #$aa-$22 ;test result
> trap_ne
0c6b : d0fe > bne * ;failed not equal (non zero)
>
0c6d : 68 > pla ;load status
0c6e : 48 > pha
> cmp_flag $ff
0c6f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c71 : d0fe > bne * ;failed not equal (non zero)
>
0c73 : 28 > plp ;restore status
>
0c74 : c042 > cpy #$42
> trap_ne ;y changed
0c76 : d0fe > bne * ;failed not equal (non zero)
>
0c78 : e000 > cpx #0
> trap_ne ;x changed
0c7a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $42,2
0c7c : a042 > ldy #$42
0c7e : a202 > ldx #4-2
0c80 : 42 > db $42 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0c81 : c8 > iny
0c82 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0c83 : ca > dex
> trap_ne ;wrong number of bytes
0c84 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$42,0
> load_flag 0
0c86 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c88 : 48 > pha ;use stack to load status
0c89 : a9bd > lda #$ff-$42 ;precharge accu
0c8b : 28 > plp
>
0c8c : 42 > db $42 ;test nop integrity - flags off
0c8d : ea > nop
0c8e : ea > nop
> tst_a $ff-$42,0
0c8f : 08 > php ;save flags
0c90 : c9bd > cmp #$ff-$42 ;test result
> trap_ne
0c92 : d0fe > bne * ;failed not equal (non zero)
>
0c94 : 68 > pla ;load status
0c95 : 48 > pha
> cmp_flag 0
0c96 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c98 : d0fe > bne * ;failed not equal (non zero)
>
0c9a : 28 > plp ;restore status
>
> set_a $aa-$42,$ff
> load_flag $ff
0c9b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0c9d : 48 > pha ;use stack to load status
0c9e : a968 > lda #$aa-$42 ;precharge accu
0ca0 : 28 > plp
>
0ca1 : 42 > db $42 ;test nop integrity - flags on
0ca2 : ea > nop
0ca3 : ea > nop
> tst_a $aa-$42,$ff
0ca4 : 08 > php ;save flags
0ca5 : c968 > cmp #$aa-$42 ;test result
> trap_ne
0ca7 : d0fe > bne * ;failed not equal (non zero)
>
0ca9 : 68 > pla ;load status
0caa : 48 > pha
> cmp_flag $ff
0cab : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0cad : d0fe > bne * ;failed not equal (non zero)
>
0caf : 28 > plp ;restore status
>
0cb0 : c042 > cpy #$42
> trap_ne ;y changed
0cb2 : d0fe > bne * ;failed not equal (non zero)
>
0cb4 : e000 > cpx #0
> trap_ne ;x changed
0cb6 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $62,2
0cb8 : a042 > ldy #$42
0cba : a202 > ldx #4-2
0cbc : 62 > db $62 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0cbd : c8 > iny
0cbe : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0cbf : ca > dex
> trap_ne ;wrong number of bytes
0cc0 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$62,0
> load_flag 0
0cc2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0cc4 : 48 > pha ;use stack to load status
0cc5 : a99d > lda #$ff-$62 ;precharge accu
0cc7 : 28 > plp
>
0cc8 : 62 > db $62 ;test nop integrity - flags off
0cc9 : ea > nop
0cca : ea > nop
> tst_a $ff-$62,0
0ccb : 08 > php ;save flags
0ccc : c99d > cmp #$ff-$62 ;test result
> trap_ne
0cce : d0fe > bne * ;failed not equal (non zero)
>
0cd0 : 68 > pla ;load status
0cd1 : 48 > pha
> cmp_flag 0
0cd2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0cd4 : d0fe > bne * ;failed not equal (non zero)
>
0cd6 : 28 > plp ;restore status
>
> set_a $aa-$62,$ff
> load_flag $ff
0cd7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0cd9 : 48 > pha ;use stack to load status
0cda : a948 > lda #$aa-$62 ;precharge accu
0cdc : 28 > plp
>
0cdd : 62 > db $62 ;test nop integrity - flags on
0cde : ea > nop
0cdf : ea > nop
> tst_a $aa-$62,$ff
0ce0 : 08 > php ;save flags
0ce1 : c948 > cmp #$aa-$62 ;test result
> trap_ne
0ce3 : d0fe > bne * ;failed not equal (non zero)
>
0ce5 : 68 > pla ;load status
0ce6 : 48 > pha
> cmp_flag $ff
0ce7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ce9 : d0fe > bne * ;failed not equal (non zero)
>
0ceb : 28 > plp ;restore status
>
0cec : c042 > cpy #$42
> trap_ne ;y changed
0cee : d0fe > bne * ;failed not equal (non zero)
>
0cf0 : e000 > cpx #0
> trap_ne ;x changed
0cf2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $82,2
0cf4 : a042 > ldy #$42
0cf6 : a202 > ldx #4-2
0cf8 : 82 > db $82 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0cf9 : c8 > iny
0cfa : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0cfb : ca > dex
> trap_ne ;wrong number of bytes
0cfc : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$82,0
> load_flag 0
0cfe : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d00 : 48 > pha ;use stack to load status
0d01 : a97d > lda #$ff-$82 ;precharge accu
0d03 : 28 > plp
>
0d04 : 82 > db $82 ;test nop integrity - flags off
0d05 : ea > nop
0d06 : ea > nop
> tst_a $ff-$82,0
0d07 : 08 > php ;save flags
0d08 : c97d > cmp #$ff-$82 ;test result
> trap_ne
0d0a : d0fe > bne * ;failed not equal (non zero)
>
0d0c : 68 > pla ;load status
0d0d : 48 > pha
> cmp_flag 0
0d0e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d10 : d0fe > bne * ;failed not equal (non zero)
>
0d12 : 28 > plp ;restore status
>
> set_a $aa-$82,$ff
> load_flag $ff
0d13 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d15 : 48 > pha ;use stack to load status
0d16 : a928 > lda #$aa-$82 ;precharge accu
0d18 : 28 > plp
>
0d19 : 82 > db $82 ;test nop integrity - flags on
0d1a : ea > nop
0d1b : ea > nop
> tst_a $aa-$82,$ff
0d1c : 08 > php ;save flags
0d1d : c928 > cmp #$aa-$82 ;test result
> trap_ne
0d1f : d0fe > bne * ;failed not equal (non zero)
>
0d21 : 68 > pla ;load status
0d22 : 48 > pha
> cmp_flag $ff
0d23 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d25 : d0fe > bne * ;failed not equal (non zero)
>
0d27 : 28 > plp ;restore status
>
0d28 : c042 > cpy #$42
> trap_ne ;y changed
0d2a : d0fe > bne * ;failed not equal (non zero)
>
0d2c : e000 > cpx #0
> trap_ne ;x changed
0d2e : d0fe > bne * ;failed not equal (non zero)
>
nop_test $c2,2
0d30 : a042 > ldy #$42
0d32 : a202 > ldx #4-2
0d34 : c2 > db $c2 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0d35 : c8 > iny
0d36 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0d37 : ca > dex
> trap_ne ;wrong number of bytes
0d38 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$c2,0
> load_flag 0
0d3a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d3c : 48 > pha ;use stack to load status
0d3d : a93d > lda #$ff-$c2 ;precharge accu
0d3f : 28 > plp
>
0d40 : c2 > db $c2 ;test nop integrity - flags off
0d41 : ea > nop
0d42 : ea > nop
> tst_a $ff-$c2,0
0d43 : 08 > php ;save flags
0d44 : c93d > cmp #$ff-$c2 ;test result
> trap_ne
0d46 : d0fe > bne * ;failed not equal (non zero)
>
0d48 : 68 > pla ;load status
0d49 : 48 > pha
> cmp_flag 0
0d4a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d4c : d0fe > bne * ;failed not equal (non zero)
>
0d4e : 28 > plp ;restore status
>
> set_a $aa-$c2,$ff
> load_flag $ff
0d4f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d51 : 48 > pha ;use stack to load status
0d52 : a9e8 > lda #$aa-$c2 ;precharge accu
0d54 : 28 > plp
>
0d55 : c2 > db $c2 ;test nop integrity - flags on
0d56 : ea > nop
0d57 : ea > nop
> tst_a $aa-$c2,$ff
0d58 : 08 > php ;save flags
0d59 : c9e8 > cmp #$aa-$c2 ;test result
> trap_ne
0d5b : d0fe > bne * ;failed not equal (non zero)
>
0d5d : 68 > pla ;load status
0d5e : 48 > pha
> cmp_flag $ff
0d5f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d61 : d0fe > bne * ;failed not equal (non zero)
>
0d63 : 28 > plp ;restore status
>
0d64 : c042 > cpy #$42
> trap_ne ;y changed
0d66 : d0fe > bne * ;failed not equal (non zero)
>
0d68 : e000 > cpx #0
> trap_ne ;x changed
0d6a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $e2,2
0d6c : a042 > ldy #$42
0d6e : a202 > ldx #4-2
0d70 : e2 > db $e2 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0d71 : c8 > iny
0d72 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0d73 : ca > dex
> trap_ne ;wrong number of bytes
0d74 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$e2,0
> load_flag 0
0d76 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d78 : 48 > pha ;use stack to load status
0d79 : a91d > lda #$ff-$e2 ;precharge accu
0d7b : 28 > plp
>
0d7c : e2 > db $e2 ;test nop integrity - flags off
0d7d : ea > nop
0d7e : ea > nop
> tst_a $ff-$e2,0
0d7f : 08 > php ;save flags
0d80 : c91d > cmp #$ff-$e2 ;test result
> trap_ne
0d82 : d0fe > bne * ;failed not equal (non zero)
>
0d84 : 68 > pla ;load status
0d85 : 48 > pha
> cmp_flag 0
0d86 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d88 : d0fe > bne * ;failed not equal (non zero)
>
0d8a : 28 > plp ;restore status
>
> set_a $aa-$e2,$ff
> load_flag $ff
0d8b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d8d : 48 > pha ;use stack to load status
0d8e : a9c8 > lda #$aa-$e2 ;precharge accu
0d90 : 28 > plp
>
0d91 : e2 > db $e2 ;test nop integrity - flags on
0d92 : ea > nop
0d93 : ea > nop
> tst_a $aa-$e2,$ff
0d94 : 08 > php ;save flags
0d95 : c9c8 > cmp #$aa-$e2 ;test result
> trap_ne
0d97 : d0fe > bne * ;failed not equal (non zero)
>
0d99 : 68 > pla ;load status
0d9a : 48 > pha
> cmp_flag $ff
0d9b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d9d : d0fe > bne * ;failed not equal (non zero)
>
0d9f : 28 > plp ;restore status
>
0da0 : c042 > cpy #$42
> trap_ne ;y changed
0da2 : d0fe > bne * ;failed not equal (non zero)
>
0da4 : e000 > cpx #0
> trap_ne ;x changed
0da6 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $44,2
0da8 : a042 > ldy #$42
0daa : a202 > ldx #4-2
0dac : 44 > db $44 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0dad : c8 > iny
0dae : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0daf : ca > dex
> trap_ne ;wrong number of bytes
0db0 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$44,0
> load_flag 0
0db2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0db4 : 48 > pha ;use stack to load status
0db5 : a9bb > lda #$ff-$44 ;precharge accu
0db7 : 28 > plp
>
0db8 : 44 > db $44 ;test nop integrity - flags off
0db9 : ea > nop
0dba : ea > nop
> tst_a $ff-$44,0
0dbb : 08 > php ;save flags
0dbc : c9bb > cmp #$ff-$44 ;test result
> trap_ne
0dbe : d0fe > bne * ;failed not equal (non zero)
>
0dc0 : 68 > pla ;load status
0dc1 : 48 > pha
> cmp_flag 0
0dc2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0dc4 : d0fe > bne * ;failed not equal (non zero)
>
0dc6 : 28 > plp ;restore status
>
> set_a $aa-$44,$ff
> load_flag $ff
0dc7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0dc9 : 48 > pha ;use stack to load status
0dca : a966 > lda #$aa-$44 ;precharge accu
0dcc : 28 > plp
>
0dcd : 44 > db $44 ;test nop integrity - flags on
0dce : ea > nop
0dcf : ea > nop
> tst_a $aa-$44,$ff
0dd0 : 08 > php ;save flags
0dd1 : c966 > cmp #$aa-$44 ;test result
> trap_ne
0dd3 : d0fe > bne * ;failed not equal (non zero)
>
0dd5 : 68 > pla ;load status
0dd6 : 48 > pha
> cmp_flag $ff
0dd7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0dd9 : d0fe > bne * ;failed not equal (non zero)
>
0ddb : 28 > plp ;restore status
>
0ddc : c042 > cpy #$42
> trap_ne ;y changed
0dde : d0fe > bne * ;failed not equal (non zero)
>
0de0 : e000 > cpx #0
> trap_ne ;x changed
0de2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $54,2
0de4 : a042 > ldy #$42
0de6 : a202 > ldx #4-2
0de8 : 54 > db $54 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0de9 : c8 > iny
0dea : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0deb : ca > dex
> trap_ne ;wrong number of bytes
0dec : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$54,0
> load_flag 0
0dee : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0df0 : 48 > pha ;use stack to load status
0df1 : a9ab > lda #$ff-$54 ;precharge accu
0df3 : 28 > plp
>
0df4 : 54 > db $54 ;test nop integrity - flags off
0df5 : ea > nop
0df6 : ea > nop
> tst_a $ff-$54,0
0df7 : 08 > php ;save flags
0df8 : c9ab > cmp #$ff-$54 ;test result
> trap_ne
0dfa : d0fe > bne * ;failed not equal (non zero)
>
0dfc : 68 > pla ;load status
0dfd : 48 > pha
> cmp_flag 0
0dfe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e00 : d0fe > bne * ;failed not equal (non zero)
>
0e02 : 28 > plp ;restore status
>
> set_a $aa-$54,$ff
> load_flag $ff
0e03 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0e05 : 48 > pha ;use stack to load status
0e06 : a956 > lda #$aa-$54 ;precharge accu
0e08 : 28 > plp
>
0e09 : 54 > db $54 ;test nop integrity - flags on
0e0a : ea > nop
0e0b : ea > nop
> tst_a $aa-$54,$ff
0e0c : 08 > php ;save flags
0e0d : c956 > cmp #$aa-$54 ;test result
> trap_ne
0e0f : d0fe > bne * ;failed not equal (non zero)
>
0e11 : 68 > pla ;load status
0e12 : 48 > pha
> cmp_flag $ff
0e13 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e15 : d0fe > bne * ;failed not equal (non zero)
>
0e17 : 28 > plp ;restore status
>
0e18 : c042 > cpy #$42
> trap_ne ;y changed
0e1a : d0fe > bne * ;failed not equal (non zero)
>
0e1c : e000 > cpx #0
> trap_ne ;x changed
0e1e : d0fe > bne * ;failed not equal (non zero)
>
nop_test $d4,2
0e20 : a042 > ldy #$42
0e22 : a202 > ldx #4-2
0e24 : d4 > db $d4 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0e25 : c8 > iny
0e26 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0e27 : ca > dex
> trap_ne ;wrong number of bytes
0e28 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$d4,0
> load_flag 0
0e2a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0e2c : 48 > pha ;use stack to load status
0e2d : a92b > lda #$ff-$d4 ;precharge accu
0e2f : 28 > plp
>
0e30 : d4 > db $d4 ;test nop integrity - flags off
0e31 : ea > nop
0e32 : ea > nop
> tst_a $ff-$d4,0
0e33 : 08 > php ;save flags
0e34 : c92b > cmp #$ff-$d4 ;test result
> trap_ne
0e36 : d0fe > bne * ;failed not equal (non zero)
>
0e38 : 68 > pla ;load status
0e39 : 48 > pha
> cmp_flag 0
0e3a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e3c : d0fe > bne * ;failed not equal (non zero)
>
0e3e : 28 > plp ;restore status
>
> set_a $aa-$d4,$ff
> load_flag $ff
0e3f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0e41 : 48 > pha ;use stack to load status
0e42 : a9d6 > lda #$aa-$d4 ;precharge accu
0e44 : 28 > plp
>
0e45 : d4 > db $d4 ;test nop integrity - flags on
0e46 : ea > nop
0e47 : ea > nop
> tst_a $aa-$d4,$ff
0e48 : 08 > php ;save flags
0e49 : c9d6 > cmp #$aa-$d4 ;test result
> trap_ne
0e4b : d0fe > bne * ;failed not equal (non zero)
>
0e4d : 68 > pla ;load status
0e4e : 48 > pha
> cmp_flag $ff
0e4f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e51 : d0fe > bne * ;failed not equal (non zero)
>
0e53 : 28 > plp ;restore status
>
0e54 : c042 > cpy #$42
> trap_ne ;y changed
0e56 : d0fe > bne * ;failed not equal (non zero)
>
0e58 : e000 > cpx #0
> trap_ne ;x changed
0e5a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $f4,2
0e5c : a042 > ldy #$42
0e5e : a202 > ldx #4-2
0e60 : f4 > db $f4 ;test nop length
> if 2 = 1
> dex
> dex
> endif
> if 2 = 2
0e61 : c8 > iny
0e62 : ca > dex
> endif
> if 2 = 3
> iny
> iny
> endif
0e63 : ca > dex
> trap_ne ;wrong number of bytes
0e64 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$f4,0
> load_flag 0
0e66 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0e68 : 48 > pha ;use stack to load status
0e69 : a90b > lda #$ff-$f4 ;precharge accu
0e6b : 28 > plp
>
0e6c : f4 > db $f4 ;test nop integrity - flags off
0e6d : ea > nop
0e6e : ea > nop
> tst_a $ff-$f4,0
0e6f : 08 > php ;save flags
0e70 : c90b > cmp #$ff-$f4 ;test result
> trap_ne
0e72 : d0fe > bne * ;failed not equal (non zero)
>
0e74 : 68 > pla ;load status
0e75 : 48 > pha
> cmp_flag 0
0e76 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e78 : d0fe > bne * ;failed not equal (non zero)
>
0e7a : 28 > plp ;restore status
>
> set_a $aa-$f4,$ff
> load_flag $ff
0e7b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0e7d : 48 > pha ;use stack to load status
0e7e : a9b6 > lda #$aa-$f4 ;precharge accu
0e80 : 28 > plp
>
0e81 : f4 > db $f4 ;test nop integrity - flags on
0e82 : ea > nop
0e83 : ea > nop
> tst_a $aa-$f4,$ff
0e84 : 08 > php ;save flags
0e85 : c9b6 > cmp #$aa-$f4 ;test result
> trap_ne
0e87 : d0fe > bne * ;failed not equal (non zero)
>
0e89 : 68 > pla ;load status
0e8a : 48 > pha
> cmp_flag $ff
0e8b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0e8d : d0fe > bne * ;failed not equal (non zero)
>
0e8f : 28 > plp ;restore status
>
0e90 : c042 > cpy #$42
> trap_ne ;y changed
0e92 : d0fe > bne * ;failed not equal (non zero)
>
0e94 : e000 > cpx #0
> trap_ne ;x changed
0e96 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $5c,3
0e98 : a042 > ldy #$42
0e9a : a201 > ldx #4-3
0e9c : 5c > db $5c ;test nop length
> if 3 = 1
> dex
> dex
> endif
> if 3 = 2
> iny
> dex
> endif
> if 3 = 3
0e9d : c8 > iny
0e9e : c8 > iny
> endif
0e9f : ca > dex
> trap_ne ;wrong number of bytes
0ea0 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$5c,0
> load_flag 0
0ea2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0ea4 : 48 > pha ;use stack to load status
0ea5 : a9a3 > lda #$ff-$5c ;precharge accu
0ea7 : 28 > plp
>
0ea8 : 5c > db $5c ;test nop integrity - flags off
0ea9 : ea > nop
0eaa : ea > nop
> tst_a $ff-$5c,0
0eab : 08 > php ;save flags
0eac : c9a3 > cmp #$ff-$5c ;test result
> trap_ne
0eae : d0fe > bne * ;failed not equal (non zero)
>
0eb0 : 68 > pla ;load status
0eb1 : 48 > pha
> cmp_flag 0
0eb2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0eb4 : d0fe > bne * ;failed not equal (non zero)
>
0eb6 : 28 > plp ;restore status
>
> set_a $aa-$5c,$ff
> load_flag $ff
0eb7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0eb9 : 48 > pha ;use stack to load status
0eba : a94e > lda #$aa-$5c ;precharge accu
0ebc : 28 > plp
>
0ebd : 5c > db $5c ;test nop integrity - flags on
0ebe : ea > nop
0ebf : ea > nop
> tst_a $aa-$5c,$ff
0ec0 : 08 > php ;save flags
0ec1 : c94e > cmp #$aa-$5c ;test result
> trap_ne
0ec3 : d0fe > bne * ;failed not equal (non zero)
>
0ec5 : 68 > pla ;load status
0ec6 : 48 > pha
> cmp_flag $ff
0ec7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ec9 : d0fe > bne * ;failed not equal (non zero)
>
0ecb : 28 > plp ;restore status
>
0ecc : c042 > cpy #$42
> trap_ne ;y changed
0ece : d0fe > bne * ;failed not equal (non zero)
>
0ed0 : e000 > cpx #0
> trap_ne ;x changed
0ed2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $dc,3
0ed4 : a042 > ldy #$42
0ed6 : a201 > ldx #4-3
0ed8 : dc > db $dc ;test nop length
> if 3 = 1
> dex
> dex
> endif
> if 3 = 2
> iny
> dex
> endif
> if 3 = 3
0ed9 : c8 > iny
0eda : c8 > iny
> endif
0edb : ca > dex
> trap_ne ;wrong number of bytes
0edc : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$dc,0
> load_flag 0
0ede : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0ee0 : 48 > pha ;use stack to load status
0ee1 : a923 > lda #$ff-$dc ;precharge accu
0ee3 : 28 > plp
>
0ee4 : dc > db $dc ;test nop integrity - flags off
0ee5 : ea > nop
0ee6 : ea > nop
> tst_a $ff-$dc,0
0ee7 : 08 > php ;save flags
0ee8 : c923 > cmp #$ff-$dc ;test result
> trap_ne
0eea : d0fe > bne * ;failed not equal (non zero)
>
0eec : 68 > pla ;load status
0eed : 48 > pha
> cmp_flag 0
0eee : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ef0 : d0fe > bne * ;failed not equal (non zero)
>
0ef2 : 28 > plp ;restore status
>
> set_a $aa-$dc,$ff
> load_flag $ff
0ef3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0ef5 : 48 > pha ;use stack to load status
0ef6 : a9ce > lda #$aa-$dc ;precharge accu
0ef8 : 28 > plp
>
0ef9 : dc > db $dc ;test nop integrity - flags on
0efa : ea > nop
0efb : ea > nop
> tst_a $aa-$dc,$ff
0efc : 08 > php ;save flags
0efd : c9ce > cmp #$aa-$dc ;test result
> trap_ne
0eff : d0fe > bne * ;failed not equal (non zero)
>
0f01 : 68 > pla ;load status
0f02 : 48 > pha
> cmp_flag $ff
0f03 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f05 : d0fe > bne * ;failed not equal (non zero)
>
0f07 : 28 > plp ;restore status
>
0f08 : c042 > cpy #$42
> trap_ne ;y changed
0f0a : d0fe > bne * ;failed not equal (non zero)
>
0f0c : e000 > cpx #0
> trap_ne ;x changed
0f0e : d0fe > bne * ;failed not equal (non zero)
>
nop_test $fc,3
0f10 : a042 > ldy #$42
0f12 : a201 > ldx #4-3
0f14 : fc > db $fc ;test nop length
> if 3 = 1
> dex
> dex
> endif
> if 3 = 2
> iny
> dex
> endif
> if 3 = 3
0f15 : c8 > iny
0f16 : c8 > iny
> endif
0f17 : ca > dex
> trap_ne ;wrong number of bytes
0f18 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$fc,0
> load_flag 0
0f1a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0f1c : 48 > pha ;use stack to load status
0f1d : a903 > lda #$ff-$fc ;precharge accu
0f1f : 28 > plp
>
0f20 : fc > db $fc ;test nop integrity - flags off
0f21 : ea > nop
0f22 : ea > nop
> tst_a $ff-$fc,0
0f23 : 08 > php ;save flags
0f24 : c903 > cmp #$ff-$fc ;test result
> trap_ne
0f26 : d0fe > bne * ;failed not equal (non zero)
>
0f28 : 68 > pla ;load status
0f29 : 48 > pha
> cmp_flag 0
0f2a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f2c : d0fe > bne * ;failed not equal (non zero)
>
0f2e : 28 > plp ;restore status
>
> set_a $aa-$fc,$ff
> load_flag $ff
0f2f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0f31 : 48 > pha ;use stack to load status
0f32 : a9ae > lda #$aa-$fc ;precharge accu
0f34 : 28 > plp
>
0f35 : fc > db $fc ;test nop integrity - flags on
0f36 : ea > nop
0f37 : ea > nop
> tst_a $aa-$fc,$ff
0f38 : 08 > php ;save flags
0f39 : c9ae > cmp #$aa-$fc ;test result
> trap_ne
0f3b : d0fe > bne * ;failed not equal (non zero)
>
0f3d : 68 > pla ;load status
0f3e : 48 > pha
> cmp_flag $ff
0f3f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f41 : d0fe > bne * ;failed not equal (non zero)
>
0f43 : 28 > plp ;restore status
>
0f44 : c042 > cpy #$42
> trap_ne ;y changed
0f46 : d0fe > bne * ;failed not equal (non zero)
>
0f48 : e000 > cpx #0
> trap_ne ;x changed
0f4a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $03,1
0f4c : a042 > ldy #$42
0f4e : a203 > ldx #4-1
0f50 : 03 > db $03 ;test nop length
> if 1 = 1
0f51 : ca > dex
0f52 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
0f53 : ca > dex
> trap_ne ;wrong number of bytes
0f54 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$03,0
> load_flag 0
0f56 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0f58 : 48 > pha ;use stack to load status
0f59 : a9fc > lda #$ff-$03 ;precharge accu
0f5b : 28 > plp
>
0f5c : 03 > db $03 ;test nop integrity - flags off
0f5d : ea > nop
0f5e : ea > nop
> tst_a $ff-$03,0
0f5f : 08 > php ;save flags
0f60 : c9fc > cmp #$ff-$03 ;test result
> trap_ne
0f62 : d0fe > bne * ;failed not equal (non zero)
>
0f64 : 68 > pla ;load status
0f65 : 48 > pha
> cmp_flag 0
0f66 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f68 : d0fe > bne * ;failed not equal (non zero)
>
0f6a : 28 > plp ;restore status
>
> set_a $aa-$03,$ff
> load_flag $ff
0f6b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0f6d : 48 > pha ;use stack to load status
0f6e : a9a7 > lda #$aa-$03 ;precharge accu
0f70 : 28 > plp
>
0f71 : 03 > db $03 ;test nop integrity - flags on
0f72 : ea > nop
0f73 : ea > nop
> tst_a $aa-$03,$ff
0f74 : 08 > php ;save flags
0f75 : c9a7 > cmp #$aa-$03 ;test result
> trap_ne
0f77 : d0fe > bne * ;failed not equal (non zero)
>
0f79 : 68 > pla ;load status
0f7a : 48 > pha
> cmp_flag $ff
0f7b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0f7d : d0fe > bne * ;failed not equal (non zero)
>
0f7f : 28 > plp ;restore status
>
0f80 : c042 > cpy #$42
> trap_ne ;y changed
0f82 : d0fe > bne * ;failed not equal (non zero)
>
0f84 : e000 > cpx #0
> trap_ne ;x changed
0f86 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $13,1
0f88 : a042 > ldy #$42
0f8a : a203 > ldx #4-1
0f8c : 13 > db $13 ;test nop length
> if 1 = 1
0f8d : ca > dex
0f8e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
0f8f : ca > dex
> trap_ne ;wrong number of bytes
0f90 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$13,0
> load_flag 0
0f92 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0f94 : 48 > pha ;use stack to load status
0f95 : a9ec > lda #$ff-$13 ;precharge accu
0f97 : 28 > plp
>
0f98 : 13 > db $13 ;test nop integrity - flags off
0f99 : ea > nop
0f9a : ea > nop
> tst_a $ff-$13,0
0f9b : 08 > php ;save flags
0f9c : c9ec > cmp #$ff-$13 ;test result
> trap_ne
0f9e : d0fe > bne * ;failed not equal (non zero)
>
0fa0 : 68 > pla ;load status
0fa1 : 48 > pha
> cmp_flag 0
0fa2 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fa4 : d0fe > bne * ;failed not equal (non zero)
>
0fa6 : 28 > plp ;restore status
>
> set_a $aa-$13,$ff
> load_flag $ff
0fa7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0fa9 : 48 > pha ;use stack to load status
0faa : a997 > lda #$aa-$13 ;precharge accu
0fac : 28 > plp
>
0fad : 13 > db $13 ;test nop integrity - flags on
0fae : ea > nop
0faf : ea > nop
> tst_a $aa-$13,$ff
0fb0 : 08 > php ;save flags
0fb1 : c997 > cmp #$aa-$13 ;test result
> trap_ne
0fb3 : d0fe > bne * ;failed not equal (non zero)
>
0fb5 : 68 > pla ;load status
0fb6 : 48 > pha
> cmp_flag $ff
0fb7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fb9 : d0fe > bne * ;failed not equal (non zero)
>
0fbb : 28 > plp ;restore status
>
0fbc : c042 > cpy #$42
> trap_ne ;y changed
0fbe : d0fe > bne * ;failed not equal (non zero)
>
0fc0 : e000 > cpx #0
> trap_ne ;x changed
0fc2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $23,1
0fc4 : a042 > ldy #$42
0fc6 : a203 > ldx #4-1
0fc8 : 23 > db $23 ;test nop length
> if 1 = 1
0fc9 : ca > dex
0fca : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
0fcb : ca > dex
> trap_ne ;wrong number of bytes
0fcc : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$23,0
> load_flag 0
0fce : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0fd0 : 48 > pha ;use stack to load status
0fd1 : a9dc > lda #$ff-$23 ;precharge accu
0fd3 : 28 > plp
>
0fd4 : 23 > db $23 ;test nop integrity - flags off
0fd5 : ea > nop
0fd6 : ea > nop
> tst_a $ff-$23,0
0fd7 : 08 > php ;save flags
0fd8 : c9dc > cmp #$ff-$23 ;test result
> trap_ne
0fda : d0fe > bne * ;failed not equal (non zero)
>
0fdc : 68 > pla ;load status
0fdd : 48 > pha
> cmp_flag 0
0fde : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0fe0 : d0fe > bne * ;failed not equal (non zero)
>
0fe2 : 28 > plp ;restore status
>
> set_a $aa-$23,$ff
> load_flag $ff
0fe3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0fe5 : 48 > pha ;use stack to load status
0fe6 : a987 > lda #$aa-$23 ;precharge accu
0fe8 : 28 > plp
>
0fe9 : 23 > db $23 ;test nop integrity - flags on
0fea : ea > nop
0feb : ea > nop
> tst_a $aa-$23,$ff
0fec : 08 > php ;save flags
0fed : c987 > cmp #$aa-$23 ;test result
> trap_ne
0fef : d0fe > bne * ;failed not equal (non zero)
>
0ff1 : 68 > pla ;load status
0ff2 : 48 > pha
> cmp_flag $ff
0ff3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ff5 : d0fe > bne * ;failed not equal (non zero)
>
0ff7 : 28 > plp ;restore status
>
0ff8 : c042 > cpy #$42
> trap_ne ;y changed
0ffa : d0fe > bne * ;failed not equal (non zero)
>
0ffc : e000 > cpx #0
> trap_ne ;x changed
0ffe : d0fe > bne * ;failed not equal (non zero)
>
nop_test $33,1
1000 : a042 > ldy #$42
1002 : a203 > ldx #4-1
1004 : 33 > db $33 ;test nop length
> if 1 = 1
1005 : ca > dex
1006 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1007 : ca > dex
> trap_ne ;wrong number of bytes
1008 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$33,0
> load_flag 0
100a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
100c : 48 > pha ;use stack to load status
100d : a9cc > lda #$ff-$33 ;precharge accu
100f : 28 > plp
>
1010 : 33 > db $33 ;test nop integrity - flags off
1011 : ea > nop
1012 : ea > nop
> tst_a $ff-$33,0
1013 : 08 > php ;save flags
1014 : c9cc > cmp #$ff-$33 ;test result
> trap_ne
1016 : d0fe > bne * ;failed not equal (non zero)
>
1018 : 68 > pla ;load status
1019 : 48 > pha
> cmp_flag 0
101a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
101c : d0fe > bne * ;failed not equal (non zero)
>
101e : 28 > plp ;restore status
>
> set_a $aa-$33,$ff
> load_flag $ff
101f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1021 : 48 > pha ;use stack to load status
1022 : a977 > lda #$aa-$33 ;precharge accu
1024 : 28 > plp
>
1025 : 33 > db $33 ;test nop integrity - flags on
1026 : ea > nop
1027 : ea > nop
> tst_a $aa-$33,$ff
1028 : 08 > php ;save flags
1029 : c977 > cmp #$aa-$33 ;test result
> trap_ne
102b : d0fe > bne * ;failed not equal (non zero)
>
102d : 68 > pla ;load status
102e : 48 > pha
> cmp_flag $ff
102f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1031 : d0fe > bne * ;failed not equal (non zero)
>
1033 : 28 > plp ;restore status
>
1034 : c042 > cpy #$42
> trap_ne ;y changed
1036 : d0fe > bne * ;failed not equal (non zero)
>
1038 : e000 > cpx #0
> trap_ne ;x changed
103a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $43,1
103c : a042 > ldy #$42
103e : a203 > ldx #4-1
1040 : 43 > db $43 ;test nop length
> if 1 = 1
1041 : ca > dex
1042 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1043 : ca > dex
> trap_ne ;wrong number of bytes
1044 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$43,0
> load_flag 0
1046 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1048 : 48 > pha ;use stack to load status
1049 : a9bc > lda #$ff-$43 ;precharge accu
104b : 28 > plp
>
104c : 43 > db $43 ;test nop integrity - flags off
104d : ea > nop
104e : ea > nop
> tst_a $ff-$43,0
104f : 08 > php ;save flags
1050 : c9bc > cmp #$ff-$43 ;test result
> trap_ne
1052 : d0fe > bne * ;failed not equal (non zero)
>
1054 : 68 > pla ;load status
1055 : 48 > pha
> cmp_flag 0
1056 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1058 : d0fe > bne * ;failed not equal (non zero)
>
105a : 28 > plp ;restore status
>
> set_a $aa-$43,$ff
> load_flag $ff
105b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
105d : 48 > pha ;use stack to load status
105e : a967 > lda #$aa-$43 ;precharge accu
1060 : 28 > plp
>
1061 : 43 > db $43 ;test nop integrity - flags on
1062 : ea > nop
1063 : ea > nop
> tst_a $aa-$43,$ff
1064 : 08 > php ;save flags
1065 : c967 > cmp #$aa-$43 ;test result
> trap_ne
1067 : d0fe > bne * ;failed not equal (non zero)
>
1069 : 68 > pla ;load status
106a : 48 > pha
> cmp_flag $ff
106b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
106d : d0fe > bne * ;failed not equal (non zero)
>
106f : 28 > plp ;restore status
>
1070 : c042 > cpy #$42
> trap_ne ;y changed
1072 : d0fe > bne * ;failed not equal (non zero)
>
1074 : e000 > cpx #0
> trap_ne ;x changed
1076 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $53,1
1078 : a042 > ldy #$42
107a : a203 > ldx #4-1
107c : 53 > db $53 ;test nop length
> if 1 = 1
107d : ca > dex
107e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
107f : ca > dex
> trap_ne ;wrong number of bytes
1080 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$53,0
> load_flag 0
1082 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1084 : 48 > pha ;use stack to load status
1085 : a9ac > lda #$ff-$53 ;precharge accu
1087 : 28 > plp
>
1088 : 53 > db $53 ;test nop integrity - flags off
1089 : ea > nop
108a : ea > nop
> tst_a $ff-$53,0
108b : 08 > php ;save flags
108c : c9ac > cmp #$ff-$53 ;test result
> trap_ne
108e : d0fe > bne * ;failed not equal (non zero)
>
1090 : 68 > pla ;load status
1091 : 48 > pha
> cmp_flag 0
1092 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1094 : d0fe > bne * ;failed not equal (non zero)
>
1096 : 28 > plp ;restore status
>
> set_a $aa-$53,$ff
> load_flag $ff
1097 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1099 : 48 > pha ;use stack to load status
109a : a957 > lda #$aa-$53 ;precharge accu
109c : 28 > plp
>
109d : 53 > db $53 ;test nop integrity - flags on
109e : ea > nop
109f : ea > nop
> tst_a $aa-$53,$ff
10a0 : 08 > php ;save flags
10a1 : c957 > cmp #$aa-$53 ;test result
> trap_ne
10a3 : d0fe > bne * ;failed not equal (non zero)
>
10a5 : 68 > pla ;load status
10a6 : 48 > pha
> cmp_flag $ff
10a7 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10a9 : d0fe > bne * ;failed not equal (non zero)
>
10ab : 28 > plp ;restore status
>
10ac : c042 > cpy #$42
> trap_ne ;y changed
10ae : d0fe > bne * ;failed not equal (non zero)
>
10b0 : e000 > cpx #0
> trap_ne ;x changed
10b2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $63,1
10b4 : a042 > ldy #$42
10b6 : a203 > ldx #4-1
10b8 : 63 > db $63 ;test nop length
> if 1 = 1
10b9 : ca > dex
10ba : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
10bb : ca > dex
> trap_ne ;wrong number of bytes
10bc : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$63,0
> load_flag 0
10be : a900 > lda #0 ;allow test to change I-flag (no mask)
>
10c0 : 48 > pha ;use stack to load status
10c1 : a99c > lda #$ff-$63 ;precharge accu
10c3 : 28 > plp
>
10c4 : 63 > db $63 ;test nop integrity - flags off
10c5 : ea > nop
10c6 : ea > nop
> tst_a $ff-$63,0
10c7 : 08 > php ;save flags
10c8 : c99c > cmp #$ff-$63 ;test result
> trap_ne
10ca : d0fe > bne * ;failed not equal (non zero)
>
10cc : 68 > pla ;load status
10cd : 48 > pha
> cmp_flag 0
10ce : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10d0 : d0fe > bne * ;failed not equal (non zero)
>
10d2 : 28 > plp ;restore status
>
> set_a $aa-$63,$ff
> load_flag $ff
10d3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
10d5 : 48 > pha ;use stack to load status
10d6 : a947 > lda #$aa-$63 ;precharge accu
10d8 : 28 > plp
>
10d9 : 63 > db $63 ;test nop integrity - flags on
10da : ea > nop
10db : ea > nop
> tst_a $aa-$63,$ff
10dc : 08 > php ;save flags
10dd : c947 > cmp #$aa-$63 ;test result
> trap_ne
10df : d0fe > bne * ;failed not equal (non zero)
>
10e1 : 68 > pla ;load status
10e2 : 48 > pha
> cmp_flag $ff
10e3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
10e5 : d0fe > bne * ;failed not equal (non zero)
>
10e7 : 28 > plp ;restore status
>
10e8 : c042 > cpy #$42
> trap_ne ;y changed
10ea : d0fe > bne * ;failed not equal (non zero)
>
10ec : e000 > cpx #0
> trap_ne ;x changed
10ee : d0fe > bne * ;failed not equal (non zero)
>
nop_test $73,1
10f0 : a042 > ldy #$42
10f2 : a203 > ldx #4-1
10f4 : 73 > db $73 ;test nop length
> if 1 = 1
10f5 : ca > dex
10f6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
10f7 : ca > dex
> trap_ne ;wrong number of bytes
10f8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$73,0
> load_flag 0
10fa : a900 > lda #0 ;allow test to change I-flag (no mask)
>
10fc : 48 > pha ;use stack to load status
10fd : a98c > lda #$ff-$73 ;precharge accu
10ff : 28 > plp
>
1100 : 73 > db $73 ;test nop integrity - flags off
1101 : ea > nop
1102 : ea > nop
> tst_a $ff-$73,0
1103 : 08 > php ;save flags
1104 : c98c > cmp #$ff-$73 ;test result
> trap_ne
1106 : d0fe > bne * ;failed not equal (non zero)
>
1108 : 68 > pla ;load status
1109 : 48 > pha
> cmp_flag 0
110a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
110c : d0fe > bne * ;failed not equal (non zero)
>
110e : 28 > plp ;restore status
>
> set_a $aa-$73,$ff
> load_flag $ff
110f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1111 : 48 > pha ;use stack to load status
1112 : a937 > lda #$aa-$73 ;precharge accu
1114 : 28 > plp
>
1115 : 73 > db $73 ;test nop integrity - flags on
1116 : ea > nop
1117 : ea > nop
> tst_a $aa-$73,$ff
1118 : 08 > php ;save flags
1119 : c937 > cmp #$aa-$73 ;test result
> trap_ne
111b : d0fe > bne * ;failed not equal (non zero)
>
111d : 68 > pla ;load status
111e : 48 > pha
> cmp_flag $ff
111f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1121 : d0fe > bne * ;failed not equal (non zero)
>
1123 : 28 > plp ;restore status
>
1124 : c042 > cpy #$42
> trap_ne ;y changed
1126 : d0fe > bne * ;failed not equal (non zero)
>
1128 : e000 > cpx #0
> trap_ne ;x changed
112a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $83,1
112c : a042 > ldy #$42
112e : a203 > ldx #4-1
1130 : 83 > db $83 ;test nop length
> if 1 = 1
1131 : ca > dex
1132 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1133 : ca > dex
> trap_ne ;wrong number of bytes
1134 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$83,0
> load_flag 0
1136 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1138 : 48 > pha ;use stack to load status
1139 : a97c > lda #$ff-$83 ;precharge accu
113b : 28 > plp
>
113c : 83 > db $83 ;test nop integrity - flags off
113d : ea > nop
113e : ea > nop
> tst_a $ff-$83,0
113f : 08 > php ;save flags
1140 : c97c > cmp #$ff-$83 ;test result
> trap_ne
1142 : d0fe > bne * ;failed not equal (non zero)
>
1144 : 68 > pla ;load status
1145 : 48 > pha
> cmp_flag 0
1146 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1148 : d0fe > bne * ;failed not equal (non zero)
>
114a : 28 > plp ;restore status
>
> set_a $aa-$83,$ff
> load_flag $ff
114b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
114d : 48 > pha ;use stack to load status
114e : a927 > lda #$aa-$83 ;precharge accu
1150 : 28 > plp
>
1151 : 83 > db $83 ;test nop integrity - flags on
1152 : ea > nop
1153 : ea > nop
> tst_a $aa-$83,$ff
1154 : 08 > php ;save flags
1155 : c927 > cmp #$aa-$83 ;test result
> trap_ne
1157 : d0fe > bne * ;failed not equal (non zero)
>
1159 : 68 > pla ;load status
115a : 48 > pha
> cmp_flag $ff
115b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
115d : d0fe > bne * ;failed not equal (non zero)
>
115f : 28 > plp ;restore status
>
1160 : c042 > cpy #$42
> trap_ne ;y changed
1162 : d0fe > bne * ;failed not equal (non zero)
>
1164 : e000 > cpx #0
> trap_ne ;x changed
1166 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $93,1
1168 : a042 > ldy #$42
116a : a203 > ldx #4-1
116c : 93 > db $93 ;test nop length
> if 1 = 1
116d : ca > dex
116e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
116f : ca > dex
> trap_ne ;wrong number of bytes
1170 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$93,0
> load_flag 0
1172 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1174 : 48 > pha ;use stack to load status
1175 : a96c > lda #$ff-$93 ;precharge accu
1177 : 28 > plp
>
1178 : 93 > db $93 ;test nop integrity - flags off
1179 : ea > nop
117a : ea > nop
> tst_a $ff-$93,0
117b : 08 > php ;save flags
117c : c96c > cmp #$ff-$93 ;test result
> trap_ne
117e : d0fe > bne * ;failed not equal (non zero)
>
1180 : 68 > pla ;load status
1181 : 48 > pha
> cmp_flag 0
1182 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1184 : d0fe > bne * ;failed not equal (non zero)
>
1186 : 28 > plp ;restore status
>
> set_a $aa-$93,$ff
> load_flag $ff
1187 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1189 : 48 > pha ;use stack to load status
118a : a917 > lda #$aa-$93 ;precharge accu
118c : 28 > plp
>
118d : 93 > db $93 ;test nop integrity - flags on
118e : ea > nop
118f : ea > nop
> tst_a $aa-$93,$ff
1190 : 08 > php ;save flags
1191 : c917 > cmp #$aa-$93 ;test result
> trap_ne
1193 : d0fe > bne * ;failed not equal (non zero)
>
1195 : 68 > pla ;load status
1196 : 48 > pha
> cmp_flag $ff
1197 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1199 : d0fe > bne * ;failed not equal (non zero)
>
119b : 28 > plp ;restore status
>
119c : c042 > cpy #$42
> trap_ne ;y changed
119e : d0fe > bne * ;failed not equal (non zero)
>
11a0 : e000 > cpx #0
> trap_ne ;x changed
11a2 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $a3,1
11a4 : a042 > ldy #$42
11a6 : a203 > ldx #4-1
11a8 : a3 > db $a3 ;test nop length
> if 1 = 1
11a9 : ca > dex
11aa : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
11ab : ca > dex
> trap_ne ;wrong number of bytes
11ac : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$a3,0
> load_flag 0
11ae : a900 > lda #0 ;allow test to change I-flag (no mask)
>
11b0 : 48 > pha ;use stack to load status
11b1 : a95c > lda #$ff-$a3 ;precharge accu
11b3 : 28 > plp
>
11b4 : a3 > db $a3 ;test nop integrity - flags off
11b5 : ea > nop
11b6 : ea > nop
> tst_a $ff-$a3,0
11b7 : 08 > php ;save flags
11b8 : c95c > cmp #$ff-$a3 ;test result
> trap_ne
11ba : d0fe > bne * ;failed not equal (non zero)
>
11bc : 68 > pla ;load status
11bd : 48 > pha
> cmp_flag 0
11be : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
11c0 : d0fe > bne * ;failed not equal (non zero)
>
11c2 : 28 > plp ;restore status
>
> set_a $aa-$a3,$ff
> load_flag $ff
11c3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
11c5 : 48 > pha ;use stack to load status
11c6 : a907 > lda #$aa-$a3 ;precharge accu
11c8 : 28 > plp
>
11c9 : a3 > db $a3 ;test nop integrity - flags on
11ca : ea > nop
11cb : ea > nop
> tst_a $aa-$a3,$ff
11cc : 08 > php ;save flags
11cd : c907 > cmp #$aa-$a3 ;test result
> trap_ne
11cf : d0fe > bne * ;failed not equal (non zero)
>
11d1 : 68 > pla ;load status
11d2 : 48 > pha
> cmp_flag $ff
11d3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
11d5 : d0fe > bne * ;failed not equal (non zero)
>
11d7 : 28 > plp ;restore status
>
11d8 : c042 > cpy #$42
> trap_ne ;y changed
11da : d0fe > bne * ;failed not equal (non zero)
>
11dc : e000 > cpx #0
> trap_ne ;x changed
11de : d0fe > bne * ;failed not equal (non zero)
>
nop_test $b3,1
11e0 : a042 > ldy #$42
11e2 : a203 > ldx #4-1
11e4 : b3 > db $b3 ;test nop length
> if 1 = 1
11e5 : ca > dex
11e6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
11e7 : ca > dex
> trap_ne ;wrong number of bytes
11e8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$b3,0
> load_flag 0
11ea : a900 > lda #0 ;allow test to change I-flag (no mask)
>
11ec : 48 > pha ;use stack to load status
11ed : a94c > lda #$ff-$b3 ;precharge accu
11ef : 28 > plp
>
11f0 : b3 > db $b3 ;test nop integrity - flags off
11f1 : ea > nop
11f2 : ea > nop
> tst_a $ff-$b3,0
11f3 : 08 > php ;save flags
11f4 : c94c > cmp #$ff-$b3 ;test result
> trap_ne
11f6 : d0fe > bne * ;failed not equal (non zero)
>
11f8 : 68 > pla ;load status
11f9 : 48 > pha
> cmp_flag 0
11fa : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
11fc : d0fe > bne * ;failed not equal (non zero)
>
11fe : 28 > plp ;restore status
>
> set_a $aa-$b3,$ff
> load_flag $ff
11ff : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1201 : 48 > pha ;use stack to load status
1202 : a9f7 > lda #$aa-$b3 ;precharge accu
1204 : 28 > plp
>
1205 : b3 > db $b3 ;test nop integrity - flags on
1206 : ea > nop
1207 : ea > nop
> tst_a $aa-$b3,$ff
1208 : 08 > php ;save flags
1209 : c9f7 > cmp #$aa-$b3 ;test result
> trap_ne
120b : d0fe > bne * ;failed not equal (non zero)
>
120d : 68 > pla ;load status
120e : 48 > pha
> cmp_flag $ff
120f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1211 : d0fe > bne * ;failed not equal (non zero)
>
1213 : 28 > plp ;restore status
>
1214 : c042 > cpy #$42
> trap_ne ;y changed
1216 : d0fe > bne * ;failed not equal (non zero)
>
1218 : e000 > cpx #0
> trap_ne ;x changed
121a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $c3,1
121c : a042 > ldy #$42
121e : a203 > ldx #4-1
1220 : c3 > db $c3 ;test nop length
> if 1 = 1
1221 : ca > dex
1222 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1223 : ca > dex
> trap_ne ;wrong number of bytes
1224 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$c3,0
> load_flag 0
1226 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1228 : 48 > pha ;use stack to load status
1229 : a93c > lda #$ff-$c3 ;precharge accu
122b : 28 > plp
>
122c : c3 > db $c3 ;test nop integrity - flags off
122d : ea > nop
122e : ea > nop
> tst_a $ff-$c3,0
122f : 08 > php ;save flags
1230 : c93c > cmp #$ff-$c3 ;test result
> trap_ne
1232 : d0fe > bne * ;failed not equal (non zero)
>
1234 : 68 > pla ;load status
1235 : 48 > pha
> cmp_flag 0
1236 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1238 : d0fe > bne * ;failed not equal (non zero)
>
123a : 28 > plp ;restore status
>
> set_a $aa-$c3,$ff
> load_flag $ff
123b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
123d : 48 > pha ;use stack to load status
123e : a9e7 > lda #$aa-$c3 ;precharge accu
1240 : 28 > plp
>
1241 : c3 > db $c3 ;test nop integrity - flags on
1242 : ea > nop
1243 : ea > nop
> tst_a $aa-$c3,$ff
1244 : 08 > php ;save flags
1245 : c9e7 > cmp #$aa-$c3 ;test result
> trap_ne
1247 : d0fe > bne * ;failed not equal (non zero)
>
1249 : 68 > pla ;load status
124a : 48 > pha
> cmp_flag $ff
124b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
124d : d0fe > bne * ;failed not equal (non zero)
>
124f : 28 > plp ;restore status
>
1250 : c042 > cpy #$42
> trap_ne ;y changed
1252 : d0fe > bne * ;failed not equal (non zero)
>
1254 : e000 > cpx #0
> trap_ne ;x changed
1256 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $d3,1
1258 : a042 > ldy #$42
125a : a203 > ldx #4-1
125c : d3 > db $d3 ;test nop length
> if 1 = 1
125d : ca > dex
125e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
125f : ca > dex
> trap_ne ;wrong number of bytes
1260 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$d3,0
> load_flag 0
1262 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1264 : 48 > pha ;use stack to load status
1265 : a92c > lda #$ff-$d3 ;precharge accu
1267 : 28 > plp
>
1268 : d3 > db $d3 ;test nop integrity - flags off
1269 : ea > nop
126a : ea > nop
> tst_a $ff-$d3,0
126b : 08 > php ;save flags
126c : c92c > cmp #$ff-$d3 ;test result
> trap_ne
126e : d0fe > bne * ;failed not equal (non zero)
>
1270 : 68 > pla ;load status
1271 : 48 > pha
> cmp_flag 0
1272 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1274 : d0fe > bne * ;failed not equal (non zero)
>
1276 : 28 > plp ;restore status
>
> set_a $aa-$d3,$ff
> load_flag $ff
1277 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1279 : 48 > pha ;use stack to load status
127a : a9d7 > lda #$aa-$d3 ;precharge accu
127c : 28 > plp
>
127d : d3 > db $d3 ;test nop integrity - flags on
127e : ea > nop
127f : ea > nop
> tst_a $aa-$d3,$ff
1280 : 08 > php ;save flags
1281 : c9d7 > cmp #$aa-$d3 ;test result
> trap_ne
1283 : d0fe > bne * ;failed not equal (non zero)
>
1285 : 68 > pla ;load status
1286 : 48 > pha
> cmp_flag $ff
1287 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1289 : d0fe > bne * ;failed not equal (non zero)
>
128b : 28 > plp ;restore status
>
128c : c042 > cpy #$42
> trap_ne ;y changed
128e : d0fe > bne * ;failed not equal (non zero)
>
1290 : e000 > cpx #0
> trap_ne ;x changed
1292 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $e3,1
1294 : a042 > ldy #$42
1296 : a203 > ldx #4-1
1298 : e3 > db $e3 ;test nop length
> if 1 = 1
1299 : ca > dex
129a : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
129b : ca > dex
> trap_ne ;wrong number of bytes
129c : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$e3,0
> load_flag 0
129e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
12a0 : 48 > pha ;use stack to load status
12a1 : a91c > lda #$ff-$e3 ;precharge accu
12a3 : 28 > plp
>
12a4 : e3 > db $e3 ;test nop integrity - flags off
12a5 : ea > nop
12a6 : ea > nop
> tst_a $ff-$e3,0
12a7 : 08 > php ;save flags
12a8 : c91c > cmp #$ff-$e3 ;test result
> trap_ne
12aa : d0fe > bne * ;failed not equal (non zero)
>
12ac : 68 > pla ;load status
12ad : 48 > pha
> cmp_flag 0
12ae : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
12b0 : d0fe > bne * ;failed not equal (non zero)
>
12b2 : 28 > plp ;restore status
>
> set_a $aa-$e3,$ff
> load_flag $ff
12b3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
12b5 : 48 > pha ;use stack to load status
12b6 : a9c7 > lda #$aa-$e3 ;precharge accu
12b8 : 28 > plp
>
12b9 : e3 > db $e3 ;test nop integrity - flags on
12ba : ea > nop
12bb : ea > nop
> tst_a $aa-$e3,$ff
12bc : 08 > php ;save flags
12bd : c9c7 > cmp #$aa-$e3 ;test result
> trap_ne
12bf : d0fe > bne * ;failed not equal (non zero)
>
12c1 : 68 > pla ;load status
12c2 : 48 > pha
> cmp_flag $ff
12c3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
12c5 : d0fe > bne * ;failed not equal (non zero)
>
12c7 : 28 > plp ;restore status
>
12c8 : c042 > cpy #$42
> trap_ne ;y changed
12ca : d0fe > bne * ;failed not equal (non zero)
>
12cc : e000 > cpx #0
> trap_ne ;x changed
12ce : d0fe > bne * ;failed not equal (non zero)
>
nop_test $f3,1
12d0 : a042 > ldy #$42
12d2 : a203 > ldx #4-1
12d4 : f3 > db $f3 ;test nop length
> if 1 = 1
12d5 : ca > dex
12d6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
12d7 : ca > dex
> trap_ne ;wrong number of bytes
12d8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$f3,0
> load_flag 0
12da : a900 > lda #0 ;allow test to change I-flag (no mask)
>
12dc : 48 > pha ;use stack to load status
12dd : a90c > lda #$ff-$f3 ;precharge accu
12df : 28 > plp
>
12e0 : f3 > db $f3 ;test nop integrity - flags off
12e1 : ea > nop
12e2 : ea > nop
> tst_a $ff-$f3,0
12e3 : 08 > php ;save flags
12e4 : c90c > cmp #$ff-$f3 ;test result
> trap_ne
12e6 : d0fe > bne * ;failed not equal (non zero)
>
12e8 : 68 > pla ;load status
12e9 : 48 > pha
> cmp_flag 0
12ea : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
12ec : d0fe > bne * ;failed not equal (non zero)
>
12ee : 28 > plp ;restore status
>
> set_a $aa-$f3,$ff
> load_flag $ff
12ef : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
12f1 : 48 > pha ;use stack to load status
12f2 : a9b7 > lda #$aa-$f3 ;precharge accu
12f4 : 28 > plp
>
12f5 : f3 > db $f3 ;test nop integrity - flags on
12f6 : ea > nop
12f7 : ea > nop
> tst_a $aa-$f3,$ff
12f8 : 08 > php ;save flags
12f9 : c9b7 > cmp #$aa-$f3 ;test result
> trap_ne
12fb : d0fe > bne * ;failed not equal (non zero)
>
12fd : 68 > pla ;load status
12fe : 48 > pha
> cmp_flag $ff
12ff : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1301 : d0fe > bne * ;failed not equal (non zero)
>
1303 : 28 > plp ;restore status
>
1304 : c042 > cpy #$42
> trap_ne ;y changed
1306 : d0fe > bne * ;failed not equal (non zero)
>
1308 : e000 > cpx #0
> trap_ne ;x changed
130a : d0fe > bne * ;failed not equal (non zero)
>
nop_test $0b,1
130c : a042 > ldy #$42
130e : a203 > ldx #4-1
1310 : 0b > db $0b ;test nop length
> if 1 = 1
1311 : ca > dex
1312 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1313 : ca > dex
> trap_ne ;wrong number of bytes
1314 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$0b,0
> load_flag 0
1316 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1318 : 48 > pha ;use stack to load status
1319 : a9f4 > lda #$ff-$0b ;precharge accu
131b : 28 > plp
>
131c : 0b > db $0b ;test nop integrity - flags off
131d : ea > nop
131e : ea > nop
> tst_a $ff-$0b,0
131f : 08 > php ;save flags
1320 : c9f4 > cmp #$ff-$0b ;test result
> trap_ne
1322 : d0fe > bne * ;failed not equal (non zero)
>
1324 : 68 > pla ;load status
1325 : 48 > pha
> cmp_flag 0
1326 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1328 : d0fe > bne * ;failed not equal (non zero)
>
132a : 28 > plp ;restore status
>
> set_a $aa-$0b,$ff
> load_flag $ff
132b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
132d : 48 > pha ;use stack to load status
132e : a99f > lda #$aa-$0b ;precharge accu
1330 : 28 > plp
>
1331 : 0b > db $0b ;test nop integrity - flags on
1332 : ea > nop
1333 : ea > nop
> tst_a $aa-$0b,$ff
1334 : 08 > php ;save flags
1335 : c99f > cmp #$aa-$0b ;test result
> trap_ne
1337 : d0fe > bne * ;failed not equal (non zero)
>
1339 : 68 > pla ;load status
133a : 48 > pha
> cmp_flag $ff
133b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
133d : d0fe > bne * ;failed not equal (non zero)
>
133f : 28 > plp ;restore status
>
1340 : c042 > cpy #$42
> trap_ne ;y changed
1342 : d0fe > bne * ;failed not equal (non zero)
>
1344 : e000 > cpx #0
> trap_ne ;x changed
1346 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $1b,1
1348 : a042 > ldy #$42
134a : a203 > ldx #4-1
134c : 1b > db $1b ;test nop length
> if 1 = 1
134d : ca > dex
134e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
134f : ca > dex
> trap_ne ;wrong number of bytes
1350 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$1b,0
> load_flag 0
1352 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1354 : 48 > pha ;use stack to load status
1355 : a9e4 > lda #$ff-$1b ;precharge accu
1357 : 28 > plp
>
1358 : 1b > db $1b ;test nop integrity - flags off
1359 : ea > nop
135a : ea > nop
> tst_a $ff-$1b,0
135b : 08 > php ;save flags
135c : c9e4 > cmp #$ff-$1b ;test result
> trap_ne
135e : d0fe > bne * ;failed not equal (non zero)
>
1360 : 68 > pla ;load status
1361 : 48 > pha
> cmp_flag 0
1362 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1364 : d0fe > bne * ;failed not equal (non zero)
>
1366 : 28 > plp ;restore status
>
> set_a $aa-$1b,$ff
> load_flag $ff
1367 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1369 : 48 > pha ;use stack to load status
136a : a98f > lda #$aa-$1b ;precharge accu
136c : 28 > plp
>
136d : 1b > db $1b ;test nop integrity - flags on
136e : ea > nop
136f : ea > nop
> tst_a $aa-$1b,$ff
1370 : 08 > php ;save flags
1371 : c98f > cmp #$aa-$1b ;test result
> trap_ne
1373 : d0fe > bne * ;failed not equal (non zero)
>
1375 : 68 > pla ;load status
1376 : 48 > pha
> cmp_flag $ff
1377 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1379 : d0fe > bne * ;failed not equal (non zero)
>
137b : 28 > plp ;restore status
>
137c : c042 > cpy #$42
> trap_ne ;y changed
137e : d0fe > bne * ;failed not equal (non zero)
>
1380 : e000 > cpx #0
> trap_ne ;x changed
1382 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $2b,1
1384 : a042 > ldy #$42
1386 : a203 > ldx #4-1
1388 : 2b > db $2b ;test nop length
> if 1 = 1
1389 : ca > dex
138a : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
138b : ca > dex
> trap_ne ;wrong number of bytes
138c : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$2b,0
> load_flag 0
138e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1390 : 48 > pha ;use stack to load status
1391 : a9d4 > lda #$ff-$2b ;precharge accu
1393 : 28 > plp
>
1394 : 2b > db $2b ;test nop integrity - flags off
1395 : ea > nop
1396 : ea > nop
> tst_a $ff-$2b,0
1397 : 08 > php ;save flags
1398 : c9d4 > cmp #$ff-$2b ;test result
> trap_ne
139a : d0fe > bne * ;failed not equal (non zero)
>
139c : 68 > pla ;load status
139d : 48 > pha
> cmp_flag 0
139e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
13a0 : d0fe > bne * ;failed not equal (non zero)
>
13a2 : 28 > plp ;restore status
>
> set_a $aa-$2b,$ff
> load_flag $ff
13a3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
13a5 : 48 > pha ;use stack to load status
13a6 : a97f > lda #$aa-$2b ;precharge accu
13a8 : 28 > plp
>
13a9 : 2b > db $2b ;test nop integrity - flags on
13aa : ea > nop
13ab : ea > nop
> tst_a $aa-$2b,$ff
13ac : 08 > php ;save flags
13ad : c97f > cmp #$aa-$2b ;test result
> trap_ne
13af : d0fe > bne * ;failed not equal (non zero)
>
13b1 : 68 > pla ;load status
13b2 : 48 > pha
> cmp_flag $ff
13b3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
13b5 : d0fe > bne * ;failed not equal (non zero)
>
13b7 : 28 > plp ;restore status
>
13b8 : c042 > cpy #$42
> trap_ne ;y changed
13ba : d0fe > bne * ;failed not equal (non zero)
>
13bc : e000 > cpx #0
> trap_ne ;x changed
13be : d0fe > bne * ;failed not equal (non zero)
>
nop_test $3b,1
13c0 : a042 > ldy #$42
13c2 : a203 > ldx #4-1
13c4 : 3b > db $3b ;test nop length
> if 1 = 1
13c5 : ca > dex
13c6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
13c7 : ca > dex
> trap_ne ;wrong number of bytes
13c8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$3b,0
> load_flag 0
13ca : a900 > lda #0 ;allow test to change I-flag (no mask)
>
13cc : 48 > pha ;use stack to load status
13cd : a9c4 > lda #$ff-$3b ;precharge accu
13cf : 28 > plp
>
13d0 : 3b > db $3b ;test nop integrity - flags off
13d1 : ea > nop
13d2 : ea > nop
> tst_a $ff-$3b,0
13d3 : 08 > php ;save flags
13d4 : c9c4 > cmp #$ff-$3b ;test result
> trap_ne
13d6 : d0fe > bne * ;failed not equal (non zero)
>
13d8 : 68 > pla ;load status
13d9 : 48 > pha
> cmp_flag 0
13da : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
13dc : d0fe > bne * ;failed not equal (non zero)
>
13de : 28 > plp ;restore status
>
> set_a $aa-$3b,$ff
> load_flag $ff
13df : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
13e1 : 48 > pha ;use stack to load status
13e2 : a96f > lda #$aa-$3b ;precharge accu
13e4 : 28 > plp
>
13e5 : 3b > db $3b ;test nop integrity - flags on
13e6 : ea > nop
13e7 : ea > nop
> tst_a $aa-$3b,$ff
13e8 : 08 > php ;save flags
13e9 : c96f > cmp #$aa-$3b ;test result
> trap_ne
13eb : d0fe > bne * ;failed not equal (non zero)
>
13ed : 68 > pla ;load status
13ee : 48 > pha
> cmp_flag $ff
13ef : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
13f1 : d0fe > bne * ;failed not equal (non zero)
>
13f3 : 28 > plp ;restore status
>
13f4 : c042 > cpy #$42
> trap_ne ;y changed
13f6 : d0fe > bne * ;failed not equal (non zero)
>
13f8 : e000 > cpx #0
> trap_ne ;x changed
13fa : d0fe > bne * ;failed not equal (non zero)
>
nop_test $4b,1
13fc : a042 > ldy #$42
13fe : a203 > ldx #4-1
1400 : 4b > db $4b ;test nop length
> if 1 = 1
1401 : ca > dex
1402 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
1403 : ca > dex
> trap_ne ;wrong number of bytes
1404 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$4b,0
> load_flag 0
1406 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1408 : 48 > pha ;use stack to load status
1409 : a9b4 > lda #$ff-$4b ;precharge accu
140b : 28 > plp
>
140c : 4b > db $4b ;test nop integrity - flags off
140d : ea > nop
140e : ea > nop
> tst_a $ff-$4b,0
140f : 08 > php ;save flags
1410 : c9b4 > cmp #$ff-$4b ;test result
> trap_ne
1412 : d0fe > bne * ;failed not equal (non zero)
>
1414 : 68 > pla ;load status
1415 : 48 > pha
> cmp_flag 0
1416 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1418 : d0fe > bne * ;failed not equal (non zero)
>
141a : 28 > plp ;restore status
>
> set_a $aa-$4b,$ff
> load_flag $ff
141b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
141d : 48 > pha ;use stack to load status
141e : a95f > lda #$aa-$4b ;precharge accu
1420 : 28 > plp
>
1421 : 4b > db $4b ;test nop integrity - flags on
1422 : ea > nop
1423 : ea > nop
> tst_a $aa-$4b,$ff
1424 : 08 > php ;save flags
1425 : c95f > cmp #$aa-$4b ;test result
> trap_ne
1427 : d0fe > bne * ;failed not equal (non zero)
>
1429 : 68 > pla ;load status
142a : 48 > pha
> cmp_flag $ff
142b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
142d : d0fe > bne * ;failed not equal (non zero)
>
142f : 28 > plp ;restore status
>
1430 : c042 > cpy #$42
> trap_ne ;y changed
1432 : d0fe > bne * ;failed not equal (non zero)
>
1434 : e000 > cpx #0
> trap_ne ;x changed
1436 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $5b,1
1438 : a042 > ldy #$42
143a : a203 > ldx #4-1
143c : 5b > db $5b ;test nop length
> if 1 = 1
143d : ca > dex
143e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
143f : ca > dex
> trap_ne ;wrong number of bytes
1440 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$5b,0
> load_flag 0
1442 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1444 : 48 > pha ;use stack to load status
1445 : a9a4 > lda #$ff-$5b ;precharge accu
1447 : 28 > plp
>
1448 : 5b > db $5b ;test nop integrity - flags off
1449 : ea > nop
144a : ea > nop
> tst_a $ff-$5b,0
144b : 08 > php ;save flags
144c : c9a4 > cmp #$ff-$5b ;test result
> trap_ne
144e : d0fe > bne * ;failed not equal (non zero)
>
1450 : 68 > pla ;load status
1451 : 48 > pha
> cmp_flag 0
1452 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1454 : d0fe > bne * ;failed not equal (non zero)
>
1456 : 28 > plp ;restore status
>
> set_a $aa-$5b,$ff
> load_flag $ff
1457 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1459 : 48 > pha ;use stack to load status
145a : a94f > lda #$aa-$5b ;precharge accu
145c : 28 > plp
>
145d : 5b > db $5b ;test nop integrity - flags on
145e : ea > nop
145f : ea > nop
> tst_a $aa-$5b,$ff
1460 : 08 > php ;save flags
1461 : c94f > cmp #$aa-$5b ;test result
> trap_ne
1463 : d0fe > bne * ;failed not equal (non zero)
>
1465 : 68 > pla ;load status
1466 : 48 > pha
> cmp_flag $ff
1467 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1469 : d0fe > bne * ;failed not equal (non zero)
>
146b : 28 > plp ;restore status
>
146c : c042 > cpy #$42
> trap_ne ;y changed
146e : d0fe > bne * ;failed not equal (non zero)
>
1470 : e000 > cpx #0
> trap_ne ;x changed
1472 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $6b,1
1474 : a042 > ldy #$42
1476 : a203 > ldx #4-1
1478 : 6b > db $6b ;test nop length
> if 1 = 1
1479 : ca > dex
147a : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
147b : ca > dex
> trap_ne ;wrong number of bytes
147c : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$6b,0
> load_flag 0
147e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1480 : 48 > pha ;use stack to load status
1481 : a994 > lda #$ff-$6b ;precharge accu
1483 : 28 > plp
>
1484 : 6b > db $6b ;test nop integrity - flags off
1485 : ea > nop
1486 : ea > nop
> tst_a $ff-$6b,0
1487 : 08 > php ;save flags
1488 : c994 > cmp #$ff-$6b ;test result
> trap_ne
148a : d0fe > bne * ;failed not equal (non zero)
>
148c : 68 > pla ;load status
148d : 48 > pha
> cmp_flag 0
148e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1490 : d0fe > bne * ;failed not equal (non zero)
>
1492 : 28 > plp ;restore status
>
> set_a $aa-$6b,$ff
> load_flag $ff
1493 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1495 : 48 > pha ;use stack to load status
1496 : a93f > lda #$aa-$6b ;precharge accu
1498 : 28 > plp
>
1499 : 6b > db $6b ;test nop integrity - flags on
149a : ea > nop
149b : ea > nop
> tst_a $aa-$6b,$ff
149c : 08 > php ;save flags
149d : c93f > cmp #$aa-$6b ;test result
> trap_ne
149f : d0fe > bne * ;failed not equal (non zero)
>
14a1 : 68 > pla ;load status
14a2 : 48 > pha
> cmp_flag $ff
14a3 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
14a5 : d0fe > bne * ;failed not equal (non zero)
>
14a7 : 28 > plp ;restore status
>
14a8 : c042 > cpy #$42
> trap_ne ;y changed
14aa : d0fe > bne * ;failed not equal (non zero)
>
14ac : e000 > cpx #0
> trap_ne ;x changed
14ae : d0fe > bne * ;failed not equal (non zero)
>
nop_test $7b,1
14b0 : a042 > ldy #$42
14b2 : a203 > ldx #4-1
14b4 : 7b > db $7b ;test nop length
> if 1 = 1
14b5 : ca > dex
14b6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
14b7 : ca > dex
> trap_ne ;wrong number of bytes
14b8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$7b,0
> load_flag 0
14ba : a900 > lda #0 ;allow test to change I-flag (no mask)
>
14bc : 48 > pha ;use stack to load status
14bd : a984 > lda #$ff-$7b ;precharge accu
14bf : 28 > plp
>
14c0 : 7b > db $7b ;test nop integrity - flags off
14c1 : ea > nop
14c2 : ea > nop
> tst_a $ff-$7b,0
14c3 : 08 > php ;save flags
14c4 : c984 > cmp #$ff-$7b ;test result
> trap_ne
14c6 : d0fe > bne * ;failed not equal (non zero)
>
14c8 : 68 > pla ;load status
14c9 : 48 > pha
> cmp_flag 0
14ca : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
14cc : d0fe > bne * ;failed not equal (non zero)
>
14ce : 28 > plp ;restore status
>
> set_a $aa-$7b,$ff
> load_flag $ff
14cf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
14d1 : 48 > pha ;use stack to load status
14d2 : a92f > lda #$aa-$7b ;precharge accu
14d4 : 28 > plp
>
14d5 : 7b > db $7b ;test nop integrity - flags on
14d6 : ea > nop
14d7 : ea > nop
> tst_a $aa-$7b,$ff
14d8 : 08 > php ;save flags
14d9 : c92f > cmp #$aa-$7b ;test result
> trap_ne
14db : d0fe > bne * ;failed not equal (non zero)
>
14dd : 68 > pla ;load status
14de : 48 > pha
> cmp_flag $ff
14df : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
14e1 : d0fe > bne * ;failed not equal (non zero)
>
14e3 : 28 > plp ;restore status
>
14e4 : c042 > cpy #$42
> trap_ne ;y changed
14e6 : d0fe > bne * ;failed not equal (non zero)
>
14e8 : e000 > cpx #0
> trap_ne ;x changed
14ea : d0fe > bne * ;failed not equal (non zero)
>
nop_test $8b,1
14ec : a042 > ldy #$42
14ee : a203 > ldx #4-1
14f0 : 8b > db $8b ;test nop length
> if 1 = 1
14f1 : ca > dex
14f2 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
14f3 : ca > dex
> trap_ne ;wrong number of bytes
14f4 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$8b,0
> load_flag 0
14f6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
14f8 : 48 > pha ;use stack to load status
14f9 : a974 > lda #$ff-$8b ;precharge accu
14fb : 28 > plp
>
14fc : 8b > db $8b ;test nop integrity - flags off
14fd : ea > nop
14fe : ea > nop
> tst_a $ff-$8b,0
14ff : 08 > php ;save flags
1500 : c974 > cmp #$ff-$8b ;test result
> trap_ne
1502 : d0fe > bne * ;failed not equal (non zero)
>
1504 : 68 > pla ;load status
1505 : 48 > pha
> cmp_flag 0
1506 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1508 : d0fe > bne * ;failed not equal (non zero)
>
150a : 28 > plp ;restore status
>
> set_a $aa-$8b,$ff
> load_flag $ff
150b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
150d : 48 > pha ;use stack to load status
150e : a91f > lda #$aa-$8b ;precharge accu
1510 : 28 > plp
>
1511 : 8b > db $8b ;test nop integrity - flags on
1512 : ea > nop
1513 : ea > nop
> tst_a $aa-$8b,$ff
1514 : 08 > php ;save flags
1515 : c91f > cmp #$aa-$8b ;test result
> trap_ne
1517 : d0fe > bne * ;failed not equal (non zero)
>
1519 : 68 > pla ;load status
151a : 48 > pha
> cmp_flag $ff
151b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
151d : d0fe > bne * ;failed not equal (non zero)
>
151f : 28 > plp ;restore status
>
1520 : c042 > cpy #$42
> trap_ne ;y changed
1522 : d0fe > bne * ;failed not equal (non zero)
>
1524 : e000 > cpx #0
> trap_ne ;x changed
1526 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $9b,1
1528 : a042 > ldy #$42
152a : a203 > ldx #4-1
152c : 9b > db $9b ;test nop length
> if 1 = 1
152d : ca > dex
152e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
152f : ca > dex
> trap_ne ;wrong number of bytes
1530 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$9b,0
> load_flag 0
1532 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1534 : 48 > pha ;use stack to load status
1535 : a964 > lda #$ff-$9b ;precharge accu
1537 : 28 > plp
>
1538 : 9b > db $9b ;test nop integrity - flags off
1539 : ea > nop
153a : ea > nop
> tst_a $ff-$9b,0
153b : 08 > php ;save flags
153c : c964 > cmp #$ff-$9b ;test result
> trap_ne
153e : d0fe > bne * ;failed not equal (non zero)
>
1540 : 68 > pla ;load status
1541 : 48 > pha
> cmp_flag 0
1542 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1544 : d0fe > bne * ;failed not equal (non zero)
>
1546 : 28 > plp ;restore status
>
> set_a $aa-$9b,$ff
> load_flag $ff
1547 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1549 : 48 > pha ;use stack to load status
154a : a90f > lda #$aa-$9b ;precharge accu
154c : 28 > plp
>
154d : 9b > db $9b ;test nop integrity - flags on
154e : ea > nop
154f : ea > nop
> tst_a $aa-$9b,$ff
1550 : 08 > php ;save flags
1551 : c90f > cmp #$aa-$9b ;test result
> trap_ne
1553 : d0fe > bne * ;failed not equal (non zero)
>
1555 : 68 > pla ;load status
1556 : 48 > pha
> cmp_flag $ff
1557 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1559 : d0fe > bne * ;failed not equal (non zero)
>
155b : 28 > plp ;restore status
>
155c : c042 > cpy #$42
> trap_ne ;y changed
155e : d0fe > bne * ;failed not equal (non zero)
>
1560 : e000 > cpx #0
> trap_ne ;x changed
1562 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $ab,1
1564 : a042 > ldy #$42
1566 : a203 > ldx #4-1
1568 : ab > db $ab ;test nop length
> if 1 = 1
1569 : ca > dex
156a : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
156b : ca > dex
> trap_ne ;wrong number of bytes
156c : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$ab,0
> load_flag 0
156e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1570 : 48 > pha ;use stack to load status
1571 : a954 > lda #$ff-$ab ;precharge accu
1573 : 28 > plp
>
1574 : ab > db $ab ;test nop integrity - flags off
1575 : ea > nop
1576 : ea > nop
> tst_a $ff-$ab,0
1577 : 08 > php ;save flags
1578 : c954 > cmp #$ff-$ab ;test result
> trap_ne
157a : d0fe > bne * ;failed not equal (non zero)
>
157c : 68 > pla ;load status
157d : 48 > pha
> cmp_flag 0
157e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1580 : d0fe > bne * ;failed not equal (non zero)
>
1582 : 28 > plp ;restore status
>
> set_a $aa-$ab,$ff
> load_flag $ff
1583 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1585 : 48 > pha ;use stack to load status
1586 : a9ff > lda #$aa-$ab ;precharge accu
1588 : 28 > plp
>
1589 : ab > db $ab ;test nop integrity - flags on
158a : ea > nop
158b : ea > nop
> tst_a $aa-$ab,$ff
158c : 08 > php ;save flags
158d : c9ff > cmp #$aa-$ab ;test result
> trap_ne
158f : d0fe > bne * ;failed not equal (non zero)
>
1591 : 68 > pla ;load status
1592 : 48 > pha
> cmp_flag $ff
1593 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1595 : d0fe > bne * ;failed not equal (non zero)
>
1597 : 28 > plp ;restore status
>
1598 : c042 > cpy #$42
> trap_ne ;y changed
159a : d0fe > bne * ;failed not equal (non zero)
>
159c : e000 > cpx #0
> trap_ne ;x changed
159e : d0fe > bne * ;failed not equal (non zero)
>
nop_test $bb,1
15a0 : a042 > ldy #$42
15a2 : a203 > ldx #4-1
15a4 : bb > db $bb ;test nop length
> if 1 = 1
15a5 : ca > dex
15a6 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
15a7 : ca > dex
> trap_ne ;wrong number of bytes
15a8 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$bb,0
> load_flag 0
15aa : a900 > lda #0 ;allow test to change I-flag (no mask)
>
15ac : 48 > pha ;use stack to load status
15ad : a944 > lda #$ff-$bb ;precharge accu
15af : 28 > plp
>
15b0 : bb > db $bb ;test nop integrity - flags off
15b1 : ea > nop
15b2 : ea > nop
> tst_a $ff-$bb,0
15b3 : 08 > php ;save flags
15b4 : c944 > cmp #$ff-$bb ;test result
> trap_ne
15b6 : d0fe > bne * ;failed not equal (non zero)
>
15b8 : 68 > pla ;load status
15b9 : 48 > pha
> cmp_flag 0
15ba : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
15bc : d0fe > bne * ;failed not equal (non zero)
>
15be : 28 > plp ;restore status
>
> set_a $aa-$bb,$ff
> load_flag $ff
15bf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
15c1 : 48 > pha ;use stack to load status
15c2 : a9ef > lda #$aa-$bb ;precharge accu
15c4 : 28 > plp
>
15c5 : bb > db $bb ;test nop integrity - flags on
15c6 : ea > nop
15c7 : ea > nop
> tst_a $aa-$bb,$ff
15c8 : 08 > php ;save flags
15c9 : c9ef > cmp #$aa-$bb ;test result
> trap_ne
15cb : d0fe > bne * ;failed not equal (non zero)
>
15cd : 68 > pla ;load status
15ce : 48 > pha
> cmp_flag $ff
15cf : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
15d1 : d0fe > bne * ;failed not equal (non zero)
>
15d3 : 28 > plp ;restore status
>
15d4 : c042 > cpy #$42
> trap_ne ;y changed
15d6 : d0fe > bne * ;failed not equal (non zero)
>
15d8 : e000 > cpx #0
> trap_ne ;x changed
15da : d0fe > bne * ;failed not equal (non zero)
>
nop_test $eb,1
15dc : a042 > ldy #$42
15de : a203 > ldx #4-1
15e0 : eb > db $eb ;test nop length
> if 1 = 1
15e1 : ca > dex
15e2 : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
15e3 : ca > dex
> trap_ne ;wrong number of bytes
15e4 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$eb,0
> load_flag 0
15e6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
15e8 : 48 > pha ;use stack to load status
15e9 : a914 > lda #$ff-$eb ;precharge accu
15eb : 28 > plp
>
15ec : eb > db $eb ;test nop integrity - flags off
15ed : ea > nop
15ee : ea > nop
> tst_a $ff-$eb,0
15ef : 08 > php ;save flags
15f0 : c914 > cmp #$ff-$eb ;test result
> trap_ne
15f2 : d0fe > bne * ;failed not equal (non zero)
>
15f4 : 68 > pla ;load status
15f5 : 48 > pha
> cmp_flag 0
15f6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
15f8 : d0fe > bne * ;failed not equal (non zero)
>
15fa : 28 > plp ;restore status
>
> set_a $aa-$eb,$ff
> load_flag $ff
15fb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
15fd : 48 > pha ;use stack to load status
15fe : a9bf > lda #$aa-$eb ;precharge accu
1600 : 28 > plp
>
1601 : eb > db $eb ;test nop integrity - flags on
1602 : ea > nop
1603 : ea > nop
> tst_a $aa-$eb,$ff
1604 : 08 > php ;save flags
1605 : c9bf > cmp #$aa-$eb ;test result
> trap_ne
1607 : d0fe > bne * ;failed not equal (non zero)
>
1609 : 68 > pla ;load status
160a : 48 > pha
> cmp_flag $ff
160b : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
160d : d0fe > bne * ;failed not equal (non zero)
>
160f : 28 > plp ;restore status
>
1610 : c042 > cpy #$42
> trap_ne ;y changed
1612 : d0fe > bne * ;failed not equal (non zero)
>
1614 : e000 > cpx #0
> trap_ne ;x changed
1616 : d0fe > bne * ;failed not equal (non zero)
>
nop_test $fb,1
1618 : a042 > ldy #$42
161a : a203 > ldx #4-1
161c : fb > db $fb ;test nop length
> if 1 = 1
161d : ca > dex
161e : ca > dex
> endif
> if 1 = 2
> iny
> dex
> endif
> if 1 = 3
> iny
> iny
> endif
161f : ca > dex
> trap_ne ;wrong number of bytes
1620 : d0fe > bne * ;failed not equal (non zero)
>
> set_a $ff-$fb,0
> load_flag 0
1622 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1624 : 48 > pha ;use stack to load status
1625 : a904 > lda #$ff-$fb ;precharge accu
1627 : 28 > plp
>
1628 : fb > db $fb ;test nop integrity - flags off
1629 : ea > nop
162a : ea > nop
> tst_a $ff-$fb,0
162b : 08 > php ;save flags
162c : c904 > cmp #$ff-$fb ;test result
> trap_ne
162e : d0fe > bne * ;failed not equal (non zero)
>
1630 : 68 > pla ;load status
1631 : 48 > pha
> cmp_flag 0
1632 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1634 : d0fe > bne * ;failed not equal (non zero)
>
1636 : 28 > plp ;restore status
>
> set_a $aa-$fb,$ff
> load_flag $ff
1637 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1639 : 48 > pha ;use stack to load status
163a : a9af > lda #$aa-$fb ;precharge accu
163c : 28 > plp
>
163d : fb > db $fb ;test nop integrity - flags on
163e : ea > nop
163f : ea > nop
> tst_a $aa-$fb,$ff
1640 : 08 > php ;save flags
1641 : c9af > cmp #$aa-$fb ;test result
> trap_ne
1643 : d0fe > bne * ;failed not equal (non zero)
>
1645 : 68 > pla ;load status
1646 : 48 > pha
> cmp_flag $ff
1647 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1649 : d0fe > bne * ;failed not equal (non zero)
>
164b : 28 > plp ;restore status
>
164c : c042 > cpy #$42
> trap_ne ;y changed
164e : d0fe > bne * ;failed not equal (non zero)
>
1650 : e000 > cpx #0
> trap_ne ;x changed
1652 : d0fe > bne * ;failed not equal (non zero)
>
if rkwl_wdc_op = 0 ;NOPs not available on Rockwell & WDC 65C02
nop_test $07,1
nop_test $17,1
nop_test $27,1
nop_test $37,1
nop_test $47,1
nop_test $57,1
nop_test $67,1
nop_test $77,1
nop_test $87,1
nop_test $97,1
nop_test $a7,1
nop_test $b7,1
nop_test $c7,1
nop_test $d7,1
nop_test $e7,1
nop_test $f7,1
nop_test $0f,1
nop_test $1f,1
nop_test $2f,1
nop_test $3f,1
nop_test $4f,1
nop_test $5f,1
nop_test $6f,1
nop_test $7f,1
nop_test $8f,1
nop_test $9f,1
nop_test $af,1
nop_test $bf,1
nop_test $cf,1
nop_test $df,1
nop_test $ef,1
nop_test $ff,1
endif
if wdc_op = 0 ;NOPs not available on WDC 65C02 (WAI, STP)
nop_test $cb,1
nop_test $db,1
endif
next_test
1654 : ad0202 > lda test_case ;previous test
1657 : c908 > cmp #test_num
> trap_ne ;test is out of sequence
1659 : d0fe > bne * ;failed not equal (non zero)
>
0009 = >test_num = test_num + 1
165b : a909 > lda #test_num ;*** next tests' number
165d : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; jump indirect (test page cross bug is fixed)
1660 : a203 ldx #3 ;prepare table
1662 : bd4026 ji1 lda ji_adr,x
1665 : 9dfd02 sta ji_tab,x
1668 : ca dex
1669 : 10f7 bpl ji1
166b : a927 lda #hi(ji_px) ;high address if page cross bug
166d : 8d0002 sta pg_x
set_stat 0
> load_flag 0
1670 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1672 : 48 > pha ;use stack to load status
1673 : 28 > plp
1674 : a949 lda #'I'
1676 : a24e ldx #'N'
1678 : a044 ldy #'D' ;N=0, V=0, Z=0, C=0
167a : 6cfd02 jmp (ji_tab)
167d : ea nop
trap_ne ;runover protection
167e : d0fe > bne * ;failed not equal (non zero)
1680 : 88 dey
1681 : 88 dey
1682 : 08 ji_ret php ;either SP or Y count will fail, if we do not hit
1683 : 88 dey
1684 : 88 dey
1685 : 88 dey
1686 : 28 plp
trap_eq ;returned flags OK?
1687 : f0fe > beq * ;failed equal (zero)
trap_pl
1689 : 10fe > bpl * ;failed plus (bit 7 clear)
trap_cc
168b : 90fe > bcc * ;failed carry clear
trap_vc
168d : 50fe > bvc * ;failed overflow clear
168f : c9e3 cmp #('I'^$aa) ;returned registers OK?
trap_ne
1691 : d0fe > bne * ;failed not equal (non zero)
1693 : e04f cpx #('N'+1)
trap_ne
1695 : d0fe > bne * ;failed not equal (non zero)
1697 : c03e cpy #('D'-6)
trap_ne
1699 : d0fe > bne * ;failed not equal (non zero)
169b : ba tsx ;SP check
169c : e0ff cpx #$ff
trap_ne
169e : d0fe > bne * ;failed not equal (non zero)
next_test
16a0 : ad0202 > lda test_case ;previous test
16a3 : c909 > cmp #test_num
> trap_ne ;test is out of sequence
16a5 : d0fe > bne * ;failed not equal (non zero)
>
000a = >test_num = test_num + 1
16a7 : a90a > lda #test_num ;*** next tests' number
16a9 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; jump indexed indirect
16ac : a20b ldx #11 ;prepare table
16ae : bd7926 jxi1 lda jxi_adr,x
16b1 : 9df902 sta jxi_tab,x
16b4 : ca dex
16b5 : 10f7 bpl jxi1
16b7 : a927 lda #hi(jxi_px) ;high address if page cross bug
16b9 : 8d0002 sta pg_x
set_stat 0
> load_flag 0
16bc : a900 > lda #0 ;allow test to change I-flag (no mask)
>
16be : 48 > pha ;use stack to load status
16bf : 28 > plp
16c0 : a958 lda #'X'
16c2 : a204 ldx #4
16c4 : a049 ldy #'I' ;N=0, V=0, Z=0, C=0
16c6 : 7cf902 jmp (jxi_tab,x)
16c9 : ea nop
trap_ne ;runover protection
16ca : d0fe > bne * ;failed not equal (non zero)
16cc : 88 dey
16cd : 88 dey
16ce : 08 jxi_ret php ;either SP or Y count will fail, if we do not hit
16cf : 88 dey
16d0 : 88 dey
16d1 : 88 dey
16d2 : 28 plp
trap_eq ;returned flags OK?
16d3 : f0fe > beq * ;failed equal (zero)
trap_pl
16d5 : 10fe > bpl * ;failed plus (bit 7 clear)
trap_cc
16d7 : 90fe > bcc * ;failed carry clear
trap_vc
16d9 : 50fe > bvc * ;failed overflow clear
16db : c9f2 cmp #('X'^$aa) ;returned registers OK?
trap_ne
16dd : d0fe > bne * ;failed not equal (non zero)
16df : e006 cpx #6
trap_ne
16e1 : d0fe > bne * ;failed not equal (non zero)
16e3 : c043 cpy #('I'-6)
trap_ne
16e5 : d0fe > bne * ;failed not equal (non zero)
16e7 : ba tsx ;SP check
16e8 : e0ff cpx #$ff
trap_ne
16ea : d0fe > bne * ;failed not equal (non zero)
16ec : a908 lda #lo(jxp_ok) ;test with index causing a page cross
16ee : 8d0003 sta jxp_tab
16f1 : a917 lda #hi(jxp_ok)
16f3 : 8d0103 sta jxp_tab+1
16f6 : a905 lda #lo(jxp_px)
16f8 : 8d0002 sta pg_x
16fb : a917 lda #hi(jxp_px)
16fd : 8d0102 sta pg_x+1
1700 : a2ff ldx #$ff
1702 : 7c0102 jmp (jxp_tab-$ff,x)
1705 : jxp_px
trap ;page cross by index to wrong page
1705 : 4c0517 > jmp * ;failed anyway
1708 : jxp_ok
next_test
1708 : ad0202 > lda test_case ;previous test
170b : c90a > cmp #test_num
> trap_ne ;test is out of sequence
170d : d0fe > bne * ;failed not equal (non zero)
>
000b = >test_num = test_num + 1
170f : a90b > lda #test_num ;*** next tests' number
1711 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
if ROM_vectors = 1
; test BRK clears decimal mode
1714 : f8 sed
1715 : 00 brk
1716 : ea nop
1717 : brk_ret
next_test
1717 : ad0202 > lda test_case ;previous test
171a : c90b > cmp #test_num
> trap_ne ;test is out of sequence
171c : d0fe > bne * ;failed not equal (non zero)
>
000c = >test_num = test_num + 1
171e : a90c > lda #test_num ;*** next tests' number
1720 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
endif
; testing accumulator increment/decrement INC A & DEC A
1723 : a2ac ldx #$ac ;protect x & y
1725 : a0dc ldy #$dc
set_a $fe,$ff
> load_flag $ff
1727 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1729 : 48 > pha ;use stack to load status
172a : a9fe > lda #$fe ;precharge accu
172c : 28 > plp
172d : 1a inc a ;ff
tst_as $ff,$ff-zero
172e : 48 > pha
172f : 08 > php ;save flags
1730 : c9ff > cmp #$ff ;test result
> trap_ne
1732 : d0fe > bne * ;failed not equal (non zero)
>
1734 : 68 > pla ;load status
1735 : 48 > pha
> cmp_flag $ff-zero
1736 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1738 : d0fe > bne * ;failed not equal (non zero)
>
173a : 28 > plp ;restore status
173b : 68 > pla
173c : 1a inc a ;00
tst_as 0,$ff-minus
173d : 48 > pha
173e : 08 > php ;save flags
173f : c900 > cmp #0 ;test result
> trap_ne
1741 : d0fe > bne * ;failed not equal (non zero)
>
1743 : 68 > pla ;load status
1744 : 48 > pha
> cmp_flag $ff-minus
1745 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1747 : d0fe > bne * ;failed not equal (non zero)
>
1749 : 28 > plp ;restore status
174a : 68 > pla
174b : 1a inc a ;01
tst_as 1,$ff-minus-zero
174c : 48 > pha
174d : 08 > php ;save flags
174e : c901 > cmp #1 ;test result
> trap_ne
1750 : d0fe > bne * ;failed not equal (non zero)
>
1752 : 68 > pla ;load status
1753 : 48 > pha
> cmp_flag $ff-minus-zero
1754 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1756 : d0fe > bne * ;failed not equal (non zero)
>
1758 : 28 > plp ;restore status
1759 : 68 > pla
175a : 3a dec a ;00
tst_as 0,$ff-minus
175b : 48 > pha
175c : 08 > php ;save flags
175d : c900 > cmp #0 ;test result
> trap_ne
175f : d0fe > bne * ;failed not equal (non zero)
>
1761 : 68 > pla ;load status
1762 : 48 > pha
> cmp_flag $ff-minus
1763 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1765 : d0fe > bne * ;failed not equal (non zero)
>
1767 : 28 > plp ;restore status
1768 : 68 > pla
1769 : 3a dec a ;ff
tst_as $ff,$ff-zero
176a : 48 > pha
176b : 08 > php ;save flags
176c : c9ff > cmp #$ff ;test result
> trap_ne
176e : d0fe > bne * ;failed not equal (non zero)
>
1770 : 68 > pla ;load status
1771 : 48 > pha
> cmp_flag $ff-zero
1772 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1774 : d0fe > bne * ;failed not equal (non zero)
>
1776 : 28 > plp ;restore status
1777 : 68 > pla
1778 : 3a dec a ;fe
set_a $fe,0
> load_flag 0
1779 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
177b : 48 > pha ;use stack to load status
177c : a9fe > lda #$fe ;precharge accu
177e : 28 > plp
177f : 1a inc a ;ff
tst_as $ff,minus
1780 : 48 > pha
1781 : 08 > php ;save flags
1782 : c9ff > cmp #$ff ;test result
> trap_ne
1784 : d0fe > bne * ;failed not equal (non zero)
>
1786 : 68 > pla ;load status
1787 : 48 > pha
> cmp_flag minus
1788 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
178a : d0fe > bne * ;failed not equal (non zero)
>
178c : 28 > plp ;restore status
178d : 68 > pla
178e : 1a inc a ;00
tst_as 0,zero
178f : 48 > pha
1790 : 08 > php ;save flags
1791 : c900 > cmp #0 ;test result
> trap_ne
1793 : d0fe > bne * ;failed not equal (non zero)
>
1795 : 68 > pla ;load status
1796 : 48 > pha
> cmp_flag zero
1797 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1799 : d0fe > bne * ;failed not equal (non zero)
>
179b : 28 > plp ;restore status
179c : 68 > pla
179d : 1a inc a ;01
tst_as 1,0
179e : 48 > pha
179f : 08 > php ;save flags
17a0 : c901 > cmp #1 ;test result
> trap_ne
17a2 : d0fe > bne * ;failed not equal (non zero)
>
17a4 : 68 > pla ;load status
17a5 : 48 > pha
> cmp_flag 0
17a6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
17a8 : d0fe > bne * ;failed not equal (non zero)
>
17aa : 28 > plp ;restore status
17ab : 68 > pla
17ac : 3a dec a ;00
tst_as 0,zero
17ad : 48 > pha
17ae : 08 > php ;save flags
17af : c900 > cmp #0 ;test result
> trap_ne
17b1 : d0fe > bne * ;failed not equal (non zero)
>
17b3 : 68 > pla ;load status
17b4 : 48 > pha
> cmp_flag zero
17b5 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
17b7 : d0fe > bne * ;failed not equal (non zero)
>
17b9 : 28 > plp ;restore status
17ba : 68 > pla
17bb : 3a dec a ;ff
tst_as $ff,minus
17bc : 48 > pha
17bd : 08 > php ;save flags
17be : c9ff > cmp #$ff ;test result
> trap_ne
17c0 : d0fe > bne * ;failed not equal (non zero)
>
17c2 : 68 > pla ;load status
17c3 : 48 > pha
> cmp_flag minus
17c4 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
17c6 : d0fe > bne * ;failed not equal (non zero)
>
17c8 : 28 > plp ;restore status
17c9 : 68 > pla
17ca : e0ac cpx #$ac
trap_ne ;x altered during test
17cc : d0fe > bne * ;failed not equal (non zero)
17ce : c0dc cpy #$dc
trap_ne ;y altered during test
17d0 : d0fe > bne * ;failed not equal (non zero)
17d2 : ba tsx
17d3 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
17d5 : d0fe > bne * ;failed not equal (non zero)
next_test
17d7 : ad0202 > lda test_case ;previous test
17da : c90c > cmp #test_num
> trap_ne ;test is out of sequence
17dc : d0fe > bne * ;failed not equal (non zero)
>
000d = >test_num = test_num + 1
17de : a90d > lda #test_num ;*** next tests' number
17e0 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing load / store accumulator LDA / STA (zp)
17e3 : a299 ldx #$99 ;protect x & y
17e5 : a066 ldy #$66
set_stat 0
> load_flag 0
17e7 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
17e9 : 48 > pha ;use stack to load status
17ea : 28 > plp
17eb : b222 lda (ind1)
17ed : 08 php ;test stores do not alter flags
17ee : 49c3 eor #$c3
17f0 : 28 plp
17f1 : 922e sta (indt)
17f3 : 08 php ;flags after load/store sequence
17f4 : 49c3 eor #$c3
17f6 : c9c3 cmp #$c3 ;test result
trap_ne
17f8 : d0fe > bne * ;failed not equal (non zero)
17fa : 68 pla ;load status
eor_flag 0
17fb : 4930 > eor #0|fao ;invert expected flags + always on bits
17fd : cd0f02 cmp fLDx ;test flags
trap_ne
1800 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1802 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1804 : 48 > pha ;use stack to load status
1805 : 28 > plp
1806 : b224 lda (ind1+2)
1808 : 08 php ;test stores do not alter flags
1809 : 49c3 eor #$c3
180b : 28 plp
180c : 9230 sta (indt+2)
180e : 08 php ;flags after load/store sequence
180f : 49c3 eor #$c3
1811 : c982 cmp #$82 ;test result
trap_ne
1813 : d0fe > bne * ;failed not equal (non zero)
1815 : 68 pla ;load status
eor_flag 0
1816 : 4930 > eor #0|fao ;invert expected flags + always on bits
1818 : cd1002 cmp fLDx+1 ;test flags
trap_ne
181b : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
181d : a900 > lda #0 ;allow test to change I-flag (no mask)
>
181f : 48 > pha ;use stack to load status
1820 : 28 > plp
1821 : b226 lda (ind1+4)
1823 : 08 php ;test stores do not alter flags
1824 : 49c3 eor #$c3
1826 : 28 plp
1827 : 9232 sta (indt+4)
1829 : 08 php ;flags after load/store sequence
182a : 49c3 eor #$c3
182c : c941 cmp #$41 ;test result
trap_ne
182e : d0fe > bne * ;failed not equal (non zero)
1830 : 68 pla ;load status
eor_flag 0
1831 : 4930 > eor #0|fao ;invert expected flags + always on bits
1833 : cd1102 cmp fLDx+2 ;test flags
trap_ne
1836 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1838 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
183a : 48 > pha ;use stack to load status
183b : 28 > plp
183c : b228 lda (ind1+6)
183e : 08 php ;test stores do not alter flags
183f : 49c3 eor #$c3
1841 : 28 plp
1842 : 9234 sta (indt+6)
1844 : 08 php ;flags after load/store sequence
1845 : 49c3 eor #$c3
1847 : c900 cmp #0 ;test result
trap_ne
1849 : d0fe > bne * ;failed not equal (non zero)
184b : 68 pla ;load status
eor_flag 0
184c : 4930 > eor #0|fao ;invert expected flags + always on bits
184e : cd1202 cmp fLDx+3 ;test flags
trap_ne
1851 : d0fe > bne * ;failed not equal (non zero)
1853 : e099 cpx #$99
trap_ne ;x altered during test
1855 : d0fe > bne * ;failed not equal (non zero)
1857 : c066 cpy #$66
trap_ne ;y altered during test
1859 : d0fe > bne * ;failed not equal (non zero)
185b : a003 ldy #3 ;testing store result
185d : a200 ldx #0
185f : b90502 tstai1 lda abst,y
1862 : 49c3 eor #$c3
1864 : d90a02 cmp abs1,y
trap_ne ;store to indirect data
1867 : d0fe > bne * ;failed not equal (non zero)
1869 : 8a txa
186a : 990502 sta abst,y ;clear
186d : 88 dey
186e : 10ef bpl tstai1
1870 : a299 ldx #$99 ;protect x & y
1872 : a066 ldy #$66
set_stat $ff
> load_flag $ff
1874 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1876 : 48 > pha ;use stack to load status
1877 : 28 > plp
1878 : b222 lda (ind1)
187a : 08 php ;test stores do not alter flags
187b : 49c3 eor #$c3
187d : 28 plp
187e : 922e sta (indt)
1880 : 08 php ;flags after load/store sequence
1881 : 49c3 eor #$c3
1883 : c9c3 cmp #$c3 ;test result
trap_ne
1885 : d0fe > bne * ;failed not equal (non zero)
1887 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1888 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
188a : cd0f02 cmp fLDx ;test flags
trap_ne
188d : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
188f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1891 : 48 > pha ;use stack to load status
1892 : 28 > plp
1893 : b224 lda (ind1+2)
1895 : 08 php ;test stores do not alter flags
1896 : 49c3 eor #$c3
1898 : 28 plp
1899 : 9230 sta (indt+2)
189b : 08 php ;flags after load/store sequence
189c : 49c3 eor #$c3
189e : c982 cmp #$82 ;test result
trap_ne
18a0 : d0fe > bne * ;failed not equal (non zero)
18a2 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
18a3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
18a5 : cd1002 cmp fLDx+1 ;test flags
trap_ne
18a8 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18aa : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18ac : 48 > pha ;use stack to load status
18ad : 28 > plp
18ae : b226 lda (ind1+4)
18b0 : 08 php ;test stores do not alter flags
18b1 : 49c3 eor #$c3
18b3 : 28 plp
18b4 : 9232 sta (indt+4)
18b6 : 08 php ;flags after load/store sequence
18b7 : 49c3 eor #$c3
18b9 : c941 cmp #$41 ;test result
trap_ne
18bb : d0fe > bne * ;failed not equal (non zero)
18bd : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
18be : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
18c0 : cd1102 cmp fLDx+2 ;test flags
trap_ne
18c3 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18c5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18c7 : 48 > pha ;use stack to load status
18c8 : 28 > plp
18c9 : b228 lda (ind1+6)
18cb : 08 php ;test stores do not alter flags
18cc : 49c3 eor #$c3
18ce : 28 plp
18cf : 9234 sta (indt+6)
18d1 : 08 php ;flags after load/store sequence
18d2 : 49c3 eor #$c3
18d4 : c900 cmp #0 ;test result
trap_ne
18d6 : d0fe > bne * ;failed not equal (non zero)
18d8 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
18d9 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
18db : cd1202 cmp fLDx+3 ;test flags
trap_ne
18de : d0fe > bne * ;failed not equal (non zero)
18e0 : e099 cpx #$99
trap_ne ;x altered during test
18e2 : d0fe > bne * ;failed not equal (non zero)
18e4 : c066 cpy #$66
trap_ne ;y altered during test
18e6 : d0fe > bne * ;failed not equal (non zero)
18e8 : a003 ldy #3 ;testing store result
18ea : a200 ldx #0
18ec : b90502 tstai2 lda abst,y
18ef : 49c3 eor #$c3
18f1 : d90a02 cmp abs1,y
trap_ne ;store to indirect data
18f4 : d0fe > bne * ;failed not equal (non zero)
18f6 : 8a txa
18f7 : 990502 sta abst,y ;clear
18fa : 88 dey
18fb : 10ef bpl tstai2
18fd : ba tsx
18fe : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
1900 : d0fe > bne * ;failed not equal (non zero)
next_test
1902 : ad0202 > lda test_case ;previous test
1905 : c90d > cmp #test_num
> trap_ne ;test is out of sequence
1907 : d0fe > bne * ;failed not equal (non zero)
>
000e = >test_num = test_num + 1
1909 : a90e > lda #test_num ;*** next tests' number
190b : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing STZ - zp / abs / zp,x / abs,x
190e : a07b ldy #123 ;protect y
1910 : a204 ldx #4 ;precharge test area
1912 : a907 lda #7
1914 : 950a tstz1 sta zpt,x
1916 : 0a asl a
1917 : ca dex
1918 : 10fa bpl tstz1
191a : a204 ldx #4
set_a $55,$ff
> load_flag $ff
191c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
191e : 48 > pha ;use stack to load status
191f : a955 > lda #$55 ;precharge accu
1921 : 28 > plp
1922 : 640a stz zpt
1924 : 640b stz zpt+1
1926 : 640c stz zpt+2
1928 : 640d stz zpt+3
192a : 640e stz zpt+4
tst_a $55,$ff
192c : 08 > php ;save flags
192d : c955 > cmp #$55 ;test result
> trap_ne
192f : d0fe > bne * ;failed not equal (non zero)
>
1931 : 68 > pla ;load status
1932 : 48 > pha
> cmp_flag $ff
1933 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1935 : d0fe > bne * ;failed not equal (non zero)
>
1937 : 28 > plp ;restore status
1938 : b50a tstz2 lda zpt,x ;verify zeros stored
trap_ne ;non zero after STZ zp
193a : d0fe > bne * ;failed not equal (non zero)
193c : ca dex
193d : 10f9 bpl tstz2
193f : a204 ldx #4 ;precharge test area
1941 : a907 lda #7
1943 : 950a tstz3 sta zpt,x
1945 : 0a asl a
1946 : ca dex
1947 : 10fa bpl tstz3
1949 : a204 ldx #4
set_a $aa,0
> load_flag 0
194b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
194d : 48 > pha ;use stack to load status
194e : a9aa > lda #$aa ;precharge accu
1950 : 28 > plp
1951 : 640a stz zpt
1953 : 640b stz zpt+1
1955 : 640c stz zpt+2
1957 : 640d stz zpt+3
1959 : 640e stz zpt+4
tst_a $aa,0
195b : 08 > php ;save flags
195c : c9aa > cmp #$aa ;test result
> trap_ne
195e : d0fe > bne * ;failed not equal (non zero)
>
1960 : 68 > pla ;load status
1961 : 48 > pha
> cmp_flag 0
1962 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1964 : d0fe > bne * ;failed not equal (non zero)
>
1966 : 28 > plp ;restore status
1967 : b50a tstz4 lda zpt,x ;verify zeros stored
trap_ne ;non zero after STZ zp
1969 : d0fe > bne * ;failed not equal (non zero)
196b : ca dex
196c : 10f9 bpl tstz4
196e : a204 ldx #4 ;precharge test area
1970 : a907 lda #7
1972 : 9d0502 tstz5 sta abst,x
1975 : 0a asl a
1976 : ca dex
1977 : 10f9 bpl tstz5
1979 : a204 ldx #4
set_a $55,$ff
> load_flag $ff
197b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
197d : 48 > pha ;use stack to load status
197e : a955 > lda #$55 ;precharge accu
1980 : 28 > plp
1981 : 9c0502 stz abst
1984 : 9c0602 stz abst+1
1987 : 9c0702 stz abst+2
198a : 9c0802 stz abst+3
198d : 9c0902 stz abst+4
tst_a $55,$ff
1990 : 08 > php ;save flags
1991 : c955 > cmp #$55 ;test result
> trap_ne
1993 : d0fe > bne * ;failed not equal (non zero)
>
1995 : 68 > pla ;load status
1996 : 48 > pha
> cmp_flag $ff
1997 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1999 : d0fe > bne * ;failed not equal (non zero)
>
199b : 28 > plp ;restore status
199c : bd0502 tstz6 lda abst,x ;verify zeros stored
trap_ne ;non zero after STZ abs
199f : d0fe > bne * ;failed not equal (non zero)
19a1 : ca dex
19a2 : 10f8 bpl tstz6
19a4 : a204 ldx #4 ;precharge test area
19a6 : a907 lda #7
19a8 : 9d0502 tstz7 sta abst,x
19ab : 0a asl a
19ac : ca dex
19ad : 10f9 bpl tstz7
19af : a204 ldx #4
set_a $aa,0
> load_flag 0
19b1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
19b3 : 48 > pha ;use stack to load status
19b4 : a9aa > lda #$aa ;precharge accu
19b6 : 28 > plp
19b7 : 9c0502 stz abst
19ba : 9c0602 stz abst+1
19bd : 9c0702 stz abst+2
19c0 : 9c0802 stz abst+3
19c3 : 9c0902 stz abst+4
tst_a $aa,0
19c6 : 08 > php ;save flags
19c7 : c9aa > cmp #$aa ;test result
> trap_ne
19c9 : d0fe > bne * ;failed not equal (non zero)
>
19cb : 68 > pla ;load status
19cc : 48 > pha
> cmp_flag 0
19cd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
19cf : d0fe > bne * ;failed not equal (non zero)
>
19d1 : 28 > plp ;restore status
19d2 : bd0502 tstz8 lda abst,x ;verify zeros stored
trap_ne ;non zero after STZ abs
19d5 : d0fe > bne * ;failed not equal (non zero)
19d7 : ca dex
19d8 : 10f8 bpl tstz8
19da : a204 ldx #4 ;precharge test area
19dc : a907 lda #7
19de : 950a tstz11 sta zpt,x
19e0 : 0a asl a
19e1 : ca dex
19e2 : 10fa bpl tstz11
19e4 : a204 ldx #4
19e6 : tstz15
set_a $55,$ff
> load_flag $ff
19e6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
19e8 : 48 > pha ;use stack to load status
19e9 : a955 > lda #$55 ;precharge accu
19eb : 28 > plp
19ec : 740a stz zpt,x
tst_a $55,$ff
19ee : 08 > php ;save flags
19ef : c955 > cmp #$55 ;test result
> trap_ne
19f1 : d0fe > bne * ;failed not equal (non zero)
>
19f3 : 68 > pla ;load status
19f4 : 48 > pha
> cmp_flag $ff
19f5 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
19f7 : d0fe > bne * ;failed not equal (non zero)
>
19f9 : 28 > plp ;restore status
19fa : ca dex
19fb : 10e9 bpl tstz15
19fd : a204 ldx #4
19ff : b50a tstz12 lda zpt,x ;verify zeros stored
trap_ne ;non zero after STZ zp
1a01 : d0fe > bne * ;failed not equal (non zero)
1a03 : ca dex
1a04 : 10f9 bpl tstz12
1a06 : a204 ldx #4 ;precharge test area
1a08 : a907 lda #7
1a0a : 950a tstz13 sta zpt,x
1a0c : 0a asl a
1a0d : ca dex
1a0e : 10fa bpl tstz13
1a10 : a204 ldx #4
1a12 : tstz16
set_a $aa,0
> load_flag 0
1a12 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1a14 : 48 > pha ;use stack to load status
1a15 : a9aa > lda #$aa ;precharge accu
1a17 : 28 > plp
1a18 : 740a stz zpt,x
tst_a $aa,0
1a1a : 08 > php ;save flags
1a1b : c9aa > cmp #$aa ;test result
> trap_ne
1a1d : d0fe > bne * ;failed not equal (non zero)
>
1a1f : 68 > pla ;load status
1a20 : 48 > pha
> cmp_flag 0
1a21 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1a23 : d0fe > bne * ;failed not equal (non zero)
>
1a25 : 28 > plp ;restore status
1a26 : ca dex
1a27 : 10e9 bpl tstz16
1a29 : a204 ldx #4
1a2b : b50a tstz14 lda zpt,x ;verify zeros stored
trap_ne ;non zero after STZ zp
1a2d : d0fe > bne * ;failed not equal (non zero)
1a2f : ca dex
1a30 : 10f9 bpl tstz14
1a32 : a204 ldx #4 ;precharge test area
1a34 : a907 lda #7
1a36 : 9d0502 tstz21 sta abst,x
1a39 : 0a asl a
1a3a : ca dex
1a3b : 10f9 bpl tstz21
1a3d : a204 ldx #4
1a3f : tstz25
set_a $55,$ff
> load_flag $ff
1a3f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1a41 : 48 > pha ;use stack to load status
1a42 : a955 > lda #$55 ;precharge accu
1a44 : 28 > plp
1a45 : 9e0502 stz abst,x
tst_a $55,$ff
1a48 : 08 > php ;save flags
1a49 : c955 > cmp #$55 ;test result
> trap_ne
1a4b : d0fe > bne * ;failed not equal (non zero)
>
1a4d : 68 > pla ;load status
1a4e : 48 > pha
> cmp_flag $ff
1a4f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1a51 : d0fe > bne * ;failed not equal (non zero)
>
1a53 : 28 > plp ;restore status
1a54 : ca dex
1a55 : 10e8 bpl tstz25
1a57 : a204 ldx #4
1a59 : bd0502 tstz22 lda abst,x ;verify zeros stored
trap_ne ;non zero after STZ zp
1a5c : d0fe > bne * ;failed not equal (non zero)
1a5e : ca dex
1a5f : 10f8 bpl tstz22
1a61 : a204 ldx #4 ;precharge test area
1a63 : a907 lda #7
1a65 : 9d0502 tstz23 sta abst,x
1a68 : 0a asl a
1a69 : ca dex
1a6a : 10f9 bpl tstz23
1a6c : a204 ldx #4
1a6e : tstz26
set_a $aa,0
> load_flag 0
1a6e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1a70 : 48 > pha ;use stack to load status
1a71 : a9aa > lda #$aa ;precharge accu
1a73 : 28 > plp
1a74 : 9e0502 stz abst,x
tst_a $aa,0
1a77 : 08 > php ;save flags
1a78 : c9aa > cmp #$aa ;test result
> trap_ne
1a7a : d0fe > bne * ;failed not equal (non zero)
>
1a7c : 68 > pla ;load status
1a7d : 48 > pha
> cmp_flag 0
1a7e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1a80 : d0fe > bne * ;failed not equal (non zero)
>
1a82 : 28 > plp ;restore status
1a83 : ca dex
1a84 : 10e8 bpl tstz26
1a86 : a204 ldx #4
1a88 : bd0502 tstz24 lda abst,x ;verify zeros stored
trap_ne ;non zero after STZ zp
1a8b : d0fe > bne * ;failed not equal (non zero)
1a8d : ca dex
1a8e : 10f8 bpl tstz24
1a90 : c07b cpy #123
trap_ne ;y altered during test
1a92 : d0fe > bne * ;failed not equal (non zero)
1a94 : ba tsx
1a95 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
1a97 : d0fe > bne * ;failed not equal (non zero)
next_test
1a99 : ad0202 > lda test_case ;previous test
1a9c : c90e > cmp #test_num
> trap_ne ;test is out of sequence
1a9e : d0fe > bne * ;failed not equal (non zero)
>
000f = >test_num = test_num + 1
1aa0 : a90f > lda #test_num ;*** next tests' number
1aa2 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing BIT - zp,x / abs,x / #
1aa5 : a042 ldy #$42
1aa7 : a203 ldx #3
set_a $ff,0
> load_flag 0
1aa9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1aab : 48 > pha ;use stack to load status
1aac : a9ff > lda #$ff ;precharge accu
1aae : 28 > plp
1aaf : 3411 bit zp1,x ;00 - should set Z / clear NV
tst_a $ff,fz
1ab1 : 08 > php ;save flags
1ab2 : c9ff > cmp #$ff ;test result
> trap_ne
1ab4 : d0fe > bne * ;failed not equal (non zero)
>
1ab6 : 68 > pla ;load status
1ab7 : 48 > pha
> cmp_flag fz
1ab8 : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1aba : d0fe > bne * ;failed not equal (non zero)
>
1abc : 28 > plp ;restore status
1abd : ca dex
set_a 1,0
> load_flag 0
1abe : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ac0 : 48 > pha ;use stack to load status
1ac1 : a901 > lda #1 ;precharge accu
1ac3 : 28 > plp
1ac4 : 3411 bit zp1,x ;41 - should set V (M6) / clear NZ
tst_a 1,fv
1ac6 : 08 > php ;save flags
1ac7 : c901 > cmp #1 ;test result
> trap_ne
1ac9 : d0fe > bne * ;failed not equal (non zero)
>
1acb : 68 > pla ;load status
1acc : 48 > pha
> cmp_flag fv
1acd : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1acf : d0fe > bne * ;failed not equal (non zero)
>
1ad1 : 28 > plp ;restore status
1ad2 : ca dex
set_a 1,0
> load_flag 0
1ad3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ad5 : 48 > pha ;use stack to load status
1ad6 : a901 > lda #1 ;precharge accu
1ad8 : 28 > plp
1ad9 : 3411 bit zp1,x ;82 - should set N (M7) & Z / clear V
tst_a 1,fnz
1adb : 08 > php ;save flags
1adc : c901 > cmp #1 ;test result
> trap_ne
1ade : d0fe > bne * ;failed not equal (non zero)
>
1ae0 : 68 > pla ;load status
1ae1 : 48 > pha
> cmp_flag fnz
1ae2 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ae4 : d0fe > bne * ;failed not equal (non zero)
>
1ae6 : 28 > plp ;restore status
1ae7 : ca dex
set_a 1,0
> load_flag 0
1ae8 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1aea : 48 > pha ;use stack to load status
1aeb : a901 > lda #1 ;precharge accu
1aed : 28 > plp
1aee : 3411 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,fnv
1af0 : 08 > php ;save flags
1af1 : c901 > cmp #1 ;test result
> trap_ne
1af3 : d0fe > bne * ;failed not equal (non zero)
>
1af5 : 68 > pla ;load status
1af6 : 48 > pha
> cmp_flag fnv
1af7 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1af9 : d0fe > bne * ;failed not equal (non zero)
>
1afb : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1afc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1afe : 48 > pha ;use stack to load status
1aff : a901 > lda #1 ;precharge accu
1b01 : 28 > plp
1b02 : 3411 bit zp1,x ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,~fz
1b04 : 08 > php ;save flags
1b05 : c901 > cmp #1 ;test result
> trap_ne
1b07 : d0fe > bne * ;failed not equal (non zero)
>
1b09 : 68 > pla ;load status
1b0a : 48 > pha
> cmp_flag ~fz
1b0b : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b0d : d0fe > bne * ;failed not equal (non zero)
>
1b0f : 28 > plp ;restore status
1b10 : e8 inx
set_a 1,$ff
> load_flag $ff
1b11 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b13 : 48 > pha ;use stack to load status
1b14 : a901 > lda #1 ;precharge accu
1b16 : 28 > plp
1b17 : 3411 bit zp1,x ;82 - should set N (M7) & Z / clear V
tst_a 1,~fv
1b19 : 08 > php ;save flags
1b1a : c901 > cmp #1 ;test result
> trap_ne
1b1c : d0fe > bne * ;failed not equal (non zero)
>
1b1e : 68 > pla ;load status
1b1f : 48 > pha
> cmp_flag ~fv
1b20 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b22 : d0fe > bne * ;failed not equal (non zero)
>
1b24 : 28 > plp ;restore status
1b25 : e8 inx
set_a 1,$ff
> load_flag $ff
1b26 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b28 : 48 > pha ;use stack to load status
1b29 : a901 > lda #1 ;precharge accu
1b2b : 28 > plp
1b2c : 3411 bit zp1,x ;41 - should set V (M6) / clear NZ
tst_a 1,~fnz
1b2e : 08 > php ;save flags
1b2f : c901 > cmp #1 ;test result
> trap_ne
1b31 : d0fe > bne * ;failed not equal (non zero)
>
1b33 : 68 > pla ;load status
1b34 : 48 > pha
> cmp_flag ~fnz
1b35 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b37 : d0fe > bne * ;failed not equal (non zero)
>
1b39 : 28 > plp ;restore status
1b3a : e8 inx
set_a $ff,$ff
> load_flag $ff
1b3b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b3d : 48 > pha ;use stack to load status
1b3e : a9ff > lda #$ff ;precharge accu
1b40 : 28 > plp
1b41 : 3411 bit zp1,x ;00 - should set Z / clear NV
tst_a $ff,~fnv
1b43 : 08 > php ;save flags
1b44 : c9ff > cmp #$ff ;test result
> trap_ne
1b46 : d0fe > bne * ;failed not equal (non zero)
>
1b48 : 68 > pla ;load status
1b49 : 48 > pha
> cmp_flag ~fnv
1b4a : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b4c : d0fe > bne * ;failed not equal (non zero)
>
1b4e : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
1b4f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b51 : 48 > pha ;use stack to load status
1b52 : a9ff > lda #$ff ;precharge accu
1b54 : 28 > plp
1b55 : 3c0a02 bit abs1,x ;00 - should set Z / clear NV
tst_a $ff,fz
1b58 : 08 > php ;save flags
1b59 : c9ff > cmp #$ff ;test result
> trap_ne
1b5b : d0fe > bne * ;failed not equal (non zero)
>
1b5d : 68 > pla ;load status
1b5e : 48 > pha
> cmp_flag fz
1b5f : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b61 : d0fe > bne * ;failed not equal (non zero)
>
1b63 : 28 > plp ;restore status
1b64 : ca dex
set_a 1,0
> load_flag 0
1b65 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b67 : 48 > pha ;use stack to load status
1b68 : a901 > lda #1 ;precharge accu
1b6a : 28 > plp
1b6b : 3c0a02 bit abs1,x ;41 - should set V (M6) / clear NZ
tst_a 1,fv
1b6e : 08 > php ;save flags
1b6f : c901 > cmp #1 ;test result
> trap_ne
1b71 : d0fe > bne * ;failed not equal (non zero)
>
1b73 : 68 > pla ;load status
1b74 : 48 > pha
> cmp_flag fv
1b75 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b77 : d0fe > bne * ;failed not equal (non zero)
>
1b79 : 28 > plp ;restore status
1b7a : ca dex
set_a 1,0
> load_flag 0
1b7b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b7d : 48 > pha ;use stack to load status
1b7e : a901 > lda #1 ;precharge accu
1b80 : 28 > plp
1b81 : 3c0a02 bit abs1,x ;82 - should set N (M7) & Z / clear V
tst_a 1,fnz
1b84 : 08 > php ;save flags
1b85 : c901 > cmp #1 ;test result
> trap_ne
1b87 : d0fe > bne * ;failed not equal (non zero)
>
1b89 : 68 > pla ;load status
1b8a : 48 > pha
> cmp_flag fnz
1b8b : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b8d : d0fe > bne * ;failed not equal (non zero)
>
1b8f : 28 > plp ;restore status
1b90 : ca dex
set_a 1,0
> load_flag 0
1b91 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b93 : 48 > pha ;use stack to load status
1b94 : a901 > lda #1 ;precharge accu
1b96 : 28 > plp
1b97 : 3c0a02 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,fnv
1b9a : 08 > php ;save flags
1b9b : c901 > cmp #1 ;test result
> trap_ne
1b9d : d0fe > bne * ;failed not equal (non zero)
>
1b9f : 68 > pla ;load status
1ba0 : 48 > pha
> cmp_flag fnv
1ba1 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ba3 : d0fe > bne * ;failed not equal (non zero)
>
1ba5 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1ba6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1ba8 : 48 > pha ;use stack to load status
1ba9 : a901 > lda #1 ;precharge accu
1bab : 28 > plp
1bac : 3c0a02 bit abs1,x ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,~fz
1baf : 08 > php ;save flags
1bb0 : c901 > cmp #1 ;test result
> trap_ne
1bb2 : d0fe > bne * ;failed not equal (non zero)
>
1bb4 : 68 > pla ;load status
1bb5 : 48 > pha
> cmp_flag ~fz
1bb6 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1bb8 : d0fe > bne * ;failed not equal (non zero)
>
1bba : 28 > plp ;restore status
1bbb : e8 inx
set_a 1,$ff
> load_flag $ff
1bbc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1bbe : 48 > pha ;use stack to load status
1bbf : a901 > lda #1 ;precharge accu
1bc1 : 28 > plp
1bc2 : 3c0a02 bit abs1,x ;82 - should set N (M7) & Z / clear V
tst_a 1,~fv
1bc5 : 08 > php ;save flags
1bc6 : c901 > cmp #1 ;test result
> trap_ne
1bc8 : d0fe > bne * ;failed not equal (non zero)
>
1bca : 68 > pla ;load status
1bcb : 48 > pha
> cmp_flag ~fv
1bcc : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1bce : d0fe > bne * ;failed not equal (non zero)
>
1bd0 : 28 > plp ;restore status
1bd1 : e8 inx
set_a 1,$ff
> load_flag $ff
1bd2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1bd4 : 48 > pha ;use stack to load status
1bd5 : a901 > lda #1 ;precharge accu
1bd7 : 28 > plp
1bd8 : 3c0a02 bit abs1,x ;41 - should set V (M6) / clear NZ
tst_a 1,~fnz
1bdb : 08 > php ;save flags
1bdc : c901 > cmp #1 ;test result
> trap_ne
1bde : d0fe > bne * ;failed not equal (non zero)
>
1be0 : 68 > pla ;load status
1be1 : 48 > pha
> cmp_flag ~fnz
1be2 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1be4 : d0fe > bne * ;failed not equal (non zero)
>
1be6 : 28 > plp ;restore status
1be7 : e8 inx
set_a $ff,$ff
> load_flag $ff
1be8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1bea : 48 > pha ;use stack to load status
1beb : a9ff > lda #$ff ;precharge accu
1bed : 28 > plp
1bee : 3c0a02 bit abs1,x ;00 - should set Z / clear NV
tst_a $ff,~fnv
1bf1 : 08 > php ;save flags
1bf2 : c9ff > cmp #$ff ;test result
> trap_ne
1bf4 : d0fe > bne * ;failed not equal (non zero)
>
1bf6 : 68 > pla ;load status
1bf7 : 48 > pha
> cmp_flag ~fnv
1bf8 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1bfa : d0fe > bne * ;failed not equal (non zero)
>
1bfc : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
1bfd : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1bff : 48 > pha ;use stack to load status
1c00 : a9ff > lda #$ff ;precharge accu
1c02 : 28 > plp
1c03 : 8900 bit #$00 ;00 - should set Z
tst_a $ff,fz
1c05 : 08 > php ;save flags
1c06 : c9ff > cmp #$ff ;test result
> trap_ne
1c08 : d0fe > bne * ;failed not equal (non zero)
>
1c0a : 68 > pla ;load status
1c0b : 48 > pha
> cmp_flag fz
1c0c : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c0e : d0fe > bne * ;failed not equal (non zero)
>
1c10 : 28 > plp ;restore status
1c11 : ca dex
set_a 1,0
> load_flag 0
1c12 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1c14 : 48 > pha ;use stack to load status
1c15 : a901 > lda #1 ;precharge accu
1c17 : 28 > plp
1c18 : 8941 bit #$41 ;41 - should clear Z
tst_a 1,0
1c1a : 08 > php ;save flags
1c1b : c901 > cmp #1 ;test result
> trap_ne
1c1d : d0fe > bne * ;failed not equal (non zero)
>
1c1f : 68 > pla ;load status
1c20 : 48 > pha
> cmp_flag 0
1c21 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c23 : d0fe > bne * ;failed not equal (non zero)
>
1c25 : 28 > plp ;restore status
; *** DEBUG INFO ***
; if it fails the previous test and your BIT # has set the V flag
; see http://forum.6502.org/viewtopic.php?f=2&t=2241&p=27243#p27239
; why it shouldn't alter N or V flags on a BIT #
1c26 : ca dex
set_a 1,0
> load_flag 0
1c27 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1c29 : 48 > pha ;use stack to load status
1c2a : a901 > lda #1 ;precharge accu
1c2c : 28 > plp
1c2d : 8982 bit #$82 ;82 - should set Z
tst_a 1,fz
1c2f : 08 > php ;save flags
1c30 : c901 > cmp #1 ;test result
> trap_ne
1c32 : d0fe > bne * ;failed not equal (non zero)
>
1c34 : 68 > pla ;load status
1c35 : 48 > pha
> cmp_flag fz
1c36 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c38 : d0fe > bne * ;failed not equal (non zero)
>
1c3a : 28 > plp ;restore status
1c3b : ca dex
set_a 1,0
> load_flag 0
1c3c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1c3e : 48 > pha ;use stack to load status
1c3f : a901 > lda #1 ;precharge accu
1c41 : 28 > plp
1c42 : 89c3 bit #$c3 ;c3 - should clear Z
tst_a 1,0
1c44 : 08 > php ;save flags
1c45 : c901 > cmp #1 ;test result
> trap_ne
1c47 : d0fe > bne * ;failed not equal (non zero)
>
1c49 : 68 > pla ;load status
1c4a : 48 > pha
> cmp_flag 0
1c4b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c4d : d0fe > bne * ;failed not equal (non zero)
>
1c4f : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1c50 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c52 : 48 > pha ;use stack to load status
1c53 : a901 > lda #1 ;precharge accu
1c55 : 28 > plp
1c56 : 89c3 bit #$c3 ;c3 - clear Z
tst_a 1,~fz
1c58 : 08 > php ;save flags
1c59 : c901 > cmp #1 ;test result
> trap_ne
1c5b : d0fe > bne * ;failed not equal (non zero)
>
1c5d : 68 > pla ;load status
1c5e : 48 > pha
> cmp_flag ~fz
1c5f : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c61 : d0fe > bne * ;failed not equal (non zero)
>
1c63 : 28 > plp ;restore status
1c64 : e8 inx
set_a 1,$ff
> load_flag $ff
1c65 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c67 : 48 > pha ;use stack to load status
1c68 : a901 > lda #1 ;precharge accu
1c6a : 28 > plp
1c6b : 8982 bit #$82 ;82 - should set Z
tst_a 1,$ff
1c6d : 08 > php ;save flags
1c6e : c901 > cmp #1 ;test result
> trap_ne
1c70 : d0fe > bne * ;failed not equal (non zero)
>
1c72 : 68 > pla ;load status
1c73 : 48 > pha
> cmp_flag $ff
1c74 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c76 : d0fe > bne * ;failed not equal (non zero)
>
1c78 : 28 > plp ;restore status
1c79 : e8 inx
set_a 1,$ff
> load_flag $ff
1c7a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c7c : 48 > pha ;use stack to load status
1c7d : a901 > lda #1 ;precharge accu
1c7f : 28 > plp
1c80 : 8941 bit #$41 ;41 - should clear Z
tst_a 1,~fz
1c82 : 08 > php ;save flags
1c83 : c901 > cmp #1 ;test result
> trap_ne
1c85 : d0fe > bne * ;failed not equal (non zero)
>
1c87 : 68 > pla ;load status
1c88 : 48 > pha
> cmp_flag ~fz
1c89 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c8b : d0fe > bne * ;failed not equal (non zero)
>
1c8d : 28 > plp ;restore status
1c8e : e8 inx
set_a $ff,$ff
> load_flag $ff
1c8f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c91 : 48 > pha ;use stack to load status
1c92 : a9ff > lda #$ff ;precharge accu
1c94 : 28 > plp
1c95 : 8900 bit #$00 ;00 - should set Z
tst_a $ff,$ff
1c97 : 08 > php ;save flags
1c98 : c9ff > cmp #$ff ;test result
> trap_ne
1c9a : d0fe > bne * ;failed not equal (non zero)
>
1c9c : 68 > pla ;load status
1c9d : 48 > pha
> cmp_flag $ff
1c9e : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ca0 : d0fe > bne * ;failed not equal (non zero)
>
1ca2 : 28 > plp ;restore status
1ca3 : e003 cpx #3
trap_ne ;x altered during test
1ca5 : d0fe > bne * ;failed not equal (non zero)
1ca7 : c042 cpy #$42
trap_ne ;y altered during test
1ca9 : d0fe > bne * ;failed not equal (non zero)
1cab : ba tsx
1cac : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
1cae : d0fe > bne * ;failed not equal (non zero)
next_test
1cb0 : ad0202 > lda test_case ;previous test
1cb3 : c90f > cmp #test_num
> trap_ne ;test is out of sequence
1cb5 : d0fe > bne * ;failed not equal (non zero)
>
0010 = >test_num = test_num + 1
1cb7 : a910 > lda #test_num ;*** next tests' number
1cb9 : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing TRB, TSB - zp / abs
trbt macro ;\1 = memory, \2 = flags
sty \1
load_flag \2
pha
lda zpt+1
plp
trb \1
php
cmp zpt+1
trap_ne ;accu was changed
pla
pha
ora #fz ;mask Z
cmp_flag \2|fz
trap_ne ;flags changed except Z
pla
and #fz
cmp zpt+2
trap_ne ;Z flag invalid
lda zpt+3
cmp zpt
trap_ne ;altered bits in memory wrong
endm
tsbt macro ;\1 = memory, \2 = flags
sty \1
load_flag \2
pha
lda zpt+1
plp
tsb \1
php
cmp zpt+1
trap_ne ;accu was changed
pla
pha
ora #fz ;mask Z
cmp_flag \2|fz
trap_ne ;flags changed except Z
pla
and #fz
cmp zpt+2
trap_ne ;Z flag invalid
lda zpt+4
cmp zpt
trap_ne ;altered bits in memory wrong
endm
1cbc : a2c0 ldx #$c0
1cbe : a000 ldy #0 ;op1 - memory save
; zpt ;op1 - memory modifiable
1cc0 : 640b stz zpt+1 ;op2 - accu
; zpt+2 ;and flags
; zpt+3 ;memory after reset
; zpt+4 ;memory after set
1cc2 : 98 tbt1 tya
1cc3 : 250b and zpt+1 ;set Z by anding the 2 operands
1cc5 : 08 php
1cc6 : 68 pla
1cc7 : 2902 and #fz ;mask Z
1cc9 : 850c sta zpt+2
1ccb : 98 tya ;reset op1 bits by op2
1ccc : 49ff eor #$ff
1cce : 050b ora zpt+1
1cd0 : 49ff eor #$ff
1cd2 : 850d sta zpt+3
1cd4 : 98 tya ;set op1 bits by op2
1cd5 : 050b ora zpt+1
1cd7 : 850e sta zpt+4
trbt zpt,$ff
1cd9 : 840a > sty zpt
> load_flag $ff
1cdb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1cdd : 48 > pha
1cde : a50b > lda zpt+1
1ce0 : 28 > plp
1ce1 : 140a > trb zpt
1ce3 : 08 > php
1ce4 : c50b > cmp zpt+1
> trap_ne ;accu was changed
1ce6 : d0fe > bne * ;failed not equal (non zero)
>
1ce8 : 68 > pla
1ce9 : 48 > pha
1cea : 0902 > ora #fz ;mask Z
> cmp_flag $ff|fz
1cec : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1cee : d0fe > bne * ;failed not equal (non zero)
>
1cf0 : 68 > pla
1cf1 : 2902 > and #fz
1cf3 : c50c > cmp zpt+2
> trap_ne ;Z flag invalid
1cf5 : d0fe > bne * ;failed not equal (non zero)
>
1cf7 : a50d > lda zpt+3
1cf9 : c50a > cmp zpt
> trap_ne ;altered bits in memory wrong
1cfb : d0fe > bne * ;failed not equal (non zero)
>
trbt abst,$ff
1cfd : 8c0502 > sty abst
> load_flag $ff
1d00 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d02 : 48 > pha
1d03 : a50b > lda zpt+1
1d05 : 28 > plp
1d06 : 1c0502 > trb abst
1d09 : 08 > php
1d0a : c50b > cmp zpt+1
> trap_ne ;accu was changed
1d0c : d0fe > bne * ;failed not equal (non zero)
>
1d0e : 68 > pla
1d0f : 48 > pha
1d10 : 0902 > ora #fz ;mask Z
> cmp_flag $ff|fz
1d12 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1d14 : d0fe > bne * ;failed not equal (non zero)
>
1d16 : 68 > pla
1d17 : 2902 > and #fz
1d19 : c50c > cmp zpt+2
> trap_ne ;Z flag invalid
1d1b : d0fe > bne * ;failed not equal (non zero)
>
1d1d : a50d > lda zpt+3
1d1f : c50a > cmp zpt
> trap_ne ;altered bits in memory wrong
1d21 : d0fe > bne * ;failed not equal (non zero)
>
trbt zpt,0
1d23 : 840a > sty zpt
> load_flag 0
1d25 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1d27 : 48 > pha
1d28 : a50b > lda zpt+1
1d2a : 28 > plp
1d2b : 140a > trb zpt
1d2d : 08 > php
1d2e : c50b > cmp zpt+1
> trap_ne ;accu was changed
1d30 : d0fe > bne * ;failed not equal (non zero)
>
1d32 : 68 > pla
1d33 : 48 > pha
1d34 : 0902 > ora #fz ;mask Z
> cmp_flag 0|fz
1d36 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1d38 : d0fe > bne * ;failed not equal (non zero)
>
1d3a : 68 > pla
1d3b : 2902 > and #fz
1d3d : c50c > cmp zpt+2
> trap_ne ;Z flag invalid
1d3f : d0fe > bne * ;failed not equal (non zero)
>
1d41 : a50d > lda zpt+3
1d43 : c50a > cmp zpt
> trap_ne ;altered bits in memory wrong
1d45 : d0fe > bne * ;failed not equal (non zero)
>
trbt abst,0
1d47 : 8c0502 > sty abst
> load_flag 0
1d4a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1d4c : 48 > pha
1d4d : a50b > lda zpt+1
1d4f : 28 > plp
1d50 : 1c0502 > trb abst
1d53 : 08 > php
1d54 : c50b > cmp zpt+1
> trap_ne ;accu was changed
1d56 : d0fe > bne * ;failed not equal (non zero)
>
1d58 : 68 > pla
1d59 : 48 > pha
1d5a : 0902 > ora #fz ;mask Z
> cmp_flag 0|fz
1d5c : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1d5e : d0fe > bne * ;failed not equal (non zero)
>
1d60 : 68 > pla
1d61 : 2902 > and #fz
1d63 : c50c > cmp zpt+2
> trap_ne ;Z flag invalid
1d65 : d0fe > bne * ;failed not equal (non zero)
>
1d67 : a50d > lda zpt+3
1d69 : c50a > cmp zpt
> trap_ne ;altered bits in memory wrong
1d6b : d0fe > bne * ;failed not equal (non zero)
>
tsbt zpt,$ff
1d6d : 840a > sty zpt
> load_flag $ff
1d6f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d71 : 48 > pha
1d72 : a50b > lda zpt+1
1d74 : 28 > plp
1d75 : 040a > tsb zpt
1d77 : 08 > php
1d78 : c50b > cmp zpt+1
> trap_ne ;accu was changed
1d7a : d0fe > bne * ;failed not equal (non zero)
>
1d7c : 68 > pla
1d7d : 48 > pha
1d7e : 0902 > ora #fz ;mask Z
> cmp_flag $ff|fz
1d80 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1d82 : d0fe > bne * ;failed not equal (non zero)
>
1d84 : 68 > pla
1d85 : 2902 > and #fz
1d87 : c50c > cmp zpt+2
> trap_ne ;Z flag invalid
1d89 : d0fe > bne * ;failed not equal (non zero)
>
1d8b : a50e > lda zpt+4
1d8d : c50a > cmp zpt
> trap_ne ;altered bits in memory wrong
1d8f : d0fe > bne * ;failed not equal (non zero)
>
tsbt abst,$ff
1d91 : 8c0502 > sty abst
> load_flag $ff
1d94 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d96 : 48 > pha
1d97 : a50b > lda zpt+1
1d99 : 28 > plp
1d9a : 0c0502 > tsb abst
1d9d : 08 > php
1d9e : c50b > cmp zpt+1
> trap_ne ;accu was changed
1da0 : d0fe > bne * ;failed not equal (non zero)
>
1da2 : 68 > pla
1da3 : 48 > pha
1da4 : 0902 > ora #fz ;mask Z
> cmp_flag $ff|fz
1da6 : c9ff > cmp #($ff|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1da8 : d0fe > bne * ;failed not equal (non zero)
>
1daa : 68 > pla
1dab : 2902 > and #fz
1dad : c50c > cmp zpt+2
> trap_ne ;Z flag invalid
1daf : d0fe > bne * ;failed not equal (non zero)
>
1db1 : a50e > lda zpt+4
1db3 : c50a > cmp zpt
> trap_ne ;altered bits in memory wrong
1db5 : d0fe > bne * ;failed not equal (non zero)
>
tsbt zpt,0
1db7 : 840a > sty zpt
> load_flag 0
1db9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1dbb : 48 > pha
1dbc : a50b > lda zpt+1
1dbe : 28 > plp
1dbf : 040a > tsb zpt
1dc1 : 08 > php
1dc2 : c50b > cmp zpt+1
> trap_ne ;accu was changed
1dc4 : d0fe > bne * ;failed not equal (non zero)
>
1dc6 : 68 > pla
1dc7 : 48 > pha
1dc8 : 0902 > ora #fz ;mask Z
> cmp_flag 0|fz
1dca : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1dcc : d0fe > bne * ;failed not equal (non zero)
>
1dce : 68 > pla
1dcf : 2902 > and #fz
1dd1 : c50c > cmp zpt+2
> trap_ne ;Z flag invalid
1dd3 : d0fe > bne * ;failed not equal (non zero)
>
1dd5 : a50e > lda zpt+4
1dd7 : c50a > cmp zpt
> trap_ne ;altered bits in memory wrong
1dd9 : d0fe > bne * ;failed not equal (non zero)
>
tsbt abst,0
1ddb : 8c0502 > sty abst
> load_flag 0
1dde : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1de0 : 48 > pha
1de1 : a50b > lda zpt+1
1de3 : 28 > plp
1de4 : 0c0502 > tsb abst
1de7 : 08 > php
1de8 : c50b > cmp zpt+1
> trap_ne ;accu was changed
1dea : d0fe > bne * ;failed not equal (non zero)
>
1dec : 68 > pla
1ded : 48 > pha
1dee : 0902 > ora #fz ;mask Z
> cmp_flag 0|fz
1df0 : c932 > cmp #(0|fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne ;flags changed except Z
1df2 : d0fe > bne * ;failed not equal (non zero)
>
1df4 : 68 > pla
1df5 : 2902 > and #fz
1df7 : c50c > cmp zpt+2
> trap_ne ;Z flag invalid
1df9 : d0fe > bne * ;failed not equal (non zero)
>
1dfb : a50e > lda zpt+4
1dfd : c50a > cmp zpt
> trap_ne ;altered bits in memory wrong
1dff : d0fe > bne * ;failed not equal (non zero)
>
1e01 : c8 iny ;iterate op1
1e02 : d004 bne tbt3
1e04 : e60b inc zpt+1 ;iterate op2
1e06 : f003 beq tbt2
1e08 : 4cc21c tbt3 jmp tbt1
1e0b : tbt2
1e0b : e0c0 cpx #$c0
trap_ne ;x altered during test
1e0d : d0fe > bne * ;failed not equal (non zero)
1e0f : ba tsx
1e10 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
1e12 : d0fe > bne * ;failed not equal (non zero)
next_test
1e14 : ad0202 > lda test_case ;previous test
1e17 : c910 > cmp #test_num
> trap_ne ;test is out of sequence
1e19 : d0fe > bne * ;failed not equal (non zero)
>
0011 = >test_num = test_num + 1
1e1b : a911 > lda #test_num ;*** next tests' number
1e1d : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
if rkwl_wdc_op
; testing RMB, SMB - zp
rmbt macro ;\1 = bitnum
lda #$ff
sta zpt
set_a $a5,0
rmb \1,zpt
tst_a $a5,0
lda zpt
cmp #$ff-(1<<\1)
trap_ne ;wrong bits set or cleared
lda #1<<\1
sta zpt
set_a $5a,$ff
rmb \1,zpt
tst_a $5a,$ff
lda zpt
trap_ne ;wrong bits set or cleared
endm
smbt macro ;\1 = bitnum
lda #$ff-(1<<\1)
sta zpt
set_a $a5,0
smb \1,zpt
tst_a $a5,0
lda zpt
cmp #$ff
trap_ne ;wrong bits set or cleared
lda #0
sta zpt
set_a $5a,$ff
smb \1,zpt
tst_a $5a,$ff
lda zpt
cmp #1<<\1
trap_ne ;wrong bits set or cleared
endm
1e20 : a2ba ldx #$ba ;protect x & y
1e22 : a0d0 ldy #$d0
rmbt 0
1e24 : a9ff > lda #$ff
1e26 : 850a > sta zpt
> set_a $a5,0
> load_flag 0
1e28 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e2a : 48 > pha ;use stack to load status
1e2b : a9a5 > lda #$a5 ;precharge accu
1e2d : 28 > plp
>
1e2e : 070a > rmb 0,zpt
> tst_a $a5,0
1e30 : 08 > php ;save flags
1e31 : c9a5 > cmp #$a5 ;test result
> trap_ne
1e33 : d0fe > bne * ;failed not equal (non zero)
>
1e35 : 68 > pla ;load status
1e36 : 48 > pha
> cmp_flag 0
1e37 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e39 : d0fe > bne * ;failed not equal (non zero)
>
1e3b : 28 > plp ;restore status
>
1e3c : a50a > lda zpt
1e3e : c9fe > cmp #$ff-(1<<0)
> trap_ne ;wrong bits set or cleared
1e40 : d0fe > bne * ;failed not equal (non zero)
>
1e42 : a901 > lda #1<<0
1e44 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
1e46 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1e48 : 48 > pha ;use stack to load status
1e49 : a95a > lda #$5a ;precharge accu
1e4b : 28 > plp
>
1e4c : 070a > rmb 0,zpt
> tst_a $5a,$ff
1e4e : 08 > php ;save flags
1e4f : c95a > cmp #$5a ;test result
> trap_ne
1e51 : d0fe > bne * ;failed not equal (non zero)
>
1e53 : 68 > pla ;load status
1e54 : 48 > pha
> cmp_flag $ff
1e55 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e57 : d0fe > bne * ;failed not equal (non zero)
>
1e59 : 28 > plp ;restore status
>
1e5a : a50a > lda zpt
> trap_ne ;wrong bits set or cleared
1e5c : d0fe > bne * ;failed not equal (non zero)
>
rmbt 1
1e5e : a9ff > lda #$ff
1e60 : 850a > sta zpt
> set_a $a5,0
> load_flag 0
1e62 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e64 : 48 > pha ;use stack to load status
1e65 : a9a5 > lda #$a5 ;precharge accu
1e67 : 28 > plp
>
1e68 : 170a > rmb 1,zpt
> tst_a $a5,0
1e6a : 08 > php ;save flags
1e6b : c9a5 > cmp #$a5 ;test result
> trap_ne
1e6d : d0fe > bne * ;failed not equal (non zero)
>
1e6f : 68 > pla ;load status
1e70 : 48 > pha
> cmp_flag 0
1e71 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e73 : d0fe > bne * ;failed not equal (non zero)
>
1e75 : 28 > plp ;restore status
>
1e76 : a50a > lda zpt
1e78 : c9fd > cmp #$ff-(1<<1)
> trap_ne ;wrong bits set or cleared
1e7a : d0fe > bne * ;failed not equal (non zero)
>
1e7c : a902 > lda #1<<1
1e7e : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
1e80 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1e82 : 48 > pha ;use stack to load status
1e83 : a95a > lda #$5a ;precharge accu
1e85 : 28 > plp
>
1e86 : 170a > rmb 1,zpt
> tst_a $5a,$ff
1e88 : 08 > php ;save flags
1e89 : c95a > cmp #$5a ;test result
> trap_ne
1e8b : d0fe > bne * ;failed not equal (non zero)
>
1e8d : 68 > pla ;load status
1e8e : 48 > pha
> cmp_flag $ff
1e8f : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e91 : d0fe > bne * ;failed not equal (non zero)
>
1e93 : 28 > plp ;restore status
>
1e94 : a50a > lda zpt
> trap_ne ;wrong bits set or cleared
1e96 : d0fe > bne * ;failed not equal (non zero)
>
rmbt 2
1e98 : a9ff > lda #$ff
1e9a : 850a > sta zpt
> set_a $a5,0
> load_flag 0
1e9c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e9e : 48 > pha ;use stack to load status
1e9f : a9a5 > lda #$a5 ;precharge accu
1ea1 : 28 > plp
>
1ea2 : 270a > rmb 2,zpt
> tst_a $a5,0
1ea4 : 08 > php ;save flags
1ea5 : c9a5 > cmp #$a5 ;test result
> trap_ne
1ea7 : d0fe > bne * ;failed not equal (non zero)
>
1ea9 : 68 > pla ;load status
1eaa : 48 > pha
> cmp_flag 0
1eab : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ead : d0fe > bne * ;failed not equal (non zero)
>
1eaf : 28 > plp ;restore status
>
1eb0 : a50a > lda zpt
1eb2 : c9fb > cmp #$ff-(1<<2)
> trap_ne ;wrong bits set or cleared
1eb4 : d0fe > bne * ;failed not equal (non zero)
>
1eb6 : a904 > lda #1<<2
1eb8 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
1eba : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1ebc : 48 > pha ;use stack to load status
1ebd : a95a > lda #$5a ;precharge accu
1ebf : 28 > plp
>
1ec0 : 270a > rmb 2,zpt
> tst_a $5a,$ff
1ec2 : 08 > php ;save flags
1ec3 : c95a > cmp #$5a ;test result
> trap_ne
1ec5 : d0fe > bne * ;failed not equal (non zero)
>
1ec7 : 68 > pla ;load status
1ec8 : 48 > pha
> cmp_flag $ff
1ec9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ecb : d0fe > bne * ;failed not equal (non zero)
>
1ecd : 28 > plp ;restore status
>
1ece : a50a > lda zpt
> trap_ne ;wrong bits set or cleared
1ed0 : d0fe > bne * ;failed not equal (non zero)
>
rmbt 3
1ed2 : a9ff > lda #$ff
1ed4 : 850a > sta zpt
> set_a $a5,0
> load_flag 0
1ed6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ed8 : 48 > pha ;use stack to load status
1ed9 : a9a5 > lda #$a5 ;precharge accu
1edb : 28 > plp
>
1edc : 370a > rmb 3,zpt
> tst_a $a5,0
1ede : 08 > php ;save flags
1edf : c9a5 > cmp #$a5 ;test result
> trap_ne
1ee1 : d0fe > bne * ;failed not equal (non zero)
>
1ee3 : 68 > pla ;load status
1ee4 : 48 > pha
> cmp_flag 0
1ee5 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ee7 : d0fe > bne * ;failed not equal (non zero)
>
1ee9 : 28 > plp ;restore status
>
1eea : a50a > lda zpt
1eec : c9f7 > cmp #$ff-(1<<3)
> trap_ne ;wrong bits set or cleared
1eee : d0fe > bne * ;failed not equal (non zero)
>
1ef0 : a908 > lda #1<<3
1ef2 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
1ef4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1ef6 : 48 > pha ;use stack to load status
1ef7 : a95a > lda #$5a ;precharge accu
1ef9 : 28 > plp
>
1efa : 370a > rmb 3,zpt
> tst_a $5a,$ff
1efc : 08 > php ;save flags
1efd : c95a > cmp #$5a ;test result
> trap_ne
1eff : d0fe > bne * ;failed not equal (non zero)
>
1f01 : 68 > pla ;load status
1f02 : 48 > pha
> cmp_flag $ff
1f03 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f05 : d0fe > bne * ;failed not equal (non zero)
>
1f07 : 28 > plp ;restore status
>
1f08 : a50a > lda zpt
> trap_ne ;wrong bits set or cleared
1f0a : d0fe > bne * ;failed not equal (non zero)
>
rmbt 4
1f0c : a9ff > lda #$ff
1f0e : 850a > sta zpt
> set_a $a5,0
> load_flag 0
1f10 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f12 : 48 > pha ;use stack to load status
1f13 : a9a5 > lda #$a5 ;precharge accu
1f15 : 28 > plp
>
1f16 : 470a > rmb 4,zpt
> tst_a $a5,0
1f18 : 08 > php ;save flags
1f19 : c9a5 > cmp #$a5 ;test result
> trap_ne
1f1b : d0fe > bne * ;failed not equal (non zero)
>
1f1d : 68 > pla ;load status
1f1e : 48 > pha
> cmp_flag 0
1f1f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f21 : d0fe > bne * ;failed not equal (non zero)
>
1f23 : 28 > plp ;restore status
>
1f24 : a50a > lda zpt
1f26 : c9ef > cmp #$ff-(1<<4)
> trap_ne ;wrong bits set or cleared
1f28 : d0fe > bne * ;failed not equal (non zero)
>
1f2a : a910 > lda #1<<4
1f2c : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
1f2e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1f30 : 48 > pha ;use stack to load status
1f31 : a95a > lda #$5a ;precharge accu
1f33 : 28 > plp
>
1f34 : 470a > rmb 4,zpt
> tst_a $5a,$ff
1f36 : 08 > php ;save flags
1f37 : c95a > cmp #$5a ;test result
> trap_ne
1f39 : d0fe > bne * ;failed not equal (non zero)
>
1f3b : 68 > pla ;load status
1f3c : 48 > pha
> cmp_flag $ff
1f3d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f3f : d0fe > bne * ;failed not equal (non zero)
>
1f41 : 28 > plp ;restore status
>
1f42 : a50a > lda zpt
> trap_ne ;wrong bits set or cleared
1f44 : d0fe > bne * ;failed not equal (non zero)
>
rmbt 5
1f46 : a9ff > lda #$ff
1f48 : 850a > sta zpt
> set_a $a5,0
> load_flag 0
1f4a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f4c : 48 > pha ;use stack to load status
1f4d : a9a5 > lda #$a5 ;precharge accu
1f4f : 28 > plp
>
1f50 : 570a > rmb 5,zpt
> tst_a $a5,0
1f52 : 08 > php ;save flags
1f53 : c9a5 > cmp #$a5 ;test result
> trap_ne
1f55 : d0fe > bne * ;failed not equal (non zero)
>
1f57 : 68 > pla ;load status
1f58 : 48 > pha
> cmp_flag 0
1f59 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f5b : d0fe > bne * ;failed not equal (non zero)
>
1f5d : 28 > plp ;restore status
>
1f5e : a50a > lda zpt
1f60 : c9df > cmp #$ff-(1<<5)
> trap_ne ;wrong bits set or cleared
1f62 : d0fe > bne * ;failed not equal (non zero)
>
1f64 : a920 > lda #1<<5
1f66 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
1f68 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1f6a : 48 > pha ;use stack to load status
1f6b : a95a > lda #$5a ;precharge accu
1f6d : 28 > plp
>
1f6e : 570a > rmb 5,zpt
> tst_a $5a,$ff
1f70 : 08 > php ;save flags
1f71 : c95a > cmp #$5a ;test result
> trap_ne
1f73 : d0fe > bne * ;failed not equal (non zero)
>
1f75 : 68 > pla ;load status
1f76 : 48 > pha
> cmp_flag $ff
1f77 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f79 : d0fe > bne * ;failed not equal (non zero)
>
1f7b : 28 > plp ;restore status
>
1f7c : a50a > lda zpt
> trap_ne ;wrong bits set or cleared
1f7e : d0fe > bne * ;failed not equal (non zero)
>
rmbt 6
1f80 : a9ff > lda #$ff
1f82 : 850a > sta zpt
> set_a $a5,0
> load_flag 0
1f84 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f86 : 48 > pha ;use stack to load status
1f87 : a9a5 > lda #$a5 ;precharge accu
1f89 : 28 > plp
>
1f8a : 670a > rmb 6,zpt
> tst_a $a5,0
1f8c : 08 > php ;save flags
1f8d : c9a5 > cmp #$a5 ;test result
> trap_ne
1f8f : d0fe > bne * ;failed not equal (non zero)
>
1f91 : 68 > pla ;load status
1f92 : 48 > pha
> cmp_flag 0
1f93 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f95 : d0fe > bne * ;failed not equal (non zero)
>
1f97 : 28 > plp ;restore status
>
1f98 : a50a > lda zpt
1f9a : c9bf > cmp #$ff-(1<<6)
> trap_ne ;wrong bits set or cleared
1f9c : d0fe > bne * ;failed not equal (non zero)
>
1f9e : a940 > lda #1<<6
1fa0 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
1fa2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1fa4 : 48 > pha ;use stack to load status
1fa5 : a95a > lda #$5a ;precharge accu
1fa7 : 28 > plp
>
1fa8 : 670a > rmb 6,zpt
> tst_a $5a,$ff
1faa : 08 > php ;save flags
1fab : c95a > cmp #$5a ;test result
> trap_ne
1fad : d0fe > bne * ;failed not equal (non zero)
>
1faf : 68 > pla ;load status
1fb0 : 48 > pha
> cmp_flag $ff
1fb1 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fb3 : d0fe > bne * ;failed not equal (non zero)
>
1fb5 : 28 > plp ;restore status
>
1fb6 : a50a > lda zpt
> trap_ne ;wrong bits set or cleared
1fb8 : d0fe > bne * ;failed not equal (non zero)
>
rmbt 7
1fba : a9ff > lda #$ff
1fbc : 850a > sta zpt
> set_a $a5,0
> load_flag 0
1fbe : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1fc0 : 48 > pha ;use stack to load status
1fc1 : a9a5 > lda #$a5 ;precharge accu
1fc3 : 28 > plp
>
1fc4 : 770a > rmb 7,zpt
> tst_a $a5,0
1fc6 : 08 > php ;save flags
1fc7 : c9a5 > cmp #$a5 ;test result
> trap_ne
1fc9 : d0fe > bne * ;failed not equal (non zero)
>
1fcb : 68 > pla ;load status
1fcc : 48 > pha
> cmp_flag 0
1fcd : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fcf : d0fe > bne * ;failed not equal (non zero)
>
1fd1 : 28 > plp ;restore status
>
1fd2 : a50a > lda zpt
1fd4 : c97f > cmp #$ff-(1<<7)
> trap_ne ;wrong bits set or cleared
1fd6 : d0fe > bne * ;failed not equal (non zero)
>
1fd8 : a980 > lda #1<<7
1fda : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
1fdc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1fde : 48 > pha ;use stack to load status
1fdf : a95a > lda #$5a ;precharge accu
1fe1 : 28 > plp
>
1fe2 : 770a > rmb 7,zpt
> tst_a $5a,$ff
1fe4 : 08 > php ;save flags
1fe5 : c95a > cmp #$5a ;test result
> trap_ne
1fe7 : d0fe > bne * ;failed not equal (non zero)
>
1fe9 : 68 > pla ;load status
1fea : 48 > pha
> cmp_flag $ff
1feb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fed : d0fe > bne * ;failed not equal (non zero)
>
1fef : 28 > plp ;restore status
>
1ff0 : a50a > lda zpt
> trap_ne ;wrong bits set or cleared
1ff2 : d0fe > bne * ;failed not equal (non zero)
>
smbt 0
1ff4 : a9fe > lda #$ff-(1<<0)
1ff6 : 850a > sta zpt
> set_a $a5,0
> load_flag 0
1ff8 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ffa : 48 > pha ;use stack to load status
1ffb : a9a5 > lda #$a5 ;precharge accu
1ffd : 28 > plp
>
1ffe : 870a > smb 0,zpt
> tst_a $a5,0
2000 : 08 > php ;save flags
2001 : c9a5 > cmp #$a5 ;test result
> trap_ne
2003 : d0fe > bne * ;failed not equal (non zero)
>
2005 : 68 > pla ;load status
2006 : 48 > pha
> cmp_flag 0
2007 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2009 : d0fe > bne * ;failed not equal (non zero)
>
200b : 28 > plp ;restore status
>
200c : a50a > lda zpt
200e : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
2010 : d0fe > bne * ;failed not equal (non zero)
>
2012 : a900 > lda #0
2014 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
2016 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2018 : 48 > pha ;use stack to load status
2019 : a95a > lda #$5a ;precharge accu
201b : 28 > plp
>
201c : 870a > smb 0,zpt
> tst_a $5a,$ff
201e : 08 > php ;save flags
201f : c95a > cmp #$5a ;test result
> trap_ne
2021 : d0fe > bne * ;failed not equal (non zero)
>
2023 : 68 > pla ;load status
2024 : 48 > pha
> cmp_flag $ff
2025 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2027 : d0fe > bne * ;failed not equal (non zero)
>
2029 : 28 > plp ;restore status
>
202a : a50a > lda zpt
202c : c901 > cmp #1<<0
> trap_ne ;wrong bits set or cleared
202e : d0fe > bne * ;failed not equal (non zero)
>
smbt 1
2030 : a9fd > lda #$ff-(1<<1)
2032 : 850a > sta zpt
> set_a $a5,0
> load_flag 0
2034 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2036 : 48 > pha ;use stack to load status
2037 : a9a5 > lda #$a5 ;precharge accu
2039 : 28 > plp
>
203a : 970a > smb 1,zpt
> tst_a $a5,0
203c : 08 > php ;save flags
203d : c9a5 > cmp #$a5 ;test result
> trap_ne
203f : d0fe > bne * ;failed not equal (non zero)
>
2041 : 68 > pla ;load status
2042 : 48 > pha
> cmp_flag 0
2043 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2045 : d0fe > bne * ;failed not equal (non zero)
>
2047 : 28 > plp ;restore status
>
2048 : a50a > lda zpt
204a : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
204c : d0fe > bne * ;failed not equal (non zero)
>
204e : a900 > lda #0
2050 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
2052 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2054 : 48 > pha ;use stack to load status
2055 : a95a > lda #$5a ;precharge accu
2057 : 28 > plp
>
2058 : 970a > smb 1,zpt
> tst_a $5a,$ff
205a : 08 > php ;save flags
205b : c95a > cmp #$5a ;test result
> trap_ne
205d : d0fe > bne * ;failed not equal (non zero)
>
205f : 68 > pla ;load status
2060 : 48 > pha
> cmp_flag $ff
2061 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2063 : d0fe > bne * ;failed not equal (non zero)
>
2065 : 28 > plp ;restore status
>
2066 : a50a > lda zpt
2068 : c902 > cmp #1<<1
> trap_ne ;wrong bits set or cleared
206a : d0fe > bne * ;failed not equal (non zero)
>
smbt 2
206c : a9fb > lda #$ff-(1<<2)
206e : 850a > sta zpt
> set_a $a5,0
> load_flag 0
2070 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2072 : 48 > pha ;use stack to load status
2073 : a9a5 > lda #$a5 ;precharge accu
2075 : 28 > plp
>
2076 : a70a > smb 2,zpt
> tst_a $a5,0
2078 : 08 > php ;save flags
2079 : c9a5 > cmp #$a5 ;test result
> trap_ne
207b : d0fe > bne * ;failed not equal (non zero)
>
207d : 68 > pla ;load status
207e : 48 > pha
> cmp_flag 0
207f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2081 : d0fe > bne * ;failed not equal (non zero)
>
2083 : 28 > plp ;restore status
>
2084 : a50a > lda zpt
2086 : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
2088 : d0fe > bne * ;failed not equal (non zero)
>
208a : a900 > lda #0
208c : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
208e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2090 : 48 > pha ;use stack to load status
2091 : a95a > lda #$5a ;precharge accu
2093 : 28 > plp
>
2094 : a70a > smb 2,zpt
> tst_a $5a,$ff
2096 : 08 > php ;save flags
2097 : c95a > cmp #$5a ;test result
> trap_ne
2099 : d0fe > bne * ;failed not equal (non zero)
>
209b : 68 > pla ;load status
209c : 48 > pha
> cmp_flag $ff
209d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
209f : d0fe > bne * ;failed not equal (non zero)
>
20a1 : 28 > plp ;restore status
>
20a2 : a50a > lda zpt
20a4 : c904 > cmp #1<<2
> trap_ne ;wrong bits set or cleared
20a6 : d0fe > bne * ;failed not equal (non zero)
>
smbt 3
20a8 : a9f7 > lda #$ff-(1<<3)
20aa : 850a > sta zpt
> set_a $a5,0
> load_flag 0
20ac : a900 > lda #0 ;allow test to change I-flag (no mask)
>
20ae : 48 > pha ;use stack to load status
20af : a9a5 > lda #$a5 ;precharge accu
20b1 : 28 > plp
>
20b2 : b70a > smb 3,zpt
> tst_a $a5,0
20b4 : 08 > php ;save flags
20b5 : c9a5 > cmp #$a5 ;test result
> trap_ne
20b7 : d0fe > bne * ;failed not equal (non zero)
>
20b9 : 68 > pla ;load status
20ba : 48 > pha
> cmp_flag 0
20bb : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20bd : d0fe > bne * ;failed not equal (non zero)
>
20bf : 28 > plp ;restore status
>
20c0 : a50a > lda zpt
20c2 : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
20c4 : d0fe > bne * ;failed not equal (non zero)
>
20c6 : a900 > lda #0
20c8 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
20ca : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
20cc : 48 > pha ;use stack to load status
20cd : a95a > lda #$5a ;precharge accu
20cf : 28 > plp
>
20d0 : b70a > smb 3,zpt
> tst_a $5a,$ff
20d2 : 08 > php ;save flags
20d3 : c95a > cmp #$5a ;test result
> trap_ne
20d5 : d0fe > bne * ;failed not equal (non zero)
>
20d7 : 68 > pla ;load status
20d8 : 48 > pha
> cmp_flag $ff
20d9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20db : d0fe > bne * ;failed not equal (non zero)
>
20dd : 28 > plp ;restore status
>
20de : a50a > lda zpt
20e0 : c908 > cmp #1<<3
> trap_ne ;wrong bits set or cleared
20e2 : d0fe > bne * ;failed not equal (non zero)
>
smbt 4
20e4 : a9ef > lda #$ff-(1<<4)
20e6 : 850a > sta zpt
> set_a $a5,0
> load_flag 0
20e8 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
20ea : 48 > pha ;use stack to load status
20eb : a9a5 > lda #$a5 ;precharge accu
20ed : 28 > plp
>
20ee : c70a > smb 4,zpt
> tst_a $a5,0
20f0 : 08 > php ;save flags
20f1 : c9a5 > cmp #$a5 ;test result
> trap_ne
20f3 : d0fe > bne * ;failed not equal (non zero)
>
20f5 : 68 > pla ;load status
20f6 : 48 > pha
> cmp_flag 0
20f7 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20f9 : d0fe > bne * ;failed not equal (non zero)
>
20fb : 28 > plp ;restore status
>
20fc : a50a > lda zpt
20fe : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
2100 : d0fe > bne * ;failed not equal (non zero)
>
2102 : a900 > lda #0
2104 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
2106 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2108 : 48 > pha ;use stack to load status
2109 : a95a > lda #$5a ;precharge accu
210b : 28 > plp
>
210c : c70a > smb 4,zpt
> tst_a $5a,$ff
210e : 08 > php ;save flags
210f : c95a > cmp #$5a ;test result
> trap_ne
2111 : d0fe > bne * ;failed not equal (non zero)
>
2113 : 68 > pla ;load status
2114 : 48 > pha
> cmp_flag $ff
2115 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2117 : d0fe > bne * ;failed not equal (non zero)
>
2119 : 28 > plp ;restore status
>
211a : a50a > lda zpt
211c : c910 > cmp #1<<4
> trap_ne ;wrong bits set or cleared
211e : d0fe > bne * ;failed not equal (non zero)
>
smbt 5
2120 : a9df > lda #$ff-(1<<5)
2122 : 850a > sta zpt
> set_a $a5,0
> load_flag 0
2124 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2126 : 48 > pha ;use stack to load status
2127 : a9a5 > lda #$a5 ;precharge accu
2129 : 28 > plp
>
212a : d70a > smb 5,zpt
> tst_a $a5,0
212c : 08 > php ;save flags
212d : c9a5 > cmp #$a5 ;test result
> trap_ne
212f : d0fe > bne * ;failed not equal (non zero)
>
2131 : 68 > pla ;load status
2132 : 48 > pha
> cmp_flag 0
2133 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2135 : d0fe > bne * ;failed not equal (non zero)
>
2137 : 28 > plp ;restore status
>
2138 : a50a > lda zpt
213a : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
213c : d0fe > bne * ;failed not equal (non zero)
>
213e : a900 > lda #0
2140 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
2142 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2144 : 48 > pha ;use stack to load status
2145 : a95a > lda #$5a ;precharge accu
2147 : 28 > plp
>
2148 : d70a > smb 5,zpt
> tst_a $5a,$ff
214a : 08 > php ;save flags
214b : c95a > cmp #$5a ;test result
> trap_ne
214d : d0fe > bne * ;failed not equal (non zero)
>
214f : 68 > pla ;load status
2150 : 48 > pha
> cmp_flag $ff
2151 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2153 : d0fe > bne * ;failed not equal (non zero)
>
2155 : 28 > plp ;restore status
>
2156 : a50a > lda zpt
2158 : c920 > cmp #1<<5
> trap_ne ;wrong bits set or cleared
215a : d0fe > bne * ;failed not equal (non zero)
>
smbt 6
215c : a9bf > lda #$ff-(1<<6)
215e : 850a > sta zpt
> set_a $a5,0
> load_flag 0
2160 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2162 : 48 > pha ;use stack to load status
2163 : a9a5 > lda #$a5 ;precharge accu
2165 : 28 > plp
>
2166 : e70a > smb 6,zpt
> tst_a $a5,0
2168 : 08 > php ;save flags
2169 : c9a5 > cmp #$a5 ;test result
> trap_ne
216b : d0fe > bne * ;failed not equal (non zero)
>
216d : 68 > pla ;load status
216e : 48 > pha
> cmp_flag 0
216f : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2171 : d0fe > bne * ;failed not equal (non zero)
>
2173 : 28 > plp ;restore status
>
2174 : a50a > lda zpt
2176 : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
2178 : d0fe > bne * ;failed not equal (non zero)
>
217a : a900 > lda #0
217c : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
217e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2180 : 48 > pha ;use stack to load status
2181 : a95a > lda #$5a ;precharge accu
2183 : 28 > plp
>
2184 : e70a > smb 6,zpt
> tst_a $5a,$ff
2186 : 08 > php ;save flags
2187 : c95a > cmp #$5a ;test result
> trap_ne
2189 : d0fe > bne * ;failed not equal (non zero)
>
218b : 68 > pla ;load status
218c : 48 > pha
> cmp_flag $ff
218d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
218f : d0fe > bne * ;failed not equal (non zero)
>
2191 : 28 > plp ;restore status
>
2192 : a50a > lda zpt
2194 : c940 > cmp #1<<6
> trap_ne ;wrong bits set or cleared
2196 : d0fe > bne * ;failed not equal (non zero)
>
smbt 7
2198 : a97f > lda #$ff-(1<<7)
219a : 850a > sta zpt
> set_a $a5,0
> load_flag 0
219c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
219e : 48 > pha ;use stack to load status
219f : a9a5 > lda #$a5 ;precharge accu
21a1 : 28 > plp
>
21a2 : f70a > smb 7,zpt
> tst_a $a5,0
21a4 : 08 > php ;save flags
21a5 : c9a5 > cmp #$a5 ;test result
> trap_ne
21a7 : d0fe > bne * ;failed not equal (non zero)
>
21a9 : 68 > pla ;load status
21aa : 48 > pha
> cmp_flag 0
21ab : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21ad : d0fe > bne * ;failed not equal (non zero)
>
21af : 28 > plp ;restore status
>
21b0 : a50a > lda zpt
21b2 : c9ff > cmp #$ff
> trap_ne ;wrong bits set or cleared
21b4 : d0fe > bne * ;failed not equal (non zero)
>
21b6 : a900 > lda #0
21b8 : 850a > sta zpt
> set_a $5a,$ff
> load_flag $ff
21ba : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
21bc : 48 > pha ;use stack to load status
21bd : a95a > lda #$5a ;precharge accu
21bf : 28 > plp
>
21c0 : f70a > smb 7,zpt
> tst_a $5a,$ff
21c2 : 08 > php ;save flags
21c3 : c95a > cmp #$5a ;test result
> trap_ne
21c5 : d0fe > bne * ;failed not equal (non zero)
>
21c7 : 68 > pla ;load status
21c8 : 48 > pha
> cmp_flag $ff
21c9 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21cb : d0fe > bne * ;failed not equal (non zero)
>
21cd : 28 > plp ;restore status
>
21ce : a50a > lda zpt
21d0 : c980 > cmp #1<<7
> trap_ne ;wrong bits set or cleared
21d2 : d0fe > bne * ;failed not equal (non zero)
>
21d4 : e0ba cpx #$ba
trap_ne ;x altered during test
21d6 : d0fe > bne * ;failed not equal (non zero)
21d8 : c0d0 cpy #$d0
trap_ne ;y altered during test
21da : d0fe > bne * ;failed not equal (non zero)
21dc : ba tsx
21dd : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
21df : d0fe > bne * ;failed not equal (non zero)
next_test
21e1 : ad0202 > lda test_case ;previous test
21e4 : c911 > cmp #test_num
> trap_ne ;test is out of sequence
21e6 : d0fe > bne * ;failed not equal (non zero)
>
0012 = >test_num = test_num + 1
21e8 : a912 > lda #test_num ;*** next tests' number
21ea : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
endif
; testing CMP - (zp)
21ed : a2de ldx #$de ;protect x & y
21ef : a0ad ldy #$ad
set_a $80,0
> load_flag 0
21f1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
21f3 : 48 > pha ;use stack to load status
21f4 : a980 > lda #$80 ;precharge accu
21f6 : 28 > plp
21f7 : d22a cmp (ind1+8)
tst_a $80,fc
21f9 : 08 > php ;save flags
21fa : c980 > cmp #$80 ;test result
> trap_ne
21fc : d0fe > bne * ;failed not equal (non zero)
>
21fe : 68 > pla ;load status
21ff : 48 > pha
> cmp_flag fc
2200 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2202 : d0fe > bne * ;failed not equal (non zero)
>
2204 : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
2205 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2207 : 48 > pha ;use stack to load status
2208 : a97f > lda #$7f ;precharge accu
220a : 28 > plp
220b : d22a cmp (ind1+8)
tst_a $7f,fzc
220d : 08 > php ;save flags
220e : c97f > cmp #$7f ;test result
> trap_ne
2210 : d0fe > bne * ;failed not equal (non zero)
>
2212 : 68 > pla ;load status
2213 : 48 > pha
> cmp_flag fzc
2214 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2216 : d0fe > bne * ;failed not equal (non zero)
>
2218 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
2219 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
221b : 48 > pha ;use stack to load status
221c : a97e > lda #$7e ;precharge accu
221e : 28 > plp
221f : d22a cmp (ind1+8)
tst_a $7e,fn
2221 : 08 > php ;save flags
2222 : c97e > cmp #$7e ;test result
> trap_ne
2224 : d0fe > bne * ;failed not equal (non zero)
>
2226 : 68 > pla ;load status
2227 : 48 > pha
> cmp_flag fn
2228 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
222a : d0fe > bne * ;failed not equal (non zero)
>
222c : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
222d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
222f : 48 > pha ;use stack to load status
2230 : a980 > lda #$80 ;precharge accu
2232 : 28 > plp
2233 : d22a cmp (ind1+8)
tst_a $80,~fnz
2235 : 08 > php ;save flags
2236 : c980 > cmp #$80 ;test result
> trap_ne
2238 : d0fe > bne * ;failed not equal (non zero)
>
223a : 68 > pla ;load status
223b : 48 > pha
> cmp_flag ~fnz
223c : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
223e : d0fe > bne * ;failed not equal (non zero)
>
2240 : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
2241 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2243 : 48 > pha ;use stack to load status
2244 : a97f > lda #$7f ;precharge accu
2246 : 28 > plp
2247 : d22a cmp (ind1+8)
tst_a $7f,~fn
2249 : 08 > php ;save flags
224a : c97f > cmp #$7f ;test result
> trap_ne
224c : d0fe > bne * ;failed not equal (non zero)
>
224e : 68 > pla ;load status
224f : 48 > pha
> cmp_flag ~fn
2250 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2252 : d0fe > bne * ;failed not equal (non zero)
>
2254 : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
2255 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2257 : 48 > pha ;use stack to load status
2258 : a97e > lda #$7e ;precharge accu
225a : 28 > plp
225b : d22a cmp (ind1+8)
tst_a $7e,~fzc
225d : 08 > php ;save flags
225e : c97e > cmp #$7e ;test result
> trap_ne
2260 : d0fe > bne * ;failed not equal (non zero)
>
2262 : 68 > pla ;load status
2263 : 48 > pha
> cmp_flag ~fzc
2264 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2266 : d0fe > bne * ;failed not equal (non zero)
>
2268 : 28 > plp ;restore status
2269 : e0de cpx #$de
trap_ne ;x altered during test
226b : d0fe > bne * ;failed not equal (non zero)
226d : c0ad cpy #$ad
trap_ne ;y altered during test
226f : d0fe > bne * ;failed not equal (non zero)
2271 : ba tsx
2272 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
2274 : d0fe > bne * ;failed not equal (non zero)
next_test
2276 : ad0202 > lda test_case ;previous test
2279 : c912 > cmp #test_num
> trap_ne ;test is out of sequence
227b : d0fe > bne * ;failed not equal (non zero)
>
0013 = >test_num = test_num + 1
227d : a913 > lda #test_num ;*** next tests' number
227f : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing logical instructions - AND EOR ORA (zp)
2282 : a242 ldx #$42 ;protect x & y
2284 : a000 ldy #0 ;AND
2286 : a538 lda indAN ;set indirect address
2288 : 850a sta zpt
228a : a539 lda indAN+1
228c : 850b sta zpt+1
228e : tand1
set_ay absANa,0
> load_flag 0
228e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2290 : 48 > pha ;use stack to load status
2291 : b94d02 > lda absANa,y ;precharge accu
2294 : 28 > plp
2295 : 320a and (zpt)
tst_ay absrlo,absflo,0
2297 : 08 > php ;save flags
2298 : d95502 > cmp absrlo,y ;test result
> trap_ne ;
229b : d0fe > bne * ;failed not equal (non zero)
>
229d : 68 > pla ;load status
> eor_flag 0
229e : 4930 > eor #0|fao ;invert expected flags + always on bits
>
22a0 : d95902 > cmp absflo,y ;test flags
> trap_ne
22a3 : d0fe > bne * ;failed not equal (non zero)
>
22a5 : e60a inc zpt
22a7 : c8 iny
22a8 : c004 cpy #4
22aa : d0e2 bne tand1
22ac : 88 dey
22ad : c60a dec zpt
22af : tand2
set_ay absANa,$ff
> load_flag $ff
22af : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
22b1 : 48 > pha ;use stack to load status
22b2 : b94d02 > lda absANa,y ;precharge accu
22b5 : 28 > plp
22b6 : 320a and (zpt)
tst_ay absrlo,absflo,$ff-fnz
22b8 : 08 > php ;save flags
22b9 : d95502 > cmp absrlo,y ;test result
> trap_ne ;
22bc : d0fe > bne * ;failed not equal (non zero)
>
22be : 68 > pla ;load status
> eor_flag $ff-fnz
22bf : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
22c1 : d95902 > cmp absflo,y ;test flags
> trap_ne
22c4 : d0fe > bne * ;failed not equal (non zero)
>
22c6 : c60a dec zpt
22c8 : 88 dey
22c9 : 10e4 bpl tand2
22cb : a000 ldy #0 ;EOR
22cd : a540 lda indEO ;set indirect address
22cf : 850a sta zpt
22d1 : a541 lda indEO+1
22d3 : 850b sta zpt+1
22d5 : teor1
set_ay absEOa,0
> load_flag 0
22d5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
22d7 : 48 > pha ;use stack to load status
22d8 : b95102 > lda absEOa,y ;precharge accu
22db : 28 > plp
22dc : 520a eor (zpt)
tst_ay absrlo,absflo,0
22de : 08 > php ;save flags
22df : d95502 > cmp absrlo,y ;test result
> trap_ne ;
22e2 : d0fe > bne * ;failed not equal (non zero)
>
22e4 : 68 > pla ;load status
> eor_flag 0
22e5 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
22e7 : d95902 > cmp absflo,y ;test flags
> trap_ne
22ea : d0fe > bne * ;failed not equal (non zero)
>
22ec : e60a inc zpt
22ee : c8 iny
22ef : c004 cpy #4
22f1 : d0e2 bne teor1
22f3 : 88 dey
22f4 : c60a dec zpt
22f6 : teor2
set_ay absEOa,$ff
> load_flag $ff
22f6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
22f8 : 48 > pha ;use stack to load status
22f9 : b95102 > lda absEOa,y ;precharge accu
22fc : 28 > plp
22fd : 520a eor (zpt)
tst_ay absrlo,absflo,$ff-fnz
22ff : 08 > php ;save flags
2300 : d95502 > cmp absrlo,y ;test result
> trap_ne ;
2303 : d0fe > bne * ;failed not equal (non zero)
>
2305 : 68 > pla ;load status
> eor_flag $ff-fnz
2306 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2308 : d95902 > cmp absflo,y ;test flags
> trap_ne
230b : d0fe > bne * ;failed not equal (non zero)
>
230d : c60a dec zpt
230f : 88 dey
2310 : 10e4 bpl teor2
2312 : a000 ldy #0 ;ORA
2314 : a548 lda indOR ;set indirect address
2316 : 850a sta zpt
2318 : a549 lda indOR+1
231a : 850b sta zpt+1
231c : tora1
set_ay absORa,0
> load_flag 0
231c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
231e : 48 > pha ;use stack to load status
231f : b94902 > lda absORa,y ;precharge accu
2322 : 28 > plp
2323 : 120a ora (zpt)
tst_ay absrlo,absflo,0
2325 : 08 > php ;save flags
2326 : d95502 > cmp absrlo,y ;test result
> trap_ne ;
2329 : d0fe > bne * ;failed not equal (non zero)
>
232b : 68 > pla ;load status
> eor_flag 0
232c : 4930 > eor #0|fao ;invert expected flags + always on bits
>
232e : d95902 > cmp absflo,y ;test flags
> trap_ne
2331 : d0fe > bne * ;failed not equal (non zero)
>
2333 : e60a inc zpt
2335 : c8 iny
2336 : c004 cpy #4
2338 : d0e2 bne tora1
233a : 88 dey
233b : c60a dec zpt
233d : tora2
set_ay absORa,$ff
> load_flag $ff
233d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
233f : 48 > pha ;use stack to load status
2340 : b94902 > lda absORa,y ;precharge accu
2343 : 28 > plp
2344 : 120a ora (zpt)
tst_ay absrlo,absflo,$ff-fnz
2346 : 08 > php ;save flags
2347 : d95502 > cmp absrlo,y ;test result
> trap_ne ;
234a : d0fe > bne * ;failed not equal (non zero)
>
234c : 68 > pla ;load status
> eor_flag $ff-fnz
234d : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
234f : d95902 > cmp absflo,y ;test flags
> trap_ne
2352 : d0fe > bne * ;failed not equal (non zero)
>
2354 : c60a dec zpt
2356 : 88 dey
2357 : 10e4 bpl tora2
2359 : e042 cpx #$42
trap_ne ;x altered during test
235b : d0fe > bne * ;failed not equal (non zero)
235d : ba tsx
235e : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
2360 : d0fe > bne * ;failed not equal (non zero)
next_test
2362 : ad0202 > lda test_case ;previous test
2365 : c913 > cmp #test_num
> trap_ne ;test is out of sequence
2367 : d0fe > bne * ;failed not equal (non zero)
>
0014 = >test_num = test_num + 1
2369 : a914 > lda #test_num ;*** next tests' number
236b : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
if I_flag = 3
236e : 58 cli
endif
; full binary add/subtract test - (zp) only
; iterates through all combinations of operands and carry input
; uses increments/decrements to predict result & result flags
236f : d8 cld
2370 : a20c ldx #ad2 ;for indexed test
2372 : a0ff ldy #$ff ;max range
2374 : a900 lda #0 ;start with adding zeroes & no carry
2376 : 850a sta adfc ;carry in - for diag
2378 : 850b sta ad1 ;operand 1 - accumulator
237a : 850c sta ad2 ;operand 2 - memory or immediate
237c : 8d0502 sta ada2 ;non zp
237f : 850d sta adrl ;expected result bits 0-7
2381 : 850e sta adrh ;expected result bit 8 (carry out)
2383 : a9ff lda #$ff ;complemented operand 2 for subtract
2385 : 8510 sta sb2
2387 : 8d0602 sta sba2 ;non zp
238a : a902 lda #2 ;expected Z-flag
238c : 850f sta adrf
238e : 18 tadd clc ;test with carry clear
238f : 200326 jsr chkadd
2392 : e60a inc adfc ;now with carry
2394 : e60d inc adrl ;result +1
2396 : 08 php ;save N & Z from low result
2397 : 08 php
2398 : 68 pla ;accu holds expected flags
2399 : 2982 and #$82 ;mask N & Z
239b : 28 plp
239c : d002 bne tadd1
239e : e60e inc adrh ;result bit 8 - carry
23a0 : 050e tadd1 ora adrh ;merge C to expected flags
23a2 : 850f sta adrf ;save expected flags except overflow
23a4 : 38 sec ;test with carry set
23a5 : 200326 jsr chkadd
23a8 : c60a dec adfc ;same for operand +1 but no carry
23aa : e60b inc ad1
23ac : d0e0 bne tadd ;iterate op1
23ae : a900 lda #0 ;preset result to op2 when op1 = 0
23b0 : 850e sta adrh
23b2 : ee0502 inc ada2
23b5 : e60c inc ad2
23b7 : 08 php ;save NZ as operand 2 becomes the new result
23b8 : 68 pla
23b9 : 2982 and #$82 ;mask N00000Z0
23bb : 850f sta adrf ;no need to check carry as we are adding to 0
23bd : c610 dec sb2 ;complement subtract operand 2
23bf : ce0602 dec sba2
23c2 : a50c lda ad2
23c4 : 850d sta adrl
23c6 : d0c6 bne tadd ;iterate op2
23c8 : e00c cpx #ad2
trap_ne ;x altered during test
23ca : d0fe > bne * ;failed not equal (non zero)
23cc : c0ff cpy #$ff
trap_ne ;y altered during test
23ce : d0fe > bne * ;failed not equal (non zero)
23d0 : ba tsx
23d1 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
23d3 : d0fe > bne * ;failed not equal (non zero)
next_test
23d5 : ad0202 > lda test_case ;previous test
23d8 : c914 > cmp #test_num
> trap_ne ;test is out of sequence
23da : d0fe > bne * ;failed not equal (non zero)
>
0015 = >test_num = test_num + 1
23dc : a915 > lda #test_num ;*** next tests' number
23de : 8d0202 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; decimal add/subtract test
; *** WARNING - tests documented behavior only! ***
; only valid BCD operands are tested, the V flag is ignored
; although V is declared as beeing valid on the 65C02 it has absolutely
; no use in BCD math. No sign = no overflow!
; iterates through all valid combinations of operands and carry input
; uses increments/decrements to predict result & carry flag
23e1 : f8 sed
23e2 : a20c ldx #ad2 ;for indexed test
23e4 : a0ff ldy #$ff ;max range
23e6 : a999 lda #$99 ;start with adding 99 to 99 with carry
23e8 : 850b sta ad1 ;operand 1 - accumulator
23ea : 850c sta ad2 ;operand 2 - memory or immediate
23ec : 8d0502 sta ada2 ;non zp
23ef : 850d sta adrl ;expected result bits 0-7
23f1 : a901 lda #1 ;set carry in & out
23f3 : 850a sta adfc ;carry in - for diag
23f5 : 850e sta adrh ;expected result bit 8 (carry out)
23f7 : a981 lda #$81 ;set N & C (99 + 99 + C = 99 + C)
23f9 : 850f sta adrf
23fb : a900 lda #0 ;complemented operand 2 for subtract
23fd : 8510 sta sb2
23ff : 8d0602 sta sba2 ;non zp
2402 : 38 tdad sec ;test with carry set
2403 : 20ae24 jsr chkdad
2406 : c60a dec adfc ;now with carry clear
2408 : a50d lda adrl ;decimal adjust result
240a : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1)
240c : c60e dec adrh
240e : a999 lda #$99
2410 : 850d sta adrl
2412 : d012 bne tdad3
2414 : 290f tdad1 and #$f ;lower nibble mask
2416 : d00c bne tdad2 ;no decimal adjust needed
2418 : c60d dec adrl ;decimal adjust (?0-6)
241a : c60d dec adrl
241c : c60d dec adrl
241e : c60d dec adrl
2420 : c60d dec adrl
2422 : c60d dec adrl
2424 : c60d tdad2 dec adrl ;result -1
2426 : 08 tdad3 php ;save valid flags
2427 : 68 pla
2428 : 2982 and #$82 ;N-----Z-
242a : 050e ora adrh ;N-----ZC
242c : 850f sta adrf
242e : 18 clc ;test with carry clear
242f : 20ae24 jsr chkdad
2432 : e60a inc adfc ;same for operand -1 but with carry
2434 : a50b lda ad1 ;decimal adjust operand 1
2436 : f015 beq tdad5 ;iterate operand 2
2438 : 290f and #$f ;lower nibble mask
243a : d00c bne tdad4 ;skip decimal adjust
243c : c60b dec ad1 ;decimal adjust (?0-6)
243e : c60b dec ad1
2440 : c60b dec ad1
2442 : c60b dec ad1
2444 : c60b dec ad1
2446 : c60b dec ad1
2448 : c60b tdad4 dec ad1 ;operand 1 -1
244a : 4c0224 jmp tdad ;iterate op1
244d : a999 tdad5 lda #$99 ;precharge op1 max
244f : 850b sta ad1
2451 : a50c lda ad2 ;decimal adjust operand 2
2453 : f039 beq tdad7 ;end of iteration
2455 : 290f and #$f ;lower nibble mask
2457 : d018 bne tdad6 ;skip decimal adjust
2459 : c60c dec ad2 ;decimal adjust (?0-6)
245b : c60c dec ad2
245d : c60c dec ad2
245f : c60c dec ad2
2461 : c60c dec ad2
2463 : c60c dec ad2
2465 : e610 inc sb2 ;complemented decimal adjust for subtract (?9+6)
2467 : e610 inc sb2
2469 : e610 inc sb2
246b : e610 inc sb2
246d : e610 inc sb2
246f : e610 inc sb2
2471 : c60c tdad6 dec ad2 ;operand 2 -1
2473 : e610 inc sb2 ;complemented operand for subtract
2475 : a510 lda sb2
2477 : 8d0602 sta sba2 ;copy as non zp operand
247a : a50c lda ad2
247c : 8d0502 sta ada2 ;copy as non zp operand
247f : 850d sta adrl ;new result since op1+carry=00+carry +op2=op2
2481 : 08 php ;save flags
2482 : 68 pla
2483 : 2982 and #$82 ;N-----Z-
2485 : 0901 ora #1 ;N-----ZC
2487 : 850f sta adrf
2489 : e60e inc adrh ;result carry
248b : 4c0224 jmp tdad ;iterate op2
248e : e00c tdad7 cpx #ad2
trap_ne ;x altered during test
2490 : d0fe > bne * ;failed not equal (non zero)
2492 : c0ff cpy #$ff
trap_ne ;y altered during test
2494 : d0fe > bne * ;failed not equal (non zero)
2496 : ba tsx
2497 : e0ff cpx #$ff
trap_ne ;sp push/pop mismatch
2499 : d0fe > bne * ;failed not equal (non zero)
249b : d8 cld
249c : ad0202 lda test_case
249f : c915 cmp #test_num
trap_ne ;previous test is out of sequence
24a1 : d0fe > bne * ;failed not equal (non zero)
24a3 : a9f0 lda #$f0 ;mark opcode testing complete
24a5 : 8d0202 sta test_case
; final RAM integrity test
; verifies that none of the previous tests has altered RAM outside of the
; designated write areas.
check_ram
> ;RAM check disabled - RAM size not set
; *** DEBUG INFO ***
; to debug checksum errors uncomment check_ram in the next_test macro to
; narrow down the responsible opcode.
; may give false errors when monitor, OS or other background activity is
; allowed during previous tests.
; S U C C E S S ************************************************
; -------------
success ;if you get here everything went well
24a8 : 4ca824 > jmp * ;test passed, no errors
; -------------
; S U C C E S S ************************************************
24ab : 4c0004 jmp start ;run again
; core subroutine of the decimal add/subtract test
; *** WARNING - tests documented behavior only! ***
; only valid BCD operands are tested, V flag is ignored
; iterates through all valid combinations of operands and carry input
; uses increments/decrements to predict result & carry flag
24ae : chkdad
; decimal ADC / SBC zp
24ae : 08 php ;save carry for subtract
24af : a50b lda ad1
24b1 : 650c adc ad2 ;perform add
24b3 : 08 php
24b4 : c50d cmp adrl ;check result
trap_ne ;bad result
24b6 : d0fe > bne * ;failed not equal (non zero)
24b8 : 68 pla ;check flags
24b9 : 2983 and #$83 ;mask N-----ZC
24bb : c50f cmp adrf
trap_ne ;bad flags
24bd : d0fe > bne * ;failed not equal (non zero)
24bf : 28 plp
24c0 : 08 php ;save carry for next add
24c1 : a50b lda ad1
24c3 : e510 sbc sb2 ;perform subtract
24c5 : 08 php
24c6 : c50d cmp adrl ;check result
trap_ne ;bad result
24c8 : d0fe > bne * ;failed not equal (non zero)
24ca : 68 pla ;check flags
24cb : 2983 and #$83 ;mask N-----ZC
24cd : c50f cmp adrf
trap_ne ;bad flags
24cf : d0fe > bne * ;failed not equal (non zero)
24d1 : 28 plp
; decimal ADC / SBC abs
24d2 : 08 php ;save carry for subtract
24d3 : a50b lda ad1
24d5 : 6d0502 adc ada2 ;perform add
24d8 : 08 php
24d9 : c50d cmp adrl ;check result
trap_ne ;bad result
24db : d0fe > bne * ;failed not equal (non zero)
24dd : 68 pla ;check flags
24de : 2983 and #$83 ;mask N-----ZC
24e0 : c50f cmp adrf
trap_ne ;bad flags
24e2 : d0fe > bne * ;failed not equal (non zero)
24e4 : 28 plp
24e5 : 08 php ;save carry for next add
24e6 : a50b lda ad1
24e8 : ed0602 sbc sba2 ;perform subtract
24eb : 08 php
24ec : c50d cmp adrl ;check result
trap_ne ;bad result
24ee : d0fe > bne * ;failed not equal (non zero)
24f0 : 68 pla ;check flags
24f1 : 2983 and #$83 ;mask N-----ZC
24f3 : c50f cmp adrf
trap_ne ;bad flags
24f5 : d0fe > bne * ;failed not equal (non zero)
24f7 : 28 plp
; decimal ADC / SBC #
24f8 : 08 php ;save carry for subtract
24f9 : a50c lda ad2
24fb : 8d0125 sta chkdadi ;self modify immediate
24fe : a50b lda ad1
2501 = chkdadi = * + 1 ;operand of the immediate ADC
2500 : 6900 adc #0 ;perform add
2502 : 08 php
2503 : c50d cmp adrl ;check result
trap_ne ;bad result
2505 : d0fe > bne * ;failed not equal (non zero)
2507 : 68 pla ;check flags
2508 : 2983 and #$83 ;mask N-----ZC
250a : c50f cmp adrf
trap_ne ;bad flags
250c : d0fe > bne * ;failed not equal (non zero)
250e : 28 plp
250f : 08 php ;save carry for next add
2510 : a510 lda sb2
2512 : 8d1825 sta chkdsbi ;self modify immediate
2515 : a50b lda ad1
2518 = chkdsbi = * + 1 ;operand of the immediate SBC
2517 : e900 sbc #0 ;perform subtract
2519 : 08 php
251a : c50d cmp adrl ;check result
trap_ne ;bad result
251c : d0fe > bne * ;failed not equal (non zero)
251e : 68 pla ;check flags
251f : 2983 and #$83 ;mask N-----ZC
2521 : c50f cmp adrf
trap_ne ;bad flags
2523 : d0fe > bne * ;failed not equal (non zero)
2525 : 28 plp
; decimal ADC / SBC zp,x
2526 : 08 php ;save carry for subtract
2527 : a50b lda ad1
2529 : 7500 adc 0,x ;perform add
252b : 08 php
252c : c50d cmp adrl ;check result
trap_ne ;bad result
252e : d0fe > bne * ;failed not equal (non zero)
2530 : 68 pla ;check flags
2531 : 2983 and #$83 ;mask N-----ZC
2533 : c50f cmp adrf
trap_ne ;bad flags
2535 : d0fe > bne * ;failed not equal (non zero)
2537 : 28 plp
2538 : 08 php ;save carry for next add
2539 : a50b lda ad1
253b : f504 sbc sb2-ad2,x ;perform subtract
253d : 08 php
253e : c50d cmp adrl ;check result
trap_ne ;bad result
2540 : d0fe > bne * ;failed not equal (non zero)
2542 : 68 pla ;check flags
2543 : 2983 and #$83 ;mask N-----ZC
2545 : c50f cmp adrf
trap_ne ;bad flags
2547 : d0fe > bne * ;failed not equal (non zero)
2549 : 28 plp
; decimal ADC / SBC abs,x
254a : 08 php ;save carry for subtract
254b : a50b lda ad1
254d : 7df901 adc ada2-ad2,x ;perform add
2550 : 08 php
2551 : c50d cmp adrl ;check result
trap_ne ;bad result
2553 : d0fe > bne * ;failed not equal (non zero)
2555 : 68 pla ;check flags
2556 : 2983 and #$83 ;mask N-----ZC
2558 : c50f cmp adrf
trap_ne ;bad flags
255a : d0fe > bne * ;failed not equal (non zero)
255c : 28 plp
255d : 08 php ;save carry for next add
255e : a50b lda ad1
2560 : fdfa01 sbc sba2-ad2,x ;perform subtract
2563 : 08 php
2564 : c50d cmp adrl ;check result
trap_ne ;bad result
2566 : d0fe > bne * ;failed not equal (non zero)
2568 : 68 pla ;check flags
2569 : 2983 and #$83 ;mask N-----ZC
256b : c50f cmp adrf
trap_ne ;bad flags
256d : d0fe > bne * ;failed not equal (non zero)
256f : 28 plp
; decimal ADC / SBC abs,y
2570 : 08 php ;save carry for subtract
2571 : a50b lda ad1
2573 : 790601 adc ada2-$ff,y ;perform add
2576 : 08 php
2577 : c50d cmp adrl ;check result
trap_ne ;bad result
2579 : d0fe > bne * ;failed not equal (non zero)
257b : 68 pla ;check flags
257c : 2983 and #$83 ;mask N-----ZC
257e : c50f cmp adrf
trap_ne ;bad flags
2580 : d0fe > bne * ;failed not equal (non zero)
2582 : 28 plp
2583 : 08 php ;save carry for next add
2584 : a50b lda ad1
2586 : f90701 sbc sba2-$ff,y ;perform subtract
2589 : 08 php
258a : c50d cmp adrl ;check result
trap_ne ;bad result
258c : d0fe > bne * ;failed not equal (non zero)
258e : 68 pla ;check flags
258f : 2983 and #$83 ;mask N-----ZC
2591 : c50f cmp adrf
trap_ne ;bad flags
2593 : d0fe > bne * ;failed not equal (non zero)
2595 : 28 plp
; decimal ADC / SBC (zp,x)
2596 : 08 php ;save carry for subtract
2597 : a50b lda ad1
2599 : 6144 adc (lo adi2-ad2,x) ;perform add
259b : 08 php
259c : c50d cmp adrl ;check result
trap_ne ;bad result
259e : d0fe > bne * ;failed not equal (non zero)
25a0 : 68 pla ;check flags
25a1 : 2983 and #$83 ;mask N-----ZC
25a3 : c50f cmp adrf
trap_ne ;bad flags
25a5 : d0fe > bne * ;failed not equal (non zero)
25a7 : 28 plp
25a8 : 08 php ;save carry for next add
25a9 : a50b lda ad1
25ab : e146 sbc (lo sbi2-ad2,x) ;perform subtract
25ad : 08 php
25ae : c50d cmp adrl ;check result
trap_ne ;bad result
25b0 : d0fe > bne * ;failed not equal (non zero)
25b2 : 68 pla ;check flags
25b3 : 2983 and #$83 ;mask N-----ZC
25b5 : c50f cmp adrf
trap_ne ;bad flags
25b7 : d0fe > bne * ;failed not equal (non zero)
25b9 : 28 plp
; decimal ADC / SBC (abs),y
25ba : 08 php ;save carry for subtract
25bb : a50b lda ad1
25bd : 7154 adc (adiy2),y ;perform add
25bf : 08 php
25c0 : c50d cmp adrl ;check result
trap_ne ;bad result
25c2 : d0fe > bne * ;failed not equal (non zero)
25c4 : 68 pla ;check flags
25c5 : 2983 and #$83 ;mask N-----ZC
25c7 : c50f cmp adrf
trap_ne ;bad flags
25c9 : d0fe > bne * ;failed not equal (non zero)
25cb : 28 plp
25cc : 08 php ;save carry for next add
25cd : a50b lda ad1
25cf : f156 sbc (sbiy2),y ;perform subtract
25d1 : 08 php
25d2 : c50d cmp adrl ;check result
trap_ne ;bad result
25d4 : d0fe > bne * ;failed not equal (non zero)
25d6 : 68 pla ;check flags
25d7 : 2983 and #$83 ;mask N-----ZC
25d9 : c50f cmp adrf
trap_ne ;bad flags
25db : d0fe > bne * ;failed not equal (non zero)
25dd : 28 plp
; decimal ADC / SBC (zp)
25de : 08 php ;save carry for subtract
25df : a50b lda ad1
25e1 : 7250 adc (adi2) ;perform add
25e3 : 08 php
25e4 : c50d cmp adrl ;check result
trap_ne ;bad result
25e6 : d0fe > bne * ;failed not equal (non zero)
25e8 : 68 pla ;check flags
25e9 : 2983 and #$83 ;mask N-----ZC
25eb : c50f cmp adrf
trap_ne ;bad flags
25ed : d0fe > bne * ;failed not equal (non zero)
25ef : 28 plp
25f0 : 08 php ;save carry for next add
25f1 : a50b lda ad1
25f3 : f252 sbc (sbi2) ;perform subtract
25f5 : 08 php
25f6 : c50d cmp adrl ;check result
trap_ne ;bad result
25f8 : d0fe > bne * ;failed not equal (non zero)
25fa : 68 pla ;check flags
25fb : 2983 and #$83 ;mask N-----ZC
25fd : c50f cmp adrf
trap_ne ;bad flags
25ff : d0fe > bne * ;failed not equal (non zero)
2601 : 28 plp
2602 : 60 rts
; core subroutine of the full binary add/subtract test
; iterates through all combinations of operands and carry input
; uses increments/decrements to predict result & result flags
2603 : a50f chkadd lda adrf ;add V-flag if overflow
2605 : 2983 and #$83 ;keep N-----ZC / clear V
2607 : 48 pha
2608 : a50b lda ad1 ;test sign unequal between operands
260a : 450c eor ad2
260c : 300a bmi ckad1 ;no overflow possible - operands have different sign
260e : a50b lda ad1 ;test sign equal between operands and result
2610 : 450d eor adrl
2612 : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign
2614 : 68 pla
2615 : 0940 ora #$40 ;set V
2617 : 48 pha
2618 : 68 ckad1 pla
2619 : 850f sta adrf ;save expected flags
; binary ADC / SBC (zp)
261b : 08 php ;save carry for subtract
261c : a50b lda ad1
261e : 7250 adc (adi2) ;perform add
2620 : 08 php
2621 : c50d cmp adrl ;check result
trap_ne ;bad result
2623 : d0fe > bne * ;failed not equal (non zero)
2625 : 68 pla ;check flags
2626 : 29c3 and #$c3 ;mask NV----ZC
2628 : c50f cmp adrf
trap_ne ;bad flags
262a : d0fe > bne * ;failed not equal (non zero)
262c : 28 plp
262d : 08 php ;save carry for next add
262e : a50b lda ad1
2630 : f252 sbc (sbi2) ;perform subtract
2632 : 08 php
2633 : c50d cmp adrl ;check result
trap_ne ;bad result
2635 : d0fe > bne * ;failed not equal (non zero)
2637 : 68 pla ;check flags
2638 : 29c3 and #$c3 ;mask NV----ZC
263a : c50f cmp adrf
trap_ne ;bad flags
263c : d0fe > bne * ;failed not equal (non zero)
263e : 28 plp
263f : 60 rts
; target for the jump indirect test
2640 : 4626 ji_adr dw test_ji
2642 : 8216 dw ji_ret
2644 : 88 dey
2645 : 88 dey
2646 : test_ji
2646 : 08 php ;either SP or Y count will fail, if we do not hit
2647 : 88 dey
2648 : 88 dey
2649 : 88 dey
264a : 28 plp
trap_cs ;flags loaded?
264b : b0fe > bcs * ;failed carry set
trap_vs
264d : 70fe > bvs * ;failed overflow set
trap_mi
264f : 30fe > bmi * ;failed minus (bit 7 set)
trap_eq
2651 : f0fe > beq * ;failed equal (zero)
2653 : c949 cmp #'I' ;registers loaded?
trap_ne
2655 : d0fe > bne * ;failed not equal (non zero)
2657 : e04e cpx #'N'
trap_ne
2659 : d0fe > bne * ;failed not equal (non zero)
265b : c041 cpy #('D'-3)
trap_ne
265d : d0fe > bne * ;failed not equal (non zero)
265f : 48 pha ;save a,x
2660 : 8a txa
2661 : 48 pha
2662 : ba tsx
2663 : e0fd cpx #$fd ;check SP
trap_ne
2665 : d0fe > bne * ;failed not equal (non zero)
2667 : 68 pla ;restore x
2668 : aa tax
set_stat $ff
> load_flag $ff
2669 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
266b : 48 > pha ;use stack to load status
266c : 28 > plp
266d : 68 pla ;restore a
266e : e8 inx ;return registers with modifications
266f : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
2671 : 6cff02 jmp (ji_tab+2)
2674 : ea nop
2675 : ea nop
trap ;runover protection
2676 : 4c7626 > jmp * ;failed anyway
; target for the jump indirect test
2679 : bd26 jxi_adr dw trap_ind
267b : bd26 dw trap_ind
267d : 8726 dw test_jxi ;+4
267f : ce16 dw jxi_ret ;+6
2681 : bd26 dw trap_ind
2683 : bd26 dw trap_ind
2685 : 88 dey
2686 : 88 dey
2687 : test_jxi
2687 : 08 php ;either SP or Y count will fail, if we do not hit
2688 : 88 dey
2689 : 88 dey
268a : 88 dey
268b : 28 plp
trap_cs ;flags loaded?
268c : b0fe > bcs * ;failed carry set
trap_vs
268e : 70fe > bvs * ;failed overflow set
trap_mi
2690 : 30fe > bmi * ;failed minus (bit 7 set)
trap_eq
2692 : f0fe > beq * ;failed equal (zero)
2694 : c958 cmp #'X' ;registers loaded?
trap_ne
2696 : d0fe > bne * ;failed not equal (non zero)
2698 : e004 cpx #4
trap_ne
269a : d0fe > bne * ;failed not equal (non zero)
269c : c046 cpy #('I'-3)
trap_ne
269e : d0fe > bne * ;failed not equal (non zero)
26a0 : 48 pha ;save a,x
26a1 : 8a txa
26a2 : 48 pha
26a3 : ba tsx
26a4 : e0fd cpx #$fd ;check SP
trap_ne
26a6 : d0fe > bne * ;failed not equal (non zero)
26a8 : 68 pla ;restore x
26a9 : aa tax
set_stat $ff
> load_flag $ff
26aa : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
26ac : 48 > pha ;use stack to load status
26ad : 28 > plp
26ae : 68 pla ;restore a
26af : e8 inx ;return registers with modifications
26b0 : e8 inx
26b1 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
26b3 : 7cf902 jmp (jxi_tab,x)
26b6 : ea nop
26b7 : ea nop
trap ;runover protection
26b8 : 4cb826 > jmp * ;failed anyway
; JMP (abs,x) with bad x
26bb : ea nop
26bc : ea nop
26bd : trap_ind
26bd : ea nop
26be : ea nop
trap ;near miss indexed indirect jump
26bf : 4cbf26 > jmp * ;failed anyway
;trap in case of unexpected IRQ, NMI, BRK, RESET
26c2 : nmi_trap
trap ;check stack for conditions at NMI
26c2 : 4cc226 > jmp * ;failed anyway
26c5 : res_trap
trap ;unexpected RESET
26c5 : 4cc526 > jmp * ;failed anyway
26c8 : irq_trap
26c8 : 08 php ;save decimal flag
26c9 : ba tsx ;test break on stack
26ca : bd0201 lda $102,x
26cd : 2910 and #break
trap_eq ;check stack for conditions at IRQ
26cf : f0fe > beq * ;failed equal (zero)
if ROM_vectors = 1
26d1 : 68 pla ;test decimal mode cleared
26d2 : 2908 and #decmode
trap_ne ;decimal mode not cleared after BRK
26d4 : d0fe > bne * ;failed not equal (non zero)
26d6 : 28 plp ;pop saved flags
26d7 : 68 pla ;return address low
26d8 : c917 cmp #lo(brk_ret)
trap_ne ;unexpected BRK
26da : d0fe > bne * ;failed not equal (non zero)
26dc : 68 pla ;return address high
26dd : c917 cmp #hi(brk_ret)
trap_ne ;unexpected BRK
26df : d0fe > bne * ;failed not equal (non zero)
26e1 : 4c1717 jmp brk_ret
else
trap_ne ;check stack for conditions at BRK
endif
if report = 1
include "report.i65"
endif
;copy of data to initialize BSS segment
if load_data_direct != 1
zp_init
zp1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
zp7f_ db $7f ;test pattern for compare
;logical zeropage operands
zpOR_ db 0,$1f,$71,$80 ;test pattern for OR
zpAN_ db $0f,$ff,$7f,$80 ;test pattern for AND
zpEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR
;indirect addressing pointers
ind1_ dw abs1 ;indirect pointer to pattern in absolute memory
dw abs1+1
dw abs1+2
dw abs1+3
dw abs7f
inw1_ dw abs1-$f8 ;indirect pointer for wrap-test pattern
indt_ dw abst ;indirect pointer to store area in absolute memory
dw abst+1
dw abst+2
dw abst+3
inwt_ dw abst-$f8 ;indirect pointer for wrap-test store
indAN_ dw absAN ;indirect pointer to AND pattern in absolute memory
dw absAN+1
dw absAN+2
dw absAN+3
indEO_ dw absEO ;indirect pointer to EOR pattern in absolute memory
dw absEO+1
dw absEO+2
dw absEO+3
indOR_ dw absOR ;indirect pointer to OR pattern in absolute memory
dw absOR+1
dw absOR+2
dw absOR+3
;add/subtract indirect pointers
adi2_ dw ada2 ;indirect pointer to operand 2 in absolute memory
sbi2_ dw sba2 ;indirect pointer to complemented operand 2 (SBC)
adiy2_ dw ada2-$ff ;with offset for indirect indexed
sbiy2_ dw sba2-$ff
zp_end
if (zp_end - zp_init) != (zp_bss_end - zp_bss)
;force assembler error if size is different
ERROR ERROR ERROR ;mismatch between bss and zeropage data
endif
data_init
abs1_ db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
abs7f_ db $7f ;test pattern for compare
;loads
fLDx_ db fn,fn,0,fz ;expected flags for load
;shifts
rASL_ ;expected result ASL & ROL -carry
rROL_ db $86,$04,$82,0 ; "
rROLc_ db $87,$05,$83,1 ;expected result ROL +carry
rLSR_ ;expected result LSR & ROR -carry
rROR_ db $61,$41,$20,0 ; "
rRORc_ db $e1,$c1,$a0,$80 ;expected result ROR +carry
fASL_ ;expected flags for shifts
fROL_ db fnc,fc,fn,fz ;no carry in
fROLc_ db fnc,fc,fn,0 ;carry in
fLSR_
fROR_ db fc,0,fc,fz ;no carry in
fRORc_ db fnc,fn,fnc,fn ;carry in
;increments (decrements)
rINC_ db $7f,$80,$ff,0,1 ;expected result for INC/DEC
fINC_ db 0,fn,fn,fz,0 ;expected flags for INC/DEC
;logical memory operand
absOR_ db 0,$1f,$71,$80 ;test pattern for OR
absAN_ db $0f,$ff,$7f,$80 ;test pattern for AND
absEO_ db $ff,$0f,$8f,$8f ;test pattern for EOR
;logical accu operand
absORa_ db 0,$f1,$1f,0 ;test pattern for OR
absANa_ db $f0,$ff,$ff,$ff ;test pattern for AND
absEOa_ db $ff,$f0,$f0,$0f ;test pattern for EOR
;logical results
absrlo_ db 0,$ff,$7f,$80
absflo_ db fz,fn,0,fn
data_end
if (data_end - data_init) != (data_bss_end - data_bss)
;force assembler error if size is different
ERROR ERROR ERROR ;mismatch between bss and data
endif
vec_init
dw nmi_trap
dw res_trap
dw irq_trap
vec_bss equ $fffa
endif ;end of RAM init data
; code at end of image due to the need to add blank space as required
if ($ff & (ji_ret - * - 2)) < ($ff & (jxi_ret - * - 2))
; JMP (abs) when $xxff and $xx00 are from same page
26e4 : 00000000000000.. ds lo(ji_ret - * - 2)
2780 : ea nop
2781 : ea nop
2782 : ea ji_px nop ;low address byte matched with ji_ret
2783 : ea nop
trap ;jmp indirect page cross bug
2784 : 4c8427 > jmp * ;failed anyway
; JMP (abs,x) when $xxff and $xx00 are from same page
2787 : 00000000000000.. ds lo(jxi_ret - * - 2)
27cc : ea nop
27cd : ea nop
27ce : ea jxi_px nop ;low address byte matched with jxi_ret
27cf : ea nop
trap ;jmp indexed indirect page cross bug
27d0 : 4cd027 > jmp * ;failed anyway
else
; JMP (abs,x) when $xxff and $xx00 are from same page
ds lo(jxi_ret - * - 2)
nop
nop
jxi_px nop ;low address byte matched with jxi_ret
nop
trap ;jmp indexed indirect page cross bug
; JMP (abs) when $xxff and $xx00 are from same page
ds lo(ji_ret - * - 2)
nop
nop
ji_px nop ;low address byte matched with ji_ret
nop
trap ;jmp indirect page cross bug
endif
if (load_data_direct = 1) & (ROM_vectors = 1)
fffa = org $fffa ;vectors
fffa : c226 dw nmi_trap
fffc : c526 dw res_trap
fffe : c826 dw irq_trap
endif
fffa = end start
No errors in pass 2.
Wrote binary from address $0000 through $ffff.
Total size 65536 bytes.
Program start address is at $0400 (1024).
Reference in New Issue View Git Blame Copy Permalink