from cpu6502 import *
import unittest


class TestCPU6502(unittest.TestCase):

    def setUp(self):
        self.cpu = CPU6502()
        self.cpu.pc = 0x7000
        self.cpu.start = self.cpu.pc
        self.debug = False
        print("")
        print("---------------------------")
        print("test method: %s" % self._testMethodName)

    def check_flags(self, neg, zero, carry):
        self.assertEqual(self.cpu.flag_n, neg)
        self.assertEqual(self.cpu.flag_z, zero)
        self.assertEqual(self.cpu.flag_c, carry)

    def check_a(self, val, neg, zero, carry):
        self.assertEqual(self.cpu.reg_a, val)
        self.check_flags(neg, zero, carry)

    def check_x(self, val, neg, zero, carry):
        self.assertEqual(self.cpu.reg_x, val)
        self.check_flags(neg, zero, carry)

    def check_y(self, val, neg, zero, carry):
        self.assertEqual(self.cpu.reg_y, val)
        self.check_flags(neg, zero, carry)

    def check_mem(self, adr, val, neg, zero):
        self.assertEqual(self.cpu.mem[adr], val)
        self.assertEqual(self.cpu.flag_n, neg)
        self.assertEqual(self.cpu.flag_z, zero)

    def listing(self):
        self.cpu.end = self.cpu.pc
        self.cpu.disass()

    def run_test(self, debug=False):
        self.cpu.resetcyc()
        if self.debug:
            self.listing()
        self.cpu.run()
        if self.debug:
            self.cpu.registers()
            print("")
            print("Cycles: %d" % (self.cpu.cycles))
            print("")
        self.assertEqual(0xff, self.cpu.sp)

    def test_adc_imm_1(self):
        # 15 + 21 = 36
        self.cpu.addcmd('clc')
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('adc #', 21)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(36, False, False, False)

    def test_adc_imm_2(self):
        # 15 + 21 + Carry = 37
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('adc #', 21)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(37, False, False, False)

    def test_adc_imm_3(self):
        # 100 + 28 = 128 und Neg gesetzt
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('adc #', 28)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_adc_imm_4(self):
        # 100 + 156 = $0100 = 0 (lowbyte) und Carry gesetzt
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('adc #', 156)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)

    def test_adc_zp_1(self):
        # [aa] = 21; 15 + [aa] = 36
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('adc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(36, False, False, False)

    def test_adc_zp_2(self):
        # [aa] = 21; 15 + [aa] + Carry = 37
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('adc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(37, False, False, False)

    def test_adc_zp_3(self):
        # [aa] = 28; 100 + [aa] = 128 und Neg gesetzt
        self.cpu.addcmd('ldx #', 28)
        self.cpu.addcmd2('stx aa', 0xc6)
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('clc')
        self.cpu.addcmd2('adc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_adc_zp_4(self):
        # [aa] = 156; 100 + [aa] = $0100 = 0 (lowbyte) und Carry gesetzt
        self.cpu.addcmd('ldx #', 156)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('adc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)

    def test_adc_abs_1(self):
        # [aaaa] = 21; 15 + [aaaa] = 36
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd2('adc aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(36, False, False, False)

    def test_adc_abs_2(self):
        # [aaaa] = 21; 15 + [aaaa] + Carry = 37
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('sec')
        self.cpu.addcmd2('adc aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(37, False, False, False)

    def test_adc_abs_3(self):
        # [aaaa] = 28; 100 + [aaaa] = 128 und Neg gesetzt
        self.cpu.addcmd('ldx #', 28)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('clc')
        self.cpu.addcmd2('adc aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_adc_abs_4(self):
        # [aaaa] = 156; 100 + [aaaa] = $0100 = 0 (lowbyte) und Carry gesetzt
        self.cpu.addcmd('ldx #', 156)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('clc')
        self.cpu.addcmd2('adc aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)

    def test_adc_abs_x_1(self):
        # [aaaa,x] = 21; 15 + [aaaa,x] = 36
        self.cpu.addcmd('ldy #', 21)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd2('adc aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(36, False, False, False)

    def test_adc_abs_x_2(self):
        # [aaaa,x] = 21; 15 + [aaaa,x] + Carry = 37
        self.cpu.addcmd('ldy #', 21)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('sec')
        self.cpu.addcmd2('adc aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(37, False, False, False)

    def test_adc_abs_x_3(self):
        # [aaaa,x] = 28; 100 + [aaaa,x] = 128 und Neg gesetzt
        self.cpu.addcmd('ldy #', 28)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('clc')
        self.cpu.addcmd2('adc aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_adc_abs_x_4(self):
        # [aaaa,x] = 156; 100 + [aaaa,x] = $0100 = 0 (lowbyte) und Carry gesetzt
        self.cpu.addcmd('ldy #', 156)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('clc')
        self.cpu.addcmd2('adc aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)

    def test_adc_abs_y_1(self):
        # [aaaa,y] = 21; 15 + [aaaa,y] = 36
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd2('adc aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(36, False, False, False)

    def test_adc_abs_y_2(self):
        # [aaaa,y] = 21; 15 + [aaaa,y] + Carry = 37
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('sec')
        self.cpu.addcmd2('adc aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(37, False, False, False)

    def test_adc_abs_y_3(self):
        # [aaaa,y] = 28; 100 + [aaaa,y] = 128 und Neg gesetzt
        self.cpu.addcmd('ldx #', 28)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('clc')
        self.cpu.addcmd2('adc aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_adc_abs_y_4(self):
        # [aaaa,y] = 156; 100 + [aaaa,y] = $0100 = 0 (lowbyte) und Carry gesetzt
        self.cpu.addcmd('ldx #', 156)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('clc')
        self.cpu.addcmd2('adc aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)

    def test_asl_1(self):
        #    1010 1010  170
        # << 0101 0100   84 und Carry gesetzt
        self.cpu.addcmd('lda #', 170)
        self.cpu.addcmd('asl A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(84, False, False, True)

    def test_asl_2(self):
        #    0101 0100   84
        # << 1010 1000  168
        self.cpu.addcmd('lda #', 84)
        self.cpu.addcmd('asl A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(168, True, False, False)

    def test_asl_zp_1(self):
        #    1010 1010  170
        # << 0101 0100   84 und Carry gesetzt
        self.cpu.addcmd('lda #', 170)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('asl aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 84, False, False)
        self.assertTrue(self.cpu.flag_c)

    def test_asl_zp_2(self):
        #    0101 0100   84
        # << 1010 1000  168
        self.cpu.addcmd('lda #', 84)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('asl aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 168, True, False)
        self.assertFalse(self.cpu.flag_c)

    def test_and_imm_1(self):
        #   1110 0100   228
        # & 0101 0101    85
        # = 0100 0100    68
        self.cpu.addcmd('lda #', 228)
        self.cpu.addcmd('and #', 85)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(68, False, False, False)

    def test_and_imm_2(self):
        #   1111 1111
        # & 0000 0000
        # = 0000 0000
        self.cpu.addcmd('lda #', 255)
        self.cpu.addcmd('and #', 0)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, False)

    def test_and_imm_3(self):
        #   1111 1111
        # & 1000 0000
        # = 1000 0000
        self.cpu.addcmd('lda #', 255)
        self.cpu.addcmd('and #', 128)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_bcc_1(self):
        # kein Sprung: X = 0, C = 1 -> X = 1, C = 1
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('bcc aa', 0x01)
        self.cpu.addcmd('inx')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(1, False, False, True)

    def test_bcc_2(self):
        # Vorwaertssprung: X = 0, C = 0 -> X = 0, C = 0
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('bcc aa', 0x01)
        self.cpu.addcmd('dex')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(0, False, True, False)

    def test_bcc_3(self):
        # Schleife mit Rueckwaertssprung (16 Durchlaeufe)
        #    A = $00, $10, $20, ... , $e0
        # -> A = $10, $20, $30, ... , $f0; C = 0, Y = 1..15
        # ->                      A = $00, C = 1, Y = 16
        self.cpu.addcmd('lda #', 0)
        self.cpu.addcmd('ldy #', 0)
        self.cpu.addcmd('iny')
        self.cpu.addcmd('clc')
        self.cpu.addcmd('adc #', 0x10)
        self.cpu.addcmd('bcc aa', 0xfa)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)
        # Flags nicht pruefen wg. adc #
        self.assertEqual(self.cpu.reg_y, 16)

    def test_bcs_1(self):
        # kein Sprung: X = 0, C = 0 -> X = 1, C = 0
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('bcs aa', 0x01)
        self.cpu.addcmd('inx')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(1, False, False, False)

    def test_bcs_2(self):
        # Vorwaertssprung: X = 0, C = 1 -> X = 0, C = 1
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('bcs aa', 0x01)
        self.cpu.addcmd('dex')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(0, False, True, True)

    def test_bcs_3(self):
        # Schleife mit Rueckwaertssprung (16 Durchlaeufe)
        #    A = $ff, $ef, $df, ... , $1f
        # -> A = $ef, $df, $cf, ... , $0f; C = 1, Y = 1..15
        # ->                      A = $ff, C = 0, Y = 16
        self.cpu.addcmd('lda #', 0xff)
        self.cpu.addcmd('ldy #', 0)
        self.cpu.addcmd('iny')
        self.cpu.addcmd('sec')
        self.cpu.addcmd('sbc #', 0x10)
        self.cpu.addcmd('bcs aa', 0xfa)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(255, True, False, False)
        # Flags nicht pruefen wg. sbc #
        self.assertEqual(self.cpu.reg_y, 16)

    def test_beq_1(self):
        # kein Sprung -> X = 2
        self.cpu.addcmd('ldx #', 1)
        self.cpu.addcmd('beq aa', 0x01)
        self.cpu.addcmd('inx')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(2, False, False, False)

    def test_beq_2(self):
        # Vorwaertssprung -> X = 0
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('beq aa', 0x01)
        self.cpu.addcmd('dex')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(0, False, True, False)

    def test_beq_3(self):
        # Schleife X=1..0 mit Rueckwaertssprung (2 Durchlaeufe)
        # -> X = 255; Y = 2
        self.cpu.addcmd('ldx #', 1)
        self.cpu.addcmd('ldy #', 0)
        self.cpu.addcmd('iny')
        self.cpu.addcmd('dex')
        self.cpu.addcmd('beq aa', 0xfc)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(255, True, False, False)
        # Flags nicht pruefen wg dex
        self.assertEqual(self.cpu.reg_y, 2)

    def test_bne_1(self):
        # kein Sprung -> X = 1
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('bne aa', 0x01)
        self.cpu.addcmd('inx')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(1, False, False, False)

    def test_bne_2(self):
        # Vorwaertssprung -> X = 1
        self.cpu.addcmd('ldx #', 1)
        self.cpu.addcmd('bne aa', 0x01)
        self.cpu.addcmd('dex')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(1, False, False, False)

    def test_bne_3(self):
        # Schleife X=10..1 mit Rueckwaertssprung (10 Durchlaeufe)
        # -> X = 0; Y = 10
        self.cpu.addcmd('ldx #', 10)
        self.cpu.addcmd('ldy #', 0)
        self.cpu.addcmd('iny')
        self.cpu.addcmd('dex')
        self.cpu.addcmd('bne aa', 0xfc)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(0, False, True, False)
        # Flags nicht pruefen wg. dex
        self.assertEqual(self.cpu.reg_y, 10)

    def test_bpl_1(self):
        # kein Sprung -> X = 0
        self.cpu.addcmd('ldx #', 0xff)
        self.cpu.addcmd('bpl aa', 0x01)
        self.cpu.addcmd('inx')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(0, False, True, False)

    def test_bpl_2(self):
        # Vorwaertssprung -> X = 127
        self.cpu.addcmd('ldx #', 0x7f)
        self.cpu.addcmd('bpl aa', 0x01)
        self.cpu.addcmd('inx')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(127, False, False, False)

    def test_bpl_3(self):
        # Schleife X=10..0 mit Rueckwaertssprung (11 Durchlaeufe)
        # -> X = 255; Y = 11
        self.cpu.addcmd('ldx #', 10)
        self.cpu.addcmd('ldy #', 0)
        self.cpu.addcmd('iny')
        self.cpu.addcmd('dex')
        self.cpu.addcmd('bpl aa', 0xfc)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(255, True, False, False)
        # Flags nicht pruefen wg. dex
        self.assertEqual(self.cpu.reg_y, 11)

    def compare_eql(self):
        """ Testet die Flags fuer A == B """
        self.assertFalse(self.cpu.flag_n)
        self.assertTrue(self.cpu.flag_z)
        self.assertTrue(self.cpu.flag_c)

    def compare_gtr(self):
        """ Testet die Flags fuer A > B """
        self.assertFalse(self.cpu.flag_n)
        self.assertFalse(self.cpu.flag_z)
        self.assertTrue(self.cpu.flag_c)

    def compare_lss(self):
        """ Testet die Flags fuer A < B """
        self.assertTrue(self.cpu.flag_n)
        self.assertFalse(self.cpu.flag_z)
        self.assertFalse(self.cpu.flag_c)

    def test_cmp_imm_1(self):
        # A == val
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd('cmp #', 16)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cmp_imm_2(self):
        # A > val
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd('cmp #', 15)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cmp_imm_3(self):
        # A < val
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('cmp #', 16)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_cmp_zp_1(self):
        # A == [aa]
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd('cmp aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cmp_zp_2(self):
        # A > [aa]
        self.cpu.addcmd('ldx #', 15)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd('cmp aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cmp_zp_3(self):
        # A < [aa]
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('cmp aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_cmp_abs_1(self):
        # A == [aaaa]
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd2('cmp aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cmp_abs_2(self):
        # A > [aaaa]
        self.cpu.addcmd('ldx #', 15)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd2('cmp aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cmp_abs_3(self):
        # A < [aaaa]
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd2('cmp aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_cmp_abs_x_1(self):
        # X = 4; A == [aaaa,x]
        self.cpu.addcmd('ldy #', 16)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd2('cmp aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cmp_abs_x_2(self):
        # X = 4; A > [aaaa,x]
        self.cpu.addcmd('ldy #', 15)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd2('cmp aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cmp_abs_x_3(self):
        # X = 4; A < [aaaa,x]
        self.cpu.addcmd('ldy #', 16)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd2('cmp aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_cmp_abs_y_1(self):
        # Y = 4; A == [aaaa,y]
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd2('cmp aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cmp_abs_y_2(self):
        # Y = 4; A > [aaaa,y]
        self.cpu.addcmd('ldx #', 15)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd2('cmp aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cmp_abs_y_3(self):
        # Y = 4; A < [aaaa,y]
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd2('cmp aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_cpx_imm_1(self):
        # X == val
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd('cpx #', 16)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cpx_imm_2(self):
        # X > val
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd('cpx #', 15)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cpx_imm_3(self):
        # X < val
        self.cpu.addcmd('ldx #', 15)
        self.cpu.addcmd('cpx #', 16)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_cpx_zp_1(self):
        # X == [aa]
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd('cpx aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cpx_zp_2(self):
        # X > [aa]
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd('cpx aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cpx_zp_3(self):
        # X < [aa]
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('ldx #', 15)
        self.cpu.addcmd('cpx aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_cpx_abs_1(self):
        # X == [aaaa]
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd2('sta aaaa', 0x2000)
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd2('cpx aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cpx_abs_2(self):
        # X > [aaaa]
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd2('sta aaaa', 0x2000)
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd2('cpx aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cpx_abs_3(self):
        # X < [aaaa]
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd2('sta aaaa', 0x2000)
        self.cpu.addcmd('ldx #', 15)
        self.cpu.addcmd2('cpx aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_cpy_imm_1(self):
        # Y == val
        self.cpu.addcmd('ldy #', 16)
        self.cpu.addcmd('cpy #', 16)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cpy_imm_2(self):
        # Y > val
        self.cpu.addcmd('ldy #', 16)
        self.cpu.addcmd('cpy #', 15)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cpy_imm_3(self):
        # Y < val
        self.cpu.addcmd('ldy #', 15)
        self.cpu.addcmd('cpy #', 16)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_cpy_zp_1(self):
        # Y == [aa]
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('ldy #', 16)
        self.cpu.addcmd('cpy aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cpy_zp_2(self):
        # Y > [aa]
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('ldy #', 16)
        self.cpu.addcmd('cpy aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cpy_zp_3(self):
        # Y < [aa]
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('ldy #', 15)
        self.cpu.addcmd('cpy aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_cpy_abs_1(self):
        # Y == [aaaa]
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd2('sta aaaa', 0x2000)
        self.cpu.addcmd('ldy #', 16)
        self.cpu.addcmd2('cpy aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_eql()

    def test_cpy_abs_2(self):
        # Y > [aaaa]
        self.cpu.addcmd('lda #', 15)
        self.cpu.addcmd2('sta aaaa', 0x2000)
        self.cpu.addcmd('ldy #', 16)
        self.cpu.addcmd2('cpy aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_gtr()

    def test_cpy_abs_3(self):
        # Y < [aaaa]
        self.cpu.addcmd('lda #', 16)
        self.cpu.addcmd2('sta aaaa', 0x2000)
        self.cpu.addcmd('ldy #', 15)
        self.cpu.addcmd2('cpy aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.compare_lss()

    def test_dec_zp_1(self):
        # 1 -> $c6, DEC -> 0, Zero-Flag
        self.cpu.addcmd('ldx #', 1)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('dec aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 0, False, True)

    def test_dec_zp_2(self):
        # 0 -> $c6, DEC -> 255, N-Flag
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('dec aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 255, True, False)

    def test_dec_zp_3(self):
        # 128 -> $c6, DEC -> 127
        self.cpu.addcmd('ldx #', 128)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('dec aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 127, False, False)

    def test_dec_abs_1(self):
        # 1 -> $07e8, DEC -> 0, Zero-Flag
        self.cpu.addcmd('ldx #', 1)
        self.cpu.addcmd2('stx aaaa', 0x07e8)
        self.cpu.addcmd2('dec aaaa', 0x07e8)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0x07e8, 0, False, True)

    def test_dec_abs_2(self):
        # 0 -> $07e8, DEC -> 255, N-Flag
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd2('stx aaaa', 0x07e8)
        self.cpu.addcmd2('dec aaaa', 0x07e8)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0x07e8, 255, True, False)

    def test_dec_abs_3(self):
        # 128 -> $07e8, DEC -> 127
        self.cpu.addcmd('ldx #', 128)
        self.cpu.addcmd2('stx aaaa', 0x07e8)
        self.cpu.addcmd2('dec aaaa', 0x07e8)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0x07e8, 127, False, False)

    def test_dex_1(self):
        # 1 - 1 -> 0, Zero-Flag
        self.cpu.addcmd('ldx #', 1)
        self.cpu.addcmd('dex')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(0, False, True, False)

    def test_dex_2(self):
        # 0 - 1 -> 255, N-Flag
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('dex')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(255, True, False, False)

    def test_dex_3(self):
        # 128 - 1 -> 127
        self.cpu.addcmd('ldx #', 128)
        self.cpu.addcmd('dex')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(127, False, False, False)

    def test_dey_1(self):
        # 1 - 1 -> 0, Zero-Flag
        self.cpu.addcmd('ldy #', 1)
        self.cpu.addcmd('dey')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(0, False, True, False)

    def test_dey_2(self):
        # 0 - 1 -> 255, N-Flag
        self.cpu.addcmd('ldy #', 0)
        self.cpu.addcmd('dey')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(255, True, False, False)

    def test_dey_3(self):
        # 128 -1 -> 127
        self.cpu.addcmd('ldy #', 128)
        self.cpu.addcmd('dey')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(127, False, False, False)

    def test_inc_zp_1(self):
        # 254 -> $c6, INC -> 255, Neg-Flag
        self.cpu.addcmd('ldx #', 254)
        self.cpu.addcmd('lda #', 1) # Neg-Flag loeschen
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('inc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 255, True, False)

    def test_inc_zp_2(self):
        # 255 -> $c6, INC -> 0, Zero-Flag
        self.cpu.addcmd('ldx #', 255)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('inc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 0, False, True)

    def test_inc_zp_3(self):
        # 0 -> $c6, INC -> 1
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('inc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 1, False, False)

    def test_inc_abs_1(self):
        # 254 -> $07e8, INC -> 255, Neg-Flag
        self.cpu.addcmd('ldx #', 254)
        self.cpu.addcmd('lda #', 1) # Neg-Flag loeschen
        self.cpu.addcmd2('stx aaaa', 0x07e8)
        self.cpu.addcmd2('inc aaaa', 0x07e8)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0x07e8, 255, True, False)

    def test_inc_abs_2(self):
        # 255 -> $07e8, INC -> 0, Zero-Flag
        self.cpu.addcmd('ldx #', 255)
        self.cpu.addcmd2('stx aaaa', 0x07e8)
        self.cpu.addcmd2('inc aaaa', 0x07e8)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0x07e8, 0, False, True)

    def test_inc_abs_3(self):
        # 0 -> $07e8, INC -> 1
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd2('stx aaaa', 0x07e8)
        self.cpu.addcmd2('inc aaaa', 0x07e8)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0x07e8, 1, False, False)

    def test_eor_imm_1(self):
        #   1000 1000   136
        # ^ 0101 1010    90
        # = 1101 0010   210
        self.cpu.addcmd('lda #', 136)
        self.cpu.addcmd('eor #', 90)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(210, True, False, False)

    def test_eor_imm_2(self):
        #   1111 0000   240
        # | 1111 1111    15
        # = 0000 1111   255
        self.cpu.addcmd('lda #', 240)
        self.cpu.addcmd('eor #', 255)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(15, False, False, False)

    def test_inx_1(self):
        # 254 + 1 -> 255, Neg-Flag
        self.cpu.addcmd('ldx #', 254)
        self.cpu.addcmd('lda #', 1) # Neg-Flag loeschen
        self.cpu.addcmd('inx')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(255, True, False, False)

    def test_inx_2(self):
        # 255 + 1 -> 0, Zero-Flag
        self.cpu.addcmd('ldx #', 255)
        self.cpu.addcmd('inx')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(0, False, True, False)

    def test_inx_3(self):
        # 0 + 1 -> 1
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('inx')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(1, False, False, False)

    def test_iny_1(self):
        # 254 + 1 -> 255, Neg-Flag
        self.cpu.addcmd('ldy #', 254)
        self.cpu.addcmd('lda #', 1) # Neg-Flag loeschen
        self.cpu.addcmd('iny')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(255, True, False, False)

    def test_iny_2(self):
        # 255 + 1 -> 0, Zero-Flag
        self.cpu.addcmd('ldy #', 255)
        self.cpu.addcmd('iny')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(0, False, True, False)

    def test_iny_3(self):
        # 0 + 1 -> 1
        self.cpu.addcmd('ldy #', 0)
        self.cpu.addcmd('iny')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(1, False, False, False)

    def test_jmp_abs(self):
        # PC -> $7010
        self.cpu.addcmd2('jmp aaaa', 0x7010)
        self.run_test()
        # PC steht auf $7011, da der brk-Befehl noch
        # ausgefuehrt wird
        self.assertEqual(self.cpu.pc, 0x7011)

    def test_jmp_ind(self):
        # $8010/$8011 = $7010; PC -> ($8010)
        self.cpu.addcmd('lda #', 0x10)
        self.cpu.addcmd2('sta aaaa', 0x8010)
        self.cpu.addcmd('lda #', 0x70)
        self.cpu.addcmd2('sta aaaa', 0x8011)
        self.cpu.addcmd2('jmp (aaaa)', 0x8010)
        self.run_test()
        # PC steht auf $7011, da der brk-Befehl noch
        # ausgefuehrt wird
        self.assertEqual(self.cpu.pc, 0x7011)

    def test_jsr_rts(self):
        # $7005 -> PC, 80 -> A, $7003 -> PC
        self.cpu.addcmd2('jsr aaaa', 0x7005)
        self.cpu.addcmd('brk')
        self.cpu.addcmd('brk')
        self.cpu.addcmd('lda #', 80)
        self.cpu.addcmd('rts')
        self.run_test()
        self.check_a(80, False, False, False)
        # $7004 wegen brk
        self.assertEqual(self.cpu.pc, 0x7004)

    def test_jsr_alt(self):
        # Alternativer Handler bei $6000;
        # 128 -> A, Neg. gesetzt, $7005 -> PC
        def handler():
            self.cpu.reg_a = 128
            self.cpu._a_set_nz_flags()
        # Handler setzen
        self.cpu.addhandler('test', 0x6000, handler)
        self.cpu.addcmd('lda #', 0)
        self.cpu.addcmd2('jsr aaaa', 0x6000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)
        # $7006 wegen brk
        self.assertEqual(self.cpu.pc, 0x7006)

    def test_lda_imm_1(self):
        # 0 -> A, Zero-Flag
        self.cpu.addcmd('lda #', 0)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, False)

    def test_lda_imm_2(self):
        # 100 -> A
        self.cpu.addcmd('lda #', 100)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(100, False, False, False)

    def test_lda_imm_3(self):
        # 128 -> A, Neg-Flag
        self.cpu.addcmd('lda #', 128)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)
    
    def test_lda_zp(self):
        # 192 -> $61 -> A
        self.cpu.addcmd('ldx #', 192)
        self.cpu.addcmd('stx aa', 97)
        self.cpu.addcmd('lda aa', 97)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(192, True, False, False)

    def test_lda_zp_x(self):
        # 128 -> $c6; X=4; $c6,X -> A
        self.cpu.addcmd('ldy #', 128)
        self.cpu.addcmd('sty aa', 0xca)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('lda aa,x', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)
    
    def test_lda_abs(self):
        # 128 -> $0424 -> A
        self.cpu.addcmd('ldx #', 128)
        self.cpu.addcmd('stx aaaa', 36, 4)
        self.cpu.addcmd('lda aaaa', 36, 4)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_lda_abs_x(self):
        # 128 -> $0424; X=4; $0424,X -> A
        self.cpu.addcmd('ldy #', 128)
        self.cpu.addcmd2('sty aaaa', 0x0428)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd2('lda aaaa,x', 0x0424)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_lda_abs_y(self):
        # 128 -> $0424; Y=4; $0424,Y -> A
        self.cpu.addcmd('ldx #', 128)
        self.cpu.addcmd2('stx aaaa', 0x0428)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd2('lda aaaa,y', 0x0424)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_lda_ind_y(self):
        # 128 -> $0428; $0424 -> $61/62; Y=4; ($61/62),Y -> A
        self.cpu.addcmd('ldx #', 128)
        self.cpu.addcmd('stx aaaa', 40, 4)
        self.cpu.addcmd('ldx #', 0x24)
        self.cpu.addcmd('stx aa', 97)
        self.cpu.addcmd('ldx #', 0x04)
        self.cpu.addcmd('stx aa', 98)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('lda (aa),y', 97)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_ldx_imm_1(self):
        # 0 -> X, Zero-Flag
        self.cpu.addcmd('ldx #', 0)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(0, False, True, False)

    def test_ldx_imm_2(self):
        # 100 -> X
        self.cpu.addcmd('ldx #', 100)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(100, False, False, False)

    def test_ldx_imm_3(self):
        # 128 -> X, Neg-Flag
        self.cpu.addcmd('ldx #', 128)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(128, True, False, False)

    def test_ldx_zp(self):
        # 192 -> $61 -> X
        self.cpu.addcmd('lda #', 192)
        self.cpu.addcmd('sta aa', 97)
        self.cpu.addcmd('ldx aa', 97)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(192, True, False, False)

    def test_ldx_abs(self):
        # 128 -> $0424 -> X
        self.cpu.addcmd('lda #', 128)
        self.cpu.addcmd2('sta aaaa', 0x0424)
        self.cpu.addcmd2('ldx aaaa', 0x0424)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(128, True, False, False)

    def test_ldy_imm_1(self):
        # 0 -> Y, Zero-Flag
        self.cpu.addcmd('ldy #', 0)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(0, False, True, False)

    def test_ldy_imm_2(self):
        # 100 -> Y
        self.cpu.addcmd('ldy #', 100)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(100, False, False, False)

    def test_ldy_imm_3(self):
        # 128 -> Y, Neg-Flag
        self.cpu.addcmd('ldy #', 128)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(128, True, False, False)

    def test_ldy_zp(self):
        # 192 -> $61 -> Y
        self.cpu.addcmd('lda #', 192)
        self.cpu.addcmd('sta aa', 97)
        self.cpu.addcmd('ldy aa', 97)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(192, True, False, False)

    def test_ldy_abs(self):
        # 128 -> $0424 -> Y
        self.cpu.addcmd('lda #', 128)
        self.cpu.addcmd2('sta aaaa', 0x0424)
        self.cpu.addcmd2('ldy aaaa', 0x0424)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(128, True, False, False)

    def test_lsr_1(self):
        #    0101 0101   85
        # >> 0010 1010   42 und Carry gesetzt
        self.cpu.addcmd('lda #', 85)
        self.cpu.addcmd('lsr A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(42, False, False, True)

    def test_lsr_2(self):
        #    0010 1010   42
        # >> 0001 0101  21
        self.cpu.addcmd('lda #', 42)
        self.cpu.addcmd('lsr A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(21, False, False, False)

    def test_lsr_zp_1(self):
        #    0101 0101   85
        # >> 0010 1010   42 und Carry gesetzt
        self.cpu.addcmd('lda #', 85)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('lsr aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 42, False, False)
        self.assertTrue(self.cpu.flag_c)

    def test_lsr_zp_2(self):
        #    0010 1010   42
        # >> 0001 0101  21
        self.cpu.addcmd('lda #', 42)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('lsr aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 21, False, False)
        self.assertFalse(self.cpu.flag_c)

    def test_nop(self):
        self.cpu.addcmd('lda #', 1)
        for i in range(5):
            self.cpu.addcmd('nop')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(1, False, False, False)        

    def test_ora_imm_1(self):
        #   1000 1000   136
        # | 0101 1010    90
        # = 1101 1010   218
        self.cpu.addcmd('lda #', 136)
        self.cpu.addcmd('ora #', 90)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(218, True, False, False)

    def test_ora_imm_2(self):
        #   1111 0000   240
        # | 0000 1111    15
        # = 1111 1111   255
        self.cpu.addcmd('lda #', 240)
        self.cpu.addcmd('ora #', 15)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(255, True, False, False)

    def test_pha_pla(self):
        # 128 -> ST -> A, Neg-Flag
        self.cpu.addcmd('lda #', 128)
        self.cpu.addcmd('pha')
        self.cpu.addcmd('lda #', 0)
        self.cpu.addcmd('pla')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)
        self.assertEqual(self.cpu.sp, 255)

    def test_php_plp_1(self):
        # 128 -> Neg-Flag -> ST -> Neg-Flag
        self.cpu.addcmd('lda #', 128)
        self.cpu.addcmd('php')
        self.cpu.addcmd('lda #', 0)
        self.cpu.addcmd('plp')
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertTrue(self.cpu.flag_n)
        self.assertEqual(self.cpu.sp, 255)

    def test_php_plp_2(self):
        # 0 -> Zero-Flag -> ST -> Zero-Flag
        self.cpu.addcmd('lda #', 0)
        self.cpu.addcmd('php')
        self.cpu.addcmd('lda #', 1)
        self.cpu.addcmd('plp')
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertTrue(self.cpu.flag_z)
        self.assertEqual(self.cpu.sp, 255)

    def test_php_plp_3(self):
        # Carry-Flag -> ST -> Carry-Flag
        self.cpu.addcmd('sec')
        self.cpu.addcmd('php')
        self.cpu.addcmd('clc')
        self.cpu.addcmd('plp')
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertTrue(self.cpu.flag_c)
        self.assertEqual(self.cpu.sp, 255)

    def test_php_plp_4(self):
        # Interrupt-Flag -> ST -> Interrupt-Flag
        self.cpu.addcmd('sei') # eigentlich nicht noetig
        self.cpu.addcmd('php')
        self.cpu.addcmd('cli')
        self.cpu.addcmd('plp')
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertTrue(self.cpu.flag_i)
        self.assertEqual(self.cpu.sp, 255)

    def test_rol_1(self):
        #    1010 1010  170
        # << 0101 0100   84 und Carry gesetzt
        self.cpu.addcmd('lda #', 170)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('rol A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(84, False, False, True)

    def test_rol_2(self):
        #    0101 0100   84
        # << 1010 1000  168
        self.cpu.addcmd('lda #', 84)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('rol A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(168, True, False, False)

    def test_rol_3(self):
        #    1010 1010  170 + Carry
        # << 0101 0101   85 und Carry gesetzt
        self.cpu.addcmd('lda #', 170)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('rol A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(85, False, False, True)

    def test_rol_4(self):
        #    0101 0100   84 + Carry
        # << 1010 1001  169
        self.cpu.addcmd('lda #', 84)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('rol A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(169, True, False, False)

    def test_rol_zp_1(self):
        #    1010 1010  170
        # << 0101 0100   84 und Carry gesetzt
        self.cpu.addcmd('lda #', 170)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('rol aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 84, False, False)
        self.assertTrue(self.cpu.flag_c)

    def test_rol_zp_2(self):
        #    0101 0100   84
        # << 1010 1000  168
        self.cpu.addcmd('lda #', 84)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('rol aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 168, True, False)
        self.assertFalse(self.cpu.flag_c)

    def test_rol_zp_3(self):
        #    1010 1010  170 + Carry
        # << 0101 0100   85 und Carry gesetzt
        self.cpu.addcmd('lda #', 170)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('rol aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 85, False, False)
        self.assertTrue(self.cpu.flag_c)

    def test_rol_zp_4(self):
        #    0101 0100   84 + Carry
        # << 1010 1000  169
        self.cpu.addcmd('lda #', 84)
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('rol aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 169, True, False)
        self.assertFalse(self.cpu.flag_c)

    def test_ror_1(self):
        #    0101 0101   85
        # >> 0010 1010   42 und Carry gesetzt
        self.cpu.addcmd('lda #', 85)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('ror A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(42, False, False, True)

    def test_ror_2(self):
        #    0010 1010   42
        # >> 0001 0101   21
        self.cpu.addcmd('lda #', 42)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('ror A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(21, False, False, False)

    def test_ror_3(self):
        #    0101 0101   85 + Carry
        # >> 1010 1010  170 und Carry gesetzt
        self.cpu.addcmd('lda #', 85)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('ror A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(170, True, False, True)

    def test_ror_4(self):
        #    0010 1010   42 + Carry
        # >> 1001 0101  149
        self.cpu.addcmd('lda #', 42)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('ror A')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(149, True, False, False)

    def test_ror_zp_1(self):
        #    0101 0101   85
        # >> 0010 1010   42 und Carry gesetzt
        self.cpu.addcmd('lda #', 85)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('ror aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 42, False, False)
        self.assertTrue(self.cpu.flag_c)

    def test_ror_zp_2(self):
        #    0010 1010   42
        # >> 0001 0101   21
        self.cpu.addcmd('lda #', 42)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('ror aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 21, False, False)
        self.assertFalse(self.cpu.flag_c)

    def test_ror_zp_3(self):
        #    0101 0101   85 + Carry
        # >> 1010 1010  170 und Carry gesetzt
        self.cpu.addcmd('lda #', 85)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('ror aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 170, True, False)
        self.assertTrue(self.cpu.flag_c)

    def test_ror_zp_4(self):
        #    0010 1010   42 + Carry
        # >> 1001 0101  149
        self.cpu.addcmd('lda #', 42)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('sta aa', 0xc6)
        self.cpu.addcmd('ror aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_mem(0xc6, 149, True, False)
        self.assertFalse(self.cpu.flag_c)

    def test_sta_zp(self):
        # 80 -> $61
        self.cpu.addcmd('lda #', 80)
        self.cpu.addcmd('sta aa', 97)
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertEqual(self.cpu.mem[97], 80)

    def test_sbc_imm_1(self):
        # 36 - 21 = 15 und Carry gesetzt
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd('sbc #', 21)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(15, False, False, True)

    def test_sbc_imm_2(self):
        # 36 - 21 - Carry = 14 und Carry gesetzt
        self.cpu.addcmd('clc')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd('sbc #', 21)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(14, False, False, True)

    def test_sbc_imm_3(self):
        # 36 - 36 = 0 und Carry und Zero gesetzt
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd('sbc #', 36)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)

    def test_sbc_imm_4(self):
        # 36 - 37 = -1 = $ff und Carry geloescht, Neg gesetzt
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd('sbc #', 37)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0xff, True, False, False)

    def test_sbc_zp_1(self):
        # [aa] = 21; 36 - [aa] = 15 und Carry gesetzt
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd('sbc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(15, False, False, True)

    def test_sbc_zp_2(self):
        # [aa] = 21; 36 - [aa] - Carry = 14 und Carry gesetzt
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd('sbc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(14, False, False, True)

    def test_sbc_zp_3(self):
        # [aa] = 36; 36 - [aa] = 0 und Carry und Zero gesetzt
        self.cpu.addcmd('ldx #', 36)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd('sbc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)

    def test_sbc_zp_4(self):
        # [aa] = 37; 36 - [aa] = -1 = $ff und Carry geloescht, Neg gesetzt
        self.cpu.addcmd('ldx #', 37)
        self.cpu.addcmd('stx aa', 0xc6)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd('sbc aa', 0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0xff, True, False, False)

    def test_sbc_abs_1(self):
        # [aaaa] = 21; 36 - [aaaa] = 15 und Carry gesetzt
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(15, False, False, True)

    def test_sbc_abs_2(self):
        # [aaaa] = 21; 36 - [aaaa] - Carry = 14 und Carry gesetzt
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(14, False, False, True)

    def test_sbc_abs_3(self):
        # [aaaa] = 36; 36 - [aaaa] = 0 und Carry und Zero gesetzt
        self.cpu.addcmd('ldx #', 36)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)

    def test_sbc_abs_4(self):
        # [aaaa] = 37; 36 - [aaaa] = -1 = $ff und Carry geloescht, Neg gesetzt
        self.cpu.addcmd('ldx #', 37)
        self.cpu.addcmd2('stx aaaa', 0x2000)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0xff, True, False, False)

    def test_sbc_abs_x_1(self):
        # [aaaa,x] = 21; 36 - [aaaa,x] = 15 und Carry gesetzt
        self.cpu.addcmd('ldy #', 21)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(15, False, False, True)

    def test_sbc_abs_x_2(self):
        # [aaaa,x] = 21; 36 - [aaaa,x] - Carry = 14 und Carry gesetzt
        self.cpu.addcmd('ldy #', 21)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(14, False, False, True)

    def test_sbc_abs_x_3(self):
        # [aaaa,x] = 36; 36 - [aaaa,x] = 0 und Carry und Zero gesetzt
        self.cpu.addcmd('ldy #', 36)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)

    def test_sbc_abs_x_4(self):
        # [aaaa,x] = 37; 36 - [aaaa,x] = -1 = $ff und Carry geloescht, Neg gesetzt
        self.cpu.addcmd('ldy #', 37)
        self.cpu.addcmd2('sty aaaa', 0x2004)
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa,x', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0xff, True, False, False)

    def test_sbc_abs_y_1(self):
        # [aaaa,y] = 21; 36 - [aaaa,y] = 15 und Carry gesetzt
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(15, False, False, True)

    def test_sbc_abs_y_2(self):
        # [aaaa,y] = 21; 36 - [aaaa,y] - Carry = 14 und Carry gesetzt
        self.cpu.addcmd('ldx #', 21)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('clc')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(14, False, False, True)

    def test_sbc_abs_y_3(self):
        # [aaaa,y] = 36; 36 - [aaaa,y] = 0 und Carry und Zero gesetzt
        self.cpu.addcmd('ldx #', 36)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0, False, True, True)

    def test_sbc_abs_y_4(self):
        # [aaaa,y] = 37; 36 - [aaaa,y] = -1 = $ff und Carry geloescht, Neg gesetzt
        self.cpu.addcmd('ldx #', 37)
        self.cpu.addcmd2('stx aaaa', 0x2004)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('sec')
        self.cpu.addcmd('lda #', 36)
        self.cpu.addcmd2('sbc aaaa,y', 0x2000)
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(0xff, True, False, False)

    def test_sta_zp_x(self):
        # X=4; 65 -> $c6,X
        self.cpu.addcmd('ldx #', 4)
        self.cpu.addcmd('lda #', 65)
        self.cpu.addcmd('sta aa,x',0xc6)
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertEqual(self.cpu.mem[0xca], 65)

    def test_sta_abs(self):
        # 65 -> $0424
        self.cpu.addcmd('lda #', 65)
        self.cpu.addcmd2('sta aaaa', 0x0424)
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertEqual(self.cpu.mem[0x0424], 65)

    def test_sta_abs_x(self):
        # X=16; 65 -> $0424,X
        self.cpu.addcmd('ldx #', 16)
        self.cpu.addcmd('lda #', 65)
        self.cpu.addcmd2('sta aaaa,x', 0x0424)
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertEqual(self.cpu.mem[0x0434], 65)

    def test_sta_abs_y(self):
        # Y=16; 65 -> $0424,Y
        self.cpu.addcmd('ldy #', 16)
        self.cpu.addcmd('lda #', 65)
        self.cpu.addcmd2('sta aaaa,y',0x0424)
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertEqual(self.cpu.mem[0x0434], 65)

    def test_sta_ind_y(self):
        # $0424 -> $61/62; Y=4; 65 -> ($61/62),Y
        self.cpu.addcmd('ldx #', 0x24)
        self.cpu.addcmd('stx aa', 97)
        self.cpu.addcmd('ldx #', 0x04)
        self.cpu.addcmd('stx aa', 98)
        self.cpu.addcmd('lda #', 65)
        self.cpu.addcmd('ldy #', 4)
        self.cpu.addcmd('sta (aa),y', 97)
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertEqual(self.cpu.mem[0x0428], 65)

    def test_stx_zp(self):
        # 80 -> $61
        self.cpu.addcmd('ldx #', 80)
        self.cpu.addcmd('stx aa', 97)
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertEqual(self.cpu.mem[97], 80)

    def test_stx_abs(self):
        # 65 -> $0424
        self.cpu.addcmd('ldx #', 65)
        self.cpu.addcmd2('stx aaaa', 0x0424)
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertEqual(self.cpu.mem[0x0424], 65)

    def test_sty_zp(self):
        # 80 -> $61
        self.cpu.addcmd('ldy #', 80)
        self.cpu.addcmd('sty aa', 97)
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertEqual(self.cpu.mem[97], 80)

    def test_sty_abs(self):
        # 65 -> $0424
        self.cpu.addcmd('ldy #', 65)
        self.cpu.addcmd2('sty aaaa', 0x0424)
        self.cpu.addcmd('brk')
        self.run_test()
        self.assertEqual(self.cpu.mem[0x0424], 65)

    def test_tax(self):
        # A -> X
        self.cpu.addcmd('lda #', 128)
        self.cpu.addcmd('tax')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_x(128, True, False, False)

    def test_tay(self):
        # A -> Y
        self.cpu.addcmd('lda #', 128)
        self.cpu.addcmd('tay')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_y(128, True, False, False)

    def test_txa(self):
        # X -> A
        self.cpu.addcmd('ldx #', 128)
        self.cpu.addcmd('txa')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)

    def test_tya(self):
        # Y -> A
        self.cpu.addcmd('ldy #', 128)
        self.cpu.addcmd('tya')
        self.cpu.addcmd('brk')
        self.run_test()
        self.check_a(128, True, False, False)


if __name__ == '__main__':
    unittest.main()