web-a2e 1.0.0

package/tests/unit/test_cpu_cycle_counts.cpp

@@ -0,0 +1,409 @@
+/*
+ * test_cpu_cycle_counts.cpp - 65C02 instruction cycle count tests
+ *
+ * Verifies correct cycle counts for various instructions and
+ * addressing modes, including page boundary crossing penalties.
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+#include "test_helpers.hpp"
+
+// Helper: returns cycles consumed by the next instruction
+static uint64_t measureCycles(a2e::CPU6502& cpu) {
+    uint64_t before = cpu.getTotalCycles();
+    cpu.executeInstruction();
+    uint64_t after = cpu.getTotalCycles();
+    return after - before;
+}
+
+// ============================================================================
+// Basic Instruction Cycle Counts
+// ============================================================================
+
+TEST_CASE("Basic instruction cycle counts", "[cpu][cycles]") {
+
+    SECTION("NOP takes 2 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xEA}); // NOP
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+
+    SECTION("LDA immediate takes 2 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xA9, 0x42}); // LDA #$42
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+
+    SECTION("LDX immediate takes 2 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xA2, 0x10}); // LDX #$10
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+
+    SECTION("LDY immediate takes 2 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xA0, 0x10}); // LDY #$10
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+}
+
+// ============================================================================
+// Zero Page Cycle Counts
+// ============================================================================
+
+TEST_CASE("Zero page instruction cycle counts", "[cpu][cycles]") {
+
+    SECTION("LDA zero page takes 3 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xA5, 0x10}); // LDA $10
+        REQUIRE(measureCycles(*f.cpu) == 3);
+    }
+
+    SECTION("STA zero page takes 3 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x85, 0x10}); // STA $10
+        REQUIRE(measureCycles(*f.cpu) == 3);
+    }
+
+    SECTION("LDA zero page,X takes 4 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xB5, 0x10}); // LDA $10,X
+        REQUIRE(measureCycles(*f.cpu) == 4);
+    }
+}
+
+// ============================================================================
+// Absolute Addressing Cycle Counts
+// ============================================================================
+
+TEST_CASE("Absolute addressing cycle counts", "[cpu][cycles]") {
+
+    SECTION("LDA absolute takes 4 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xAD, 0x00, 0x20}); // LDA $2000
+        REQUIRE(measureCycles(*f.cpu) == 4);
+    }
+
+    SECTION("STA absolute takes 4 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x8D, 0x00, 0x20}); // STA $2000
+        REQUIRE(measureCycles(*f.cpu) == 4);
+    }
+}
+
+// ============================================================================
+// Absolute,X with Page Crossing
+// ============================================================================
+
+TEST_CASE("Absolute,X cycle counts with page crossing", "[cpu][cycles]") {
+
+    SECTION("LDA abs,X no page cross takes 4 cycles") {
+        test::CPUTestFixture f;
+        // X=$01, base=$2000 -> $2001, same page
+        f.loadAndReset(0x0400, {0xA2, 0x01, 0xBD, 0x00, 0x20}); // LDX #$01; LDA $2000,X
+        measureCycles(*f.cpu); // LDX
+        REQUIRE(measureCycles(*f.cpu) == 4);
+    }
+
+    SECTION("LDA abs,X with page cross takes 5 cycles") {
+        test::CPUTestFixture f;
+        // X=$01, base=$20FF -> $2100, page crossed
+        f.loadAndReset(0x0400, {0xA2, 0x01, 0xBD, 0xFF, 0x20}); // LDX #$01; LDA $20FF,X
+        measureCycles(*f.cpu); // LDX
+        REQUIRE(measureCycles(*f.cpu) == 5);
+    }
+
+    SECTION("STA abs,X always takes 5 cycles (no page cross optimization)") {
+        test::CPUTestFixture f;
+        // Stores always take the same cycles regardless of page cross
+        f.loadAndReset(0x0400, {0xA2, 0x01, 0x9D, 0x00, 0x20}); // LDX #$01; STA $2000,X
+        measureCycles(*f.cpu); // LDX
+        REQUIRE(measureCycles(*f.cpu) == 5);
+    }
+}
+
+// ============================================================================
+// Absolute,Y with Page Crossing
+// ============================================================================
+
+TEST_CASE("Absolute,Y cycle counts with page crossing", "[cpu][cycles]") {
+
+    SECTION("LDA abs,Y no page cross takes 4 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xA0, 0x01, 0xB9, 0x00, 0x20}); // LDY #$01; LDA $2000,Y
+        measureCycles(*f.cpu); // LDY
+        REQUIRE(measureCycles(*f.cpu) == 4);
+    }
+
+    SECTION("LDA abs,Y with page cross takes 5 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xA0, 0x01, 0xB9, 0xFF, 0x20}); // LDY #$01; LDA $20FF,Y
+        measureCycles(*f.cpu); // LDY
+        REQUIRE(measureCycles(*f.cpu) == 5);
+    }
+}
+
+// ============================================================================
+// (Indirect),Y with Page Crossing
+// ============================================================================
+
+TEST_CASE("(Indirect),Y cycle counts with page crossing", "[cpu][cycles]") {
+
+    SECTION("LDA (zp),Y no page cross takes 5 cycles") {
+        test::CPUTestFixture f;
+        f.mem[0x10] = 0x00;
+        f.mem[0x11] = 0x20;
+        // Y=$01 -> $2000+$01 = $2001, same page
+        f.loadAndReset(0x0400, {0xA0, 0x01, 0xB1, 0x10}); // LDY #$01; LDA ($10),Y
+        measureCycles(*f.cpu); // LDY
+        REQUIRE(measureCycles(*f.cpu) == 5);
+    }
+
+    SECTION("LDA (zp),Y with page cross takes 6 cycles") {
+        test::CPUTestFixture f;
+        f.mem[0x10] = 0xFF;
+        f.mem[0x11] = 0x20;
+        // Y=$01 -> $20FF+$01 = $2100, page crossed
+        f.loadAndReset(0x0400, {0xA0, 0x01, 0xB1, 0x10}); // LDY #$01; LDA ($10),Y
+        measureCycles(*f.cpu); // LDY
+        REQUIRE(measureCycles(*f.cpu) == 6);
+    }
+}
+
+// ============================================================================
+// Branch Instruction Cycle Counts
+// ============================================================================
+
+TEST_CASE("Branch instruction cycle counts", "[cpu][cycles]") {
+
+    SECTION("Branch not taken takes 2 cycles") {
+        test::CPUTestFixture f;
+        // LDA #$01 sets Z=0, then BEQ (not taken)
+        f.loadAndReset(0x0400, {0xA9, 0x01, 0xF0, 0x02}); // LDA #$01; BEQ +2
+        measureCycles(*f.cpu); // LDA
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+
+    SECTION("Branch taken same page takes 3 cycles") {
+        test::CPUTestFixture f;
+        // LDA #$00 sets Z=1, then BEQ +2 (taken, same page)
+        f.loadAndReset(0x0400, {0xA9, 0x00, 0xF0, 0x02}); // LDA #$00; BEQ +2
+        measureCycles(*f.cpu); // LDA
+        REQUIRE(measureCycles(*f.cpu) == 3);
+    }
+
+    SECTION("Branch taken crossing page takes 4 cycles") {
+        test::CPUTestFixture f;
+        // Place code near page boundary: $04FB: LDA #$00; BEQ +$05
+        // BEQ at $04FD, PC after fetch = $04FF, target = $0504 (different page)
+        // oldPC ($04FF) is in page $0400, target ($0504) is in page $0500
+        f.mem.loadProgram(0x04FB, {0xA9, 0x00, 0xF0, 0x05});
+        f.mem.setResetVector(0x04FB);
+        f.cpu->reset();
+        measureCycles(*f.cpu); // LDA
+        REQUIRE(measureCycles(*f.cpu) == 4);
+    }
+}
+
+// ============================================================================
+// JSR / RTS Cycle Counts
+// ============================================================================
+
+TEST_CASE("JSR and RTS cycle counts", "[cpu][cycles]") {
+
+    SECTION("JSR takes 6 cycles") {
+        test::CPUTestFixture f;
+        f.mem.loadProgram(0x0500, {0xEA}); // NOP at subroutine
+        f.loadAndReset(0x0400, {0x20, 0x00, 0x05}); // JSR $0500
+        REQUIRE(measureCycles(*f.cpu) == 6);
+    }
+
+    SECTION("RTS takes 6 cycles") {
+        test::CPUTestFixture f;
+        f.mem.loadProgram(0x0500, {0x60}); // RTS at subroutine
+        f.loadAndReset(0x0400, {0x20, 0x00, 0x05}); // JSR $0500
+        measureCycles(*f.cpu); // JSR
+        REQUIRE(measureCycles(*f.cpu) == 6); // RTS
+    }
+}
+
+// ============================================================================
+// BRK Cycle Count
+// ============================================================================
+
+TEST_CASE("BRK cycle count", "[cpu][cycles]") {
+
+    SECTION("BRK takes 7 cycles") {
+        test::CPUTestFixture f;
+        f.mem.setIRQVector(0x1000);
+        f.mem.loadProgram(0x1000, {0xEA});
+        f.loadAndReset(0x0400, {0x00, 0xEA}); // BRK; padding
+        REQUIRE(measureCycles(*f.cpu) == 7);
+    }
+}
+
+// ============================================================================
+// Read-Modify-Write Cycle Counts
+// ============================================================================
+
+TEST_CASE("Read-modify-write cycle counts", "[cpu][cycles]") {
+
+    SECTION("INC absolute takes 6 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xEE, 0x00, 0x20}); // INC $2000
+        REQUIRE(measureCycles(*f.cpu) == 6);
+    }
+
+    SECTION("DEC absolute takes 6 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xCE, 0x00, 0x20}); // DEC $2000
+        REQUIRE(measureCycles(*f.cpu) == 6);
+    }
+
+    SECTION("ASL absolute takes 6 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x0E, 0x00, 0x20}); // ASL $2000
+        REQUIRE(measureCycles(*f.cpu) == 6);
+    }
+
+    SECTION("LSR absolute takes 6 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x4E, 0x00, 0x20}); // LSR $2000
+        REQUIRE(measureCycles(*f.cpu) == 6);
+    }
+
+    SECTION("ROL absolute takes 6 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x2E, 0x00, 0x20}); // ROL $2000
+        REQUIRE(measureCycles(*f.cpu) == 6);
+    }
+
+    SECTION("ROR absolute takes 6 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x6E, 0x00, 0x20}); // ROR $2000
+        REQUIRE(measureCycles(*f.cpu) == 6);
+    }
+
+    SECTION("INC zero page takes 5 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xE6, 0x10}); // INC $10
+        REQUIRE(measureCycles(*f.cpu) == 5);
+    }
+
+    SECTION("ASL accumulator takes 2 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x0A}); // ASL A
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+}
+
+// ============================================================================
+// Stack Operation Cycle Counts
+// ============================================================================
+
+TEST_CASE("Stack operation cycle counts", "[cpu][cycles]") {
+
+    SECTION("PHA takes 3 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x48}); // PHA
+        REQUIRE(measureCycles(*f.cpu) == 3);
+    }
+
+    SECTION("PLA takes 4 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x48, 0x68}); // PHA; PLA
+        measureCycles(*f.cpu); // PHA
+        REQUIRE(measureCycles(*f.cpu) == 4);
+    }
+
+    SECTION("PHP takes 3 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x08}); // PHP
+        REQUIRE(measureCycles(*f.cpu) == 3);
+    }
+
+    SECTION("PLP takes 4 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x08, 0x28}); // PHP; PLP
+        measureCycles(*f.cpu); // PHP
+        REQUIRE(measureCycles(*f.cpu) == 4);
+    }
+}
+
+// ============================================================================
+// Implied Instruction Cycle Counts
+// ============================================================================
+
+TEST_CASE("Implied instruction cycle counts", "[cpu][cycles]") {
+
+    SECTION("INX takes 2 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xE8}); // INX
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+
+    SECTION("DEX takes 2 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xCA}); // DEX
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+
+    SECTION("TAX takes 2 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xAA}); // TAX
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+
+    SECTION("SEC takes 2 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x38}); // SEC
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+
+    SECTION("CLC takes 2 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x18}); // CLC
+        REQUIRE(measureCycles(*f.cpu) == 2);
+    }
+}
+
+// ============================================================================
+// JMP Cycle Counts
+// ============================================================================
+
+TEST_CASE("JMP cycle counts", "[cpu][cycles]") {
+
+    SECTION("JMP absolute takes 3 cycles") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0x4C, 0x00, 0x20}); // JMP $2000
+        REQUIRE(measureCycles(*f.cpu) == 3);
+    }
+
+    SECTION("JMP indirect takes 5 cycles") {
+        test::CPUTestFixture f;
+        // Indirect vector at $3000 -> $2000
+        f.mem[0x3000] = 0x00;
+        f.mem[0x3001] = 0x20;
+        f.loadAndReset(0x0400, {0x6C, 0x00, 0x30}); // JMP ($3000)
+        // 65C02 JMP (abs) = 5 cycles (not 6 which is NMOS indirect)
+        // Actually the cycle table shows opcode $6C = 5 for 65C02
+        REQUIRE(measureCycles(*f.cpu) == 5);
+    }
+}
+
+// ============================================================================
+// (Indirect,X) Cycle Count
+// ============================================================================
+
+TEST_CASE("(Indirect,X) cycle count", "[cpu][cycles]") {
+
+    SECTION("LDA (zp,X) takes 6 cycles") {
+        test::CPUTestFixture f;
+        f.mem[0x12] = 0x00;
+        f.mem[0x13] = 0x20;
+        f.loadAndReset(0x0400, {0xA2, 0x02, 0xA1, 0x10}); // LDX #$02; LDA ($10,X)
+        measureCycles(*f.cpu); // LDX
+        REQUIRE(measureCycles(*f.cpu) == 6);
+    }
+}

package/tests/unit/test_cpu_decimal.cpp

@@ -0,0 +1,166 @@
+/*
+ * test_cpu_decimal.cpp - 65C02 BCD (decimal mode) arithmetic tests
+ *
+ * Tests ADC and SBC in decimal mode with various BCD inputs,
+ * including carry/borrow, edge cases, and flag behavior.
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+#include "test_helpers.hpp"
+
+// ============================================================================
+// ADC in Decimal Mode
+// ============================================================================
+
+TEST_CASE("ADC in decimal mode", "[cpu][decimal]") {
+
+    SECTION("Simple BCD addition: 15 + 27 = 42") {
+        test::CPUTestFixture f;
+        // SED; CLC; LDA #$15; ADC #$27
+        f.loadAndReset(0x0400, {0xF8, 0x18, 0xA9, 0x15, 0x69, 0x27});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x42);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == false);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_D) == true);
+    }
+
+    SECTION("BCD addition: 25 + 35 = 60") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xF8, 0x18, 0xA9, 0x25, 0x69, 0x35});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x60);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == false);
+    }
+
+    SECTION("BCD addition: 50 + 50 = 00 with carry (100 in BCD)") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xF8, 0x18, 0xA9, 0x50, 0x69, 0x50});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x00);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == true);
+    }
+
+    SECTION("BCD addition with carry in: 15 + 27 + 1 = 43") {
+        test::CPUTestFixture f;
+        // SED; SEC; LDA #$15; ADC #$27
+        f.loadAndReset(0x0400, {0xF8, 0x38, 0xA9, 0x15, 0x69, 0x27});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x43);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == false);
+    }
+
+    SECTION("BCD addition: 99 + 01 = 00 with carry") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xF8, 0x18, 0xA9, 0x99, 0x69, 0x01});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x00);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == true);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_Z) == true);
+    }
+
+    SECTION("BCD addition: 99 + 99 = 98 with carry") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xF8, 0x18, 0xA9, 0x99, 0x69, 0x99});
+        test::runInstructions(*f.cpu, 4);
+        // 99 + 99 = 198 in decimal -> 0x98 with carry
+        REQUIRE(f.cpu->getA() == 0x98);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == true);
+    }
+
+    SECTION("BCD addition: 00 + 00 = 00") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xF8, 0x18, 0xA9, 0x00, 0x69, 0x00});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x00);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_Z) == true);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == false);
+    }
+}
+
+// ============================================================================
+// SBC in Decimal Mode
+// ============================================================================
+
+TEST_CASE("SBC in decimal mode", "[cpu][decimal]") {
+
+    SECTION("Simple BCD subtraction: 42 - 15 = 27") {
+        test::CPUTestFixture f;
+        // SED; SEC; LDA #$42; SBC #$15
+        f.loadAndReset(0x0400, {0xF8, 0x38, 0xA9, 0x42, 0xE9, 0x15});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x27);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == true); // no borrow
+    }
+
+    SECTION("BCD subtraction: 50 - 25 = 25") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xF8, 0x38, 0xA9, 0x50, 0xE9, 0x25});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x25);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == true);
+    }
+
+    SECTION("BCD subtraction with borrow: 10 - 20 = 90 (with borrow)") {
+        test::CPUTestFixture f;
+        // SED; SEC; LDA #$10; SBC #$20
+        f.loadAndReset(0x0400, {0xF8, 0x38, 0xA9, 0x10, 0xE9, 0x20});
+        test::runInstructions(*f.cpu, 4);
+        // 10 - 20 = -10 in decimal -> borrow -> result = 90
+        REQUIRE(f.cpu->getA() == 0x90);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == false); // borrow occurred
+    }
+
+    SECTION("BCD subtraction: 00 - 01 with borrow = 99") {
+        test::CPUTestFixture f;
+        // SED; SEC; LDA #$00; SBC #$01
+        f.loadAndReset(0x0400, {0xF8, 0x38, 0xA9, 0x00, 0xE9, 0x01});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x99);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == false);
+    }
+
+    SECTION("BCD subtraction: 42 - 42 = 00") {
+        test::CPUTestFixture f;
+        f.loadAndReset(0x0400, {0xF8, 0x38, 0xA9, 0x42, 0xE9, 0x42});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x00);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_Z) == true);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_C) == true);
+    }
+
+    SECTION("BCD subtraction with borrow in (carry clear): 42 - 15 - 1 = 26") {
+        test::CPUTestFixture f;
+        // SED; CLC; LDA #$42; SBC #$15
+        f.loadAndReset(0x0400, {0xF8, 0x18, 0xA9, 0x42, 0xE9, 0x15});
+        test::runInstructions(*f.cpu, 4);
+        REQUIRE(f.cpu->getA() == 0x26);
+    }
+}
+
+// ============================================================================
+// Decimal Mode Flag Preservation
+// ============================================================================
+
+TEST_CASE("Decimal mode flag preservation", "[cpu][decimal]") {
+
+    SECTION("D flag remains set across multiple operations") {
+        test::CPUTestFixture f;
+        // SED; CLC; LDA #$10; ADC #$20; CLC; ADC #$05
+        f.loadAndReset(0x0400, {0xF8, 0x18, 0xA9, 0x10, 0x69, 0x20, 0x18, 0x69, 0x05});
+        test::runInstructions(*f.cpu, 6);
+        // 10 + 20 = 30, then 30 + 05 = 35
+        REQUIRE(f.cpu->getA() == 0x35);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_D) == true);
+    }
+
+    SECTION("CLD clears decimal mode and subsequent ADC is binary") {
+        test::CPUTestFixture f;
+        // SED; CLD; CLC; LDA #$09; ADC #$01
+        f.loadAndReset(0x0400, {0xF8, 0xD8, 0x18, 0xA9, 0x09, 0x69, 0x01});
+        test::runInstructions(*f.cpu, 5);
+        // Binary: $09 + $01 = $0A (not BCD $10)
+        REQUIRE(f.cpu->getA() == 0x0A);
+        REQUIRE(f.cpu->getFlag(a2e::FLAG_D) == false);
+    }
+}