package com.loomcom.symon;

import com.loomcom.symon.devices.Memory;
import com.loomcom.symon.exceptions.MemoryAccessException;

import junit.framework.TestCase;

public class CpuAbsoluteModeTest extends TestCase {

    protected Cpu    cpu;
    protected Bus    bus;
    protected Memory mem;

    protected void setUp() throws Exception {
        this.cpu = new Cpu();
        this.bus = new Bus(0x0000, 0xffff);
        this.mem = new Memory(0x0000, 0xffff);
        bus.addCpu(cpu);
        bus.addDevice(mem);

        // Load the reset vector.
        bus.write(0xfffc, Bus.DEFAULT_LOAD_ADDRESS & 0x00ff);
        bus.write(0xfffd, (Bus.DEFAULT_LOAD_ADDRESS & 0xff00) >>> 8);

        cpu.reset();
        // Assert initial state
        assertEquals(0, cpu.getAccumulator());
        assertEquals(0, cpu.getXRegister());
        assertEquals(0, cpu.getYRegister());
        assertEquals(0x200, cpu.getProgramCounter());
        assertEquals(0xff, cpu.getStackPointer());
        assertEquals(0x20, cpu.getProcessorStatus());
    }

    /*
    * The following opcodes are tested for correctness in this file:
    *
    * ORA - $0d
    * ASL - $0e
    * JSR - $20
    * BIT - $2c
    * AND - $2d
    *
    * ROL - $2e
    * JMP - $4c
    * EOR - $4d
    * LSR - $4e
    * ADC - $6d
    *
    * ROR - $6e
    * STY - $8c
    * STA - $8d
    * STX - $8e
    * LDA - $ad
    *
    * LDX - $ae
    * LDY - $bc
    * CMP - $cd
    * CPY - $cc
    * DEC - $ce
    *
    * CPX - $ec
    * SBC - $ed
    * INC - $ee
    */

    /* ORA - Logical Inclusive OR - $0d */

    public void test_ORA() throws MemoryAccessException {
        // Set some initial values in memory
        bus.write(0x7f00, 0x00);
        bus.write(0x7f02, 0x11);
        bus.write(0x3504, 0x22);
        bus.write(0x3508, 0x44);
        bus.write(0x1210, 0x88);

        bus.loadProgram(0x0d, 0x00, 0x7f,  // ORA $7f00
                        0x0d, 0x02, 0x7f,  // ORA $7f02
                        0x0d, 0x04, 0x35,  // ORA $3504
                        0x0d, 0x08, 0x35,  // ORA $3508
                        0x0d, 0x10, 0x12); // ORA $1210
        cpu.step();
        assertEquals(0x00, cpu.getAccumulator());
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x11, cpu.getAccumulator());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x33, cpu.getAccumulator());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x77, cpu.getAccumulator());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0xff, cpu.getAccumulator());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
    }

    /* ASL - Arithmetic Shift Left - $0e */

    public void test_ASL() throws MemoryAccessException {
        bus.write(0x7f00, 0x00);
        bus.write(0x7f01, 0x01);
        bus.write(0x3502, 0x02);
        bus.write(0x3503, 0x44);
        bus.write(0x1204, 0x80);

        bus.loadProgram(0x0e, 0x00, 0x7f,  // ASL $7f00
                        0x0e, 0x01, 0x7f,  // ASL $7f01
                        0x0e, 0x02, 0x35,  // ASL $3502
                        0x0e, 0x03, 0x35,  // ASL $3503
                        0x0e, 0x04, 0x12); // ASL $1204

        cpu.step();
        assertEquals(0x00, bus.read(0x7f00));
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x02, bus.read(0x7f01));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x04, bus.read(0x3502));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x88, bus.read(0x3503));
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x00, bus.read(0x1204));
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertTrue(cpu.getCarryFlag());
    }

    /* JSR - Jump to Subroutine - $20 */

    public void test_JSR() throws MemoryAccessException {
        bus.loadProgram(0xea,              // NOP
                        0xea,              // NOP
                        0x20, 0x00, 0x34); // JSR $3400

        cpu.step(3);

        // New PC should be 0x3400
        assertEquals(0x3400, cpu.getProgramCounter());

        // Old PC-1 should be on stack (i.e.: address of third byte of the
        // JSR instruction, 0x0204)
        assertEquals(0x02, bus.read(0x1ff));
        assertEquals(0x04, bus.read(0x1fe));

        // No flags should have changed.
        assertEquals(0x20, cpu.getProcessorStatus());
    }

    /* BIT - Bit Test - $2c */

    public void test_BIT() throws MemoryAccessException {
        bus.write(0x1200, 0xc0);

        bus.loadProgram(0xa9, 0x01,        // LDA #$01
                        0x2c, 0x00, 0x12,  // BIT $1200

                        0xa9, 0x0f,        // LDA #$0f
                        0x2c, 0x00, 0x12,  // BIT $1200

                        0xa9, 0x40,        // LDA #$40
                        0x2c, 0x00, 0x12,  // BIT $1200

                        0xa9, 0x80,        // LDA #$80
                        0x2c, 0x00, 0x12,  // BIT $1200

                        0xa9, 0xc0,        // LDA #$c0
                        0x2c, 0x00, 0x12,  // BIT $1200

                        0xa9, 0xff,        // LDA #$ff
                        0x2c, 0x00, 0x12); // BIT $1200

        cpu.step(2);
        assertTrue(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
        assertTrue(cpu.getOverflowFlag());

        cpu.step(2);
        assertTrue(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
        assertTrue(cpu.getOverflowFlag());

        cpu.step(2);
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
        assertTrue(cpu.getOverflowFlag());

        cpu.step(2);
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
        assertTrue(cpu.getOverflowFlag());

        cpu.step(2);
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
        assertTrue(cpu.getOverflowFlag());

        cpu.step(2);
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
        assertTrue(cpu.getOverflowFlag());
    }

    /* AND - Logical AND - $2d */

    public void test_AND() throws MemoryAccessException {
        bus.write(0x1200, 0x00);
        bus.write(0x1201, 0x11);
        bus.write(0x1202, 0xff);
        bus.write(0x1203, 0x99);
        bus.write(0x1204, 0x11);
        bus.write(0x1205, 0x0f);

        bus.loadProgram(0x2d, 0x00, 0x12,  // AND $1200
                        0x2d, 0x01, 0x12,  // AND $1201
                        0xa9, 0xaa,        // LDA #$aa
                        0x2d, 0x02, 0x12,  // AND $1202
                        0x2d, 0x03, 0x12,  // AND $1203
                        0x2d, 0x04, 0x12,  // AND $1204
                        0xa9, 0xff,        // LDA #$ff
                        0x2d, 0x05, 0x12); // AND $1205
        cpu.step();
        assertEquals(0x00, cpu.getAccumulator());
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x00, cpu.getAccumulator());
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step(2);
        assertEquals(0xaa, cpu.getAccumulator());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x88, cpu.getAccumulator());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x00, cpu.getAccumulator());
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step(2);
        assertEquals(0x0f, cpu.getAccumulator());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
    }

    /* ROL - Rotate Shift Left - $2e */

    public void test_ROL() throws MemoryAccessException {

        bus.write(0x1200, 0x00);
        bus.write(0x1201, 0x01);

        bus.loadProgram(0x2e, 0x00, 0x12,  // ROL $1200 (m=%00000000, c=0)
                        0x2e, 0x01, 0x12,  // ROL $1201 (m=%00000010, c=0)
                        0x38,              // SEC       (m=%00000010, c=1)
                        0x2e, 0x01, 0x12,  // ROL $1201 (m=%00000101, c=0)
                        0x2e, 0x01, 0x12,  // ROL $1201 (m=%00001010, c=0)
                        0x2e, 0x01, 0x12,  // ROL $1201 (m=%00010100, c=0)
                        0x2e, 0x01, 0x12,  // ROL $1201 (m=%00101000, c=0)
                        0x2e, 0x01, 0x12,  // ROL $1201 (m=%01010000, c=0)
                        0x2e, 0x01, 0x12,  // ROL $1201 (m=%10100000, c=0)
                        0x2e, 0x01, 0x12,  // ROL $1201 (m=%01000000, c=1)
                        0x2e, 0x01, 0x12); // ROL $1201 (m=%10000001, c=0)

        cpu.step();
        assertEquals(0x00, bus.read(0x1200));
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x02, bus.read(0x1201));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step(2);
        assertEquals(0x05, bus.read(0x1201));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x0a, bus.read(0x1201));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x14, bus.read(0x1201));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x28, bus.read(0x1201));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x50, bus.read(0x1201));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0xa0, bus.read(0x1201));
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x40, bus.read(0x1201));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x81, bus.read(0x1201));
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());
    }

    /* JMP - Jump - $4c */

    public void test_JMP() throws MemoryAccessException {
        bus.loadProgram(0x4c, 0x00, 0x34);
        cpu.step();
        assertEquals(0x3400, cpu.getProgramCounter());
        // No change to status flags.
        assertEquals(0x20, cpu.getProcessorStatus());
    }

    /* EOR - Exclusive OR - $4d */

    public void test_EOR() throws MemoryAccessException {
        bus.write(0x1210, 0x00);
        bus.write(0x1211, 0xff);
        bus.write(0x1212, 0x33);
        bus.write(0x1213, 0x44);

        bus.loadProgram(0xa9, 0x88,        // LDA #$88
                        0x4d, 0x10, 0x12,  // EOR $1210
                        0x4d, 0x11, 0x12,  // EOR $1211
                        0x4d, 0x12, 0x12,  // EOR $1212
                        0x4d, 0x13, 0x12); // EOR $1213
        cpu.step(2);
        assertEquals(0x88, cpu.getAccumulator());
        assertTrue(cpu.getNegativeFlag());
        assertFalse(cpu.getZeroFlag());

        cpu.step();
        assertEquals(0x77, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getZeroFlag());

        cpu.step();
        assertEquals(0x44, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getZeroFlag());

        cpu.step();
        assertEquals(0x00, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertTrue(cpu.getZeroFlag());
    }

    /* LSR - Logical Shift Right - $4e */

    public void test_LSR() throws MemoryAccessException {
        bus.write(0x1200, 0x00);
        bus.write(0x1201, 0x01);
        bus.write(0x1202, 0x02);
        bus.write(0x1203, 0x44);
        bus.write(0x1204, 0x80);
        bus.write(0x1205, 0x02);

        bus.loadProgram(0x4e, 0x00, 0x12,  // LSR $1200
                        0x4e, 0x01, 0x12,  // LSR $1201
                        0x4e, 0x02, 0x12,  // LSR $1202
                        0x4e, 0x03, 0x12,  // LSR $1203
                        0x4e, 0x04, 0x12,  // LSR $1204
                        0x38,              // SEC
                        0x4e, 0x05, 0x12); // LSR $1205

        cpu.step();
        assertEquals(0x00, bus.read(0x1200));
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x00, bus.read(0x1201));
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x01, bus.read(0x1202));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x22, bus.read(0x1203));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x40, bus.read(0x1204));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        // Setting Carry should not affect the result.
        cpu.step(2);
        assertEquals(0x01, bus.read(0x1205));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());
    }

    /* ADC - Add with Carry - $6d */

    public void test_ADC() throws MemoryAccessException {
        bus.write(0x1210, 0x01);
        bus.write(0x1211, 0xff);

        bus.loadProgram(0xa9, 0x00,        // LDA #$00
                        0x6d, 0x10, 0x12); // ADC $1210
        cpu.step(2);
        assertEquals(0x01, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0x7f,        // LDA #$7f
                        0x6d, 0x10, 0x12); // ADC $1210
        cpu.step(2);
        assertEquals(0x80, cpu.getAccumulator());
        assertTrue(cpu.getNegativeFlag());
        assertTrue(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0x80,        // LDA #$80
                        0x6d, 0x10, 0x12); // ADC $1210
        cpu.step(2);
        assertEquals(0x81, cpu.getAccumulator());
        assertTrue(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0xff,        // LDA #$ff
                        0x6d, 0x10, 0x12); // ADC $10
        cpu.step(2);
        assertEquals(0x00, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertTrue(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0x00,        // LDA #$00
                        0x6d, 0x11, 0x12); // ADC $11
        cpu.step(2);
        assertEquals(0xff, cpu.getAccumulator());
        assertTrue(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0x7f,        // LDA #$7f
                        0x6d, 0x11, 0x12); // ADC $11
        cpu.step(2);
        assertEquals(0x7e, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0x80,        // LDA #$80
                        0x6d, 0x11, 0x12); // ADC $11
        cpu.step(2);
        assertEquals(0x7f, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertTrue(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0xff,        // LDA #$ff
                        0x6d, 0x11, 0x12); // ADC $11
        cpu.step(2);
        assertEquals(0xfe, cpu.getAccumulator());
        assertTrue(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());
    }

    public void test_ADC_IncludesCarry() throws MemoryAccessException {
        bus.write(0x1210, 0x01);

        bus.loadProgram(0xa9, 0x00,        // LDA #$00
                        0x38,              // SEC
                        0x6d, 0x10, 0x12); // ADC $10
        cpu.step(3);
        assertEquals(0x02, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getCarryFlag());
    }

    public void test_ADC_DecimalMode() throws MemoryAccessException {
        bus.write(0x1210, 0x01);
        bus.write(0x1211, 0x99);

        bus.loadProgram(0xf8,              // SED
                        0xa9, 0x01,        // LDA #$01
                        0x6d, 0x10, 0x12); // ADC $10
        cpu.step(3);
        assertEquals(0x02, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xf8,              // SED
                        0xa9, 0x49,        // LDA #$49
                        0x6d, 0x10, 0x12); // ADC $10
        cpu.step(3);
        assertEquals(0x50, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xf8,              // SED
                        0xa9, 0x50,        // LDA #$50
                        0x6d, 0x10, 0x12); // ADC $10
        cpu.step(3);
        assertEquals(0x51, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xf8,              // SED
                        0xa9, 0x99,        // LDA #$99
                        0x6d, 0x10, 0x12); // ADC $10
        cpu.step(3);
        assertEquals(0x00, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertTrue(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xf8,              // SED
                        0xa9, 0x00,        // LDA #$00
                        0x6d, 0x11, 0x12); // ADC $10
        cpu.step(3);
        assertEquals(0x99, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xf8,              // SED
                        0xa9, 0x49,        // LDA #$49
                        0x6d, 0x11, 0x12); // ADC $11
        cpu.step(3);
        assertEquals(0x48, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xf8,              // SED
                        0xa9, 0x50,        // LDA #$59
                        0x6d, 0x11, 0x12); // ADC $11
        cpu.step(3);
        assertEquals(0x49, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());
    }

    /* ROR - Rotate Right - $6e */

    public void test_ROR() throws MemoryAccessException {
        bus.write(0x1210, 0x00);
        bus.write(0x1211, 0x10);

        bus.loadProgram(0x6e, 0x10, 0x12,  // ROR $1200 (m=%00000000, c=0)
                        0x6e, 0x11, 0x12,  // ROR $1201 (m=%00001000, c=0)
                        0x6e, 0x11, 0x12,  // ROR $1201 (m=%00000100, c=0)
                        0x6e, 0x11, 0x12,  // ROR $1201 (m=%00000010, c=0)
                        0x6e, 0x11, 0x12,  // ROR $1201 (m=%00000001, c=0)
                        0x6e, 0x11, 0x12,  // ROR $1201 (m=%00000000, c=1)
                        0x6e, 0x11, 0x12,  // ROR $1201 (m=%10000000, c=0)
                        0x6e, 0x11, 0x12,  // ROR $1201 (m=%01000000, c=0)
                        0x6e, 0x11, 0x12,  // ROR $1201 (m=%00100000, c=0)
                        0x6e, 0x11, 0x12); // ROR $1201 (m=%00010000, c=0)

        cpu.step();
        assertEquals(0x00, bus.read(0x1210));
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x08, bus.read(0x1211));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x04, bus.read(0x1211));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x02, bus.read(0x1211));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x01, bus.read(0x1211));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x00, bus.read(0x1211));
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x80, bus.read(0x1211));
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x40, bus.read(0x1211));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x20, bus.read(0x1211));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.step();
        assertEquals(0x10, bus.read(0x1211));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getCarryFlag());
    }

    /* STY - Store Y Register - $8c */

    public void test_STY() throws MemoryAccessException {
        cpu.setYRegister(0x00);
        bus.loadProgram(0x8c, 0x10, 0x12);
        cpu.step();
        assertEquals(0x00, bus.read(0x1210));
        // STY should have NO effect on flags.
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.reset();

        cpu.setYRegister(0x0f);
        bus.loadProgram(0x8c, 0x10, 0x12);
        cpu.step();
        assertEquals(0x0f, bus.read(0x1210));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.reset();

        cpu.setYRegister(0x80);
        bus.loadProgram(0x8c, 0x10, 0x12);
        cpu.step();
        assertEquals(0x80, bus.read(0x1210));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
    }

    /* STA - Store Accumulator - $8d */

    public void test_STA() throws MemoryAccessException {
        cpu.setAccumulator(0x00);
        bus.loadProgram(0x8d, 0x10, 0x12);
        cpu.step();
        assertEquals(0x00, bus.read(0x1210));
        // STA should have NO effect on flags.
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.reset();

        cpu.setAccumulator(0x0f);
        bus.loadProgram(0x8d, 0x10, 0x12);
        cpu.step();
        assertEquals(0x0f, bus.read(0x1210));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.reset();

        cpu.setAccumulator(0x80);
        bus.loadProgram(0x8d, 0x10, 0x12);
        cpu.step();
        assertEquals(0x80, bus.read(0x1210));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
    }

    /* STX - Store X Register - $8e */

    public void test_STX() throws MemoryAccessException {
        cpu.setXRegister(0x00);
        bus.loadProgram(0x8e, 0x10, 0x12);
        cpu.step();
        assertEquals(0x00, bus.read(0x1210));
        // STX should have NO effect on flags.
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.reset();

        cpu.setXRegister(0x0f);
        bus.loadProgram(0x8e, 0x10, 0x12);
        cpu.step();
        assertEquals(0x0f, bus.read(0x1210));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.reset();

        cpu.setXRegister(0x80);
        bus.loadProgram(0x8e, 0x10, 0x12);
        cpu.step();
        assertEquals(0x80, bus.read(0x1210));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());
    }

    /* LDA - Load Accumulator - $ad */

    public void test_LDA() throws MemoryAccessException {
        bus.write(0x1210, 0x00);
        bus.write(0x1211, 0x0f);
        bus.write(0x1212, 0x80);

        bus.loadProgram(0xad, 0x10, 0x12,  // LDA $1210
                        0xad, 0x11, 0x12,  // LDA $1211
                        0xad, 0x12, 0x12); // LDA $1212

        cpu.step();
        assertEquals(0x00, cpu.getAccumulator());
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x0f, cpu.getAccumulator());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x80, cpu.getAccumulator());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
    }

    /* LDX - Load X Register - $ae */

    public void test_LDX() throws MemoryAccessException {
        bus.write(0x1210, 0x00);
        bus.write(0x1211, 0x0f);
        bus.write(0x1212, 0x80);

        bus.loadProgram(0xae, 0x10, 0x12,  // LDX $1210
                        0xae, 0x11, 0x12,  // LDX $1211
                        0xae, 0x12, 0x12); // LDX $1212

        cpu.step();
        assertEquals(0x00, cpu.getXRegister());
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x0f, cpu.getXRegister());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x80, cpu.getXRegister());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
    }

    /* LDY - Load Y Register - $bc */

    public void test_LDY() throws MemoryAccessException {
        bus.write(0x1210, 0x00);
        bus.write(0x1211, 0x0f);
        bus.write(0x1212, 0x80);

        bus.loadProgram(0xbc, 0x10, 0x12,  // LDY $1210
                        0xbc, 0x11, 0x12,  // LDY $1211
                        0xbc, 0x12, 0x12); // LDY $1212

        cpu.step();
        assertEquals(0x00, cpu.getYRegister());
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x0f, cpu.getYRegister());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x80, cpu.getYRegister());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
    }

    /* CMP - Compare Accumulator - $cd */

    public void test_CMP() throws MemoryAccessException {
        bus.write(0x1210, 0x00);
        bus.write(0x1211, 0x80);
        bus.write(0x1212, 0xff);

        cpu.setAccumulator(0x80);

        bus.loadProgram(0xcd, 0x10, 0x12,  // CMP $1210
                        0xcd, 0x11, 0x12,  // CMP $1211
                        0xcd, 0x12, 0x12); // CMP $1212

        cpu.step();
        assertTrue(cpu.getCarryFlag());    // m > y
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag()); // m - y < 0

        cpu.step();
        assertTrue(cpu.getCarryFlag());     // m = y
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag()); // m - y == 0

        cpu.step();
        assertFalse(cpu.getCarryFlag());    // m < y
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());  // m - y > 0
    }

    /* CPY - Compare Y Register - $cc */

    public void test_CPY() throws MemoryAccessException {
        bus.write(0x1210, 0x00);
        bus.write(0x1211, 0x80);
        bus.write(0x1212, 0xff);

        cpu.setYRegister(0x80);

        bus.loadProgram(0xcc, 0x10, 0x12,  // CPY $1210
                        0xcc, 0x11, 0x12,  // CPY $1211
                        0xcc, 0x12, 0x12); // CPY $1212

        cpu.step();
        assertTrue(cpu.getCarryFlag());    // m > y
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag()); // m - y < 0

        cpu.step();
        assertTrue(cpu.getCarryFlag());     // m = y
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag()); // m - y == 0

        cpu.step();
        assertFalse(cpu.getCarryFlag());    // m < y
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());  // m - y = $81
    }

    /* DEC - Decrement Memory Location - $ce */

    public void test_DEC() throws MemoryAccessException {
        bus.write(0x1210, 0x00);
        bus.write(0x1211, 0x01);
        bus.write(0x1212, 0x80);
        bus.write(0x1213, 0xff);

        bus.loadProgram(0xce, 0x10, 0x12,  // DEC $1210
                        0xce, 0x11, 0x12,  // DEC $1211
                        0xce, 0x12, 0x12,  // DEC $1212
                        0xce, 0x13, 0x12); // DEC $1213

        cpu.step();
        assertEquals(0xff, bus.read(0x1210));
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x00, bus.read(0x1211));
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x7f, bus.read(0x1212));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0xfe, bus.read(0x1213));
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());
    }

    /* CPX - Compare X Register - $ec */

    public void test_CPX() throws MemoryAccessException {
        bus.write(0x1210, 0x00);
        bus.write(0x1211, 0x80);
        bus.write(0x1212, 0xff);

        cpu.setXRegister(0x80);

        bus.loadProgram(0xec, 0x10, 0x12,  // CPX $1210
                        0xec, 0x11, 0x12,  // CPX $1211
                        0xec, 0x12, 0x12); // CPX $1212

        cpu.step();
        assertTrue(cpu.getCarryFlag());    // m > y
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag()); // m - y < 0

        cpu.step();
        assertTrue(cpu.getCarryFlag());    // m = y
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag()); // m - y == 0

        cpu.step();
        assertFalse(cpu.getCarryFlag());    // m < y
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag()); // $80 - $ff = 81
    }

    /* SBC - Subtract with Carry (borrow) - $ed */

    public void test_SBC() throws MemoryAccessException {
        bus.write(0x1210, 0x01);

        bus.loadProgram(0xa9, 0x00,        // LDA #$00
                        0xed, 0x10, 0x12); // SBC $1210
        cpu.step(2);
        assertEquals(0xfe, cpu.getAccumulator());
        assertTrue(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0x7f,        // LDA #$7f
                        0xed, 0x10, 0x12); // SBC $1210
        cpu.step(2);
        assertEquals(0x7d, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0x80,        // LDA #$80
                        0xed, 0x10, 0x12); // SBC $1210
        cpu.step(2);
        assertEquals(0x7e, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertTrue(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0xff,        // LDA #$ff
                        0xed, 0x10, 0x12); // SBC $1210
        cpu.step(2);
        assertEquals(0xfd, cpu.getAccumulator());
        assertTrue(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());

        cpu.reset();
        bus.loadProgram(0xa9, 0x02,        // LDA #$02
                        0xed, 0x10, 0x12); // SBC $1210
        cpu.step(2);
        assertEquals(0x00, cpu.getAccumulator());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertTrue(cpu.getZeroFlag());
        assertTrue(cpu.getCarryFlag());
    }

    public void test_SBC_IncludesNotOfCarry() throws MemoryAccessException {
        bus.write(0x1210, 0x01);

        // Subtrace with Carry Flag cleared
        bus.loadProgram(0x18,              // CLC
                        0xa9, 0x05,        // LDA #$00
                        0xed, 0x10, 0x12); // SBC $1210

        cpu.step(3);
        assertEquals(0x03, cpu.getAccumulator());

        cpu.reset();

        // Subtrace with Carry Flag cleared
        bus.loadProgram(0x18,              // CLC
                        0xa9, 0x00,        // LDA #$00
                        0xed, 0x10, 0x12); // SBC $1210

        cpu.step(3);
        assertEquals(0xfe, cpu.getAccumulator());

        cpu.reset();

        // Subtract with Carry Flag set
        bus.loadProgram(0x38,              // SEC
                        0xa9, 0x05,        // LDA #$00
                        0xed, 0x10, 0x12); // SBC $1210
        cpu.step(3);
        assertEquals(0x04, cpu.getAccumulator());
        assertTrue(cpu.getCarryFlag());

        cpu.reset();

        // Subtract with Carry Flag set
        bus.loadProgram(0x38,              // SEC
                        0xa9, 0x00,        // LDA #$00
                        0xed, 0x10, 0x12); // SBC $1210
        cpu.step(3);
        assertEquals(0xff, cpu.getAccumulator());
        assertFalse(cpu.getCarryFlag());

    }

    public void test_SBC_DecimalMode() throws MemoryAccessException {
        bus.write(0x1210, 0x01);
        bus.write(0x1220, 0x11);

        bus.loadProgram(0xf8,
                        0xa9, 0x00,
                        0xed, 0x10, 0x12);
        cpu.step(3);
        assertEquals(0x98, cpu.getAccumulator());
        assertFalse(cpu.getCarryFlag()); // borrow = set flag
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getDecimalModeFlag());

        cpu.reset();

        bus.loadProgram(0xf8,
                        0xa9, 0x99,
                        0xed, 0x10, 0x12);
        cpu.step(3);
        assertEquals(0x97, cpu.getAccumulator());
        assertTrue(cpu.getCarryFlag()); // No borrow = clear flag
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getDecimalModeFlag());

        cpu.reset();

        bus.loadProgram(0xf8,
                        0xa9, 0x50,
                        0xed, 0x10, 0x12);
        cpu.step(3);
        assertEquals(0x48, cpu.getAccumulator());
        assertTrue(cpu.getCarryFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getDecimalModeFlag());


        cpu.reset();

        bus.loadProgram(0xf8,               // SED
                        0xa9, 0x02,         // LDA #$02
                        0xed, 0x10, 0x12);  // SBC $1210
        cpu.step(3);
        assertEquals(0x00, cpu.getAccumulator());
        assertTrue(cpu.getCarryFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertTrue(cpu.getZeroFlag());
        assertTrue(cpu.getDecimalModeFlag());

        cpu.reset();

        bus.loadProgram(0xf8,               // SED
                        0xa9, 0x10,         // LDA #$10
                        0xed, 0x20, 0x12);  // SBC $20
        cpu.step(3);
        assertEquals(0x98, cpu.getAccumulator());
        assertFalse(cpu.getCarryFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getDecimalModeFlag());

        cpu.reset();

        bus.loadProgram(0x38,               // SEC
                        0xf8,               // SED
                        0xa9, 0x05,         // LDA #$05
                        0xed, 0x10, 0x12);  // SBC $1210
        cpu.step(4);
        assertEquals(0x04, cpu.getAccumulator());
        assertTrue(cpu.getCarryFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getDecimalModeFlag());

        cpu.reset();

        bus.loadProgram(0x38,               // SEC
                        0xf8,               // SED
                        0xa9, 0x00,         // LDA #$00
                        0xed, 0x10, 0x12);  // SBC $1210
        cpu.step(4);
        assertEquals(0x99, cpu.getAccumulator());
        assertFalse(cpu.getCarryFlag());
        assertFalse(cpu.getNegativeFlag());
        assertFalse(cpu.getOverflowFlag());
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getDecimalModeFlag());
    }

    /* INC - Increment Memory Location - $ee */

    public void test_INC() throws MemoryAccessException {
        bus.write(0x1210, 0x00);
        bus.write(0x1211, 0x7f);
        bus.write(0x1212, 0xff);

        bus.loadProgram(0xee, 0x10, 0x12,  // INC $1210
                        0xee, 0x11, 0x12,  // INC $1211
                        0xee, 0x12, 0x12); // INC $1212

        cpu.step();
        assertEquals(0x01, bus.read(0x1210));
        assertFalse(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x80, bus.read(0x1211));
        assertFalse(cpu.getZeroFlag());
        assertTrue(cpu.getNegativeFlag());

        cpu.step();
        assertEquals(0x00, bus.read(0x1212));
        assertTrue(cpu.getZeroFlag());
        assertFalse(cpu.getNegativeFlag());

    }

}