web-a2e 1.0.0

package/tests/unit/test_mouse_card.cpp

@@ -0,0 +1,386 @@
+/*
+ * test_mouse_card.cpp - Unit tests for MouseCard
+ *
+ * Tests the Apple Mouse Interface card implementation including:
+ * - Construction
+ * - Card metadata (name, preferred slot)
+ * - ROM presence
+ * - ROM data reading
+ * - Mouse delta input and position tracking
+ * - Button state tracking
+ * - Position clamping
+ * - PIA register access
+ * - Reset behavior
+ * - Serialization round-trip
+ * - Slot number configuration
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include "mouse_card.hpp"
+#include "roms.cpp"
+
+#include <cstring>
+#include <vector>
+
+using namespace a2e;
+
+// ---------------------------------------------------------------------------
+// Construction
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard constructor creates valid instance", "[mouse]") {
+    MouseCard card;
+    REQUIRE(card.getName() != nullptr);
+}
+
+// ---------------------------------------------------------------------------
+// Card metadata
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard getName returns Mouse", "[mouse]") {
+    MouseCard card;
+    REQUIRE(std::string(card.getName()) == "Mouse");
+}
+
+TEST_CASE("MouseCard getPreferredSlot returns 4", "[mouse]") {
+    MouseCard card;
+    REQUIRE(card.getPreferredSlot() == 4);
+}
+
+// ---------------------------------------------------------------------------
+// ROM presence
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard hasROM returns true", "[mouse]") {
+    MouseCard card;
+    REQUIRE(card.hasROM());
+}
+
+TEST_CASE("MouseCard hasExpansionROM returns false", "[mouse]") {
+    MouseCard card;
+    REQUIRE_FALSE(card.hasExpansionROM());
+}
+
+// ---------------------------------------------------------------------------
+// ROM data reading
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard readROM returns ROM data from embedded mouse ROM", "[mouse]") {
+    MouseCard card;
+
+    // The mouse ROM should not be all zeros
+    bool allZero = true;
+    for (int i = 0; i < 256; ++i) {
+        if (card.readROM(static_cast<uint8_t>(i)) != 0x00) {
+            allZero = false;
+            break;
+        }
+    }
+    REQUIRE_FALSE(allZero);
+}
+
+TEST_CASE("MouseCard readROM returns ROM data not all 0xFF", "[mouse]") {
+    MouseCard card;
+
+    bool allFF = true;
+    for (int i = 0; i < 256; ++i) {
+        if (card.readROM(static_cast<uint8_t>(i)) != 0xFF) {
+            allFF = false;
+            break;
+        }
+    }
+    REQUIRE_FALSE(allFF);
+}
+
+// ---------------------------------------------------------------------------
+// Mouse delta input: addDelta
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard initial position is 0,0", "[mouse]") {
+    MouseCard card;
+    REQUIRE(card.getMouseX() == 0);
+    REQUIRE(card.getMouseY() == 0);
+}
+
+TEST_CASE("MouseCard addDelta changes position", "[mouse]") {
+    MouseCard card;
+
+    card.addDelta(10, 20);
+    REQUIRE(card.getMouseX() == 10);
+    REQUIRE(card.getMouseY() == 20);
+}
+
+TEST_CASE("MouseCard addDelta sets moved flag", "[mouse]") {
+    MouseCard card;
+
+    REQUIRE_FALSE(card.getMoved());
+    card.addDelta(5, 5);
+    REQUIRE(card.getMoved());
+}
+
+TEST_CASE("MouseCard addDelta accumulates", "[mouse]") {
+    MouseCard card;
+
+    card.addDelta(10, 10);
+    card.addDelta(5, -3);
+    REQUIRE(card.getMouseX() == 15);
+    REQUIRE(card.getMouseY() == 7);
+}
+
+TEST_CASE("MouseCard addDelta with zero does not change position", "[mouse]") {
+    MouseCard card;
+
+    card.addDelta(0, 0);
+    REQUIRE(card.getMouseX() == 0);
+    REQUIRE(card.getMouseY() == 0);
+}
+
+// ---------------------------------------------------------------------------
+// Button state
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard button starts unpressed", "[mouse]") {
+    MouseCard card;
+    REQUIRE_FALSE(card.getMouseButton());
+}
+
+TEST_CASE("MouseCard setMouseButton true sets button pressed", "[mouse]") {
+    MouseCard card;
+
+    card.setMouseButton(true);
+    REQUIRE(card.getMouseButton());
+}
+
+TEST_CASE("MouseCard setMouseButton sets buttonChanged flag", "[mouse]") {
+    MouseCard card;
+
+    REQUIRE_FALSE(card.getButtonChanged());
+    card.setMouseButton(true);
+    REQUIRE(card.getButtonChanged());
+}
+
+TEST_CASE("MouseCard setMouseButton false after true clears button", "[mouse]") {
+    MouseCard card;
+
+    card.setMouseButton(true);
+    REQUIRE(card.getMouseButton());
+
+    card.setMouseButton(false);
+    REQUIRE_FALSE(card.getMouseButton());
+}
+
+// ---------------------------------------------------------------------------
+// Position clamping
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard default clamp range is 0-1023", "[mouse]") {
+    MouseCard card;
+    REQUIRE(card.getClampMinX() == 0);
+    REQUIRE(card.getClampMaxX() == 1023);
+    REQUIRE(card.getClampMinY() == 0);
+    REQUIRE(card.getClampMaxY() == 1023);
+}
+
+TEST_CASE("MouseCard position clamps to max bounds", "[mouse]") {
+    MouseCard card;
+
+    // Move far beyond the default max clamp of 1023
+    card.addDelta(2000, 2000);
+
+    REQUIRE(card.getMouseX() <= card.getClampMaxX());
+    REQUIRE(card.getMouseY() <= card.getClampMaxY());
+}
+
+TEST_CASE("MouseCard position clamps to min bounds", "[mouse]") {
+    MouseCard card;
+
+    // Move far negative beyond the default min clamp of 0
+    card.addDelta(-1000, -1000);
+
+    REQUIRE(card.getMouseX() >= card.getClampMinX());
+    REQUIRE(card.getMouseY() >= card.getClampMinY());
+}
+
+// ---------------------------------------------------------------------------
+// PIA register access
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard readIO for PIA registers does not crash", "[mouse]") {
+    MouseCard card;
+
+    // PIA has 4 registers at offsets 0-3
+    for (uint8_t offset = 0; offset < 4; ++offset) {
+        uint8_t val = card.readIO(offset);
+        (void)val;
+    }
+    REQUIRE(true);
+}
+
+TEST_CASE("MouseCard writeIO for PIA registers does not crash", "[mouse]") {
+    MouseCard card;
+
+    for (uint8_t offset = 0; offset < 4; ++offset) {
+        card.writeIO(offset, 0x00);
+        card.writeIO(offset, 0xFF);
+    }
+    REQUIRE(true);
+}
+
+TEST_CASE("MouseCard peekIO does not crash", "[mouse]") {
+    MouseCard card;
+
+    for (uint8_t offset = 0; offset < 4; ++offset) {
+        uint8_t val = card.peekIO(offset);
+        (void)val;
+    }
+    REQUIRE(true);
+}
+
+TEST_CASE("MouseCard PIA debug accessors return initial values", "[mouse]") {
+    MouseCard card;
+
+    // After construction, PIA registers should be 0
+    REQUIRE(card.getDDRA() == 0);
+    REQUIRE(card.getDDRB() == 0);
+    REQUIRE(card.getORA() == 0);
+    REQUIRE(card.getORB() == 0);
+    REQUIRE(card.getCRA() == 0);
+    REQUIRE(card.getCRB() == 0);
+}
+
+// ---------------------------------------------------------------------------
+// Reset
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard reset clears state", "[mouse]") {
+    MouseCard card;
+
+    // Set up some state
+    card.addDelta(100, 200);
+    card.setMouseButton(true);
+
+    card.reset();
+
+    // After reset, position and button should be cleared
+    REQUIRE(card.getMouseX() == 0);
+    REQUIRE(card.getMouseY() == 0);
+    REQUIRE_FALSE(card.getMouseButton());
+    REQUIRE_FALSE(card.getMoved());
+    REQUIRE_FALSE(card.getButtonChanged());
+}
+
+TEST_CASE("MouseCard reset clears PIA registers", "[mouse]") {
+    MouseCard card;
+
+    // Write to PIA registers to set state
+    card.writeIO(0, 0xFF);
+    card.writeIO(1, 0xFF);
+
+    card.reset();
+
+    REQUIRE(card.getDDRA() == 0);
+    REQUIRE(card.getDDRB() == 0);
+    REQUIRE(card.getORA() == 0);
+    REQUIRE(card.getORB() == 0);
+}
+
+// ---------------------------------------------------------------------------
+// Serialization round-trip
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard getStateSize is correct", "[mouse]") {
+    MouseCard card;
+    REQUIRE(card.getStateSize() == MouseCard::STATE_SIZE);
+}
+
+TEST_CASE("MouseCard serialize/deserialize round-trip", "[mouse]") {
+    MouseCard card1;
+
+    // Set up some state
+    card1.addDelta(50, 75);
+    card1.setMouseButton(true);
+
+    int16_t xBefore = card1.getMouseX();
+    int16_t yBefore = card1.getMouseY();
+    bool btnBefore  = card1.getMouseButton();
+
+    // 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
+    MouseCard card2;
+    size_t consumed = card2.deserialize(buffer.data(), written);
+    REQUIRE(consumed > 0);
+
+    // Verify state preserved
+    REQUIRE(card2.getMouseX() == xBefore);
+    REQUIRE(card2.getMouseY() == yBefore);
+    REQUIRE(card2.getMouseButton() == btnBefore);
+}
+
+// ---------------------------------------------------------------------------
+// Slot number
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard default slot is 4", "[mouse]") {
+    MouseCard card;
+    REQUIRE(card.getSlotNumber() == 4);
+}
+
+TEST_CASE("MouseCard setSlotNumber changes slot", "[mouse]") {
+    MouseCard card;
+
+    card.setSlotNumber(2);
+    REQUIRE(card.getSlotNumber() == 2);
+
+    card.setSlotNumber(7);
+    REQUIRE(card.getSlotNumber() == 7);
+}
+
+// ---------------------------------------------------------------------------
+// IRQ state
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard isIRQActive is false initially", "[mouse]") {
+    MouseCard card;
+    REQUIRE_FALSE(card.isIRQActive());
+}
+
+// ---------------------------------------------------------------------------
+// Update
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard update does not crash", "[mouse]") {
+    MouseCard card;
+    card.update(100);
+    card.update(1000);
+    REQUIRE(true);
+}
+
+// ---------------------------------------------------------------------------
+// Mode
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard initial mode is 0", "[mouse]") {
+    MouseCard card;
+    REQUIRE(card.getMode() == 0);
+}
+
+// ---------------------------------------------------------------------------
+// Debug accessors
+// ---------------------------------------------------------------------------
+
+TEST_CASE("MouseCard getLastCommand returns 0 initially", "[mouse]") {
+    MouseCard card;
+    REQUIRE(card.getLastCommand() == 0);
+}
+
+TEST_CASE("MouseCard getResponseState returns 0 initially", "[mouse]") {
+    MouseCard card;
+    REQUIRE(card.getResponseState() == 0);
+}

package/tests/unit/test_pascal.cpp

@@ -0,0 +1,248 @@
+/*
+ * test_pascal.cpp - Unit tests for Apple Pascal filesystem parser
+ *
+ * Tests the Pascal filesystem reader including:
+ * - Format detection (isPascal)
+ * - Volume information parsing
+ * - Catalog reading
+ * - File data retrieval
+ * - File type mapping for viewer
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include "pascal.hpp"
+#include "disk_image_builder.hpp"
+
+#include <array>
+#include <cstring>
+#include <vector>
+
+using namespace a2e;
+
+// ---------------------------------------------------------------------------
+// isPascal - Format detection
+// ---------------------------------------------------------------------------
+
+TEST_CASE("isPascal returns true for valid Pascal image", "[pascal][detection]") {
+    test::PascalDiskBuilder builder("PASCAL");
+    REQUIRE(Pascal::isPascal(builder.data(), builder.size()));
+}
+
+TEST_CASE("isPascal returns false for zeroed data", "[pascal][detection]") {
+    std::vector<uint8_t> zeroed(143360, 0x00);
+    REQUIRE_FALSE(Pascal::isPascal(zeroed.data(), zeroed.size()));
+}
+
+TEST_CASE("isPascal returns false for too-small data", "[pascal][detection]") {
+    std::vector<uint8_t> small(512, 0x00);
+    REQUIRE_FALSE(Pascal::isPascal(small.data(), small.size()));
+}
+
+TEST_CASE("isPascal returns false for null pointer", "[pascal][detection]") {
+    REQUIRE_FALSE(Pascal::isPascal(nullptr, 0));
+}
+
+// ---------------------------------------------------------------------------
+// parseVolumeInfo - Volume information
+// ---------------------------------------------------------------------------
+
+TEST_CASE("parseVolumeInfo returns correct volume name", "[pascal][volume]") {
+    test::PascalDiskBuilder builder("MYDISC");
+
+    PascalVolumeInfo info;
+    bool result = Pascal::parseVolumeInfo(builder.data(), builder.size(), &info);
+    REQUIRE(result);
+    CHECK(std::string(info.volumeName) == "MYDISC");
+}
+
+TEST_CASE("parseVolumeInfo returns correct total blocks", "[pascal][volume]") {
+    test::PascalDiskBuilder builder("TEST");
+
+    PascalVolumeInfo info;
+    bool result = Pascal::parseVolumeInfo(builder.data(), builder.size(), &info);
+    REQUIRE(result);
+    CHECK(info.totalBlocks == 280);
+}
+
+TEST_CASE("parseVolumeInfo file count reflects added files", "[pascal][volume]") {
+    test::PascalDiskBuilder builder("TEST");
+
+    const uint8_t data1[] = "FIRST";
+    const uint8_t data2[] = "SECOND";
+    builder.addFile("FILE1", 2, data1, sizeof(data1));  // 2 = Code file
+    builder.addFile("FILE2", 3, data2, sizeof(data2));  // 3 = Text file
+
+    PascalVolumeInfo info;
+    bool result = Pascal::parseVolumeInfo(builder.data(), builder.size(), &info);
+    REQUIRE(result);
+    CHECK(info.fileCount == 2);
+}
+
+TEST_CASE("parseVolumeInfo returns false for zeroed data", "[pascal][volume]") {
+    std::vector<uint8_t> zeroed(143360, 0x00);
+    PascalVolumeInfo info;
+    REQUIRE_FALSE(Pascal::parseVolumeInfo(zeroed.data(), zeroed.size(), &info));
+}
+
+// ---------------------------------------------------------------------------
+// readCatalog - Catalog reading
+// ---------------------------------------------------------------------------
+
+TEST_CASE("readCatalog returns correct file count", "[pascal][catalog]") {
+    test::PascalDiskBuilder builder("TEST");
+
+    const uint8_t data[] = "HELLO PASCAL";
+    builder.addFile("GREETING", 3, data, sizeof(data));  // 3 = Text
+
+    PascalCatalogEntry entries[32];
+    int count = Pascal::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+}
+
+TEST_CASE("Catalog entry has correct filename", "[pascal][catalog]") {
+    test::PascalDiskBuilder builder("TEST");
+
+    const uint8_t data[] = "DATA";
+    builder.addFile("MYCODE", 2, data, sizeof(data));  // 2 = Code
+
+    PascalCatalogEntry entries[32];
+    int count = Pascal::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+    CHECK(std::string(entries[0].filename) == "MYCODE");
+}
+
+TEST_CASE("Catalog entry has correct file type name", "[pascal][catalog]") {
+    test::PascalDiskBuilder builder("TEST");
+
+    const uint8_t data[] = "CONTENT";
+    builder.addFile("SOURCE", 3, data, sizeof(data));  // 3 = Text
+
+    PascalCatalogEntry entries[32];
+    int count = Pascal::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+    CHECK(entries[0].fileType == 3);
+    CHECK(std::string(entries[0].fileTypeName) == "TEXT");
+}
+
+TEST_CASE("readCatalog with empty disk returns zero", "[pascal][catalog]") {
+    test::PascalDiskBuilder builder("EMPTY");
+
+    PascalCatalogEntry entries[32];
+    int count = Pascal::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 0);
+}
+
+TEST_CASE("Multiple files in Pascal catalog", "[pascal][catalog]") {
+    test::PascalDiskBuilder builder("MULTI");
+
+    const uint8_t d1[] = "AAA";
+    const uint8_t d2[] = "BBB";
+    const uint8_t d3[] = "CCC";
+    builder.addFile("ALPHA", 3, d1, sizeof(d1));     // Text
+    builder.addFile("BETA", 2, d2, sizeof(d2));      // Code
+    builder.addFile("GAMMA", 5, d3, sizeof(d3));     // Data
+
+    PascalCatalogEntry entries[32];
+    int count = Pascal::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 3);
+}
+
+TEST_CASE("Catalog entry has valid block range", "[pascal][catalog]") {
+    test::PascalDiskBuilder builder("TEST");
+
+    const uint8_t data[] = "BLOCK DATA";
+    builder.addFile("BLKFILE", 2, data, sizeof(data));  // Code
+
+    PascalCatalogEntry entries[32];
+    int count = Pascal::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+    CHECK(entries[0].startBlock >= 6);   // First data block is after directory
+    CHECK(entries[0].nextBlock > entries[0].startBlock);
+}
+
+TEST_CASE("Catalog entry fileSize is computed correctly", "[pascal][catalog]") {
+    test::PascalDiskBuilder builder("TEST");
+
+    // Create a file smaller than one block
+    std::vector<uint8_t> data(100, 0x42);
+    builder.addFile("SMALL", 5, data.data(), static_cast<int>(data.size()));
+
+    PascalCatalogEntry entries[32];
+    int count = Pascal::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+    CHECK(entries[0].fileSize == 100);
+}
+
+// ---------------------------------------------------------------------------
+// readFile - File data retrieval
+// ---------------------------------------------------------------------------
+
+TEST_CASE("readFile retrieves correct data", "[pascal][readFile]") {
+    test::PascalDiskBuilder builder("TEST");
+
+    std::vector<uint8_t> fileData(64);
+    for (int i = 0; i < 64; i++) {
+        fileData[i] = static_cast<uint8_t>(i);
+    }
+    builder.addFile("SEQDATA", 5, fileData.data(), static_cast<int>(fileData.size()));
+
+    PascalCatalogEntry entries[32];
+    int count = Pascal::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+
+    std::vector<uint8_t> outBuf(1024, 0);
+    int bytesRead = Pascal::readFile(builder.data(), builder.size(),
+                                      &entries[0], outBuf.data(),
+                                      static_cast<int>(outBuf.size()));
+    REQUIRE(bytesRead > 0);
+
+    // Verify the data bytes match
+    for (int i = 0; i < 64; i++) {
+        INFO("Byte at offset " << i);
+        CHECK(outBuf[i] == static_cast<uint8_t>(i));
+    }
+}
+
+TEST_CASE("readFile with code file type", "[pascal][readFile]") {
+    test::PascalDiskBuilder builder("TEST");
+
+    std::vector<uint8_t> codeData = {0xEA, 0xEA, 0x60, 0x00};  // NOP NOP RTS BRK
+    builder.addFile("PROG", 2, codeData.data(), static_cast<int>(codeData.size()));  // 2 = Code
+
+    PascalCatalogEntry entries[32];
+    int count = Pascal::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+
+    std::vector<uint8_t> outBuf(1024, 0);
+    int bytesRead = Pascal::readFile(builder.data(), builder.size(),
+                                      &entries[0], outBuf.data(),
+                                      static_cast<int>(outBuf.size()));
+    REQUIRE(bytesRead >= 4);
+    CHECK(outBuf[0] == 0xEA);
+    CHECK(outBuf[1] == 0xEA);
+    CHECK(outBuf[2] == 0x60);
+    CHECK(outBuf[3] == 0x00);
+}
+
+// ---------------------------------------------------------------------------
+// mapFileTypeForViewer - File type mapping
+// ---------------------------------------------------------------------------
+
+TEST_CASE("mapFileTypeForViewer maps Text type", "[pascal][fileType]") {
+    // Pascal file type 3 = TEXT -> text viewer (0x00)
+    int viewerType = Pascal::mapFileTypeForViewer(3);
+    CHECK(viewerType == 0x00);  // Text viewer
+}
+
+TEST_CASE("mapFileTypeForViewer maps Code type to hex dump", "[pascal][fileType]") {
+    // Pascal file type 2 = CODE -> not mapped (-1, hex dump)
+    int viewerType = Pascal::mapFileTypeForViewer(2);
+    CHECK(viewerType == -1);
+}
+
+TEST_CASE("mapFileTypeForViewer returns -1 for unknown type", "[pascal][fileType]") {
+    int viewerType = Pascal::mapFileTypeForViewer(99);
+    CHECK(viewerType == -1);
+}