6502
/
i6502
mirror of https://github.com/ariejan/i6502.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
i6502/test/6502_functional_test.lst

13999 lines
693 KiB
Plaintext
Raw Permalink 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
---------------------------------------------------- 6502_functional_test.a65 ----------------------------------------------------
5803 lines read, no errors in pass 1.
;
; 6 5 0 2 F U N C T I O N A L T E S T
;
; Copyright (C) 2012-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 opcodes of a 6502 emulator using all
; addressing modes with focus on propper setting of the processor status
; register bits.
;
; 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 -h0
; | | | | no page headers in listing
; | | | 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 NMOS 6502 only! No unofficial
; opcodes. Additional opcodes of newer versions of the CPU (65C02, 65816) will
; not be tested. Decimal ops will only be tested with valid BCD operands and
; N V Z flags will be ignored.
;
; 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:
; 28-jul-2012 1st version distributed for testing
; 29-jul-2012 fixed references to location 0, now #0
; added license - GPLv3
; 30-jul-2012 added configuration options
; 01-aug-2012 added trap macro to allow user to change error handling
; 01-dec-2012 fixed trap in branch field must be a branch
; 02-mar-2013 fixed PLA flags not tested
; 19-jul-2013 allowed ROM vectors to be loaded when load_data_direct = 0
; added test sequence check to detect if tests jump their fence
; 23-jul-2013 added RAM integrity check option
; 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. SEI & CLI can only be
;tested if you allow changing the interrupt status (I_flag = 3)
0003 = I_flag = 3
;configure memory - try to stay away from memory used by the system
;zero_page memory start address, $50 (80) consecutive Bytes required
; add 2 if I_flag = 2
000a = zero_page = $a
;data_segment memory start address, $5B (91) consecutive Bytes required
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, 13kB of consecutive space required
; add 2.5 kB if I_flag = 2
;parts of the code are self modifying and must reside in RAM
0400 = code_segment = $400
;report errors through I/O channel (0=use standard self trap loops, 1=include
;report.i65 as I/O channel, add 3.5 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_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
sta range_adr ;reset self modifying code
sta tandi1
sta tandi2
sta teori1
sta teori2
sta torai1
sta torai2
sta chkdadi
sta chkdsbi
sta chkadi
sta chksbi
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
;break test interrupt save
000a : 00 irq_a ds 1 ;a register
000b : 00 irq_x ds 1 ;x register
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
000c : zpt ;5 bytes store/modify test area
;add/subtract operand generation and result/flag prediction
000c : 00 adfc ds 1 ;carry flag before op
000d : 00 ad1 ds 1 ;operand 1 - accumulator
000e : 00 ad2 ds 1 ;operand 2 - memory / immediate
000f : 00 adrl ds 1 ;expected result bits 0-7
0010 : 00 adrh ds 1 ;expected result bit 8 (carry)
0011 : 00 adrf ds 1 ;expected flags NV0000ZC (only binary mode)
0012 : 00 sb2 ds 1 ;operand 2 complemented for subtract
0013 : zp_bss
0013 : c3824100 zp1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
0017 : 7f zp7f db $7f ;test pattern for compare
;logical zeropage operands
0018 : 001f7180 zpOR db 0,$1f,$71,$80 ;test pattern for OR
001c : 0fff7f80 zpAN db $0f,$ff,$7f,$80 ;test pattern for AND
0020 : ff0f8f8f zpEO db $ff,$0f,$8f,$8f ;test pattern for EOR
;indirect addressing pointers
0024 : 0802 ind1 dw abs1 ;indirect pointer to pattern in absolute memory
0026 : 0902 dw abs1+1
0028 : 0a02 dw abs1+2
002a : 0b02 dw abs1+3
002c : 0c02 dw abs7f
002e : 1001 inw1 dw abs1-$f8 ;indirect pointer for wrap-test pattern
0030 : 0302 indt dw abst ;indirect pointer to store area in absolute memory
0032 : 0402 dw abst+1
0034 : 0502 dw abst+2
0036 : 0602 dw abst+3
0038 : 0b01 inwt dw abst-$f8 ;indirect pointer for wrap-test store
003a : 3f02 indAN dw absAN ;indirect pointer to AND pattern in absolute memory
003c : 4002 dw absAN+1
003e : 4102 dw absAN+2
0040 : 4202 dw absAN+3
0042 : 4302 indEO dw absEO ;indirect pointer to EOR pattern in absolute memory
0044 : 4402 dw absEO+1
0046 : 4502 dw absEO+2
0048 : 4602 dw absEO+3
004a : 3b02 indOR dw absOR ;indirect pointer to OR pattern in absolute memory
004c : 3c02 dw absOR+1
004e : 3d02 dw absOR+2
0050 : 3e02 dw absOR+3
;add/subtract indirect pointers
0052 : 0302 adi2 dw ada2 ;indirect pointer to operand 2 in absolute memory
0054 : 0402 sbi2 dw sba2 ;indirect pointer to complemented operand 2 (SBC)
0056 : 0401 adiy2 dw ada2-$ff ;with offset for indirect indexed
0058 : 0501 sbiy2 dw sba2-$ff
005a : zp_bss_end
0200 = org data_segment
0200 : 00 test_case ds 1 ;current test number
0201 : 0000 ram_chksm ds 2 ;checksum for RAM integrity test
;add/subtract operand copy - abs tests write area
0203 : abst ;5 bytes store/modify test area
0203 : 00 ada2 ds 1 ;operand 2
0204 : 00 sba2 ds 1 ;operand 2 complemented for subtract
0205 : 000000 ds 3 ;fill remaining bytes
0208 : data_bss
0208 : c3824100 abs1 db $c3,$82,$41,0 ;test patterns for LDx BIT ROL ROR ASL LSR
020c : 7f abs7f db $7f ;test pattern for compare
;loads
020d : 80800002 fLDx db fn,fn,0,fz ;expected flags for load
;shifts
0211 : rASL ;expected result ASL & ROL -carry
0211 : 86048200 rROL db $86,$04,$82,0 ; "
0215 : 87058301 rROLc db $87,$05,$83,1 ;expected result ROL +carry
0219 : rLSR ;expected result LSR & ROR -carry
0219 : 61412000 rROR db $61,$41,$20,0 ; "
021d : e1c1a080 rRORc db $e1,$c1,$a0,$80 ;expected result ROR +carry
0221 : fASL ;expected flags for shifts
0221 : 81018002 fROL db fnc,fc,fn,fz ;no carry in
0225 : 81018000 fROLc db fnc,fc,fn,0 ;carry in
0229 : fLSR
0229 : 01000102 fROR db fc,0,fc,fz ;no carry in
022d : 81808180 fRORc db fnc,fn,fnc,fn ;carry in
;increments (decrements)
0231 : 7f80ff0001 rINC db $7f,$80,$ff,0,1 ;expected result for INC/DEC
0236 : 0080800200 fINC db 0,fn,fn,fz,0 ;expected flags for INC/DEC
;logical memory operand
023b : 001f7180 absOR db 0,$1f,$71,$80 ;test pattern for OR
023f : 0fff7f80 absAN db $0f,$ff,$7f,$80 ;test pattern for AND
0243 : ff0f8f8f absEO db $ff,$0f,$8f,$8f ;test pattern for EOR
;logical accu operand
0247 : 00f11f00 absORa db 0,$f1,$1f,0 ;test pattern for OR
024b : f0ffffff absANa db $f0,$ff,$ff,$ff ;test pattern for AND
024f : fff0f00f absEOa db $ff,$f0,$f0,$0f ;test pattern for EOR
;logical results
0253 : 00ff7f80 absrlo db 0,$ff,$7f,$80
0257 : 02800080 absflo db fz,fn,0,fn
025b : data_bss_end
code
0400 = org code_segment
0400 : d8 start cld
0401 : a2ff ldx #$ff
0403 : 9a txs
0404 : a900 lda #0 ;*** test 0 = initialize
0406 : 8d0002 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
sta range_adr ;reset self modifying code
sta tandi1
sta tandi2
sta teori1
sta teori2
sta torai1
sta torai2
sta chkdadi
sta chkdsbi
sta chkadi
sta chksbi
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 : ad0002 > 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 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;testing relative addressing with BEQ
0415 : a0fe ldy #$fe ;testing maximum range, not -1/-2 (invalid/self adr)
0417 : range_loop
0417 : 88 dey ;next relative address
0418 : 98 tya
0419 : aa tax ;precharge count to end of loop
041a : 1003 bpl range_fw ;calculate relative address
041c : 18 clc ;avoid branch self or to relative address of branch
041d : 6902 adc #2
041f : range_fw
041f : 497f eor #$7f ;complement except sign
0421 : 8da804 sta range_adr ;load into test target
0424 : a900 lda #0 ;should set zero flag in status register
0426 : 4ca704 jmp range_op
;relative address target field with branch under test in the middle
0429 : ca dex ;-128 - max backward
042a : ca dex
042b : ca dex
042c : ca dex
042d : ca dex
042e : ca dex
042f : ca dex
0430 : ca dex
0431 : ca dex ;-120
0432 : ca dex
0433 : ca dex
0434 : ca dex
0435 : ca dex
0436 : ca dex
0437 : ca dex
0438 : ca dex
0439 : ca dex
043a : ca dex
043b : ca dex ;-110
043c : ca dex
043d : ca dex
043e : ca dex
043f : ca dex
0440 : ca dex
0441 : ca dex
0442 : ca dex
0443 : ca dex
0444 : ca dex
0445 : ca dex ;-100
0446 : ca dex
0447 : ca dex
0448 : ca dex
0449 : ca dex
044a : ca dex
044b : ca dex
044c : ca dex
044d : ca dex
044e : ca dex
044f : ca dex ;-90
0450 : ca dex
0451 : ca dex
0452 : ca dex
0453 : ca dex
0454 : ca dex
0455 : ca dex
0456 : ca dex
0457 : ca dex
0458 : ca dex
0459 : ca dex ;-80
045a : ca dex
045b : ca dex
045c : ca dex
045d : ca dex
045e : ca dex
045f : ca dex
0460 : ca dex
0461 : ca dex
0462 : ca dex
0463 : ca dex ;-70
0464 : ca dex
0465 : ca dex
0466 : ca dex
0467 : ca dex
0468 : ca dex
0469 : ca dex
046a : ca dex
046b : ca dex
046c : ca dex
046d : ca dex ;-60
046e : ca dex
046f : ca dex
0470 : ca dex
0471 : ca dex
0472 : ca dex
0473 : ca dex
0474 : ca dex
0475 : ca dex
0476 : ca dex
0477 : ca dex ;-50
0478 : ca dex
0479 : ca dex
047a : ca dex
047b : ca dex
047c : ca dex
047d : ca dex
047e : ca dex
047f : ca dex
0480 : ca dex
0481 : ca dex ;-40
0482 : ca dex
0483 : ca dex
0484 : ca dex
0485 : ca dex
0486 : ca dex
0487 : ca dex
0488 : ca dex
0489 : ca dex
048a : ca dex
048b : ca dex ;-30
048c : ca dex
048d : ca dex
048e : ca dex
048f : ca dex
0490 : ca dex
0491 : ca dex
0492 : ca dex
0493 : ca dex
0494 : ca dex
0495 : ca dex ;-20
0496 : ca dex
0497 : ca dex
0498 : ca dex
0499 : ca dex
049a : ca dex
049b : ca dex
049c : ca dex
049d : ca dex
049e : ca dex
049f : ca dex ;-10
04a0 : ca dex
04a1 : ca dex
04a2 : ca dex
04a3 : ca dex
04a4 : ca dex
04a5 : ca dex
04a6 : ca dex ;-3
04a7 : range_op ;test target with zero flag=0, z=1 if previous dex
04a8 = range_adr = *+1 ;modifiable relative address
04a7 : f03e beq *+64 ;if called without modification
04a9 : ca dex ;+0
04aa : ca dex
04ab : ca dex
04ac : ca dex
04ad : ca dex
04ae : ca dex
04af : ca dex
04b0 : ca dex
04b1 : ca dex
04b2 : ca dex
04b3 : ca dex ;+10
04b4 : ca dex
04b5 : ca dex
04b6 : ca dex
04b7 : ca dex
04b8 : ca dex
04b9 : ca dex
04ba : ca dex
04bb : ca dex
04bc : ca dex
04bd : ca dex ;+20
04be : ca dex
04bf : ca dex
04c0 : ca dex
04c1 : ca dex
04c2 : ca dex
04c3 : ca dex
04c4 : ca dex
04c5 : ca dex
04c6 : ca dex
04c7 : ca dex ;+30
04c8 : ca dex
04c9 : ca dex
04ca : ca dex
04cb : ca dex
04cc : ca dex
04cd : ca dex
04ce : ca dex
04cf : ca dex
04d0 : ca dex
04d1 : ca dex ;+40
04d2 : ca dex
04d3 : ca dex
04d4 : ca dex
04d5 : ca dex
04d6 : ca dex
04d7 : ca dex
04d8 : ca dex
04d9 : ca dex
04da : ca dex
04db : ca dex ;+50
04dc : ca dex
04dd : ca dex
04de : ca dex
04df : ca dex
04e0 : ca dex
04e1 : ca dex
04e2 : ca dex
04e3 : ca dex
04e4 : ca dex
04e5 : ca dex ;+60
04e6 : ca dex
04e7 : ca dex
04e8 : ca dex
04e9 : ca dex
04ea : ca dex
04eb : ca dex
04ec : ca dex
04ed : ca dex
04ee : ca dex
04ef : ca dex ;+70
04f0 : ca dex
04f1 : ca dex
04f2 : ca dex
04f3 : ca dex
04f4 : ca dex
04f5 : ca dex
04f6 : ca dex
04f7 : ca dex
04f8 : ca dex
04f9 : ca dex ;+80
04fa : ca dex
04fb : ca dex
04fc : ca dex
04fd : ca dex
04fe : ca dex
04ff : ca dex
0500 : ca dex
0501 : ca dex
0502 : ca dex
0503 : ca dex ;+90
0504 : ca dex
0505 : ca dex
0506 : ca dex
0507 : ca dex
0508 : ca dex
0509 : ca dex
050a : ca dex
050b : ca dex
050c : ca dex
050d : ca dex ;+100
050e : ca dex
050f : ca dex
0510 : ca dex
0511 : ca dex
0512 : ca dex
0513 : ca dex
0514 : ca dex
0515 : ca dex
0516 : ca dex
0517 : ca dex ;+110
0518 : ca dex
0519 : ca dex
051a : ca dex
051b : ca dex
051c : ca dex
051d : ca dex
051e : ca dex
051f : ca dex
0520 : ca dex
0521 : ca dex ;+120
0522 : ca dex
0523 : ca dex
0524 : ca dex
0525 : ca dex
0526 : ca dex
0527 : ca dex
0528 : f003 beq range_ok ;+127 - max forward
trap ; bad range
052a : 4c2a05 > jmp * ;failed anyway
052d : range_ok
052d : c000 cpy #0
052f : f003 beq range_end
0531 : 4c1704 jmp range_loop
0534 : range_end ;range test successful
next_test
0534 : ad0002 > lda test_case ;previous test
0537 : c901 > cmp #test_num
> trap_ne ;test is out of sequence
0539 : d0fe > bne * ;failed not equal (non zero)
>
0002 = >test_num = test_num + 1
053b : a902 > lda #test_num ;*** next tests' number
053d : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;partial test BNE & CMP, CPX, CPY immediate
0540 : c001 cpy #1 ;testing BNE true
0542 : d003 bne test_bne
trap
0544 : 4c4405 > jmp * ;failed anyway
0547 : test_bne
0547 : a900 lda #0
0549 : c900 cmp #0 ;test compare immediate
trap_ne
054b : d0fe > bne * ;failed not equal (non zero)
trap_cc
054d : 90fe > bcc * ;failed carry clear
trap_mi
054f : 30fe > bmi * ;failed minus (bit 7 set)
0551 : c901 cmp #1
trap_eq
0553 : f0fe > beq * ;failed equal (zero)
trap_cs
0555 : b0fe > bcs * ;failed carry set
trap_pl
0557 : 10fe > bpl * ;failed plus (bit 7 clear)
0559 : aa tax
055a : e000 cpx #0 ;test compare x immediate
trap_ne
055c : d0fe > bne * ;failed not equal (non zero)
trap_cc
055e : 90fe > bcc * ;failed carry clear
trap_mi
0560 : 30fe > bmi * ;failed minus (bit 7 set)
0562 : e001 cpx #1
trap_eq
0564 : f0fe > beq * ;failed equal (zero)
trap_cs
0566 : b0fe > bcs * ;failed carry set
trap_pl
0568 : 10fe > bpl * ;failed plus (bit 7 clear)
056a : a8 tay
056b : c000 cpy #0 ;test compare y immediate
trap_ne
056d : d0fe > bne * ;failed not equal (non zero)
trap_cc
056f : 90fe > bcc * ;failed carry clear
trap_mi
0571 : 30fe > bmi * ;failed minus (bit 7 set)
0573 : c001 cpy #1
trap_eq
0575 : f0fe > beq * ;failed equal (zero)
trap_cs
0577 : b0fe > bcs * ;failed carry set
trap_pl
0579 : 10fe > bpl * ;failed plus (bit 7 clear)
next_test
057b : ad0002 > lda test_case ;previous test
057e : c902 > cmp #test_num
> trap_ne ;test is out of sequence
0580 : d0fe > bne * ;failed not equal (non zero)
>
0003 = >test_num = test_num + 1
0582 : a903 > lda #test_num ;*** next tests' number
0584 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;testing stack operations PHA PHP PLA PLP
0587 : a2ff ldx #$ff ;initialize stack
0589 : 9a txs
058a : a955 lda #$55
058c : 48 pha
058d : a9aa lda #$aa
058f : 48 pha
0590 : cdfe01 cmp $1fe ;on stack ?
trap_ne
0593 : d0fe > bne * ;failed not equal (non zero)
0595 : ba tsx
0596 : 8a txa ;overwrite accu
0597 : c9fd cmp #$fd ;sp decremented?
trap_ne
0599 : d0fe > bne * ;failed not equal (non zero)
059b : 68 pla
059c : c9aa cmp #$aa ;successful retreived from stack?
trap_ne
059e : d0fe > bne * ;failed not equal (non zero)
05a0 : 68 pla
05a1 : c955 cmp #$55
trap_ne
05a3 : d0fe > bne * ;failed not equal (non zero)
05a5 : cdff01 cmp $1ff ;remains on stack?
trap_ne
05a8 : d0fe > bne * ;failed not equal (non zero)
05aa : ba tsx
05ab : e0ff cpx #$ff ;sp incremented?
trap_ne
05ad : d0fe > bne * ;failed not equal (non zero)
next_test
05af : ad0002 > lda test_case ;previous test
05b2 : c903 > cmp #test_num
> trap_ne ;test is out of sequence
05b4 : d0fe > bne * ;failed not equal (non zero)
>
0004 = >test_num = test_num + 1
05b6 : a904 > lda #test_num ;*** next tests' number
05b8 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;testing branch decisions BPL BMI BVC BVS BCC BCS BNE BEQ
set_stat $ff ;all on
> load_flag $ff
05bb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
05bd : 48 > pha ;use stack to load status
05be : 28 > plp
05bf : 101a bpl nbr1 ;branches should not be taken
05c1 : 501b bvc nbr2
05c3 : 901c bcc nbr3
05c5 : d01d bne nbr4
05c7 : 3003 bmi br1 ;branches should be taken
trap
05c9 : 4cc905 > jmp * ;failed anyway
05cc : 7003 br1 bvs br2
trap
05ce : 4cce05 > jmp * ;failed anyway
05d1 : b003 br2 bcs br3
trap
05d3 : 4cd305 > jmp * ;failed anyway
05d6 : f00f br3 beq br4
trap
05d8 : 4cd805 > jmp * ;failed anyway
05db : nbr1
trap ;previous bpl taken
05db : 4cdb05 > jmp * ;failed anyway
05de : nbr2
trap ;previous bvc taken
05de : 4cde05 > jmp * ;failed anyway
05e1 : nbr3
trap ;previous bcc taken
05e1 : 4ce105 > jmp * ;failed anyway
05e4 : nbr4
trap ;previous bne taken
05e4 : 4ce405 > jmp * ;failed anyway
05e7 : 08 br4 php
05e8 : ba tsx
05e9 : e0fe cpx #$fe ;sp after php?
trap_ne
05eb : d0fe > bne * ;failed not equal (non zero)
05ed : 68 pla
cmp_flag $ff ;returned all flags on?
05ee : c9ff > cmp #($ff |fao)&m8 ;expected flags + always on bits
trap_ne
05f0 : d0fe > bne * ;failed not equal (non zero)
05f2 : ba tsx
05f3 : e0ff cpx #$ff ;sp after php?
trap_ne
05f5 : d0fe > bne * ;failed not equal (non zero)
set_stat 0 ;all off
> load_flag 0
05f7 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
05f9 : 48 > pha ;use stack to load status
05fa : 28 > plp
05fb : 301a bmi nbr11 ;branches should not be taken
05fd : 701b bvs nbr12
05ff : b01c bcs nbr13
0601 : f01d beq nbr14
0603 : 1003 bpl br11 ;branches should be taken
trap
0605 : 4c0506 > jmp * ;failed anyway
0608 : 5003 br11 bvc br12
trap
060a : 4c0a06 > jmp * ;failed anyway
060d : 9003 br12 bcc br13
trap
060f : 4c0f06 > jmp * ;failed anyway
0612 : d00f br13 bne br14
trap
0614 : 4c1406 > jmp * ;failed anyway
0617 : nbr11
trap ;previous bmi taken
0617 : 4c1706 > jmp * ;failed anyway
061a : nbr12
trap ;previous bvs taken
061a : 4c1a06 > jmp * ;failed anyway
061d : nbr13
trap ;previous bcs taken
061d : 4c1d06 > jmp * ;failed anyway
0620 : nbr14
trap ;previous beq taken
0620 : 4c2006 > jmp * ;failed anyway
0623 : 08 br14 php
0624 : 68 pla
cmp_flag 0 ;flags off except break (pushed by sw) + reserved?
0625 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
trap_ne
0627 : d0fe > bne * ;failed not equal (non zero)
;crosscheck flags
set_stat zero
> load_flag zero
0629 : a902 > lda #zero ;allow test to change I-flag (no mask)
>
062b : 48 > pha ;use stack to load status
062c : 28 > plp
062d : d002 bne brzs1
062f : f003 beq brzs2
0631 : brzs1
trap ;branch zero/non zero
0631 : 4c3106 > jmp * ;failed anyway
0634 : b002 brzs2 bcs brzs3
0636 : 9003 bcc brzs4
0638 : brzs3
trap ;branch carry/no carry
0638 : 4c3806 > jmp * ;failed anyway
063b : 3002 brzs4 bmi brzs5
063d : 1003 bpl brzs6
063f : brzs5
trap ;branch minus/plus
063f : 4c3f06 > jmp * ;failed anyway
0642 : 7002 brzs6 bvs brzs7
0644 : 5003 bvc brzs8
0646 : brzs7
trap ;branch overflow/no overflow
0646 : 4c4606 > jmp * ;failed anyway
0649 : brzs8
set_stat carry
> load_flag carry
0649 : a901 > lda #carry ;allow test to change I-flag (no mask)
>
064b : 48 > pha ;use stack to load status
064c : 28 > plp
064d : f002 beq brcs1
064f : d003 bne brcs2
0651 : brcs1
trap ;branch zero/non zero
0651 : 4c5106 > jmp * ;failed anyway
0654 : 9002 brcs2 bcc brcs3
0656 : b003 bcs brcs4
0658 : brcs3
trap ;branch carry/no carry
0658 : 4c5806 > jmp * ;failed anyway
065b : 3002 brcs4 bmi brcs5
065d : 1003 bpl brcs6
065f : brcs5
trap ;branch minus/plus
065f : 4c5f06 > jmp * ;failed anyway
0662 : 7002 brcs6 bvs brcs7
0664 : 5003 bvc brcs8
0666 : brcs7
trap ;branch overflow/no overflow
0666 : 4c6606 > jmp * ;failed anyway
0669 : brcs8
set_stat minus
> load_flag minus
0669 : a980 > lda #minus ;allow test to change I-flag (no mask)
>
066b : 48 > pha ;use stack to load status
066c : 28 > plp
066d : f002 beq brmi1
066f : d003 bne brmi2
0671 : brmi1
trap ;branch zero/non zero
0671 : 4c7106 > jmp * ;failed anyway
0674 : b002 brmi2 bcs brmi3
0676 : 9003 bcc brmi4
0678 : brmi3
trap ;branch carry/no carry
0678 : 4c7806 > jmp * ;failed anyway
067b : 1002 brmi4 bpl brmi5
067d : 3003 bmi brmi6
067f : brmi5
trap ;branch minus/plus
067f : 4c7f06 > jmp * ;failed anyway
0682 : 7002 brmi6 bvs brmi7
0684 : 5003 bvc brmi8
0686 : brmi7
trap ;branch overflow/no overflow
0686 : 4c8606 > jmp * ;failed anyway
0689 : brmi8
set_stat overfl
> load_flag overfl
0689 : a940 > lda #overfl ;allow test to change I-flag (no mask)
>
068b : 48 > pha ;use stack to load status
068c : 28 > plp
068d : f002 beq brvs1
068f : d003 bne brvs2
0691 : brvs1
trap ;branch zero/non zero
0691 : 4c9106 > jmp * ;failed anyway
0694 : b002 brvs2 bcs brvs3
0696 : 9003 bcc brvs4
0698 : brvs3
trap ;branch carry/no carry
0698 : 4c9806 > jmp * ;failed anyway
069b : 3002 brvs4 bmi brvs5
069d : 1003 bpl brvs6
069f : brvs5
trap ;branch minus/plus
069f : 4c9f06 > jmp * ;failed anyway
06a2 : 5002 brvs6 bvc brvs7
06a4 : 7003 bvs brvs8
06a6 : brvs7
trap ;branch overflow/no overflow
06a6 : 4ca606 > jmp * ;failed anyway
06a9 : brvs8
set_stat $ff-zero
> load_flag $ff-zero
06a9 : a9fd > lda #$ff-zero ;allow test to change I-flag (no mask)
>
06ab : 48 > pha ;use stack to load status
06ac : 28 > plp
06ad : f002 beq brzc1
06af : d003 bne brzc2
06b1 : brzc1
trap ;branch zero/non zero
06b1 : 4cb106 > jmp * ;failed anyway
06b4 : 9002 brzc2 bcc brzc3
06b6 : b003 bcs brzc4
06b8 : brzc3
trap ;branch carry/no carry
06b8 : 4cb806 > jmp * ;failed anyway
06bb : 1002 brzc4 bpl brzc5
06bd : 3003 bmi brzc6
06bf : brzc5
trap ;branch minus/plus
06bf : 4cbf06 > jmp * ;failed anyway
06c2 : 5002 brzc6 bvc brzc7
06c4 : 7003 bvs brzc8
06c6 : brzc7
trap ;branch overflow/no overflow
06c6 : 4cc606 > jmp * ;failed anyway
06c9 : brzc8
set_stat $ff-carry
> load_flag $ff-carry
06c9 : a9fe > lda #$ff-carry ;allow test to change I-flag (no mask)
>
06cb : 48 > pha ;use stack to load status
06cc : 28 > plp
06cd : d002 bne brcc1
06cf : f003 beq brcc2
06d1 : brcc1
trap ;branch zero/non zero
06d1 : 4cd106 > jmp * ;failed anyway
06d4 : b002 brcc2 bcs brcc3
06d6 : 9003 bcc brcc4
06d8 : brcc3
trap ;branch carry/no carry
06d8 : 4cd806 > jmp * ;failed anyway
06db : 1002 brcc4 bpl brcc5
06dd : 3003 bmi brcc6
06df : brcc5
trap ;branch minus/plus
06df : 4cdf06 > jmp * ;failed anyway
06e2 : 5002 brcc6 bvc brcc7
06e4 : 7003 bvs brcc8
06e6 : brcc7
trap ;branch overflow/no overflow
06e6 : 4ce606 > jmp * ;failed anyway
06e9 : brcc8
set_stat $ff-minus
> load_flag $ff-minus
06e9 : a97f > lda #$ff-minus ;allow test to change I-flag (no mask)
>
06eb : 48 > pha ;use stack to load status
06ec : 28 > plp
06ed : d002 bne brpl1
06ef : f003 beq brpl2
06f1 : brpl1
trap ;branch zero/non zero
06f1 : 4cf106 > jmp * ;failed anyway
06f4 : 9002 brpl2 bcc brpl3
06f6 : b003 bcs brpl4
06f8 : brpl3
trap ;branch carry/no carry
06f8 : 4cf806 > jmp * ;failed anyway
06fb : 3002 brpl4 bmi brpl5
06fd : 1003 bpl brpl6
06ff : brpl5
trap ;branch minus/plus
06ff : 4cff06 > jmp * ;failed anyway
0702 : 5002 brpl6 bvc brpl7
0704 : 7003 bvs brpl8
0706 : brpl7
trap ;branch overflow/no overflow
0706 : 4c0607 > jmp * ;failed anyway
0709 : brpl8
set_stat $ff-overfl
> load_flag $ff-overfl
0709 : a9bf > lda #$ff-overfl ;allow test to change I-flag (no mask)
>
070b : 48 > pha ;use stack to load status
070c : 28 > plp
070d : d002 bne brvc1
070f : f003 beq brvc2
0711 : brvc1
trap ;branch zero/non zero
0711 : 4c1107 > jmp * ;failed anyway
0714 : 9002 brvc2 bcc brvc3
0716 : b003 bcs brvc4
0718 : brvc3
trap ;branch carry/no carry
0718 : 4c1807 > jmp * ;failed anyway
071b : 1002 brvc4 bpl brvc5
071d : 3003 bmi brvc6
071f : brvc5
trap ;branch minus/plus
071f : 4c1f07 > jmp * ;failed anyway
0722 : 7002 brvc6 bvs brvc7
0724 : 5003 bvc brvc8
0726 : brvc7
trap ;branch overflow/no overflow
0726 : 4c2607 > jmp * ;failed anyway
0729 : brvc8
next_test
0729 : ad0002 > lda test_case ;previous test
072c : c904 > cmp #test_num
> trap_ne ;test is out of sequence
072e : d0fe > bne * ;failed not equal (non zero)
>
0005 = >test_num = test_num + 1
0730 : a905 > lda #test_num ;*** next tests' number
0732 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; test PHA does not alter flags or accumulator but PLA does
0735 : a255 ldx #$55 ;x & y protected
0737 : a0aa ldy #$aa
set_a 1,$ff ;push
> load_flag $ff
0739 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
073b : 48 > pha ;use stack to load status
073c : a901 > lda #1 ;precharge accu
073e : 28 > plp
073f : 48 pha
tst_a 1,$ff
0740 : 08 > php ;save flags
0741 : c901 > cmp #1 ;test result
> trap_ne
0743 : d0fe > bne * ;failed not equal (non zero)
>
0745 : 68 > pla ;load status
0746 : 48 > pha
> cmp_flag $ff
0747 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0749 : d0fe > bne * ;failed not equal (non zero)
>
074b : 28 > plp ;restore status
set_a 0,0
> load_flag 0
074c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
074e : 48 > pha ;use stack to load status
074f : a900 > lda #0 ;precharge accu
0751 : 28 > plp
0752 : 48 pha
tst_a 0,0
0753 : 08 > php ;save flags
0754 : c900 > cmp #0 ;test result
> trap_ne
0756 : d0fe > bne * ;failed not equal (non zero)
>
0758 : 68 > pla ;load status
0759 : 48 > pha
> cmp_flag 0
075a : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
075c : d0fe > bne * ;failed not equal (non zero)
>
075e : 28 > plp ;restore status
set_a $ff,$ff
> load_flag $ff
075f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0761 : 48 > pha ;use stack to load status
0762 : a9ff > lda #$ff ;precharge accu
0764 : 28 > plp
0765 : 48 pha
tst_a $ff,$ff
0766 : 08 > php ;save flags
0767 : c9ff > cmp #$ff ;test result
> trap_ne
0769 : d0fe > bne * ;failed not equal (non zero)
>
076b : 68 > pla ;load status
076c : 48 > pha
> cmp_flag $ff
076d : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
076f : d0fe > bne * ;failed not equal (non zero)
>
0771 : 28 > plp ;restore status
set_a 1,0
> load_flag 0
0772 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0774 : 48 > pha ;use stack to load status
0775 : a901 > lda #1 ;precharge accu
0777 : 28 > plp
0778 : 48 pha
tst_a 1,0
0779 : 08 > php ;save flags
077a : c901 > cmp #1 ;test result
> trap_ne
077c : d0fe > bne * ;failed not equal (non zero)
>
077e : 68 > pla ;load status
077f : 48 > pha
> cmp_flag 0
0780 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0782 : d0fe > bne * ;failed not equal (non zero)
>
0784 : 28 > plp ;restore status
set_a 0,$ff
> load_flag $ff
0785 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0787 : 48 > pha ;use stack to load status
0788 : a900 > lda #0 ;precharge accu
078a : 28 > plp
078b : 48 pha
tst_a 0,$ff
078c : 08 > php ;save flags
078d : c900 > cmp #0 ;test result
> trap_ne
078f : d0fe > bne * ;failed not equal (non zero)
>
0791 : 68 > pla ;load status
0792 : 48 > pha
> cmp_flag $ff
0793 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0795 : d0fe > bne * ;failed not equal (non zero)
>
0797 : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
0798 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
079a : 48 > pha ;use stack to load status
079b : a9ff > lda #$ff ;precharge accu
079d : 28 > plp
079e : 48 pha
tst_a $ff,0
079f : 08 > php ;save flags
07a0 : c9ff > cmp #$ff ;test result
> trap_ne
07a2 : d0fe > bne * ;failed not equal (non zero)
>
07a4 : 68 > pla ;load status
07a5 : 48 > pha
> cmp_flag 0
07a6 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07a8 : d0fe > bne * ;failed not equal (non zero)
>
07aa : 28 > plp ;restore status
set_a 0,$ff ;pull
> load_flag $ff
07ab : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
07ad : 48 > pha ;use stack to load status
07ae : a900 > lda #0 ;precharge accu
07b0 : 28 > plp
07b1 : 68 pla
tst_a $ff,$ff-zero
07b2 : 08 > php ;save flags
07b3 : c9ff > cmp #$ff ;test result
> trap_ne
07b5 : d0fe > bne * ;failed not equal (non zero)
>
07b7 : 68 > pla ;load status
07b8 : 48 > pha
> cmp_flag $ff-zero
07b9 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07bb : d0fe > bne * ;failed not equal (non zero)
>
07bd : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
07be : a900 > lda #0 ;allow test to change I-flag (no mask)
>
07c0 : 48 > pha ;use stack to load status
07c1 : a9ff > lda #$ff ;precharge accu
07c3 : 28 > plp
07c4 : 68 pla
tst_a 0,zero
07c5 : 08 > php ;save flags
07c6 : c900 > cmp #0 ;test result
> trap_ne
07c8 : d0fe > bne * ;failed not equal (non zero)
>
07ca : 68 > pla ;load status
07cb : 48 > pha
> cmp_flag zero
07cc : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07ce : d0fe > bne * ;failed not equal (non zero)
>
07d0 : 28 > plp ;restore status
set_a $fe,$ff
> load_flag $ff
07d1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
07d3 : 48 > pha ;use stack to load status
07d4 : a9fe > lda #$fe ;precharge accu
07d6 : 28 > plp
07d7 : 68 pla
tst_a 1,$ff-zero-minus
07d8 : 08 > php ;save flags
07d9 : c901 > cmp #1 ;test result
> trap_ne
07db : d0fe > bne * ;failed not equal (non zero)
>
07dd : 68 > pla ;load status
07de : 48 > pha
> cmp_flag $ff-zero-minus
07df : c97d > cmp #($ff-zero-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07e1 : d0fe > bne * ;failed not equal (non zero)
>
07e3 : 28 > plp ;restore status
set_a 0,0
> load_flag 0
07e4 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
07e6 : 48 > pha ;use stack to load status
07e7 : a900 > lda #0 ;precharge accu
07e9 : 28 > plp
07ea : 68 pla
tst_a $ff,minus
07eb : 08 > php ;save flags
07ec : c9ff > cmp #$ff ;test result
> trap_ne
07ee : d0fe > bne * ;failed not equal (non zero)
>
07f0 : 68 > pla ;load status
07f1 : 48 > pha
> cmp_flag minus
07f2 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
07f4 : d0fe > bne * ;failed not equal (non zero)
>
07f6 : 28 > plp ;restore status
set_a $ff,$ff
> load_flag $ff
07f7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
07f9 : 48 > pha ;use stack to load status
07fa : a9ff > lda #$ff ;precharge accu
07fc : 28 > plp
07fd : 68 pla
tst_a 0,$ff-minus
07fe : 08 > php ;save flags
07ff : c900 > cmp #0 ;test result
> trap_ne
0801 : d0fe > bne * ;failed not equal (non zero)
>
0803 : 68 > pla ;load status
0804 : 48 > pha
> cmp_flag $ff-minus
0805 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0807 : d0fe > bne * ;failed not equal (non zero)
>
0809 : 28 > plp ;restore status
set_a $fe,0
> load_flag 0
080a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
080c : 48 > pha ;use stack to load status
080d : a9fe > lda #$fe ;precharge accu
080f : 28 > plp
0810 : 68 pla
tst_a 1,0
0811 : 08 > php ;save flags
0812 : c901 > cmp #1 ;test result
> trap_ne
0814 : d0fe > bne * ;failed not equal (non zero)
>
0816 : 68 > pla ;load status
0817 : 48 > pha
> cmp_flag 0
0818 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
081a : d0fe > bne * ;failed not equal (non zero)
>
081c : 28 > plp ;restore status
081d : e055 cpx #$55 ;x & y unchanged?
trap_ne
081f : d0fe > bne * ;failed not equal (non zero)
0821 : c0aa cpy #$aa
trap_ne
0823 : d0fe > bne * ;failed not equal (non zero)
next_test
0825 : ad0002 > lda test_case ;previous test
0828 : c905 > cmp #test_num
> trap_ne ;test is out of sequence
082a : d0fe > bne * ;failed not equal (non zero)
>
0006 = >test_num = test_num + 1
082c : a906 > lda #test_num ;*** next tests' number
082e : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; partial pretest EOR #
set_a $3c,0
> load_flag 0
0831 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0833 : 48 > pha ;use stack to load status
0834 : a93c > lda #$3c ;precharge accu
0836 : 28 > plp
0837 : 49c3 eor #$c3
tst_a $ff,fn
0839 : 08 > php ;save flags
083a : c9ff > cmp #$ff ;test result
> trap_ne
083c : d0fe > bne * ;failed not equal (non zero)
>
083e : 68 > pla ;load status
083f : 48 > pha
> cmp_flag fn
0840 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0842 : d0fe > bne * ;failed not equal (non zero)
>
0844 : 28 > plp ;restore status
set_a $c3,0
> load_flag 0
0845 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0847 : 48 > pha ;use stack to load status
0848 : a9c3 > lda #$c3 ;precharge accu
084a : 28 > plp
084b : 49c3 eor #$c3
tst_a 0,fz
084d : 08 > php ;save flags
084e : c900 > cmp #0 ;test result
> trap_ne
0850 : d0fe > bne * ;failed not equal (non zero)
>
0852 : 68 > pla ;load status
0853 : 48 > pha
> cmp_flag fz
0854 : c932 > cmp #(fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0856 : d0fe > bne * ;failed not equal (non zero)
>
0858 : 28 > plp ;restore status
next_test
0859 : ad0002 > lda test_case ;previous test
085c : c906 > cmp #test_num
> trap_ne ;test is out of sequence
085e : d0fe > bne * ;failed not equal (non zero)
>
0007 = >test_num = test_num + 1
0860 : a907 > lda #test_num ;*** next tests' number
0862 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; PC modifying instructions except branches (NOP, JMP, JSR, RTS, BRK, RTI)
; testing NOP
0865 : a224 ldx #$24
0867 : a042 ldy #$42
set_a $18,0
> load_flag 0
0869 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
086b : 48 > pha ;use stack to load status
086c : a918 > lda #$18 ;precharge accu
086e : 28 > plp
086f : ea nop
tst_a $18,0
0870 : 08 > php ;save flags
0871 : c918 > cmp #$18 ;test result
> trap_ne
0873 : d0fe > bne * ;failed not equal (non zero)
>
0875 : 68 > pla ;load status
0876 : 48 > pha
> cmp_flag 0
0877 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0879 : d0fe > bne * ;failed not equal (non zero)
>
087b : 28 > plp ;restore status
087c : e024 cpx #$24
trap_ne
087e : d0fe > bne * ;failed not equal (non zero)
0880 : c042 cpy #$42
trap_ne
0882 : d0fe > bne * ;failed not equal (non zero)
0884 : a2db ldx #$db
0886 : a0bd ldy #$bd
set_a $e7,$ff
> load_flag $ff
0888 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
088a : 48 > pha ;use stack to load status
088b : a9e7 > lda #$e7 ;precharge accu
088d : 28 > plp
088e : ea nop
tst_a $e7,$ff
088f : 08 > php ;save flags
0890 : c9e7 > cmp #$e7 ;test result
> trap_ne
0892 : d0fe > bne * ;failed not equal (non zero)
>
0894 : 68 > pla ;load status
0895 : 48 > pha
> cmp_flag $ff
0896 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0898 : d0fe > bne * ;failed not equal (non zero)
>
089a : 28 > plp ;restore status
089b : e0db cpx #$db
trap_ne
089d : d0fe > bne * ;failed not equal (non zero)
089f : c0bd cpy #$bd
trap_ne
08a1 : d0fe > bne * ;failed not equal (non zero)
next_test
08a3 : ad0002 > lda test_case ;previous test
08a6 : c907 > cmp #test_num
> trap_ne ;test is out of sequence
08a8 : d0fe > bne * ;failed not equal (non zero)
>
0008 = >test_num = test_num + 1
08aa : a908 > lda #test_num ;*** next tests' number
08ac : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; jump absolute
set_stat $0
> load_flag $0
08af : a900 > lda #$0 ;allow test to change I-flag (no mask)
>
08b1 : 48 > pha ;use stack to load status
08b2 : 28 > plp
08b3 : a946 lda #'F'
08b5 : a241 ldx #'A'
08b7 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0
08b9 : 4c1b36 jmp test_far
08bc : ea nop
08bd : ea nop
trap_ne ;runover protection
08be : d0fe > bne * ;failed not equal (non zero)
08c0 : e8 inx
08c1 : e8 inx
08c2 : far_ret
trap_eq ;returned flags OK?
08c2 : f0fe > beq * ;failed equal (zero)
trap_pl
08c4 : 10fe > bpl * ;failed plus (bit 7 clear)
trap_cc
08c6 : 90fe > bcc * ;failed carry clear
trap_vc
08c8 : 50fe > bvc * ;failed overflow clear
08ca : c9ec cmp #('F'^$aa) ;returned registers OK?
trap_ne
08cc : d0fe > bne * ;failed not equal (non zero)
08ce : e042 cpx #('A'+1)
trap_ne
08d0 : d0fe > bne * ;failed not equal (non zero)
08d2 : c04f cpy #('R'-3)
trap_ne
08d4 : d0fe > bne * ;failed not equal (non zero)
08d6 : ca dex
08d7 : c8 iny
08d8 : c8 iny
08d9 : c8 iny
08da : 49aa eor #$aa ;N=0, V=1, Z=0, C=1
08dc : 4ce508 jmp test_near
08df : ea nop
08e0 : ea nop
trap_ne ;runover protection
08e1 : d0fe > bne * ;failed not equal (non zero)
08e3 : e8 inx
08e4 : e8 inx
08e5 : test_near
trap_eq ;passed flags OK?
08e5 : f0fe > beq * ;failed equal (zero)
trap_mi
08e7 : 30fe > bmi * ;failed minus (bit 7 set)
trap_cc
08e9 : 90fe > bcc * ;failed carry clear
trap_vc
08eb : 50fe > bvc * ;failed overflow clear
08ed : c946 cmp #'F' ;passed registers OK?
trap_ne
08ef : d0fe > bne * ;failed not equal (non zero)
08f1 : e041 cpx #'A'
trap_ne
08f3 : d0fe > bne * ;failed not equal (non zero)
08f5 : c052 cpy #'R'
trap_ne
08f7 : d0fe > bne * ;failed not equal (non zero)
next_test
08f9 : ad0002 > lda test_case ;previous test
08fc : c908 > cmp #test_num
> trap_ne ;test is out of sequence
08fe : d0fe > bne * ;failed not equal (non zero)
>
0009 = >test_num = test_num + 1
0900 : a909 > lda #test_num ;*** next tests' number
0902 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; jump indirect
set_stat 0
> load_flag 0
0905 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0907 : 48 > pha ;use stack to load status
0908 : 28 > plp
0909 : a949 lda #'I'
090b : a24e ldx #'N'
090d : a044 ldy #'D' ;N=0, V=0, Z=0, C=0
090f : 6c4a36 jmp (ptr_tst_ind)
0912 : ea nop
trap_ne ;runover protection
0913 : d0fe > bne * ;failed not equal (non zero)
0915 : 88 dey
0916 : 88 dey
0917 : ind_ret
0917 : 08 php ;either SP or Y count will fail, if we do not hit
0918 : 88 dey
0919 : 88 dey
091a : 88 dey
091b : 28 plp
trap_eq ;returned flags OK?
091c : f0fe > beq * ;failed equal (zero)
trap_pl
091e : 10fe > bpl * ;failed plus (bit 7 clear)
trap_cc
0920 : 90fe > bcc * ;failed carry clear
trap_vc
0922 : 50fe > bvc * ;failed overflow clear
0924 : c9e3 cmp #('I'^$aa) ;returned registers OK?
trap_ne
0926 : d0fe > bne * ;failed not equal (non zero)
0928 : e04f cpx #('N'+1)
trap_ne
092a : d0fe > bne * ;failed not equal (non zero)
092c : c03e cpy #('D'-6)
trap_ne
092e : d0fe > bne * ;failed not equal (non zero)
0930 : ba tsx ;SP check
0931 : e0ff cpx #$ff
trap_ne
0933 : d0fe > bne * ;failed not equal (non zero)
next_test
0935 : ad0002 > lda test_case ;previous test
0938 : c909 > cmp #test_num
> trap_ne ;test is out of sequence
093a : d0fe > bne * ;failed not equal (non zero)
>
000a = >test_num = test_num + 1
093c : a90a > lda #test_num ;*** next tests' number
093e : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; jump subroutine & return from subroutine
set_stat 0
> load_flag 0
0941 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0943 : 48 > pha ;use stack to load status
0944 : 28 > plp
0945 : a94a lda #'J'
0947 : a253 ldx #'S'
0949 : a052 ldy #'R' ;N=0, V=0, Z=0, C=0
094b : 208636 jsr test_jsr
094d = jsr_ret = *-1 ;last address of jsr = return address
094e : 08 php ;either SP or Y count will fail, if we do not hit
094f : 88 dey
0950 : 88 dey
0951 : 88 dey
0952 : 28 plp
trap_eq ;returned flags OK?
0953 : f0fe > beq * ;failed equal (zero)
trap_pl
0955 : 10fe > bpl * ;failed plus (bit 7 clear)
trap_cc
0957 : 90fe > bcc * ;failed carry clear
trap_vc
0959 : 50fe > bvc * ;failed overflow clear
095b : c9e0 cmp #('J'^$aa) ;returned registers OK?
trap_ne
095d : d0fe > bne * ;failed not equal (non zero)
095f : e054 cpx #('S'+1)
trap_ne
0961 : d0fe > bne * ;failed not equal (non zero)
0963 : c04c cpy #('R'-6)
trap_ne
0965 : d0fe > bne * ;failed not equal (non zero)
0967 : ba tsx ;sp?
0968 : e0ff cpx #$ff
trap_ne
096a : d0fe > bne * ;failed not equal (non zero)
next_test
096c : ad0002 > lda test_case ;previous test
096f : c90a > cmp #test_num
> trap_ne ;test is out of sequence
0971 : d0fe > bne * ;failed not equal (non zero)
>
000b = >test_num = test_num + 1
0973 : a90b > lda #test_num ;*** next tests' number
0975 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; break & return from interrupt
if ROM_vectors = 1
set_stat 0
> load_flag 0
0978 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
097a : 48 > pha ;use stack to load status
097b : 28 > plp
097c : a942 lda #'B'
097e : a252 ldx #'R'
0980 : a04b ldy #'K' ;N=0, V=0, Z=0, C=0
0982 : 00 brk
else
lda #hi brk_ret ;emulated break
pha
lda #lo brk_ret
pha
lda #fao ;set break & unused on stack
pha
set_stat intdis
lda #'B'
ldx #'R'
ldy #'K' ;N=0, V=0, Z=0, C=0
jmp irq_trap
endif
0983 : 88 dey ;should not be executed
0984 : brk_ret ;address of break return
0984 : 08 php ;either SP or Y count will fail, if we do not hit
0985 : 88 dey
0986 : 88 dey
0987 : 88 dey
0988 : c9e8 cmp #('B'^$aa) ;returned registers OK?
trap_ne
098a : d0fe > bne * ;failed not equal (non zero)
098c : e053 cpx #('R'+1)
trap_ne
098e : d0fe > bne * ;failed not equal (non zero)
0990 : c045 cpy #('K'-6)
trap_ne
0992 : d0fe > bne * ;failed not equal (non zero)
0994 : 68 pla ;returned flags OK (unchanged)?
cmp_flag 0
0995 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
trap_ne
0997 : d0fe > bne * ;failed not equal (non zero)
0999 : ba tsx ;sp?
099a : e0ff cpx #$ff
trap_ne
099c : d0fe > bne * ;failed not equal (non zero)
next_test
099e : ad0002 > lda test_case ;previous test
09a1 : c90b > cmp #test_num
> trap_ne ;test is out of sequence
09a3 : d0fe > bne * ;failed not equal (non zero)
>
000c = >test_num = test_num + 1
09a5 : a90c > lda #test_num ;*** next tests' number
09a7 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; test set and clear flags CLC CLI CLD CLV SEC SEI SED
set_stat $ff
> load_flag $ff
09aa : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
09ac : 48 > pha ;use stack to load status
09ad : 28 > plp
09ae : 18 clc
tst_stat $ff-carry
09af : 08 > php ;save status
09b0 : 68 > pla ;use stack to retrieve status
09b1 : 48 > pha
> cmp_flag $ff-carry
09b2 : c9fe > cmp #($ff-carry|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09b4 : d0fe > bne * ;failed not equal (non zero)
>
09b6 : 28 > plp ;restore status
09b7 : 38 sec
tst_stat $ff
09b8 : 08 > php ;save status
09b9 : 68 > pla ;use stack to retrieve status
09ba : 48 > pha
> cmp_flag $ff
09bb : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09bd : d0fe > bne * ;failed not equal (non zero)
>
09bf : 28 > plp ;restore status
if I_flag = 3
09c0 : 58 cli
tst_stat $ff-intdis
09c1 : 08 > php ;save status
09c2 : 68 > pla ;use stack to retrieve status
09c3 : 48 > pha
> cmp_flag $ff-intdis
09c4 : c9fb > cmp #($ff-intdis|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09c6 : d0fe > bne * ;failed not equal (non zero)
>
09c8 : 28 > plp ;restore status
09c9 : 78 sei
tst_stat $ff
09ca : 08 > php ;save status
09cb : 68 > pla ;use stack to retrieve status
09cc : 48 > pha
> cmp_flag $ff
09cd : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09cf : d0fe > bne * ;failed not equal (non zero)
>
09d1 : 28 > plp ;restore status
endif
09d2 : d8 cld
tst_stat $ff-decmode
09d3 : 08 > php ;save status
09d4 : 68 > pla ;use stack to retrieve status
09d5 : 48 > pha
> cmp_flag $ff-decmode
09d6 : c9f7 > cmp #($ff-decmode|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09d8 : d0fe > bne * ;failed not equal (non zero)
>
09da : 28 > plp ;restore status
09db : f8 sed
tst_stat $ff
09dc : 08 > php ;save status
09dd : 68 > pla ;use stack to retrieve status
09de : 48 > pha
> cmp_flag $ff
09df : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09e1 : d0fe > bne * ;failed not equal (non zero)
>
09e3 : 28 > plp ;restore status
09e4 : b8 clv
tst_stat $ff-overfl
09e5 : 08 > php ;save status
09e6 : 68 > pla ;use stack to retrieve status
09e7 : 48 > pha
> cmp_flag $ff-overfl
09e8 : c9bf > cmp #($ff-overfl|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09ea : d0fe > bne * ;failed not equal (non zero)
>
09ec : 28 > plp ;restore status
set_stat 0
> load_flag 0
09ed : a900 > lda #0 ;allow test to change I-flag (no mask)
>
09ef : 48 > pha ;use stack to load status
09f0 : 28 > plp
tst_stat 0
09f1 : 08 > php ;save status
09f2 : 68 > pla ;use stack to retrieve status
09f3 : 48 > pha
> cmp_flag 0
09f4 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09f6 : d0fe > bne * ;failed not equal (non zero)
>
09f8 : 28 > plp ;restore status
09f9 : 38 sec
tst_stat carry
09fa : 08 > php ;save status
09fb : 68 > pla ;use stack to retrieve status
09fc : 48 > pha
> cmp_flag carry
09fd : c931 > cmp #(carry|fao)&m8 ;expected flags + always on bits
>
> trap_ne
09ff : d0fe > bne * ;failed not equal (non zero)
>
0a01 : 28 > plp ;restore status
0a02 : 18 clc
tst_stat 0
0a03 : 08 > php ;save status
0a04 : 68 > pla ;use stack to retrieve status
0a05 : 48 > pha
> cmp_flag 0
0a06 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a08 : d0fe > bne * ;failed not equal (non zero)
>
0a0a : 28 > plp ;restore status
if I_flag = 3
0a0b : 78 sei
tst_stat intdis
0a0c : 08 > php ;save status
0a0d : 68 > pla ;use stack to retrieve status
0a0e : 48 > pha
> cmp_flag intdis
0a0f : c934 > cmp #(intdis|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a11 : d0fe > bne * ;failed not equal (non zero)
>
0a13 : 28 > plp ;restore status
0a14 : 58 cli
tst_stat 0
0a15 : 08 > php ;save status
0a16 : 68 > pla ;use stack to retrieve status
0a17 : 48 > pha
> cmp_flag 0
0a18 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a1a : d0fe > bne * ;failed not equal (non zero)
>
0a1c : 28 > plp ;restore status
endif
0a1d : f8 sed
tst_stat decmode
0a1e : 08 > php ;save status
0a1f : 68 > pla ;use stack to retrieve status
0a20 : 48 > pha
> cmp_flag decmode
0a21 : c938 > cmp #(decmode|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a23 : d0fe > bne * ;failed not equal (non zero)
>
0a25 : 28 > plp ;restore status
0a26 : d8 cld
tst_stat 0
0a27 : 08 > php ;save status
0a28 : 68 > pla ;use stack to retrieve status
0a29 : 48 > pha
> cmp_flag 0
0a2a : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a2c : d0fe > bne * ;failed not equal (non zero)
>
0a2e : 28 > plp ;restore status
set_stat overfl
> load_flag overfl
0a2f : a940 > lda #overfl ;allow test to change I-flag (no mask)
>
0a31 : 48 > pha ;use stack to load status
0a32 : 28 > plp
tst_stat overfl
0a33 : 08 > php ;save status
0a34 : 68 > pla ;use stack to retrieve status
0a35 : 48 > pha
> cmp_flag overfl
0a36 : c970 > cmp #(overfl|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a38 : d0fe > bne * ;failed not equal (non zero)
>
0a3a : 28 > plp ;restore status
0a3b : b8 clv
tst_stat 0
0a3c : 08 > php ;save status
0a3d : 68 > pla ;use stack to retrieve 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
next_test
0a44 : ad0002 > lda test_case ;previous test
0a47 : c90c > cmp #test_num
> trap_ne ;test is out of sequence
0a49 : d0fe > bne * ;failed not equal (non zero)
>
000d = >test_num = test_num + 1
0a4b : a90d > lda #test_num ;*** next tests' number
0a4d : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing index register increment/decrement and transfer
; INX INY DEX DEY TAX TXA TAY TYA
0a50 : a2fe ldx #$fe
set_stat $ff
> load_flag $ff
0a52 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0a54 : 48 > pha ;use stack to load status
0a55 : 28 > plp
0a56 : e8 inx ;ff
tst_x $ff,$ff-zero
0a57 : 08 > php ;save flags
0a58 : e0ff > cpx #$ff ;test result
> trap_ne
0a5a : d0fe > bne * ;failed not equal (non zero)
>
0a5c : 68 > pla ;load status
0a5d : 48 > pha
> cmp_flag $ff-zero
0a5e : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a60 : d0fe > bne * ;failed not equal (non zero)
>
0a62 : 28 > plp ;restore status
0a63 : e8 inx ;00
tst_x 0,$ff-minus
0a64 : 08 > php ;save flags
0a65 : e000 > cpx #0 ;test result
> trap_ne
0a67 : d0fe > bne * ;failed not equal (non zero)
>
0a69 : 68 > pla ;load status
0a6a : 48 > pha
> cmp_flag $ff-minus
0a6b : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a6d : d0fe > bne * ;failed not equal (non zero)
>
0a6f : 28 > plp ;restore status
0a70 : e8 inx ;01
tst_x 1,$ff-minus-zero
0a71 : 08 > php ;save flags
0a72 : e001 > cpx #1 ;test result
> trap_ne
0a74 : d0fe > bne * ;failed not equal (non zero)
>
0a76 : 68 > pla ;load status
0a77 : 48 > pha
> cmp_flag $ff-minus-zero
0a78 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a7a : d0fe > bne * ;failed not equal (non zero)
>
0a7c : 28 > plp ;restore status
0a7d : ca dex ;00
tst_x 0,$ff-minus
0a7e : 08 > php ;save flags
0a7f : e000 > cpx #0 ;test result
> trap_ne
0a81 : d0fe > bne * ;failed not equal (non zero)
>
0a83 : 68 > pla ;load status
0a84 : 48 > pha
> cmp_flag $ff-minus
0a85 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a87 : d0fe > bne * ;failed not equal (non zero)
>
0a89 : 28 > plp ;restore status
0a8a : ca dex ;ff
tst_x $ff,$ff-zero
0a8b : 08 > php ;save flags
0a8c : e0ff > cpx #$ff ;test result
> trap_ne
0a8e : d0fe > bne * ;failed not equal (non zero)
>
0a90 : 68 > pla ;load status
0a91 : 48 > pha
> cmp_flag $ff-zero
0a92 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0a94 : d0fe > bne * ;failed not equal (non zero)
>
0a96 : 28 > plp ;restore status
0a97 : ca dex ;fe
set_stat 0
> load_flag 0
0a98 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0a9a : 48 > pha ;use stack to load status
0a9b : 28 > plp
0a9c : e8 inx ;ff
tst_x $ff,minus
0a9d : 08 > php ;save flags
0a9e : e0ff > cpx #$ff ;test result
> trap_ne
0aa0 : d0fe > bne * ;failed not equal (non zero)
>
0aa2 : 68 > pla ;load status
0aa3 : 48 > pha
> cmp_flag minus
0aa4 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0aa6 : d0fe > bne * ;failed not equal (non zero)
>
0aa8 : 28 > plp ;restore status
0aa9 : e8 inx ;00
tst_x 0,zero
0aaa : 08 > php ;save flags
0aab : e000 > cpx #0 ;test result
> trap_ne
0aad : d0fe > bne * ;failed not equal (non zero)
>
0aaf : 68 > pla ;load status
0ab0 : 48 > pha
> cmp_flag zero
0ab1 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ab3 : d0fe > bne * ;failed not equal (non zero)
>
0ab5 : 28 > plp ;restore status
0ab6 : e8 inx ;01
tst_x 1,0
0ab7 : 08 > php ;save flags
0ab8 : e001 > cpx #1 ;test result
> trap_ne
0aba : d0fe > bne * ;failed not equal (non zero)
>
0abc : 68 > pla ;load status
0abd : 48 > pha
> cmp_flag 0
0abe : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ac0 : d0fe > bne * ;failed not equal (non zero)
>
0ac2 : 28 > plp ;restore status
0ac3 : ca dex ;00
tst_x 0,zero
0ac4 : 08 > php ;save flags
0ac5 : e000 > cpx #0 ;test result
> trap_ne
0ac7 : d0fe > bne * ;failed not equal (non zero)
>
0ac9 : 68 > pla ;load status
0aca : 48 > pha
> cmp_flag zero
0acb : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0acd : d0fe > bne * ;failed not equal (non zero)
>
0acf : 28 > plp ;restore status
0ad0 : ca dex ;ff
tst_x $ff,minus
0ad1 : 08 > php ;save flags
0ad2 : e0ff > cpx #$ff ;test result
> trap_ne
0ad4 : d0fe > bne * ;failed not equal (non zero)
>
0ad6 : 68 > pla ;load status
0ad7 : 48 > pha
> cmp_flag minus
0ad8 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ada : d0fe > bne * ;failed not equal (non zero)
>
0adc : 28 > plp ;restore status
0add : a0fe ldy #$fe
set_stat $ff
> load_flag $ff
0adf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0ae1 : 48 > pha ;use stack to load status
0ae2 : 28 > plp
0ae3 : c8 iny ;ff
tst_y $ff,$ff-zero
0ae4 : 08 > php ;save flags
0ae5 : c0ff > cpy #$ff ;test result
> trap_ne
0ae7 : d0fe > bne * ;failed not equal (non zero)
>
0ae9 : 68 > pla ;load status
0aea : 48 > pha
> cmp_flag $ff-zero
0aeb : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0aed : d0fe > bne * ;failed not equal (non zero)
>
0aef : 28 > plp ;restore status
0af0 : c8 iny ;00
tst_y 0,$ff-minus
0af1 : 08 > php ;save flags
0af2 : c000 > cpy #0 ;test result
> trap_ne
0af4 : d0fe > bne * ;failed not equal (non zero)
>
0af6 : 68 > pla ;load status
0af7 : 48 > pha
> cmp_flag $ff-minus
0af8 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0afa : d0fe > bne * ;failed not equal (non zero)
>
0afc : 28 > plp ;restore status
0afd : c8 iny ;01
tst_y 1,$ff-minus-zero
0afe : 08 > php ;save flags
0aff : c001 > cpy #1 ;test result
> trap_ne
0b01 : d0fe > bne * ;failed not equal (non zero)
>
0b03 : 68 > pla ;load status
0b04 : 48 > pha
> cmp_flag $ff-minus-zero
0b05 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b07 : d0fe > bne * ;failed not equal (non zero)
>
0b09 : 28 > plp ;restore status
0b0a : 88 dey ;00
tst_y 0,$ff-minus
0b0b : 08 > php ;save flags
0b0c : c000 > cpy #0 ;test result
> trap_ne
0b0e : d0fe > bne * ;failed not equal (non zero)
>
0b10 : 68 > pla ;load status
0b11 : 48 > pha
> cmp_flag $ff-minus
0b12 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b14 : d0fe > bne * ;failed not equal (non zero)
>
0b16 : 28 > plp ;restore status
0b17 : 88 dey ;ff
tst_y $ff,$ff-zero
0b18 : 08 > php ;save flags
0b19 : c0ff > cpy #$ff ;test result
> trap_ne
0b1b : d0fe > bne * ;failed not equal (non zero)
>
0b1d : 68 > pla ;load status
0b1e : 48 > pha
> cmp_flag $ff-zero
0b1f : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b21 : d0fe > bne * ;failed not equal (non zero)
>
0b23 : 28 > plp ;restore status
0b24 : 88 dey ;fe
set_stat 0
> load_flag 0
0b25 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0b27 : 48 > pha ;use stack to load status
0b28 : 28 > plp
0b29 : c8 iny ;ff
tst_y $ff,0+minus
0b2a : 08 > php ;save flags
0b2b : c0ff > cpy #$ff ;test result
> trap_ne
0b2d : d0fe > bne * ;failed not equal (non zero)
>
0b2f : 68 > pla ;load status
0b30 : 48 > pha
> cmp_flag 0+minus
0b31 : c9b0 > cmp #(0+minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b33 : d0fe > bne * ;failed not equal (non zero)
>
0b35 : 28 > plp ;restore status
0b36 : c8 iny ;00
tst_y 0,zero
0b37 : 08 > php ;save flags
0b38 : c000 > cpy #0 ;test result
> trap_ne
0b3a : d0fe > bne * ;failed not equal (non zero)
>
0b3c : 68 > pla ;load status
0b3d : 48 > pha
> cmp_flag zero
0b3e : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b40 : d0fe > bne * ;failed not equal (non zero)
>
0b42 : 28 > plp ;restore status
0b43 : c8 iny ;01
tst_y 1,0
0b44 : 08 > php ;save flags
0b45 : c001 > cpy #1 ;test result
> trap_ne
0b47 : d0fe > bne * ;failed not equal (non zero)
>
0b49 : 68 > pla ;load status
0b4a : 48 > pha
> cmp_flag 0
0b4b : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b4d : d0fe > bne * ;failed not equal (non zero)
>
0b4f : 28 > plp ;restore status
0b50 : 88 dey ;00
tst_y 0,zero
0b51 : 08 > php ;save flags
0b52 : c000 > cpy #0 ;test result
> trap_ne
0b54 : d0fe > bne * ;failed not equal (non zero)
>
0b56 : 68 > pla ;load status
0b57 : 48 > pha
> cmp_flag zero
0b58 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b5a : d0fe > bne * ;failed not equal (non zero)
>
0b5c : 28 > plp ;restore status
0b5d : 88 dey ;ff
tst_y $ff,minus
0b5e : 08 > php ;save flags
0b5f : c0ff > cpy #$ff ;test result
> trap_ne
0b61 : d0fe > bne * ;failed not equal (non zero)
>
0b63 : 68 > pla ;load status
0b64 : 48 > pha
> cmp_flag minus
0b65 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b67 : d0fe > bne * ;failed not equal (non zero)
>
0b69 : 28 > plp ;restore status
0b6a : a2ff ldx #$ff
set_stat $ff
> load_flag $ff
0b6c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0b6e : 48 > pha ;use stack to load status
0b6f : 28 > plp
0b70 : 8a txa
tst_a $ff,$ff-zero
0b71 : 08 > php ;save flags
0b72 : c9ff > cmp #$ff ;test result
> trap_ne
0b74 : d0fe > bne * ;failed not equal (non zero)
>
0b76 : 68 > pla ;load status
0b77 : 48 > pha
> cmp_flag $ff-zero
0b78 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b7a : d0fe > bne * ;failed not equal (non zero)
>
0b7c : 28 > plp ;restore status
0b7d : 08 php
0b7e : e8 inx ;00
0b7f : 28 plp
0b80 : 8a txa
tst_a 0,$ff-minus
0b81 : 08 > php ;save flags
0b82 : c900 > cmp #0 ;test result
> trap_ne
0b84 : d0fe > bne * ;failed not equal (non zero)
>
0b86 : 68 > pla ;load status
0b87 : 48 > pha
> cmp_flag $ff-minus
0b88 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b8a : d0fe > bne * ;failed not equal (non zero)
>
0b8c : 28 > plp ;restore status
0b8d : 08 php
0b8e : e8 inx ;01
0b8f : 28 plp
0b90 : 8a txa
tst_a 1,$ff-minus-zero
0b91 : 08 > php ;save flags
0b92 : c901 > cmp #1 ;test result
> trap_ne
0b94 : d0fe > bne * ;failed not equal (non zero)
>
0b96 : 68 > pla ;load status
0b97 : 48 > pha
> cmp_flag $ff-minus-zero
0b98 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0b9a : d0fe > bne * ;failed not equal (non zero)
>
0b9c : 28 > plp ;restore status
set_stat 0
> load_flag 0
0b9d : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0b9f : 48 > pha ;use stack to load status
0ba0 : 28 > plp
0ba1 : 8a txa
tst_a 1,0
0ba2 : 08 > php ;save flags
0ba3 : c901 > cmp #1 ;test result
> trap_ne
0ba5 : d0fe > bne * ;failed not equal (non zero)
>
0ba7 : 68 > pla ;load status
0ba8 : 48 > pha
> cmp_flag 0
0ba9 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0bab : d0fe > bne * ;failed not equal (non zero)
>
0bad : 28 > plp ;restore status
0bae : 08 php
0baf : ca dex ;00
0bb0 : 28 plp
0bb1 : 8a txa
tst_a 0,zero
0bb2 : 08 > php ;save flags
0bb3 : c900 > cmp #0 ;test result
> trap_ne
0bb5 : d0fe > bne * ;failed not equal (non zero)
>
0bb7 : 68 > pla ;load status
0bb8 : 48 > pha
> cmp_flag zero
0bb9 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0bbb : d0fe > bne * ;failed not equal (non zero)
>
0bbd : 28 > plp ;restore status
0bbe : 08 php
0bbf : ca dex ;ff
0bc0 : 28 plp
0bc1 : 8a txa
tst_a $ff,minus
0bc2 : 08 > php ;save flags
0bc3 : c9ff > cmp #$ff ;test result
> trap_ne
0bc5 : d0fe > bne * ;failed not equal (non zero)
>
0bc7 : 68 > pla ;load status
0bc8 : 48 > pha
> cmp_flag minus
0bc9 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0bcb : d0fe > bne * ;failed not equal (non zero)
>
0bcd : 28 > plp ;restore status
0bce : a0ff ldy #$ff
set_stat $ff
> load_flag $ff
0bd0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0bd2 : 48 > pha ;use stack to load status
0bd3 : 28 > plp
0bd4 : 98 tya
tst_a $ff,$ff-zero
0bd5 : 08 > php ;save flags
0bd6 : c9ff > cmp #$ff ;test result
> trap_ne
0bd8 : d0fe > bne * ;failed not equal (non zero)
>
0bda : 68 > pla ;load status
0bdb : 48 > pha
> cmp_flag $ff-zero
0bdc : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0bde : d0fe > bne * ;failed not equal (non zero)
>
0be0 : 28 > plp ;restore status
0be1 : 08 php
0be2 : c8 iny ;00
0be3 : 28 plp
0be4 : 98 tya
tst_a 0,$ff-minus
0be5 : 08 > php ;save flags
0be6 : c900 > cmp #0 ;test result
> trap_ne
0be8 : d0fe > bne * ;failed not equal (non zero)
>
0bea : 68 > pla ;load status
0beb : 48 > pha
> cmp_flag $ff-minus
0bec : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0bee : d0fe > bne * ;failed not equal (non zero)
>
0bf0 : 28 > plp ;restore status
0bf1 : 08 php
0bf2 : c8 iny ;01
0bf3 : 28 plp
0bf4 : 98 tya
tst_a 1,$ff-minus-zero
0bf5 : 08 > php ;save flags
0bf6 : c901 > cmp #1 ;test result
> trap_ne
0bf8 : d0fe > bne * ;failed not equal (non zero)
>
0bfa : 68 > pla ;load status
0bfb : 48 > pha
> cmp_flag $ff-minus-zero
0bfc : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0bfe : d0fe > bne * ;failed not equal (non zero)
>
0c00 : 28 > plp ;restore status
set_stat 0
> load_flag 0
0c01 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0c03 : 48 > pha ;use stack to load status
0c04 : 28 > plp
0c05 : 98 tya
tst_a 1,0
0c06 : 08 > php ;save flags
0c07 : c901 > cmp #1 ;test result
> trap_ne
0c09 : d0fe > bne * ;failed not equal (non zero)
>
0c0b : 68 > pla ;load status
0c0c : 48 > pha
> cmp_flag 0
0c0d : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c0f : d0fe > bne * ;failed not equal (non zero)
>
0c11 : 28 > plp ;restore status
0c12 : 08 php
0c13 : 88 dey ;00
0c14 : 28 plp
0c15 : 98 tya
tst_a 0,zero
0c16 : 08 > php ;save flags
0c17 : c900 > cmp #0 ;test result
> trap_ne
0c19 : d0fe > bne * ;failed not equal (non zero)
>
0c1b : 68 > pla ;load status
0c1c : 48 > pha
> cmp_flag zero
0c1d : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c1f : d0fe > bne * ;failed not equal (non zero)
>
0c21 : 28 > plp ;restore status
0c22 : 08 php
0c23 : 88 dey ;ff
0c24 : 28 plp
0c25 : 98 tya
tst_a $ff,minus
0c26 : 08 > php ;save flags
0c27 : c9ff > cmp #$ff ;test result
> trap_ne
0c29 : d0fe > bne * ;failed not equal (non zero)
>
0c2b : 68 > pla ;load status
0c2c : 48 > pha
> cmp_flag minus
0c2d : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c2f : d0fe > bne * ;failed not equal (non zero)
>
0c31 : 28 > plp ;restore status
load_flag $ff
0c32 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
0c34 : 48 pha
0c35 : a2ff ldx #$ff ;ff
0c37 : 8a txa
0c38 : 28 plp
0c39 : a8 tay
tst_y $ff,$ff-zero
0c3a : 08 > php ;save flags
0c3b : c0ff > cpy #$ff ;test result
> trap_ne
0c3d : d0fe > bne * ;failed not equal (non zero)
>
0c3f : 68 > pla ;load status
0c40 : 48 > pha
> cmp_flag $ff-zero
0c41 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c43 : d0fe > bne * ;failed not equal (non zero)
>
0c45 : 28 > plp ;restore status
0c46 : 08 php
0c47 : e8 inx ;00
0c48 : 8a txa
0c49 : 28 plp
0c4a : a8 tay
tst_y 0,$ff-minus
0c4b : 08 > php ;save flags
0c4c : c000 > cpy #0 ;test result
> trap_ne
0c4e : d0fe > bne * ;failed not equal (non zero)
>
0c50 : 68 > pla ;load status
0c51 : 48 > pha
> cmp_flag $ff-minus
0c52 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c54 : d0fe > bne * ;failed not equal (non zero)
>
0c56 : 28 > plp ;restore status
0c57 : 08 php
0c58 : e8 inx ;01
0c59 : 8a txa
0c5a : 28 plp
0c5b : a8 tay
tst_y 1,$ff-minus-zero
0c5c : 08 > php ;save flags
0c5d : c001 > cpy #1 ;test result
> trap_ne
0c5f : d0fe > bne * ;failed not equal (non zero)
>
0c61 : 68 > pla ;load status
0c62 : 48 > pha
> cmp_flag $ff-minus-zero
0c63 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c65 : d0fe > bne * ;failed not equal (non zero)
>
0c67 : 28 > plp ;restore status
load_flag 0
0c68 : a900 > lda #0 ;allow test to change I-flag (no mask)
0c6a : 48 pha
0c6b : a900 lda #0
0c6d : 8a txa
0c6e : 28 plp
0c6f : a8 tay
tst_y 1,0
0c70 : 08 > php ;save flags
0c71 : c001 > cpy #1 ;test result
> trap_ne
0c73 : d0fe > bne * ;failed not equal (non zero)
>
0c75 : 68 > pla ;load status
0c76 : 48 > pha
> cmp_flag 0
0c77 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c79 : d0fe > bne * ;failed not equal (non zero)
>
0c7b : 28 > plp ;restore status
0c7c : 08 php
0c7d : ca dex ;00
0c7e : 8a txa
0c7f : 28 plp
0c80 : a8 tay
tst_y 0,zero
0c81 : 08 > php ;save flags
0c82 : c000 > cpy #0 ;test result
> trap_ne
0c84 : d0fe > bne * ;failed not equal (non zero)
>
0c86 : 68 > pla ;load status
0c87 : 48 > pha
> cmp_flag zero
0c88 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c8a : d0fe > bne * ;failed not equal (non zero)
>
0c8c : 28 > plp ;restore status
0c8d : 08 php
0c8e : ca dex ;ff
0c8f : 8a txa
0c90 : 28 plp
0c91 : a8 tay
tst_y $ff,minus
0c92 : 08 > php ;save flags
0c93 : c0ff > cpy #$ff ;test result
> trap_ne
0c95 : d0fe > bne * ;failed not equal (non zero)
>
0c97 : 68 > pla ;load status
0c98 : 48 > pha
> cmp_flag minus
0c99 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0c9b : d0fe > bne * ;failed not equal (non zero)
>
0c9d : 28 > plp ;restore status
load_flag $ff
0c9e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
0ca0 : 48 pha
0ca1 : a0ff ldy #$ff ;ff
0ca3 : 98 tya
0ca4 : 28 plp
0ca5 : aa tax
tst_x $ff,$ff-zero
0ca6 : 08 > php ;save flags
0ca7 : e0ff > cpx #$ff ;test result
> trap_ne
0ca9 : d0fe > bne * ;failed not equal (non zero)
>
0cab : 68 > pla ;load status
0cac : 48 > pha
> cmp_flag $ff-zero
0cad : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0caf : d0fe > bne * ;failed not equal (non zero)
>
0cb1 : 28 > plp ;restore status
0cb2 : 08 php
0cb3 : c8 iny ;00
0cb4 : 98 tya
0cb5 : 28 plp
0cb6 : aa tax
tst_x 0,$ff-minus
0cb7 : 08 > php ;save flags
0cb8 : e000 > cpx #0 ;test result
> trap_ne
0cba : d0fe > bne * ;failed not equal (non zero)
>
0cbc : 68 > pla ;load status
0cbd : 48 > pha
> cmp_flag $ff-minus
0cbe : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0cc0 : d0fe > bne * ;failed not equal (non zero)
>
0cc2 : 28 > plp ;restore status
0cc3 : 08 php
0cc4 : c8 iny ;01
0cc5 : 98 tya
0cc6 : 28 plp
0cc7 : aa tax
tst_x 1,$ff-minus-zero
0cc8 : 08 > php ;save flags
0cc9 : e001 > cpx #1 ;test result
> trap_ne
0ccb : d0fe > bne * ;failed not equal (non zero)
>
0ccd : 68 > pla ;load status
0cce : 48 > pha
> cmp_flag $ff-minus-zero
0ccf : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0cd1 : d0fe > bne * ;failed not equal (non zero)
>
0cd3 : 28 > plp ;restore status
load_flag 0
0cd4 : a900 > lda #0 ;allow test to change I-flag (no mask)
0cd6 : 48 pha
0cd7 : a900 lda #0 ;preset status
0cd9 : 98 tya
0cda : 28 plp
0cdb : aa tax
tst_x 1,0
0cdc : 08 > php ;save flags
0cdd : e001 > cpx #1 ;test result
> trap_ne
0cdf : d0fe > bne * ;failed not equal (non zero)
>
0ce1 : 68 > pla ;load status
0ce2 : 48 > pha
> cmp_flag 0
0ce3 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0ce5 : d0fe > bne * ;failed not equal (non zero)
>
0ce7 : 28 > plp ;restore status
0ce8 : 08 php
0ce9 : 88 dey ;00
0cea : 98 tya
0ceb : 28 plp
0cec : aa tax
tst_x 0,zero
0ced : 08 > php ;save flags
0cee : e000 > cpx #0 ;test result
> trap_ne
0cf0 : d0fe > bne * ;failed not equal (non zero)
>
0cf2 : 68 > pla ;load status
0cf3 : 48 > pha
> cmp_flag zero
0cf4 : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0cf6 : d0fe > bne * ;failed not equal (non zero)
>
0cf8 : 28 > plp ;restore status
0cf9 : 08 php
0cfa : 88 dey ;ff
0cfb : 98 tya
0cfc : 28 plp
0cfd : aa tax
tst_x $ff,minus
0cfe : 08 > php ;save flags
0cff : e0ff > cpx #$ff ;test result
> trap_ne
0d01 : d0fe > bne * ;failed not equal (non zero)
>
0d03 : 68 > pla ;load status
0d04 : 48 > pha
> cmp_flag minus
0d05 : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
>
> trap_ne
0d07 : d0fe > bne * ;failed not equal (non zero)
>
0d09 : 28 > plp ;restore status
next_test
0d0a : ad0002 > lda test_case ;previous test
0d0d : c90d > cmp #test_num
> trap_ne ;test is out of sequence
0d0f : d0fe > bne * ;failed not equal (non zero)
>
000e = >test_num = test_num + 1
0d11 : a90e > lda #test_num ;*** next tests' number
0d13 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
;TSX sets NZ - TXS does not
0d16 : a201 ldx #1 ;01
set_stat $ff
> load_flag $ff
0d18 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d1a : 48 > pha ;use stack to load status
0d1b : 28 > plp
0d1c : 9a txs
0d1d : 08 php
0d1e : ad0101 lda $101
cmp_flag $ff
0d21 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
trap_ne
0d23 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
0d25 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d27 : 48 > pha ;use stack to load status
0d28 : 28 > plp
0d29 : 9a txs
0d2a : 08 php
0d2b : ad0101 lda $101
cmp_flag 0
0d2e : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
trap_ne
0d30 : d0fe > bne * ;failed not equal (non zero)
0d32 : ca dex ;00
set_stat $ff
> load_flag $ff
0d33 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d35 : 48 > pha ;use stack to load status
0d36 : 28 > plp
0d37 : 9a txs
0d38 : 08 php
0d39 : ad0001 lda $100
cmp_flag $ff
0d3c : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
trap_ne
0d3e : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
0d40 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d42 : 48 > pha ;use stack to load status
0d43 : 28 > plp
0d44 : 9a txs
0d45 : 08 php
0d46 : ad0001 lda $100
cmp_flag 0
0d49 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
trap_ne
0d4b : d0fe > bne * ;failed not equal (non zero)
0d4d : ca dex ;ff
set_stat $ff
> load_flag $ff
0d4e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d50 : 48 > pha ;use stack to load status
0d51 : 28 > plp
0d52 : 9a txs
0d53 : 08 php
0d54 : adff01 lda $1ff
cmp_flag $ff
0d57 : c9ff > cmp #($ff|fao)&m8 ;expected flags + always on bits
trap_ne
0d59 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
0d5b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0d5d : 48 > pha ;use stack to load status
0d5e : 28 > plp
0d5f : 9a txs
0d60 : 08 php
0d61 : adff01 lda $1ff
cmp_flag 0
0d64 : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
0d66 : a201 ldx #1
0d68 : 9a txs ;sp=01
set_stat $ff
> load_flag $ff
0d69 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d6b : 48 > pha ;use stack to load status
0d6c : 28 > plp
0d6d : ba tsx ;clears Z, N
0d6e : 08 php ;sp=00
0d6f : e001 cpx #1
trap_ne
0d71 : d0fe > bne * ;failed not equal (non zero)
0d73 : ad0101 lda $101
cmp_flag $ff-minus-zero
0d76 : c97d > cmp #($ff-minus-zero|fao)&m8 ;expected flags + always on bits
trap_ne
0d78 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
0d7a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0d7c : 48 > pha ;use stack to load status
0d7d : 28 > plp
0d7e : ba tsx ;clears N, sets Z
0d7f : 08 php ;sp=ff
0d80 : e000 cpx #0
trap_ne
0d82 : d0fe > bne * ;failed not equal (non zero)
0d84 : ad0001 lda $100
cmp_flag $ff-minus
0d87 : c97f > cmp #($ff-minus|fao)&m8 ;expected flags + always on bits
trap_ne
0d89 : d0fe > bne * ;failed not equal (non zero)
set_stat $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 : 28 > plp
0d8f : ba tsx ;clears N, sets Z
0d90 : 08 php ;sp=fe
0d91 : e0ff cpx #$ff
trap_ne
0d93 : d0fe > bne * ;failed not equal (non zero)
0d95 : adff01 lda $1ff
cmp_flag $ff-zero
0d98 : c9fd > cmp #($ff-zero|fao)&m8 ;expected flags + always on bits
trap_ne
0d9a : d0fe > bne * ;failed not equal (non zero)
0d9c : a201 ldx #1
0d9e : 9a txs ;sp=01
set_stat 0
> load_flag 0
0d9f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0da1 : 48 > pha ;use stack to load status
0da2 : 28 > plp
0da3 : ba tsx ;clears Z, N
0da4 : 08 php ;sp=00
0da5 : e001 cpx #1
trap_ne
0da7 : d0fe > bne * ;failed not equal (non zero)
0da9 : ad0101 lda $101
cmp_flag 0
0dac : c930 > cmp #(0|fao)&m8 ;expected flags + always on bits
trap_ne
0dae : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
0db0 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0db2 : 48 > pha ;use stack to load status
0db3 : 28 > plp
0db4 : ba tsx ;clears N, sets Z
0db5 : 08 php ;sp=ff
0db6 : e000 cpx #0
trap_ne
0db8 : d0fe > bne * ;failed not equal (non zero)
0dba : ad0001 lda $100
cmp_flag zero
0dbd : c932 > cmp #(zero|fao)&m8 ;expected flags + always on bits
trap_ne
0dbf : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
0dc1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0dc3 : 48 > pha ;use stack to load status
0dc4 : 28 > plp
0dc5 : ba tsx ;clears N, sets Z
0dc6 : 08 php ;sp=fe
0dc7 : e0ff cpx #$ff
trap_ne
0dc9 : d0fe > bne * ;failed not equal (non zero)
0dcb : adff01 lda $1ff
cmp_flag minus
0dce : c9b0 > cmp #(minus|fao)&m8 ;expected flags + always on bits
trap_ne
0dd0 : d0fe > bne * ;failed not equal (non zero)
0dd2 : 68 pla ;sp=ff
next_test
0dd3 : ad0002 > lda test_case ;previous test
0dd6 : c90e > cmp #test_num
> trap_ne ;test is out of sequence
0dd8 : d0fe > bne * ;failed not equal (non zero)
>
000f = >test_num = test_num + 1
0dda : a90f > lda #test_num ;*** next tests' number
0ddc : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing index register load & store LDY LDX STY STX all addressing modes
; LDX / STX - zp,y / abs,y
0ddf : a003 ldy #3
0de1 : tldx
set_stat 0
> load_flag 0
0de1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0de3 : 48 > pha ;use stack to load status
0de4 : 28 > plp
0de5 : b613 ldx zp1,y
0de7 : 08 php ;test stores do not alter flags
0de8 : 8a txa
0de9 : 49c3 eor #$c3
0deb : 28 plp
0dec : 990302 sta abst,y
0def : 08 php ;flags after load/store sequence
0df0 : 49c3 eor #$c3
0df2 : d90802 cmp abs1,y ;test result
trap_ne
0df5 : d0fe > bne * ;failed not equal (non zero)
0df7 : 68 pla ;load status
eor_flag 0
0df8 : 4930 > eor #0|fao ;invert expected flags + always on bits
0dfa : d90d02 cmp fLDx,y ;test flags
trap_ne
0dfd : d0fe > bne * ;failed not equal (non zero)
0dff : 88 dey
0e00 : 10df bpl tldx
0e02 : a003 ldy #3
0e04 : tldx1
set_stat $ff
> load_flag $ff
0e04 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0e06 : 48 > pha ;use stack to load status
0e07 : 28 > plp
0e08 : b613 ldx zp1,y
0e0a : 08 php ;test stores do not alter flags
0e0b : 8a txa
0e0c : 49c3 eor #$c3
0e0e : 28 plp
0e0f : 990302 sta abst,y
0e12 : 08 php ;flags after load/store sequence
0e13 : 49c3 eor #$c3
0e15 : d90802 cmp abs1,y ;test result
trap_ne
0e18 : d0fe > bne * ;failed not equal (non zero)
0e1a : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
0e1b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
0e1d : d90d02 cmp fLDx,y ;test flags
trap_ne
0e20 : d0fe > bne * ;failed not equal (non zero)
0e22 : 88 dey
0e23 : 10df bpl tldx1
0e25 : a003 ldy #3
0e27 : tldx2
set_stat 0
> load_flag 0
0e27 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0e29 : 48 > pha ;use stack to load status
0e2a : 28 > plp
0e2b : be0802 ldx abs1,y
0e2e : 08 php ;test stores do not alter flags
0e2f : 8a txa
0e30 : 49c3 eor #$c3
0e32 : aa tax
0e33 : 28 plp
0e34 : 960c stx zpt,y
0e36 : 08 php ;flags after load/store sequence
0e37 : 49c3 eor #$c3
0e39 : d91300 cmp zp1,y ;test result
trap_ne
0e3c : d0fe > bne * ;failed not equal (non zero)
0e3e : 68 pla ;load status
eor_flag 0
0e3f : 4930 > eor #0|fao ;invert expected flags + always on bits
0e41 : d90d02 cmp fLDx,y ;test flags
trap_ne
0e44 : d0fe > bne * ;failed not equal (non zero)
0e46 : 88 dey
0e47 : 10de bpl tldx2
0e49 : a003 ldy #3
0e4b : tldx3
set_stat $ff
> load_flag $ff
0e4b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0e4d : 48 > pha ;use stack to load status
0e4e : 28 > plp
0e4f : be0802 ldx abs1,y
0e52 : 08 php ;test stores do not alter flags
0e53 : 8a txa
0e54 : 49c3 eor #$c3
0e56 : aa tax
0e57 : 28 plp
0e58 : 960c stx zpt,y
0e5a : 08 php ;flags after load/store sequence
0e5b : 49c3 eor #$c3
0e5d : d91300 cmp zp1,y ;test result
trap_ne
0e60 : d0fe > bne * ;failed not equal (non zero)
0e62 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
0e63 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
0e65 : d90d02 cmp fLDx,y ;test flags
trap_ne
0e68 : d0fe > bne * ;failed not equal (non zero)
0e6a : 88 dey
0e6b : 10de bpl tldx3
0e6d : a003 ldy #3 ;testing store result
0e6f : a200 ldx #0
0e71 : b90c00 tstx lda zpt,y
0e74 : 49c3 eor #$c3
0e76 : d91300 cmp zp1,y
trap_ne ;store to zp data
0e79 : d0fe > bne * ;failed not equal (non zero)
0e7b : 960c stx zpt,y ;clear
0e7d : b90302 lda abst,y
0e80 : 49c3 eor #$c3
0e82 : d90802 cmp abs1,y
trap_ne ;store to abs data
0e85 : d0fe > bne * ;failed not equal (non zero)
0e87 : 8a txa
0e88 : 990302 sta abst,y ;clear
0e8b : 88 dey
0e8c : 10e3 bpl tstx
next_test
0e8e : ad0002 > lda test_case ;previous test
0e91 : c90f > cmp #test_num
> trap_ne ;test is out of sequence
0e93 : d0fe > bne * ;failed not equal (non zero)
>
0010 = >test_num = test_num + 1
0e95 : a910 > lda #test_num ;*** next tests' number
0e97 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; indexed wraparound test (only zp should wrap)
0e9a : a0fd ldy #3+$fa
0e9c : b619 tldx4 ldx zp1-$fa&$ff,y ;wrap on indexed zp
0e9e : 8a txa
0e9f : 990901 sta abst-$fa,y ;no STX abs,y!
0ea2 : 88 dey
0ea3 : c0fa cpy #$fa
0ea5 : b0f5 bcs tldx4
0ea7 : a0fd ldy #3+$fa
0ea9 : be0e01 tldx5 ldx abs1-$fa,y ;no wrap on indexed abs
0eac : 9612 stx zpt-$fa&$ff,y
0eae : 88 dey
0eaf : c0fa cpy #$fa
0eb1 : b0f6 bcs tldx5
0eb3 : a003 ldy #3 ;testing wraparound result
0eb5 : a200 ldx #0
0eb7 : b90c00 tstx1 lda zpt,y
0eba : d91300 cmp zp1,y
trap_ne ;store to zp data
0ebd : d0fe > bne * ;failed not equal (non zero)
0ebf : 960c stx zpt,y ;clear
0ec1 : b90302 lda abst,y
0ec4 : d90802 cmp abs1,y
trap_ne ;store to abs data
0ec7 : d0fe > bne * ;failed not equal (non zero)
0ec9 : 8a txa
0eca : 990302 sta abst,y ;clear
0ecd : 88 dey
0ece : 10e7 bpl tstx1
next_test
0ed0 : ad0002 > lda test_case ;previous test
0ed3 : c910 > cmp #test_num
> trap_ne ;test is out of sequence
0ed5 : d0fe > bne * ;failed not equal (non zero)
>
0011 = >test_num = test_num + 1
0ed7 : a911 > lda #test_num ;*** next tests' number
0ed9 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; LDY / STY - zp,x / abs,x
0edc : a203 ldx #3
0ede : tldy
set_stat 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 : 28 > plp
0ee2 : b413 ldy zp1,x
0ee4 : 08 php ;test stores do not alter flags
0ee5 : 98 tya
0ee6 : 49c3 eor #$c3
0ee8 : 28 plp
0ee9 : 9d0302 sta abst,x
0eec : 08 php ;flags after load/store sequence
0eed : 49c3 eor #$c3
0eef : dd0802 cmp abs1,x ;test result
trap_ne
0ef2 : d0fe > bne * ;failed not equal (non zero)
0ef4 : 68 pla ;load status
eor_flag 0
0ef5 : 4930 > eor #0|fao ;invert expected flags + always on bits
0ef7 : dd0d02 cmp fLDx,x ;test flags
trap_ne
0efa : d0fe > bne * ;failed not equal (non zero)
0efc : ca dex
0efd : 10df bpl tldy
0eff : a203 ldx #3
0f01 : tldy1
set_stat $ff
> load_flag $ff
0f01 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0f03 : 48 > pha ;use stack to load status
0f04 : 28 > plp
0f05 : b413 ldy zp1,x
0f07 : 08 php ;test stores do not alter flags
0f08 : 98 tya
0f09 : 49c3 eor #$c3
0f0b : 28 plp
0f0c : 9d0302 sta abst,x
0f0f : 08 php ;flags after load/store sequence
0f10 : 49c3 eor #$c3
0f12 : dd0802 cmp abs1,x ;test result
trap_ne
0f15 : d0fe > bne * ;failed not equal (non zero)
0f17 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
0f18 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
0f1a : dd0d02 cmp fLDx,x ;test flags
trap_ne
0f1d : d0fe > bne * ;failed not equal (non zero)
0f1f : ca dex
0f20 : 10df bpl tldy1
0f22 : a203 ldx #3
0f24 : tldy2
set_stat 0
> load_flag 0
0f24 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0f26 : 48 > pha ;use stack to load status
0f27 : 28 > plp
0f28 : bc0802 ldy abs1,x
0f2b : 08 php ;test stores do not alter flags
0f2c : 98 tya
0f2d : 49c3 eor #$c3
0f2f : a8 tay
0f30 : 28 plp
0f31 : 940c sty zpt,x
0f33 : 08 php ;flags after load/store sequence
0f34 : 49c3 eor #$c3
0f36 : d513 cmp zp1,x ;test result
trap_ne
0f38 : d0fe > bne * ;failed not equal (non zero)
0f3a : 68 pla ;load status
eor_flag 0
0f3b : 4930 > eor #0|fao ;invert expected flags + always on bits
0f3d : dd0d02 cmp fLDx,x ;test flags
trap_ne
0f40 : d0fe > bne * ;failed not equal (non zero)
0f42 : ca dex
0f43 : 10df bpl tldy2
0f45 : a203 ldx #3
0f47 : tldy3
set_stat $ff
> load_flag $ff
0f47 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
0f49 : 48 > pha ;use stack to load status
0f4a : 28 > plp
0f4b : bc0802 ldy abs1,x
0f4e : 08 php ;test stores do not alter flags
0f4f : 98 tya
0f50 : 49c3 eor #$c3
0f52 : a8 tay
0f53 : 28 plp
0f54 : 940c sty zpt,x
0f56 : 08 php ;flags after load/store sequence
0f57 : 49c3 eor #$c3
0f59 : d513 cmp zp1,x ;test result
trap_ne
0f5b : d0fe > bne * ;failed not equal (non zero)
0f5d : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
0f5e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
0f60 : dd0d02 cmp fLDx,x ;test flags
trap_ne
0f63 : d0fe > bne * ;failed not equal (non zero)
0f65 : ca dex
0f66 : 10df bpl tldy3
0f68 : a203 ldx #3 ;testing store result
0f6a : a000 ldy #0
0f6c : b50c tsty lda zpt,x
0f6e : 49c3 eor #$c3
0f70 : d513 cmp zp1,x
trap_ne ;store to zp,x data
0f72 : d0fe > bne * ;failed not equal (non zero)
0f74 : 940c sty zpt,x ;clear
0f76 : bd0302 lda abst,x
0f79 : 49c3 eor #$c3
0f7b : dd0802 cmp abs1,x
trap_ne ;store to abs,x data
0f7e : d0fe > bne * ;failed not equal (non zero)
0f80 : 8a txa
0f81 : 9d0302 sta abst,x ;clear
0f84 : ca dex
0f85 : 10e5 bpl tsty
next_test
0f87 : ad0002 > lda test_case ;previous test
0f8a : c911 > cmp #test_num
> trap_ne ;test is out of sequence
0f8c : d0fe > bne * ;failed not equal (non zero)
>
0012 = >test_num = test_num + 1
0f8e : a912 > lda #test_num ;*** next tests' number
0f90 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; indexed wraparound test (only zp should wrap)
0f93 : a2fd ldx #3+$fa
0f95 : b419 tldy4 ldy zp1-$fa&$ff,x ;wrap on indexed zp
0f97 : 98 tya
0f98 : 9d0901 sta abst-$fa,x ;no STX abs,x!
0f9b : ca dex
0f9c : e0fa cpx #$fa
0f9e : b0f5 bcs tldy4
0fa0 : a2fd ldx #3+$fa
0fa2 : bc0e01 tldy5 ldy abs1-$fa,x ;no wrap on indexed abs
0fa5 : 9412 sty zpt-$fa&$ff,x
0fa7 : ca dex
0fa8 : e0fa cpx #$fa
0faa : b0f6 bcs tldy5
0fac : a203 ldx #3 ;testing wraparound result
0fae : a000 ldy #0
0fb0 : b50c tsty1 lda zpt,x
0fb2 : d513 cmp zp1,x
trap_ne ;store to zp,x data
0fb4 : d0fe > bne * ;failed not equal (non zero)
0fb6 : 940c sty zpt,x ;clear
0fb8 : bd0302 lda abst,x
0fbb : dd0802 cmp abs1,x
trap_ne ;store to abs,x data
0fbe : d0fe > bne * ;failed not equal (non zero)
0fc0 : 8a txa
0fc1 : 9d0302 sta abst,x ;clear
0fc4 : ca dex
0fc5 : 10e9 bpl tsty1
next_test
0fc7 : ad0002 > lda test_case ;previous test
0fca : c912 > cmp #test_num
> trap_ne ;test is out of sequence
0fcc : d0fe > bne * ;failed not equal (non zero)
>
0013 = >test_num = test_num + 1
0fce : a913 > lda #test_num ;*** next tests' number
0fd0 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; LDX / STX - zp / abs / #
set_stat 0
> load_flag 0
0fd3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0fd5 : 48 > pha ;use stack to load status
0fd6 : 28 > plp
0fd7 : a613 ldx zp1
0fd9 : 08 php ;test stores do not alter flags
0fda : 8a txa
0fdb : 49c3 eor #$c3
0fdd : aa tax
0fde : 28 plp
0fdf : 8e0302 stx abst
0fe2 : 08 php ;flags after load/store sequence
0fe3 : 49c3 eor #$c3
0fe5 : aa tax
0fe6 : e0c3 cpx #$c3 ;test result
trap_ne
0fe8 : d0fe > bne * ;failed not equal (non zero)
0fea : 68 pla ;load status
eor_flag 0
0feb : 4930 > eor #0|fao ;invert expected flags + always on bits
0fed : cd0d02 cmp fLDx ;test flags
trap_ne
0ff0 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
0ff2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
0ff4 : 48 > pha ;use stack to load status
0ff5 : 28 > plp
0ff6 : a614 ldx zp1+1
0ff8 : 08 php ;test stores do not alter flags
0ff9 : 8a txa
0ffa : 49c3 eor #$c3
0ffc : aa tax
0ffd : 28 plp
0ffe : 8e0402 stx abst+1
1001 : 08 php ;flags after load/store sequence
1002 : 49c3 eor #$c3
1004 : aa tax
1005 : e082 cpx #$82 ;test result
trap_ne
1007 : d0fe > bne * ;failed not equal (non zero)
1009 : 68 pla ;load status
eor_flag 0
100a : 4930 > eor #0|fao ;invert expected flags + always on bits
100c : cd0e02 cmp fLDx+1 ;test flags
trap_ne
100f : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1011 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1013 : 48 > pha ;use stack to load status
1014 : 28 > plp
1015 : a615 ldx zp1+2
1017 : 08 php ;test stores do not alter flags
1018 : 8a txa
1019 : 49c3 eor #$c3
101b : aa tax
101c : 28 plp
101d : 8e0502 stx abst+2
1020 : 08 php ;flags after load/store sequence
1021 : 49c3 eor #$c3
1023 : aa tax
1024 : e041 cpx #$41 ;test result
trap_ne
1026 : d0fe > bne * ;failed not equal (non zero)
1028 : 68 pla ;load status
eor_flag 0
1029 : 4930 > eor #0|fao ;invert expected flags + always on bits
102b : cd0f02 cmp fLDx+2 ;test flags
trap_ne
102e : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1030 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1032 : 48 > pha ;use stack to load status
1033 : 28 > plp
1034 : a616 ldx zp1+3
1036 : 08 php ;test stores do not alter flags
1037 : 8a txa
1038 : 49c3 eor #$c3
103a : aa tax
103b : 28 plp
103c : 8e0602 stx abst+3
103f : 08 php ;flags after load/store sequence
1040 : 49c3 eor #$c3
1042 : aa tax
1043 : e000 cpx #0 ;test result
trap_ne
1045 : d0fe > bne * ;failed not equal (non zero)
1047 : 68 pla ;load status
eor_flag 0
1048 : 4930 > eor #0|fao ;invert expected flags + always on bits
104a : cd1002 cmp fLDx+3 ;test flags
trap_ne
104d : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
104f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1051 : 48 > pha ;use stack to load status
1052 : 28 > plp
1053 : a613 ldx zp1
1055 : 08 php ;test stores do not alter flags
1056 : 8a txa
1057 : 49c3 eor #$c3
1059 : aa tax
105a : 28 plp
105b : 8e0302 stx abst
105e : 08 php ;flags after load/store sequence
105f : 49c3 eor #$c3
1061 : aa tax
1062 : e0c3 cpx #$c3 ;test result
trap_ne ;
1064 : d0fe > bne * ;failed not equal (non zero)
1066 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1067 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1069 : cd0d02 cmp fLDx ;test flags
trap_ne
106c : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
106e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1070 : 48 > pha ;use stack to load status
1071 : 28 > plp
1072 : a614 ldx zp1+1
1074 : 08 php ;test stores do not alter flags
1075 : 8a txa
1076 : 49c3 eor #$c3
1078 : aa tax
1079 : 28 plp
107a : 8e0402 stx abst+1
107d : 08 php ;flags after load/store sequence
107e : 49c3 eor #$c3
1080 : aa tax
1081 : e082 cpx #$82 ;test result
trap_ne
1083 : d0fe > bne * ;failed not equal (non zero)
1085 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1086 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1088 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
108b : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
108d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
108f : 48 > pha ;use stack to load status
1090 : 28 > plp
1091 : a615 ldx zp1+2
1093 : 08 php ;test stores do not alter flags
1094 : 8a txa
1095 : 49c3 eor #$c3
1097 : aa tax
1098 : 28 plp
1099 : 8e0502 stx abst+2
109c : 08 php ;flags after load/store sequence
109d : 49c3 eor #$c3
109f : aa tax
10a0 : e041 cpx #$41 ;test result
trap_ne ;
10a2 : d0fe > bne * ;failed not equal (non zero)
10a4 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
10a5 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
10a7 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
10aa : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
10ac : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
10ae : 48 > pha ;use stack to load status
10af : 28 > plp
10b0 : a616 ldx zp1+3
10b2 : 08 php ;test stores do not alter flags
10b3 : 8a txa
10b4 : 49c3 eor #$c3
10b6 : aa tax
10b7 : 28 plp
10b8 : 8e0602 stx abst+3
10bb : 08 php ;flags after load/store sequence
10bc : 49c3 eor #$c3
10be : aa tax
10bf : e000 cpx #0 ;test result
trap_ne
10c1 : d0fe > bne * ;failed not equal (non zero)
10c3 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
10c4 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
10c6 : cd1002 cmp fLDx+3 ;test flags
trap_ne
10c9 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
10cb : a900 > lda #0 ;allow test to change I-flag (no mask)
>
10cd : 48 > pha ;use stack to load status
10ce : 28 > plp
10cf : ae0802 ldx abs1
10d2 : 08 php ;test stores do not alter flags
10d3 : 8a txa
10d4 : 49c3 eor #$c3
10d6 : aa tax
10d7 : 28 plp
10d8 : 860c stx zpt
10da : 08 php ;flags after load/store sequence
10db : 49c3 eor #$c3
10dd : c513 cmp zp1 ;test result
trap_ne
10df : d0fe > bne * ;failed not equal (non zero)
10e1 : 68 pla ;load status
eor_flag 0
10e2 : 4930 > eor #0|fao ;invert expected flags + always on bits
10e4 : cd0d02 cmp fLDx ;test flags
trap_ne
10e7 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
10e9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
10eb : 48 > pha ;use stack to load status
10ec : 28 > plp
10ed : ae0902 ldx abs1+1
10f0 : 08 php ;test stores do not alter flags
10f1 : 8a txa
10f2 : 49c3 eor #$c3
10f4 : aa tax
10f5 : 28 plp
10f6 : 860d stx zpt+1
10f8 : 08 php ;flags after load/store sequence
10f9 : 49c3 eor #$c3
10fb : c514 cmp zp1+1 ;test result
trap_ne
10fd : d0fe > bne * ;failed not equal (non zero)
10ff : 68 pla ;load status
eor_flag 0
1100 : 4930 > eor #0|fao ;invert expected flags + always on bits
1102 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
1105 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1107 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1109 : 48 > pha ;use stack to load status
110a : 28 > plp
110b : ae0a02 ldx abs1+2
110e : 08 php ;test stores do not alter flags
110f : 8a txa
1110 : 49c3 eor #$c3
1112 : aa tax
1113 : 28 plp
1114 : 860e stx zpt+2
1116 : 08 php ;flags after load/store sequence
1117 : 49c3 eor #$c3
1119 : c515 cmp zp1+2 ;test result
trap_ne
111b : d0fe > bne * ;failed not equal (non zero)
111d : 68 pla ;load status
eor_flag 0
111e : 4930 > eor #0|fao ;invert expected flags + always on bits
1120 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
1123 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1125 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1127 : 48 > pha ;use stack to load status
1128 : 28 > plp
1129 : ae0b02 ldx abs1+3
112c : 08 php ;test stores do not alter flags
112d : 8a txa
112e : 49c3 eor #$c3
1130 : aa tax
1131 : 28 plp
1132 : 860f stx zpt+3
1134 : 08 php ;flags after load/store sequence
1135 : 49c3 eor #$c3
1137 : c516 cmp zp1+3 ;test result
trap_ne
1139 : d0fe > bne * ;failed not equal (non zero)
113b : 68 pla ;load status
eor_flag 0
113c : 4930 > eor #0|fao ;invert expected flags + always on bits
113e : cd1002 cmp fLDx+3 ;test flags
trap_ne
1141 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1143 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1145 : 48 > pha ;use stack to load status
1146 : 28 > plp
1147 : ae0802 ldx abs1
114a : 08 php ;test stores do not alter flags
114b : 8a txa
114c : 49c3 eor #$c3
114e : aa tax
114f : 28 plp
1150 : 860c stx zpt
1152 : 08 php ;flags after load/store sequence
1153 : 49c3 eor #$c3
1155 : aa tax
1156 : e413 cpx zp1 ;test result
trap_ne
1158 : d0fe > bne * ;failed not equal (non zero)
115a : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
115b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
115d : cd0d02 cmp fLDx ;test flags
trap_ne
1160 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1162 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1164 : 48 > pha ;use stack to load status
1165 : 28 > plp
1166 : ae0902 ldx abs1+1
1169 : 08 php ;test stores do not alter flags
116a : 8a txa
116b : 49c3 eor #$c3
116d : aa tax
116e : 28 plp
116f : 860d stx zpt+1
1171 : 08 php ;flags after load/store sequence
1172 : 49c3 eor #$c3
1174 : aa tax
1175 : e414 cpx zp1+1 ;test result
trap_ne
1177 : d0fe > bne * ;failed not equal (non zero)
1179 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
117a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
117c : cd0e02 cmp fLDx+1 ;test flags
trap_ne
117f : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1181 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1183 : 48 > pha ;use stack to load status
1184 : 28 > plp
1185 : ae0a02 ldx abs1+2
1188 : 08 php ;test stores do not alter flags
1189 : 8a txa
118a : 49c3 eor #$c3
118c : aa tax
118d : 28 plp
118e : 860e stx zpt+2
1190 : 08 php ;flags after load/store sequence
1191 : 49c3 eor #$c3
1193 : aa tax
1194 : e415 cpx zp1+2 ;test result
trap_ne
1196 : d0fe > bne * ;failed not equal (non zero)
1198 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1199 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
119b : cd0f02 cmp fLDx+2 ;test flags
trap_ne
119e : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
11a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
11a2 : 48 > pha ;use stack to load status
11a3 : 28 > plp
11a4 : ae0b02 ldx abs1+3
11a7 : 08 php ;test stores do not alter flags
11a8 : 8a txa
11a9 : 49c3 eor #$c3
11ab : aa tax
11ac : 28 plp
11ad : 860f stx zpt+3
11af : 08 php ;flags after load/store sequence
11b0 : 49c3 eor #$c3
11b2 : aa tax
11b3 : e416 cpx zp1+3 ;test result
trap_ne
11b5 : d0fe > bne * ;failed not equal (non zero)
11b7 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
11b8 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
11ba : cd1002 cmp fLDx+3 ;test flags
trap_ne
11bd : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
11bf : a900 > lda #0 ;allow test to change I-flag (no mask)
>
11c1 : 48 > pha ;use stack to load status
11c2 : 28 > plp
11c3 : a2c3 ldx #$c3
11c5 : 08 php
11c6 : ec0802 cpx abs1 ;test result
trap_ne
11c9 : d0fe > bne * ;failed not equal (non zero)
11cb : 68 pla ;load status
eor_flag 0
11cc : 4930 > eor #0|fao ;invert expected flags + always on bits
11ce : cd0d02 cmp fLDx ;test flags
trap_ne
11d1 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
11d3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
11d5 : 48 > pha ;use stack to load status
11d6 : 28 > plp
11d7 : a282 ldx #$82
11d9 : 08 php
11da : ec0902 cpx abs1+1 ;test result
trap_ne
11dd : d0fe > bne * ;failed not equal (non zero)
11df : 68 pla ;load status
eor_flag 0
11e0 : 4930 > eor #0|fao ;invert expected flags + always on bits
11e2 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
11e5 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
11e7 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
11e9 : 48 > pha ;use stack to load status
11ea : 28 > plp
11eb : a241 ldx #$41
11ed : 08 php
11ee : ec0a02 cpx abs1+2 ;test result
trap_ne
11f1 : d0fe > bne * ;failed not equal (non zero)
11f3 : 68 pla ;load status
eor_flag 0
11f4 : 4930 > eor #0|fao ;invert expected flags + always on bits
11f6 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
11f9 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
11fb : a900 > lda #0 ;allow test to change I-flag (no mask)
>
11fd : 48 > pha ;use stack to load status
11fe : 28 > plp
11ff : a200 ldx #0
1201 : 08 php
1202 : ec0b02 cpx abs1+3 ;test result
trap_ne
1205 : d0fe > bne * ;failed not equal (non zero)
1207 : 68 pla ;load status
eor_flag 0
1208 : 4930 > eor #0|fao ;invert expected flags + always on bits
120a : cd1002 cmp fLDx+3 ;test flags
trap_ne
120d : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
120f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1211 : 48 > pha ;use stack to load status
1212 : 28 > plp
1213 : a2c3 ldx #$c3
1215 : 08 php
1216 : ec0802 cpx abs1 ;test result
trap_ne
1219 : d0fe > bne * ;failed not equal (non zero)
121b : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
121c : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
121e : cd0d02 cmp fLDx ;test flags
trap_ne
1221 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1223 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1225 : 48 > pha ;use stack to load status
1226 : 28 > plp
1227 : a282 ldx #$82
1229 : 08 php
122a : ec0902 cpx abs1+1 ;test result
trap_ne
122d : d0fe > bne * ;failed not equal (non zero)
122f : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1230 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1232 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
1235 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1237 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1239 : 48 > pha ;use stack to load status
123a : 28 > plp
123b : a241 ldx #$41
123d : 08 php
123e : ec0a02 cpx abs1+2 ;test result
trap_ne
1241 : d0fe > bne * ;failed not equal (non zero)
1243 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1244 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1246 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
1249 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
124b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
124d : 48 > pha ;use stack to load status
124e : 28 > plp
124f : a200 ldx #0
1251 : 08 php
1252 : ec0b02 cpx abs1+3 ;test result
trap_ne
1255 : d0fe > bne * ;failed not equal (non zero)
1257 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1258 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
125a : cd1002 cmp fLDx+3 ;test flags
trap_ne
125d : d0fe > bne * ;failed not equal (non zero)
125f : a200 ldx #0
1261 : a50c lda zpt
1263 : 49c3 eor #$c3
1265 : c513 cmp zp1
trap_ne ;store to zp data
1267 : d0fe > bne * ;failed not equal (non zero)
1269 : 860c stx zpt ;clear
126b : ad0302 lda abst
126e : 49c3 eor #$c3
1270 : cd0802 cmp abs1
trap_ne ;store to abs data
1273 : d0fe > bne * ;failed not equal (non zero)
1275 : 8e0302 stx abst ;clear
1278 : a50d lda zpt+1
127a : 49c3 eor #$c3
127c : c514 cmp zp1+1
trap_ne ;store to zp data
127e : d0fe > bne * ;failed not equal (non zero)
1280 : 860d stx zpt+1 ;clear
1282 : ad0402 lda abst+1
1285 : 49c3 eor #$c3
1287 : cd0902 cmp abs1+1
trap_ne ;store to abs data
128a : d0fe > bne * ;failed not equal (non zero)
128c : 8e0402 stx abst+1 ;clear
128f : a50e lda zpt+2
1291 : 49c3 eor #$c3
1293 : c515 cmp zp1+2
trap_ne ;store to zp data
1295 : d0fe > bne * ;failed not equal (non zero)
1297 : 860e stx zpt+2 ;clear
1299 : ad0502 lda abst+2
129c : 49c3 eor #$c3
129e : cd0a02 cmp abs1+2
trap_ne ;store to abs data
12a1 : d0fe > bne * ;failed not equal (non zero)
12a3 : 8e0502 stx abst+2 ;clear
12a6 : a50f lda zpt+3
12a8 : 49c3 eor #$c3
12aa : c516 cmp zp1+3
trap_ne ;store to zp data
12ac : d0fe > bne * ;failed not equal (non zero)
12ae : 860f stx zpt+3 ;clear
12b0 : ad0602 lda abst+3
12b3 : 49c3 eor #$c3
12b5 : cd0b02 cmp abs1+3
trap_ne ;store to abs data
12b8 : d0fe > bne * ;failed not equal (non zero)
12ba : 8e0602 stx abst+3 ;clear
next_test
12bd : ad0002 > lda test_case ;previous test
12c0 : c913 > cmp #test_num
> trap_ne ;test is out of sequence
12c2 : d0fe > bne * ;failed not equal (non zero)
>
0014 = >test_num = test_num + 1
12c4 : a914 > lda #test_num ;*** next tests' number
12c6 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; LDY / STY - zp / abs / #
set_stat 0
> load_flag 0
12c9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
12cb : 48 > pha ;use stack to load status
12cc : 28 > plp
12cd : a413 ldy zp1
12cf : 08 php ;test stores do not alter flags
12d0 : 98 tya
12d1 : 49c3 eor #$c3
12d3 : a8 tay
12d4 : 28 plp
12d5 : 8c0302 sty abst
12d8 : 08 php ;flags after load/store sequence
12d9 : 49c3 eor #$c3
12db : a8 tay
12dc : c0c3 cpy #$c3 ;test result
trap_ne
12de : d0fe > bne * ;failed not equal (non zero)
12e0 : 68 pla ;load status
eor_flag 0
12e1 : 4930 > eor #0|fao ;invert expected flags + always on bits
12e3 : cd0d02 cmp fLDx ;test flags
trap_ne
12e6 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
12e8 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
12ea : 48 > pha ;use stack to load status
12eb : 28 > plp
12ec : a414 ldy zp1+1
12ee : 08 php ;test stores do not alter flags
12ef : 98 tya
12f0 : 49c3 eor #$c3
12f2 : a8 tay
12f3 : 28 plp
12f4 : 8c0402 sty abst+1
12f7 : 08 php ;flags after load/store sequence
12f8 : 49c3 eor #$c3
12fa : a8 tay
12fb : c082 cpy #$82 ;test result
trap_ne
12fd : d0fe > bne * ;failed not equal (non zero)
12ff : 68 pla ;load status
eor_flag 0
1300 : 4930 > eor #0|fao ;invert expected flags + always on bits
1302 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
1305 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1307 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1309 : 48 > pha ;use stack to load status
130a : 28 > plp
130b : a415 ldy zp1+2
130d : 08 php ;test stores do not alter flags
130e : 98 tya
130f : 49c3 eor #$c3
1311 : a8 tay
1312 : 28 plp
1313 : 8c0502 sty abst+2
1316 : 08 php ;flags after load/store sequence
1317 : 49c3 eor #$c3
1319 : a8 tay
131a : c041 cpy #$41 ;test result
trap_ne
131c : d0fe > bne * ;failed not equal (non zero)
131e : 68 pla ;load status
eor_flag 0
131f : 4930 > eor #0|fao ;invert expected flags + always on bits
1321 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
1324 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1326 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1328 : 48 > pha ;use stack to load status
1329 : 28 > plp
132a : a416 ldy zp1+3
132c : 08 php ;test stores do not alter flags
132d : 98 tya
132e : 49c3 eor #$c3
1330 : a8 tay
1331 : 28 plp
1332 : 8c0602 sty abst+3
1335 : 08 php ;flags after load/store sequence
1336 : 49c3 eor #$c3
1338 : a8 tay
1339 : c000 cpy #0 ;test result
trap_ne
133b : d0fe > bne * ;failed not equal (non zero)
133d : 68 pla ;load status
eor_flag 0
133e : 4930 > eor #0|fao ;invert expected flags + always on bits
1340 : cd1002 cmp fLDx+3 ;test flags
trap_ne
1343 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1345 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1347 : 48 > pha ;use stack to load status
1348 : 28 > plp
1349 : a413 ldy zp1
134b : 08 php ;test stores do not alter flags
134c : 98 tya
134d : 49c3 eor #$c3
134f : a8 tay
1350 : 28 plp
1351 : 8c0302 sty abst
1354 : 08 php ;flags after load/store sequence
1355 : 49c3 eor #$c3
1357 : a8 tay
1358 : c0c3 cpy #$c3 ;test result
trap_ne
135a : d0fe > bne * ;failed not equal (non zero)
135c : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
135d : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
135f : cd0d02 cmp fLDx ;test flags
trap_ne
1362 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1364 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1366 : 48 > pha ;use stack to load status
1367 : 28 > plp
1368 : a414 ldy zp1+1
136a : 08 php ;test stores do not alter flags
136b : 98 tya
136c : 49c3 eor #$c3
136e : a8 tay
136f : 28 plp
1370 : 8c0402 sty abst+1
1373 : 08 php ;flags after load/store sequence
1374 : 49c3 eor #$c3
1376 : a8 tay
1377 : c082 cpy #$82 ;test result
trap_ne
1379 : d0fe > bne * ;failed not equal (non zero)
137b : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
137c : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
137e : cd0e02 cmp fLDx+1 ;test flags
trap_ne
1381 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1383 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1385 : 48 > pha ;use stack to load status
1386 : 28 > plp
1387 : a415 ldy zp1+2
1389 : 08 php ;test stores do not alter flags
138a : 98 tya
138b : 49c3 eor #$c3
138d : a8 tay
138e : 28 plp
138f : 8c0502 sty abst+2
1392 : 08 php ;flags after load/store sequence
1393 : 49c3 eor #$c3
1395 : a8 tay
1396 : c041 cpy #$41 ;test result
trap_ne
1398 : d0fe > bne * ;failed not equal (non zero)
139a : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
139b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
139d : cd0f02 cmp fLDx+2 ;test flags
trap_ne
13a0 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
13a2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
13a4 : 48 > pha ;use stack to load status
13a5 : 28 > plp
13a6 : a416 ldy zp1+3
13a8 : 08 php ;test stores do not alter flags
13a9 : 98 tya
13aa : 49c3 eor #$c3
13ac : a8 tay
13ad : 28 plp
13ae : 8c0602 sty abst+3
13b1 : 08 php ;flags after load/store sequence
13b2 : 49c3 eor #$c3
13b4 : a8 tay
13b5 : c000 cpy #0 ;test result
trap_ne
13b7 : d0fe > bne * ;failed not equal (non zero)
13b9 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
13ba : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
13bc : cd1002 cmp fLDx+3 ;test flags
trap_ne
13bf : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
13c1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
13c3 : 48 > pha ;use stack to load status
13c4 : 28 > plp
13c5 : ac0802 ldy abs1
13c8 : 08 php ;test stores do not alter flags
13c9 : 98 tya
13ca : 49c3 eor #$c3
13cc : a8 tay
13cd : 28 plp
13ce : 840c sty zpt
13d0 : 08 php ;flags after load/store sequence
13d1 : 49c3 eor #$c3
13d3 : a8 tay
13d4 : c413 cpy zp1 ;test result
trap_ne
13d6 : d0fe > bne * ;failed not equal (non zero)
13d8 : 68 pla ;load status
eor_flag 0
13d9 : 4930 > eor #0|fao ;invert expected flags + always on bits
13db : cd0d02 cmp fLDx ;test flags
trap_ne
13de : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
13e0 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
13e2 : 48 > pha ;use stack to load status
13e3 : 28 > plp
13e4 : ac0902 ldy abs1+1
13e7 : 08 php ;test stores do not alter flags
13e8 : 98 tya
13e9 : 49c3 eor #$c3
13eb : a8 tay
13ec : 28 plp
13ed : 840d sty zpt+1
13ef : 08 php ;flags after load/store sequence
13f0 : 49c3 eor #$c3
13f2 : a8 tay
13f3 : c414 cpy zp1+1 ;test result
trap_ne
13f5 : d0fe > bne * ;failed not equal (non zero)
13f7 : 68 pla ;load status
eor_flag 0
13f8 : 4930 > eor #0|fao ;invert expected flags + always on bits
13fa : cd0e02 cmp fLDx+1 ;test flags
trap_ne
13fd : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
13ff : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1401 : 48 > pha ;use stack to load status
1402 : 28 > plp
1403 : ac0a02 ldy abs1+2
1406 : 08 php ;test stores do not alter flags
1407 : 98 tya
1408 : 49c3 eor #$c3
140a : a8 tay
140b : 28 plp
140c : 840e sty zpt+2
140e : 08 php ;flags after load/store sequence
140f : 49c3 eor #$c3
1411 : a8 tay
1412 : c415 cpy zp1+2 ;test result
trap_ne
1414 : d0fe > bne * ;failed not equal (non zero)
1416 : 68 pla ;load status
eor_flag 0
1417 : 4930 > eor #0|fao ;invert expected flags + always on bits
1419 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
141c : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
141e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1420 : 48 > pha ;use stack to load status
1421 : 28 > plp
1422 : ac0b02 ldy abs1+3
1425 : 08 php ;test stores do not alter flags
1426 : 98 tya
1427 : 49c3 eor #$c3
1429 : a8 tay
142a : 28 plp
142b : 840f sty zpt+3
142d : 08 php ;flags after load/store sequence
142e : 49c3 eor #$c3
1430 : a8 tay
1431 : c416 cpy zp1+3 ;test result
trap_ne
1433 : d0fe > bne * ;failed not equal (non zero)
1435 : 68 pla ;load status
eor_flag 0
1436 : 4930 > eor #0|fao ;invert expected flags + always on bits
1438 : cd1002 cmp fLDx+3 ;test flags
trap_ne
143b : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
143d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
143f : 48 > pha ;use stack to load status
1440 : 28 > plp
1441 : ac0802 ldy abs1
1444 : 08 php ;test stores do not alter flags
1445 : 98 tya
1446 : 49c3 eor #$c3
1448 : a8 tay
1449 : 28 plp
144a : 840c sty zpt
144c : 08 php ;flags after load/store sequence
144d : 49c3 eor #$c3
144f : a8 tay
1450 : c513 cmp zp1 ;test result
trap_ne
1452 : d0fe > bne * ;failed not equal (non zero)
1454 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1455 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1457 : cd0d02 cmp fLDx ;test flags
trap_ne
145a : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
145c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
145e : 48 > pha ;use stack to load status
145f : 28 > plp
1460 : ac0902 ldy abs1+1
1463 : 08 php ;test stores do not alter flags
1464 : 98 tya
1465 : 49c3 eor #$c3
1467 : a8 tay
1468 : 28 plp
1469 : 840d sty zpt+1
146b : 08 php ;flags after load/store sequence
146c : 49c3 eor #$c3
146e : a8 tay
146f : c514 cmp zp1+1 ;test result
trap_ne
1471 : d0fe > bne * ;failed not equal (non zero)
1473 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1474 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1476 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
1479 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
147b : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
147d : 48 > pha ;use stack to load status
147e : 28 > plp
147f : ac0a02 ldy abs1+2
1482 : 08 php ;test stores do not alter flags
1483 : 98 tya
1484 : 49c3 eor #$c3
1486 : a8 tay
1487 : 28 plp
1488 : 840e sty zpt+2
148a : 08 php ;flags after load/store sequence
148b : 49c3 eor #$c3
148d : a8 tay
148e : c515 cmp zp1+2 ;test result
trap_ne
1490 : d0fe > bne * ;failed not equal (non zero)
1492 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1493 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1495 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
1498 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
149a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
149c : 48 > pha ;use stack to load status
149d : 28 > plp
149e : ac0b02 ldy abs1+3
14a1 : 08 php ;test stores do not alter flags
14a2 : 98 tya
14a3 : 49c3 eor #$c3
14a5 : a8 tay
14a6 : 28 plp
14a7 : 840f sty zpt+3
14a9 : 08 php ;flags after load/store sequence
14aa : 49c3 eor #$c3
14ac : a8 tay
14ad : c516 cmp zp1+3 ;test result
trap_ne
14af : d0fe > bne * ;failed not equal (non zero)
14b1 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
14b2 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
14b4 : cd1002 cmp fLDx+3 ;test flags
trap_ne
14b7 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
14b9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
14bb : 48 > pha ;use stack to load status
14bc : 28 > plp
14bd : a0c3 ldy #$c3
14bf : 08 php
14c0 : cc0802 cpy abs1 ;test result
trap_ne
14c3 : d0fe > bne * ;failed not equal (non zero)
14c5 : 68 pla ;load status
eor_flag 0
14c6 : 4930 > eor #0|fao ;invert expected flags + always on bits
14c8 : cd0d02 cmp fLDx ;test flags
trap_ne
14cb : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
14cd : a900 > lda #0 ;allow test to change I-flag (no mask)
>
14cf : 48 > pha ;use stack to load status
14d0 : 28 > plp
14d1 : a082 ldy #$82
14d3 : 08 php
14d4 : cc0902 cpy abs1+1 ;test result
trap_ne
14d7 : d0fe > bne * ;failed not equal (non zero)
14d9 : 68 pla ;load status
eor_flag 0
14da : 4930 > eor #0|fao ;invert expected flags + always on bits
14dc : cd0e02 cmp fLDx+1 ;test flags
trap_ne
14df : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
14e1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
14e3 : 48 > pha ;use stack to load status
14e4 : 28 > plp
14e5 : a041 ldy #$41
14e7 : 08 php
14e8 : cc0a02 cpy abs1+2 ;test result
trap_ne
14eb : d0fe > bne * ;failed not equal (non zero)
14ed : 68 pla ;load status
eor_flag 0
14ee : 4930 > eor #0|fao ;invert expected flags + always on bits
14f0 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
14f3 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
14f5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
14f7 : 48 > pha ;use stack to load status
14f8 : 28 > plp
14f9 : a000 ldy #0
14fb : 08 php
14fc : cc0b02 cpy abs1+3 ;test result
trap_ne
14ff : d0fe > bne * ;failed not equal (non zero)
1501 : 68 pla ;load status
eor_flag 0
1502 : 4930 > eor #0|fao ;invert expected flags + always on bits
1504 : cd1002 cmp fLDx+3 ;test flags
trap_ne
1507 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1509 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
150b : 48 > pha ;use stack to load status
150c : 28 > plp
150d : a0c3 ldy #$c3
150f : 08 php
1510 : cc0802 cpy abs1 ;test result
trap_ne
1513 : d0fe > bne * ;failed not equal (non zero)
1515 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1516 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1518 : cd0d02 cmp fLDx ;test flags
trap_ne
151b : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
151d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
151f : 48 > pha ;use stack to load status
1520 : 28 > plp
1521 : a082 ldy #$82
1523 : 08 php
1524 : cc0902 cpy abs1+1 ;test result
trap_ne
1527 : d0fe > bne * ;failed not equal (non zero)
1529 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
152a : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
152c : cd0e02 cmp fLDx+1 ;test flags
trap_ne
152f : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1531 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1533 : 48 > pha ;use stack to load status
1534 : 28 > plp
1535 : a041 ldy #$41
1537 : 08 php
1538 : cc0a02 cpy abs1+2 ;test result
trap_ne
153b : d0fe > bne * ;failed not equal (non zero)
153d : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
153e : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1540 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
1543 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1545 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1547 : 48 > pha ;use stack to load status
1548 : 28 > plp
1549 : a000 ldy #0
154b : 08 php
154c : cc0b02 cpy abs1+3 ;test result
trap_ne
154f : d0fe > bne * ;failed not equal (non zero)
1551 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1552 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1554 : cd1002 cmp fLDx+3 ;test flags
trap_ne
1557 : d0fe > bne * ;failed not equal (non zero)
1559 : a000 ldy #0
155b : a50c lda zpt
155d : 49c3 eor #$c3
155f : c513 cmp zp1
trap_ne ;store to zp data
1561 : d0fe > bne * ;failed not equal (non zero)
1563 : 840c sty zpt ;clear
1565 : ad0302 lda abst
1568 : 49c3 eor #$c3
156a : cd0802 cmp abs1
trap_ne ;store to abs data
156d : d0fe > bne * ;failed not equal (non zero)
156f : 8c0302 sty abst ;clear
1572 : a50d lda zpt+1
1574 : 49c3 eor #$c3
1576 : c514 cmp zp1+1
trap_ne ;store to zp+1 data
1578 : d0fe > bne * ;failed not equal (non zero)
157a : 840d sty zpt+1 ;clear
157c : ad0402 lda abst+1
157f : 49c3 eor #$c3
1581 : cd0902 cmp abs1+1
trap_ne ;store to abs+1 data
1584 : d0fe > bne * ;failed not equal (non zero)
1586 : 8c0402 sty abst+1 ;clear
1589 : a50e lda zpt+2
158b : 49c3 eor #$c3
158d : c515 cmp zp1+2
trap_ne ;store to zp+2 data
158f : d0fe > bne * ;failed not equal (non zero)
1591 : 840e sty zpt+2 ;clear
1593 : ad0502 lda abst+2
1596 : 49c3 eor #$c3
1598 : cd0a02 cmp abs1+2
trap_ne ;store to abs+2 data
159b : d0fe > bne * ;failed not equal (non zero)
159d : 8c0502 sty abst+2 ;clear
15a0 : a50f lda zpt+3
15a2 : 49c3 eor #$c3
15a4 : c516 cmp zp1+3
trap_ne ;store to zp+3 data
15a6 : d0fe > bne * ;failed not equal (non zero)
15a8 : 840f sty zpt+3 ;clear
15aa : ad0602 lda abst+3
15ad : 49c3 eor #$c3
15af : cd0b02 cmp abs1+3
trap_ne ;store to abs+3 data
15b2 : d0fe > bne * ;failed not equal (non zero)
15b4 : 8c0602 sty abst+3 ;clear
next_test
15b7 : ad0002 > lda test_case ;previous test
15ba : c914 > cmp #test_num
> trap_ne ;test is out of sequence
15bc : d0fe > bne * ;failed not equal (non zero)
>
0015 = >test_num = test_num + 1
15be : a915 > lda #test_num ;*** next tests' number
15c0 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing load / store accumulator LDA / STA all addressing modes
; LDA / STA - zp,x / abs,x
15c3 : a203 ldx #3
15c5 : tldax
set_stat 0
> load_flag 0
15c5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
15c7 : 48 > pha ;use stack to load status
15c8 : 28 > plp
15c9 : b513 lda zp1,x
15cb : 08 php ;test stores do not alter flags
15cc : 49c3 eor #$c3
15ce : 28 plp
15cf : 9d0302 sta abst,x
15d2 : 08 php ;flags after load/store sequence
15d3 : 49c3 eor #$c3
15d5 : dd0802 cmp abs1,x ;test result
trap_ne
15d8 : d0fe > bne * ;failed not equal (non zero)
15da : 68 pla ;load status
eor_flag 0
15db : 4930 > eor #0|fao ;invert expected flags + always on bits
15dd : dd0d02 cmp fLDx,x ;test flags
trap_ne
15e0 : d0fe > bne * ;failed not equal (non zero)
15e2 : ca dex
15e3 : 10e0 bpl tldax
15e5 : a203 ldx #3
15e7 : tldax1
set_stat $ff
> load_flag $ff
15e7 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
15e9 : 48 > pha ;use stack to load status
15ea : 28 > plp
15eb : b513 lda zp1,x
15ed : 08 php ;test stores do not alter flags
15ee : 49c3 eor #$c3
15f0 : 28 plp
15f1 : 9d0302 sta abst,x
15f4 : 08 php ;flags after load/store sequence
15f5 : 49c3 eor #$c3
15f7 : dd0802 cmp abs1,x ;test result
trap_ne
15fa : d0fe > bne * ;failed not equal (non zero)
15fc : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
15fd : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
15ff : dd0d02 cmp fLDx,x ;test flags
trap_ne
1602 : d0fe > bne * ;failed not equal (non zero)
1604 : ca dex
1605 : 10e0 bpl tldax1
1607 : a203 ldx #3
1609 : tldax2
set_stat 0
> load_flag 0
1609 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
160b : 48 > pha ;use stack to load status
160c : 28 > plp
160d : bd0802 lda abs1,x
1610 : 08 php ;test stores do not alter flags
1611 : 49c3 eor #$c3
1613 : 28 plp
1614 : 950c sta zpt,x
1616 : 08 php ;flags after load/store sequence
1617 : 49c3 eor #$c3
1619 : d513 cmp zp1,x ;test result
trap_ne
161b : d0fe > bne * ;failed not equal (non zero)
161d : 68 pla ;load status
eor_flag 0
161e : 4930 > eor #0|fao ;invert expected flags + always on bits
1620 : dd0d02 cmp fLDx,x ;test flags
trap_ne
1623 : d0fe > bne * ;failed not equal (non zero)
1625 : ca dex
1626 : 10e1 bpl tldax2
1628 : a203 ldx #3
162a : tldax3
set_stat $ff
> load_flag $ff
162a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
162c : 48 > pha ;use stack to load status
162d : 28 > plp
162e : bd0802 lda abs1,x
1631 : 08 php ;test stores do not alter flags
1632 : 49c3 eor #$c3
1634 : 28 plp
1635 : 950c sta zpt,x
1637 : 08 php ;flags after load/store sequence
1638 : 49c3 eor #$c3
163a : d513 cmp zp1,x ;test result
trap_ne
163c : d0fe > bne * ;failed not equal (non zero)
163e : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
163f : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1641 : dd0d02 cmp fLDx,x ;test flags
trap_ne
1644 : d0fe > bne * ;failed not equal (non zero)
1646 : ca dex
1647 : 10e1 bpl tldax3
1649 : a203 ldx #3 ;testing store result
164b : a000 ldy #0
164d : b50c tstax lda zpt,x
164f : 49c3 eor #$c3
1651 : d513 cmp zp1,x
trap_ne ;store to zp,x data
1653 : d0fe > bne * ;failed not equal (non zero)
1655 : 940c sty zpt,x ;clear
1657 : bd0302 lda abst,x
165a : 49c3 eor #$c3
165c : dd0802 cmp abs1,x
trap_ne ;store to abs,x data
165f : d0fe > bne * ;failed not equal (non zero)
1661 : 8a txa
1662 : 9d0302 sta abst,x ;clear
1665 : ca dex
1666 : 10e5 bpl tstax
next_test
1668 : ad0002 > lda test_case ;previous test
166b : c915 > cmp #test_num
> trap_ne ;test is out of sequence
166d : d0fe > bne * ;failed not equal (non zero)
>
0016 = >test_num = test_num + 1
166f : a916 > lda #test_num ;*** next tests' number
1671 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; LDA / STA - (zp),y / abs,y / (zp,x)
1674 : a003 ldy #3
1676 : tlday
set_stat 0
> load_flag 0
1676 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1678 : 48 > pha ;use stack to load status
1679 : 28 > plp
167a : b124 lda (ind1),y
167c : 08 php ;test stores do not alter flags
167d : 49c3 eor #$c3
167f : 28 plp
1680 : 990302 sta abst,y
1683 : 08 php ;flags after load/store sequence
1684 : 49c3 eor #$c3
1686 : d90802 cmp abs1,y ;test result
trap_ne
1689 : d0fe > bne * ;failed not equal (non zero)
168b : 68 pla ;load status
eor_flag 0
168c : 4930 > eor #0|fao ;invert expected flags + always on bits
168e : d90d02 cmp fLDx,y ;test flags
trap_ne
1691 : d0fe > bne * ;failed not equal (non zero)
1693 : 88 dey
1694 : 10e0 bpl tlday
1696 : a003 ldy #3
1698 : tlday1
set_stat $ff
> load_flag $ff
1698 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
169a : 48 > pha ;use stack to load status
169b : 28 > plp
169c : b124 lda (ind1),y
169e : 08 php ;test stores do not alter flags
169f : 49c3 eor #$c3
16a1 : 28 plp
16a2 : 990302 sta abst,y
16a5 : 08 php ;flags after load/store sequence
16a6 : 49c3 eor #$c3
16a8 : d90802 cmp abs1,y ;test result
trap_ne
16ab : d0fe > bne * ;failed not equal (non zero)
16ad : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
16ae : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
16b0 : d90d02 cmp fLDx,y ;test flags
trap_ne
16b3 : d0fe > bne * ;failed not equal (non zero)
16b5 : 88 dey
16b6 : 10e0 bpl tlday1
16b8 : a003 ldy #3 ;testing store result
16ba : a200 ldx #0
16bc : b90302 tstay lda abst,y
16bf : 49c3 eor #$c3
16c1 : d90802 cmp abs1,y
trap_ne ;store to abs data
16c4 : d0fe > bne * ;failed not equal (non zero)
16c6 : 8a txa
16c7 : 990302 sta abst,y ;clear
16ca : 88 dey
16cb : 10ef bpl tstay
16cd : a003 ldy #3
16cf : tlday2
set_stat 0
> load_flag 0
16cf : a900 > lda #0 ;allow test to change I-flag (no mask)
>
16d1 : 48 > pha ;use stack to load status
16d2 : 28 > plp
16d3 : b90802 lda abs1,y
16d6 : 08 php ;test stores do not alter flags
16d7 : 49c3 eor #$c3
16d9 : 28 plp
16da : 9130 sta (indt),y
16dc : 08 php ;flags after load/store sequence
16dd : 49c3 eor #$c3
16df : d124 cmp (ind1),y ;test result
trap_ne
16e1 : d0fe > bne * ;failed not equal (non zero)
16e3 : 68 pla ;load status
eor_flag 0
16e4 : 4930 > eor #0|fao ;invert expected flags + always on bits
16e6 : d90d02 cmp fLDx,y ;test flags
trap_ne
16e9 : d0fe > bne * ;failed not equal (non zero)
16eb : 88 dey
16ec : 10e1 bpl tlday2
16ee : a003 ldy #3
16f0 : tlday3
set_stat $ff
> load_flag $ff
16f0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
16f2 : 48 > pha ;use stack to load status
16f3 : 28 > plp
16f4 : b90802 lda abs1,y
16f7 : 08 php ;test stores do not alter flags
16f8 : 49c3 eor #$c3
16fa : 28 plp
16fb : 9130 sta (indt),y
16fd : 08 php ;flags after load/store sequence
16fe : 49c3 eor #$c3
1700 : d124 cmp (ind1),y ;test result
trap_ne
1702 : d0fe > bne * ;failed not equal (non zero)
1704 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1705 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1707 : d90d02 cmp fLDx,y ;test flags
trap_ne
170a : d0fe > bne * ;failed not equal (non zero)
170c : 88 dey
170d : 10e1 bpl tlday3
170f : a003 ldy #3 ;testing store result
1711 : a200 ldx #0
1713 : b90302 tstay1 lda abst,y
1716 : 49c3 eor #$c3
1718 : d90802 cmp abs1,y
trap_ne ;store to abs data
171b : d0fe > bne * ;failed not equal (non zero)
171d : 8a txa
171e : 990302 sta abst,y ;clear
1721 : 88 dey
1722 : 10ef bpl tstay1
1724 : a206 ldx #6
1726 : a003 ldy #3
1728 : tldax4
set_stat 0
> load_flag 0
1728 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
172a : 48 > pha ;use stack to load status
172b : 28 > plp
172c : a124 lda (ind1,x)
172e : 08 php ;test stores do not alter flags
172f : 49c3 eor #$c3
1731 : 28 plp
1732 : 8130 sta (indt,x)
1734 : 08 php ;flags after load/store sequence
1735 : 49c3 eor #$c3
1737 : d90802 cmp abs1,y ;test result
trap_ne
173a : d0fe > bne * ;failed not equal (non zero)
173c : 68 pla ;load status
eor_flag 0
173d : 4930 > eor #0|fao ;invert expected flags + always on bits
173f : d90d02 cmp fLDx,y ;test flags
trap_ne
1742 : d0fe > bne * ;failed not equal (non zero)
1744 : ca dex
1745 : ca dex
1746 : 88 dey
1747 : 10df bpl tldax4
1749 : a206 ldx #6
174b : a003 ldy #3
174d : tldax5
set_stat $ff
> load_flag $ff
174d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
174f : 48 > pha ;use stack to load status
1750 : 28 > plp
1751 : a124 lda (ind1,x)
1753 : 08 php ;test stores do not alter flags
1754 : 49c3 eor #$c3
1756 : 28 plp
1757 : 8130 sta (indt,x)
1759 : 08 php ;flags after load/store sequence
175a : 49c3 eor #$c3
175c : d90802 cmp abs1,y ;test result
trap_ne
175f : d0fe > bne * ;failed not equal (non zero)
1761 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1762 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1764 : d90d02 cmp fLDx,y ;test flags
trap_ne
1767 : d0fe > bne * ;failed not equal (non zero)
1769 : ca dex
176a : ca dex
176b : 88 dey
176c : 10df bpl tldax5
176e : a003 ldy #3 ;testing store result
1770 : a200 ldx #0
1772 : b90302 tstay2 lda abst,y
1775 : 49c3 eor #$c3
1777 : d90802 cmp abs1,y
trap_ne ;store to abs data
177a : d0fe > bne * ;failed not equal (non zero)
177c : 8a txa
177d : 990302 sta abst,y ;clear
1780 : 88 dey
1781 : 10ef bpl tstay2
next_test
1783 : ad0002 > lda test_case ;previous test
1786 : c916 > cmp #test_num
> trap_ne ;test is out of sequence
1788 : d0fe > bne * ;failed not equal (non zero)
>
0017 = >test_num = test_num + 1
178a : a917 > lda #test_num ;*** next tests' number
178c : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; indexed wraparound test (only zp should wrap)
178f : a2fd ldx #3+$fa
1791 : b519 tldax6 lda zp1-$fa&$ff,x ;wrap on indexed zp
1793 : 9d0901 sta abst-$fa,x ;no STX abs,x!
1796 : ca dex
1797 : e0fa cpx #$fa
1799 : b0f6 bcs tldax6
179b : a2fd ldx #3+$fa
179d : bd0e01 tldax7 lda abs1-$fa,x ;no wrap on indexed abs
17a0 : 9512 sta zpt-$fa&$ff,x
17a2 : ca dex
17a3 : e0fa cpx #$fa
17a5 : b0f6 bcs tldax7
17a7 : a203 ldx #3 ;testing wraparound result
17a9 : a000 ldy #0
17ab : b50c tstax1 lda zpt,x
17ad : d513 cmp zp1,x
trap_ne ;store to zp,x data
17af : d0fe > bne * ;failed not equal (non zero)
17b1 : 940c sty zpt,x ;clear
17b3 : bd0302 lda abst,x
17b6 : dd0802 cmp abs1,x
trap_ne ;store to abs,x data
17b9 : d0fe > bne * ;failed not equal (non zero)
17bb : 8a txa
17bc : 9d0302 sta abst,x ;clear
17bf : ca dex
17c0 : 10e9 bpl tstax1
17c2 : a0fb ldy #3+$f8
17c4 : a2fe ldx #6+$f8
17c6 : a12c tlday4 lda (ind1-$f8&$ff,x) ;wrap on indexed zp indirect
17c8 : 990b01 sta abst-$f8,y
17cb : ca dex
17cc : ca dex
17cd : 88 dey
17ce : c0f8 cpy #$f8
17d0 : b0f4 bcs tlday4
17d2 : a003 ldy #3 ;testing wraparound result
17d4 : a200 ldx #0
17d6 : b90302 tstay4 lda abst,y
17d9 : d90802 cmp abs1,y
trap_ne ;store to abs data
17dc : d0fe > bne * ;failed not equal (non zero)
17de : 8a txa
17df : 990302 sta abst,y ;clear
17e2 : 88 dey
17e3 : 10f1 bpl tstay4
17e5 : a0fb ldy #3+$f8
17e7 : b91001 tlday5 lda abs1-$f8,y ;no wrap on indexed abs
17ea : 9138 sta (inwt),y
17ec : 88 dey
17ed : c0f8 cpy #$f8
17ef : b0f6 bcs tlday5
17f1 : a003 ldy #3 ;testing wraparound result
17f3 : a200 ldx #0
17f5 : b90302 tstay5 lda abst,y
17f8 : d90802 cmp abs1,y
trap_ne ;store to abs data
17fb : d0fe > bne * ;failed not equal (non zero)
17fd : 8a txa
17fe : 990302 sta abst,y ;clear
1801 : 88 dey
1802 : 10f1 bpl tstay5
1804 : a0fb ldy #3+$f8
1806 : a2fe ldx #6+$f8
1808 : b12e tlday6 lda (inw1),y ;no wrap on zp indirect indexed
180a : 8138 sta (indt-$f8&$ff,x)
180c : ca dex
180d : ca dex
180e : 88 dey
180f : c0f8 cpy #$f8
1811 : b0f5 bcs tlday6
1813 : a003 ldy #3 ;testing wraparound result
1815 : a200 ldx #0
1817 : b90302 tstay6 lda abst,y
181a : d90802 cmp abs1,y
trap_ne ;store to abs data
181d : d0fe > bne * ;failed not equal (non zero)
181f : 8a txa
1820 : 990302 sta abst,y ;clear
1823 : 88 dey
1824 : 10f1 bpl tstay6
next_test
1826 : ad0002 > lda test_case ;previous test
1829 : c917 > cmp #test_num
> trap_ne ;test is out of sequence
182b : d0fe > bne * ;failed not equal (non zero)
>
0018 = >test_num = test_num + 1
182d : a918 > lda #test_num ;*** next tests' number
182f : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; LDA / STA - zp / abs / #
set_stat 0
> load_flag 0
1832 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1834 : 48 > pha ;use stack to load status
1835 : 28 > plp
1836 : a513 lda zp1
1838 : 08 php ;test stores do not alter flags
1839 : 49c3 eor #$c3
183b : 28 plp
183c : 8d0302 sta abst
183f : 08 php ;flags after load/store sequence
1840 : 49c3 eor #$c3
1842 : c9c3 cmp #$c3 ;test result
trap_ne
1844 : d0fe > bne * ;failed not equal (non zero)
1846 : 68 pla ;load status
eor_flag 0
1847 : 4930 > eor #0|fao ;invert expected flags + always on bits
1849 : cd0d02 cmp fLDx ;test flags
trap_ne
184c : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
184e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1850 : 48 > pha ;use stack to load status
1851 : 28 > plp
1852 : a514 lda zp1+1
1854 : 08 php ;test stores do not alter flags
1855 : 49c3 eor #$c3
1857 : 28 plp
1858 : 8d0402 sta abst+1
185b : 08 php ;flags after load/store sequence
185c : 49c3 eor #$c3
185e : c982 cmp #$82 ;test result
trap_ne
1860 : d0fe > bne * ;failed not equal (non zero)
1862 : 68 pla ;load status
eor_flag 0
1863 : 4930 > eor #0|fao ;invert expected flags + always on bits
1865 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
1868 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
186a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
186c : 48 > pha ;use stack to load status
186d : 28 > plp
186e : a515 lda zp1+2
1870 : 08 php ;test stores do not alter flags
1871 : 49c3 eor #$c3
1873 : 28 plp
1874 : 8d0502 sta abst+2
1877 : 08 php ;flags after load/store sequence
1878 : 49c3 eor #$c3
187a : c941 cmp #$41 ;test result
trap_ne
187c : d0fe > bne * ;failed not equal (non zero)
187e : 68 pla ;load status
eor_flag 0
187f : 4930 > eor #0|fao ;invert expected flags + always on bits
1881 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
1884 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1886 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1888 : 48 > pha ;use stack to load status
1889 : 28 > plp
188a : a516 lda zp1+3
188c : 08 php ;test stores do not alter flags
188d : 49c3 eor #$c3
188f : 28 plp
1890 : 8d0602 sta abst+3
1893 : 08 php ;flags after load/store sequence
1894 : 49c3 eor #$c3
1896 : c900 cmp #0 ;test result
trap_ne
1898 : d0fe > bne * ;failed not equal (non zero)
189a : 68 pla ;load status
eor_flag 0
189b : 4930 > eor #0|fao ;invert expected flags + always on bits
189d : cd1002 cmp fLDx+3 ;test flags
trap_ne
18a0 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18a2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18a4 : 48 > pha ;use stack to load status
18a5 : 28 > plp
18a6 : a513 lda zp1
18a8 : 08 php ;test stores do not alter flags
18a9 : 49c3 eor #$c3
18ab : 28 plp
18ac : 8d0302 sta abst
18af : 08 php ;flags after load/store sequence
18b0 : 49c3 eor #$c3
18b2 : c9c3 cmp #$c3 ;test result
trap_ne
18b4 : d0fe > bne * ;failed not equal (non zero)
18b6 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
18b7 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
18b9 : cd0d02 cmp fLDx ;test flags
trap_ne
18bc : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18be : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18c0 : 48 > pha ;use stack to load status
18c1 : 28 > plp
18c2 : a514 lda zp1+1
18c4 : 08 php ;test stores do not alter flags
18c5 : 49c3 eor #$c3
18c7 : 28 plp
18c8 : 8d0402 sta abst+1
18cb : 08 php ;flags after load/store sequence
18cc : 49c3 eor #$c3
18ce : c982 cmp #$82 ;test result
trap_ne
18d0 : d0fe > bne * ;failed not equal (non zero)
18d2 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
18d3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
18d5 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
18d8 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18da : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18dc : 48 > pha ;use stack to load status
18dd : 28 > plp
18de : a515 lda zp1+2
18e0 : 08 php ;test stores do not alter flags
18e1 : 49c3 eor #$c3
18e3 : 28 plp
18e4 : 8d0502 sta abst+2
18e7 : 08 php ;flags after load/store sequence
18e8 : 49c3 eor #$c3
18ea : c941 cmp #$41 ;test result
trap_ne
18ec : d0fe > bne * ;failed not equal (non zero)
18ee : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
18ef : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
18f1 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
18f4 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
18f6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
18f8 : 48 > pha ;use stack to load status
18f9 : 28 > plp
18fa : a516 lda zp1+3
18fc : 08 php ;test stores do not alter flags
18fd : 49c3 eor #$c3
18ff : 28 plp
1900 : 8d0602 sta abst+3
1903 : 08 php ;flags after load/store sequence
1904 : 49c3 eor #$c3
1906 : c900 cmp #0 ;test result
trap_ne
1908 : d0fe > bne * ;failed not equal (non zero)
190a : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
190b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
190d : cd1002 cmp fLDx+3 ;test flags
trap_ne
1910 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1912 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1914 : 48 > pha ;use stack to load status
1915 : 28 > plp
1916 : ad0802 lda abs1
1919 : 08 php ;test stores do not alter flags
191a : 49c3 eor #$c3
191c : 28 plp
191d : 850c sta zpt
191f : 08 php ;flags after load/store sequence
1920 : 49c3 eor #$c3
1922 : c513 cmp zp1 ;test result
trap_ne
1924 : d0fe > bne * ;failed not equal (non zero)
1926 : 68 pla ;load status
eor_flag 0
1927 : 4930 > eor #0|fao ;invert expected flags + always on bits
1929 : cd0d02 cmp fLDx ;test flags
trap_ne
192c : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
192e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1930 : 48 > pha ;use stack to load status
1931 : 28 > plp
1932 : ad0902 lda abs1+1
1935 : 08 php ;test stores do not alter flags
1936 : 49c3 eor #$c3
1938 : 28 plp
1939 : 850d sta zpt+1
193b : 08 php ;flags after load/store sequence
193c : 49c3 eor #$c3
193e : c514 cmp zp1+1 ;test result
trap_ne
1940 : d0fe > bne * ;failed not equal (non zero)
1942 : 68 pla ;load status
eor_flag 0
1943 : 4930 > eor #0|fao ;invert expected flags + always on bits
1945 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
1948 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
194a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
194c : 48 > pha ;use stack to load status
194d : 28 > plp
194e : ad0a02 lda abs1+2
1951 : 08 php ;test stores do not alter flags
1952 : 49c3 eor #$c3
1954 : 28 plp
1955 : 850e sta zpt+2
1957 : 08 php ;flags after load/store sequence
1958 : 49c3 eor #$c3
195a : c515 cmp zp1+2 ;test result
trap_ne
195c : d0fe > bne * ;failed not equal (non zero)
195e : 68 pla ;load status
eor_flag 0
195f : 4930 > eor #0|fao ;invert expected flags + always on bits
1961 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
1964 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1966 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1968 : 48 > pha ;use stack to load status
1969 : 28 > plp
196a : ad0b02 lda abs1+3
196d : 08 php ;test stores do not alter flags
196e : 49c3 eor #$c3
1970 : 28 plp
1971 : 850f sta zpt+3
1973 : 08 php ;flags after load/store sequence
1974 : 49c3 eor #$c3
1976 : c516 cmp zp1+3 ;test result
trap_ne
1978 : d0fe > bne * ;failed not equal (non zero)
197a : 68 pla ;load status
eor_flag 0
197b : 4930 > eor #0|fao ;invert expected flags + always on bits
197d : cd1002 cmp fLDx+3 ;test flags
trap_ne
1980 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1982 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1984 : 48 > pha ;use stack to load status
1985 : 28 > plp
1986 : ad0802 lda abs1
1989 : 08 php ;test stores do not alter flags
198a : 49c3 eor #$c3
198c : 28 plp
198d : 850c sta zpt
198f : 08 php ;flags after load/store sequence
1990 : 49c3 eor #$c3
1992 : c513 cmp zp1 ;test result
trap_ne
1994 : d0fe > bne * ;failed not equal (non zero)
1996 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1997 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1999 : cd0d02 cmp fLDx ;test flags
trap_ne
199c : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
199e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
19a0 : 48 > pha ;use stack to load status
19a1 : 28 > plp
19a2 : ad0902 lda abs1+1
19a5 : 08 php ;test stores do not alter flags
19a6 : 49c3 eor #$c3
19a8 : 28 plp
19a9 : 850d sta zpt+1
19ab : 08 php ;flags after load/store sequence
19ac : 49c3 eor #$c3
19ae : c514 cmp zp1+1 ;test result
trap_ne
19b0 : d0fe > bne * ;failed not equal (non zero)
19b2 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
19b3 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
19b5 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
19b8 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
19ba : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
19bc : 48 > pha ;use stack to load status
19bd : 28 > plp
19be : ad0a02 lda abs1+2
19c1 : 08 php ;test stores do not alter flags
19c2 : 49c3 eor #$c3
19c4 : 28 plp
19c5 : 850e sta zpt+2
19c7 : 08 php ;flags after load/store sequence
19c8 : 49c3 eor #$c3
19ca : c515 cmp zp1+2 ;test result
trap_ne
19cc : d0fe > bne * ;failed not equal (non zero)
19ce : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
19cf : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
19d1 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
19d4 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
19d6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
19d8 : 48 > pha ;use stack to load status
19d9 : 28 > plp
19da : ad0b02 lda abs1+3
19dd : 08 php ;test stores do not alter flags
19de : 49c3 eor #$c3
19e0 : 28 plp
19e1 : 850f sta zpt+3
19e3 : 08 php ;flags after load/store sequence
19e4 : 49c3 eor #$c3
19e6 : c516 cmp zp1+3 ;test result
trap_ne
19e8 : d0fe > bne * ;failed not equal (non zero)
19ea : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
19eb : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
19ed : cd1002 cmp fLDx+3 ;test flags
trap_ne
19f0 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
19f2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
19f4 : 48 > pha ;use stack to load status
19f5 : 28 > plp
19f6 : a9c3 lda #$c3
19f8 : 08 php
19f9 : cd0802 cmp abs1 ;test result
trap_ne
19fc : d0fe > bne * ;failed not equal (non zero)
19fe : 68 pla ;load status
eor_flag 0
19ff : 4930 > eor #0|fao ;invert expected flags + always on bits
1a01 : cd0d02 cmp fLDx ;test flags
trap_ne
1a04 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1a06 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1a08 : 48 > pha ;use stack to load status
1a09 : 28 > plp
1a0a : a982 lda #$82
1a0c : 08 php
1a0d : cd0902 cmp abs1+1 ;test result
trap_ne
1a10 : d0fe > bne * ;failed not equal (non zero)
1a12 : 68 pla ;load status
eor_flag 0
1a13 : 4930 > eor #0|fao ;invert expected flags + always on bits
1a15 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
1a18 : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1a1a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1a1c : 48 > pha ;use stack to load status
1a1d : 28 > plp
1a1e : a941 lda #$41
1a20 : 08 php
1a21 : cd0a02 cmp abs1+2 ;test result
trap_ne
1a24 : d0fe > bne * ;failed not equal (non zero)
1a26 : 68 pla ;load status
eor_flag 0
1a27 : 4930 > eor #0|fao ;invert expected flags + always on bits
1a29 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
1a2c : d0fe > bne * ;failed not equal (non zero)
set_stat 0
> load_flag 0
1a2e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1a30 : 48 > pha ;use stack to load status
1a31 : 28 > plp
1a32 : a900 lda #0
1a34 : 08 php
1a35 : cd0b02 cmp abs1+3 ;test result
trap_ne
1a38 : d0fe > bne * ;failed not equal (non zero)
1a3a : 68 pla ;load status
eor_flag 0
1a3b : 4930 > eor #0|fao ;invert expected flags + always on bits
1a3d : cd1002 cmp fLDx+3 ;test flags
trap_ne
1a40 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1a42 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1a44 : 48 > pha ;use stack to load status
1a45 : 28 > plp
1a46 : a9c3 lda #$c3
1a48 : 08 php
1a49 : cd0802 cmp abs1 ;test result
trap_ne
1a4c : d0fe > bne * ;failed not equal (non zero)
1a4e : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1a4f : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1a51 : cd0d02 cmp fLDx ;test flags
trap_ne
1a54 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1a56 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1a58 : 48 > pha ;use stack to load status
1a59 : 28 > plp
1a5a : a982 lda #$82
1a5c : 08 php
1a5d : cd0902 cmp abs1+1 ;test result
trap_ne
1a60 : d0fe > bne * ;failed not equal (non zero)
1a62 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1a63 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1a65 : cd0e02 cmp fLDx+1 ;test flags
trap_ne
1a68 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1a6a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1a6c : 48 > pha ;use stack to load status
1a6d : 28 > plp
1a6e : a941 lda #$41
1a70 : 08 php
1a71 : cd0a02 cmp abs1+2 ;test result
trap_ne
1a74 : d0fe > bne * ;failed not equal (non zero)
1a76 : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1a77 : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1a79 : cd0f02 cmp fLDx+2 ;test flags
trap_ne
1a7c : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
1a7e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1a80 : 48 > pha ;use stack to load status
1a81 : 28 > plp
1a82 : a900 lda #0
1a84 : 08 php
1a85 : cd0b02 cmp abs1+3 ;test result
trap_ne
1a88 : d0fe > bne * ;failed not equal (non zero)
1a8a : 68 pla ;load status
eor_flag lo~fnz ;mask bits not altered
1a8b : 497d > eor #lo~fnz |fao ;invert expected flags + always on bits
1a8d : cd1002 cmp fLDx+3 ;test flags
trap_ne
1a90 : d0fe > bne * ;failed not equal (non zero)
1a92 : a200 ldx #0
1a94 : a50c lda zpt
1a96 : 49c3 eor #$c3
1a98 : c513 cmp zp1
trap_ne ;store to zp data
1a9a : d0fe > bne * ;failed not equal (non zero)
1a9c : 860c stx zpt ;clear
1a9e : ad0302 lda abst
1aa1 : 49c3 eor #$c3
1aa3 : cd0802 cmp abs1
trap_ne ;store to abs data
1aa6 : d0fe > bne * ;failed not equal (non zero)
1aa8 : 8e0302 stx abst ;clear
1aab : a50d lda zpt+1
1aad : 49c3 eor #$c3
1aaf : c514 cmp zp1+1
trap_ne ;store to zp data
1ab1 : d0fe > bne * ;failed not equal (non zero)
1ab3 : 860d stx zpt+1 ;clear
1ab5 : ad0402 lda abst+1
1ab8 : 49c3 eor #$c3
1aba : cd0902 cmp abs1+1
trap_ne ;store to abs data
1abd : d0fe > bne * ;failed not equal (non zero)
1abf : 8e0402 stx abst+1 ;clear
1ac2 : a50e lda zpt+2
1ac4 : 49c3 eor #$c3
1ac6 : c515 cmp zp1+2
trap_ne ;store to zp data
1ac8 : d0fe > bne * ;failed not equal (non zero)
1aca : 860e stx zpt+2 ;clear
1acc : ad0502 lda abst+2
1acf : 49c3 eor #$c3
1ad1 : cd0a02 cmp abs1+2
trap_ne ;store to abs data
1ad4 : d0fe > bne * ;failed not equal (non zero)
1ad6 : 8e0502 stx abst+2 ;clear
1ad9 : a50f lda zpt+3
1adb : 49c3 eor #$c3
1add : c516 cmp zp1+3
trap_ne ;store to zp data
1adf : d0fe > bne * ;failed not equal (non zero)
1ae1 : 860f stx zpt+3 ;clear
1ae3 : ad0602 lda abst+3
1ae6 : 49c3 eor #$c3
1ae8 : cd0b02 cmp abs1+3
trap_ne ;store to abs data
1aeb : d0fe > bne * ;failed not equal (non zero)
1aed : 8e0602 stx abst+3 ;clear
next_test
1af0 : ad0002 > lda test_case ;previous test
1af3 : c918 > cmp #test_num
> trap_ne ;test is out of sequence
1af5 : d0fe > bne * ;failed not equal (non zero)
>
0019 = >test_num = test_num + 1
1af7 : a919 > lda #test_num ;*** next tests' number
1af9 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing bit test & compares BIT CPX CPY CMP all addressing modes
; BIT - zp / abs
set_a $ff,0
> load_flag 0
1afc : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1afe : 48 > pha ;use stack to load status
1aff : a9ff > lda #$ff ;precharge accu
1b01 : 28 > plp
1b02 : 2416 bit zp1+3 ;00 - should set Z / clear NV
tst_a $ff,fz
1b04 : 08 > php ;save flags
1b05 : c9ff > cmp #$ff ;test result
> trap_ne
1b07 : d0fe > bne * ;failed not equal (non zero)
>
1b09 : 68 > pla ;load status
1b0a : 48 > pha
> cmp_flag fz
1b0b : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b0d : d0fe > bne * ;failed not equal (non zero)
>
1b0f : 28 > plp ;restore status
set_a 1,0
> load_flag 0
1b10 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b12 : 48 > pha ;use stack to load status
1b13 : a901 > lda #1 ;precharge accu
1b15 : 28 > plp
1b16 : 2415 bit zp1+2 ;41 - should set V (M6) / clear NZ
tst_a 1,fv
1b18 : 08 > php ;save flags
1b19 : c901 > cmp #1 ;test result
> trap_ne
1b1b : d0fe > bne * ;failed not equal (non zero)
>
1b1d : 68 > pla ;load status
1b1e : 48 > pha
> cmp_flag fv
1b1f : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b21 : d0fe > bne * ;failed not equal (non zero)
>
1b23 : 28 > plp ;restore status
set_a 1,0
> load_flag 0
1b24 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b26 : 48 > pha ;use stack to load status
1b27 : a901 > lda #1 ;precharge accu
1b29 : 28 > plp
1b2a : 2414 bit zp1+1 ;82 - should set N (M7) & Z / clear V
tst_a 1,fnz
1b2c : 08 > php ;save flags
1b2d : c901 > cmp #1 ;test result
> trap_ne
1b2f : d0fe > bne * ;failed not equal (non zero)
>
1b31 : 68 > pla ;load status
1b32 : 48 > pha
> cmp_flag fnz
1b33 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b35 : d0fe > bne * ;failed not equal (non zero)
>
1b37 : 28 > plp ;restore status
set_a 1,0
> load_flag 0
1b38 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b3a : 48 > pha ;use stack to load status
1b3b : a901 > lda #1 ;precharge accu
1b3d : 28 > plp
1b3e : 2413 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,fnv
1b40 : 08 > php ;save flags
1b41 : c901 > cmp #1 ;test result
> trap_ne
1b43 : d0fe > bne * ;failed not equal (non zero)
>
1b45 : 68 > pla ;load status
1b46 : 48 > pha
> cmp_flag fnv
1b47 : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b49 : d0fe > bne * ;failed not equal (non zero)
>
1b4b : 28 > plp ;restore status
set_a $ff,$ff
> load_flag $ff
1b4c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b4e : 48 > pha ;use stack to load status
1b4f : a9ff > lda #$ff ;precharge accu
1b51 : 28 > plp
1b52 : 2416 bit zp1+3 ;00 - should set Z / clear NV
tst_a $ff,~fnv
1b54 : 08 > php ;save flags
1b55 : c9ff > cmp #$ff ;test result
> trap_ne
1b57 : d0fe > bne * ;failed not equal (non zero)
>
1b59 : 68 > pla ;load status
1b5a : 48 > pha
> cmp_flag ~fnv
1b5b : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b5d : d0fe > bne * ;failed not equal (non zero)
>
1b5f : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1b60 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b62 : 48 > pha ;use stack to load status
1b63 : a901 > lda #1 ;precharge accu
1b65 : 28 > plp
1b66 : 2415 bit zp1+2 ;41 - should set V (M6) / clear NZ
tst_a 1,~fnz
1b68 : 08 > php ;save flags
1b69 : c901 > cmp #1 ;test result
> trap_ne
1b6b : d0fe > bne * ;failed not equal (non zero)
>
1b6d : 68 > pla ;load status
1b6e : 48 > pha
> cmp_flag ~fnz
1b6f : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b71 : d0fe > bne * ;failed not equal (non zero)
>
1b73 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1b74 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b76 : 48 > pha ;use stack to load status
1b77 : a901 > lda #1 ;precharge accu
1b79 : 28 > plp
1b7a : 2414 bit zp1+1 ;82 - should set N (M7) & Z / clear V
tst_a 1,~fv
1b7c : 08 > php ;save flags
1b7d : c901 > cmp #1 ;test result
> trap_ne
1b7f : d0fe > bne * ;failed not equal (non zero)
>
1b81 : 68 > pla ;load status
1b82 : 48 > pha
> cmp_flag ~fv
1b83 : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b85 : d0fe > bne * ;failed not equal (non zero)
>
1b87 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1b88 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1b8a : 48 > pha ;use stack to load status
1b8b : a901 > lda #1 ;precharge accu
1b8d : 28 > plp
1b8e : 2413 bit zp1 ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,~fz
1b90 : 08 > php ;save flags
1b91 : c901 > cmp #1 ;test result
> trap_ne
1b93 : d0fe > bne * ;failed not equal (non zero)
>
1b95 : 68 > pla ;load status
1b96 : 48 > pha
> cmp_flag ~fz
1b97 : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1b99 : d0fe > bne * ;failed not equal (non zero)
>
1b9b : 28 > plp ;restore status
set_a $ff,0
> load_flag 0
1b9c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1b9e : 48 > pha ;use stack to load status
1b9f : a9ff > lda #$ff ;precharge accu
1ba1 : 28 > plp
1ba2 : 2c0b02 bit abs1+3 ;00 - should set Z / clear NV
tst_a $ff,fz
1ba5 : 08 > php ;save flags
1ba6 : c9ff > cmp #$ff ;test result
> trap_ne
1ba8 : d0fe > bne * ;failed not equal (non zero)
>
1baa : 68 > pla ;load status
1bab : 48 > pha
> cmp_flag fz
1bac : c932 > cmp #(fz |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1bae : d0fe > bne * ;failed not equal (non zero)
>
1bb0 : 28 > plp ;restore status
set_a 1,0
> load_flag 0
1bb1 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1bb3 : 48 > pha ;use stack to load status
1bb4 : a901 > lda #1 ;precharge accu
1bb6 : 28 > plp
1bb7 : 2c0a02 bit abs1+2 ;41 - should set V (M6) / clear NZ
tst_a 1,fv
1bba : 08 > php ;save flags
1bbb : c901 > cmp #1 ;test result
> trap_ne
1bbd : d0fe > bne * ;failed not equal (non zero)
>
1bbf : 68 > pla ;load status
1bc0 : 48 > pha
> cmp_flag fv
1bc1 : c970 > cmp #(fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1bc3 : d0fe > bne * ;failed not equal (non zero)
>
1bc5 : 28 > plp ;restore status
set_a 1,0
> load_flag 0
1bc6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1bc8 : 48 > pha ;use stack to load status
1bc9 : a901 > lda #1 ;precharge accu
1bcb : 28 > plp
1bcc : 2c0902 bit abs1+1 ;82 - should set N (M7) & Z / clear V
tst_a 1,fnz
1bcf : 08 > php ;save flags
1bd0 : c901 > cmp #1 ;test result
> trap_ne
1bd2 : d0fe > bne * ;failed not equal (non zero)
>
1bd4 : 68 > pla ;load status
1bd5 : 48 > pha
> cmp_flag fnz
1bd6 : c9b2 > cmp #(fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1bd8 : d0fe > bne * ;failed not equal (non zero)
>
1bda : 28 > plp ;restore status
set_a 1,0
> load_flag 0
1bdb : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1bdd : 48 > pha ;use stack to load status
1bde : a901 > lda #1 ;precharge accu
1be0 : 28 > plp
1be1 : 2c0802 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,fnv
1be4 : 08 > php ;save flags
1be5 : c901 > cmp #1 ;test result
> trap_ne
1be7 : d0fe > bne * ;failed not equal (non zero)
>
1be9 : 68 > pla ;load status
1bea : 48 > pha
> cmp_flag fnv
1beb : c9f0 > cmp #(fnv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1bed : d0fe > bne * ;failed not equal (non zero)
>
1bef : 28 > plp ;restore status
set_a $ff,$ff
> load_flag $ff
1bf0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1bf2 : 48 > pha ;use stack to load status
1bf3 : a9ff > lda #$ff ;precharge accu
1bf5 : 28 > plp
1bf6 : 2c0b02 bit abs1+3 ;00 - should set Z / clear NV
tst_a $ff,~fnv
1bf9 : 08 > php ;save flags
1bfa : c9ff > cmp #$ff ;test result
> trap_ne
1bfc : d0fe > bne * ;failed not equal (non zero)
>
1bfe : 68 > pla ;load status
1bff : 48 > pha
> cmp_flag ~fnv
1c00 : c93f > cmp #(~fnv |fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c02 : d0fe > bne * ;failed not equal (non zero)
>
1c04 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1c05 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c07 : 48 > pha ;use stack to load status
1c08 : a901 > lda #1 ;precharge accu
1c0a : 28 > plp
1c0b : 2c0a02 bit abs1+2 ;41 - should set V (M6) / clear NZ
tst_a 1,~fnz
1c0e : 08 > php ;save flags
1c0f : c901 > cmp #1 ;test result
> trap_ne
1c11 : d0fe > bne * ;failed not equal (non zero)
>
1c13 : 68 > pla ;load status
1c14 : 48 > pha
> cmp_flag ~fnz
1c15 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c17 : d0fe > bne * ;failed not equal (non zero)
>
1c19 : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1c1a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c1c : 48 > pha ;use stack to load status
1c1d : a901 > lda #1 ;precharge accu
1c1f : 28 > plp
1c20 : 2c0902 bit abs1+1 ;82 - should set N (M7) & Z / clear V
tst_a 1,~fv
1c23 : 08 > php ;save flags
1c24 : c901 > cmp #1 ;test result
> trap_ne
1c26 : d0fe > bne * ;failed not equal (non zero)
>
1c28 : 68 > pla ;load status
1c29 : 48 > pha
> cmp_flag ~fv
1c2a : c9bf > cmp #(~fv|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c2c : d0fe > bne * ;failed not equal (non zero)
>
1c2e : 28 > plp ;restore status
set_a 1,$ff
> load_flag $ff
1c2f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1c31 : 48 > pha ;use stack to load status
1c32 : a901 > lda #1 ;precharge accu
1c34 : 28 > plp
1c35 : 2c0802 bit abs1 ;c3 - should set N (M7) & V (M6) / clear Z
tst_a 1,~fz
1c38 : 08 > php ;save flags
1c39 : c901 > cmp #1 ;test result
> trap_ne
1c3b : d0fe > bne * ;failed not equal (non zero)
>
1c3d : 68 > pla ;load status
1c3e : 48 > pha
> cmp_flag ~fz
1c3f : c9fd > cmp #(~fz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c41 : d0fe > bne * ;failed not equal (non zero)
>
1c43 : 28 > plp ;restore status
next_test
1c44 : ad0002 > lda test_case ;previous test
1c47 : c919 > cmp #test_num
> trap_ne ;test is out of sequence
1c49 : d0fe > bne * ;failed not equal (non zero)
>
001a = >test_num = test_num + 1
1c4b : a91a > lda #test_num ;*** next tests' number
1c4d : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; CPX - zp / abs / #
set_x $80,0
> load_flag 0
1c50 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1c52 : 48 > pha ;use stack to load status
1c53 : a280 > ldx #$80 ;precharge index x
1c55 : 28 > plp
1c56 : e417 cpx zp7f
tst_stat fc
1c58 : 08 > php ;save status
1c59 : 68 > pla ;use stack to retrieve status
1c5a : 48 > pha
> cmp_flag fc
1c5b : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c5d : d0fe > bne * ;failed not equal (non zero)
>
1c5f : 28 > plp ;restore status
1c60 : ca dex
1c61 : e417 cpx zp7f
tst_stat fzc
1c63 : 08 > php ;save status
1c64 : 68 > pla ;use stack to retrieve status
1c65 : 48 > pha
> cmp_flag fzc
1c66 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c68 : d0fe > bne * ;failed not equal (non zero)
>
1c6a : 28 > plp ;restore status
1c6b : ca dex
1c6c : e417 cpx zp7f
tst_x $7e,fn
1c6e : 08 > php ;save flags
1c6f : e07e > cpx #$7e ;test result
> trap_ne
1c71 : d0fe > bne * ;failed not equal (non zero)
>
1c73 : 68 > pla ;load status
1c74 : 48 > pha
> cmp_flag fn
1c75 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c77 : d0fe > bne * ;failed not equal (non zero)
>
1c79 : 28 > plp ;restore status
set_x $80,$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 : a280 > ldx #$80 ;precharge index x
1c7f : 28 > plp
1c80 : e417 cpx zp7f
tst_stat ~fnz
1c82 : 08 > php ;save status
1c83 : 68 > pla ;use stack to retrieve status
1c84 : 48 > pha
> cmp_flag ~fnz
1c85 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c87 : d0fe > bne * ;failed not equal (non zero)
>
1c89 : 28 > plp ;restore status
1c8a : ca dex
1c8b : e417 cpx zp7f
tst_stat ~fn
1c8d : 08 > php ;save status
1c8e : 68 > pla ;use stack to retrieve status
1c8f : 48 > pha
> cmp_flag ~fn
1c90 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1c92 : d0fe > bne * ;failed not equal (non zero)
>
1c94 : 28 > plp ;restore status
1c95 : ca dex
1c96 : e417 cpx zp7f
tst_x $7e,~fzc
1c98 : 08 > php ;save flags
1c99 : e07e > cpx #$7e ;test result
> trap_ne
1c9b : d0fe > bne * ;failed not equal (non zero)
>
1c9d : 68 > pla ;load status
1c9e : 48 > pha
> cmp_flag ~fzc
1c9f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ca1 : d0fe > bne * ;failed not equal (non zero)
>
1ca3 : 28 > plp ;restore status
set_x $80,0
> load_flag 0
1ca4 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ca6 : 48 > pha ;use stack to load status
1ca7 : a280 > ldx #$80 ;precharge index x
1ca9 : 28 > plp
1caa : ec0c02 cpx abs7f
tst_stat fc
1cad : 08 > php ;save status
1cae : 68 > pla ;use stack to retrieve status
1caf : 48 > pha
> cmp_flag fc
1cb0 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1cb2 : d0fe > bne * ;failed not equal (non zero)
>
1cb4 : 28 > plp ;restore status
1cb5 : ca dex
1cb6 : ec0c02 cpx abs7f
tst_stat fzc
1cb9 : 08 > php ;save status
1cba : 68 > pla ;use stack to retrieve status
1cbb : 48 > pha
> cmp_flag fzc
1cbc : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1cbe : d0fe > bne * ;failed not equal (non zero)
>
1cc0 : 28 > plp ;restore status
1cc1 : ca dex
1cc2 : ec0c02 cpx abs7f
tst_x $7e,fn
1cc5 : 08 > php ;save flags
1cc6 : e07e > cpx #$7e ;test result
> trap_ne
1cc8 : d0fe > bne * ;failed not equal (non zero)
>
1cca : 68 > pla ;load status
1ccb : 48 > pha
> cmp_flag fn
1ccc : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1cce : d0fe > bne * ;failed not equal (non zero)
>
1cd0 : 28 > plp ;restore status
set_x $80,$ff
> load_flag $ff
1cd1 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1cd3 : 48 > pha ;use stack to load status
1cd4 : a280 > ldx #$80 ;precharge index x
1cd6 : 28 > plp
1cd7 : ec0c02 cpx abs7f
tst_stat ~fnz
1cda : 08 > php ;save status
1cdb : 68 > pla ;use stack to retrieve status
1cdc : 48 > pha
> cmp_flag ~fnz
1cdd : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1cdf : d0fe > bne * ;failed not equal (non zero)
>
1ce1 : 28 > plp ;restore status
1ce2 : ca dex
1ce3 : ec0c02 cpx abs7f
tst_stat ~fn
1ce6 : 08 > php ;save status
1ce7 : 68 > pla ;use stack to retrieve status
1ce8 : 48 > pha
> cmp_flag ~fn
1ce9 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ceb : d0fe > bne * ;failed not equal (non zero)
>
1ced : 28 > plp ;restore status
1cee : ca dex
1cef : ec0c02 cpx abs7f
tst_x $7e,~fzc
1cf2 : 08 > php ;save flags
1cf3 : e07e > cpx #$7e ;test result
> trap_ne
1cf5 : d0fe > bne * ;failed not equal (non zero)
>
1cf7 : 68 > pla ;load status
1cf8 : 48 > pha
> cmp_flag ~fzc
1cf9 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1cfb : d0fe > bne * ;failed not equal (non zero)
>
1cfd : 28 > plp ;restore status
set_x $80,0
> load_flag 0
1cfe : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1d00 : 48 > pha ;use stack to load status
1d01 : a280 > ldx #$80 ;precharge index x
1d03 : 28 > plp
1d04 : e07f cpx #$7f
tst_stat fc
1d06 : 08 > php ;save status
1d07 : 68 > pla ;use stack to retrieve status
1d08 : 48 > pha
> cmp_flag fc
1d09 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1d0b : d0fe > bne * ;failed not equal (non zero)
>
1d0d : 28 > plp ;restore status
1d0e : ca dex
1d0f : e07f cpx #$7f
tst_stat fzc
1d11 : 08 > php ;save status
1d12 : 68 > pla ;use stack to retrieve status
1d13 : 48 > pha
> cmp_flag fzc
1d14 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1d16 : d0fe > bne * ;failed not equal (non zero)
>
1d18 : 28 > plp ;restore status
1d19 : ca dex
1d1a : e07f cpx #$7f
tst_x $7e,fn
1d1c : 08 > php ;save flags
1d1d : e07e > cpx #$7e ;test result
> trap_ne
1d1f : d0fe > bne * ;failed not equal (non zero)
>
1d21 : 68 > pla ;load status
1d22 : 48 > pha
> cmp_flag fn
1d23 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1d25 : d0fe > bne * ;failed not equal (non zero)
>
1d27 : 28 > plp ;restore status
set_x $80,$ff
> load_flag $ff
1d28 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d2a : 48 > pha ;use stack to load status
1d2b : a280 > ldx #$80 ;precharge index x
1d2d : 28 > plp
1d2e : e07f cpx #$7f
tst_stat ~fnz
1d30 : 08 > php ;save status
1d31 : 68 > pla ;use stack to retrieve status
1d32 : 48 > pha
> cmp_flag ~fnz
1d33 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1d35 : d0fe > bne * ;failed not equal (non zero)
>
1d37 : 28 > plp ;restore status
1d38 : ca dex
1d39 : e07f cpx #$7f
tst_stat ~fn
1d3b : 08 > php ;save status
1d3c : 68 > pla ;use stack to retrieve status
1d3d : 48 > pha
> cmp_flag ~fn
1d3e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1d40 : d0fe > bne * ;failed not equal (non zero)
>
1d42 : 28 > plp ;restore status
1d43 : ca dex
1d44 : e07f cpx #$7f
tst_x $7e,~fzc
1d46 : 08 > php ;save flags
1d47 : e07e > cpx #$7e ;test result
> trap_ne
1d49 : d0fe > bne * ;failed not equal (non zero)
>
1d4b : 68 > pla ;load status
1d4c : 48 > pha
> cmp_flag ~fzc
1d4d : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1d4f : d0fe > bne * ;failed not equal (non zero)
>
1d51 : 28 > plp ;restore status
next_test
1d52 : ad0002 > lda test_case ;previous test
1d55 : c91a > cmp #test_num
> trap_ne ;test is out of sequence
1d57 : d0fe > bne * ;failed not equal (non zero)
>
001b = >test_num = test_num + 1
1d59 : a91b > lda #test_num ;*** next tests' number
1d5b : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; CPY - zp / abs / #
set_y $80,0
> load_flag 0
1d5e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1d60 : 48 > pha ;use stack to load status
1d61 : a080 > ldy #$80 ;precharge index y
1d63 : 28 > plp
1d64 : c417 cpy zp7f
tst_stat fc
1d66 : 08 > php ;save status
1d67 : 68 > pla ;use stack to retrieve status
1d68 : 48 > pha
> cmp_flag fc
1d69 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1d6b : d0fe > bne * ;failed not equal (non zero)
>
1d6d : 28 > plp ;restore status
1d6e : 88 dey
1d6f : c417 cpy zp7f
tst_stat fzc
1d71 : 08 > php ;save status
1d72 : 68 > pla ;use stack to retrieve status
1d73 : 48 > pha
> cmp_flag fzc
1d74 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1d76 : d0fe > bne * ;failed not equal (non zero)
>
1d78 : 28 > plp ;restore status
1d79 : 88 dey
1d7a : c417 cpy zp7f
tst_y $7e,fn
1d7c : 08 > php ;save flags
1d7d : c07e > cpy #$7e ;test result
> trap_ne
1d7f : d0fe > bne * ;failed not equal (non zero)
>
1d81 : 68 > pla ;load status
1d82 : 48 > pha
> cmp_flag fn
1d83 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1d85 : d0fe > bne * ;failed not equal (non zero)
>
1d87 : 28 > plp ;restore status
set_y $80,$ff
> load_flag $ff
1d88 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1d8a : 48 > pha ;use stack to load status
1d8b : a080 > ldy #$80 ;precharge index y
1d8d : 28 > plp
1d8e : c417 cpy zp7f
tst_stat ~fnz
1d90 : 08 > php ;save status
1d91 : 68 > pla ;use stack to retrieve status
1d92 : 48 > pha
> cmp_flag ~fnz
1d93 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1d95 : d0fe > bne * ;failed not equal (non zero)
>
1d97 : 28 > plp ;restore status
1d98 : 88 dey
1d99 : c417 cpy zp7f
tst_stat ~fn
1d9b : 08 > php ;save status
1d9c : 68 > pla ;use stack to retrieve status
1d9d : 48 > pha
> cmp_flag ~fn
1d9e : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1da0 : d0fe > bne * ;failed not equal (non zero)
>
1da2 : 28 > plp ;restore status
1da3 : 88 dey
1da4 : c417 cpy zp7f
tst_y $7e,~fzc
1da6 : 08 > php ;save flags
1da7 : c07e > cpy #$7e ;test result
> trap_ne
1da9 : d0fe > bne * ;failed not equal (non zero)
>
1dab : 68 > pla ;load status
1dac : 48 > pha
> cmp_flag ~fzc
1dad : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1daf : d0fe > bne * ;failed not equal (non zero)
>
1db1 : 28 > plp ;restore status
set_y $80,0
> load_flag 0
1db2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1db4 : 48 > pha ;use stack to load status
1db5 : a080 > ldy #$80 ;precharge index y
1db7 : 28 > plp
1db8 : cc0c02 cpy abs7f
tst_stat fc
1dbb : 08 > php ;save status
1dbc : 68 > pla ;use stack to retrieve status
1dbd : 48 > pha
> cmp_flag fc
1dbe : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1dc0 : d0fe > bne * ;failed not equal (non zero)
>
1dc2 : 28 > plp ;restore status
1dc3 : 88 dey
1dc4 : cc0c02 cpy abs7f
tst_stat fzc
1dc7 : 08 > php ;save status
1dc8 : 68 > pla ;use stack to retrieve status
1dc9 : 48 > pha
> cmp_flag fzc
1dca : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1dcc : d0fe > bne * ;failed not equal (non zero)
>
1dce : 28 > plp ;restore status
1dcf : 88 dey
1dd0 : cc0c02 cpy abs7f
tst_y $7e,fn
1dd3 : 08 > php ;save flags
1dd4 : c07e > cpy #$7e ;test result
> trap_ne
1dd6 : d0fe > bne * ;failed not equal (non zero)
>
1dd8 : 68 > pla ;load status
1dd9 : 48 > pha
> cmp_flag fn
1dda : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ddc : d0fe > bne * ;failed not equal (non zero)
>
1dde : 28 > plp ;restore status
set_y $80,$ff
> load_flag $ff
1ddf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1de1 : 48 > pha ;use stack to load status
1de2 : a080 > ldy #$80 ;precharge index y
1de4 : 28 > plp
1de5 : cc0c02 cpy abs7f
tst_stat ~fnz
1de8 : 08 > php ;save status
1de9 : 68 > pla ;use stack to retrieve status
1dea : 48 > pha
> cmp_flag ~fnz
1deb : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ded : d0fe > bne * ;failed not equal (non zero)
>
1def : 28 > plp ;restore status
1df0 : 88 dey
1df1 : cc0c02 cpy abs7f
tst_stat ~fn
1df4 : 08 > php ;save status
1df5 : 68 > pla ;use stack to retrieve status
1df6 : 48 > pha
> cmp_flag ~fn
1df7 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1df9 : d0fe > bne * ;failed not equal (non zero)
>
1dfb : 28 > plp ;restore status
1dfc : 88 dey
1dfd : cc0c02 cpy abs7f
tst_y $7e,~fzc
1e00 : 08 > php ;save flags
1e01 : c07e > cpy #$7e ;test result
> trap_ne
1e03 : d0fe > bne * ;failed not equal (non zero)
>
1e05 : 68 > pla ;load status
1e06 : 48 > pha
> cmp_flag ~fzc
1e07 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e09 : d0fe > bne * ;failed not equal (non zero)
>
1e0b : 28 > plp ;restore status
set_y $80,0
> load_flag 0
1e0c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e0e : 48 > pha ;use stack to load status
1e0f : a080 > ldy #$80 ;precharge index y
1e11 : 28 > plp
1e12 : c07f cpy #$7f
tst_stat fc
1e14 : 08 > php ;save status
1e15 : 68 > pla ;use stack to retrieve status
1e16 : 48 > pha
> cmp_flag fc
1e17 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e19 : d0fe > bne * ;failed not equal (non zero)
>
1e1b : 28 > plp ;restore status
1e1c : 88 dey
1e1d : c07f cpy #$7f
tst_stat fzc
1e1f : 08 > php ;save status
1e20 : 68 > pla ;use stack to retrieve status
1e21 : 48 > pha
> cmp_flag fzc
1e22 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e24 : d0fe > bne * ;failed not equal (non zero)
>
1e26 : 28 > plp ;restore status
1e27 : 88 dey
1e28 : c07f cpy #$7f
tst_y $7e,fn
1e2a : 08 > php ;save flags
1e2b : c07e > cpy #$7e ;test result
> trap_ne
1e2d : d0fe > bne * ;failed not equal (non zero)
>
1e2f : 68 > pla ;load status
1e30 : 48 > pha
> cmp_flag fn
1e31 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e33 : d0fe > bne * ;failed not equal (non zero)
>
1e35 : 28 > plp ;restore status
set_y $80,$ff
> load_flag $ff
1e36 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1e38 : 48 > pha ;use stack to load status
1e39 : a080 > ldy #$80 ;precharge index y
1e3b : 28 > plp
1e3c : c07f cpy #$7f
tst_stat ~fnz
1e3e : 08 > php ;save status
1e3f : 68 > pla ;use stack to retrieve status
1e40 : 48 > pha
> cmp_flag ~fnz
1e41 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e43 : d0fe > bne * ;failed not equal (non zero)
>
1e45 : 28 > plp ;restore status
1e46 : 88 dey
1e47 : c07f cpy #$7f
tst_stat ~fn
1e49 : 08 > php ;save status
1e4a : 68 > pla ;use stack to retrieve status
1e4b : 48 > pha
> cmp_flag ~fn
1e4c : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e4e : d0fe > bne * ;failed not equal (non zero)
>
1e50 : 28 > plp ;restore status
1e51 : 88 dey
1e52 : c07f cpy #$7f
tst_y $7e,~fzc
1e54 : 08 > php ;save flags
1e55 : c07e > cpy #$7e ;test result
> trap_ne
1e57 : d0fe > bne * ;failed not equal (non zero)
>
1e59 : 68 > pla ;load status
1e5a : 48 > pha
> cmp_flag ~fzc
1e5b : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e5d : d0fe > bne * ;failed not equal (non zero)
>
1e5f : 28 > plp ;restore status
next_test
1e60 : ad0002 > lda test_case ;previous test
1e63 : c91b > cmp #test_num
> trap_ne ;test is out of sequence
1e65 : d0fe > bne * ;failed not equal (non zero)
>
001c = >test_num = test_num + 1
1e67 : a91c > lda #test_num ;*** next tests' number
1e69 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; CMP - zp / abs / #
set_a $80,0
> load_flag 0
1e6c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e6e : 48 > pha ;use stack to load status
1e6f : a980 > lda #$80 ;precharge accu
1e71 : 28 > plp
1e72 : c517 cmp zp7f
tst_a $80,fc
1e74 : 08 > php ;save flags
1e75 : c980 > cmp #$80 ;test result
> trap_ne
1e77 : d0fe > bne * ;failed not equal (non zero)
>
1e79 : 68 > pla ;load status
1e7a : 48 > pha
> cmp_flag fc
1e7b : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e7d : d0fe > bne * ;failed not equal (non zero)
>
1e7f : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
1e80 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e82 : 48 > pha ;use stack to load status
1e83 : a97f > lda #$7f ;precharge accu
1e85 : 28 > plp
1e86 : c517 cmp zp7f
tst_a $7f,fzc
1e88 : 08 > php ;save flags
1e89 : c97f > cmp #$7f ;test result
> trap_ne
1e8b : d0fe > bne * ;failed not equal (non zero)
>
1e8d : 68 > pla ;load status
1e8e : 48 > pha
> cmp_flag fzc
1e8f : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1e91 : d0fe > bne * ;failed not equal (non zero)
>
1e93 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
1e94 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1e96 : 48 > pha ;use stack to load status
1e97 : a97e > lda #$7e ;precharge accu
1e99 : 28 > plp
1e9a : c517 cmp zp7f
tst_a $7e,fn
1e9c : 08 > php ;save flags
1e9d : c97e > cmp #$7e ;test result
> trap_ne
1e9f : d0fe > bne * ;failed not equal (non zero)
>
1ea1 : 68 > pla ;load status
1ea2 : 48 > pha
> cmp_flag fn
1ea3 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ea5 : d0fe > bne * ;failed not equal (non zero)
>
1ea7 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
1ea8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1eaa : 48 > pha ;use stack to load status
1eab : a980 > lda #$80 ;precharge accu
1ead : 28 > plp
1eae : c517 cmp zp7f
tst_a $80,~fnz
1eb0 : 08 > php ;save flags
1eb1 : c980 > cmp #$80 ;test result
> trap_ne
1eb3 : d0fe > bne * ;failed not equal (non zero)
>
1eb5 : 68 > pla ;load status
1eb6 : 48 > pha
> cmp_flag ~fnz
1eb7 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1eb9 : d0fe > bne * ;failed not equal (non zero)
>
1ebb : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
1ebc : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1ebe : 48 > pha ;use stack to load status
1ebf : a97f > lda #$7f ;precharge accu
1ec1 : 28 > plp
1ec2 : c517 cmp zp7f
tst_a $7f,~fn
1ec4 : 08 > php ;save flags
1ec5 : c97f > cmp #$7f ;test result
> trap_ne
1ec7 : d0fe > bne * ;failed not equal (non zero)
>
1ec9 : 68 > pla ;load status
1eca : 48 > pha
> cmp_flag ~fn
1ecb : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ecd : d0fe > bne * ;failed not equal (non zero)
>
1ecf : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
1ed0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1ed2 : 48 > pha ;use stack to load status
1ed3 : a97e > lda #$7e ;precharge accu
1ed5 : 28 > plp
1ed6 : c517 cmp zp7f
tst_a $7e,~fzc
1ed8 : 08 > php ;save flags
1ed9 : c97e > cmp #$7e ;test result
> trap_ne
1edb : d0fe > bne * ;failed not equal (non zero)
>
1edd : 68 > pla ;load status
1ede : 48 > pha
> cmp_flag ~fzc
1edf : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ee1 : d0fe > bne * ;failed not equal (non zero)
>
1ee3 : 28 > plp ;restore status
set_a $80,0
> load_flag 0
1ee4 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ee6 : 48 > pha ;use stack to load status
1ee7 : a980 > lda #$80 ;precharge accu
1ee9 : 28 > plp
1eea : cd0c02 cmp abs7f
tst_a $80,fc
1eed : 08 > php ;save flags
1eee : c980 > cmp #$80 ;test result
> trap_ne
1ef0 : d0fe > bne * ;failed not equal (non zero)
>
1ef2 : 68 > pla ;load status
1ef3 : 48 > pha
> cmp_flag fc
1ef4 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1ef6 : d0fe > bne * ;failed not equal (non zero)
>
1ef8 : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
1ef9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1efb : 48 > pha ;use stack to load status
1efc : a97f > lda #$7f ;precharge accu
1efe : 28 > plp
1eff : cd0c02 cmp abs7f
tst_a $7f,fzc
1f02 : 08 > php ;save flags
1f03 : c97f > cmp #$7f ;test result
> trap_ne
1f05 : d0fe > bne * ;failed not equal (non zero)
>
1f07 : 68 > pla ;load status
1f08 : 48 > pha
> cmp_flag fzc
1f09 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f0b : d0fe > bne * ;failed not equal (non zero)
>
1f0d : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
1f0e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f10 : 48 > pha ;use stack to load status
1f11 : a97e > lda #$7e ;precharge accu
1f13 : 28 > plp
1f14 : cd0c02 cmp abs7f
tst_a $7e,fn
1f17 : 08 > php ;save flags
1f18 : c97e > cmp #$7e ;test result
> trap_ne
1f1a : d0fe > bne * ;failed not equal (non zero)
>
1f1c : 68 > pla ;load status
1f1d : 48 > pha
> cmp_flag fn
1f1e : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f20 : d0fe > bne * ;failed not equal (non zero)
>
1f22 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
1f23 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1f25 : 48 > pha ;use stack to load status
1f26 : a980 > lda #$80 ;precharge accu
1f28 : 28 > plp
1f29 : cd0c02 cmp abs7f
tst_a $80,~fnz
1f2c : 08 > php ;save flags
1f2d : c980 > cmp #$80 ;test result
> trap_ne
1f2f : d0fe > bne * ;failed not equal (non zero)
>
1f31 : 68 > pla ;load status
1f32 : 48 > pha
> cmp_flag ~fnz
1f33 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f35 : d0fe > bne * ;failed not equal (non zero)
>
1f37 : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
1f38 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1f3a : 48 > pha ;use stack to load status
1f3b : a97f > lda #$7f ;precharge accu
1f3d : 28 > plp
1f3e : cd0c02 cmp abs7f
tst_a $7f,~fn
1f41 : 08 > php ;save flags
1f42 : c97f > cmp #$7f ;test result
> trap_ne
1f44 : d0fe > bne * ;failed not equal (non zero)
>
1f46 : 68 > pla ;load status
1f47 : 48 > pha
> cmp_flag ~fn
1f48 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f4a : d0fe > bne * ;failed not equal (non zero)
>
1f4c : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
1f4d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1f4f : 48 > pha ;use stack to load status
1f50 : a97e > lda #$7e ;precharge accu
1f52 : 28 > plp
1f53 : cd0c02 cmp abs7f
tst_a $7e,~fzc
1f56 : 08 > php ;save flags
1f57 : c97e > cmp #$7e ;test result
> trap_ne
1f59 : d0fe > bne * ;failed not equal (non zero)
>
1f5b : 68 > pla ;load status
1f5c : 48 > pha
> cmp_flag ~fzc
1f5d : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f5f : d0fe > bne * ;failed not equal (non zero)
>
1f61 : 28 > plp ;restore status
set_a $80,0
> load_flag 0
1f62 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f64 : 48 > pha ;use stack to load status
1f65 : a980 > lda #$80 ;precharge accu
1f67 : 28 > plp
1f68 : c97f cmp #$7f
tst_a $80,fc
1f6a : 08 > php ;save flags
1f6b : c980 > cmp #$80 ;test result
> trap_ne
1f6d : d0fe > bne * ;failed not equal (non zero)
>
1f6f : 68 > pla ;load status
1f70 : 48 > pha
> cmp_flag fc
1f71 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f73 : d0fe > bne * ;failed not equal (non zero)
>
1f75 : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
1f76 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f78 : 48 > pha ;use stack to load status
1f79 : a97f > lda #$7f ;precharge accu
1f7b : 28 > plp
1f7c : c97f cmp #$7f
tst_a $7f,fzc
1f7e : 08 > php ;save flags
1f7f : c97f > cmp #$7f ;test result
> trap_ne
1f81 : d0fe > bne * ;failed not equal (non zero)
>
1f83 : 68 > pla ;load status
1f84 : 48 > pha
> cmp_flag fzc
1f85 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f87 : d0fe > bne * ;failed not equal (non zero)
>
1f89 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
1f8a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1f8c : 48 > pha ;use stack to load status
1f8d : a97e > lda #$7e ;precharge accu
1f8f : 28 > plp
1f90 : c97f cmp #$7f
tst_a $7e,fn
1f92 : 08 > php ;save flags
1f93 : c97e > cmp #$7e ;test result
> trap_ne
1f95 : d0fe > bne * ;failed not equal (non zero)
>
1f97 : 68 > pla ;load status
1f98 : 48 > pha
> cmp_flag fn
1f99 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1f9b : d0fe > bne * ;failed not equal (non zero)
>
1f9d : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
1f9e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1fa0 : 48 > pha ;use stack to load status
1fa1 : a980 > lda #$80 ;precharge accu
1fa3 : 28 > plp
1fa4 : c97f cmp #$7f
tst_a $80,~fnz
1fa6 : 08 > php ;save flags
1fa7 : c980 > cmp #$80 ;test result
> trap_ne
1fa9 : d0fe > bne * ;failed not equal (non zero)
>
1fab : 68 > pla ;load status
1fac : 48 > pha
> cmp_flag ~fnz
1fad : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1faf : d0fe > bne * ;failed not equal (non zero)
>
1fb1 : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
1fb2 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1fb4 : 48 > pha ;use stack to load status
1fb5 : a97f > lda #$7f ;precharge accu
1fb7 : 28 > plp
1fb8 : c97f cmp #$7f
tst_a $7f,~fn
1fba : 08 > php ;save flags
1fbb : c97f > cmp #$7f ;test result
> trap_ne
1fbd : d0fe > bne * ;failed not equal (non zero)
>
1fbf : 68 > pla ;load status
1fc0 : 48 > pha
> cmp_flag ~fn
1fc1 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fc3 : d0fe > bne * ;failed not equal (non zero)
>
1fc5 : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
1fc6 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
1fc8 : 48 > pha ;use stack to load status
1fc9 : a97e > lda #$7e ;precharge accu
1fcb : 28 > plp
1fcc : c97f cmp #$7f
tst_a $7e,~fzc
1fce : 08 > php ;save flags
1fcf : c97e > cmp #$7e ;test result
> trap_ne
1fd1 : d0fe > bne * ;failed not equal (non zero)
>
1fd3 : 68 > pla ;load status
1fd4 : 48 > pha
> cmp_flag ~fzc
1fd5 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fd7 : d0fe > bne * ;failed not equal (non zero)
>
1fd9 : 28 > plp ;restore status
1fda : a204 ldx #4 ;with indexing by X
set_a $80,0
> load_flag 0
1fdc : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1fde : 48 > pha ;use stack to load status
1fdf : a980 > lda #$80 ;precharge accu
1fe1 : 28 > plp
1fe2 : d513 cmp zp1,x
tst_a $80,fc
1fe4 : 08 > php ;save flags
1fe5 : c980 > cmp #$80 ;test result
> trap_ne
1fe7 : d0fe > bne * ;failed not equal (non zero)
>
1fe9 : 68 > pla ;load status
1fea : 48 > pha
> cmp_flag fc
1feb : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
1fed : d0fe > bne * ;failed not equal (non zero)
>
1fef : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
1ff0 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
1ff2 : 48 > pha ;use stack to load status
1ff3 : a97f > lda #$7f ;precharge accu
1ff5 : 28 > plp
1ff6 : d513 cmp zp1,x
tst_a $7f,fzc
1ff8 : 08 > php ;save flags
1ff9 : c97f > cmp #$7f ;test result
> trap_ne
1ffb : d0fe > bne * ;failed not equal (non zero)
>
1ffd : 68 > pla ;load status
1ffe : 48 > pha
> cmp_flag fzc
1fff : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2001 : d0fe > bne * ;failed not equal (non zero)
>
2003 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
2004 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2006 : 48 > pha ;use stack to load status
2007 : a97e > lda #$7e ;precharge accu
2009 : 28 > plp
200a : d513 cmp zp1,x
tst_a $7e,fn
200c : 08 > php ;save flags
200d : c97e > cmp #$7e ;test result
> trap_ne
200f : d0fe > bne * ;failed not equal (non zero)
>
2011 : 68 > pla ;load status
2012 : 48 > pha
> cmp_flag fn
2013 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2015 : d0fe > bne * ;failed not equal (non zero)
>
2017 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2018 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
201a : 48 > pha ;use stack to load status
201b : a980 > lda #$80 ;precharge accu
201d : 28 > plp
201e : d513 cmp zp1,x
tst_a $80,~fnz
2020 : 08 > php ;save flags
2021 : c980 > cmp #$80 ;test result
> trap_ne
2023 : d0fe > bne * ;failed not equal (non zero)
>
2025 : 68 > pla ;load status
2026 : 48 > pha
> cmp_flag ~fnz
2027 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2029 : d0fe > bne * ;failed not equal (non zero)
>
202b : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
202c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
202e : 48 > pha ;use stack to load status
202f : a97f > lda #$7f ;precharge accu
2031 : 28 > plp
2032 : d513 cmp zp1,x
tst_a $7f,~fn
2034 : 08 > php ;save flags
2035 : c97f > cmp #$7f ;test result
> trap_ne
2037 : d0fe > bne * ;failed not equal (non zero)
>
2039 : 68 > pla ;load status
203a : 48 > pha
> cmp_flag ~fn
203b : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
203d : d0fe > bne * ;failed not equal (non zero)
>
203f : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
2040 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2042 : 48 > pha ;use stack to load status
2043 : a97e > lda #$7e ;precharge accu
2045 : 28 > plp
2046 : d513 cmp zp1,x
tst_a $7e,~fzc
2048 : 08 > php ;save flags
2049 : c97e > cmp #$7e ;test result
> trap_ne
204b : d0fe > bne * ;failed not equal (non zero)
>
204d : 68 > pla ;load status
204e : 48 > pha
> cmp_flag ~fzc
204f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2051 : d0fe > bne * ;failed not equal (non zero)
>
2053 : 28 > plp ;restore status
set_a $80,0
> load_flag 0
2054 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2056 : 48 > pha ;use stack to load status
2057 : a980 > lda #$80 ;precharge accu
2059 : 28 > plp
205a : dd0802 cmp abs1,x
tst_a $80,fc
205d : 08 > php ;save flags
205e : c980 > cmp #$80 ;test result
> trap_ne
2060 : d0fe > bne * ;failed not equal (non zero)
>
2062 : 68 > pla ;load status
2063 : 48 > pha
> cmp_flag fc
2064 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2066 : d0fe > bne * ;failed not equal (non zero)
>
2068 : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
2069 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
206b : 48 > pha ;use stack to load status
206c : a97f > lda #$7f ;precharge accu
206e : 28 > plp
206f : dd0802 cmp abs1,x
tst_a $7f,fzc
2072 : 08 > php ;save flags
2073 : c97f > cmp #$7f ;test result
> trap_ne
2075 : d0fe > bne * ;failed not equal (non zero)
>
2077 : 68 > pla ;load status
2078 : 48 > pha
> cmp_flag fzc
2079 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
207b : d0fe > bne * ;failed not equal (non zero)
>
207d : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
207e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2080 : 48 > pha ;use stack to load status
2081 : a97e > lda #$7e ;precharge accu
2083 : 28 > plp
2084 : dd0802 cmp abs1,x
tst_a $7e,fn
2087 : 08 > php ;save flags
2088 : c97e > cmp #$7e ;test result
> trap_ne
208a : d0fe > bne * ;failed not equal (non zero)
>
208c : 68 > pla ;load status
208d : 48 > pha
> cmp_flag fn
208e : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2090 : d0fe > bne * ;failed not equal (non zero)
>
2092 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2093 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2095 : 48 > pha ;use stack to load status
2096 : a980 > lda #$80 ;precharge accu
2098 : 28 > plp
2099 : dd0802 cmp abs1,x
tst_a $80,~fnz
209c : 08 > php ;save flags
209d : c980 > cmp #$80 ;test result
> trap_ne
209f : d0fe > bne * ;failed not equal (non zero)
>
20a1 : 68 > pla ;load status
20a2 : 48 > pha
> cmp_flag ~fnz
20a3 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20a5 : d0fe > bne * ;failed not equal (non zero)
>
20a7 : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
20a8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
20aa : 48 > pha ;use stack to load status
20ab : a97f > lda #$7f ;precharge accu
20ad : 28 > plp
20ae : dd0802 cmp abs1,x
tst_a $7f,~fn
20b1 : 08 > php ;save flags
20b2 : c97f > cmp #$7f ;test result
> trap_ne
20b4 : d0fe > bne * ;failed not equal (non zero)
>
20b6 : 68 > pla ;load status
20b7 : 48 > pha
> cmp_flag ~fn
20b8 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20ba : d0fe > bne * ;failed not equal (non zero)
>
20bc : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
20bd : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
20bf : 48 > pha ;use stack to load status
20c0 : a97e > lda #$7e ;precharge accu
20c2 : 28 > plp
20c3 : dd0802 cmp abs1,x
tst_a $7e,~fzc
20c6 : 08 > php ;save flags
20c7 : c97e > cmp #$7e ;test result
> trap_ne
20c9 : d0fe > bne * ;failed not equal (non zero)
>
20cb : 68 > pla ;load status
20cc : 48 > pha
> cmp_flag ~fzc
20cd : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20cf : d0fe > bne * ;failed not equal (non zero)
>
20d1 : 28 > plp ;restore status
20d2 : a004 ldy #4 ;with indexing by Y
20d4 : a208 ldx #8 ;with indexed indirect
set_a $80,0
> load_flag 0
20d6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
20d8 : 48 > pha ;use stack to load status
20d9 : a980 > lda #$80 ;precharge accu
20db : 28 > plp
20dc : d90802 cmp abs1,y
tst_a $80,fc
20df : 08 > php ;save flags
20e0 : c980 > cmp #$80 ;test result
> trap_ne
20e2 : d0fe > bne * ;failed not equal (non zero)
>
20e4 : 68 > pla ;load status
20e5 : 48 > pha
> cmp_flag fc
20e6 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20e8 : d0fe > bne * ;failed not equal (non zero)
>
20ea : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
20eb : a900 > lda #0 ;allow test to change I-flag (no mask)
>
20ed : 48 > pha ;use stack to load status
20ee : a97f > lda #$7f ;precharge accu
20f0 : 28 > plp
20f1 : d90802 cmp abs1,y
tst_a $7f,fzc
20f4 : 08 > php ;save flags
20f5 : c97f > cmp #$7f ;test result
> trap_ne
20f7 : d0fe > bne * ;failed not equal (non zero)
>
20f9 : 68 > pla ;load status
20fa : 48 > pha
> cmp_flag fzc
20fb : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
20fd : d0fe > bne * ;failed not equal (non zero)
>
20ff : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
2100 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2102 : 48 > pha ;use stack to load status
2103 : a97e > lda #$7e ;precharge accu
2105 : 28 > plp
2106 : d90802 cmp abs1,y
tst_a $7e,fn
2109 : 08 > php ;save flags
210a : c97e > cmp #$7e ;test result
> trap_ne
210c : d0fe > bne * ;failed not equal (non zero)
>
210e : 68 > pla ;load status
210f : 48 > pha
> cmp_flag fn
2110 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2112 : d0fe > bne * ;failed not equal (non zero)
>
2114 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2115 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2117 : 48 > pha ;use stack to load status
2118 : a980 > lda #$80 ;precharge accu
211a : 28 > plp
211b : d90802 cmp abs1,y
tst_a $80,~fnz
211e : 08 > php ;save flags
211f : c980 > cmp #$80 ;test result
> trap_ne
2121 : d0fe > bne * ;failed not equal (non zero)
>
2123 : 68 > pla ;load status
2124 : 48 > pha
> cmp_flag ~fnz
2125 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2127 : d0fe > bne * ;failed not equal (non zero)
>
2129 : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
212a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
212c : 48 > pha ;use stack to load status
212d : a97f > lda #$7f ;precharge accu
212f : 28 > plp
2130 : d90802 cmp abs1,y
tst_a $7f,~fn
2133 : 08 > php ;save flags
2134 : c97f > cmp #$7f ;test result
> trap_ne
2136 : d0fe > bne * ;failed not equal (non zero)
>
2138 : 68 > pla ;load status
2139 : 48 > pha
> cmp_flag ~fn
213a : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
213c : d0fe > bne * ;failed not equal (non zero)
>
213e : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
213f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2141 : 48 > pha ;use stack to load status
2142 : a97e > lda #$7e ;precharge accu
2144 : 28 > plp
2145 : d90802 cmp abs1,y
tst_a $7e,~fzc
2148 : 08 > php ;save flags
2149 : c97e > cmp #$7e ;test result
> trap_ne
214b : d0fe > bne * ;failed not equal (non zero)
>
214d : 68 > pla ;load status
214e : 48 > pha
> cmp_flag ~fzc
214f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2151 : d0fe > bne * ;failed not equal (non zero)
>
2153 : 28 > plp ;restore status
set_a $80,0
> load_flag 0
2154 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2156 : 48 > pha ;use stack to load status
2157 : a980 > lda #$80 ;precharge accu
2159 : 28 > plp
215a : c124 cmp (ind1,x)
tst_a $80,fc
215c : 08 > php ;save flags
215d : c980 > cmp #$80 ;test result
> trap_ne
215f : d0fe > bne * ;failed not equal (non zero)
>
2161 : 68 > pla ;load status
2162 : 48 > pha
> cmp_flag fc
2163 : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2165 : d0fe > bne * ;failed not equal (non zero)
>
2167 : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
2168 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
216a : 48 > pha ;use stack to load status
216b : a97f > lda #$7f ;precharge accu
216d : 28 > plp
216e : c124 cmp (ind1,x)
tst_a $7f,fzc
2170 : 08 > php ;save flags
2171 : c97f > cmp #$7f ;test result
> trap_ne
2173 : d0fe > bne * ;failed not equal (non zero)
>
2175 : 68 > pla ;load status
2176 : 48 > pha
> cmp_flag fzc
2177 : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2179 : d0fe > bne * ;failed not equal (non zero)
>
217b : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
217c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
217e : 48 > pha ;use stack to load status
217f : a97e > lda #$7e ;precharge accu
2181 : 28 > plp
2182 : c124 cmp (ind1,x)
tst_a $7e,fn
2184 : 08 > php ;save flags
2185 : c97e > cmp #$7e ;test result
> trap_ne
2187 : d0fe > bne * ;failed not equal (non zero)
>
2189 : 68 > pla ;load status
218a : 48 > pha
> cmp_flag fn
218b : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
218d : d0fe > bne * ;failed not equal (non zero)
>
218f : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2190 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2192 : 48 > pha ;use stack to load status
2193 : a980 > lda #$80 ;precharge accu
2195 : 28 > plp
2196 : c124 cmp (ind1,x)
tst_a $80,~fnz
2198 : 08 > php ;save flags
2199 : c980 > cmp #$80 ;test result
> trap_ne
219b : d0fe > bne * ;failed not equal (non zero)
>
219d : 68 > pla ;load status
219e : 48 > pha
> cmp_flag ~fnz
219f : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21a1 : d0fe > bne * ;failed not equal (non zero)
>
21a3 : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
21a4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
21a6 : 48 > pha ;use stack to load status
21a7 : a97f > lda #$7f ;precharge accu
21a9 : 28 > plp
21aa : c124 cmp (ind1,x)
tst_a $7f,~fn
21ac : 08 > php ;save flags
21ad : c97f > cmp #$7f ;test result
> trap_ne
21af : d0fe > bne * ;failed not equal (non zero)
>
21b1 : 68 > pla ;load status
21b2 : 48 > pha
> cmp_flag ~fn
21b3 : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21b5 : d0fe > bne * ;failed not equal (non zero)
>
21b7 : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
21b8 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
21ba : 48 > pha ;use stack to load status
21bb : a97e > lda #$7e ;precharge accu
21bd : 28 > plp
21be : c124 cmp (ind1,x)
tst_a $7e,~fzc
21c0 : 08 > php ;save flags
21c1 : c97e > cmp #$7e ;test result
> trap_ne
21c3 : d0fe > bne * ;failed not equal (non zero)
>
21c5 : 68 > pla ;load status
21c6 : 48 > pha
> cmp_flag ~fzc
21c7 : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21c9 : d0fe > bne * ;failed not equal (non zero)
>
21cb : 28 > plp ;restore status
set_a $80,0
> load_flag 0
21cc : a900 > lda #0 ;allow test to change I-flag (no mask)
>
21ce : 48 > pha ;use stack to load status
21cf : a980 > lda #$80 ;precharge accu
21d1 : 28 > plp
21d2 : d124 cmp (ind1),y
tst_a $80,fc
21d4 : 08 > php ;save flags
21d5 : c980 > cmp #$80 ;test result
> trap_ne
21d7 : d0fe > bne * ;failed not equal (non zero)
>
21d9 : 68 > pla ;load status
21da : 48 > pha
> cmp_flag fc
21db : c931 > cmp #(fc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21dd : d0fe > bne * ;failed not equal (non zero)
>
21df : 28 > plp ;restore status
set_a $7f,0
> load_flag 0
21e0 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
21e2 : 48 > pha ;use stack to load status
21e3 : a97f > lda #$7f ;precharge accu
21e5 : 28 > plp
21e6 : d124 cmp (ind1),y
tst_a $7f,fzc
21e8 : 08 > php ;save flags
21e9 : c97f > cmp #$7f ;test result
> trap_ne
21eb : d0fe > bne * ;failed not equal (non zero)
>
21ed : 68 > pla ;load status
21ee : 48 > pha
> cmp_flag fzc
21ef : c933 > cmp #(fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
21f1 : d0fe > bne * ;failed not equal (non zero)
>
21f3 : 28 > plp ;restore status
set_a $7e,0
> load_flag 0
21f4 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
21f6 : 48 > pha ;use stack to load status
21f7 : a97e > lda #$7e ;precharge accu
21f9 : 28 > plp
21fa : d124 cmp (ind1),y
tst_a $7e,fn
21fc : 08 > php ;save flags
21fd : c97e > cmp #$7e ;test result
> trap_ne
21ff : d0fe > bne * ;failed not equal (non zero)
>
2201 : 68 > pla ;load status
2202 : 48 > pha
> cmp_flag fn
2203 : c9b0 > cmp #(fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2205 : d0fe > bne * ;failed not equal (non zero)
>
2207 : 28 > plp ;restore status
set_a $80,$ff
> load_flag $ff
2208 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
220a : 48 > pha ;use stack to load status
220b : a980 > lda #$80 ;precharge accu
220d : 28 > plp
220e : d124 cmp (ind1),y
tst_a $80,~fnz
2210 : 08 > php ;save flags
2211 : c980 > cmp #$80 ;test result
> trap_ne
2213 : d0fe > bne * ;failed not equal (non zero)
>
2215 : 68 > pla ;load status
2216 : 48 > pha
> cmp_flag ~fnz
2217 : c97d > cmp #(~fnz|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2219 : d0fe > bne * ;failed not equal (non zero)
>
221b : 28 > plp ;restore status
set_a $7f,$ff
> load_flag $ff
221c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
221e : 48 > pha ;use stack to load status
221f : a97f > lda #$7f ;precharge accu
2221 : 28 > plp
2222 : d124 cmp (ind1),y
tst_a $7f,~fn
2224 : 08 > php ;save flags
2225 : c97f > cmp #$7f ;test result
> trap_ne
2227 : d0fe > bne * ;failed not equal (non zero)
>
2229 : 68 > pla ;load status
222a : 48 > pha
> cmp_flag ~fn
222b : c97f > cmp #(~fn|fao)&m8 ;expected flags + always on bits
>
> trap_ne
222d : d0fe > bne * ;failed not equal (non zero)
>
222f : 28 > plp ;restore status
set_a $7e,$ff
> load_flag $ff
2230 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2232 : 48 > pha ;use stack to load status
2233 : a97e > lda #$7e ;precharge accu
2235 : 28 > plp
2236 : d124 cmp (ind1),y
tst_a $7e,~fzc
2238 : 08 > php ;save flags
2239 : c97e > cmp #$7e ;test result
> trap_ne
223b : d0fe > bne * ;failed not equal (non zero)
>
223d : 68 > pla ;load status
223e : 48 > pha
> cmp_flag ~fzc
223f : c9fc > cmp #(~fzc|fao)&m8 ;expected flags + always on bits
>
> trap_ne
2241 : d0fe > bne * ;failed not equal (non zero)
>
2243 : 28 > plp ;restore status
next_test
2244 : ad0002 > lda test_case ;previous test
2247 : c91c > cmp #test_num
> trap_ne ;test is out of sequence
2249 : d0fe > bne * ;failed not equal (non zero)
>
001d = >test_num = test_num + 1
224b : a91d > lda #test_num ;*** next tests' number
224d : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing shifts - ASL LSR ROL ROR all addressing modes
; shifts - accumulator
2250 : a203 ldx #3
2252 : tasl
set_ax zp1,0
> load_flag 0
2252 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2254 : 48 > pha ;use stack to load status
2255 : b513 > lda zp1,x ;precharge accu
2257 : 28 > plp
2258 : 0a asl a
tst_ax rASL,fASL,0
2259 : 08 > php ;save flags
225a : dd1102 > cmp rASL,x ;test result
> trap_ne
225d : d0fe > bne * ;failed not equal (non zero)
>
225f : 68 > pla ;load status
> eor_flag 0
2260 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2262 : dd2102 > cmp fASL,x ;test flags
> trap_ne ;
2265 : d0fe > bne * ;failed not equal (non zero)
>
2267 : ca dex
2268 : 10e8 bpl tasl
226a : a203 ldx #3
226c : tasl1
set_ax zp1,$ff
> load_flag $ff
226c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
226e : 48 > pha ;use stack to load status
226f : b513 > lda zp1,x ;precharge accu
2271 : 28 > plp
2272 : 0a asl a
tst_ax rASL,fASL,$ff-fnzc
2273 : 08 > php ;save flags
2274 : dd1102 > cmp rASL,x ;test result
> trap_ne
2277 : d0fe > bne * ;failed not equal (non zero)
>
2279 : 68 > pla ;load status
> eor_flag $ff-fnzc
227a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
227c : dd2102 > cmp fASL,x ;test flags
> trap_ne ;
227f : d0fe > bne * ;failed not equal (non zero)
>
2281 : ca dex
2282 : 10e8 bpl tasl1
2284 : a203 ldx #3
2286 : tlsr
set_ax zp1,0
> load_flag 0
2286 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2288 : 48 > pha ;use stack to load status
2289 : b513 > lda zp1,x ;precharge accu
228b : 28 > plp
228c : 4a lsr a
tst_ax rLSR,fLSR,0
228d : 08 > php ;save flags
228e : dd1902 > cmp rLSR,x ;test result
> trap_ne
2291 : d0fe > bne * ;failed not equal (non zero)
>
2293 : 68 > pla ;load status
> eor_flag 0
2294 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2296 : dd2902 > cmp fLSR,x ;test flags
> trap_ne ;
2299 : d0fe > bne * ;failed not equal (non zero)
>
229b : ca dex
229c : 10e8 bpl tlsr
229e : a203 ldx #3
22a0 : tlsr1
set_ax zp1,$ff
> load_flag $ff
22a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
22a2 : 48 > pha ;use stack to load status
22a3 : b513 > lda zp1,x ;precharge accu
22a5 : 28 > plp
22a6 : 4a lsr a
tst_ax rLSR,fLSR,$ff-fnzc
22a7 : 08 > php ;save flags
22a8 : dd1902 > cmp rLSR,x ;test result
> trap_ne
22ab : d0fe > bne * ;failed not equal (non zero)
>
22ad : 68 > pla ;load status
> eor_flag $ff-fnzc
22ae : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
22b0 : dd2902 > cmp fLSR,x ;test flags
> trap_ne ;
22b3 : d0fe > bne * ;failed not equal (non zero)
>
22b5 : ca dex
22b6 : 10e8 bpl tlsr1
22b8 : a203 ldx #3
22ba : trol
set_ax zp1,0
> load_flag 0
22ba : a900 > lda #0 ;allow test to change I-flag (no mask)
>
22bc : 48 > pha ;use stack to load status
22bd : b513 > lda zp1,x ;precharge accu
22bf : 28 > plp
22c0 : 2a rol a
tst_ax rROL,fROL,0
22c1 : 08 > php ;save flags
22c2 : dd1102 > cmp rROL,x ;test result
> trap_ne
22c5 : d0fe > bne * ;failed not equal (non zero)
>
22c7 : 68 > pla ;load status
> eor_flag 0
22c8 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
22ca : dd2102 > cmp fROL,x ;test flags
> trap_ne ;
22cd : d0fe > bne * ;failed not equal (non zero)
>
22cf : ca dex
22d0 : 10e8 bpl trol
22d2 : a203 ldx #3
22d4 : trol1
set_ax zp1,$ff-fc
> load_flag $ff-fc
22d4 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
22d6 : 48 > pha ;use stack to load status
22d7 : b513 > lda zp1,x ;precharge accu
22d9 : 28 > plp
22da : 2a rol a
tst_ax rROL,fROL,$ff-fnzc
22db : 08 > php ;save flags
22dc : dd1102 > cmp rROL,x ;test result
> trap_ne
22df : d0fe > bne * ;failed not equal (non zero)
>
22e1 : 68 > pla ;load status
> eor_flag $ff-fnzc
22e2 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
22e4 : dd2102 > cmp fROL,x ;test flags
> trap_ne ;
22e7 : d0fe > bne * ;failed not equal (non zero)
>
22e9 : ca dex
22ea : 10e8 bpl trol1
22ec : a203 ldx #3
22ee : trolc
set_ax zp1,fc
> load_flag fc
22ee : a901 > lda #fc ;allow test to change I-flag (no mask)
>
22f0 : 48 > pha ;use stack to load status
22f1 : b513 > lda zp1,x ;precharge accu
22f3 : 28 > plp
22f4 : 2a rol a
tst_ax rROLc,fROLc,0
22f5 : 08 > php ;save flags
22f6 : dd1502 > cmp rROLc,x ;test result
> trap_ne
22f9 : d0fe > bne * ;failed not equal (non zero)
>
22fb : 68 > pla ;load status
> eor_flag 0
22fc : 4930 > eor #0|fao ;invert expected flags + always on bits
>
22fe : dd2502 > cmp fROLc,x ;test flags
> trap_ne ;
2301 : d0fe > bne * ;failed not equal (non zero)
>
2303 : ca dex
2304 : 10e8 bpl trolc
2306 : a203 ldx #3
2308 : trolc1
set_ax zp1,$ff
> load_flag $ff
2308 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
230a : 48 > pha ;use stack to load status
230b : b513 > lda zp1,x ;precharge accu
230d : 28 > plp
230e : 2a rol a
tst_ax rROLc,fROLc,$ff-fnzc
230f : 08 > php ;save flags
2310 : dd1502 > cmp rROLc,x ;test result
> trap_ne
2313 : d0fe > bne * ;failed not equal (non zero)
>
2315 : 68 > pla ;load status
> eor_flag $ff-fnzc
2316 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2318 : dd2502 > cmp fROLc,x ;test flags
> trap_ne ;
231b : d0fe > bne * ;failed not equal (non zero)
>
231d : ca dex
231e : 10e8 bpl trolc1
2320 : a203 ldx #3
2322 : tror
set_ax zp1,0
> load_flag 0
2322 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2324 : 48 > pha ;use stack to load status
2325 : b513 > lda zp1,x ;precharge accu
2327 : 28 > plp
2328 : 6a ror a
tst_ax rROR,fROR,0
2329 : 08 > php ;save flags
232a : dd1902 > cmp rROR,x ;test result
> trap_ne
232d : d0fe > bne * ;failed not equal (non zero)
>
232f : 68 > pla ;load status
> eor_flag 0
2330 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2332 : dd2902 > cmp fROR,x ;test flags
> trap_ne ;
2335 : d0fe > bne * ;failed not equal (non zero)
>
2337 : ca dex
2338 : 10e8 bpl tror
233a : a203 ldx #3
233c : tror1
set_ax zp1,$ff-fc
> load_flag $ff-fc
233c : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
233e : 48 > pha ;use stack to load status
233f : b513 > lda zp1,x ;precharge accu
2341 : 28 > plp
2342 : 6a ror a
tst_ax rROR,fROR,$ff-fnzc
2343 : 08 > php ;save flags
2344 : dd1902 > cmp rROR,x ;test result
> trap_ne
2347 : d0fe > bne * ;failed not equal (non zero)
>
2349 : 68 > pla ;load status
> eor_flag $ff-fnzc
234a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
234c : dd2902 > cmp fROR,x ;test flags
> trap_ne ;
234f : d0fe > bne * ;failed not equal (non zero)
>
2351 : ca dex
2352 : 10e8 bpl tror1
2354 : a203 ldx #3
2356 : trorc
set_ax zp1,fc
> load_flag fc
2356 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2358 : 48 > pha ;use stack to load status
2359 : b513 > lda zp1,x ;precharge accu
235b : 28 > plp
235c : 6a ror a
tst_ax rRORc,fRORc,0
235d : 08 > php ;save flags
235e : dd1d02 > cmp rRORc,x ;test result
> trap_ne
2361 : d0fe > bne * ;failed not equal (non zero)
>
2363 : 68 > pla ;load status
> eor_flag 0
2364 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2366 : dd2d02 > cmp fRORc,x ;test flags
> trap_ne ;
2369 : d0fe > bne * ;failed not equal (non zero)
>
236b : ca dex
236c : 10e8 bpl trorc
236e : a203 ldx #3
2370 : trorc1
set_ax zp1,$ff
> load_flag $ff
2370 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2372 : 48 > pha ;use stack to load status
2373 : b513 > lda zp1,x ;precharge accu
2375 : 28 > plp
2376 : 6a ror a
tst_ax rRORc,fRORc,$ff-fnzc
2377 : 08 > php ;save flags
2378 : dd1d02 > cmp rRORc,x ;test result
> trap_ne
237b : d0fe > bne * ;failed not equal (non zero)
>
237d : 68 > pla ;load status
> eor_flag $ff-fnzc
237e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2380 : dd2d02 > cmp fRORc,x ;test flags
> trap_ne ;
2383 : d0fe > bne * ;failed not equal (non zero)
>
2385 : ca dex
2386 : 10e8 bpl trorc1
next_test
2388 : ad0002 > lda test_case ;previous test
238b : c91d > cmp #test_num
> trap_ne ;test is out of sequence
238d : d0fe > bne * ;failed not equal (non zero)
>
001e = >test_num = test_num + 1
238f : a91e > lda #test_num ;*** next tests' number
2391 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; shifts - zeropage
2394 : a203 ldx #3
2396 : tasl2
set_z zp1,0
> load_flag 0
2396 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2398 : 48 > pha ;use stack to load status
2399 : b513 > lda zp1,x ;load to zeropage
239b : 850c > sta zpt
239d : 28 > plp
239e : 060c asl zpt
tst_z rASL,fASL,0
23a0 : 08 > php ;save flags
23a1 : a50c > lda zpt
23a3 : dd1102 > cmp rASL,x ;test result
> trap_ne
23a6 : d0fe > bne * ;failed not equal (non zero)
>
23a8 : 68 > pla ;load status
> eor_flag 0
23a9 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
23ab : dd2102 > cmp fASL,x ;test flags
> trap_ne
23ae : d0fe > bne * ;failed not equal (non zero)
>
23b0 : ca dex
23b1 : 10e3 bpl tasl2
23b3 : a203 ldx #3
23b5 : tasl3
set_z zp1,$ff
> load_flag $ff
23b5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
23b7 : 48 > pha ;use stack to load status
23b8 : b513 > lda zp1,x ;load to zeropage
23ba : 850c > sta zpt
23bc : 28 > plp
23bd : 060c asl zpt
tst_z rASL,fASL,$ff-fnzc
23bf : 08 > php ;save flags
23c0 : a50c > lda zpt
23c2 : dd1102 > cmp rASL,x ;test result
> trap_ne
23c5 : d0fe > bne * ;failed not equal (non zero)
>
23c7 : 68 > pla ;load status
> eor_flag $ff-fnzc
23c8 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
23ca : dd2102 > cmp fASL,x ;test flags
> trap_ne
23cd : d0fe > bne * ;failed not equal (non zero)
>
23cf : ca dex
23d0 : 10e3 bpl tasl3
23d2 : a203 ldx #3
23d4 : tlsr2
set_z zp1,0
> load_flag 0
23d4 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
23d6 : 48 > pha ;use stack to load status
23d7 : b513 > lda zp1,x ;load to zeropage
23d9 : 850c > sta zpt
23db : 28 > plp
23dc : 460c lsr zpt
tst_z rLSR,fLSR,0
23de : 08 > php ;save flags
23df : a50c > lda zpt
23e1 : dd1902 > cmp rLSR,x ;test result
> trap_ne
23e4 : d0fe > bne * ;failed not equal (non zero)
>
23e6 : 68 > pla ;load status
> eor_flag 0
23e7 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
23e9 : dd2902 > cmp fLSR,x ;test flags
> trap_ne
23ec : d0fe > bne * ;failed not equal (non zero)
>
23ee : ca dex
23ef : 10e3 bpl tlsr2
23f1 : a203 ldx #3
23f3 : tlsr3
set_z zp1,$ff
> load_flag $ff
23f3 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
23f5 : 48 > pha ;use stack to load status
23f6 : b513 > lda zp1,x ;load to zeropage
23f8 : 850c > sta zpt
23fa : 28 > plp
23fb : 460c lsr zpt
tst_z rLSR,fLSR,$ff-fnzc
23fd : 08 > php ;save flags
23fe : a50c > lda zpt
2400 : dd1902 > cmp rLSR,x ;test result
> trap_ne
2403 : d0fe > bne * ;failed not equal (non zero)
>
2405 : 68 > pla ;load status
> eor_flag $ff-fnzc
2406 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2408 : dd2902 > cmp fLSR,x ;test flags
> trap_ne
240b : d0fe > bne * ;failed not equal (non zero)
>
240d : ca dex
240e : 10e3 bpl tlsr3
2410 : a203 ldx #3
2412 : trol2
set_z zp1,0
> load_flag 0
2412 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2414 : 48 > pha ;use stack to load status
2415 : b513 > lda zp1,x ;load to zeropage
2417 : 850c > sta zpt
2419 : 28 > plp
241a : 260c rol zpt
tst_z rROL,fROL,0
241c : 08 > php ;save flags
241d : a50c > lda zpt
241f : dd1102 > cmp rROL,x ;test result
> trap_ne
2422 : d0fe > bne * ;failed not equal (non zero)
>
2424 : 68 > pla ;load status
> eor_flag 0
2425 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2427 : dd2102 > cmp fROL,x ;test flags
> trap_ne
242a : d0fe > bne * ;failed not equal (non zero)
>
242c : ca dex
242d : 10e3 bpl trol2
242f : a203 ldx #3
2431 : trol3
set_z zp1,$ff-fc
> load_flag $ff-fc
2431 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
2433 : 48 > pha ;use stack to load status
2434 : b513 > lda zp1,x ;load to zeropage
2436 : 850c > sta zpt
2438 : 28 > plp
2439 : 260c rol zpt
tst_z rROL,fROL,$ff-fnzc
243b : 08 > php ;save flags
243c : a50c > lda zpt
243e : dd1102 > cmp rROL,x ;test result
> trap_ne
2441 : d0fe > bne * ;failed not equal (non zero)
>
2443 : 68 > pla ;load status
> eor_flag $ff-fnzc
2444 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2446 : dd2102 > cmp fROL,x ;test flags
> trap_ne
2449 : d0fe > bne * ;failed not equal (non zero)
>
244b : ca dex
244c : 10e3 bpl trol3
244e : a203 ldx #3
2450 : trolc2
set_z zp1,fc
> load_flag fc
2450 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2452 : 48 > pha ;use stack to load status
2453 : b513 > lda zp1,x ;load to zeropage
2455 : 850c > sta zpt
2457 : 28 > plp
2458 : 260c rol zpt
tst_z rROLc,fROLc,0
245a : 08 > php ;save flags
245b : a50c > lda zpt
245d : dd1502 > cmp rROLc,x ;test result
> trap_ne
2460 : d0fe > bne * ;failed not equal (non zero)
>
2462 : 68 > pla ;load status
> eor_flag 0
2463 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2465 : dd2502 > cmp fROLc,x ;test flags
> trap_ne
2468 : d0fe > bne * ;failed not equal (non zero)
>
246a : ca dex
246b : 10e3 bpl trolc2
246d : a203 ldx #3
246f : trolc3
set_z zp1,$ff
> load_flag $ff
246f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2471 : 48 > pha ;use stack to load status
2472 : b513 > lda zp1,x ;load to zeropage
2474 : 850c > sta zpt
2476 : 28 > plp
2477 : 260c rol zpt
tst_z rROLc,fROLc,$ff-fnzc
2479 : 08 > php ;save flags
247a : a50c > lda zpt
247c : dd1502 > cmp rROLc,x ;test result
> trap_ne
247f : d0fe > bne * ;failed not equal (non zero)
>
2481 : 68 > pla ;load status
> eor_flag $ff-fnzc
2482 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2484 : dd2502 > cmp fROLc,x ;test flags
> trap_ne
2487 : d0fe > bne * ;failed not equal (non zero)
>
2489 : ca dex
248a : 10e3 bpl trolc3
248c : a203 ldx #3
248e : tror2
set_z zp1,0
> load_flag 0
248e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2490 : 48 > pha ;use stack to load status
2491 : b513 > lda zp1,x ;load to zeropage
2493 : 850c > sta zpt
2495 : 28 > plp
2496 : 660c ror zpt
tst_z rROR,fROR,0
2498 : 08 > php ;save flags
2499 : a50c > lda zpt
249b : dd1902 > cmp rROR,x ;test result
> trap_ne
249e : d0fe > bne * ;failed not equal (non zero)
>
24a0 : 68 > pla ;load status
> eor_flag 0
24a1 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
24a3 : dd2902 > cmp fROR,x ;test flags
> trap_ne
24a6 : d0fe > bne * ;failed not equal (non zero)
>
24a8 : ca dex
24a9 : 10e3 bpl tror2
24ab : a203 ldx #3
24ad : tror3
set_z zp1,$ff-fc
> load_flag $ff-fc
24ad : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
24af : 48 > pha ;use stack to load status
24b0 : b513 > lda zp1,x ;load to zeropage
24b2 : 850c > sta zpt
24b4 : 28 > plp
24b5 : 660c ror zpt
tst_z rROR,fROR,$ff-fnzc
24b7 : 08 > php ;save flags
24b8 : a50c > lda zpt
24ba : dd1902 > cmp rROR,x ;test result
> trap_ne
24bd : d0fe > bne * ;failed not equal (non zero)
>
24bf : 68 > pla ;load status
> eor_flag $ff-fnzc
24c0 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
24c2 : dd2902 > cmp fROR,x ;test flags
> trap_ne
24c5 : d0fe > bne * ;failed not equal (non zero)
>
24c7 : ca dex
24c8 : 10e3 bpl tror3
24ca : a203 ldx #3
24cc : trorc2
set_z zp1,fc
> load_flag fc
24cc : a901 > lda #fc ;allow test to change I-flag (no mask)
>
24ce : 48 > pha ;use stack to load status
24cf : b513 > lda zp1,x ;load to zeropage
24d1 : 850c > sta zpt
24d3 : 28 > plp
24d4 : 660c ror zpt
tst_z rRORc,fRORc,0
24d6 : 08 > php ;save flags
24d7 : a50c > lda zpt
24d9 : dd1d02 > cmp rRORc,x ;test result
> trap_ne
24dc : d0fe > bne * ;failed not equal (non zero)
>
24de : 68 > pla ;load status
> eor_flag 0
24df : 4930 > eor #0|fao ;invert expected flags + always on bits
>
24e1 : dd2d02 > cmp fRORc,x ;test flags
> trap_ne
24e4 : d0fe > bne * ;failed not equal (non zero)
>
24e6 : ca dex
24e7 : 10e3 bpl trorc2
24e9 : a203 ldx #3
24eb : trorc3
set_z zp1,$ff
> load_flag $ff
24eb : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
24ed : 48 > pha ;use stack to load status
24ee : b513 > lda zp1,x ;load to zeropage
24f0 : 850c > sta zpt
24f2 : 28 > plp
24f3 : 660c ror zpt
tst_z rRORc,fRORc,$ff-fnzc
24f5 : 08 > php ;save flags
24f6 : a50c > lda zpt
24f8 : dd1d02 > cmp rRORc,x ;test result
> trap_ne
24fb : d0fe > bne * ;failed not equal (non zero)
>
24fd : 68 > pla ;load status
> eor_flag $ff-fnzc
24fe : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2500 : dd2d02 > cmp fRORc,x ;test flags
> trap_ne
2503 : d0fe > bne * ;failed not equal (non zero)
>
2505 : ca dex
2506 : 10e3 bpl trorc3
next_test
2508 : ad0002 > lda test_case ;previous test
250b : c91e > cmp #test_num
> trap_ne ;test is out of sequence
250d : d0fe > bne * ;failed not equal (non zero)
>
001f = >test_num = test_num + 1
250f : a91f > lda #test_num ;*** next tests' number
2511 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; shifts - absolute
2514 : a203 ldx #3
2516 : tasl4
set_abs zp1,0
> load_flag 0
2516 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2518 : 48 > pha ;use stack to load status
2519 : b513 > lda zp1,x ;load to memory
251b : 8d0302 > sta abst
251e : 28 > plp
251f : 0e0302 asl abst
tst_abs rASL,fASL,0
2522 : 08 > php ;save flags
2523 : ad0302 > lda abst
2526 : dd1102 > cmp rASL,x ;test result
> trap_ne
2529 : d0fe > bne * ;failed not equal (non zero)
>
252b : 68 > pla ;load status
> eor_flag 0
252c : 4930 > eor #0|fao ;invert expected flags + always on bits
>
252e : dd2102 > cmp fASL,x ;test flags
> trap_ne
2531 : d0fe > bne * ;failed not equal (non zero)
>
2533 : ca dex
2534 : 10e0 bpl tasl4
2536 : a203 ldx #3
2538 : tasl5
set_abs zp1,$ff
> load_flag $ff
2538 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
253a : 48 > pha ;use stack to load status
253b : b513 > lda zp1,x ;load to memory
253d : 8d0302 > sta abst
2540 : 28 > plp
2541 : 0e0302 asl abst
tst_abs rASL,fASL,$ff-fnzc
2544 : 08 > php ;save flags
2545 : ad0302 > lda abst
2548 : dd1102 > cmp rASL,x ;test result
> trap_ne
254b : d0fe > bne * ;failed not equal (non zero)
>
254d : 68 > pla ;load status
> eor_flag $ff-fnzc
254e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2550 : dd2102 > cmp fASL,x ;test flags
> trap_ne
2553 : d0fe > bne * ;failed not equal (non zero)
>
2555 : ca dex
2556 : 10e0 bpl tasl5
2558 : a203 ldx #3
255a : tlsr4
set_abs zp1,0
> load_flag 0
255a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
255c : 48 > pha ;use stack to load status
255d : b513 > lda zp1,x ;load to memory
255f : 8d0302 > sta abst
2562 : 28 > plp
2563 : 4e0302 lsr abst
tst_abs rLSR,fLSR,0
2566 : 08 > php ;save flags
2567 : ad0302 > lda abst
256a : dd1902 > cmp rLSR,x ;test result
> trap_ne
256d : d0fe > bne * ;failed not equal (non zero)
>
256f : 68 > pla ;load status
> eor_flag 0
2570 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2572 : dd2902 > cmp fLSR,x ;test flags
> trap_ne
2575 : d0fe > bne * ;failed not equal (non zero)
>
2577 : ca dex
2578 : 10e0 bpl tlsr4
257a : a203 ldx #3
257c : tlsr5
set_abs zp1,$ff
> load_flag $ff
257c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
257e : 48 > pha ;use stack to load status
257f : b513 > lda zp1,x ;load to memory
2581 : 8d0302 > sta abst
2584 : 28 > plp
2585 : 4e0302 lsr abst
tst_abs rLSR,fLSR,$ff-fnzc
2588 : 08 > php ;save flags
2589 : ad0302 > lda abst
258c : dd1902 > cmp rLSR,x ;test result
> trap_ne
258f : d0fe > bne * ;failed not equal (non zero)
>
2591 : 68 > pla ;load status
> eor_flag $ff-fnzc
2592 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2594 : dd2902 > cmp fLSR,x ;test flags
> trap_ne
2597 : d0fe > bne * ;failed not equal (non zero)
>
2599 : ca dex
259a : 10e0 bpl tlsr5
259c : a203 ldx #3
259e : trol4
set_abs zp1,0
> load_flag 0
259e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
25a0 : 48 > pha ;use stack to load status
25a1 : b513 > lda zp1,x ;load to memory
25a3 : 8d0302 > sta abst
25a6 : 28 > plp
25a7 : 2e0302 rol abst
tst_abs rROL,fROL,0
25aa : 08 > php ;save flags
25ab : ad0302 > lda abst
25ae : dd1102 > cmp rROL,x ;test result
> trap_ne
25b1 : d0fe > bne * ;failed not equal (non zero)
>
25b3 : 68 > pla ;load status
> eor_flag 0
25b4 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
25b6 : dd2102 > cmp fROL,x ;test flags
> trap_ne
25b9 : d0fe > bne * ;failed not equal (non zero)
>
25bb : ca dex
25bc : 10e0 bpl trol4
25be : a203 ldx #3
25c0 : trol5
set_abs zp1,$ff-fc
> load_flag $ff-fc
25c0 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
25c2 : 48 > pha ;use stack to load status
25c3 : b513 > lda zp1,x ;load to memory
25c5 : 8d0302 > sta abst
25c8 : 28 > plp
25c9 : 2e0302 rol abst
tst_abs rROL,fROL,$ff-fnzc
25cc : 08 > php ;save flags
25cd : ad0302 > lda abst
25d0 : dd1102 > cmp rROL,x ;test result
> trap_ne
25d3 : d0fe > bne * ;failed not equal (non zero)
>
25d5 : 68 > pla ;load status
> eor_flag $ff-fnzc
25d6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
25d8 : dd2102 > cmp fROL,x ;test flags
> trap_ne
25db : d0fe > bne * ;failed not equal (non zero)
>
25dd : ca dex
25de : 10e0 bpl trol5
25e0 : a203 ldx #3
25e2 : trolc4
set_abs zp1,fc
> load_flag fc
25e2 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
25e4 : 48 > pha ;use stack to load status
25e5 : b513 > lda zp1,x ;load to memory
25e7 : 8d0302 > sta abst
25ea : 28 > plp
25eb : 2e0302 rol abst
tst_abs rROLc,fROLc,0
25ee : 08 > php ;save flags
25ef : ad0302 > lda abst
25f2 : dd1502 > cmp rROLc,x ;test result
> trap_ne
25f5 : d0fe > bne * ;failed not equal (non zero)
>
25f7 : 68 > pla ;load status
> eor_flag 0
25f8 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
25fa : dd2502 > cmp fROLc,x ;test flags
> trap_ne
25fd : d0fe > bne * ;failed not equal (non zero)
>
25ff : ca dex
2600 : 10e0 bpl trolc4
2602 : a203 ldx #3
2604 : trolc5
set_abs zp1,$ff
> load_flag $ff
2604 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2606 : 48 > pha ;use stack to load status
2607 : b513 > lda zp1,x ;load to memory
2609 : 8d0302 > sta abst
260c : 28 > plp
260d : 2e0302 rol abst
tst_abs rROLc,fROLc,$ff-fnzc
2610 : 08 > php ;save flags
2611 : ad0302 > lda abst
2614 : dd1502 > cmp rROLc,x ;test result
> trap_ne
2617 : d0fe > bne * ;failed not equal (non zero)
>
2619 : 68 > pla ;load status
> eor_flag $ff-fnzc
261a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
261c : dd2502 > cmp fROLc,x ;test flags
> trap_ne
261f : d0fe > bne * ;failed not equal (non zero)
>
2621 : ca dex
2622 : 10e0 bpl trolc5
2624 : a203 ldx #3
2626 : tror4
set_abs zp1,0
> load_flag 0
2626 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2628 : 48 > pha ;use stack to load status
2629 : b513 > lda zp1,x ;load to memory
262b : 8d0302 > sta abst
262e : 28 > plp
262f : 6e0302 ror abst
tst_abs rROR,fROR,0
2632 : 08 > php ;save flags
2633 : ad0302 > lda abst
2636 : dd1902 > cmp rROR,x ;test result
> trap_ne
2639 : d0fe > bne * ;failed not equal (non zero)
>
263b : 68 > pla ;load status
> eor_flag 0
263c : 4930 > eor #0|fao ;invert expected flags + always on bits
>
263e : dd2902 > cmp fROR,x ;test flags
> trap_ne
2641 : d0fe > bne * ;failed not equal (non zero)
>
2643 : ca dex
2644 : 10e0 bpl tror4
2646 : a203 ldx #3
2648 : tror5
set_abs zp1,$ff-fc
> load_flag $ff-fc
2648 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
264a : 48 > pha ;use stack to load status
264b : b513 > lda zp1,x ;load to memory
264d : 8d0302 > sta abst
2650 : 28 > plp
2651 : 6e0302 ror abst
tst_abs rROR,fROR,$ff-fnzc
2654 : 08 > php ;save flags
2655 : ad0302 > lda abst
2658 : dd1902 > cmp rROR,x ;test result
> trap_ne
265b : d0fe > bne * ;failed not equal (non zero)
>
265d : 68 > pla ;load status
> eor_flag $ff-fnzc
265e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2660 : dd2902 > cmp fROR,x ;test flags
> trap_ne
2663 : d0fe > bne * ;failed not equal (non zero)
>
2665 : ca dex
2666 : 10e0 bpl tror5
2668 : a203 ldx #3
266a : trorc4
set_abs zp1,fc
> load_flag fc
266a : a901 > lda #fc ;allow test to change I-flag (no mask)
>
266c : 48 > pha ;use stack to load status
266d : b513 > lda zp1,x ;load to memory
266f : 8d0302 > sta abst
2672 : 28 > plp
2673 : 6e0302 ror abst
tst_abs rRORc,fRORc,0
2676 : 08 > php ;save flags
2677 : ad0302 > lda abst
267a : dd1d02 > cmp rRORc,x ;test result
> trap_ne
267d : d0fe > bne * ;failed not equal (non zero)
>
267f : 68 > pla ;load status
> eor_flag 0
2680 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2682 : dd2d02 > cmp fRORc,x ;test flags
> trap_ne
2685 : d0fe > bne * ;failed not equal (non zero)
>
2687 : ca dex
2688 : 10e0 bpl trorc4
268a : a203 ldx #3
268c : trorc5
set_abs zp1,$ff
> load_flag $ff
268c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
268e : 48 > pha ;use stack to load status
268f : b513 > lda zp1,x ;load to memory
2691 : 8d0302 > sta abst
2694 : 28 > plp
2695 : 6e0302 ror abst
tst_abs rRORc,fRORc,$ff-fnzc
2698 : 08 > php ;save flags
2699 : ad0302 > lda abst
269c : dd1d02 > cmp rRORc,x ;test result
> trap_ne
269f : d0fe > bne * ;failed not equal (non zero)
>
26a1 : 68 > pla ;load status
> eor_flag $ff-fnzc
26a2 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
26a4 : dd2d02 > cmp fRORc,x ;test flags
> trap_ne
26a7 : d0fe > bne * ;failed not equal (non zero)
>
26a9 : ca dex
26aa : 10e0 bpl trorc5
next_test
26ac : ad0002 > lda test_case ;previous test
26af : c91f > cmp #test_num
> trap_ne ;test is out of sequence
26b1 : d0fe > bne * ;failed not equal (non zero)
>
0020 = >test_num = test_num + 1
26b3 : a920 > lda #test_num ;*** next tests' number
26b5 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; shifts - zp indexed
26b8 : a203 ldx #3
26ba : tasl6
set_zx zp1,0
> load_flag 0
26ba : a900 > lda #0 ;allow test to change I-flag (no mask)
>
26bc : 48 > pha ;use stack to load status
26bd : b513 > lda zp1,x ;load to indexed zeropage
26bf : 950c > sta zpt,x
26c1 : 28 > plp
26c2 : 160c asl zpt,x
tst_zx rASL,fASL,0
26c4 : 08 > php ;save flags
26c5 : b50c > lda zpt,x
26c7 : dd1102 > cmp rASL,x ;test result
> trap_ne
26ca : d0fe > bne * ;failed not equal (non zero)
>
26cc : 68 > pla ;load status
> eor_flag 0
26cd : 4930 > eor #0|fao ;invert expected flags + always on bits
>
26cf : dd2102 > cmp fASL,x ;test flags
> trap_ne
26d2 : d0fe > bne * ;failed not equal (non zero)
>
26d4 : ca dex
26d5 : 10e3 bpl tasl6
26d7 : a203 ldx #3
26d9 : tasl7
set_zx zp1,$ff
> load_flag $ff
26d9 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
26db : 48 > pha ;use stack to load status
26dc : b513 > lda zp1,x ;load to indexed zeropage
26de : 950c > sta zpt,x
26e0 : 28 > plp
26e1 : 160c asl zpt,x
tst_zx rASL,fASL,$ff-fnzc
26e3 : 08 > php ;save flags
26e4 : b50c > lda zpt,x
26e6 : dd1102 > cmp rASL,x ;test result
> trap_ne
26e9 : d0fe > bne * ;failed not equal (non zero)
>
26eb : 68 > pla ;load status
> eor_flag $ff-fnzc
26ec : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
26ee : dd2102 > cmp fASL,x ;test flags
> trap_ne
26f1 : d0fe > bne * ;failed not equal (non zero)
>
26f3 : ca dex
26f4 : 10e3 bpl tasl7
26f6 : a203 ldx #3
26f8 : tlsr6
set_zx zp1,0
> load_flag 0
26f8 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
26fa : 48 > pha ;use stack to load status
26fb : b513 > lda zp1,x ;load to indexed zeropage
26fd : 950c > sta zpt,x
26ff : 28 > plp
2700 : 560c lsr zpt,x
tst_zx rLSR,fLSR,0
2702 : 08 > php ;save flags
2703 : b50c > lda zpt,x
2705 : dd1902 > cmp rLSR,x ;test result
> trap_ne
2708 : d0fe > bne * ;failed not equal (non zero)
>
270a : 68 > pla ;load status
> eor_flag 0
270b : 4930 > eor #0|fao ;invert expected flags + always on bits
>
270d : dd2902 > cmp fLSR,x ;test flags
> trap_ne
2710 : d0fe > bne * ;failed not equal (non zero)
>
2712 : ca dex
2713 : 10e3 bpl tlsr6
2715 : a203 ldx #3
2717 : tlsr7
set_zx zp1,$ff
> load_flag $ff
2717 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2719 : 48 > pha ;use stack to load status
271a : b513 > lda zp1,x ;load to indexed zeropage
271c : 950c > sta zpt,x
271e : 28 > plp
271f : 560c lsr zpt,x
tst_zx rLSR,fLSR,$ff-fnzc
2721 : 08 > php ;save flags
2722 : b50c > lda zpt,x
2724 : dd1902 > cmp rLSR,x ;test result
> trap_ne
2727 : d0fe > bne * ;failed not equal (non zero)
>
2729 : 68 > pla ;load status
> eor_flag $ff-fnzc
272a : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
272c : dd2902 > cmp fLSR,x ;test flags
> trap_ne
272f : d0fe > bne * ;failed not equal (non zero)
>
2731 : ca dex
2732 : 10e3 bpl tlsr7
2734 : a203 ldx #3
2736 : trol6
set_zx zp1,0
> load_flag 0
2736 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2738 : 48 > pha ;use stack to load status
2739 : b513 > lda zp1,x ;load to indexed zeropage
273b : 950c > sta zpt,x
273d : 28 > plp
273e : 360c rol zpt,x
tst_zx rROL,fROL,0
2740 : 08 > php ;save flags
2741 : b50c > lda zpt,x
2743 : dd1102 > cmp rROL,x ;test result
> trap_ne
2746 : d0fe > bne * ;failed not equal (non zero)
>
2748 : 68 > pla ;load status
> eor_flag 0
2749 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
274b : dd2102 > cmp fROL,x ;test flags
> trap_ne
274e : d0fe > bne * ;failed not equal (non zero)
>
2750 : ca dex
2751 : 10e3 bpl trol6
2753 : a203 ldx #3
2755 : trol7
set_zx zp1,$ff-fc
> load_flag $ff-fc
2755 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
2757 : 48 > pha ;use stack to load status
2758 : b513 > lda zp1,x ;load to indexed zeropage
275a : 950c > sta zpt,x
275c : 28 > plp
275d : 360c rol zpt,x
tst_zx rROL,fROL,$ff-fnzc
275f : 08 > php ;save flags
2760 : b50c > lda zpt,x
2762 : dd1102 > cmp rROL,x ;test result
> trap_ne
2765 : d0fe > bne * ;failed not equal (non zero)
>
2767 : 68 > pla ;load status
> eor_flag $ff-fnzc
2768 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
276a : dd2102 > cmp fROL,x ;test flags
> trap_ne
276d : d0fe > bne * ;failed not equal (non zero)
>
276f : ca dex
2770 : 10e3 bpl trol7
2772 : a203 ldx #3
2774 : trolc6
set_zx zp1,fc
> load_flag fc
2774 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2776 : 48 > pha ;use stack to load status
2777 : b513 > lda zp1,x ;load to indexed zeropage
2779 : 950c > sta zpt,x
277b : 28 > plp
277c : 360c rol zpt,x
tst_zx rROLc,fROLc,0
277e : 08 > php ;save flags
277f : b50c > lda zpt,x
2781 : dd1502 > cmp rROLc,x ;test result
> trap_ne
2784 : d0fe > bne * ;failed not equal (non zero)
>
2786 : 68 > pla ;load status
> eor_flag 0
2787 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2789 : dd2502 > cmp fROLc,x ;test flags
> trap_ne
278c : d0fe > bne * ;failed not equal (non zero)
>
278e : ca dex
278f : 10e3 bpl trolc6
2791 : a203 ldx #3
2793 : trolc7
set_zx zp1,$ff
> load_flag $ff
2793 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2795 : 48 > pha ;use stack to load status
2796 : b513 > lda zp1,x ;load to indexed zeropage
2798 : 950c > sta zpt,x
279a : 28 > plp
279b : 360c rol zpt,x
tst_zx rROLc,fROLc,$ff-fnzc
279d : 08 > php ;save flags
279e : b50c > lda zpt,x
27a0 : dd1502 > cmp rROLc,x ;test result
> trap_ne
27a3 : d0fe > bne * ;failed not equal (non zero)
>
27a5 : 68 > pla ;load status
> eor_flag $ff-fnzc
27a6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
27a8 : dd2502 > cmp fROLc,x ;test flags
> trap_ne
27ab : d0fe > bne * ;failed not equal (non zero)
>
27ad : ca dex
27ae : 10e3 bpl trolc7
27b0 : a203 ldx #3
27b2 : tror6
set_zx zp1,0
> load_flag 0
27b2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
27b4 : 48 > pha ;use stack to load status
27b5 : b513 > lda zp1,x ;load to indexed zeropage
27b7 : 950c > sta zpt,x
27b9 : 28 > plp
27ba : 760c ror zpt,x
tst_zx rROR,fROR,0
27bc : 08 > php ;save flags
27bd : b50c > lda zpt,x
27bf : dd1902 > cmp rROR,x ;test result
> trap_ne
27c2 : d0fe > bne * ;failed not equal (non zero)
>
27c4 : 68 > pla ;load status
> eor_flag 0
27c5 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
27c7 : dd2902 > cmp fROR,x ;test flags
> trap_ne
27ca : d0fe > bne * ;failed not equal (non zero)
>
27cc : ca dex
27cd : 10e3 bpl tror6
27cf : a203 ldx #3
27d1 : tror7
set_zx zp1,$ff-fc
> load_flag $ff-fc
27d1 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
27d3 : 48 > pha ;use stack to load status
27d4 : b513 > lda zp1,x ;load to indexed zeropage
27d6 : 950c > sta zpt,x
27d8 : 28 > plp
27d9 : 760c ror zpt,x
tst_zx rROR,fROR,$ff-fnzc
27db : 08 > php ;save flags
27dc : b50c > lda zpt,x
27de : dd1902 > cmp rROR,x ;test result
> trap_ne
27e1 : d0fe > bne * ;failed not equal (non zero)
>
27e3 : 68 > pla ;load status
> eor_flag $ff-fnzc
27e4 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
27e6 : dd2902 > cmp fROR,x ;test flags
> trap_ne
27e9 : d0fe > bne * ;failed not equal (non zero)
>
27eb : ca dex
27ec : 10e3 bpl tror7
27ee : a203 ldx #3
27f0 : trorc6
set_zx zp1,fc
> load_flag fc
27f0 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
27f2 : 48 > pha ;use stack to load status
27f3 : b513 > lda zp1,x ;load to indexed zeropage
27f5 : 950c > sta zpt,x
27f7 : 28 > plp
27f8 : 760c ror zpt,x
tst_zx rRORc,fRORc,0
27fa : 08 > php ;save flags
27fb : b50c > lda zpt,x
27fd : dd1d02 > cmp rRORc,x ;test result
> trap_ne
2800 : d0fe > bne * ;failed not equal (non zero)
>
2802 : 68 > pla ;load status
> eor_flag 0
2803 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2805 : dd2d02 > cmp fRORc,x ;test flags
> trap_ne
2808 : d0fe > bne * ;failed not equal (non zero)
>
280a : ca dex
280b : 10e3 bpl trorc6
280d : a203 ldx #3
280f : trorc7
set_zx zp1,$ff
> load_flag $ff
280f : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2811 : 48 > pha ;use stack to load status
2812 : b513 > lda zp1,x ;load to indexed zeropage
2814 : 950c > sta zpt,x
2816 : 28 > plp
2817 : 760c ror zpt,x
tst_zx rRORc,fRORc,$ff-fnzc
2819 : 08 > php ;save flags
281a : b50c > lda zpt,x
281c : dd1d02 > cmp rRORc,x ;test result
> trap_ne
281f : d0fe > bne * ;failed not equal (non zero)
>
2821 : 68 > pla ;load status
> eor_flag $ff-fnzc
2822 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2824 : dd2d02 > cmp fRORc,x ;test flags
> trap_ne
2827 : d0fe > bne * ;failed not equal (non zero)
>
2829 : ca dex
282a : 10e3 bpl trorc7
next_test
282c : ad0002 > lda test_case ;previous test
282f : c920 > cmp #test_num
> trap_ne ;test is out of sequence
2831 : d0fe > bne * ;failed not equal (non zero)
>
0021 = >test_num = test_num + 1
2833 : a921 > lda #test_num ;*** next tests' number
2835 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; shifts - abs indexed
2838 : a203 ldx #3
283a : tasl8
set_absx zp1,0
> load_flag 0
283a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
283c : 48 > pha ;use stack to load status
283d : b513 > lda zp1,x ;load to indexed memory
283f : 9d0302 > sta abst,x
2842 : 28 > plp
2843 : 1e0302 asl abst,x
tst_absx rASL,fASL,0
2846 : 08 > php ;save flags
2847 : bd0302 > lda abst,x
284a : dd1102 > cmp rASL,x ;test result
> trap_ne
284d : d0fe > bne * ;failed not equal (non zero)
>
284f : 68 > pla ;load status
> eor_flag 0
2850 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2852 : dd2102 > cmp fASL,x ;test flags
> trap_ne
2855 : d0fe > bne * ;failed not equal (non zero)
>
2857 : ca dex
2858 : 10e0 bpl tasl8
285a : a203 ldx #3
285c : tasl9
set_absx zp1,$ff
> load_flag $ff
285c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
285e : 48 > pha ;use stack to load status
285f : b513 > lda zp1,x ;load to indexed memory
2861 : 9d0302 > sta abst,x
2864 : 28 > plp
2865 : 1e0302 asl abst,x
tst_absx rASL,fASL,$ff-fnzc
2868 : 08 > php ;save flags
2869 : bd0302 > lda abst,x
286c : dd1102 > cmp rASL,x ;test result
> trap_ne
286f : d0fe > bne * ;failed not equal (non zero)
>
2871 : 68 > pla ;load status
> eor_flag $ff-fnzc
2872 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2874 : dd2102 > cmp fASL,x ;test flags
> trap_ne
2877 : d0fe > bne * ;failed not equal (non zero)
>
2879 : ca dex
287a : 10e0 bpl tasl9
287c : a203 ldx #3
287e : tlsr8
set_absx zp1,0
> load_flag 0
287e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2880 : 48 > pha ;use stack to load status
2881 : b513 > lda zp1,x ;load to indexed memory
2883 : 9d0302 > sta abst,x
2886 : 28 > plp
2887 : 5e0302 lsr abst,x
tst_absx rLSR,fLSR,0
288a : 08 > php ;save flags
288b : bd0302 > lda abst,x
288e : dd1902 > cmp rLSR,x ;test result
> trap_ne
2891 : d0fe > bne * ;failed not equal (non zero)
>
2893 : 68 > pla ;load status
> eor_flag 0
2894 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2896 : dd2902 > cmp fLSR,x ;test flags
> trap_ne
2899 : d0fe > bne * ;failed not equal (non zero)
>
289b : ca dex
289c : 10e0 bpl tlsr8
289e : a203 ldx #3
28a0 : tlsr9
set_absx zp1,$ff
> load_flag $ff
28a0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
28a2 : 48 > pha ;use stack to load status
28a3 : b513 > lda zp1,x ;load to indexed memory
28a5 : 9d0302 > sta abst,x
28a8 : 28 > plp
28a9 : 5e0302 lsr abst,x
tst_absx rLSR,fLSR,$ff-fnzc
28ac : 08 > php ;save flags
28ad : bd0302 > lda abst,x
28b0 : dd1902 > cmp rLSR,x ;test result
> trap_ne
28b3 : d0fe > bne * ;failed not equal (non zero)
>
28b5 : 68 > pla ;load status
> eor_flag $ff-fnzc
28b6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
28b8 : dd2902 > cmp fLSR,x ;test flags
> trap_ne
28bb : d0fe > bne * ;failed not equal (non zero)
>
28bd : ca dex
28be : 10e0 bpl tlsr9
28c0 : a203 ldx #3
28c2 : trol8
set_absx zp1,0
> load_flag 0
28c2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
28c4 : 48 > pha ;use stack to load status
28c5 : b513 > lda zp1,x ;load to indexed memory
28c7 : 9d0302 > sta abst,x
28ca : 28 > plp
28cb : 3e0302 rol abst,x
tst_absx rROL,fROL,0
28ce : 08 > php ;save flags
28cf : bd0302 > lda abst,x
28d2 : dd1102 > cmp rROL,x ;test result
> trap_ne
28d5 : d0fe > bne * ;failed not equal (non zero)
>
28d7 : 68 > pla ;load status
> eor_flag 0
28d8 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
28da : dd2102 > cmp fROL,x ;test flags
> trap_ne
28dd : d0fe > bne * ;failed not equal (non zero)
>
28df : ca dex
28e0 : 10e0 bpl trol8
28e2 : a203 ldx #3
28e4 : trol9
set_absx zp1,$ff-fc
> load_flag $ff-fc
28e4 : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
28e6 : 48 > pha ;use stack to load status
28e7 : b513 > lda zp1,x ;load to indexed memory
28e9 : 9d0302 > sta abst,x
28ec : 28 > plp
28ed : 3e0302 rol abst,x
tst_absx rROL,fROL,$ff-fnzc
28f0 : 08 > php ;save flags
28f1 : bd0302 > lda abst,x
28f4 : dd1102 > cmp rROL,x ;test result
> trap_ne
28f7 : d0fe > bne * ;failed not equal (non zero)
>
28f9 : 68 > pla ;load status
> eor_flag $ff-fnzc
28fa : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
28fc : dd2102 > cmp fROL,x ;test flags
> trap_ne
28ff : d0fe > bne * ;failed not equal (non zero)
>
2901 : ca dex
2902 : 10e0 bpl trol9
2904 : a203 ldx #3
2906 : trolc8
set_absx zp1,fc
> load_flag fc
2906 : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2908 : 48 > pha ;use stack to load status
2909 : b513 > lda zp1,x ;load to indexed memory
290b : 9d0302 > sta abst,x
290e : 28 > plp
290f : 3e0302 rol abst,x
tst_absx rROLc,fROLc,0
2912 : 08 > php ;save flags
2913 : bd0302 > lda abst,x
2916 : dd1502 > cmp rROLc,x ;test result
> trap_ne
2919 : d0fe > bne * ;failed not equal (non zero)
>
291b : 68 > pla ;load status
> eor_flag 0
291c : 4930 > eor #0|fao ;invert expected flags + always on bits
>
291e : dd2502 > cmp fROLc,x ;test flags
> trap_ne
2921 : d0fe > bne * ;failed not equal (non zero)
>
2923 : ca dex
2924 : 10e0 bpl trolc8
2926 : a203 ldx #3
2928 : trolc9
set_absx zp1,$ff
> load_flag $ff
2928 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
292a : 48 > pha ;use stack to load status
292b : b513 > lda zp1,x ;load to indexed memory
292d : 9d0302 > sta abst,x
2930 : 28 > plp
2931 : 3e0302 rol abst,x
tst_absx rROLc,fROLc,$ff-fnzc
2934 : 08 > php ;save flags
2935 : bd0302 > lda abst,x
2938 : dd1502 > cmp rROLc,x ;test result
> trap_ne
293b : d0fe > bne * ;failed not equal (non zero)
>
293d : 68 > pla ;load status
> eor_flag $ff-fnzc
293e : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2940 : dd2502 > cmp fROLc,x ;test flags
> trap_ne
2943 : d0fe > bne * ;failed not equal (non zero)
>
2945 : ca dex
2946 : 10e0 bpl trolc9
2948 : a203 ldx #3
294a : tror8
set_absx zp1,0
> load_flag 0
294a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
294c : 48 > pha ;use stack to load status
294d : b513 > lda zp1,x ;load to indexed memory
294f : 9d0302 > sta abst,x
2952 : 28 > plp
2953 : 7e0302 ror abst,x
tst_absx rROR,fROR,0
2956 : 08 > php ;save flags
2957 : bd0302 > lda abst,x
295a : dd1902 > cmp rROR,x ;test result
> trap_ne
295d : d0fe > bne * ;failed not equal (non zero)
>
295f : 68 > pla ;load status
> eor_flag 0
2960 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2962 : dd2902 > cmp fROR,x ;test flags
> trap_ne
2965 : d0fe > bne * ;failed not equal (non zero)
>
2967 : ca dex
2968 : 10e0 bpl tror8
296a : a203 ldx #3
296c : tror9
set_absx zp1,$ff-fc
> load_flag $ff-fc
296c : a9fe > lda #$ff-fc ;allow test to change I-flag (no mask)
>
296e : 48 > pha ;use stack to load status
296f : b513 > lda zp1,x ;load to indexed memory
2971 : 9d0302 > sta abst,x
2974 : 28 > plp
2975 : 7e0302 ror abst,x
tst_absx rROR,fROR,$ff-fnzc
2978 : 08 > php ;save flags
2979 : bd0302 > lda abst,x
297c : dd1902 > cmp rROR,x ;test result
> trap_ne
297f : d0fe > bne * ;failed not equal (non zero)
>
2981 : 68 > pla ;load status
> eor_flag $ff-fnzc
2982 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
2984 : dd2902 > cmp fROR,x ;test flags
> trap_ne
2987 : d0fe > bne * ;failed not equal (non zero)
>
2989 : ca dex
298a : 10e0 bpl tror9
298c : a203 ldx #3
298e : trorc8
set_absx zp1,fc
> load_flag fc
298e : a901 > lda #fc ;allow test to change I-flag (no mask)
>
2990 : 48 > pha ;use stack to load status
2991 : b513 > lda zp1,x ;load to indexed memory
2993 : 9d0302 > sta abst,x
2996 : 28 > plp
2997 : 7e0302 ror abst,x
tst_absx rRORc,fRORc,0
299a : 08 > php ;save flags
299b : bd0302 > lda abst,x
299e : dd1d02 > cmp rRORc,x ;test result
> trap_ne
29a1 : d0fe > bne * ;failed not equal (non zero)
>
29a3 : 68 > pla ;load status
> eor_flag 0
29a4 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
29a6 : dd2d02 > cmp fRORc,x ;test flags
> trap_ne
29a9 : d0fe > bne * ;failed not equal (non zero)
>
29ab : ca dex
29ac : 10e0 bpl trorc8
29ae : a203 ldx #3
29b0 : trorc9
set_absx zp1,$ff
> load_flag $ff
29b0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
29b2 : 48 > pha ;use stack to load status
29b3 : b513 > lda zp1,x ;load to indexed memory
29b5 : 9d0302 > sta abst,x
29b8 : 28 > plp
29b9 : 7e0302 ror abst,x
tst_absx rRORc,fRORc,$ff-fnzc
29bc : 08 > php ;save flags
29bd : bd0302 > lda abst,x
29c0 : dd1d02 > cmp rRORc,x ;test result
> trap_ne
29c3 : d0fe > bne * ;failed not equal (non zero)
>
29c5 : 68 > pla ;load status
> eor_flag $ff-fnzc
29c6 : 497c > eor #$ff-fnzc|fao ;invert expected flags + always on bits
>
29c8 : dd2d02 > cmp fRORc,x ;test flags
> trap_ne
29cb : d0fe > bne * ;failed not equal (non zero)
>
29cd : ca dex
29ce : 10e0 bpl trorc9
next_test
29d0 : ad0002 > lda test_case ;previous test
29d3 : c921 > cmp #test_num
> trap_ne ;test is out of sequence
29d5 : d0fe > bne * ;failed not equal (non zero)
>
0022 = >test_num = test_num + 1
29d7 : a922 > lda #test_num ;*** next tests' number
29d9 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing memory increment/decrement - INC DEC all addressing modes
; zeropage
29dc : a200 ldx #0
29de : a97e lda #$7e
29e0 : 850c sta zpt
29e2 : tinc
set_stat 0
> load_flag 0
29e2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
29e4 : 48 > pha ;use stack to load status
29e5 : 28 > plp
29e6 : e60c inc zpt
tst_z rINC,fINC,0
29e8 : 08 > php ;save flags
29e9 : a50c > lda zpt
29eb : dd3102 > cmp rINC,x ;test result
> trap_ne
29ee : d0fe > bne * ;failed not equal (non zero)
>
29f0 : 68 > pla ;load status
> eor_flag 0
29f1 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
29f3 : dd3602 > cmp fINC,x ;test flags
> trap_ne
29f6 : d0fe > bne * ;failed not equal (non zero)
>
29f8 : e8 inx
29f9 : e002 cpx #2
29fb : d004 bne tinc1
29fd : a9fe lda #$fe
29ff : 850c sta zpt
2a01 : e005 tinc1 cpx #5
2a03 : d0dd bne tinc
2a05 : ca dex
2a06 : e60c inc zpt
2a08 : tdec
set_stat 0
> load_flag 0
2a08 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2a0a : 48 > pha ;use stack to load status
2a0b : 28 > plp
2a0c : c60c dec zpt
tst_z rINC,fINC,0
2a0e : 08 > php ;save flags
2a0f : a50c > lda zpt
2a11 : dd3102 > cmp rINC,x ;test result
> trap_ne
2a14 : d0fe > bne * ;failed not equal (non zero)
>
2a16 : 68 > pla ;load status
> eor_flag 0
2a17 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2a19 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2a1c : d0fe > bne * ;failed not equal (non zero)
>
2a1e : ca dex
2a1f : 300a bmi tdec1
2a21 : e001 cpx #1
2a23 : d0e3 bne tdec
2a25 : a981 lda #$81
2a27 : 850c sta zpt
2a29 : d0dd bne tdec
2a2b : tdec1
2a2b : a200 ldx #0
2a2d : a97e lda #$7e
2a2f : 850c sta zpt
2a31 : tinc10
set_stat $ff
> load_flag $ff
2a31 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2a33 : 48 > pha ;use stack to load status
2a34 : 28 > plp
2a35 : e60c inc zpt
tst_z rINC,fINC,$ff-fnz
2a37 : 08 > php ;save flags
2a38 : a50c > lda zpt
2a3a : dd3102 > cmp rINC,x ;test result
> trap_ne
2a3d : d0fe > bne * ;failed not equal (non zero)
>
2a3f : 68 > pla ;load status
> eor_flag $ff-fnz
2a40 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2a42 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2a45 : d0fe > bne * ;failed not equal (non zero)
>
2a47 : e8 inx
2a48 : e002 cpx #2
2a4a : d004 bne tinc11
2a4c : a9fe lda #$fe
2a4e : 850c sta zpt
2a50 : e005 tinc11 cpx #5
2a52 : d0dd bne tinc10
2a54 : ca dex
2a55 : e60c inc zpt
2a57 : tdec10
set_stat $ff
> load_flag $ff
2a57 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2a59 : 48 > pha ;use stack to load status
2a5a : 28 > plp
2a5b : c60c dec zpt
tst_z rINC,fINC,$ff-fnz
2a5d : 08 > php ;save flags
2a5e : a50c > lda zpt
2a60 : dd3102 > cmp rINC,x ;test result
> trap_ne
2a63 : d0fe > bne * ;failed not equal (non zero)
>
2a65 : 68 > pla ;load status
> eor_flag $ff-fnz
2a66 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2a68 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2a6b : d0fe > bne * ;failed not equal (non zero)
>
2a6d : ca dex
2a6e : 300a bmi tdec11
2a70 : e001 cpx #1
2a72 : d0e3 bne tdec10
2a74 : a981 lda #$81
2a76 : 850c sta zpt
2a78 : d0dd bne tdec10
2a7a : tdec11
next_test
2a7a : ad0002 > lda test_case ;previous test
2a7d : c922 > cmp #test_num
> trap_ne ;test is out of sequence
2a7f : d0fe > bne * ;failed not equal (non zero)
>
0023 = >test_num = test_num + 1
2a81 : a923 > lda #test_num ;*** next tests' number
2a83 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; absolute memory
2a86 : a200 ldx #0
2a88 : a97e lda #$7e
2a8a : 8d0302 sta abst
2a8d : tinc2
set_stat 0
> load_flag 0
2a8d : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2a8f : 48 > pha ;use stack to load status
2a90 : 28 > plp
2a91 : ee0302 inc abst
tst_abs rINC,fINC,0
2a94 : 08 > php ;save flags
2a95 : ad0302 > lda abst
2a98 : dd3102 > cmp rINC,x ;test result
> trap_ne
2a9b : d0fe > bne * ;failed not equal (non zero)
>
2a9d : 68 > pla ;load status
> eor_flag 0
2a9e : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2aa0 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2aa3 : d0fe > bne * ;failed not equal (non zero)
>
2aa5 : e8 inx
2aa6 : e002 cpx #2
2aa8 : d005 bne tinc3
2aaa : a9fe lda #$fe
2aac : 8d0302 sta abst
2aaf : e005 tinc3 cpx #5
2ab1 : d0da bne tinc2
2ab3 : ca dex
2ab4 : ee0302 inc abst
2ab7 : tdec2
set_stat 0
> load_flag 0
2ab7 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2ab9 : 48 > pha ;use stack to load status
2aba : 28 > plp
2abb : ce0302 dec abst
tst_abs rINC,fINC,0
2abe : 08 > php ;save flags
2abf : ad0302 > lda abst
2ac2 : dd3102 > cmp rINC,x ;test result
> trap_ne
2ac5 : d0fe > bne * ;failed not equal (non zero)
>
2ac7 : 68 > pla ;load status
> eor_flag 0
2ac8 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2aca : dd3602 > cmp fINC,x ;test flags
> trap_ne
2acd : d0fe > bne * ;failed not equal (non zero)
>
2acf : ca dex
2ad0 : 300b bmi tdec3
2ad2 : e001 cpx #1
2ad4 : d0e1 bne tdec2
2ad6 : a981 lda #$81
2ad8 : 8d0302 sta abst
2adb : d0da bne tdec2
2add : tdec3
2add : a200 ldx #0
2adf : a97e lda #$7e
2ae1 : 8d0302 sta abst
2ae4 : tinc12
set_stat $ff
> load_flag $ff
2ae4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2ae6 : 48 > pha ;use stack to load status
2ae7 : 28 > plp
2ae8 : ee0302 inc abst
tst_abs rINC,fINC,$ff-fnz
2aeb : 08 > php ;save flags
2aec : ad0302 > lda abst
2aef : dd3102 > cmp rINC,x ;test result
> trap_ne
2af2 : d0fe > bne * ;failed not equal (non zero)
>
2af4 : 68 > pla ;load status
> eor_flag $ff-fnz
2af5 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2af7 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2afa : d0fe > bne * ;failed not equal (non zero)
>
2afc : e8 inx
2afd : e002 cpx #2
2aff : d005 bne tinc13
2b01 : a9fe lda #$fe
2b03 : 8d0302 sta abst
2b06 : e005 tinc13 cpx #5
2b08 : d0da bne tinc12
2b0a : ca dex
2b0b : ee0302 inc abst
2b0e : tdec12
set_stat $ff
> load_flag $ff
2b0e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2b10 : 48 > pha ;use stack to load status
2b11 : 28 > plp
2b12 : ce0302 dec abst
tst_abs rINC,fINC,$ff-fnz
2b15 : 08 > php ;save flags
2b16 : ad0302 > lda abst
2b19 : dd3102 > cmp rINC,x ;test result
> trap_ne
2b1c : d0fe > bne * ;failed not equal (non zero)
>
2b1e : 68 > pla ;load status
> eor_flag $ff-fnz
2b1f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2b21 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2b24 : d0fe > bne * ;failed not equal (non zero)
>
2b26 : ca dex
2b27 : 300b bmi tdec13
2b29 : e001 cpx #1
2b2b : d0e1 bne tdec12
2b2d : a981 lda #$81
2b2f : 8d0302 sta abst
2b32 : d0da bne tdec12
2b34 : tdec13
next_test
2b34 : ad0002 > lda test_case ;previous test
2b37 : c923 > cmp #test_num
> trap_ne ;test is out of sequence
2b39 : d0fe > bne * ;failed not equal (non zero)
>
0024 = >test_num = test_num + 1
2b3b : a924 > lda #test_num ;*** next tests' number
2b3d : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; zeropage indexed
2b40 : a200 ldx #0
2b42 : a97e lda #$7e
2b44 : 950c tinc4 sta zpt,x
set_stat 0
> load_flag 0
2b46 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2b48 : 48 > pha ;use stack to load status
2b49 : 28 > plp
2b4a : f60c inc zpt,x
tst_zx rINC,fINC,0
2b4c : 08 > php ;save flags
2b4d : b50c > lda zpt,x
2b4f : dd3102 > cmp rINC,x ;test result
> trap_ne
2b52 : d0fe > bne * ;failed not equal (non zero)
>
2b54 : 68 > pla ;load status
> eor_flag 0
2b55 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2b57 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2b5a : d0fe > bne * ;failed not equal (non zero)
>
2b5c : b50c lda zpt,x
2b5e : e8 inx
2b5f : e002 cpx #2
2b61 : d002 bne tinc5
2b63 : a9fe lda #$fe
2b65 : e005 tinc5 cpx #5
2b67 : d0db bne tinc4
2b69 : ca dex
2b6a : a902 lda #2
2b6c : 950c tdec4 sta zpt,x
set_stat 0
> load_flag 0
2b6e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2b70 : 48 > pha ;use stack to load status
2b71 : 28 > plp
2b72 : d60c dec zpt,x
tst_zx rINC,fINC,0
2b74 : 08 > php ;save flags
2b75 : b50c > lda zpt,x
2b77 : dd3102 > cmp rINC,x ;test result
> trap_ne
2b7a : d0fe > bne * ;failed not equal (non zero)
>
2b7c : 68 > pla ;load status
> eor_flag 0
2b7d : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2b7f : dd3602 > cmp fINC,x ;test flags
> trap_ne
2b82 : d0fe > bne * ;failed not equal (non zero)
>
2b84 : b50c lda zpt,x
2b86 : ca dex
2b87 : 3008 bmi tdec5
2b89 : e001 cpx #1
2b8b : d0df bne tdec4
2b8d : a981 lda #$81
2b8f : d0db bne tdec4
2b91 : tdec5
2b91 : a200 ldx #0
2b93 : a97e lda #$7e
2b95 : 950c tinc14 sta zpt,x
set_stat $ff
> load_flag $ff
2b97 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2b99 : 48 > pha ;use stack to load status
2b9a : 28 > plp
2b9b : f60c inc zpt,x
tst_zx rINC,fINC,$ff-fnz
2b9d : 08 > php ;save flags
2b9e : b50c > lda zpt,x
2ba0 : dd3102 > cmp rINC,x ;test result
> trap_ne
2ba3 : d0fe > bne * ;failed not equal (non zero)
>
2ba5 : 68 > pla ;load status
> eor_flag $ff-fnz
2ba6 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2ba8 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2bab : d0fe > bne * ;failed not equal (non zero)
>
2bad : b50c lda zpt,x
2baf : e8 inx
2bb0 : e002 cpx #2
2bb2 : d002 bne tinc15
2bb4 : a9fe lda #$fe
2bb6 : e005 tinc15 cpx #5
2bb8 : d0db bne tinc14
2bba : ca dex
2bbb : a902 lda #2
2bbd : 950c tdec14 sta zpt,x
set_stat $ff
> load_flag $ff
2bbf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2bc1 : 48 > pha ;use stack to load status
2bc2 : 28 > plp
2bc3 : d60c dec zpt,x
tst_zx rINC,fINC,$ff-fnz
2bc5 : 08 > php ;save flags
2bc6 : b50c > lda zpt,x
2bc8 : dd3102 > cmp rINC,x ;test result
> trap_ne
2bcb : d0fe > bne * ;failed not equal (non zero)
>
2bcd : 68 > pla ;load status
> eor_flag $ff-fnz
2bce : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2bd0 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2bd3 : d0fe > bne * ;failed not equal (non zero)
>
2bd5 : b50c lda zpt,x
2bd7 : ca dex
2bd8 : 3008 bmi tdec15
2bda : e001 cpx #1
2bdc : d0df bne tdec14
2bde : a981 lda #$81
2be0 : d0db bne tdec14
2be2 : tdec15
next_test
2be2 : ad0002 > lda test_case ;previous test
2be5 : c924 > cmp #test_num
> trap_ne ;test is out of sequence
2be7 : d0fe > bne * ;failed not equal (non zero)
>
0025 = >test_num = test_num + 1
2be9 : a925 > lda #test_num ;*** next tests' number
2beb : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; memory indexed
2bee : a200 ldx #0
2bf0 : a97e lda #$7e
2bf2 : 9d0302 tinc6 sta abst,x
set_stat 0
> load_flag 0
2bf5 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2bf7 : 48 > pha ;use stack to load status
2bf8 : 28 > plp
2bf9 : fe0302 inc abst,x
tst_absx rINC,fINC,0
2bfc : 08 > php ;save flags
2bfd : bd0302 > lda abst,x
2c00 : dd3102 > cmp rINC,x ;test result
> trap_ne
2c03 : d0fe > bne * ;failed not equal (non zero)
>
2c05 : 68 > pla ;load status
> eor_flag 0
2c06 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2c08 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2c0b : d0fe > bne * ;failed not equal (non zero)
>
2c0d : bd0302 lda abst,x
2c10 : e8 inx
2c11 : e002 cpx #2
2c13 : d002 bne tinc7
2c15 : a9fe lda #$fe
2c17 : e005 tinc7 cpx #5
2c19 : d0d7 bne tinc6
2c1b : ca dex
2c1c : a902 lda #2
2c1e : 9d0302 tdec6 sta abst,x
set_stat 0
> load_flag 0
2c21 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2c23 : 48 > pha ;use stack to load status
2c24 : 28 > plp
2c25 : de0302 dec abst,x
tst_absx rINC,fINC,0
2c28 : 08 > php ;save flags
2c29 : bd0302 > lda abst,x
2c2c : dd3102 > cmp rINC,x ;test result
> trap_ne
2c2f : d0fe > bne * ;failed not equal (non zero)
>
2c31 : 68 > pla ;load status
> eor_flag 0
2c32 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2c34 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2c37 : d0fe > bne * ;failed not equal (non zero)
>
2c39 : bd0302 lda abst,x
2c3c : ca dex
2c3d : 3008 bmi tdec7
2c3f : e001 cpx #1
2c41 : d0db bne tdec6
2c43 : a981 lda #$81
2c45 : d0d7 bne tdec6
2c47 : tdec7
2c47 : a200 ldx #0
2c49 : a97e lda #$7e
2c4b : 9d0302 tinc16 sta abst,x
set_stat $ff
> load_flag $ff
2c4e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2c50 : 48 > pha ;use stack to load status
2c51 : 28 > plp
2c52 : fe0302 inc abst,x
tst_absx rINC,fINC,$ff-fnz
2c55 : 08 > php ;save flags
2c56 : bd0302 > lda abst,x
2c59 : dd3102 > cmp rINC,x ;test result
> trap_ne
2c5c : d0fe > bne * ;failed not equal (non zero)
>
2c5e : 68 > pla ;load status
> eor_flag $ff-fnz
2c5f : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2c61 : dd3602 > cmp fINC,x ;test flags
> trap_ne
2c64 : d0fe > bne * ;failed not equal (non zero)
>
2c66 : bd0302 lda abst,x
2c69 : e8 inx
2c6a : e002 cpx #2
2c6c : d002 bne tinc17
2c6e : a9fe lda #$fe
2c70 : e005 tinc17 cpx #5
2c72 : d0d7 bne tinc16
2c74 : ca dex
2c75 : a902 lda #2
2c77 : 9d0302 tdec16 sta abst,x
set_stat $ff
> load_flag $ff
2c7a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2c7c : 48 > pha ;use stack to load status
2c7d : 28 > plp
2c7e : de0302 dec abst,x
tst_absx rINC,fINC,$ff-fnz
2c81 : 08 > php ;save flags
2c82 : bd0302 > lda abst,x
2c85 : dd3102 > cmp rINC,x ;test result
> trap_ne
2c88 : d0fe > bne * ;failed not equal (non zero)
>
2c8a : 68 > pla ;load status
> eor_flag $ff-fnz
2c8b : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2c8d : dd3602 > cmp fINC,x ;test flags
> trap_ne
2c90 : d0fe > bne * ;failed not equal (non zero)
>
2c92 : bd0302 lda abst,x
2c95 : ca dex
2c96 : 3008 bmi tdec17
2c98 : e001 cpx #1
2c9a : d0db bne tdec16
2c9c : a981 lda #$81
2c9e : d0d7 bne tdec16
2ca0 : tdec17
next_test
2ca0 : ad0002 > lda test_case ;previous test
2ca3 : c925 > cmp #test_num
> trap_ne ;test is out of sequence
2ca5 : d0fe > bne * ;failed not equal (non zero)
>
0026 = >test_num = test_num + 1
2ca7 : a926 > lda #test_num ;*** next tests' number
2ca9 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; testing logical instructions - AND EOR ORA all addressing modes
; AND
2cac : a203 ldx #3 ;immediate - self modifying code
2cae : b51c tand lda zpAN,x
2cb0 : 8dbb2c sta tandi1
set_ax absANa,0
> load_flag 0
2cb3 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2cb5 : 48 > pha ;use stack to load status
2cb6 : bd4b02 > lda absANa,x ;precharge accu
2cb9 : 28 > plp
2cbb = tandi1 equ *+1 ;target for immediate operand
2cba : 2963 and #99
tst_ax absrlo,absflo,0
2cbc : 08 > php ;save flags
2cbd : dd5302 > cmp absrlo,x ;test result
> trap_ne
2cc0 : d0fe > bne * ;failed not equal (non zero)
>
2cc2 : 68 > pla ;load status
> eor_flag 0
2cc3 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2cc5 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2cc8 : d0fe > bne * ;failed not equal (non zero)
>
2cca : ca dex
2ccb : 10e1 bpl tand
2ccd : a203 ldx #3
2ccf : b51c tand1 lda zpAN,x
2cd1 : 8ddc2c sta tandi2
set_ax absANa,$ff
> load_flag $ff
2cd4 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2cd6 : 48 > pha ;use stack to load status
2cd7 : bd4b02 > lda absANa,x ;precharge accu
2cda : 28 > plp
2cdc = tandi2 equ *+1 ;target for immediate operand
2cdb : 2963 and #99
tst_ax absrlo,absflo,$ff-fnz
2cdd : 08 > php ;save flags
2cde : dd5302 > cmp absrlo,x ;test result
> trap_ne
2ce1 : d0fe > bne * ;failed not equal (non zero)
>
2ce3 : 68 > pla ;load status
> eor_flag $ff-fnz
2ce4 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2ce6 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2ce9 : d0fe > bne * ;failed not equal (non zero)
>
2ceb : ca dex
2cec : 10e1 bpl tand1
2cee : a203 ldx #3 ;zp
2cf0 : b51c tand2 lda zpAN,x
2cf2 : 850c sta zpt
set_ax absANa,0
> load_flag 0
2cf4 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2cf6 : 48 > pha ;use stack to load status
2cf7 : bd4b02 > lda absANa,x ;precharge accu
2cfa : 28 > plp
2cfb : 250c and zpt
tst_ax absrlo,absflo,0
2cfd : 08 > php ;save flags
2cfe : dd5302 > cmp absrlo,x ;test result
> trap_ne
2d01 : d0fe > bne * ;failed not equal (non zero)
>
2d03 : 68 > pla ;load status
> eor_flag 0
2d04 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2d06 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2d09 : d0fe > bne * ;failed not equal (non zero)
>
2d0b : ca dex
2d0c : 10e2 bpl tand2
2d0e : a203 ldx #3
2d10 : b51c tand3 lda zpAN,x
2d12 : 850c sta zpt
set_ax absANa,$ff
> load_flag $ff
2d14 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2d16 : 48 > pha ;use stack to load status
2d17 : bd4b02 > lda absANa,x ;precharge accu
2d1a : 28 > plp
2d1b : 250c and zpt
tst_ax absrlo,absflo,$ff-fnz
2d1d : 08 > php ;save flags
2d1e : dd5302 > cmp absrlo,x ;test result
> trap_ne
2d21 : d0fe > bne * ;failed not equal (non zero)
>
2d23 : 68 > pla ;load status
> eor_flag $ff-fnz
2d24 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2d26 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2d29 : d0fe > bne * ;failed not equal (non zero)
>
2d2b : ca dex
2d2c : 10e2 bpl tand3
2d2e : a203 ldx #3 ;abs
2d30 : b51c tand4 lda zpAN,x
2d32 : 8d0302 sta abst
set_ax absANa,0
> load_flag 0
2d35 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2d37 : 48 > pha ;use stack to load status
2d38 : bd4b02 > lda absANa,x ;precharge accu
2d3b : 28 > plp
2d3c : 2d0302 and abst
tst_ax absrlo,absflo,0
2d3f : 08 > php ;save flags
2d40 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2d43 : d0fe > bne * ;failed not equal (non zero)
>
2d45 : 68 > pla ;load status
> eor_flag 0
2d46 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2d48 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2d4b : d0fe > bne * ;failed not equal (non zero)
>
2d4d : ca dex
2d4e : 10e0 bpl tand4
2d50 : a203 ldx #3
2d52 : b51c tand5 lda zpAN,x
2d54 : 8d0302 sta abst
set_ax absANa,$ff
> load_flag $ff
2d57 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2d59 : 48 > pha ;use stack to load status
2d5a : bd4b02 > lda absANa,x ;precharge accu
2d5d : 28 > plp
2d5e : 2d0302 and abst
tst_ax absrlo,absflo,$ff-fnz
2d61 : 08 > php ;save flags
2d62 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2d65 : d0fe > bne * ;failed not equal (non zero)
>
2d67 : 68 > pla ;load status
> eor_flag $ff-fnz
2d68 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2d6a : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2d6d : d0fe > bne * ;failed not equal (non zero)
>
2d6f : ca dex
2d70 : 1002 bpl tand6
2d72 : a203 ldx #3 ;zp,x
2d74 : tand6
set_ax absANa,0
> load_flag 0
2d74 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2d76 : 48 > pha ;use stack to load status
2d77 : bd4b02 > lda absANa,x ;precharge accu
2d7a : 28 > plp
2d7b : 351c and zpAN,x
tst_ax absrlo,absflo,0
2d7d : 08 > php ;save flags
2d7e : dd5302 > cmp absrlo,x ;test result
> trap_ne
2d81 : d0fe > bne * ;failed not equal (non zero)
>
2d83 : 68 > pla ;load status
> eor_flag 0
2d84 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2d86 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2d89 : d0fe > bne * ;failed not equal (non zero)
>
2d8b : ca dex
2d8c : 10e6 bpl tand6
2d8e : a203 ldx #3
2d90 : tand7
set_ax absANa,$ff
> load_flag $ff
2d90 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2d92 : 48 > pha ;use stack to load status
2d93 : bd4b02 > lda absANa,x ;precharge accu
2d96 : 28 > plp
2d97 : 351c and zpAN,x
tst_ax absrlo,absflo,$ff-fnz
2d99 : 08 > php ;save flags
2d9a : dd5302 > cmp absrlo,x ;test result
> trap_ne
2d9d : d0fe > bne * ;failed not equal (non zero)
>
2d9f : 68 > pla ;load status
> eor_flag $ff-fnz
2da0 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2da2 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2da5 : d0fe > bne * ;failed not equal (non zero)
>
2da7 : ca dex
2da8 : 10e6 bpl tand7
2daa : a203 ldx #3 ;abs,x
2dac : tand8
set_ax absANa,0
> load_flag 0
2dac : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2dae : 48 > pha ;use stack to load status
2daf : bd4b02 > lda absANa,x ;precharge accu
2db2 : 28 > plp
2db3 : 3d3f02 and absAN,x
tst_ax absrlo,absflo,0
2db6 : 08 > php ;save flags
2db7 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2dba : d0fe > bne * ;failed not equal (non zero)
>
2dbc : 68 > pla ;load status
> eor_flag 0
2dbd : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2dbf : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2dc2 : d0fe > bne * ;failed not equal (non zero)
>
2dc4 : ca dex
2dc5 : 10e5 bpl tand8
2dc7 : a203 ldx #3
2dc9 : tand9
set_ax absANa,$ff
> load_flag $ff
2dc9 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2dcb : 48 > pha ;use stack to load status
2dcc : bd4b02 > lda absANa,x ;precharge accu
2dcf : 28 > plp
2dd0 : 3d3f02 and absAN,x
tst_ax absrlo,absflo,$ff-fnz
2dd3 : 08 > php ;save flags
2dd4 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2dd7 : d0fe > bne * ;failed not equal (non zero)
>
2dd9 : 68 > pla ;load status
> eor_flag $ff-fnz
2dda : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2ddc : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2ddf : d0fe > bne * ;failed not equal (non zero)
>
2de1 : ca dex
2de2 : 10e5 bpl tand9
2de4 : a003 ldy #3 ;abs,y
2de6 : tand10
set_ay absANa,0
> load_flag 0
2de6 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2de8 : 48 > pha ;use stack to load status
2de9 : b94b02 > lda absANa,y ;precharge accu
2dec : 28 > plp
2ded : 393f02 and absAN,y
tst_ay absrlo,absflo,0
2df0 : 08 > php ;save flags
2df1 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
2df4 : d0fe > bne * ;failed not equal (non zero)
>
2df6 : 68 > pla ;load status
> eor_flag 0
2df7 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2df9 : d95702 > cmp absflo,y ;test flags
> trap_ne
2dfc : d0fe > bne * ;failed not equal (non zero)
>
2dfe : 88 dey
2dff : 10e5 bpl tand10
2e01 : a003 ldy #3
2e03 : tand11
set_ay absANa,$ff
> load_flag $ff
2e03 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2e05 : 48 > pha ;use stack to load status
2e06 : b94b02 > lda absANa,y ;precharge accu
2e09 : 28 > plp
2e0a : 393f02 and absAN,y
tst_ay absrlo,absflo,$ff-fnz
2e0d : 08 > php ;save flags
2e0e : d95302 > cmp absrlo,y ;test result
> trap_ne ;
2e11 : d0fe > bne * ;failed not equal (non zero)
>
2e13 : 68 > pla ;load status
> eor_flag $ff-fnz
2e14 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2e16 : d95702 > cmp absflo,y ;test flags
> trap_ne
2e19 : d0fe > bne * ;failed not equal (non zero)
>
2e1b : 88 dey
2e1c : 10e5 bpl tand11
2e1e : a206 ldx #6 ;(zp,x)
2e20 : a003 ldy #3
2e22 : tand12
set_ay absANa,0
> load_flag 0
2e22 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2e24 : 48 > pha ;use stack to load status
2e25 : b94b02 > lda absANa,y ;precharge accu
2e28 : 28 > plp
2e29 : 213a and (indAN,x)
tst_ay absrlo,absflo,0
2e2b : 08 > php ;save flags
2e2c : d95302 > cmp absrlo,y ;test result
> trap_ne ;
2e2f : d0fe > bne * ;failed not equal (non zero)
>
2e31 : 68 > pla ;load status
> eor_flag 0
2e32 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2e34 : d95702 > cmp absflo,y ;test flags
> trap_ne
2e37 : d0fe > bne * ;failed not equal (non zero)
>
2e39 : ca dex
2e3a : ca dex
2e3b : 88 dey
2e3c : 10e4 bpl tand12
2e3e : a206 ldx #6
2e40 : a003 ldy #3
2e42 : tand13
set_ay absANa,$ff
> load_flag $ff
2e42 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2e44 : 48 > pha ;use stack to load status
2e45 : b94b02 > lda absANa,y ;precharge accu
2e48 : 28 > plp
2e49 : 213a and (indAN,x)
tst_ay absrlo,absflo,$ff-fnz
2e4b : 08 > php ;save flags
2e4c : d95302 > cmp absrlo,y ;test result
> trap_ne ;
2e4f : d0fe > bne * ;failed not equal (non zero)
>
2e51 : 68 > pla ;load status
> eor_flag $ff-fnz
2e52 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2e54 : d95702 > cmp absflo,y ;test flags
> trap_ne
2e57 : d0fe > bne * ;failed not equal (non zero)
>
2e59 : ca dex
2e5a : ca dex
2e5b : 88 dey
2e5c : 10e4 bpl tand13
2e5e : a003 ldy #3 ;(zp),y
2e60 : tand14
set_ay absANa,0
> load_flag 0
2e60 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2e62 : 48 > pha ;use stack to load status
2e63 : b94b02 > lda absANa,y ;precharge accu
2e66 : 28 > plp
2e67 : 313a and (indAN),y
tst_ay absrlo,absflo,0
2e69 : 08 > php ;save flags
2e6a : d95302 > cmp absrlo,y ;test result
> trap_ne ;
2e6d : d0fe > bne * ;failed not equal (non zero)
>
2e6f : 68 > pla ;load status
> eor_flag 0
2e70 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2e72 : d95702 > cmp absflo,y ;test flags
> trap_ne
2e75 : d0fe > bne * ;failed not equal (non zero)
>
2e77 : 88 dey
2e78 : 10e6 bpl tand14
2e7a : a003 ldy #3
2e7c : tand15
set_ay absANa,$ff
> load_flag $ff
2e7c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2e7e : 48 > pha ;use stack to load status
2e7f : b94b02 > lda absANa,y ;precharge accu
2e82 : 28 > plp
2e83 : 313a and (indAN),y
tst_ay absrlo,absflo,$ff-fnz
2e85 : 08 > php ;save flags
2e86 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
2e89 : d0fe > bne * ;failed not equal (non zero)
>
2e8b : 68 > pla ;load status
> eor_flag $ff-fnz
2e8c : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2e8e : d95702 > cmp absflo,y ;test flags
> trap_ne
2e91 : d0fe > bne * ;failed not equal (non zero)
>
2e93 : 88 dey
2e94 : 10e6 bpl tand15
next_test
2e96 : ad0002 > lda test_case ;previous test
2e99 : c926 > cmp #test_num
> trap_ne ;test is out of sequence
2e9b : d0fe > bne * ;failed not equal (non zero)
>
0027 = >test_num = test_num + 1
2e9d : a927 > lda #test_num ;*** next tests' number
2e9f : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; EOR
2ea2 : a203 ldx #3 ;immediate - self modifying code
2ea4 : b520 teor lda zpEO,x
2ea6 : 8db12e sta teori1
set_ax absEOa,0
> load_flag 0
2ea9 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2eab : 48 > pha ;use stack to load status
2eac : bd4f02 > lda absEOa,x ;precharge accu
2eaf : 28 > plp
2eb1 = teori1 equ *+1 ;target for immediate operand
2eb0 : 4963 eor #99
tst_ax absrlo,absflo,0
2eb2 : 08 > php ;save flags
2eb3 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2eb6 : d0fe > bne * ;failed not equal (non zero)
>
2eb8 : 68 > pla ;load status
> eor_flag 0
2eb9 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2ebb : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2ebe : d0fe > bne * ;failed not equal (non zero)
>
2ec0 : ca dex
2ec1 : 10e1 bpl teor
2ec3 : a203 ldx #3
2ec5 : b520 teor1 lda zpEO,x
2ec7 : 8dd22e sta teori2
set_ax absEOa,$ff
> load_flag $ff
2eca : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2ecc : 48 > pha ;use stack to load status
2ecd : bd4f02 > lda absEOa,x ;precharge accu
2ed0 : 28 > plp
2ed2 = teori2 equ *+1 ;target for immediate operand
2ed1 : 4963 eor #99
tst_ax absrlo,absflo,$ff-fnz
2ed3 : 08 > php ;save flags
2ed4 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2ed7 : d0fe > bne * ;failed not equal (non zero)
>
2ed9 : 68 > pla ;load status
> eor_flag $ff-fnz
2eda : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2edc : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2edf : d0fe > bne * ;failed not equal (non zero)
>
2ee1 : ca dex
2ee2 : 10e1 bpl teor1
2ee4 : a203 ldx #3 ;zp
2ee6 : b520 teor2 lda zpEO,x
2ee8 : 850c sta zpt
set_ax absEOa,0
> load_flag 0
2eea : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2eec : 48 > pha ;use stack to load status
2eed : bd4f02 > lda absEOa,x ;precharge accu
2ef0 : 28 > plp
2ef1 : 450c eor zpt
tst_ax absrlo,absflo,0
2ef3 : 08 > php ;save flags
2ef4 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2ef7 : d0fe > bne * ;failed not equal (non zero)
>
2ef9 : 68 > pla ;load status
> eor_flag 0
2efa : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2efc : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2eff : d0fe > bne * ;failed not equal (non zero)
>
2f01 : ca dex
2f02 : 10e2 bpl teor2
2f04 : a203 ldx #3
2f06 : b520 teor3 lda zpEO,x
2f08 : 850c sta zpt
set_ax absEOa,$ff
> load_flag $ff
2f0a : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2f0c : 48 > pha ;use stack to load status
2f0d : bd4f02 > lda absEOa,x ;precharge accu
2f10 : 28 > plp
2f11 : 450c eor zpt
tst_ax absrlo,absflo,$ff-fnz
2f13 : 08 > php ;save flags
2f14 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2f17 : d0fe > bne * ;failed not equal (non zero)
>
2f19 : 68 > pla ;load status
> eor_flag $ff-fnz
2f1a : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2f1c : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2f1f : d0fe > bne * ;failed not equal (non zero)
>
2f21 : ca dex
2f22 : 10e2 bpl teor3
2f24 : a203 ldx #3 ;abs
2f26 : b520 teor4 lda zpEO,x
2f28 : 8d0302 sta abst
set_ax absEOa,0
> load_flag 0
2f2b : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2f2d : 48 > pha ;use stack to load status
2f2e : bd4f02 > lda absEOa,x ;precharge accu
2f31 : 28 > plp
2f32 : 4d0302 eor abst
tst_ax absrlo,absflo,0
2f35 : 08 > php ;save flags
2f36 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2f39 : d0fe > bne * ;failed not equal (non zero)
>
2f3b : 68 > pla ;load status
> eor_flag 0
2f3c : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2f3e : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2f41 : d0fe > bne * ;failed not equal (non zero)
>
2f43 : ca dex
2f44 : 10e0 bpl teor4
2f46 : a203 ldx #3
2f48 : b520 teor5 lda zpEO,x
2f4a : 8d0302 sta abst
set_ax absEOa,$ff
> load_flag $ff
2f4d : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2f4f : 48 > pha ;use stack to load status
2f50 : bd4f02 > lda absEOa,x ;precharge accu
2f53 : 28 > plp
2f54 : 4d0302 eor abst
tst_ax absrlo,absflo,$ff-fnz
2f57 : 08 > php ;save flags
2f58 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2f5b : d0fe > bne * ;failed not equal (non zero)
>
2f5d : 68 > pla ;load status
> eor_flag $ff-fnz
2f5e : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2f60 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2f63 : d0fe > bne * ;failed not equal (non zero)
>
2f65 : ca dex
2f66 : 1002 bpl teor6
2f68 : a203 ldx #3 ;zp,x
2f6a : teor6
set_ax absEOa,0
> load_flag 0
2f6a : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2f6c : 48 > pha ;use stack to load status
2f6d : bd4f02 > lda absEOa,x ;precharge accu
2f70 : 28 > plp
2f71 : 5520 eor zpEO,x
tst_ax absrlo,absflo,0
2f73 : 08 > php ;save flags
2f74 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2f77 : d0fe > bne * ;failed not equal (non zero)
>
2f79 : 68 > pla ;load status
> eor_flag 0
2f7a : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2f7c : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2f7f : d0fe > bne * ;failed not equal (non zero)
>
2f81 : ca dex
2f82 : 10e6 bpl teor6
2f84 : a203 ldx #3
2f86 : teor7
set_ax absEOa,$ff
> load_flag $ff
2f86 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2f88 : 48 > pha ;use stack to load status
2f89 : bd4f02 > lda absEOa,x ;precharge accu
2f8c : 28 > plp
2f8d : 5520 eor zpEO,x
tst_ax absrlo,absflo,$ff-fnz
2f8f : 08 > php ;save flags
2f90 : dd5302 > cmp absrlo,x ;test result
> trap_ne
2f93 : d0fe > bne * ;failed not equal (non zero)
>
2f95 : 68 > pla ;load status
> eor_flag $ff-fnz
2f96 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2f98 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2f9b : d0fe > bne * ;failed not equal (non zero)
>
2f9d : ca dex
2f9e : 10e6 bpl teor7
2fa0 : a203 ldx #3 ;abs,x
2fa2 : teor8
set_ax absEOa,0
> load_flag 0
2fa2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2fa4 : 48 > pha ;use stack to load status
2fa5 : bd4f02 > lda absEOa,x ;precharge accu
2fa8 : 28 > plp
2fa9 : 5d4302 eor absEO,x
tst_ax absrlo,absflo,0
2fac : 08 > php ;save flags
2fad : dd5302 > cmp absrlo,x ;test result
> trap_ne
2fb0 : d0fe > bne * ;failed not equal (non zero)
>
2fb2 : 68 > pla ;load status
> eor_flag 0
2fb3 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2fb5 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2fb8 : d0fe > bne * ;failed not equal (non zero)
>
2fba : ca dex
2fbb : 10e5 bpl teor8
2fbd : a203 ldx #3
2fbf : teor9
set_ax absEOa,$ff
> load_flag $ff
2fbf : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2fc1 : 48 > pha ;use stack to load status
2fc2 : bd4f02 > lda absEOa,x ;precharge accu
2fc5 : 28 > plp
2fc6 : 5d4302 eor absEO,x
tst_ax absrlo,absflo,$ff-fnz
2fc9 : 08 > php ;save flags
2fca : dd5302 > cmp absrlo,x ;test result
> trap_ne
2fcd : d0fe > bne * ;failed not equal (non zero)
>
2fcf : 68 > pla ;load status
> eor_flag $ff-fnz
2fd0 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
2fd2 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
2fd5 : d0fe > bne * ;failed not equal (non zero)
>
2fd7 : ca dex
2fd8 : 10e5 bpl teor9
2fda : a003 ldy #3 ;abs,y
2fdc : teor10
set_ay absEOa,0
> load_flag 0
2fdc : a900 > lda #0 ;allow test to change I-flag (no mask)
>
2fde : 48 > pha ;use stack to load status
2fdf : b94f02 > lda absEOa,y ;precharge accu
2fe2 : 28 > plp
2fe3 : 594302 eor absEO,y
tst_ay absrlo,absflo,0
2fe6 : 08 > php ;save flags
2fe7 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
2fea : d0fe > bne * ;failed not equal (non zero)
>
2fec : 68 > pla ;load status
> eor_flag 0
2fed : 4930 > eor #0|fao ;invert expected flags + always on bits
>
2fef : d95702 > cmp absflo,y ;test flags
> trap_ne
2ff2 : d0fe > bne * ;failed not equal (non zero)
>
2ff4 : 88 dey
2ff5 : 10e5 bpl teor10
2ff7 : a003 ldy #3
2ff9 : teor11
set_ay absEOa,$ff
> load_flag $ff
2ff9 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
2ffb : 48 > pha ;use stack to load status
2ffc : b94f02 > lda absEOa,y ;precharge accu
2fff : 28 > plp
3000 : 594302 eor absEO,y
tst_ay absrlo,absflo,$ff-fnz
3003 : 08 > php ;save flags
3004 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
3007 : d0fe > bne * ;failed not equal (non zero)
>
3009 : 68 > pla ;load status
> eor_flag $ff-fnz
300a : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
300c : d95702 > cmp absflo,y ;test flags
> trap_ne
300f : d0fe > bne * ;failed not equal (non zero)
>
3011 : 88 dey
3012 : 10e5 bpl teor11
3014 : a206 ldx #6 ;(zp,x)
3016 : a003 ldy #3
3018 : teor12
set_ay absEOa,0
> load_flag 0
3018 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
301a : 48 > pha ;use stack to load status
301b : b94f02 > lda absEOa,y ;precharge accu
301e : 28 > plp
301f : 4142 eor (indEO,x)
tst_ay absrlo,absflo,0
3021 : 08 > php ;save flags
3022 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
3025 : d0fe > bne * ;failed not equal (non zero)
>
3027 : 68 > pla ;load status
> eor_flag 0
3028 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
302a : d95702 > cmp absflo,y ;test flags
> trap_ne
302d : d0fe > bne * ;failed not equal (non zero)
>
302f : ca dex
3030 : ca dex
3031 : 88 dey
3032 : 10e4 bpl teor12
3034 : a206 ldx #6
3036 : a003 ldy #3
3038 : teor13
set_ay absEOa,$ff
> load_flag $ff
3038 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
303a : 48 > pha ;use stack to load status
303b : b94f02 > lda absEOa,y ;precharge accu
303e : 28 > plp
303f : 4142 eor (indEO,x)
tst_ay absrlo,absflo,$ff-fnz
3041 : 08 > php ;save flags
3042 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
3045 : d0fe > bne * ;failed not equal (non zero)
>
3047 : 68 > pla ;load status
> eor_flag $ff-fnz
3048 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
304a : d95702 > cmp absflo,y ;test flags
> trap_ne
304d : d0fe > bne * ;failed not equal (non zero)
>
304f : ca dex
3050 : ca dex
3051 : 88 dey
3052 : 10e4 bpl teor13
3054 : a003 ldy #3 ;(zp),y
3056 : teor14
set_ay absEOa,0
> load_flag 0
3056 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3058 : 48 > pha ;use stack to load status
3059 : b94f02 > lda absEOa,y ;precharge accu
305c : 28 > plp
305d : 5142 eor (indEO),y
tst_ay absrlo,absflo,0
305f : 08 > php ;save flags
3060 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
3063 : d0fe > bne * ;failed not equal (non zero)
>
3065 : 68 > pla ;load status
> eor_flag 0
3066 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3068 : d95702 > cmp absflo,y ;test flags
> trap_ne
306b : d0fe > bne * ;failed not equal (non zero)
>
306d : 88 dey
306e : 10e6 bpl teor14
3070 : a003 ldy #3
3072 : teor15
set_ay absEOa,$ff
> load_flag $ff
3072 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3074 : 48 > pha ;use stack to load status
3075 : b94f02 > lda absEOa,y ;precharge accu
3078 : 28 > plp
3079 : 5142 eor (indEO),y
tst_ay absrlo,absflo,$ff-fnz
307b : 08 > php ;save flags
307c : d95302 > cmp absrlo,y ;test result
> trap_ne ;
307f : d0fe > bne * ;failed not equal (non zero)
>
3081 : 68 > pla ;load status
> eor_flag $ff-fnz
3082 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3084 : d95702 > cmp absflo,y ;test flags
> trap_ne
3087 : d0fe > bne * ;failed not equal (non zero)
>
3089 : 88 dey
308a : 10e6 bpl teor15
next_test
308c : ad0002 > lda test_case ;previous test
308f : c927 > cmp #test_num
> trap_ne ;test is out of sequence
3091 : d0fe > bne * ;failed not equal (non zero)
>
0028 = >test_num = test_num + 1
3093 : a928 > lda #test_num ;*** next tests' number
3095 : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; OR
3098 : a203 ldx #3 ;immediate - self modifying code
309a : b518 tora lda zpOR,x
309c : 8da730 sta torai1
set_ax absORa,0
> load_flag 0
309f : a900 > lda #0 ;allow test to change I-flag (no mask)
>
30a1 : 48 > pha ;use stack to load status
30a2 : bd4702 > lda absORa,x ;precharge accu
30a5 : 28 > plp
30a7 = torai1 equ *+1 ;target for immediate operand
30a6 : 0963 ora #99
tst_ax absrlo,absflo,0
30a8 : 08 > php ;save flags
30a9 : dd5302 > cmp absrlo,x ;test result
> trap_ne
30ac : d0fe > bne * ;failed not equal (non zero)
>
30ae : 68 > pla ;load status
> eor_flag 0
30af : 4930 > eor #0|fao ;invert expected flags + always on bits
>
30b1 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
30b4 : d0fe > bne * ;failed not equal (non zero)
>
30b6 : ca dex
30b7 : 10e1 bpl tora
30b9 : a203 ldx #3
30bb : b518 tora1 lda zpOR,x
30bd : 8dc830 sta torai2
set_ax absORa,$ff
> load_flag $ff
30c0 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
30c2 : 48 > pha ;use stack to load status
30c3 : bd4702 > lda absORa,x ;precharge accu
30c6 : 28 > plp
30c8 = torai2 equ *+1 ;target for immediate operand
30c7 : 0963 ora #99
tst_ax absrlo,absflo,$ff-fnz
30c9 : 08 > php ;save flags
30ca : dd5302 > cmp absrlo,x ;test result
> trap_ne
30cd : d0fe > bne * ;failed not equal (non zero)
>
30cf : 68 > pla ;load status
> eor_flag $ff-fnz
30d0 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
30d2 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
30d5 : d0fe > bne * ;failed not equal (non zero)
>
30d7 : ca dex
30d8 : 10e1 bpl tora1
30da : a203 ldx #3 ;zp
30dc : b518 tora2 lda zpOR,x
30de : 850c sta zpt
set_ax absORa,0
> load_flag 0
30e0 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
30e2 : 48 > pha ;use stack to load status
30e3 : bd4702 > lda absORa,x ;precharge accu
30e6 : 28 > plp
30e7 : 050c ora zpt
tst_ax absrlo,absflo,0
30e9 : 08 > php ;save flags
30ea : dd5302 > cmp absrlo,x ;test result
> trap_ne
30ed : d0fe > bne * ;failed not equal (non zero)
>
30ef : 68 > pla ;load status
> eor_flag 0
30f0 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
30f2 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
30f5 : d0fe > bne * ;failed not equal (non zero)
>
30f7 : ca dex
30f8 : 10e2 bpl tora2
30fa : a203 ldx #3
30fc : b518 tora3 lda zpOR,x
30fe : 850c sta zpt
set_ax absORa,$ff
> load_flag $ff
3100 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3102 : 48 > pha ;use stack to load status
3103 : bd4702 > lda absORa,x ;precharge accu
3106 : 28 > plp
3107 : 050c ora zpt
tst_ax absrlo,absflo,$ff-fnz
3109 : 08 > php ;save flags
310a : dd5302 > cmp absrlo,x ;test result
> trap_ne
310d : d0fe > bne * ;failed not equal (non zero)
>
310f : 68 > pla ;load status
> eor_flag $ff-fnz
3110 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3112 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
3115 : d0fe > bne * ;failed not equal (non zero)
>
3117 : ca dex
3118 : 10e2 bpl tora3
311a : a203 ldx #3 ;abs
311c : b518 tora4 lda zpOR,x
311e : 8d0302 sta abst
set_ax absORa,0
> load_flag 0
3121 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3123 : 48 > pha ;use stack to load status
3124 : bd4702 > lda absORa,x ;precharge accu
3127 : 28 > plp
3128 : 0d0302 ora abst
tst_ax absrlo,absflo,0
312b : 08 > php ;save flags
312c : dd5302 > cmp absrlo,x ;test result
> trap_ne
312f : d0fe > bne * ;failed not equal (non zero)
>
3131 : 68 > pla ;load status
> eor_flag 0
3132 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3134 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
3137 : d0fe > bne * ;failed not equal (non zero)
>
3139 : ca dex
313a : 10e0 bpl tora4
313c : a203 ldx #3
313e : b518 tora5 lda zpOR,x
3140 : 8d0302 sta abst
set_ax absORa,$ff
> load_flag $ff
3143 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3145 : 48 > pha ;use stack to load status
3146 : bd4702 > lda absORa,x ;precharge accu
3149 : 28 > plp
314a : 0d0302 ora abst
tst_ax absrlo,absflo,$ff-fnz
314d : 08 > php ;save flags
314e : dd5302 > cmp absrlo,x ;test result
> trap_ne
3151 : d0fe > bne * ;failed not equal (non zero)
>
3153 : 68 > pla ;load status
> eor_flag $ff-fnz
3154 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3156 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
3159 : d0fe > bne * ;failed not equal (non zero)
>
315b : ca dex
315c : 1002 bpl tora6
315e : a203 ldx #3 ;zp,x
3160 : tora6
set_ax absORa,0
> load_flag 0
3160 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3162 : 48 > pha ;use stack to load status
3163 : bd4702 > lda absORa,x ;precharge accu
3166 : 28 > plp
3167 : 1518 ora zpOR,x
tst_ax absrlo,absflo,0
3169 : 08 > php ;save flags
316a : dd5302 > cmp absrlo,x ;test result
> trap_ne
316d : d0fe > bne * ;failed not equal (non zero)
>
316f : 68 > pla ;load status
> eor_flag 0
3170 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3172 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
3175 : d0fe > bne * ;failed not equal (non zero)
>
3177 : ca dex
3178 : 10e6 bpl tora6
317a : a203 ldx #3
317c : tora7
set_ax absORa,$ff
> load_flag $ff
317c : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
317e : 48 > pha ;use stack to load status
317f : bd4702 > lda absORa,x ;precharge accu
3182 : 28 > plp
3183 : 1518 ora zpOR,x
tst_ax absrlo,absflo,$ff-fnz
3185 : 08 > php ;save flags
3186 : dd5302 > cmp absrlo,x ;test result
> trap_ne
3189 : d0fe > bne * ;failed not equal (non zero)
>
318b : 68 > pla ;load status
> eor_flag $ff-fnz
318c : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
318e : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
3191 : d0fe > bne * ;failed not equal (non zero)
>
3193 : ca dex
3194 : 10e6 bpl tora7
3196 : a203 ldx #3 ;abs,x
3198 : tora8
set_ax absORa,0
> load_flag 0
3198 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
319a : 48 > pha ;use stack to load status
319b : bd4702 > lda absORa,x ;precharge accu
319e : 28 > plp
319f : 1d3b02 ora absOR,x
tst_ax absrlo,absflo,0
31a2 : 08 > php ;save flags
31a3 : dd5302 > cmp absrlo,x ;test result
> trap_ne
31a6 : d0fe > bne * ;failed not equal (non zero)
>
31a8 : 68 > pla ;load status
> eor_flag 0
31a9 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
31ab : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
31ae : d0fe > bne * ;failed not equal (non zero)
>
31b0 : ca dex
31b1 : 10e5 bpl tora8
31b3 : a203 ldx #3
31b5 : tora9
set_ax absORa,$ff
> load_flag $ff
31b5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
31b7 : 48 > pha ;use stack to load status
31b8 : bd4702 > lda absORa,x ;precharge accu
31bb : 28 > plp
31bc : 1d3b02 ora absOR,x
tst_ax absrlo,absflo,$ff-fnz
31bf : 08 > php ;save flags
31c0 : dd5302 > cmp absrlo,x ;test result
> trap_ne
31c3 : d0fe > bne * ;failed not equal (non zero)
>
31c5 : 68 > pla ;load status
> eor_flag $ff-fnz
31c6 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
31c8 : dd5702 > cmp absflo,x ;test flags
> trap_ne ;
31cb : d0fe > bne * ;failed not equal (non zero)
>
31cd : ca dex
31ce : 10e5 bpl tora9
31d0 : a003 ldy #3 ;abs,y
31d2 : tora10
set_ay absORa,0
> load_flag 0
31d2 : a900 > lda #0 ;allow test to change I-flag (no mask)
>
31d4 : 48 > pha ;use stack to load status
31d5 : b94702 > lda absORa,y ;precharge accu
31d8 : 28 > plp
31d9 : 193b02 ora absOR,y
tst_ay absrlo,absflo,0
31dc : 08 > php ;save flags
31dd : d95302 > cmp absrlo,y ;test result
> trap_ne ;
31e0 : d0fe > bne * ;failed not equal (non zero)
>
31e2 : 68 > pla ;load status
> eor_flag 0
31e3 : 4930 > eor #0|fao ;invert expected flags + always on bits
>
31e5 : d95702 > cmp absflo,y ;test flags
> trap_ne
31e8 : d0fe > bne * ;failed not equal (non zero)
>
31ea : 88 dey
31eb : 10e5 bpl tora10
31ed : a003 ldy #3
31ef : tora11
set_ay absORa,$ff
> load_flag $ff
31ef : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
31f1 : 48 > pha ;use stack to load status
31f2 : b94702 > lda absORa,y ;precharge accu
31f5 : 28 > plp
31f6 : 193b02 ora absOR,y
tst_ay absrlo,absflo,$ff-fnz
31f9 : 08 > php ;save flags
31fa : d95302 > cmp absrlo,y ;test result
> trap_ne ;
31fd : d0fe > bne * ;failed not equal (non zero)
>
31ff : 68 > pla ;load status
> eor_flag $ff-fnz
3200 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3202 : d95702 > cmp absflo,y ;test flags
> trap_ne
3205 : d0fe > bne * ;failed not equal (non zero)
>
3207 : 88 dey
3208 : 10e5 bpl tora11
320a : a206 ldx #6 ;(zp,x)
320c : a003 ldy #3
320e : tora12
set_ay absORa,0
> load_flag 0
320e : a900 > lda #0 ;allow test to change I-flag (no mask)
>
3210 : 48 > pha ;use stack to load status
3211 : b94702 > lda absORa,y ;precharge accu
3214 : 28 > plp
3215 : 014a ora (indOR,x)
tst_ay absrlo,absflo,0
3217 : 08 > php ;save flags
3218 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
321b : d0fe > bne * ;failed not equal (non zero)
>
321d : 68 > pla ;load status
> eor_flag 0
321e : 4930 > eor #0|fao ;invert expected flags + always on bits
>
3220 : d95702 > cmp absflo,y ;test flags
> trap_ne
3223 : d0fe > bne * ;failed not equal (non zero)
>
3225 : ca dex
3226 : ca dex
3227 : 88 dey
3228 : 10e4 bpl tora12
322a : a206 ldx #6
322c : a003 ldy #3
322e : tora13
set_ay absORa,$ff
> load_flag $ff
322e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3230 : 48 > pha ;use stack to load status
3231 : b94702 > lda absORa,y ;precharge accu
3234 : 28 > plp
3235 : 014a ora (indOR,x)
tst_ay absrlo,absflo,$ff-fnz
3237 : 08 > php ;save flags
3238 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
323b : d0fe > bne * ;failed not equal (non zero)
>
323d : 68 > pla ;load status
> eor_flag $ff-fnz
323e : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
3240 : d95702 > cmp absflo,y ;test flags
> trap_ne
3243 : d0fe > bne * ;failed not equal (non zero)
>
3245 : ca dex
3246 : ca dex
3247 : 88 dey
3248 : 10e4 bpl tora13
324a : a003 ldy #3 ;(zp),y
324c : tora14
set_ay absORa,0
> load_flag 0
324c : a900 > lda #0 ;allow test to change I-flag (no mask)
>
324e : 48 > pha ;use stack to load status
324f : b94702 > lda absORa,y ;precharge accu
3252 : 28 > plp
3253 : 114a ora (indOR),y
tst_ay absrlo,absflo,0
3255 : 08 > php ;save flags
3256 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
3259 : d0fe > bne * ;failed not equal (non zero)
>
325b : 68 > pla ;load status
> eor_flag 0
325c : 4930 > eor #0|fao ;invert expected flags + always on bits
>
325e : d95702 > cmp absflo,y ;test flags
> trap_ne
3261 : d0fe > bne * ;failed not equal (non zero)
>
3263 : 88 dey
3264 : 10e6 bpl tora14
3266 : a003 ldy #3
3268 : tora15
set_ay absORa,$ff
> load_flag $ff
3268 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
326a : 48 > pha ;use stack to load status
326b : b94702 > lda absORa,y ;precharge accu
326e : 28 > plp
326f : 114a ora (indOR),y
tst_ay absrlo,absflo,$ff-fnz
3271 : 08 > php ;save flags
3272 : d95302 > cmp absrlo,y ;test result
> trap_ne ;
3275 : d0fe > bne * ;failed not equal (non zero)
>
3277 : 68 > pla ;load status
> eor_flag $ff-fnz
3278 : 497d > eor #$ff-fnz|fao ;invert expected flags + always on bits
>
327a : d95702 > cmp absflo,y ;test flags
> trap_ne
327d : d0fe > bne * ;failed not equal (non zero)
>
327f : 88 dey
3280 : 10e6 bpl tora15
if I_flag = 3
3282 : 58 cli
endif
next_test
3283 : ad0002 > lda test_case ;previous test
3286 : c928 > cmp #test_num
> trap_ne ;test is out of sequence
3288 : d0fe > bne * ;failed not equal (non zero)
>
0029 = >test_num = test_num + 1
328a : a929 > lda #test_num ;*** next tests' number
328c : 8d0002 > sta test_case
> ;check_ram ;uncomment to find altered RAM after each test
; full binary add/subtract test
; iterates through all combinations of operands and carry input
; uses increments/decrements to predict result & result flags
328f : d8 cld
3290 : a20e ldx #ad2 ;for indexed test
3292 : a0ff ldy #$ff ;max range
3294 : a900 lda #0 ;start with adding zeroes & no carry
3296 : 850c sta adfc ;carry in - for diag
3298 : 850d sta ad1 ;operand 1 - accumulator
329a : 850e sta ad2 ;operand 2 - memory or immediate
329c : 8d0302 sta ada2 ;non zp
329f : 850f sta adrl ;expected result bits 0-7
32a1 : 8510 sta adrh ;expected result bit 8 (carry out)
32a3 : a9ff lda #$ff ;complemented operand 2 for subtract
32a5 : 8512 sta sb2
32a7 : 8d0402 sta sba2 ;non zp
32aa : a902 lda #2 ;expected Z-flag
32ac : 8511 sta adrf
32ae : 18 tadd clc ;test with carry clear
32af : 20d034 jsr chkadd
32b2 : e60c inc adfc ;now with carry
32b4 : e60f inc adrl ;result +1
32b6 : 08 php ;save N & Z from low result
32b7 : 08 php
32b8 : 68 pla ;accu holds expected flags
32b9 : 2982 and #$82 ;mask N & Z
32bb : 28 plp
32bc : d002 bne tadd1
32be : e610 inc adrh ;result bit 8 - carry
32c0 : 0510 tadd1 ora adrh ;merge C to expected flags
32c2 : 8511 sta adrf ;save expected flags except overflow
32c4 : 38 sec ;test with carry set
32c5 : 20d034 jsr chkadd
32c8 : c60c dec adfc ;same for operand +1 but no carry
32ca : e60d inc ad1
32cc : d0e0 bne tadd ;iterate op1
32ce : a900 lda #0 ;preset result to op2 when op1 = 0
32d0 : 8510 sta adrh
32d2 : ee0302 inc ada2
32d5 : e60e inc ad2
32d7 : 08 php ;save NZ as operand 2 becomes the new result
32d8 : 68 pla
32d9 : 2982 and #$82 ;mask N00000Z0
32db : 8511 sta adrf ;no need to check carry as we are adding to 0
32dd : c612 dec sb2 ;complement subtract operand 2
32df : ce0402 dec sba2
32e2 : a50e lda ad2
32e4 : 850f sta adrl
32e6 : d0c6 bne tadd ;iterate op2
next_test
32e8 : ad0002 > lda test_case ;previous test
32eb : c929 > cmp #test_num
> trap_ne ;test is out of sequence
32ed : d0fe > bne * ;failed not equal (non zero)
>
002a = >test_num = test_num + 1
32ef : a92a > lda #test_num ;*** next tests' number
32f1 : 8d0002 > 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, N V Z flags are ignored
; iterates through all valid combinations of operands and carry input
; uses increments/decrements to predict result & carry flag
32f4 : f8 sed
32f5 : a20e ldx #ad2 ;for indexed test
32f7 : a0ff ldy #$ff ;max range
32f9 : a999 lda #$99 ;start with adding 99 to 99 with carry
32fb : 850d sta ad1 ;operand 1 - accumulator
32fd : 850e sta ad2 ;operand 2 - memory or immediate
32ff : 8d0302 sta ada2 ;non zp
3302 : 850f sta adrl ;expected result bits 0-7
3304 : a901 lda #1 ;set carry in & out
3306 : 850c sta adfc ;carry in - for diag
3308 : 8510 sta adrh ;expected result bit 8 (carry out)
330a : a900 lda #0 ;complemented operand 2 for subtract
330c : 8512 sta sb2
330e : 8d0402 sta sba2 ;non zp
3311 : 38 tdad sec ;test with carry set
3312 : 209f33 jsr chkdad
3315 : c60c dec adfc ;now with carry clear
3317 : a50f lda adrl ;decimal adjust result
3319 : d008 bne tdad1 ;skip clear carry & preset result 99 (9A-1)
331b : c610 dec adrh
331d : a999 lda #$99
331f : 850f sta adrl
3321 : d012 bne tdad3
3323 : 290f tdad1 and #$f ;lower nibble mask
3325 : d00c bne tdad2 ;no decimal adjust needed
3327 : c60f dec adrl ;decimal adjust (?0-6)
3329 : c60f dec adrl
332b : c60f dec adrl
332d : c60f dec adrl
332f : c60f dec adrl
3331 : c60f dec adrl
3333 : c60f tdad2 dec adrl ;result -1
3335 : 18 tdad3 clc ;test with carry clear
3336 : 209f33 jsr chkdad
3339 : e60c inc adfc ;same for operand -1 but with carry
333b : a50d lda ad1 ;decimal adjust operand 1
333d : f015 beq tdad5 ;iterate operand 2
333f : 290f and #$f ;lower nibble mask
3341 : d00c bne tdad4 ;skip decimal adjust
3343 : c60d dec ad1 ;decimal adjust (?0-6)
3345 : c60d dec ad1
3347 : c60d dec ad1
3349 : c60d dec ad1
334b : c60d dec ad1
334d : c60d dec ad1
334f : c60d tdad4 dec ad1 ;operand 1 -1
3351 : 4c1133 jmp tdad ;iterate op1
3354 : a999 tdad5 lda #$99 ;precharge op1 max
3356 : 850d sta ad1
3358 : a50e lda ad2 ;decimal adjust operand 2
335a : f030 beq tdad7 ;end of iteration
335c : 290f and #$f ;lower nibble mask
335e : d018 bne tdad6 ;skip decimal adjust
3360 : c60e dec ad2 ;decimal adjust (?0-6)
3362 : c60e dec ad2
3364 : c60e dec ad2
3366 : c60e dec ad2
3368 : c60e dec ad2
336a : c60e dec ad2
336c : e612 inc sb2 ;complemented decimal adjust for subtract (?9+6)
336e : e612 inc sb2
3370 : e612 inc sb2
3372 : e612 inc sb2
3374 : e612 inc sb2
3376 : e612 inc sb2
3378 : c60e tdad6 dec ad2 ;operand 2 -1
337a : e612 inc sb2 ;complemented operand for subtract
337c : a512 lda sb2
337e : 8d0402 sta sba2 ;copy as non zp operand
3381 : a50e lda ad2
3383 : 8d0302 sta ada2 ;copy as non zp operand
3386 : 850f sta adrl ;new result since op1+carry=00+carry +op2=op2
3388 : e610 inc adrh ;result carry
338a : d085 bne tdad ;iterate op2
338c : d8 tdad7 cld
338d : ad0002 lda test_case
3390 : c92a cmp #test_num
trap_ne ;previous test is out of sequence
3392 : d0fe > bne * ;failed not equal (non zero)
3394 : a9f0 lda #$f0 ;mark opcode testing complete
3396 : 8d0002 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
3399 : 4c9933 > jmp * ;test passed, no errors
; -------------
; S U C C E S S ************************************************
339c : 4c0004 jmp start ;run again
; core subroutine of the decimal add/subtract test
; *** WARNING - tests documented behavior only! ***
; only valid BCD operands are tested, N V Z flags are ignored
; iterates through all valid combinations of operands and carry input
; uses increments/decrements to predict result & carry flag
339f : chkdad
; decimal ADC / SBC zp
339f : 08 php ;save carry for subtract
33a0 : a50d lda ad1
33a2 : 650e adc ad2 ;perform add
33a4 : 08 php
33a5 : c50f cmp adrl ;check result
trap_ne ;bad result
33a7 : d0fe > bne * ;failed not equal (non zero)
33a9 : 68 pla ;check flags
33aa : 2901 and #1 ;mask carry
33ac : c510 cmp adrh
trap_ne ;bad carry
33ae : d0fe > bne * ;failed not equal (non zero)
33b0 : 28 plp
33b1 : 08 php ;save carry for next add
33b2 : a50d lda ad1
33b4 : e512 sbc sb2 ;perform subtract
33b6 : 08 php
33b7 : c50f cmp adrl ;check result
trap_ne ;bad result
33b9 : d0fe > bne * ;failed not equal (non zero)
33bb : 68 pla ;check flags
33bc : 2901 and #1 ;mask carry
33be : c510 cmp adrh
trap_ne ;bad flags
33c0 : d0fe > bne * ;failed not equal (non zero)
33c2 : 28 plp
; decimal ADC / SBC abs
33c3 : 08 php ;save carry for subtract
33c4 : a50d lda ad1
33c6 : 6d0302 adc ada2 ;perform add
33c9 : 08 php
33ca : c50f cmp adrl ;check result
trap_ne ;bad result
33cc : d0fe > bne * ;failed not equal (non zero)
33ce : 68 pla ;check flags
33cf : 2901 and #1 ;mask carry
33d1 : c510 cmp adrh
trap_ne ;bad carry
33d3 : d0fe > bne * ;failed not equal (non zero)
33d5 : 28 plp
33d6 : 08 php ;save carry for next add
33d7 : a50d lda ad1
33d9 : ed0402 sbc sba2 ;perform subtract
33dc : 08 php
33dd : c50f cmp adrl ;check result
trap_ne ;bad result
33df : d0fe > bne * ;failed not equal (non zero)
33e1 : 68 pla ;check flags
33e2 : 2901 and #1 ;mask carry
33e4 : c510 cmp adrh
trap_ne ;bad carry
33e6 : d0fe > bne * ;failed not equal (non zero)
33e8 : 28 plp
; decimal ADC / SBC #
33e9 : 08 php ;save carry for subtract
33ea : a50e lda ad2
33ec : 8df233 sta chkdadi ;self modify immediate
33ef : a50d lda ad1
33f2 = chkdadi = * + 1 ;operand of the immediate ADC
33f1 : 6900 adc #0 ;perform add
33f3 : 08 php
33f4 : c50f cmp adrl ;check result
trap_ne ;bad result
33f6 : d0fe > bne * ;failed not equal (non zero)
33f8 : 68 pla ;check flags
33f9 : 2901 and #1 ;mask carry
33fb : c510 cmp adrh
trap_ne ;bad carry
33fd : d0fe > bne * ;failed not equal (non zero)
33ff : 28 plp
3400 : 08 php ;save carry for next add
3401 : a512 lda sb2
3403 : 8d0934 sta chkdsbi ;self modify immediate
3406 : a50d lda ad1
3409 = chkdsbi = * + 1 ;operand of the immediate SBC
3408 : e900 sbc #0 ;perform subtract
340a : 08 php
340b : c50f cmp adrl ;check result
trap_ne ;bad result
340d : d0fe > bne * ;failed not equal (non zero)
340f : 68 pla ;check flags
3410 : 2901 and #1 ;mask carry
3412 : c510 cmp adrh
trap_ne ;bad carry
3414 : d0fe > bne * ;failed not equal (non zero)
3416 : 28 plp
; decimal ADC / SBC zp,x
3417 : 08 php ;save carry for subtract
3418 : a50d lda ad1
341a : 7500 adc 0,x ;perform add
341c : 08 php
341d : c50f cmp adrl ;check result
trap_ne ;bad result
341f : d0fe > bne * ;failed not equal (non zero)
3421 : 68 pla ;check flags
3422 : 2901 and #1 ;mask carry
3424 : c510 cmp adrh
trap_ne ;bad carry
3426 : d0fe > bne * ;failed not equal (non zero)
3428 : 28 plp
3429 : 08 php ;save carry for next add
342a : a50d lda ad1
342c : f504 sbc sb2-ad2,x ;perform subtract
342e : 08 php
342f : c50f cmp adrl ;check result
trap_ne ;bad result
3431 : d0fe > bne * ;failed not equal (non zero)
3433 : 68 pla ;check flags
3434 : 2901 and #1 ;mask carry
3436 : c510 cmp adrh
trap_ne ;bad carry
3438 : d0fe > bne * ;failed not equal (non zero)
343a : 28 plp
; decimal ADC / SBC abs,x
343b : 08 php ;save carry for subtract
343c : a50d lda ad1
343e : 7df501 adc ada2-ad2,x ;perform add
3441 : 08 php
3442 : c50f cmp adrl ;check result
trap_ne ;bad result
3444 : d0fe > bne * ;failed not equal (non zero)
3446 : 68 pla ;check flags
3447 : 2901 and #1 ;mask carry
3449 : c510 cmp adrh
trap_ne ;bad carry
344b : d0fe > bne * ;failed not equal (non zero)
344d : 28 plp
344e : 08 php ;save carry for next add
344f : a50d lda ad1
3451 : fdf601 sbc sba2-ad2,x ;perform subtract
3454 : 08 php
3455 : c50f cmp adrl ;check result
trap_ne ;bad result
3457 : d0fe > bne * ;failed not equal (non zero)
3459 : 68 pla ;check flags
345a : 2901 and #1 ;mask carry
345c : c510 cmp adrh
trap_ne ;bad carry
345e : d0fe > bne * ;failed not equal (non zero)
3460 : 28 plp
; decimal ADC / SBC abs,y
3461 : 08 php ;save carry for subtract
3462 : a50d lda ad1
3464 : 790401 adc ada2-$ff,y ;perform add
3467 : 08 php
3468 : c50f cmp adrl ;check result
trap_ne ;bad result
346a : d0fe > bne * ;failed not equal (non zero)
346c : 68 pla ;check flags
346d : 2901 and #1 ;mask carry
346f : c510 cmp adrh
trap_ne ;bad carry
3471 : d0fe > bne * ;failed not equal (non zero)
3473 : 28 plp
3474 : 08 php ;save carry for next add
3475 : a50d lda ad1
3477 : f90501 sbc sba2-$ff,y ;perform subtract
347a : 08 php
347b : c50f cmp adrl ;check result
trap_ne ;bad result
347d : d0fe > bne * ;failed not equal (non zero)
347f : 68 pla ;check flags
3480 : 2901 and #1 ;mask carry
3482 : c510 cmp adrh
trap_ne ;bad carry
3484 : d0fe > bne * ;failed not equal (non zero)
3486 : 28 plp
; decimal ADC / SBC (zp,x)
3487 : 08 php ;save carry for subtract
3488 : a50d lda ad1
348a : 6144 adc (lo adi2-ad2,x) ;perform add
348c : 08 php
348d : c50f cmp adrl ;check result
trap_ne ;bad result
348f : d0fe > bne * ;failed not equal (non zero)
3491 : 68 pla ;check flags
3492 : 2901 and #1 ;mask carry
3494 : c510 cmp adrh
trap_ne ;bad carry
3496 : d0fe > bne * ;failed not equal (non zero)
3498 : 28 plp
3499 : 08 php ;save carry for next add
349a : a50d lda ad1
349c : e146 sbc (lo sbi2-ad2,x) ;perform subtract
349e : 08 php
349f : c50f cmp adrl ;check result
trap_ne ;bad result
34a1 : d0fe > bne * ;failed not equal (non zero)
34a3 : 68 pla ;check flags
34a4 : 2901 and #1 ;mask carry
34a6 : c510 cmp adrh
trap_ne ;bad carry
34a8 : d0fe > bne * ;failed not equal (non zero)
34aa : 28 plp
; decimal ADC / SBC (abs),y
34ab : 08 php ;save carry for subtract
34ac : a50d lda ad1
34ae : 7156 adc (adiy2),y ;perform add
34b0 : 08 php
34b1 : c50f cmp adrl ;check result
trap_ne ;bad result
34b3 : d0fe > bne * ;failed not equal (non zero)
34b5 : 68 pla ;check flags
34b6 : 2901 and #1 ;mask carry
34b8 : c510 cmp adrh
trap_ne ;bad carry
34ba : d0fe > bne * ;failed not equal (non zero)
34bc : 28 plp
34bd : 08 php ;save carry for next add
34be : a50d lda ad1
34c0 : f158 sbc (sbiy2),y ;perform subtract
34c2 : 08 php
34c3 : c50f cmp adrl ;check result
trap_ne ;bad result
34c5 : d0fe > bne * ;failed not equal (non zero)
34c7 : 68 pla ;check flags
34c8 : 2901 and #1 ;mask carry
34ca : c510 cmp adrh
trap_ne ;bad carry
34cc : d0fe > bne * ;failed not equal (non zero)
34ce : 28 plp
34cf : 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
34d0 : a511 chkadd lda adrf ;add V-flag if overflow
34d2 : 2983 and #$83 ;keep N-----ZC / clear V
34d4 : 48 pha
34d5 : a50d lda ad1 ;test sign unequal between operands
34d7 : 450e eor ad2
34d9 : 300a bmi ckad1 ;no overflow possible - operands have different sign
34db : a50d lda ad1 ;test sign equal between operands and result
34dd : 450f eor adrl
34df : 1004 bpl ckad1 ;no overflow occured - operand and result have same sign
34e1 : 68 pla
34e2 : 0940 ora #$40 ;set V
34e4 : 48 pha
34e5 : 68 ckad1 pla
34e6 : 8511 sta adrf ;save expected flags
; binary ADC / SBC zp
34e8 : 08 php ;save carry for subtract
34e9 : a50d lda ad1
34eb : 650e adc ad2 ;perform add
34ed : 08 php
34ee : c50f cmp adrl ;check result
trap_ne ;bad result
34f0 : d0fe > bne * ;failed not equal (non zero)
34f2 : 68 pla ;check flags
34f3 : 29c3 and #$c3 ;mask NV----ZC
34f5 : c511 cmp adrf
trap_ne ;bad flags
34f7 : d0fe > bne * ;failed not equal (non zero)
34f9 : 28 plp
34fa : 08 php ;save carry for next add
34fb : a50d lda ad1
34fd : e512 sbc sb2 ;perform subtract
34ff : 08 php
3500 : c50f cmp adrl ;check result
trap_ne ;bad result
3502 : d0fe > bne * ;failed not equal (non zero)
3504 : 68 pla ;check flags
3505 : 29c3 and #$c3 ;mask NV----ZC
3507 : c511 cmp adrf
trap_ne ;bad flags
3509 : d0fe > bne * ;failed not equal (non zero)
350b : 28 plp
; binary ADC / SBC abs
350c : 08 php ;save carry for subtract
350d : a50d lda ad1
350f : 6d0302 adc ada2 ;perform add
3512 : 08 php
3513 : c50f cmp adrl ;check result
trap_ne ;bad result
3515 : d0fe > bne * ;failed not equal (non zero)
3517 : 68 pla ;check flags
3518 : 29c3 and #$c3 ;mask NV----ZC
351a : c511 cmp adrf
trap_ne ;bad flags
351c : d0fe > bne * ;failed not equal (non zero)
351e : 28 plp
351f : 08 php ;save carry for next add
3520 : a50d lda ad1
3522 : ed0402 sbc sba2 ;perform subtract
3525 : 08 php
3526 : c50f cmp adrl ;check result
trap_ne ;bad result
3528 : d0fe > bne * ;failed not equal (non zero)
352a : 68 pla ;check flags
352b : 29c3 and #$c3 ;mask NV----ZC
352d : c511 cmp adrf
trap_ne ;bad flags
352f : d0fe > bne * ;failed not equal (non zero)
3531 : 28 plp
; binary ADC / SBC #
3532 : 08 php ;save carry for subtract
3533 : a50e lda ad2
3535 : 8d3b35 sta chkadi ;self modify immediate
3538 : a50d lda ad1
353b = chkadi = * + 1 ;operand of the immediate ADC
353a : 6900 adc #0 ;perform add
353c : 08 php
353d : c50f cmp adrl ;check result
trap_ne ;bad result
353f : d0fe > bne * ;failed not equal (non zero)
3541 : 68 pla ;check flags
3542 : 29c3 and #$c3 ;mask NV----ZC
3544 : c511 cmp adrf
trap_ne ;bad flags
3546 : d0fe > bne * ;failed not equal (non zero)
3548 : 28 plp
3549 : 08 php ;save carry for next add
354a : a512 lda sb2
354c : 8d5235 sta chksbi ;self modify immediate
354f : a50d lda ad1
3552 = chksbi = * + 1 ;operand of the immediate SBC
3551 : e900 sbc #0 ;perform subtract
3553 : 08 php
3554 : c50f cmp adrl ;check result
trap_ne ;bad result
3556 : d0fe > bne * ;failed not equal (non zero)
3558 : 68 pla ;check flags
3559 : 29c3 and #$c3 ;mask NV----ZC
355b : c511 cmp adrf
trap_ne ;bad flags
355d : d0fe > bne * ;failed not equal (non zero)
355f : 28 plp
; binary ADC / SBC zp,x
3560 : 08 php ;save carry for subtract
3561 : a50d lda ad1
3563 : 7500 adc 0,x ;perform add
3565 : 08 php
3566 : c50f cmp adrl ;check result
trap_ne ;bad result
3568 : d0fe > bne * ;failed not equal (non zero)
356a : 68 pla ;check flags
356b : 29c3 and #$c3 ;mask NV----ZC
356d : c511 cmp adrf
trap_ne ;bad flags
356f : d0fe > bne * ;failed not equal (non zero)
3571 : 28 plp
3572 : 08 php ;save carry for next add
3573 : a50d lda ad1
3575 : f504 sbc sb2-ad2,x ;perform subtract
3577 : 08 php
3578 : c50f cmp adrl ;check result
trap_ne ;bad result
357a : d0fe > bne * ;failed not equal (non zero)
357c : 68 pla ;check flags
357d : 29c3 and #$c3 ;mask NV----ZC
357f : c511 cmp adrf
trap_ne ;bad flags
3581 : d0fe > bne * ;failed not equal (non zero)
3583 : 28 plp
; binary ADC / SBC abs,x
3584 : 08 php ;save carry for subtract
3585 : a50d lda ad1
3587 : 7df501 adc ada2-ad2,x ;perform add
358a : 08 php
358b : c50f cmp adrl ;check result
trap_ne ;bad result
358d : d0fe > bne * ;failed not equal (non zero)
358f : 68 pla ;check flags
3590 : 29c3 and #$c3 ;mask NV----ZC
3592 : c511 cmp adrf
trap_ne ;bad flags
3594 : d0fe > bne * ;failed not equal (non zero)
3596 : 28 plp
3597 : 08 php ;save carry for next add
3598 : a50d lda ad1
359a : fdf601 sbc sba2-ad2,x ;perform subtract
359d : 08 php
359e : c50f cmp adrl ;check result
trap_ne ;bad result
35a0 : d0fe > bne * ;failed not equal (non zero)
35a2 : 68 pla ;check flags
35a3 : 29c3 and #$c3 ;mask NV----ZC
35a5 : c511 cmp adrf
trap_ne ;bad flags
35a7 : d0fe > bne * ;failed not equal (non zero)
35a9 : 28 plp
; binary ADC / SBC abs,y
35aa : 08 php ;save carry for subtract
35ab : a50d lda ad1
35ad : 790401 adc ada2-$ff,y ;perform add
35b0 : 08 php
35b1 : c50f cmp adrl ;check result
trap_ne ;bad result
35b3 : d0fe > bne * ;failed not equal (non zero)
35b5 : 68 pla ;check flags
35b6 : 29c3 and #$c3 ;mask NV----ZC
35b8 : c511 cmp adrf
trap_ne ;bad flags
35ba : d0fe > bne * ;failed not equal (non zero)
35bc : 28 plp
35bd : 08 php ;save carry for next add
35be : a50d lda ad1
35c0 : f90501 sbc sba2-$ff,y ;perform subtract
35c3 : 08 php
35c4 : c50f cmp adrl ;check result
trap_ne ;bad result
35c6 : d0fe > bne * ;failed not equal (non zero)
35c8 : 68 pla ;check flags
35c9 : 29c3 and #$c3 ;mask NV----ZC
35cb : c511 cmp adrf
trap_ne ;bad flags
35cd : d0fe > bne * ;failed not equal (non zero)
35cf : 28 plp
; binary ADC / SBC (zp,x)
35d0 : 08 php ;save carry for subtract
35d1 : a50d lda ad1
35d3 : 6144 adc (lo adi2-ad2,x) ;perform add
35d5 : 08 php
35d6 : c50f cmp adrl ;check result
trap_ne ;bad result
35d8 : d0fe > bne * ;failed not equal (non zero)
35da : 68 pla ;check flags
35db : 29c3 and #$c3 ;mask NV----ZC
35dd : c511 cmp adrf
trap_ne ;bad flags
35df : d0fe > bne * ;failed not equal (non zero)
35e1 : 28 plp
35e2 : 08 php ;save carry for next add
35e3 : a50d lda ad1
35e5 : e146 sbc (lo sbi2-ad2,x) ;perform subtract
35e7 : 08 php
35e8 : c50f cmp adrl ;check result
trap_ne ;bad result
35ea : d0fe > bne * ;failed not equal (non zero)
35ec : 68 pla ;check flags
35ed : 29c3 and #$c3 ;mask NV----ZC
35ef : c511 cmp adrf
trap_ne ;bad flags
35f1 : d0fe > bne * ;failed not equal (non zero)
35f3 : 28 plp
; binary ADC / SBC (abs),y
35f4 : 08 php ;save carry for subtract
35f5 : a50d lda ad1
35f7 : 7156 adc (adiy2),y ;perform add
35f9 : 08 php
35fa : c50f cmp adrl ;check result
trap_ne ;bad result
35fc : d0fe > bne * ;failed not equal (non zero)
35fe : 68 pla ;check flags
35ff : 29c3 and #$c3 ;mask NV----ZC
3601 : c511 cmp adrf
trap_ne ;bad flags
3603 : d0fe > bne * ;failed not equal (non zero)
3605 : 28 plp
3606 : 08 php ;save carry for next add
3607 : a50d lda ad1
3609 : f158 sbc (sbiy2),y ;perform subtract
360b : 08 php
360c : c50f cmp adrl ;check result
trap_ne ;bad result
360e : d0fe > bne * ;failed not equal (non zero)
3610 : 68 pla ;check flags
3611 : 29c3 and #$c3 ;mask NV----ZC
3613 : c511 cmp adrf
trap_ne ;bad flags
3615 : d0fe > bne * ;failed not equal (non zero)
3617 : 28 plp
3618 : 60 rts
; target for the jump absolute test
3619 : 88 dey
361a : 88 dey
361b : test_far
361b : 08 php ;either SP or Y count will fail, if we do not hit
361c : 88 dey
361d : 88 dey
361e : 88 dey
361f : 28 plp
trap_cs ;flags loaded?
3620 : b0fe > bcs * ;failed carry set
trap_vs
3622 : 70fe > bvs * ;failed overflow set
trap_mi
3624 : 30fe > bmi * ;failed minus (bit 7 set)
trap_eq
3626 : f0fe > beq * ;failed equal (zero)
3628 : c946 cmp #'F' ;registers loaded?
trap_ne
362a : d0fe > bne * ;failed not equal (non zero)
362c : e041 cpx #'A'
trap_ne
362e : d0fe > bne * ;failed not equal (non zero)
3630 : c04f cpy #('R'-3)
trap_ne
3632 : d0fe > bne * ;failed not equal (non zero)
3634 : 48 pha ;save a,x
3635 : 8a txa
3636 : 48 pha
3637 : ba tsx
3638 : e0fd cpx #$fd ;check SP
trap_ne
363a : d0fe > bne * ;failed not equal (non zero)
363c : 68 pla ;restore x
363d : aa tax
set_stat $ff
> load_flag $ff
363e : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3640 : 48 > pha ;use stack to load status
3641 : 28 > plp
3642 : 68 pla ;restore a
3643 : e8 inx ;return registers with modifications
3644 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
3646 : 4cc208 jmp far_ret
; target for the jump indirect test
3649 : 00 align
364a : 5336 ptr_tst_ind dw test_ind
364c : 1709 ptr_ind_ret dw ind_ret
trap ;runover protection
364e : 4c4e36 > jmp * ;failed anyway
3651 : 88 dey
3652 : 88 dey
3653 : test_ind
3653 : 08 php ;either SP or Y count will fail, if we do not hit
3654 : 88 dey
3655 : 88 dey
3656 : 88 dey
3657 : 28 plp
trap_cs ;flags loaded?
3658 : b0fe > bcs * ;failed carry set
trap_vs
365a : 70fe > bvs * ;failed overflow set
trap_mi
365c : 30fe > bmi * ;failed minus (bit 7 set)
trap_eq
365e : f0fe > beq * ;failed equal (zero)
3660 : c949 cmp #'I' ;registers loaded?
trap_ne
3662 : d0fe > bne * ;failed not equal (non zero)
3664 : e04e cpx #'N'
trap_ne
3666 : d0fe > bne * ;failed not equal (non zero)
3668 : c041 cpy #('D'-3)
trap_ne
366a : d0fe > bne * ;failed not equal (non zero)
366c : 48 pha ;save a,x
366d : 8a txa
366e : 48 pha
366f : ba tsx
3670 : e0fd cpx #$fd ;check SP
trap_ne
3672 : d0fe > bne * ;failed not equal (non zero)
3674 : 68 pla ;restore x
3675 : aa tax
set_stat $ff
> load_flag $ff
3676 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3678 : 48 > pha ;use stack to load status
3679 : 28 > plp
367a : 68 pla ;restore a
367b : e8 inx ;return registers with modifications
367c : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
367e : 6c4c36 jmp (ptr_ind_ret)
trap ;runover protection
3681 : 4c8136 > jmp * ;failed anyway
; target for the jump subroutine test
3684 : 88 dey
3685 : 88 dey
3686 : test_jsr
3686 : 08 php ;either SP or Y count will fail, if we do not hit
3687 : 88 dey
3688 : 88 dey
3689 : 88 dey
368a : 28 plp
trap_cs ;flags loaded?
368b : b0fe > bcs * ;failed carry set
trap_vs
368d : 70fe > bvs * ;failed overflow set
trap_mi
368f : 30fe > bmi * ;failed minus (bit 7 set)
trap_eq
3691 : f0fe > beq * ;failed equal (zero)
3693 : c94a cmp #'J' ;registers loaded?
trap_ne
3695 : d0fe > bne * ;failed not equal (non zero)
3697 : e053 cpx #'S'
trap_ne
3699 : d0fe > bne * ;failed not equal (non zero)
369b : c04f cpy #('R'-3)
trap_ne
369d : d0fe > bne * ;failed not equal (non zero)
369f : 48 pha ;save a,x
36a0 : 8a txa
36a1 : 48 pha
36a2 : ba tsx ;sp -4? (return addr,a,x)
36a3 : e0fb cpx #$fb
trap_ne
36a5 : d0fe > bne * ;failed not equal (non zero)
36a7 : adff01 lda $1ff ;propper return on stack
36aa : c909 cmp #hi(jsr_ret)
trap_ne
36ac : d0fe > bne * ;failed not equal (non zero)
36ae : adfe01 lda $1fe
36b1 : c94d cmp #lo(jsr_ret)
trap_ne
36b3 : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
36b5 : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
36b7 : 48 > pha ;use stack to load status
36b8 : 28 > plp
36b9 : 68 pla ;pull x,a
36ba : aa tax
36bb : 68 pla
36bc : e8 inx ;return registers with modifications
36bd : 49aa eor #$aa ;N=1, V=1, Z=0, C=1
36bf : 60 rts
trap ;runover protection
36c0 : 4cc036 > jmp * ;failed anyway
;trap in case of unexpected IRQ, NMI, BRK, RESET - BRK test target
36c3 : nmi_trap
trap ;check stack for conditions at NMI
36c3 : 4cc336 > jmp * ;failed anyway
36c6 : res_trap
trap ;unexpected RESET
36c6 : 4cc636 > jmp * ;failed anyway
36c9 : 88 dey
36ca : 88 dey
36cb : irq_trap ;BRK test or unextpected BRK or IRQ
36cb : 08 php ;either SP or Y count will fail, if we do not hit
36cc : 88 dey
36cd : 88 dey
36ce : 88 dey
;next 4 traps could be caused by unexpected BRK or IRQ
;check stack for BREAK and originating location
;possible jump/branch into weeds (uninitialized space)
36cf : c942 cmp #'B' ;registers loaded?
trap_ne
36d1 : d0fe > bne * ;failed not equal (non zero)
36d3 : e052 cpx #'R'
trap_ne
36d5 : d0fe > bne * ;failed not equal (non zero)
36d7 : c048 cpy #('K'-3)
trap_ne
36d9 : d0fe > bne * ;failed not equal (non zero)
36db : 850a sta irq_a ;save registers during break test
36dd : 860b stx irq_x
36df : ba tsx ;test break on stack
36e0 : bd0201 lda $102,x
cmp_flag 0 ;break test should have B=1
36e3 : c930 > cmp #(0 |fao)&m8 ;expected flags + always on bits
trap_ne ; - no break flag on stack
36e5 : d0fe > bne * ;failed not equal (non zero)
36e7 : 68 pla
36e8 : c934 cmp #fai ;should have added interrupt disable
trap_ne
36ea : d0fe > bne * ;failed not equal (non zero)
36ec : ba tsx
36ed : e0fc cpx #$fc ;sp -3? (return addr, flags)
trap_ne
36ef : d0fe > bne * ;failed not equal (non zero)
36f1 : adff01 lda $1ff ;propper return on stack
36f4 : c909 cmp #hi(brk_ret)
trap_ne
36f6 : d0fe > bne * ;failed not equal (non zero)
36f8 : adfe01 lda $1fe
36fb : c984 cmp #lo(brk_ret)
trap_ne
36fd : d0fe > bne * ;failed not equal (non zero)
set_stat $ff
> load_flag $ff
36ff : a9ff > lda #$ff ;allow test to change I-flag (no mask)
>
3701 : 48 > pha ;use stack to load status
3702 : 28 > plp
3703 : a60b ldx irq_x
3705 : e8 inx ;return registers with modifications
3706 : a50a lda irq_a
3708 : 49aa eor #$aa ;N=1, V=1, Z=0, C=1 but original flags should be restored
370a : 40 rti
trap ;runover protection
370b : 4c0b37 > jmp * ;failed anyway
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
if (load_data_direct = 1) & (ROM_vectors = 1)
fffa = org $fffa ;vectors
fffa : c336 dw nmi_trap
fffc : c636 dw res_trap
fffe : cb36 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