MonkeyNES OpCode Test Shell Type 'help' for available commands Warning: This test shell replaces $0000-$0002 with the requested OpCode. No effect of executing the OpCode is restored. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Normal condition (No Page Boundry) ------ > memset 839a 55 Main Memory[$839A] set to $55 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op bd 7283 Syntax Ok: LDA $8372,X 4 cycles. > # Should be: ACC=55, IX=28, Cycles=4 > test acc = 55 true > test ix = 28 true > # Normal condition (Page Boundry) --------- > power on Power-On settings loaded. > memset 845f 55 Main Memory[$845F] set to $55 > op a2 ed Syntax Ok: LDX #$ED 2 cycles. > op bd 7283 Syntax Ok: LDA $8372,X 5 cycles. > # Should be: ACC=55, IX=ED, Cycles=5 > test acc = 55 true > test ix = ed true > # Zero condition -------------- > power on Power-On settings loaded. > memset 839a 00 Main Memory[$839A] set to $00 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op bd 7283 Syntax Ok: LDA $8372,X 4 cycles. > # Should be: ACC=0, IX=28, Z=1, Cycles=4 > test acc = 0 true > test ix = 28 true > test z = 1 true > # Negative condition ---------- > power on Power-On settings loaded. > memset 839a f2 Main Memory[$839A] set to $F2 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op bd 7283 Syntax Ok: LDA $8372,X 4 cycles. > # Should be: ACC=F2, IX=28, S=1, Cycles=4 > test acc = f2 true > test ix = 28 true > test s = 1 true > save verify_BD.txt Shell Output Saved to: 'verify_BD.txt'. Script Complete. > load ..\testscripts\master.txt Executing Script: '..\testscripts\master.txt'. > # Master Test Bucket - OpCodes have not been conclusively > # verified until the output from this script shows no errors. > load ..\testscripts\script_00.txt Executing Script: '..\testscripts\script_00.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Load the NMI Vector > memset fffe ef Main Memory[$FFFE] set to $EF > memset ffff be Main Memory[$FFFF] set to $BE > # Set some bits into the PS > memset dead ff Main Memory[$DEAD] set to $FF > op 2c adde Syntax Ok: BIT $DEAD 4 cycles. > # Should be: PS=E2 > test ps = e2 true > op 00 Syntax Ok: BRK 7 cycles. > # Should be: PC=BEEF, I=1, B=1 > # SP=FC, Mem[$01FF]=00, Mem[$01FE]=01 > # Mem[$01FD]=F2 > test pc = beef true > test i = 1 true > test b = 1 true > test sp = fc true > test m:01ff = 0 true > test m:01fe = 1 true > test m:01fd = f2 true > save verify_00.txt Shell Output Saved to: 'verify_00.txt'. Script Complete. > load ..\testscripts\script_05.txt Executing Script: '..\testscripts\script_05.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > memset 00be 72 Main Memory[$00BE] set to $72 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 05 be Syntax Ok: ORA $BE 2 cycles. > # Should be: ACC=77 > test acc = 77 true > # Negative test -------------------- > power on Power-On settings loaded. > memset 00be aa Main Memory[$00BE] set to $AA > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 05 be Syntax Ok: ORA $BE 2 cycles. > # Should be: ACC=FF, S=1 > test acc = ff true > test s = 1 true > # Zero test ---------------- > power on Power-On settings loaded. > memset 00be 00 Main Memory[$00BE] set to $00 > op a9 00 Syntax Ok: LDA #$00 2 cycles. > op 05 be Syntax Ok: ORA $BE 2 cycles. > # Should be: ACC=0, Z=1 > test acc = 0 true > test z = 1 true > save verify_05.txt Shell Output Saved to: 'verify_05.txt'. Script Complete. > load ..\testscripts\script_08.txt Executing Script: '..\testscripts\script_08.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Turn on some values in the PS > op 38 Syntax Ok: SEC 2 cycles. > op 78 Syntax Ok: SEI 2 cycles. > op F8 Syntax Ok: SED 2 cycles. > # Should be: SP=FF, PS=2D > test sp = ff true > test ps = 2d true > op 08 Syntax Ok: PHP 3 cycles. > # Should be: SP=FE, PS=2D, mem[$01FF]=2D > test sp = fe true > test ps = 2d true > test m:01ff = 2d true > save verify_08.txt Shell Output Saved to: 'verify_08.txt'. Script Complete. > load ..\testscripts\script_09.txt Executing Script: '..\testscripts\script_09.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 09 72 Syntax Ok: ORA #$72 2 cycles. > # Should be: ACC=77 > test acc = 77 true > # Negative test -------------------- > power on Power-On settings loaded. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 09 aa Syntax Ok: ORA #$AA 2 cycles. > # Should be: ACC=FF, S=1 > test acc = ff true > test s = 1 true > # Zero test ---------------- > power on Power-On settings loaded. > op a9 00 Syntax Ok: LDA #$00 2 cycles. > op 09 00 Syntax Ok: ORA #$00 2 cycles. > # Should be: ACC=0, Z=1 > test acc = 0 true > test z = 1 true > save verify_09.txt Shell Output Saved to: 'verify_09.txt'. Script Complete. > load ..\testscripts\script_0A.txt Executing Script: '..\testscripts\script_0A.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # No Flags Case ------------------------- > regset acc 35 ACC set to $35 > op 0a Syntax Ok: ASL A 2 cycles. > # Should be: ACC=6A, C=0, Z=0, S=0 > test acc = 6a true > test c = 0 true > test z = 0 true > test s = 0 true > # Carry Case ---------------------------- > regset acc ba ACC set to $BA > op 0a Syntax Ok: ASL A 2 cycles. > # Should be: ACC=74, C=1, Z=0, S=0 > test acc = 74 true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Case ----------------------------- > regset acc 80 ACC set to $80 > op 0a Syntax Ok: ASL A 2 cycles. > # Should be: ACC=0, C=1, Z=1, S=0 > test acc = 0 true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Case ------------------------- > regset acc 4c ACC set to $4C > op 0a Syntax Ok: ASL A 2 cycles. > # Should be: ACC=6A, C=0, Z=0, S=1 > test acc = 98 true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_0A.txt Shell Output Saved to: 'verify_0A.txt'. Script Complete. > load ..\testscripts\script_0D.txt Executing Script: '..\testscripts\script_0D.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > memset beef 72 Main Memory[$BEEF] set to $72 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 0d efbe Syntax Ok: ORA $BEEF 4 cycles. > # Should be: ACC=77 > test acc = 77 true > # Negative test -------------------- > power on Power-On settings loaded. > memset beef aa Main Memory[$BEEF] set to $AA > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 0d efbe Syntax Ok: ORA $BEEF 4 cycles. > # Should be: ACC=FF, S=1 > test acc = ff true > test s = 1 true > # Zero test ---------------- > power on Power-On settings loaded. > memset beef 00 Main Memory[$BEEF] set to $00 > op a9 00 Syntax Ok: LDA #$00 2 cycles. > op 0d efbe Syntax Ok: ORA $BEEF 4 cycles. > # Should be: ACC=0, Z=1 > test acc = 0 true > test z = 1 true > save verify_0D.txt Shell Output Saved to: 'verify_0D.txt'. Script Complete. > load ..\testscripts\script_10.txt Executing Script: '..\testscripts\script_10.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Branch instructions cannot be tested using the op > # command, and are loaded into memory directly and > # setup to execute with the step command. > # Branch not taken -------------------------------- > regset s 1 S set to $1 > regset pc 9040 PC set to $9040 > # Load op: BPL $40 > memset 9040 10 Main Memory[$9040] set to $10 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BPL $40 2 cycles. > # Should be: PC=9042, cycles=2 > test pc = 9042 true > # Positive Branch taken to same page -------------- > regset s 0 S set to $0 > regset pc 9040 PC set to $9040 > # Load op: BPL $40 > memset 9040 10 Main Memory[$9040] set to $10 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BPL $40 3 cycles. > # Should be: PC=9082, cycles=3 > test pc = 9082 true > # Negative Branch taken to same page -------------- > regset s 0 S set to $0 > regset pc 9040 PC set to $9040 > # Load op: BPL $A0 > memset 9040 10 Main Memory[$9040] set to $10 > memset 9041 A0 Main Memory[$9041] set to $A0 > step Executed: BPL $A0 3 cycles. > # Should be: PC=9022, cycles=3 > test pc = 9022 true > # Positive Branch taken to different page --------- > regset s 0 S set to $0 > regset pc 90b0 PC set to $90B0 > # Load op: BPL $7F > memset 90b0 10 Main Memory[$90B0] set to $10 > memset 90b1 7f Main Memory[$90B1] set to $7F > step Executed: BPL $7F 4 cycles. > # Should be: PC=9131, cycles=4 > test pc = 9131 true > # Negative Branch taken to different page --------- > regset s 0 S set to $0 > regset pc 9040 PC set to $9040 > # Load op: BPL $F7 > memset 9040 10 Main Memory[$9040] set to $10 > memset 9041 F7 Main Memory[$9041] set to $F7 > step Executed: BPL $F7 4 cycles. > # Should be: PC=8FCB, cycles=4 > test pc = 8FCB true > save verify_10.txt Shell Output Saved to: 'verify_10.txt'. Script Complete. > load ..\testscripts\script_15.txt Executing Script: '..\testscripts\script_15.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > memset 00c9 72 Main Memory[$00C9] set to $72 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 15 be Syntax Ok: ORA $BE,X 3 cycles. > # Should be: ACC=77, IX=0B > test acc = 77 true > test ix = 0b true > # Negative test -------------------- > power on Power-On settings loaded. > memset 00c9 aa Main Memory[$00C9] set to $AA > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 15 be Syntax Ok: ORA $BE,X 3 cycles. > # Should be: ACC=FF, IX=0B, S=1 > test acc = ff true > test ix = 0b true > test s = 1 true > # Zero test ---------------- > power on Power-On settings loaded. > memset 00c9 00 Main Memory[$00C9] set to $00 > op a9 00 Syntax Ok: LDA #$00 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 15 be Syntax Ok: ORA $BE,X 3 cycles. > # Should be: ACC=0, IX=0B, Z=1 > test acc = 0 true > test ix = 0b true > test z = 1 true > save verify_15.txt Shell Output Saved to: 'verify_15.txt'. Script Complete. > load ..\testscripts\script_18.txt Executing Script: '..\testscripts\script_18.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op 38 Syntax Ok: SEC 2 cycles. > # C flag should now be 1 > test c = 1 true > op 18 Syntax Ok: CLC 2 cycles. > # C flag should now be 0 again > test c = 0 true > save verify_18.txt Shell Output Saved to: 'verify_18.txt'. Script Complete. > load ..\testscripts\script_24.txt Executing Script: '..\testscripts\script_24.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # use bit to turn on V > memset 00ab 40 Main Memory[$00AB] set to $40 > op 24 ab Syntax Ok: BIT $AB 3 cycles. > # V should be 1 > test v = 1 true > # use bit to turn on S > memset 00ab 80 Main Memory[$00AB] set to $80 > op 24 ab Syntax Ok: BIT $AB 3 cycles. > # S should be 1 > test s = 1 true > # this should turn off Z > memset 00ab 01 Main Memory[$00AB] set to $01 > op a9 ff Syntax Ok: LDA #$FF 2 cycles. > op 24 ab Syntax Ok: BIT $AB 3 cycles. > # Z should be 0 > test z = 0 true > # this should turn on Z > memset 00ab 00 Main Memory[$00AB] set to $00 > op 24 ab Syntax Ok: BIT $AB 3 cycles. > # Z should be 1 > test z = 1 true > save verify_24.txt Shell Output Saved to: 'verify_24.txt'. Script Complete. > load ..\testscripts\script_25.txt Executing Script: '..\testscripts\script_25.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > memset 00be 72 Main Memory[$00BE] set to $72 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 25 be Syntax Ok: AND $BE 2 cycles. > # Should be: ACC=50 > test acc = 50 true > # Zero test -------------------- > power on Power-On settings loaded. > memset 00be aa Main Memory[$00BE] set to $AA > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 25 be Syntax Ok: AND $BE 2 cycles. > # Should be: ACC=0, Z=1 > test acc = 0 true > test z = 1 true > # Negative test ---------------- > power on Power-On settings loaded. > memset 00be aa Main Memory[$00BE] set to $AA > op a9 84 Syntax Ok: LDA #$84 2 cycles. > op 25 be Syntax Ok: AND $BE 2 cycles. > # Should be: ACC=80, S=1 > test acc = 80 true > test s = 1 true > save verify_25.txt Shell Output Saved to: 'verify_25.txt'. Script Complete. > load ..\testscripts\script_28.txt Executing Script: '..\testscripts\script_28.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Turn on some values in the PS > op 38 Syntax Ok: SEC 2 cycles. > op 78 Syntax Ok: SEI 2 cycles. > op F8 Syntax Ok: SED 2 cycles. > # Should be: SP=FF, PS=2D > test sp = ff true > test ps = 2d true > op 08 Syntax Ok: PHP 3 cycles. > # Should be: SP=FE, PS=2D, mem[$01FF]=2D > test sp = fe true > test ps = 2d true > test m:01ff = 2d true > # Clear out the values in the PS > op 18 Syntax Ok: CLC 2 cycles. > op 58 Syntax Ok: CLI 2 cycles. > op d8 Syntax Ok: CLD 2 cycles. > # Should be: PS=20 > test ps = 20 true > op 28 Syntax Ok: PLP 4 cycles. > # Should be: SP=FF, PS=2D > test sp = ff true > test ps = 2d true > save verify_28.txt Shell Output Saved to: 'verify_28.txt'. Script Complete. > load ..\testscripts\script_29.txt Executing Script: '..\testscripts\script_29.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 29 72 Syntax Ok: AND #$72 2 cycles. > # Should be: ACC=50 > test acc = 50 true > # Zero test -------------------- > power on Power-On settings loaded. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 29 aa Syntax Ok: AND #$AA 2 cycles. > # Should be: ACC=0, Z=1 > test acc = 0 true > test z = 1 true > # Negative test ---------------- > power on Power-On settings loaded. > op a9 84 Syntax Ok: LDA #$84 2 cycles. > op 29 aa Syntax Ok: AND #$AA 2 cycles. > # Should be: ACC=80, S=1 > test acc = 80 true > test s = 1 true > save verify_29.txt Shell Output Saved to: 'verify_29.txt'. Script Complete. > load ..\testscripts\script_2C.txt Executing Script: '..\testscripts\script_2C.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # use bit to turn on V > memset 1000 40 Main Memory[$1000] set to $40 > op 2c 0010 Syntax Ok: BIT $1000 4 cycles. > # V should be 1 > test v = 1 true > # use bit to turn on S > memset 1000 80 Main Memory[$1000] set to $80 > op 2c 0010 Syntax Ok: BIT $1000 4 cycles. > # S should be 1 > test s = 1 true > # this should turn off Z > memset 1000 01 Main Memory[$1000] set to $01 > op a9 ff Syntax Ok: LDA #$FF 2 cycles. > op 2c 0010 Syntax Ok: BIT $1000 4 cycles. > # Z should be 0 > test z = 0 true > # this should turn on Z > memset 1000 00 Main Memory[$1000] set to $00 > op 2c 0010 Syntax Ok: BIT $1000 4 cycles. > # Z should be 1 > test z = 1 true > save verify_2C.txt Shell Output Saved to: 'verify_2C.txt'. Script Complete. > load ..\testscripts\script_2D.txt Executing Script: '..\testscripts\script_2D.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > memset beef 72 Main Memory[$BEEF] set to $72 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 2d efbe Syntax Ok: AND $BEEF 4 cycles. > # Should be: ACC=50 > test acc = 50 true > # Zero test -------------------- > power on Power-On settings loaded. > memset beef aa Main Memory[$BEEF] set to $AA > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 2d efbe Syntax Ok: AND $BEEF 4 cycles. > # Should be: ACC=0, Z=1 > test acc = 0 true > test z = 1 true > # Negative test ---------------- > power on Power-On settings loaded. > memset beef aa Main Memory[$BEEF] set to $AA > op a9 84 Syntax Ok: LDA #$84 2 cycles. > op 2d efbe Syntax Ok: AND $BEEF 4 cycles. > # Should be: ACC=80, S=1 > test acc = 80 true > test s = 1 true > save verify_2D.txt Shell Output Saved to: 'verify_2D.txt'. Script Complete. > load ..\testscripts\script_30.txt Executing Script: '..\testscripts\script_30.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Branch instructions cannot be tested using the op > # command, and are loaded into memory directly and > # setup to execute with the step command. > # Branch not taken -------------------------------- > regset s 0 S set to $0 > regset pc 9040 PC set to $9040 > # Load op: BMI $40 > memset 9040 30 Main Memory[$9040] set to $30 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BMI $40 2 cycles. > # Should be: PC=9042, cycles=2 > test pc = 9042 true > # Positive Branch taken to same page -------------- > regset s 1 S set to $1 > regset pc 9040 PC set to $9040 > # Load op: BMI $40 > memset 9040 30 Main Memory[$9040] set to $30 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BMI $40 3 cycles. > # Should be: PC=9082, cycles=3 > test pc = 9082 true > # Negative Branch taken to same page -------------- > regset s 1 S set to $1 > regset pc 9040 PC set to $9040 > # Load op: BMI $A0 > memset 9040 30 Main Memory[$9040] set to $30 > memset 9041 A0 Main Memory[$9041] set to $A0 > step Executed: BMI $A0 3 cycles. > # Should be: PC=9022, cycles=3 > test pc = 9022 true > # Positive Branch taken to different page --------- > regset s 1 S set to $1 > regset pc 90b0 PC set to $90B0 > # Load op: BMI $7F > memset 90b0 30 Main Memory[$90B0] set to $30 > memset 90b1 7f Main Memory[$90B1] set to $7F > step Executed: BMI $7F 4 cycles. > # Should be: PC=9131, cycles=4 > test pc = 9131 true > # Negative Branch taken to different page --------- > regset s 1 S set to $1 > regset pc 9040 PC set to $9040 > # Load op: BMI $F7 > memset 9040 30 Main Memory[$9040] set to $30 > memset 9041 F7 Main Memory[$9041] set to $F7 > step Executed: BMI $F7 4 cycles. > # Should be: PC=8FCB, cycles=4 > test pc = 8FCB true > save verify_30.txt Shell Output Saved to: 'verify_30.txt'. Script Complete. > load ..\testscripts\script_35.txt Executing Script: '..\testscripts\script_35.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > memset 00c9 72 Main Memory[$00C9] set to $72 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 35 be Syntax Ok: AND $BE,X 3 cycles. > # Should be: ACC=50, IX=0B > test acc = 50 true > test ix = 0b true > # Zero test -------------------- > power on Power-On settings loaded. > memset 00c9 aa Main Memory[$00C9] set to $AA > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 35 be Syntax Ok: AND $BE,X 3 cycles. > # Should be: ACC=0, IX=0B, Z=1 > test acc = 0 true > test ix = 0b true > test z = 1 true > # Negative test ---------------- > power on Power-On settings loaded. > memset 00c9 aa Main Memory[$00C9] set to $AA > op a9 84 Syntax Ok: LDA #$84 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 35 be Syntax Ok: AND $BE,X 3 cycles. > # Should be: ACC=80, IX=0B, S=1 > test acc = 80 true > test ix = 0b true > test s = 1 true > save verify_35.txt Shell Output Saved to: 'verify_35.txt'. Script Complete. > load ..\testscripts\script_38.txt Executing Script: '..\testscripts\script_38.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op 38 Syntax Ok: SEC 2 cycles. > # C flag should now be 1 > test c = 1 true > save verify_38.txt Shell Output Saved to: 'verify_38.txt'. Script Complete. > load ..\testscripts\script_40.txt Executing Script: '..\testscripts\script_40.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Load the NMI Vector > memset fffe ef Main Memory[$FFFE] set to $EF > memset ffff be Main Memory[$FFFF] set to $BE > # Set some bits into the PS > memset dead ff Main Memory[$DEAD] set to $FF > op 2c adde Syntax Ok: BIT $DEAD 4 cycles. > # Should be: PS=E2 > test ps = e2 true > op 00 Syntax Ok: BRK 7 cycles. > # Should be: PC=BEEF, I=1, B=1 > # SP=FC, Mem[$01FF]=00, Mem[$01FE]=01 > # Mem[$01FD]=F2 > test pc = beef true > test i = 1 true > test b = 1 true > test sp = fc true > test m:01ff = 0 true > test m:01fe = 1 true > test m:01fd = f2 true > # Now for the RTI ---------------- > op 40 Syntax Ok: RTI 6 cycles. > # Should be: PC=0001, I=0, B=1 > # SP=FF, PS=F2 > test pc = 1 true > test i = 0 true > test b = 1 true > test sp = ff true > test ps = f2 true > save verify_40.txt Shell Output Saved to: 'verify_40.txt'. Script Complete. > load ..\testscripts\script_45.txt Executing Script: '..\testscripts\script_45.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > memset 00be 72 Main Memory[$00BE] set to $72 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 45 be Syntax Ok: EOR $BE 3 cycles. > # Should be: ACC=27 > test acc = 27 true > # Negative test -------------------- > power on Power-On settings loaded. > memset 00be aa Main Memory[$00BE] set to $AA > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 45 be Syntax Ok: EOR $BE 3 cycles. > # Should be: ACC=FF, S=1 > test acc = ff true > test s = 1 true > # Zero test ---------------- > power on Power-On settings loaded. > memset 00be 55 Main Memory[$00BE] set to $55 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 45 be Syntax Ok: EOR $BE 3 cycles. > # Should be: ACC=0, Z=1 > test acc = 0 true > test z = 1 true > save verify_45.txt Shell Output Saved to: 'verify_45.txt'. Script Complete. > load ..\testscripts\script_48.txt Executing Script: '..\testscripts\script_48.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > # Should be: SP=FF, ACC=55 > test sp = ff true > test acc = 55 true > op 48 Syntax Ok: PHA 3 cycles. > # Should be: SP=FE, ACC=55, mem[$01FF]=55 > test sp = fe true > test acc = 55 true > test m:01ff = 55 true > save verify_48.txt Shell Output Saved to: 'verify_48.txt'. Script Complete. > load ..\testscripts\script_49.txt Executing Script: '..\testscripts\script_49.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 49 72 Syntax Ok: EOR #$72 2 cycles. > # Should be: ACC=27 > test acc = 27 true > # Negative test -------------------- > power on Power-On settings loaded. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 49 aa Syntax Ok: EOR #$AA 2 cycles. > # Should be: ACC=FF, S=1 > test acc = ff true > test s = 1 true > # Zero test ---------------- > power on Power-On settings loaded. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 49 55 Syntax Ok: EOR #$55 2 cycles. > # Should be: ACC=0, Z=1 > test acc = 0 true > test z = 1 true > save verify_49.txt Shell Output Saved to: 'verify_49.txt'. Script Complete. > load ..\testscripts\script_4C.txt Executing Script: '..\testscripts\script_4C.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op 4c efbe Syntax Ok: JMP $BEEF 3 cycles. > # Should be: PC=BEEF > test pc = beef true > save verify_4C.txt Shell Output Saved to: 'verify_4C.txt'. Script Complete. > load ..\testscripts\script_4D.txt Executing Script: '..\testscripts\script_4D.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > memset beef 72 Main Memory[$BEEF] set to $72 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 4d efbe Syntax Ok: EOR $BEEF 4 cycles. > # Should be: ACC=27 > test acc = 27 true > # Negative test -------------------- > power on Power-On settings loaded. > memset beef aa Main Memory[$BEEF] set to $AA > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 4d efbe Syntax Ok: EOR $BEEF 4 cycles. > # Should be: ACC=FF, S=1 > test acc = ff true > test s = 1 true > # Zero test ---------------- > power on Power-On settings loaded. > memset beef 55 Main Memory[$BEEF] set to $55 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 4d efbe Syntax Ok: EOR $BEEF 4 cycles. > # Should be: ACC=0, Z=1 > test acc = 0 true > test z = 1 true > save verify_4D.txt Shell Output Saved to: 'verify_4D.txt'. Script Complete. > load ..\testscripts\script_50.txt Executing Script: '..\testscripts\script_50.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Branch instructions cannot be tested using the op > # command, and are loaded into memory directly and > # setup to execute with the step command. > # Branch not taken -------------------------------- > regset v 1 V set to $1 > regset pc 9040 PC set to $9040 > # Load op: BVC $40 > memset 9040 50 Main Memory[$9040] set to $50 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BVC $40 2 cycles. > # Should be: PC=9042, cycles=2 > test pc = 9042 true > # Positive Branch taken to same page -------------- > regset v 0 V set to $0 > regset pc 9040 PC set to $9040 > # Load op: BVC $40 > memset 9040 50 Main Memory[$9040] set to $50 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BVC $40 3 cycles. > # Should be: PC=9082, cycles=3 > test pc = 9082 true > # Negative Branch taken to same page -------------- > regset v 0 V set to $0 > regset pc 9040 PC set to $9040 > # Load op: BVC $A0 > memset 9040 50 Main Memory[$9040] set to $50 > memset 9041 A0 Main Memory[$9041] set to $A0 > step Executed: BVC $A0 3 cycles. > # Should be: PC=9022, cycles=3 > test pc = 9022 true > # Positive Branch taken to different page --------- > regset v 0 V set to $0 > regset pc 90b0 PC set to $90B0 > # Load op: BVC $7F > memset 90b0 50 Main Memory[$90B0] set to $50 > memset 90b1 7f Main Memory[$90B1] set to $7F > step Executed: BVC $7F 4 cycles. > # Should be: PC=9131, cycles=4 > test pc = 9131 true > # Negative Branch taken to different page --------- > regset v 0 V set to $0 > regset pc 9040 PC set to $9040 > # Load op: BVC $F7 > memset 9040 50 Main Memory[$9040] set to $50 > memset 9041 F7 Main Memory[$9041] set to $F7 > step Executed: BVC $F7 4 cycles. > # Should be: PC=8FCB, cycles=4 > test pc = 8FCB true > save verify_50.txt Shell Output Saved to: 'verify_50.txt'. Script Complete. > load ..\testscripts\script_55.txt Executing Script: '..\testscripts\script_55.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Base test -------------------- > memset 00c9 72 Main Memory[$00C9] set to $72 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 55 be Syntax Ok: EOR $BE,X 4 cycles. > # Should be: ACC=27, IX=0B > test acc = 27 true > test ix = 0b true > # Negative test -------------------- > power on Power-On settings loaded. > memset 00c9 aa Main Memory[$00C9] set to $AA > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 55 be Syntax Ok: EOR $BE,X 4 cycles. > # Should be: ACC=FF, IX=0B, S=1 > test acc = ff true > test ix = 0b true > test s = 1 true > # Zero test ---------------- > power on Power-On settings loaded. > memset 00c9 55 Main Memory[$00C9] set to $55 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 55 be Syntax Ok: EOR $BE,X 4 cycles. > # Should be: ACC=0, IX=0B, Z=1 > test acc = 0 true > test ix = 0b true > test z = 1 true > save verify_55.txt Shell Output Saved to: 'verify_55.txt'. Script Complete. > load ..\testscripts\script_58.txt Executing Script: '..\testscripts\script_58.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op 78 Syntax Ok: SEI 2 cycles. > # I flag should now be 1 > test i = 1 true > op 58 Syntax Ok: CLI 2 cycles. > # I flag should now be 0 again > test i = 0 true > save verify_58.txt Shell Output Saved to: 'verify_58.txt'. Script Complete. > load ..\testscripts\script_68.txt Executing Script: '..\testscripts\script_68.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > # Should be: SP=FF, ACC=55 > test sp = ff true > test acc = 55 true > op 48 Syntax Ok: PHA 3 cycles. > # Should be: SP=FE, ACC=55, mem[$01FF]=55 > test sp = fe true > test acc = 55 true > test m:01ff = 55 true > # Set the ACC to something else > op a9 01 Syntax Ok: LDA #$01 2 cycles. > # Should be: ACC=01 > test acc = 01 true > op 68 Syntax Ok: PLA 4 cycles. > # Should be: SP=FF, ACC=55 > test sp = ff true > test acc = 55 true > save verify_68.txt Shell Output Saved to: 'verify_68.txt'. Script Complete. > load ..\testscripts\script_69.txt Executing Script: '..\testscripts\script_69.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # No flags case ---------------------------- > op 18 Syntax Ok: CLC 2 cycles. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 69 12 Syntax Ok: ADC #$12 2 cycles. > # Should be: ACC=67, C=0, V=0, S=0, Z=0 > test acc = 67 true > test c = 0 true > test v = 0 true > test s = 0 true > test z = 0 true > # Carry flag case -------------------------- > op 18 Syntax Ok: CLC 2 cycles. > op a9 fe Syntax Ok: LDA #$FE 2 cycles. > op 69 e7 Syntax Ok: ADC #$E7 2 cycles. > # Should be: ACC=E5, C=1, V=0, S=1, Z=0 > test acc = e5 true > test c = 1 true > test v = 0 true > test s = 1 true > test z = 0 true > # Overflow and Negative flag case ---------- > op 18 Syntax Ok: CLC 2 cycles. > op a9 75 Syntax Ok: LDA #$75 2 cycles. > op 69 12 Syntax Ok: ADC #$12 2 cycles. > # Should be: ACC=67, C=0, V=1, S=1, Z=0 > test acc = 87 true > test c = 0 true > test v = 1 true > test s = 1 true > test z = 0 true > # Zero flag case --------------------------- > op 18 Syntax Ok: CLC 2 cycles. > op a9 72 Syntax Ok: LDA #$72 2 cycles. > op 69 8e Syntax Ok: ADC #$8E 2 cycles. > # Should be: ACC=0, C=1, V=0, S=0, Z=1 > test acc = 0 true > test c = 1 true > test v = 0 true > test s = 0 true > test z = 1 true > # Use Carry Flag case ---------------------- > op 38 Syntax Ok: SEC 2 cycles. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 69 12 Syntax Ok: ADC #$12 2 cycles. > # Should be: ACC=68, C=0, V=0, S=0, Z=0 > test acc = 68 true > test c = 0 true > test v = 0 true > test s = 0 true > test z = 0 true > save verify_69.txt Shell Output Saved to: 'verify_69.txt'. Script Complete. > load ..\testscripts\script_6C.txt Executing Script: '..\testscripts\script_6C.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset beef ad Main Memory[$BEEF] set to $AD > memset bef0 de Main Memory[$BEF0] set to $DE > op 6c efbe Syntax Ok: JMP ($BEEF) 5 cycles. > # Should be: PC=DEAD > test pc = dead true > save verify_6C.txt Shell Output Saved to: 'verify_6C.txt'. Script Complete. > load ..\testscripts\script_70.txt Executing Script: '..\testscripts\script_70.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Branch instructions cannot be tested using the op > # command, and are loaded into memory directly and > # setup to execute with the step command. > # Branch not taken -------------------------------- > regset v 0 V set to $0 > regset pc 9040 PC set to $9040 > # Load op: BVS $40 > memset 9040 70 Main Memory[$9040] set to $70 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BVS $40 2 cycles. > # Should be: PC=9042, cycles=2 > test pc = 9042 true > # Positive Branch taken to same page -------------- > regset v 1 V set to $1 > regset pc 9040 PC set to $9040 > # Load op: BVS $40 > memset 9040 70 Main Memory[$9040] set to $70 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BVS $40 3 cycles. > # Should be: PC=9082, cycles=3 > test pc = 9082 true > # Negative Branch taken to same page -------------- > regset v 1 V set to $1 > regset pc 9040 PC set to $9040 > # Load op: BVS $A0 > memset 9040 70 Main Memory[$9040] set to $70 > memset 9041 A0 Main Memory[$9041] set to $A0 > step Executed: BVS $A0 3 cycles. > # Should be: PC=9022, cycles=3 > test pc = 9022 true > # Positive Branch taken to different page --------- > regset v 1 V set to $1 > regset pc 90b0 PC set to $90B0 > # Load op: BVS $7F > memset 90b0 70 Main Memory[$90B0] set to $70 > memset 90b1 7f Main Memory[$90B1] set to $7F > step Executed: BVS $7F 4 cycles. > # Should be: PC=9131, cycles=4 > test pc = 9131 true > # Negative Branch taken to different page --------- > regset v 1 V set to $1 > regset pc 9040 PC set to $9040 > # Load op: BVS $F7 > memset 9040 70 Main Memory[$9040] set to $70 > memset 9041 F7 Main Memory[$9041] set to $F7 > step Executed: BVS $F7 4 cycles. > # Should be: PC=8FCB, cycles=4 > test pc = 8FCB true > save verify_70.txt Shell Output Saved to: 'verify_70.txt'. Script Complete. > load ..\testscripts\script_78.txt Executing Script: '..\testscripts\script_78.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op 78 Syntax Ok: SEI 2 cycles. > # I flag should now be 1 > test i = 1 true > save verify_78.txt Shell Output Saved to: 'verify_78.txt'. Script Complete. > load ..\testscripts\script_7C.txt Executing Script: '..\testscripts\script_7C.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 7c efbe Syntax Ok: JMP $BEEF,X 6 cycles. > # Should be: PC=BEFA > test pc = befa true > save verify_7C.txt Shell Output Saved to: 'verify_7C.txt'. Script Complete. > load ..\testscripts\script_84.txt Executing Script: '..\testscripts\script_84.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Set mem[$0072] to some other value 1st > memset 0072 ab Main Memory[$0072] set to $AB > op a0 55 Syntax Ok: LDY #$55 2 cycles. > op 84 72 Syntax Ok: STY $72 3 cycles. > # mem[$0072] and IY should = $55 > test iy = 55 true > test m:0072 = 55 true > save verify_84.txt Shell Output Saved to: 'verify_84.txt'. Script Complete. > load ..\testscripts\script_85.txt Executing Script: '..\testscripts\script_85.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Set mem[$0072] to some other value 1st > memset 0072 ab Main Memory[$0072] set to $AB > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 85 72 Syntax Ok: STA $72 3 cycles. > # mem[$0072] and ACC should = $55 > test acc = 55 true > test m:0072 = 55 true > save verify_85.txt Shell Output Saved to: 'verify_85.txt'. Script Complete. > load ..\testscripts\script_86.txt Executing Script: '..\testscripts\script_86.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Set mem[$0072] to some other value 1st > memset 0072 ab Main Memory[$0072] set to $AB > op a2 55 Syntax Ok: LDX #$55 2 cycles. > op 86 72 Syntax Ok: STX $72 3 cycles. > # mem[$0072] and IX should = $55 > test ix = 55 true > test m:0072 = 55 true > save verify_86.txt Shell Output Saved to: 'verify_86.txt'. Script Complete. > load ..\testscripts\script_88.txt Executing Script: '..\testscripts\script_88.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a0 55 Syntax Ok: LDY #$55 2 cycles. > # IY should now be set to 55 > test iy = 55 true > op 88 Syntax Ok: DEY 2 cycles. > # IY should now be set to 54 > test iy = 54 true > # Wrap and negative case -------------- > power on Power-On settings loaded. > op a0 00 Syntax Ok: LDY #$00 2 cycles. > # IY should now be set to 00 > test iy = 0 true > op 88 Syntax Ok: DEY 2 cycles. > # Should be: IY=FF, S=1 > test iy = ff true > test s = 1 true > # Zero case -------------------------- > power on Power-On settings loaded. > op a0 01 Syntax Ok: LDY #$01 2 cycles. > # Should be: IY=01, Z=0 > test iy = 1 true > test z = 0 true > op 88 Syntax Ok: DEY 2 cycles. > # Should be: IY=00, Z=1 > test iy = 0 true > test z = 1 true > save verify_88.txt Shell Output Saved to: 'verify_88.txt'. Script Complete. > load ..\testscripts\script_8A.txt Executing Script: '..\testscripts\script_8A.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a2 55 Syntax Ok: LDX #$55 2 cycles. > # IX should now show $55 > test ix = 55 true > op 8a Syntax Ok: TXA 2 cycles. > # ACC and IX should now show $55 > test acc = 55 true > test ix = 55 true > # Now for the Z flag case -------------------- > power on Power-On settings loaded. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 00 Syntax Ok: LDX #$00 2 cycles. > # Use the IY register to reset Z > op a0 01 Syntax Ok: LDY #$01 2 cycles. > # Should be: ACC=55, IX=0, Z=0 > test acc = 55 true > test ix = 0 true > test z = 0 true > op 8a Syntax Ok: TXA 2 cycles. > # Should be: ACC=0, IX=0, Z=1 > test acc = 0 true > test ix = 0 true > test z = 1 true > # Now for the S flag case -------------------- > power on Power-On settings loaded. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 f2 Syntax Ok: LDX #$F2 2 cycles. > # Use the IY register to reset S > op a0 01 Syntax Ok: LDY #$01 2 cycles. > # Should be: ACC=55, IX=F2, S=0 > test acc = 55 true > test ix = f2 true > test s = 0 true > op 8a Syntax Ok: TXA 2 cycles. > # Should be: ACC=F2, IX=F2, S=1 > test acc = f2 true > test ix = f2 true > test s = 1 true > save verify_8A.txt Shell Output Saved to: 'verify_8A.txt'. Script Complete. > load ..\testscripts\script_8C.txt Executing Script: '..\testscripts\script_8C.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a0 55 Syntax Ok: LDY #$55 2 cycles. > op 8c efbe Syntax Ok: STY $BEEF 4 cycles. > # mem[$BEEF] and IY should = $55 > test iy = 55 true > test m:beef = 55 true > save verify_8C.txt Shell Output Saved to: 'verify_8C.txt'. Script Complete. > load ..\testscripts\script_8D.txt Executing Script: '..\testscripts\script_8D.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op 8d efbe Syntax Ok: STA $BEEF 4 cycles. > # mem[$BEEF] and ACC should = $55 > test acc = 55 true > test m:beef = 55 true > save verify_8D.txt Shell Output Saved to: 'verify_8D.txt'. Script Complete. > load ..\testscripts\script_8E.txt Executing Script: '..\testscripts\script_8E.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a2 55 Syntax Ok: LDX #$55 2 cycles. > op 8e efbe Syntax Ok: STX $BEEF 4 cycles. > # mem[$BEEF] and IX should = $55 > test ix = 55 true > test m:beef = 55 true > save verify_8E.txt Shell Output Saved to: 'verify_8E.txt'. Script Complete. > load ..\testscripts\script_90.txt Executing Script: '..\testscripts\script_90.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Branch instructions cannot be tested using the op > # command, and are loaded into memory directly and > # setup to execute with the step command. > # Branch not taken -------------------------------- > regset c 1 C set to $1 > regset pc 9040 PC set to $9040 > # Load op: BCC $40 > memset 9040 90 Main Memory[$9040] set to $90 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BCC $40 2 cycles. > # Should be: PC=9042, cycles=2 > test pc = 9042 true > # Positive Branch taken to same page -------------- > regset c 0 C set to $0 > regset pc 9040 PC set to $9040 > # Load op: BCC $40 > memset 9040 90 Main Memory[$9040] set to $90 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BCC $40 3 cycles. > # Should be: PC=9082, cycles=3 > test pc = 9082 true > # Negative Branch taken to same page -------------- > regset c 0 C set to $0 > regset pc 9040 PC set to $9040 > # Load op: BCC $A0 > memset 9040 90 Main Memory[$9040] set to $90 > memset 9041 A0 Main Memory[$9041] set to $A0 > step Executed: BCC $A0 3 cycles. > # Should be: PC=9022, cycles=3 > test pc = 9022 true > # Positive Branch taken to different page --------- > regset c 0 C set to $0 > regset pc 90b0 PC set to $90B0 > # Load op: BCC $7F > memset 90b0 90 Main Memory[$90B0] set to $90 > memset 90b1 7f Main Memory[$90B1] set to $7F > step Executed: BCC $7F 4 cycles. > # Should be: PC=9131, cycles=4 > test pc = 9131 true > # Negative Branch taken to different page --------- > regset c 0 C set to $0 > regset pc 9040 PC set to $9040 > # Load op: BCC $F7 > memset 9040 90 Main Memory[$9040] set to $90 > memset 9041 F7 Main Memory[$9041] set to $F7 > step Executed: BCC $F7 4 cycles. > # Should be: PC=8FCB, cycles=4 > test pc = 8FCB true > save verify_90.txt Shell Output Saved to: 'verify_90.txt'. Script Complete. > load ..\testscripts\script_94.txt Executing Script: '..\testscripts\script_94.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # The "stay within zero page" condition > op a0 55 Syntax Ok: LDY #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 94 be Syntax Ok: STY $BE,X 4 cycles. > # Should be: IY=55, IX=0B, mem[$00C9]=55 > test iy = 55 true > test ix = 0b true > test m:00c9 = 55 true > # The "overshoot the zero page" condition > op a0 62 Syntax Ok: LDY #$62 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 94 f7 Syntax Ok: STY $F7,X 4 cycles. > # Should be: IY=62, IX=0B, mem[$0102]=62 > test iy = 62 true > test ix = 0b true > test m:0102 = 62 true > save verify_94.txt Shell Output Saved to: 'verify_94.txt'. Script Complete. > load ..\testscripts\script_95.txt Executing Script: '..\testscripts\script_95.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # The "stay within zero page" condition > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 95 be Syntax Ok: STA $BE,X 4 cycles. > # Should be: ACC=55, IX=0B, mem[$00C9]=55 > test acc = 55 true > test ix = 0b true > test m:00c9 = 55 true > # The "overshoot the zero page" condition > op a9 62 Syntax Ok: LDA #$62 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op 95 f7 Syntax Ok: STA $F7,X 4 cycles. > # Should be: ACC=62, IX=0B, mem[$0102]=62 > test acc = 62 true > test ix = 0b true > test m:0102 = 62 true > save verify_95.txt Shell Output Saved to: 'verify_95.txt'. Script Complete. > load ..\testscripts\script_96.txt Executing Script: '..\testscripts\script_96.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # The "stay within zero page" condition > op a2 55 Syntax Ok: LDX #$55 2 cycles. > op a0 0b Syntax Ok: LDY #$0B 2 cycles. > op 96 be Syntax Ok: STX $BE,Y 4 cycles. > # Should be: IY=0B, IX=55, mem[$00C9]=55 > test iy = 0b true > test ix = 55 true > test m:00c9 = 55 true > # The "overshoot the zero page" condition > op a2 62 Syntax Ok: LDX #$62 2 cycles. > op a0 0b Syntax Ok: LDY #$0B 2 cycles. > op 96 f7 Syntax Ok: STX $F7,Y 4 cycles. > # Should be: IY=0B, IX=62, mem[$0102]=62 > test iy = 0b true > test ix = 62 true > test m:0102 = 62 true > save verify_96.txt Shell Output Saved to: 'verify_96.txt'. Script Complete. > load ..\testscripts\script_98.txt Executing Script: '..\testscripts\script_98.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a0 55 Syntax Ok: LDY #$55 2 cycles. > # IY should now show $55 > test iy = 55 true > op 98 Syntax Ok: TYA 2 cycles. > # ACC and IY should now show $55 > test acc = 55 true > test iy = 55 true > # Now for the Z flag case -------------------- > power on Power-On settings loaded. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a0 00 Syntax Ok: LDY #$00 2 cycles. > # Use the IX register to reset Z > op a2 01 Syntax Ok: LDX #$01 2 cycles. > # Should be: ACC=55, IY=0, Z=0 > test acc = 55 true > test iy = 0 true > test z = 0 true > op 98 Syntax Ok: TYA 2 cycles. > # Should be: ACC=0, IY=0, Z=1 > test acc = 0 true > test iy = 0 true > test z = 1 true > # Now for the S flag case -------------------- > power on Power-On settings loaded. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a0 f2 Syntax Ok: LDY #$F2 2 cycles. > # Use the IX register to reset S > op a2 01 Syntax Ok: LDX #$01 2 cycles. > # Should be: ACC=55, IY=F2, S=0 > test acc = 55 true > test iy = f2 true > test s = 0 true > op 98 Syntax Ok: TYA 2 cycles. > # Should be: ACC=F2, IY=F2, S=1 > test acc = f2 true > test iy = f2 true > test s = 1 true > save verify_98.txt Shell Output Saved to: 'verify_98.txt'. Script Complete. > load ..\testscripts\script_99.txt Executing Script: '..\testscripts\script_99.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a0 0B Syntax Ok: LDY #$0B 2 cycles. > op 99 efbe Syntax Ok: STA $BEEF,Y 5 cycles. > # Should be: ACC=55, IY=0B, mem[$BEFA]=55 > test acc = 55 true > test iy = 0b true > test m:befa = 55 true > save verify_99.txt Shell Output Saved to: 'verify_99.txt'. Script Complete. > load ..\testscripts\script_9A.txt Executing Script: '..\testscripts\script_9A.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a2 55 Syntax Ok: LDX #$55 2 cycles. > # IX should now show $55 > test ix = 55 true > op 9a Syntax Ok: TXS 2 cycles. > # SP and IX should now show $55 > test sp = 55 true > test ix = 55 true > save verify_9A.txt Shell Output Saved to: 'verify_9A.txt'. Script Complete. > load ..\testscripts\script_9D.txt Executing Script: '..\testscripts\script_9D.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0B Syntax Ok: LDX #$0B 2 cycles. > op 9d efbe Syntax Ok: STA $BEEF,X 5 cycles. > # Should be: ACC=55, IX=0B, mem[$BEFA]=55 > test acc = 55 true > test ix = 0b true > test m:befa = 55 true > save verify_9D.txt Shell Output Saved to: 'verify_9D.txt'. Script Complete. > load ..\testscripts\script_A0.txt Executing Script: '..\testscripts\script_A0.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a0 55 Syntax Ok: LDY #$55 2 cycles. > # IY should now show $55 > test iy = 55 true > op a0 00 Syntax Ok: LDY #$00 2 cycles. > # IY should be 0 and Z should be 1 > test iy = 0 true > test z = 1 true > op a0 f2 Syntax Ok: LDY #$F2 2 cycles. > # IY should be f2 and S should be 1 > test iy = f2 true > test s = 1 true > regs CPU Registers PC: $2 SP: $FF ACC: $0 IX: $0 IY: $F2 Flags S V - B D I Z C PS: 1 0 1 0 0 0 0 0 > save verify_A0.txt Shell Output Saved to: 'verify_A0.txt'. Script Complete. > load ..\testscripts\script_A2.txt Executing Script: '..\testscripts\script_A2.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a2 55 Syntax Ok: LDX #$55 2 cycles. > # IX should now show $55 > test ix = 55 true > op a2 00 Syntax Ok: LDX #$00 2 cycles. > # IX should be 0 and Z should be 1 > test ix = 0 true > test z = 1 true > op a2 f2 Syntax Ok: LDX #$F2 2 cycles. > # IX should be f2 and S should be 1 > test ix = f2 true > test s = 1 true > regs CPU Registers PC: $2 SP: $FF ACC: $0 IX: $F2 IY: $0 Flags S V - B D I Z C PS: 1 0 1 0 0 0 0 0 > save verify_A2.txt Shell Output Saved to: 'verify_A2.txt'. Script Complete. > load ..\testscripts\script_A4.txt Executing Script: '..\testscripts\script_A4.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Normal condition ------------ > memset 0072 55 Main Memory[$0072] set to $55 > op a4 72 Syntax Ok: LDY $72 3 cycles. > # Should be: IY=55 > test iy = 55 true > # Zero condition ------------ > power on Power-On settings loaded. > memset 0072 00 Main Memory[$0072] set to $00 > op a4 72 Syntax Ok: LDY $72 3 cycles. > # Should be: IY=0, Z=1 > test iy = 0 true > test z = 1 true > # Negative condition ------------ > power on Power-On settings loaded. > memset 0072 f2 Main Memory[$0072] set to $F2 > op a4 72 Syntax Ok: LDY $72 3 cycles. > # Should be: IY=F2, S=1 > test iy = f2 true > test s = 1 true > save verify_A4.txt Shell Output Saved to: 'verify_A4.txt'. Script Complete. > load ..\testscripts\script_A5.txt Executing Script: '..\testscripts\script_A5.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Normal condition ------------ > memset 0072 55 Main Memory[$0072] set to $55 > op a5 72 Syntax Ok: LDA $72 3 cycles. > # Should be: ACC=55 > test acc = 55 true > # Zero condition ------------ > power on Power-On settings loaded. > memset 0072 00 Main Memory[$0072] set to $00 > op a5 72 Syntax Ok: LDA $72 3 cycles. > # Should be: ACC=0, Z=1 > test acc = 0 true > test z = 1 true > # Negative condition ------------ > power on Power-On settings loaded. > memset 0072 f2 Main Memory[$0072] set to $F2 > op a5 72 Syntax Ok: LDA $72 3 cycles. > # Should be: ACC=F2, S=1 > test acc = f2 true > test s = 1 true > save verify_A5.txt Shell Output Saved to: 'verify_A5.txt'. Script Complete. > load ..\testscripts\script_A6.txt Executing Script: '..\testscripts\script_A6.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Normal condition ------------ > memset 0072 55 Main Memory[$0072] set to $55 > op a6 72 Syntax Ok: LDX $72 3 cycles. > # Should be: IX=55 > test ix = 55 true > # Zero condition ------------ > memset 0072 00 Main Memory[$0072] set to $00 > op a6 72 Syntax Ok: LDX $72 3 cycles. > # Should be: IX=0, Z=1 > test ix = 0 true > test z = 1 true > # Negative condition ------------ > memset 0072 f2 Main Memory[$0072] set to $F2 > op a6 72 Syntax Ok: LDX $72 3 cycles. > # Should be: IX=F2, S=1 > test ix = f2 true > test s = 1 true > save verify_A6.txt Shell Output Saved to: 'verify_A6.txt'. Script Complete. > load ..\testscripts\script_A8.txt Executing Script: '..\testscripts\script_A8.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > # ACC should now show $55 > test acc = 55 true > op a8 Syntax Ok: TAY 2 cycles. > # ACC and IY should now show $55 > test acc = 55 true > test iy = 55 true > # Now for the Z flag case -------------------- > power on Power-On settings loaded. > op a9 00 Syntax Ok: LDA #$00 2 cycles. > op a0 55 Syntax Ok: LDY #$55 2 cycles. > # Use the IX register to reset Z > op a2 01 Syntax Ok: LDX #$01 2 cycles. > # Should be: ACC=0, IY=55, Z=0 > test acc = 0 true > test iy = 55 true > test z = 0 true > op a8 Syntax Ok: TAY 2 cycles. > # Should be: ACC=0, IY=0, Z=1 > test acc = 0 true > test iy = 0 true > test z = 1 true > # Now for the S flag case -------------------- > power on Power-On settings loaded. > op a9 f2 Syntax Ok: LDA #$F2 2 cycles. > op a0 55 Syntax Ok: LDY #$55 2 cycles. > # Use the IX register to reset S > op a2 01 Syntax Ok: LDX #$01 2 cycles. > # Should be: ACC=F2, IY=55, S=0 > test acc = f2 true > test iy = 55 true > test s = 0 true > op a8 Syntax Ok: TAY 2 cycles. > # Should be: ACC=F2, IY=F2, S=1 > test acc = f2 true > test iy = f2 true > test s = 1 true > save verify_A8.txt Shell Output Saved to: 'verify_A8.txt'. Script Complete. > load ..\testscripts\script_A9.txt Executing Script: '..\testscripts\script_A9.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > # ACC should now show $55 > test acc = 55 true > op a9 00 Syntax Ok: LDA #$00 2 cycles. > # ACC should be 0 and Z should be 1 > test acc = 0 true > test z = 1 true > op a9 f2 Syntax Ok: LDA #$F2 2 cycles. > # ACC should be f2 and S should be 1 > test acc = f2 true > test s = 1 true > regs CPU Registers PC: $2 SP: $FF ACC: $F2 IX: $0 IY: $0 Flags S V - B D I Z C PS: 1 0 1 0 0 0 0 0 > save verify_A9.txt Shell Output Saved to: 'verify_A9.txt'. Script Complete. > load ..\testscripts\script_AA.txt Executing Script: '..\testscripts\script_AA.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > # ACC should now show $55 > test acc = 55 true > op aa Syntax Ok: TAX 2 cycles. > # ACC and IX should now show $55 > test acc = 55 true > test ix = 55 true > # Now for the Z flag case -------------------- > power on Power-On settings loaded. > op a9 00 Syntax Ok: LDA #$00 2 cycles. > op a2 55 Syntax Ok: LDX #$55 2 cycles. > # Use the IY register to reset Z > op a0 01 Syntax Ok: LDY #$01 2 cycles. > # Should be: ACC=0, IX=55, Z=0 > test acc = 0 true > test ix = 55 true > test z = 0 true > op aa Syntax Ok: TAX 2 cycles. > # Should be: ACC=0, IX=0, Z=1 > test acc = 0 true > test ix = 0 true > test z = 1 true > # Now for the S flag case -------------------- > power on Power-On settings loaded. > op a9 f2 Syntax Ok: LDA #$F2 2 cycles. > op a2 55 Syntax Ok: LDX #$55 2 cycles. > # Use the IY register to reset S > op a0 01 Syntax Ok: LDY #$01 2 cycles. > # Should be: ACC=F2, IX=55, S=0 > test acc = f2 true > test ix = 55 true > test s = 0 true > op aa Syntax Ok: TAX 2 cycles. > # Should be: ACC=F2, IX=F2, S=1 > test acc = f2 true > test ix = f2 true > test s = 1 true > save verify_AA.txt Shell Output Saved to: 'verify_AA.txt'. Script Complete. > load ..\testscripts\script_AC.txt Executing Script: '..\testscripts\script_AC.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset beef 55 Main Memory[$BEEF] set to $55 > op ac efbe Syntax Ok: LDY $BEEF 4 cycles. > # IY should now show $55 > test iy = 55 true > memset beef 00 Main Memory[$BEEF] set to $00 > op ac efbe Syntax Ok: LDY $BEEF 4 cycles. > # IY should be 0 and Z should be 1 > test iy = 0 true > test z = 1 true > memset beef f2 Main Memory[$BEEF] set to $F2 > op ac efbe Syntax Ok: LDY $BEEF 4 cycles. > # IY should be f2 and S should be 1 > test iy = f2 true > test s = 1 true > regs CPU Registers PC: $3 SP: $FF ACC: $0 IX: $0 IY: $F2 Flags S V - B D I Z C PS: 1 0 1 0 0 0 0 0 > save verify_AC.txt Shell Output Saved to: 'verify_AC.txt'. Script Complete. > load ..\testscripts\script_AD.txt Executing Script: '..\testscripts\script_AD.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset beef 55 Main Memory[$BEEF] set to $55 > op ad efbe Syntax Ok: LDA $BEEF 4 cycles. > # ACC should now show $55 > test acc = 55 true > memset beef 00 Main Memory[$BEEF] set to $00 > op ad efbe Syntax Ok: LDA $BEEF 4 cycles. > # ACC should be 0 and Z should be 1 > test acc = 0 true > test z = 1 true > memset beef f2 Main Memory[$BEEF] set to $F2 > op ad efbe Syntax Ok: LDA $BEEF 4 cycles. > # ACC should be f2 and S should be 1 > test acc = f2 true > test s = 1 true > regs CPU Registers PC: $3 SP: $FF ACC: $F2 IX: $0 IY: $0 Flags S V - B D I Z C PS: 1 0 1 0 0 0 0 0 > save verify_AD.txt Shell Output Saved to: 'verify_AD.txt'. Script Complete. > load ..\testscripts\script_AE.txt Executing Script: '..\testscripts\script_AE.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset beef 55 Main Memory[$BEEF] set to $55 > op ae efbe Syntax Ok: LDX $BEEF 4 cycles. > # IX should now show $55 > test ix = 55 true > memset beef 00 Main Memory[$BEEF] set to $00 > op ae efbe Syntax Ok: LDX $BEEF 4 cycles. > # IX should be 0 and Z should be 1 > test ix = 0 true > test z = 1 true > memset beef f2 Main Memory[$BEEF] set to $F2 > op ae efbe Syntax Ok: LDX $BEEF 4 cycles. > # IX should be f2 and S should be 1 > test ix = f2 true > test s = 1 true > regs CPU Registers PC: $3 SP: $FF ACC: $0 IX: $F2 IY: $0 Flags S V - B D I Z C PS: 1 0 1 0 0 0 0 0 > save verify_AE.txt Shell Output Saved to: 'verify_AE.txt'. Script Complete. > load ..\testscripts\script_B0.txt Executing Script: '..\testscripts\script_B0.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Branch instructions cannot be tested using the op > # command, and are loaded into memory directly and > # setup to execute with the step command. > # Branch not taken -------------------------------- > regset c 0 C set to $0 > regset pc 9040 PC set to $9040 > # Load op: BCS $40 > memset 9040 B0 Main Memory[$9040] set to $B0 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BCS $40 2 cycles. > # Should be: PC=9042, cycles=2 > test pc = 9042 true > # Positive Branch taken to same page -------------- > regset c 1 C set to $1 > regset pc 9040 PC set to $9040 > # Load op: BCS $40 > memset 9040 B0 Main Memory[$9040] set to $B0 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BCS $40 3 cycles. > # Should be: PC=9082, cycles=3 > test pc = 9082 true > # Negative Branch taken to same page -------------- > regset c 1 C set to $1 > regset pc 9040 PC set to $9040 > # Load op: BCS $A0 > memset 9040 B0 Main Memory[$9040] set to $B0 > memset 9041 A0 Main Memory[$9041] set to $A0 > step Executed: BCS $A0 3 cycles. > # Should be: PC=9022, cycles=3 > test pc = 9022 true > # Positive Branch taken to different page --------- > regset c 1 C set to $1 > regset pc 90b0 PC set to $90B0 > # Load op: BCS $7F > memset 90b0 B0 Main Memory[$90B0] set to $B0 > memset 90b1 7f Main Memory[$90B1] set to $7F > step Executed: BCS $7F 4 cycles. > # Should be: PC=9131, cycles=4 > test pc = 9131 true > # Negative Branch taken to different page --------- > regset c 1 C set to $1 > regset pc 9040 PC set to $9040 > # Load op: BCS $F7 > memset 9040 B0 Main Memory[$9040] set to $B0 > memset 9041 F7 Main Memory[$9041] set to $F7 > step Executed: BCS $F7 4 cycles. > # Should be: PC=8FCB, cycles=4 > test pc = 8FCB true > save verify_B0.txt Shell Output Saved to: 'verify_B0.txt'. Script Complete. > load ..\testscripts\script_B4.txt Executing Script: '..\testscripts\script_B4.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Normal condition ------------ > memset 009a 55 Main Memory[$009A] set to $55 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op b4 72 Syntax Ok: LDY $72,X 4 cycles. > # Should be: IY=55, IX=28 > test iy = 55 true > test ix = 28 true > # Zero condition ------------ > power on Power-On settings loaded. > memset 009a 00 Main Memory[$009A] set to $00 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op b4 72 Syntax Ok: LDY $72,X 4 cycles. > # Should be: IY=0, IX=28, Z=1 > test iy = 0 true > test ix = 28 true > test z = 1 true > # Negative condition ------------ > power on Power-On settings loaded. > memset 009a f2 Main Memory[$009A] set to $F2 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op b4 72 Syntax Ok: LDY $72,X 4 cycles. > # Should be: IY=F2, IX=28, S=1 > test iy = f2 true > test ix = 28 true > test s = 1 true > save verify_B4.txt Shell Output Saved to: 'verify_B4.txt'. Script Complete. > load ..\testscripts\script_B5.txt Executing Script: '..\testscripts\script_B5.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Normal condition ------------ > memset 009a 55 Main Memory[$009A] set to $55 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op b5 72 Syntax Ok: LDA $72,X 4 cycles. > # Should be: ACC=55, IX=28 > test acc = 55 true > test ix = 28 true > # Zero condition ------------ > power on Power-On settings loaded. > memset 009a 00 Main Memory[$009A] set to $00 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op b5 72 Syntax Ok: LDA $72,X 4 cycles. > # Should be: ACC=0, IX=28, Z=1 > test acc = 0 true > test ix = 28 true > test z = 1 true > # Negative condition ------------ > power on Power-On settings loaded. > memset 009a f2 Main Memory[$009A] set to $F2 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op b5 72 Syntax Ok: LDA $72,X 4 cycles. > # Should be: ACC=F2, IX=28, S=1 > test acc = f2 true > test ix = 28 true > test s = 1 true > save verify_B5.txt Shell Output Saved to: 'verify_B5.txt'. Script Complete. > load ..\testscripts\script_B6.txt Executing Script: '..\testscripts\script_B6.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Normal condition ------------ > memset 009a 55 Main Memory[$009A] set to $55 > op a0 28 Syntax Ok: LDY #$28 2 cycles. > op b6 72 Syntax Ok: LDX $72,Y 4 cycles. > # Should be: IX=55, IY=28 > test ix = 55 true > test iy = 28 true > # Zero condition ------------ > power on Power-On settings loaded. > memset 009a 00 Main Memory[$009A] set to $00 > op a0 28 Syntax Ok: LDY #$28 2 cycles. > op b6 72 Syntax Ok: LDX $72,Y 4 cycles. > # Should be: IX=0, IY=28, Z=1 > test ix = 0 true > test iy = 28 true > test z = 1 true > # Negative condition ------------ > power on Power-On settings loaded. > memset 009a f2 Main Memory[$009A] set to $F2 > op a0 28 Syntax Ok: LDY #$28 2 cycles. > op b6 72 Syntax Ok: LDX $72,Y 4 cycles. > # Should be: IX=F2, IY=28, S=1 > test ix = f2 true > test iy = 28 true > test s = 1 true > save verify_B6.txt Shell Output Saved to: 'verify_B6.txt'. Script Complete. > load ..\testscripts\script_B8.txt Executing Script: '..\testscripts\script_B8.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # create an overflow > memset 1000 40 Main Memory[$1000] set to $40 > op 2c 0010 Syntax Ok: BIT $1000 4 cycles. > # V flag should now be 1 > test v = 1 true > op b8 Syntax Ok: CLV 2 cycles. > # V flag should now be 0 again > test v = 0 true > save verify_B8.txt Shell Output Saved to: 'verify_B8.txt'. Script Complete. > load ..\testscripts\script_BA.txt Executing Script: '..\testscripts\script_BA.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a2 55 Syntax Ok: LDX #$55 2 cycles. > # IX should now show $55 > test ix = 55 true > op 9a Syntax Ok: TXS 2 cycles. > op a2 00 Syntax Ok: LDX #$00 2 cycles. > # Only SP should now show $55 > test ix = 0 true > test sp = 55 true > op ba Syntax Ok: TSX 2 cycles. > # SP and IX should now show $55 > test sp = 55 true > test ix = 55 true > # Now for the Z flag case -------------------- > power on Power-On settings loaded. > op a2 00 Syntax Ok: LDX #$00 2 cycles. > op 9a Syntax Ok: TXS 2 cycles. > op a2 55 Syntax Ok: LDX #$55 2 cycles. > # Clear Z with the ACC > op a9 01 Syntax Ok: LDA #$01 2 cycles. > # Should be: IX=55, SP=0, Z=0 > test ix = 55 true > test sp = 0 true > test z = 0 true > op ba Syntax Ok: TSX 2 cycles. > # SP and IX should now show $00 and Z should be 1 > test sp = 0 true > test ix = 0 true > test z = 1 true > # Now for the S flag case -------------------- > power on Power-On settings loaded. > op a2 f2 Syntax Ok: LDX #$F2 2 cycles. > op 9a Syntax Ok: TXS 2 cycles. > op a2 55 Syntax Ok: LDX #$55 2 cycles. > # Clear S with the ACC > op a9 01 Syntax Ok: LDA #$01 2 cycles. > # Should be: IX=55, SP=F2, S=0 > test ix = 55 true > test sp = f2 true > test s = 0 true > op ba Syntax Ok: TSX 2 cycles. > # SP and IX should now show $f2 and S should be 1 > test sp = f2 true > test ix = f2 true > test s = 1 true > save verify_BA.txt Shell Output Saved to: 'verify_BA.txt'. Script Complete. > load ..\testscripts\script_BD.txt Executing Script: '..\testscripts\script_BD.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Normal condition (No Page Boundry) ------ > memset 839a 55 Main Memory[$839A] set to $55 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op bd 7283 Syntax Ok: LDA $8372,X 4 cycles. > # Should be: ACC=55, IX=28, Cycles=4 > test acc = 55 true > test ix = 28 true > # Normal condition (Page Boundry) --------- > power on Power-On settings loaded. > memset 845f 55 Main Memory[$845F] set to $55 > op a2 ed Syntax Ok: LDX #$ED 2 cycles. > op bd 7283 Syntax Ok: LDA $8372,X 5 cycles. > # Should be: ACC=55, IX=ED, Cycles=5 > test acc = 55 true > test ix = ed true > # Zero condition -------------- > power on Power-On settings loaded. > memset 839a 00 Main Memory[$839A] set to $00 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op bd 7283 Syntax Ok: LDA $8372,X 4 cycles. > # Should be: ACC=0, IX=28, Z=1, Cycles=4 > test acc = 0 true > test ix = 28 true > test z = 1 true > # Negative condition ---------- > power on Power-On settings loaded. > memset 839a f2 Main Memory[$839A] set to $F2 > op a2 28 Syntax Ok: LDX #$28 2 cycles. > op bd 7283 Syntax Ok: LDA $8372,X 4 cycles. > # Should be: ACC=F2, IX=28, S=1, Cycles=4 > test acc = f2 true > test ix = 28 true > test s = 1 true > save verify_BD.txt Shell Output Saved to: 'verify_BD.txt'. Script Complete. > load ..\testscripts\script_C0.txt Executing Script: '..\testscripts\script_C0.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Carry Flag Case ------------------- > op a0 55 Syntax Ok: LDY #$55 2 cycles. > op c0 2b Syntax Ok: CPY #$2B 2 cycles. > # Should be: IY=55, C=1, Z=0, S=0 > test iy = 55 true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Flag Case -------------------- > power on Power-On settings loaded. > op a0 55 Syntax Ok: LDY #$55 2 cycles. > op c0 55 Syntax Ok: CPY #$55 2 cycles. > # Should be: IY=55, C=1, Z=1, S=0 > test iy = 55 true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Flag Case ---------------- > power on Power-On settings loaded. > op a0 35 Syntax Ok: LDY #$35 2 cycles. > op c0 55 Syntax Ok: CPY #$55 2 cycles. > # Should be: IY=35, C=0, Z=0, S=1 > test iy = 35 true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_C0.txt Shell Output Saved to: 'verify_C0.txt'. Script Complete. > load ..\testscripts\script_C4.txt Executing Script: '..\testscripts\script_C4.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Carry Flag Case ------------------- > memset 00be 2b Main Memory[$00BE] set to $2B > op a0 55 Syntax Ok: LDY #$55 2 cycles. > op c4 be Syntax Ok: CPY $BE 3 cycles. > # Should be: IY=55, C=1, Z=0, S=0 > test iy = 55 true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Flag Case -------------------- > power on Power-On settings loaded. > memset 00be 55 Main Memory[$00BE] set to $55 > op a0 55 Syntax Ok: LDY #$55 2 cycles. > op c4 be Syntax Ok: CPY $BE 3 cycles. > # Should be: IY=55, C=1, Z=1, S=0 > test iy = 55 true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Flag Case ---------------- > power on Power-On settings loaded. > memset 00be 55 Main Memory[$00BE] set to $55 > op a0 35 Syntax Ok: LDY #$35 2 cycles. > op c4 be Syntax Ok: CPY $BE 3 cycles. > # Should be: IY=35, C=0, Z=0, S=1 > test iy = 35 true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_C4.txt Shell Output Saved to: 'verify_C4.txt'. Script Complete. > load ..\testscripts\script_C5.txt Executing Script: '..\testscripts\script_C5.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Carry Flag Case ------------------- > memset 00be 2b Main Memory[$00BE] set to $2B > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op c5 be Syntax Ok: CMP $BE 3 cycles. > # Should be: ACC=55, C=1, Z=0, S=0 > test acc = 55 true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Flag Case -------------------- > power on Power-On settings loaded. > memset 00be 55 Main Memory[$00BE] set to $55 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op c5 be Syntax Ok: CMP $BE 3 cycles. > # Should be: ACC=55, C=1, Z=1, S=0 > test acc = 55 true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Flag Case ---------------- > power on Power-On settings loaded. > memset 00be 55 Main Memory[$00BE] set to $55 > op a9 35 Syntax Ok: LDA #$35 2 cycles. > op c5 be Syntax Ok: CMP $BE 3 cycles. > # Should be: ACC=35, C=0, Z=0, S=1 > test acc = 35 true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_C5.txt Shell Output Saved to: 'verify_C5.txt'. Script Complete. > load ..\testscripts\script_C6.txt Executing Script: '..\testscripts\script_C6.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset 0072 55 Main Memory[$0072] set to $55 > op c6 72 Syntax Ok: DEC $72 5 cycles. > # memory[$0072] should show 54 > test m:0072 = 54 true > # Wrap and Negative case ------------- > power on Power-On settings loaded. > memset 0072 00 Main Memory[$0072] set to $00 > op c6 72 Syntax Ok: DEC $72 5 cycles. > # Should be: memory[$0072]=FF, S=1 > test m:0072 = ff true > test s = 1 true > # Zero case ------------------- > power on Power-On settings loaded. > memset 0072 01 Main Memory[$0072] set to $01 > op c6 72 Syntax Ok: DEC $72 5 cycles. > # Should be: memory[$0072]=00, Z=1 > test m:0072 = 00 true > test z = 1 true > save verify_C6.txt Shell Output Saved to: 'verify_C6.txt'. Script Complete. > load ..\testscripts\script_C8.txt Executing Script: '..\testscripts\script_C8.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a0 55 Syntax Ok: LDY #$55 2 cycles. > # IY should now be set to 55 > test iy = 55 true > op c8 Syntax Ok: INY 2 cycles. > # IY should now be set to 56 > test iy = 56 true > # Wrap and Zero case -------------- > power on Power-On settings loaded. > op a0 ff Syntax Ok: LDY #$FF 2 cycles. > # IY should now be set to ff > test iy = ff true > op c8 Syntax Ok: INY 2 cycles. > # Should be: IY=0, Z=1 > test iy = 0 true > test z = 1 true > # Negative case -------------------- > power on Power-On settings loaded. > op a0 ef Syntax Ok: LDY #$EF 2 cycles. > # Clear S with ACC > op a9 01 Syntax Ok: LDA #$01 2 cycles. > # Should be: IY=EF, S=0 > test iy = ef true > test s = 0 true > op c8 Syntax Ok: INY 2 cycles. > # Should be: IY=F0, S=1 > test iy = F0 true > test s = 1 true > save verify_C8.txt Shell Output Saved to: 'verify_C8.txt'. Script Complete. > load ..\testscripts\script_C9.txt Executing Script: '..\testscripts\script_C9.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Carry Flag Case ------------------- > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op c9 2b Syntax Ok: CMP #$2B 2 cycles. > # Should be: ACC=55, C=1, Z=0, S=0 > test acc = 55 true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Flag Case -------------------- > power on Power-On settings loaded. > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op c9 55 Syntax Ok: CMP #$55 2 cycles. > # Should be: ACC=55, C=1, Z=1, S=0 > test acc = 55 true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Flag Case ---------------- > power on Power-On settings loaded. > op a9 35 Syntax Ok: LDA #$35 2 cycles. > op c9 55 Syntax Ok: CMP #$55 2 cycles. > # Should be: ACC=35, C=0, Z=0, S=1 > test acc = 35 true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_C9.txt Shell Output Saved to: 'verify_C9.txt'. Script Complete. > load ..\testscripts\script_CA.txt Executing Script: '..\testscripts\script_CA.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a2 55 Syntax Ok: LDX #$55 2 cycles. > # IX should now be set to 55 > test ix = 55 true > op ca Syntax Ok: DEX 2 cycles. > # IX should now be set to 54 > test ix = 54 true > # Wrap and negative case -------------- > power on Power-On settings loaded. > op a2 00 Syntax Ok: LDX #$00 2 cycles. > # IX should now be set to 00 > test ix = 0 true > op ca Syntax Ok: DEX 2 cycles. > # Should be: IX=FF, S=1 > test ix = ff true > test s = 1 true > # Zero case ---------------------------- > power on Power-On settings loaded. > op a2 01 Syntax Ok: LDX #$01 2 cycles. > # Should be: IX=01, Z=0 > test ix = 1 true > test z = 0 true > op ca Syntax Ok: DEX 2 cycles. > # Should be: IX=00, Z=1 > test ix = 0 true > test z = 1 true > save verify_CA.txt Shell Output Saved to: 'verify_CA.txt'. Script Complete. > load ..\testscripts\script_CC.txt Executing Script: '..\testscripts\script_CC.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Carry Flag Case ------------------- > memset beef 2b Main Memory[$BEEF] set to $2B > op a0 55 Syntax Ok: LDY #$55 2 cycles. > op cc efbe Syntax Ok: CPY $BEEF 4 cycles. > # Should be: IY=55, C=1, Z=0, S=0 > test iy = 55 true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Flag Case -------------------- > power on Power-On settings loaded. > memset beef 55 Main Memory[$BEEF] set to $55 > op a0 55 Syntax Ok: LDY #$55 2 cycles. > op cc efbe Syntax Ok: CPY $BEEF 4 cycles. > # Should be: IY=55, C=1, Z=1, S=0 > test iy = 55 true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Flag Case ---------------- > power on Power-On settings loaded. > memset beef 55 Main Memory[$BEEF] set to $55 > op a0 35 Syntax Ok: LDY #$35 2 cycles. > op cc efbe Syntax Ok: CPY $BEEF 4 cycles. > # Should be: IY=35, C=0, Z=0, S=1 > test iy = 35 true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_CC.txt Shell Output Saved to: 'verify_CC.txt'. Script Complete. > load ..\testscripts\script_CD.txt Executing Script: '..\testscripts\script_CD.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Carry Flag Case ------------------- > memset beef 2b Main Memory[$BEEF] set to $2B > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op cd efbe Syntax Ok: CMP $BEEF 4 cycles. > # Should be: ACC=55, C=1, Z=0, S=0 > test acc = 55 true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Flag Case -------------------- > power on Power-On settings loaded. > memset beef 55 Main Memory[$BEEF] set to $55 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op cd efbe Syntax Ok: CMP $BEEF 4 cycles. > # Should be: ACC=55, C=1, Z=1, S=0 > test acc = 55 true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Flag Case ---------------- > power on Power-On settings loaded. > memset beef 55 Main Memory[$BEEF] set to $55 > op a9 35 Syntax Ok: LDA #$35 2 cycles. > op cd efbe Syntax Ok: CMP $BEEF 4 cycles. > # Should be: ACC=35, C=0, Z=0, S=1 > test acc = 35 true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_CD.txt Shell Output Saved to: 'verify_CD.txt'. Script Complete. > load ..\testscripts\script_CE.txt Executing Script: '..\testscripts\script_CE.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset beef 55 Main Memory[$BEEF] set to $55 > op ce efbe Syntax Ok: DEC $BEEF 6 cycles. > # memory[$BEEF] should show 54 > test m:beef = 54 true > # Wrap and Negative case ------------- > power on Power-On settings loaded. > memset beef 00 Main Memory[$BEEF] set to $00 > op ce efbe Syntax Ok: DEC $BEEF 6 cycles. > # Should be: memory[$BEEF]=FF, S=1 > test m:beef = ff true > test s = 1 true > # Zero case ------------------- > power on Power-On settings loaded. > memset beef 01 Main Memory[$BEEF] set to $01 > op ce efbe Syntax Ok: DEC $BEEF 6 cycles. > # Should be: memory[$BEEF]=00, Z=1 > test m:beef = 00 true > test z = 1 true > save verify_CE.txt Shell Output Saved to: 'verify_CE.txt'. Script Complete. > load ..\testscripts\script_D0.txt Executing Script: '..\testscripts\script_D0.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Branch instructions cannot be tested using the op > # command, and are loaded into memory directly and > # setup to execute with the step command. > # Branch not taken -------------------------------- > regset z 1 Z set to $1 > regset pc 9040 PC set to $9040 > # Load op: BNE $40 > memset 9040 D0 Main Memory[$9040] set to $D0 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BNE $40 2 cycles. > # Should be: PC=9042, cycles=2 > test pc = 9042 true > # Positive Branch taken to same page -------------- > regset z 0 Z set to $0 > regset pc 9040 PC set to $9040 > # Load op: BNE $40 > memset 9040 D0 Main Memory[$9040] set to $D0 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BNE $40 3 cycles. > # Should be: PC=9082, cycles=3 > test pc = 9082 true > # Negative Branch taken to same page -------------- > regset z 0 Z set to $0 > regset pc 9040 PC set to $9040 > # Load op: BNE $A0 > memset 9040 D0 Main Memory[$9040] set to $D0 > memset 9041 A0 Main Memory[$9041] set to $A0 > step Executed: BNE $A0 3 cycles. > # Should be: PC=9022, cycles=3 > test pc = 9022 true > # Positive Branch taken to different page --------- > regset z 0 Z set to $0 > regset pc 90b0 PC set to $90B0 > # Load op: BNE $7F > memset 90b0 D0 Main Memory[$90B0] set to $D0 > memset 90b1 7f Main Memory[$90B1] set to $7F > step Executed: BNE $7F 4 cycles. > # Should be: PC=9131, cycles=4 > test pc = 9131 true > # Negative Branch taken to different page --------- > regset z 0 Z set to $0 > regset pc 9040 PC set to $9040 > # Load op: BNE $F7 > memset 9040 D0 Main Memory[$9040] set to $D0 > memset 9041 F7 Main Memory[$9041] set to $F7 > step Executed: BNE $F7 4 cycles. > # Should be: PC=8FCB, cycles=4 > test pc = 8FCB true > save verify_D0.txt Shell Output Saved to: 'verify_D0.txt'. Script Complete. > load ..\testscripts\script_D5.txt Executing Script: '..\testscripts\script_D5.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Carry Flag Case ------------------- > memset 00c9 2b Main Memory[$00C9] set to $2B > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op d5 be Syntax Ok: CMP $BE,X 4 cycles. > # Should be: ACC=55, IX=0B, C=1, Z=0, S=0 > test acc = 55 true > test ix = 0b true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Flag Case -------------------- > power on Power-On settings loaded. > memset 00c9 55 Main Memory[$00C9] set to $55 > op a9 55 Syntax Ok: LDA #$55 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op d5 be Syntax Ok: CMP $BE,X 4 cycles. > # Should be: ACC=55, IX=0B, C=1, Z=1, S=0 > test acc = 55 true > test ix = 0b true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Flag Case ---------------- > power on Power-On settings loaded. > memset 00c9 55 Main Memory[$00C9] set to $55 > op a9 35 Syntax Ok: LDA #$35 2 cycles. > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op d5 be Syntax Ok: CMP $BE,X 4 cycles. > # Should be: ACC=35, IX=0B, C=0, Z=0, S=1 > test acc = 35 true > test ix = 0b true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_D5.txt Shell Output Saved to: 'verify_D5.txt'. Script Complete. > load ..\testscripts\script_D6.txt Executing Script: '..\testscripts\script_D6.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset 00c9 55 Main Memory[$00C9] set to $55 > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op d6 be Syntax Ok: DEC $BE,X 6 cycles. > # Should be: mem[$00C9]=54, IX=0B > test ix = 0b true > test m:00c9 = 54 true > # Wrap and Negative case ------------- > power on Power-On settings loaded. > memset 00c9 00 Main Memory[$00C9] set to $00 > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op d6 be Syntax Ok: DEC $BE,X 6 cycles. > # Should be: memory[$00C9]=FF, S=1 > test m:00c9 = ff true > test ix = 0b true > test s = 1 true > # Zero case ------------------- > power on Power-On settings loaded. > memset 00c9 01 Main Memory[$00C9] set to $01 > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op d6 be Syntax Ok: DEC $BE,X 6 cycles. > # Should be: memory[$00C9]=00, Z=1 > test m:00c9 = 00 true > test ix = 0b true > test z = 1 true > save verify_D6.txt Shell Output Saved to: 'verify_D6.txt'. Script Complete. > load ..\testscripts\script_D8.txt Executing Script: '..\testscripts\script_D8.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # this instruction is 6502 compatible but not > # supported by the NES > op f8 Syntax Ok: SED 2 cycles. > # D flag should now be 1 > test d = 1 true > op d8 Syntax Ok: CLD 2 cycles. > # D flag should now be 0 again > test d = 0 true > save verify_D8.txt Shell Output Saved to: 'verify_D8.txt'. Script Complete. > load ..\testscripts\script_DE.txt Executing Script: '..\testscripts\script_DE.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset befa 55 Main Memory[$BEFA] set to $55 > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op de efbe Syntax Ok: DEC $BEEF,X 7 cycles. > # Should be: mem[$BEFA]=54, IX=0B > test ix = 0b true > test m:befa = 54 true > # Wrap and Negative case ------------- > power on Power-On settings loaded. > memset befa 00 Main Memory[$BEFA] set to $00 > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op de efbe Syntax Ok: DEC $BEEF,X 7 cycles. > # Should be: memory[$BEFA]=FF, S=1 > test m:befa = ff true > test ix = 0b true > test s = 1 true > # Zero case ------------------- > power on Power-On settings loaded. > memset befa 01 Main Memory[$BEFA] set to $01 > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op de efbe Syntax Ok: DEC $BEEF,X 7 cycles. > # Should be: memory[$BEFA]=00, Z=1 > test m:befa = 00 true > test ix = 0b true > test z = 1 true > save verify_DE.txt Shell Output Saved to: 'verify_DE.txt'. Script Complete. > load ..\testscripts\script_E0.txt Executing Script: '..\testscripts\script_E0.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Carry Flag Case ------------------- > op a2 55 Syntax Ok: LDX #$55 2 cycles. > op e0 2b Syntax Ok: CPX #$2B 2 cycles. > # Should be: IX=55, C=1, Z=0, S=0 > test ix = 55 true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Flag Case -------------------- > power on Power-On settings loaded. > op a2 55 Syntax Ok: LDX #$55 2 cycles. > op e0 55 Syntax Ok: CPX #$55 2 cycles. > # Should be: IX=55, C=1, Z=1, S=0 > test ix = 55 true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Flag Case ---------------- > power on Power-On settings loaded. > op a2 35 Syntax Ok: LDX #$35 2 cycles. > op e0 55 Syntax Ok: CPX #$55 2 cycles. > # Should be: IX=35, C=0, Z=0, S=1 > test ix = 35 true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_E0.txt Shell Output Saved to: 'verify_E0.txt'. Script Complete. > load ..\testscripts\script_E4.txt Executing Script: '..\testscripts\script_E4.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Carry Flag Case ------------------- > memset 00be 2b Main Memory[$00BE] set to $2B > op a2 55 Syntax Ok: LDX #$55 2 cycles. > op e4 be Syntax Ok: CPX $BE 3 cycles. > # Should be: IX=55, C=1, Z=0, S=0 > test ix = 55 true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Flag Case -------------------- > power on Power-On settings loaded. > memset 00be 55 Main Memory[$00BE] set to $55 > op a2 55 Syntax Ok: LDX #$55 2 cycles. > op e4 be Syntax Ok: CPX $BE 3 cycles. > # Should be: IX=55, C=1, Z=1, S=0 > test ix = 55 true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Flag Case ---------------- > power on Power-On settings loaded. > memset 00be 55 Main Memory[$00BE] set to $55 > op a2 35 Syntax Ok: LDX #$35 2 cycles. > op e4 be Syntax Ok: CPX $BE 3 cycles. > # Should be: IX=35, C=0, Z=0, S=1 > test ix = 35 true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_E4.txt Shell Output Saved to: 'verify_E4.txt'. Script Complete. > load ..\testscripts\script_E6.txt Executing Script: '..\testscripts\script_E6.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset 0072 55 Main Memory[$0072] set to $55 > op e6 72 Syntax Ok: INC $72 5 cycles. > # memory[$0072] should show 56 > test m:0072 = 56 true > # Wrap and Zero case ------------- > power on Power-On settings loaded. > memset 0072 ff Main Memory[$0072] set to $FF > op e6 72 Syntax Ok: INC $72 5 cycles. > # Should be: memory[$0072]=0, Z=1 > test m:0072 = 0 true > test z = 1 true > # Negative case ------------------- > power on Power-On settings loaded. > memset 0072 7f Main Memory[$0072] set to $7F > op e6 72 Syntax Ok: INC $72 5 cycles. > # Should be: memory[$0072]=80, S=1 > test m:0072 = 80 true > test s = 1 true > save verify_E6.txt Shell Output Saved to: 'verify_E6.txt'. Script Complete. > load ..\testscripts\script_E8.txt Executing Script: '..\testscripts\script_E8.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op a2 55 Syntax Ok: LDX #$55 2 cycles. > # IX should now be set to 55 > test ix = 55 true > op e8 Syntax Ok: INX 2 cycles. > # IX should now be set to 56 > test ix = 56 true > # Wrap and Zero case -------------- > power on Power-On settings loaded. > op a2 ff Syntax Ok: LDX #$FF 2 cycles. > # IX should now be set to ff > test ix = ff true > op e8 Syntax Ok: INX 2 cycles. > # Should be: IX=0, Z=1 > test ix = 0 true > test z = 1 true > # Negative case -------------------- > power on Power-On settings loaded. > op a2 ef Syntax Ok: LDX #$EF 2 cycles. > # Clear S with ACC > op a9 01 Syntax Ok: LDA #$01 2 cycles. > # Should be: IX=EF, S=0 > test ix = ef true > test s = 0 true > op e8 Syntax Ok: INX 2 cycles. > # Should be: IX=F0, S=1 > test ix = F0 true > test s = 1 true > save verify_E8.txt Shell Output Saved to: 'verify_E8.txt'. Script Complete. > load ..\testscripts\script_EA.txt Executing Script: '..\testscripts\script_EA.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > op ea Syntax Ok: NOP 2 cycles. > # should be no change except the PC > regs CPU Registers PC: $1 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > save verify_EA.txt Shell Output Saved to: 'verify_EA.txt'. Script Complete. > load ..\testscripts\script_EC.txt Executing Script: '..\testscripts\script_EC.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Carry Flag Case ------------------- > memset beef 2b Main Memory[$BEEF] set to $2B > op a2 55 Syntax Ok: LDX #$55 2 cycles. > op ec efbe Syntax Ok: CPX $BEEF 4 cycles. > # Should be: IX=55, C=1, Z=0, S=0 > test ix = 55 true > test c = 1 true > test z = 0 true > test s = 0 true > # Zero Flag Case -------------------- > power on Power-On settings loaded. > memset beef 55 Main Memory[$BEEF] set to $55 > op a2 55 Syntax Ok: LDX #$55 2 cycles. > op ec efbe Syntax Ok: CPX $BEEF 4 cycles. > # Should be: IX=55, C=1, Z=1, S=0 > test ix = 55 true > test c = 1 true > test z = 1 true > test s = 0 true > # Negative Flag Case ---------------- > power on Power-On settings loaded. > memset beef 55 Main Memory[$BEEF] set to $55 > op a2 35 Syntax Ok: LDX #$35 2 cycles. > op ec efbe Syntax Ok: CPX $BEEF 4 cycles. > # Should be: IX=35, C=0, Z=0, S=1 > test ix = 35 true > test c = 0 true > test z = 0 true > test s = 1 true > save verify_EC.txt Shell Output Saved to: 'verify_EC.txt'. Script Complete. > load ..\testscripts\script_EE.txt Executing Script: '..\testscripts\script_EE.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset beef 55 Main Memory[$BEEF] set to $55 > op ee efbe Syntax Ok: INC $BEEF 6 cycles. > # memory[$BEEF] should show 56 > test m:beef = 56 true > # Wrap and Zero case ------------- > power on Power-On settings loaded. > memset beef ff Main Memory[$BEEF] set to $FF > op ee efbe Syntax Ok: INC $BEEF 6 cycles. > # Should be: memory[$BEEF]=0, Z=1 > test m:beef = 0 true > test z = 1 true > # Negative case ------------------- > power on Power-On settings loaded. > memset beef 7f Main Memory[$BEEF] set to $7F > op ee efbe Syntax Ok: INC $BEEF 6 cycles. > # Should be: memory[$BEEF]=80, S=1 > test m:beef = 80 true > test s = 1 true > save verify_EE.txt Shell Output Saved to: 'verify_EE.txt'. Script Complete. > load ..\testscripts\script_F0.txt Executing Script: '..\testscripts\script_F0.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # Branch instructions cannot be tested using the op > # command, and are loaded into memory directly and > # setup to execute with the step command. > # Branch not taken -------------------------------- > regset z 0 Z set to $0 > regset pc 9040 PC set to $9040 > # Load op: BEQ $40 > memset 9040 F0 Main Memory[$9040] set to $F0 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BEQ $40 2 cycles. > # Should be: PC=9042, cycles=2 > test pc = 9042 true > # Positive Branch taken to same page -------------- > regset z 1 Z set to $1 > regset pc 9040 PC set to $9040 > # Load op: BEQ $40 > memset 9040 F0 Main Memory[$9040] set to $F0 > memset 9041 40 Main Memory[$9041] set to $40 > step Executed: BEQ $40 3 cycles. > # Should be: PC=9082, cycles=3 > test pc = 9082 true > # Negative Branch taken to same page -------------- > regset z 1 Z set to $1 > regset pc 9040 PC set to $9040 > # Load op: BEQ $A0 > memset 9040 F0 Main Memory[$9040] set to $F0 > memset 9041 A0 Main Memory[$9041] set to $A0 > step Executed: BEQ $A0 3 cycles. > # Should be: PC=9022, cycles=3 > test pc = 9022 true > # Positive Branch taken to different page --------- > regset z 1 Z set to $1 > regset pc 90b0 PC set to $90B0 > # Load op: BEQ $7F > memset 90b0 F0 Main Memory[$90B0] set to $F0 > memset 90b1 7f Main Memory[$90B1] set to $7F > step Executed: BEQ $7F 4 cycles. > # Should be: PC=9131, cycles=4 > test pc = 9131 true > # Negative Branch taken to different page --------- > regset z 1 Z set to $1 > regset pc 9040 PC set to $9040 > # Load op: BEQ $F7 > memset 9040 F0 Main Memory[$9040] set to $F0 > memset 9041 F7 Main Memory[$9041] set to $F7 > step Executed: BEQ $F7 4 cycles. > # Should be: PC=8FCB, cycles=4 > test pc = 8FCB true > save verify_F0.txt Shell Output Saved to: 'verify_F0.txt'. Script Complete. > load ..\testscripts\script_F6.txt Executing Script: '..\testscripts\script_F6.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset 00c9 55 Main Memory[$00C9] set to $55 > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op f6 be Syntax Ok: INC $BE,X 6 cycles. > # Should be: mem[$00C9]=56, IX=0B > test m:00c9 = 56 true > test ix = 0b true > # Wrap and Zero case ------------- > power on Power-On settings loaded. > memset 00c9 ff Main Memory[$00C9] set to $FF > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op f6 be Syntax Ok: INC $BE,X 6 cycles. > # Should be: memory[$00C9]=0, IX=0B, Z=1 > test m:00c9 = 0 true > test ix = 0b true > test z = 1 true > # Negative case ------------------- > power on Power-On settings loaded. > memset 00c9 7f Main Memory[$00C9] set to $7F > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op f6 be Syntax Ok: INC $BE,X 6 cycles. > # Should be: memory[$00C9]=80, IX=0B, S=1 > test m:00c9 = 80 true > test ix = 0b true > test s = 1 true > save verify_F6.txt Shell Output Saved to: 'verify_F6.txt'. Script Complete. > load ..\testscripts\script_F8.txt Executing Script: '..\testscripts\script_F8.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > # this instruction is 6502 compatible but not > # supported by the NES > op f8 Syntax Ok: SED 2 cycles. > # D flag should now be 1 > test d = 1 true > save verify_F8.txt Shell Output Saved to: 'verify_F8.txt'. Script Complete. > load ..\testscripts\script_FE.txt Executing Script: '..\testscripts\script_FE.txt'. > clear Clear command disabled within nested scripts. > power on Power-On settings loaded. > regs CPU Registers PC: $0 SP: $FF ACC: $0 IX: $0 IY: $0 Flags S V - B D I Z C PS: 0 0 1 0 0 0 0 0 > memset befa 55 Main Memory[$BEFA] set to $55 > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op fe efbe Syntax Ok: INC $BEEF,X 7 cycles. > # Should be: mem[$BEFA]=56, IX=0B > test m:befa = 56 true > test ix = 0b true > # Wrap and Zero case ------------- > power on Power-On settings loaded. > memset befa ff Main Memory[$BEFA] set to $FF > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op fe efbe Syntax Ok: INC $BEEF,X 7 cycles. > # Should be: memory[$BEFA]=0, IX=0B, Z=1 > test m:befa = 0 true > test ix = 0b true > test z = 1 true > # Negative case ------------------- > power on Power-On settings loaded. > memset befa 7f Main Memory[$BEFA] set to $7F > op a2 0b Syntax Ok: LDX #$0B 2 cycles. > op fe efbe Syntax Ok: INC $BEEF,X 7 cycles. > # Should be: memory[$BEFA]=80, IX=0B, S=1 > test m:befa = 80 true > test ix = 0b true > test s = 1 true > save verify_FE.txt Shell Output Saved to: 'verify_FE.txt'. Script Complete. > save verify_master.txt