web-a2e 1.0.0

package/tests/unit/test_mmu_slots.cpp

@@ -0,0 +1,323 @@
+/*
+ * test_mmu_slots.cpp - Unit tests for MMU expansion slot system
+ *
+ * Tests the expansion card slot management including card insertion,
+ * removal, ROM routing, I/O routing, INTCXROM/SLOTC3ROM switches,
+ * expansion ROM activation, and multiple cards.
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include "mmu/mmu.hpp"
+#include "cards/thunderclock_card.hpp"
+#include "roms.cpp"
+
+#include <memory>
+
+using namespace a2e;
+
+// Helper: create an MMU with ROMs loaded
+static std::unique_ptr<MMU> createMMU() {
+    auto mmu = std::make_unique<MMU>();
+    mmu->loadROM(roms::ROM_SYSTEM, roms::ROM_SYSTEM_SIZE,
+                 roms::ROM_CHAR, roms::ROM_CHAR_SIZE);
+    return mmu;
+}
+
+// ============================================================================
+// Slot empty/occupied state
+// ============================================================================
+
+TEST_CASE("Slots are initially empty", "[mmu][slots]") {
+    auto mmu = createMMU();
+
+    for (int slot = 1; slot <= 7; ++slot) {
+        INFO("Slot " << slot);
+        CHECK(mmu->isSlotEmpty(slot));
+        CHECK(mmu->getCard(slot) == nullptr);
+    }
+}
+
+TEST_CASE("isSlotEmpty returns true for out-of-range slots", "[mmu][slots]") {
+    auto mmu = createMMU();
+
+    CHECK(mmu->isSlotEmpty(0));
+    CHECK(mmu->isSlotEmpty(8));
+}
+
+// ============================================================================
+// Card insertion
+// ============================================================================
+
+TEST_CASE("Insert card into slot: slot becomes occupied", "[mmu][slots]") {
+    auto mmu = createMMU();
+
+    auto card = std::make_unique<ThunderclockCard>();
+    auto* cardPtr = card.get();
+
+    auto removed = mmu->insertCard(5, std::move(card));
+
+    CHECK(removed == nullptr);  // Slot was empty
+    CHECK_FALSE(mmu->isSlotEmpty(5));
+    CHECK(mmu->getCard(5) == cardPtr);
+}
+
+TEST_CASE("insertCard returns previously installed card", "[mmu][slots]") {
+    auto mmu = createMMU();
+
+    auto card1 = std::make_unique<ThunderclockCard>();
+    auto* card1Ptr = card1.get();
+    mmu->insertCard(5, std::move(card1));
+
+    auto card2 = std::make_unique<ThunderclockCard>();
+    auto removed = mmu->insertCard(5, std::move(card2));
+
+    // Should get back card1
+    REQUIRE(removed != nullptr);
+    CHECK(removed.get() == card1Ptr);
+    CHECK_FALSE(mmu->isSlotEmpty(5));
+}
+
+// ============================================================================
+// Card removal
+// ============================================================================
+
+TEST_CASE("removeCard returns the card and slot becomes empty", "[mmu][slots]") {
+    auto mmu = createMMU();
+
+    auto card = std::make_unique<ThunderclockCard>();
+    auto* cardPtr = card.get();
+    mmu->insertCard(5, std::move(card));
+
+    auto removed = mmu->removeCard(5);
+    REQUIRE(removed != nullptr);
+    CHECK(removed.get() == cardPtr);
+    CHECK(mmu->isSlotEmpty(5));
+}
+
+TEST_CASE("removeCard from empty slot returns nullptr", "[mmu][slots]") {
+    auto mmu = createMMU();
+
+    auto removed = mmu->removeCard(5);
+    CHECK(removed == nullptr);
+}
+
+// ============================================================================
+// Slot ROM routing
+// ============================================================================
+
+TEST_CASE("Slot ROM: read $C500-$C5FF accesses Thunderclock card ROM", "[mmu][slots][rom]") {
+    auto mmu = createMMU();
+    mmu->insertCard(5, std::make_unique<ThunderclockCard>());
+
+    // Thunderclock ROM signature bytes (ProDOS clock detection)
+    CHECK(mmu->read(0xC500) == 0x08);  // PHP
+    CHECK(mmu->read(0xC502) == 0x28);  // PLP
+    CHECK(mmu->read(0xC504) == 0x58);  // CLI
+    CHECK(mmu->read(0xC506) == 0x70);  // BVS
+}
+
+TEST_CASE("Slot ROM: empty slot returns floating bus value", "[mmu][slots][rom]") {
+    auto mmu = createMMU();
+
+    // No cycle callback so floating bus returns 0x00
+    uint8_t val = mmu->read(0xC500);
+    CHECK(val == 0x00);
+}
+
+// ============================================================================
+// Slot I/O routing
+// ============================================================================
+
+TEST_CASE("Slot I/O: read/write $C0D0-$C0DF accesses slot 5 card", "[mmu][slots][io]") {
+    auto mmu = createMMU();
+    mmu->insertCard(5, std::make_unique<ThunderclockCard>());
+
+    // Initial I/O read from Thunderclock
+    uint8_t initialValue = mmu->read(0xC0D0);
+    CHECK(initialValue == 0x00);
+
+    // Write a command and verify I/O is being routed
+    mmu->write(0xC0D0, 0x00);
+    mmu->write(0xC0D0, 0xA4);  // CMD_TIMED | FLAG_STROBE
+
+    // The fact that we can write and read without crashing confirms routing
+    uint8_t result = mmu->read(0xC0D0);
+    // Result will have bit 7 set to data bit from Thunderclock
+    (void)result;  // Value depends on time, just verify no crash
+}
+
+TEST_CASE("Slot I/O: slot 7 I/O at $C0F0-$C0FF", "[mmu][slots][io]") {
+    auto mmu = createMMU();
+    mmu->insertCard(7, std::make_unique<ThunderclockCard>());
+
+    uint8_t val = mmu->read(0xC0F0);
+    CHECK(val == 0x00);
+
+    // Slot 7 ROM at $C700
+    CHECK(mmu->read(0xC700) == 0x08);
+}
+
+// ============================================================================
+// INTCXROM switch
+// ============================================================================
+
+TEST_CASE("INTCXROM: when internal, slot ROM reads from internal ROM", "[mmu][slots][intcxrom]") {
+    auto mmu = createMMU();
+    mmu->insertCard(5, std::make_unique<ThunderclockCard>());
+
+    // Verify card ROM is accessible first
+    CHECK(mmu->read(0xC500) == 0x08);
+
+    // Enable INTCXROM (write to $C007)
+    mmu->write(0xC007, 0);
+    CHECK(mmu->getSoftSwitches().intcxrom);
+
+    // Now $C500 should read from internal ROM instead of card
+    uint8_t internalByte = roms::ROM_SYSTEM[0x0500];  // offset $C500 - $C000 = $0500
+    CHECK(mmu->read(0xC500) == internalByte);
+
+    // Disable INTCXROM (write to $C006)
+    mmu->write(0xC006, 0);
+    CHECK_FALSE(mmu->getSoftSwitches().intcxrom);
+
+    // Card ROM should be accessible again
+    CHECK(mmu->read(0xC500) == 0x08);
+}
+
+// ============================================================================
+// SLOTC3ROM switch
+// ============================================================================
+
+TEST_CASE("SLOTC3ROM: controls slot 3 behavior", "[mmu][slots][slotc3rom]") {
+    auto mmu = createMMU();
+
+    // Default: SLOTC3ROM is off, slot 3 uses internal ROM
+    CHECK_FALSE(mmu->getSoftSwitches().slotc3rom);
+
+    // Read from $C300 should return internal ROM
+    uint8_t internalByte = roms::ROM_SYSTEM[0x0300];  // $C300 - $C000
+    CHECK(mmu->read(0xC300) == internalByte);
+
+    // Enable SLOTC3ROM (write to $C00B)
+    mmu->write(0xC00B, 0);
+    CHECK(mmu->getSoftSwitches().slotc3rom);
+
+    // Disable SLOTC3ROM (write to $C00A)
+    mmu->write(0xC00A, 0);
+    CHECK_FALSE(mmu->getSoftSwitches().slotc3rom);
+}
+
+// ============================================================================
+// Expansion ROM
+// ============================================================================
+
+TEST_CASE("Expansion ROM: reading $Cn00 activates expansion ROM at $C800", "[mmu][slots][exprom]") {
+    auto mmu = createMMU();
+    mmu->insertCard(5, std::make_unique<ThunderclockCard>());
+
+    // Access slot 5 ROM to activate expansion ROM
+    mmu->read(0xC500);
+
+    // Thunderclock has expansion ROM, should be active now
+    CHECK(mmu->getActiveExpansionSlot() == 5);
+
+    // Read from expansion ROM area - should not be floating bus
+    uint8_t byte = mmu->read(0xC800);
+    // Thunderclock expansion ROM should have valid data (not 0xFF floating bus)
+    // We just verify it was activated and returns card data
+    (void)byte;
+}
+
+TEST_CASE("Expansion ROM: reading $CFFF deactivates expansion ROM", "[mmu][slots][exprom]") {
+    auto mmu = createMMU();
+    mmu->insertCard(5, std::make_unique<ThunderclockCard>());
+
+    // Activate expansion ROM
+    mmu->read(0xC500);
+    REQUIRE(mmu->getActiveExpansionSlot() == 5);
+
+    // Read $CFFF to deactivate
+    mmu->read(0xCFFF);
+    CHECK(mmu->getActiveExpansionSlot() == 0);
+}
+
+TEST_CASE("Expansion ROM: switching between cards updates active slot", "[mmu][slots][exprom]") {
+    auto mmu = createMMU();
+    mmu->insertCard(5, std::make_unique<ThunderclockCard>());
+    mmu->insertCard(7, std::make_unique<ThunderclockCard>());
+
+    // Activate slot 5 expansion ROM
+    mmu->read(0xC500);
+    CHECK(mmu->getActiveExpansionSlot() == 5);
+
+    // Activate slot 7 expansion ROM
+    mmu->read(0xC700);
+    CHECK(mmu->getActiveExpansionSlot() == 7);
+}
+
+// ============================================================================
+// Multiple cards in different slots
+// ============================================================================
+
+TEST_CASE("Multiple cards: independent access in different slots", "[mmu][slots][multi]") {
+    auto mmu = createMMU();
+    mmu->insertCard(5, std::make_unique<ThunderclockCard>());
+    mmu->insertCard(7, std::make_unique<ThunderclockCard>());
+
+    // Both should be accessible
+    CHECK(mmu->read(0xC500) == 0x08);
+    CHECK(mmu->read(0xC700) == 0x08);
+
+    // Both slot I/O spaces should work independently
+    CHECK(mmu->read(0xC0D0) == 0x00);  // Slot 5
+    CHECK(mmu->read(0xC0F0) == 0x00);  // Slot 7
+
+    // Slots that don't have cards are still empty
+    CHECK(mmu->isSlotEmpty(1));
+    CHECK(mmu->isSlotEmpty(2));
+}
+
+TEST_CASE("Card in slot 1: ROM at $C100, I/O at $C090", "[mmu][slots][multi]") {
+    auto mmu = createMMU();
+    mmu->insertCard(1, std::make_unique<ThunderclockCard>());
+
+    // Slot 1 ROM at $C100
+    CHECK(mmu->read(0xC100) == 0x08);
+
+    // Slot 1 I/O at $C090
+    CHECK(mmu->read(0xC090) == 0x00);
+}
+
+// ============================================================================
+// INTCXROM affects all slot ROMs
+// ============================================================================
+
+TEST_CASE("INTCXROM blocks ROM for all slots simultaneously", "[mmu][slots][intcxrom]") {
+    auto mmu = createMMU();
+    mmu->insertCard(1, std::make_unique<ThunderclockCard>());
+    mmu->insertCard(5, std::make_unique<ThunderclockCard>());
+    mmu->insertCard(7, std::make_unique<ThunderclockCard>());
+
+    // All cards read their own ROM initially
+    CHECK(mmu->read(0xC100) == 0x08);
+    CHECK(mmu->read(0xC500) == 0x08);
+    CHECK(mmu->read(0xC700) == 0x08);
+
+    // Enable INTCXROM
+    mmu->write(0xC007, 0);
+
+    // All slots now read internal ROM
+    CHECK(mmu->read(0xC100) == roms::ROM_SYSTEM[0x0100]);
+    CHECK(mmu->read(0xC500) == roms::ROM_SYSTEM[0x0500]);
+    CHECK(mmu->read(0xC700) == roms::ROM_SYSTEM[0x0700]);
+
+    // Disable INTCXROM
+    mmu->write(0xC006, 0);
+
+    // Cards are accessible again
+    CHECK(mmu->read(0xC100) == 0x08);
+    CHECK(mmu->read(0xC500) == 0x08);
+    CHECK(mmu->read(0xC700) == 0x08);
+}

package/tests/unit/test_mockingboard.cpp

@@ -0,0 +1,352 @@
+/*
+ * test_mockingboard.cpp - Unit tests for MockingboardCard
+ *
+ * Tests the Mockingboard sound card implementation including:
+ * - Construction
+ * - Card metadata (name, preferred slot)
+ * - VIA register access via ROM space
+ * - PSG register write sequence via VIA
+ * - Timer updates
+ * - Reset behavior
+ * - Enable/disable state
+ * - Audio sample generation
+ * - Serialization round-trip
+ * - IRQ generation from VIA timer
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include "mockingboard_card.hpp"
+
+#include <cstring>
+#include <vector>
+
+using namespace a2e;
+
+// VIA register offsets (within the VIA's 16-register space)
+static constexpr uint8_t VIA_ORB  = 0x00;
+static constexpr uint8_t VIA_ORA  = 0x01;
+static constexpr uint8_t VIA_DDRB = 0x02;
+static constexpr uint8_t VIA_DDRA = 0x03;
+static constexpr uint8_t VIA_T1CL = 0x04;
+static constexpr uint8_t VIA_T1CH = 0x05;
+static constexpr uint8_t VIA_T1LL = 0x06;
+static constexpr uint8_t VIA_T1LH = 0x07;
+static constexpr uint8_t VIA_ACR  = 0x0B;
+static constexpr uint8_t VIA_IFR  = 0x0D;
+static constexpr uint8_t VIA_IER  = 0x0E;
+
+// VIA1 base offset in ROM space: bit 7 = 0, so offsets 0x00-0x0F
+// VIA2 base offset in ROM space: bit 7 = 1, so offsets 0x80-0x8F
+
+// ---------------------------------------------------------------------------
+// Construction
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard constructor creates a valid instance", "[mockingboard]") {
+    MockingboardCard card;
+    REQUIRE(card.getName() != nullptr);
+}
+
+// ---------------------------------------------------------------------------
+// Card metadata
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard getName returns Mockingboard", "[mockingboard]") {
+    MockingboardCard card;
+    REQUIRE(std::string(card.getName()) == "Mockingboard");
+}
+
+TEST_CASE("MockingboardCard getPreferredSlot returns 4", "[mockingboard]") {
+    MockingboardCard card;
+    REQUIRE(card.getPreferredSlot() == 4);
+}
+
+TEST_CASE("MockingboardCard hasROM returns true", "[mockingboard]") {
+    MockingboardCard card;
+    REQUIRE(card.hasROM());
+}
+
+TEST_CASE("MockingboardCard hasExpansionROM returns false", "[mockingboard]") {
+    MockingboardCard card;
+    REQUIRE_FALSE(card.hasExpansionROM());
+}
+
+// ---------------------------------------------------------------------------
+// VIA register access via ROM space
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard write/read VIA1 DDRA register", "[mockingboard]") {
+    MockingboardCard card;
+
+    // Write 0xFF to VIA1 DDRA (offset 0x03 in VIA1 space = ROM offset 0x03)
+    card.writeROM(VIA_DDRA, 0xFF);
+    uint8_t val = card.readROM(VIA_DDRA);
+    REQUIRE(val == 0xFF);
+}
+
+TEST_CASE("MockingboardCard write/read VIA1 DDRB register", "[mockingboard]") {
+    MockingboardCard card;
+
+    card.writeROM(VIA_DDRB, 0xFF);
+    uint8_t val = card.readROM(VIA_DDRB);
+    REQUIRE(val == 0xFF);
+}
+
+TEST_CASE("MockingboardCard write/read VIA2 DDRA register", "[mockingboard]") {
+    MockingboardCard card;
+
+    // VIA2 registers are at offset 0x80+
+    card.writeROM(0x80 | VIA_DDRA, 0xFF);
+    uint8_t val = card.readROM(0x80 | VIA_DDRA);
+    REQUIRE(val == 0xFF);
+}
+
+TEST_CASE("MockingboardCard write/read VIA2 DDRB register", "[mockingboard]") {
+    MockingboardCard card;
+
+    card.writeROM(0x80 | VIA_DDRB, 0xFF);
+    uint8_t val = card.readROM(0x80 | VIA_DDRB);
+    REQUIRE(val == 0xFF);
+}
+
+TEST_CASE("MockingboardCard VIA1 and VIA2 are independent", "[mockingboard]") {
+    MockingboardCard card;
+
+    card.writeROM(VIA_DDRA, 0xAA);
+    card.writeROM(0x80 | VIA_DDRA, 0x55);
+
+    REQUIRE(card.readROM(VIA_DDRA) == 0xAA);
+    REQUIRE(card.readROM(0x80 | VIA_DDRA) == 0x55);
+}
+
+// ---------------------------------------------------------------------------
+// PSG register write sequence via VIA
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard PSG register write via VIA1 protocol", "[mockingboard]") {
+    MockingboardCard card;
+
+    // The PSG write protocol via VIA:
+    // 1. Set DDRA to 0xFF (all outputs) and DDRB to 0xFF (all outputs)
+    // 2. Write register address to ORA
+    // 3. Set ORB to 0x07 (LATCH command: BC1=1, BDIR=1, /RESET=1)
+    // 4. Set ORB to 0x04 (INACTIVE: BC1=0, BDIR=0, /RESET=1)
+    // 5. Write register value to ORA
+    // 6. Set ORB to 0x06 (WRITE command: BC1=0, BDIR=1, /RESET=1)
+    // 7. Set ORB to 0x04 (INACTIVE)
+
+    // Step 1: Set data directions
+    card.writeROM(VIA_DDRA, 0xFF);
+    card.writeROM(VIA_DDRB, 0xFF);
+
+    // Step 2: Latch register address (register 7 = mixer)
+    card.writeROM(VIA_ORA, 0x07);
+    card.writeROM(VIA_ORB, 0x07); // LATCH
+    card.writeROM(VIA_ORB, 0x04); // INACTIVE
+
+    // Step 3: Write value to register
+    card.writeROM(VIA_ORA, 0x38); // All channels: tone on, noise off
+    card.writeROM(VIA_ORB, 0x06); // WRITE
+    card.writeROM(VIA_ORB, 0x04); // INACTIVE
+
+    // Verify via debug accessor
+    const AY8910& psg1 = card.getPSG1();
+    REQUIRE(psg1.getRegister(7) == 0x38);
+}
+
+// ---------------------------------------------------------------------------
+// update() advances timers
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard update does not crash", "[mockingboard]") {
+    MockingboardCard card;
+
+    // Simply verify update() runs without crashing
+    card.update(100);
+    card.update(1000);
+    card.update(10000);
+    REQUIRE(true); // If we get here, no crash occurred
+}
+
+// ---------------------------------------------------------------------------
+// reset() clears state
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard reset clears VIA state", "[mockingboard]") {
+    MockingboardCard card;
+
+    // Write something to VIA1
+    card.writeROM(VIA_DDRA, 0xFF);
+    card.writeROM(VIA_ORA, 0xAA);
+
+    card.reset();
+
+    // After reset, DDRA should be 0
+    const VIA6522& via1 = card.getVIA1();
+    REQUIRE(via1.getDDRA() == 0x00);
+    REQUIRE(via1.getORA() == 0x00);
+}
+
+// ---------------------------------------------------------------------------
+// Enable/disable
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard isEnabled is true by default", "[mockingboard]") {
+    MockingboardCard card;
+    REQUIRE(card.isEnabled());
+}
+
+TEST_CASE("MockingboardCard setEnabled toggles state", "[mockingboard]") {
+    MockingboardCard card;
+
+    card.setEnabled(false);
+    REQUIRE_FALSE(card.isEnabled());
+
+    card.setEnabled(true);
+    REQUIRE(card.isEnabled());
+}
+
+// ---------------------------------------------------------------------------
+// Audio generation
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard generateStereoSamples produces output", "[mockingboard]") {
+    MockingboardCard card;
+
+    // Generate a small buffer of stereo samples
+    const int frameCount = 128;
+    std::vector<float> buffer(frameCount * 2, -999.0f); // interleaved L/R
+
+    card.generateStereoSamples(buffer.data(), frameCount, 48000);
+
+    // After generation, buffer should have been written (values should not be -999)
+    bool anyWritten = false;
+    for (int i = 0; i < frameCount * 2; ++i) {
+        if (buffer[i] != -999.0f) {
+            anyWritten = true;
+            break;
+        }
+    }
+    REQUIRE(anyWritten);
+}
+
+TEST_CASE("MockingboardCard generateStereoSamples with timing does not crash", "[mockingboard]") {
+    MockingboardCard card;
+
+    const int frameCount = 128;
+    std::vector<float> buffer(frameCount * 2, 0.0f);
+
+    card.generateStereoSamples(buffer.data(), frameCount, 48000, 0, 2730);
+    REQUIRE(true); // No crash
+}
+
+// ---------------------------------------------------------------------------
+// I/O space (unused by Mockingboard)
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard readIO returns a value without crash", "[mockingboard]") {
+    MockingboardCard card;
+    // Mockingboard does not use I/O space, but calling it should not crash
+    uint8_t val = card.readIO(0x00);
+    (void)val;
+    REQUIRE(true);
+}
+
+TEST_CASE("MockingboardCard writeIO does not crash", "[mockingboard]") {
+    MockingboardCard card;
+    card.writeIO(0x00, 0x55);
+    REQUIRE(true);
+}
+
+// ---------------------------------------------------------------------------
+// Serialization round-trip
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard getStateSize returns expected size", "[mockingboard]") {
+    MockingboardCard card;
+    REQUIRE(card.getStateSize() == MockingboardCard::STATE_SIZE);
+}
+
+TEST_CASE("MockingboardCard serialize/deserialize round-trip", "[mockingboard]") {
+    MockingboardCard card1;
+
+    // Set up some state: write to PSG via VIA1
+    card1.writeROM(VIA_DDRA, 0xFF);
+    card1.writeROM(VIA_DDRB, 0xFF);
+    card1.writeROM(VIA_ORA, 0x07);  // register address = 7
+    card1.writeROM(VIA_ORB, 0x07);  // LATCH
+    card1.writeROM(VIA_ORB, 0x04);  // INACTIVE
+    card1.writeROM(VIA_ORA, 0x38);  // value
+    card1.writeROM(VIA_ORB, 0x06);  // WRITE
+    card1.writeROM(VIA_ORB, 0x04);  // INACTIVE
+
+    // Serialize
+    std::vector<uint8_t> buffer(card1.getStateSize());
+    size_t written = card1.serialize(buffer.data(), buffer.size());
+    REQUIRE(written > 0);
+    REQUIRE(written <= buffer.size());
+
+    // Deserialize into a new card
+    MockingboardCard card2;
+    size_t consumed = card2.deserialize(buffer.data(), written);
+    REQUIRE(consumed > 0);
+
+    // Verify PSG state was preserved
+    REQUIRE(card2.getPSG1().getRegister(7) == card1.getPSG1().getRegister(7));
+}
+
+// ---------------------------------------------------------------------------
+// IRQ: set VIA timer, update until fires, check isIRQActive
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard IRQ fires from VIA1 Timer 1", "[mockingboard]") {
+    MockingboardCard card;
+
+    // Track IRQ firing via callback
+    bool irqFired = false;
+    card.setIRQCallback([&irqFired]() {
+        irqFired = true;
+    });
+
+    // Enable Timer 1 interrupt in VIA1:
+    // Write to IER: set bit 7 (enable) and bit 6 (T1)
+    card.writeROM(VIA_IER, 0xC0);
+
+    // Set ACR for one-shot mode (bit 6 = 0)
+    card.writeROM(VIA_ACR, 0x00);
+
+    // Load a short timer value: latch low then high starts the timer
+    card.writeROM(VIA_T1CL, 0x05); // low byte = 5
+    card.writeROM(VIA_T1CH, 0x00); // high byte = 0 (starts timer)
+
+    // Update enough cycles for the timer to fire (timer counts down from 5)
+    for (int i = 0; i < 20; ++i) {
+        card.update(1);
+    }
+
+    // Either the IRQ callback was called or the IRQ flag is set
+    bool irqActive = card.isIRQActive() || irqFired;
+    REQUIRE(irqActive);
+}
+
+// ---------------------------------------------------------------------------
+// Debug accessors
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MockingboardCard debug accessors return VIA/PSG references", "[mockingboard]") {
+    MockingboardCard card;
+
+    const VIA6522& via1 = card.getVIA1();
+    const VIA6522& via2 = card.getVIA2();
+    const AY8910& psg1 = card.getPSG1();
+    const AY8910& psg2 = card.getPSG2();
+
+    // Just verify the accessors work and return references
+    (void)via1.getDDRA();
+    (void)via2.getDDRA();
+    (void)psg1.getRegister(0);
+    (void)psg2.getRegister(0);
+    REQUIRE(true);
+}