web-a2e 1.0.0

package/tests/unit/test_disk2_card.cpp

@@ -0,0 +1,330 @@
+/*
+ * test_disk2_card.cpp - Unit tests for Disk2Card
+ *
+ * Tests the Disk II controller card implementation including:
+ * - Construction with ROM data
+ * - ROM read access
+ * - Motor control (on/off)
+ * - Drive selection
+ * - Q6/Q7 latch states
+ * - Phase control for head stepping
+ * - Disk insert/eject operations
+ * - Card metadata (name, preferred slot)
+ * - State serialization round-trip
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include "disk2_card.hpp"
+#include "roms.cpp"
+
+#include <cstring>
+#include <vector>
+
+using namespace a2e;
+
+// ---------------------------------------------------------------------------
+// Construction
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Disk2Card constructor with ROM loads ROM data", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    // The ROM should be 256 bytes; every byte should match the source data
+    for (size_t i = 0; i < roms::ROM_DISK2_SIZE; ++i) {
+        REQUIRE(card.readROM(static_cast<uint8_t>(i)) == roms::ROM_DISK2[i]);
+    }
+}
+
+TEST_CASE("Disk2Card default constructor creates valid card", "[disk2]") {
+    Disk2Card card;
+    // Should still be constructable; ROM content may be zeroed
+    REQUIRE(card.getName() != nullptr);
+}
+
+// ---------------------------------------------------------------------------
+// readROM returns bytes from loaded ROM
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Disk2Card readROM returns ROM bytes after loadROM", "[disk2]") {
+    Disk2Card card;
+    card.loadROM(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    REQUIRE(card.readROM(0x00) == roms::ROM_DISK2[0]);
+    REQUIRE(card.readROM(0x7F) == roms::ROM_DISK2[0x7F]);
+    REQUIRE(card.readROM(0xFF) == roms::ROM_DISK2[0xFF]);
+}
+
+// ---------------------------------------------------------------------------
+// reset() clears controller state
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Disk2Card reset clears state", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    // Turn motor on and select drive 2
+    card.readIO(0x09); // Motor on
+    card.readIO(0x0B); // Drive 2
+
+    REQUIRE(card.isMotorOn());
+    REQUIRE(card.getSelectedDrive() == 1);
+
+    card.reset();
+
+    REQUIRE_FALSE(card.isMotorOn());
+    REQUIRE(card.getSelectedDrive() == 0);
+    REQUIRE(card.getQ6() == false);
+    REQUIRE(card.getQ7() == false);
+    REQUIRE(card.getPhaseStates() == 0);
+}
+
+// ---------------------------------------------------------------------------
+// Motor on/off via readIO
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Disk2Card motor control via I/O offsets", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    SECTION("Motor starts off") {
+        REQUIRE_FALSE(card.isMotorOn());
+    }
+
+    SECTION("Offset 0x09 turns motor on") {
+        card.readIO(0x09);
+        REQUIRE(card.isMotorOn());
+    }
+
+    SECTION("Offset 0x08 turns motor off") {
+        card.readIO(0x09); // on
+        REQUIRE(card.isMotorOn());
+        card.readIO(0x08); // off
+        // Motor may not turn off immediately (delay), but the off request is latched
+        // After enough update cycles, motor will be off. For the immediate test,
+        // just verify the toggle was accepted without error.
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Drive select
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Disk2Card drive selection via I/O offsets", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    SECTION("Default drive is 0 (drive 1)") {
+        REQUIRE(card.getSelectedDrive() == 0);
+    }
+
+    SECTION("Offset 0x0B selects drive 2 (index 1)") {
+        card.readIO(0x0B);
+        REQUIRE(card.getSelectedDrive() == 1);
+    }
+
+    SECTION("Offset 0x0A selects drive 1 (index 0)") {
+        card.readIO(0x0B); // select drive 2 first
+        card.readIO(0x0A); // back to drive 1
+        REQUIRE(card.getSelectedDrive() == 0);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Q6/Q7 latches
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Disk2Card Q6 and Q7 latch control", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    SECTION("Q6 and Q7 start low") {
+        REQUIRE(card.getQ6() == false);
+        REQUIRE(card.getQ7() == false);
+    }
+
+    SECTION("Offset 0x0C sets Q6 low") {
+        card.readIO(0x0D); // Q6H first
+        REQUIRE(card.getQ6() == true);
+        card.readIO(0x0C); // Q6L
+        REQUIRE(card.getQ6() == false);
+    }
+
+    SECTION("Offset 0x0D sets Q6 high") {
+        card.readIO(0x0D);
+        REQUIRE(card.getQ6() == true);
+    }
+
+    SECTION("Offset 0x0E sets Q7 low") {
+        card.readIO(0x0F); // Q7H first
+        REQUIRE(card.getQ7() == true);
+        card.readIO(0x0E); // Q7L
+        REQUIRE(card.getQ7() == false);
+    }
+
+    SECTION("Offset 0x0F sets Q7 high") {
+        card.readIO(0x0F);
+        REQUIRE(card.getQ7() == true);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Phase control
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Disk2Card phase control via I/O offsets", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    SECTION("All phases off initially") {
+        REQUIRE(card.getPhaseStates() == 0x00);
+    }
+
+    SECTION("Phase 0 on (offset 0x01)") {
+        card.readIO(0x01);
+        REQUIRE((card.getPhaseStates() & 0x01) != 0);
+    }
+
+    SECTION("Phase 0 off (offset 0x00)") {
+        card.readIO(0x01); // on
+        card.readIO(0x00); // off
+        REQUIRE((card.getPhaseStates() & 0x01) == 0);
+    }
+
+    SECTION("Phase 1 on (offset 0x03)") {
+        card.readIO(0x03);
+        REQUIRE((card.getPhaseStates() & 0x02) != 0);
+    }
+
+    SECTION("Phase 1 off (offset 0x02)") {
+        card.readIO(0x03);
+        card.readIO(0x02);
+        REQUIRE((card.getPhaseStates() & 0x02) == 0);
+    }
+
+    SECTION("Phase 2 on (offset 0x05)") {
+        card.readIO(0x05);
+        REQUIRE((card.getPhaseStates() & 0x04) != 0);
+    }
+
+    SECTION("Phase 2 off (offset 0x04)") {
+        card.readIO(0x05);
+        card.readIO(0x04);
+        REQUIRE((card.getPhaseStates() & 0x04) == 0);
+    }
+
+    SECTION("Phase 3 on (offset 0x07)") {
+        card.readIO(0x07);
+        REQUIRE((card.getPhaseStates() & 0x08) != 0);
+    }
+
+    SECTION("Phase 3 off (offset 0x06)") {
+        card.readIO(0x07);
+        card.readIO(0x06);
+        REQUIRE((card.getPhaseStates() & 0x08) == 0);
+    }
+
+    SECTION("Multiple phases can be on simultaneously") {
+        card.readIO(0x01); // phase 0 on
+        card.readIO(0x03); // phase 1 on
+        REQUIRE((card.getPhaseStates() & 0x03) == 0x03);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Disk insert / eject
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Disk2Card hasDisk is false by default", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+    REQUIRE_FALSE(card.hasDisk(0));
+    REQUIRE_FALSE(card.hasDisk(1));
+}
+
+TEST_CASE("Disk2Card insertDisk with DSK data makes hasDisk true", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    // Create a minimal valid DSK image (143360 bytes, all zeros)
+    std::vector<uint8_t> dskData(143360, 0x00);
+
+    bool result = card.insertDisk(0, dskData.data(), dskData.size(), "test.dsk");
+    REQUIRE(result);
+    REQUIRE(card.hasDisk(0));
+}
+
+TEST_CASE("Disk2Card insertDisk into drive 2", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    std::vector<uint8_t> dskData(143360, 0x00);
+    bool result = card.insertDisk(1, dskData.data(), dskData.size(), "test.dsk");
+    REQUIRE(result);
+    REQUIRE(card.hasDisk(1));
+    REQUIRE_FALSE(card.hasDisk(0)); // drive 1 still empty
+}
+
+TEST_CASE("Disk2Card ejectDisk clears the disk", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    std::vector<uint8_t> dskData(143360, 0x00);
+    card.insertDisk(0, dskData.data(), dskData.size(), "test.dsk");
+    REQUIRE(card.hasDisk(0));
+
+    card.ejectDisk(0);
+    REQUIRE_FALSE(card.hasDisk(0));
+}
+
+// ---------------------------------------------------------------------------
+// Card metadata
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Disk2Card getName returns Disk II", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+    REQUIRE(std::string(card.getName()) == "Disk II");
+}
+
+TEST_CASE("Disk2Card getPreferredSlot returns 6", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+    REQUIRE(card.getPreferredSlot() == 6);
+}
+
+TEST_CASE("Disk2Card hasROM returns true", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+    REQUIRE(card.hasROM());
+}
+
+TEST_CASE("Disk2Card hasExpansionROM returns false", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+    REQUIRE_FALSE(card.hasExpansionROM());
+}
+
+// ---------------------------------------------------------------------------
+// Serialization round-trip
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Disk2Card getStateSize is greater than zero", "[disk2]") {
+    Disk2Card card(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+    REQUIRE(card.getStateSize() > 0);
+}
+
+TEST_CASE("Disk2Card serialize/deserialize round-trip preserves state", "[disk2]") {
+    Disk2Card card1(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+
+    // Set up some state
+    card1.readIO(0x09); // motor on
+    card1.readIO(0x0B); // drive 2
+    card1.readIO(0x0D); // Q6H
+    card1.readIO(0x01); // phase 0 on
+
+    size_t stateSize = card1.getStateSize();
+    std::vector<uint8_t> buffer(stateSize);
+
+    size_t written = card1.serialize(buffer.data(), buffer.size());
+    REQUIRE(written > 0);
+    REQUIRE(written <= stateSize);
+
+    Disk2Card card2(roms::ROM_DISK2, roms::ROM_DISK2_SIZE);
+    size_t consumed = card2.deserialize(buffer.data(), written);
+    REQUIRE(consumed > 0);
+
+    // Verify key state was preserved
+    REQUIRE(card2.getSelectedDrive() == card1.getSelectedDrive());
+    REQUIRE(card2.getQ6() == card1.getQ6());
+    REQUIRE(card2.getQ7() == card1.getQ7());
+    REQUIRE(card2.getPhaseStates() == card1.getPhaseStates());
+}

package/tests/unit/test_dos33.cpp

@@ -0,0 +1,273 @@
+/*
+ * test_dos33.cpp - Unit tests for DOS 3.3 filesystem parser
+ *
+ * Tests the DOS 3.3 filesystem reader including:
+ * - Format detection (isDOS33)
+ * - Catalog reading
+ * - File data retrieval
+ * - Binary file header extraction
+ * - Multiple files in catalog
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include "dos33.hpp"
+#include "disk_image_builder.hpp"
+
+#include <array>
+#include <cstring>
+#include <vector>
+
+using namespace a2e;
+
+// ---------------------------------------------------------------------------
+// isDOS33 - Format detection
+// ---------------------------------------------------------------------------
+
+TEST_CASE("isDOS33 returns true for valid DOS 3.3 image", "[dos33][detection]") {
+    test::DOS33DiskBuilder builder;
+    REQUIRE(DOS33::isDOS33(builder.data(), builder.size()));
+}
+
+TEST_CASE("isDOS33 returns false for zeroed data", "[dos33][detection]") {
+    std::vector<uint8_t> zeroed(143360, 0x00);
+    REQUIRE_FALSE(DOS33::isDOS33(zeroed.data(), zeroed.size()));
+}
+
+TEST_CASE("isDOS33 returns false for too-small data", "[dos33][detection]") {
+    std::vector<uint8_t> small(1024, 0x00);
+    REQUIRE_FALSE(DOS33::isDOS33(small.data(), small.size()));
+}
+
+TEST_CASE("isDOS33 returns false for null pointer", "[dos33][detection]") {
+    REQUIRE_FALSE(DOS33::isDOS33(nullptr, 0));
+}
+
+// ---------------------------------------------------------------------------
+// readCatalog - Catalog reading
+// ---------------------------------------------------------------------------
+
+TEST_CASE("readCatalog returns correct file count after addFile", "[dos33][catalog]") {
+    test::DOS33DiskBuilder builder;
+
+    const uint8_t fileData[] = "HELLO WORLD";
+    builder.addFile("TESTFILE", 0x00, fileData, sizeof(fileData));
+
+    DOS33CatalogEntry entries[32];
+    int count = DOS33::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+}
+
+TEST_CASE("Catalog entry has correct filename", "[dos33][catalog]") {
+    test::DOS33DiskBuilder builder;
+
+    const uint8_t fileData[] = "CONTENT";
+    builder.addFile("MYFILE", 0x00, fileData, sizeof(fileData));
+
+    DOS33CatalogEntry entries[32];
+    int count = DOS33::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+    REQUIRE(std::string(entries[0].filename) == "MYFILE");
+}
+
+TEST_CASE("Catalog entry has correct file type for text file", "[dos33][catalog]") {
+    test::DOS33DiskBuilder builder;
+
+    const uint8_t fileData[] = "TEXT DATA";
+    builder.addFile("README", 0x00, fileData, sizeof(fileData));  // 0x00 = Text
+
+    DOS33CatalogEntry entries[32];
+    int count = DOS33::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+    CHECK(entries[0].fileType == 0x00);
+    CHECK(std::string(entries[0].fileTypeName) == "T");
+}
+
+TEST_CASE("Catalog entry has correct file type for binary file", "[dos33][catalog]") {
+    test::DOS33DiskBuilder builder;
+
+    const uint8_t fileData[] = {0x00, 0x20, 0x05, 0x00, 0xEA, 0xEA, 0xEA, 0x60, 0x00};
+    builder.addFile("BINFILE", 0x04, fileData, sizeof(fileData));  // 0x04 = Binary
+
+    DOS33CatalogEntry entries[32];
+    int count = DOS33::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+    CHECK(entries[0].fileType == 0x04);
+    CHECK(std::string(entries[0].fileTypeName) == "B");
+}
+
+TEST_CASE("Catalog entry locked status is correctly set", "[dos33][catalog]") {
+    test::DOS33DiskBuilder builder;
+
+    const uint8_t data1[] = "UNLOCKED";
+    const uint8_t data2[] = "LOCKED";
+    builder.addFile("FREE", 0x00, data1, sizeof(data1), false);
+    builder.addFile("PROT", 0x00, data2, sizeof(data2), true);
+
+    DOS33CatalogEntry entries[32];
+    int count = DOS33::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 2);
+
+    // Find each entry by name
+    bool foundFree = false, foundProt = false;
+    for (int i = 0; i < count; i++) {
+        if (std::string(entries[i].filename) == "FREE") {
+            CHECK_FALSE(entries[i].isLocked);
+            foundFree = true;
+        }
+        if (std::string(entries[i].filename) == "PROT") {
+            CHECK(entries[i].isLocked);
+            foundProt = true;
+        }
+    }
+    REQUIRE(foundFree);
+    REQUIRE(foundProt);
+}
+
+TEST_CASE("readCatalog with empty disk returns zero", "[dos33][catalog]") {
+    test::DOS33DiskBuilder builder;
+
+    DOS33CatalogEntry entries[32];
+    int count = DOS33::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 0);
+}
+
+// ---------------------------------------------------------------------------
+// Multiple files in catalog
+// ---------------------------------------------------------------------------
+
+TEST_CASE("Multiple files in catalog are all enumerated", "[dos33][catalog]") {
+    test::DOS33DiskBuilder builder;
+
+    const uint8_t data1[] = "FILE ONE DATA";
+    const uint8_t data2[] = "FILE TWO DATA";
+    const uint8_t data3[] = "FILE THREE DATA";
+
+    builder.addFile("FILE1", 0x00, data1, sizeof(data1));
+    builder.addFile("FILE2", 0x02, data2, sizeof(data2));    // 0x02 = Applesoft
+    builder.addFile("FILE3", 0x04, data3, sizeof(data3));    // 0x04 = Binary
+
+    DOS33CatalogEntry entries[32];
+    int count = DOS33::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 3);
+
+    // Verify filenames are present (order may vary)
+    bool found1 = false, found2 = false, found3 = false;
+    for (int i = 0; i < count; i++) {
+        std::string name(entries[i].filename);
+        if (name == "FILE1") found1 = true;
+        if (name == "FILE2") found2 = true;
+        if (name == "FILE3") found3 = true;
+    }
+    CHECK(found1);
+    CHECK(found2);
+    CHECK(found3);
+}
+
+TEST_CASE("Catalog entries have non-zero sector count", "[dos33][catalog]") {
+    test::DOS33DiskBuilder builder;
+
+    const uint8_t fileData[] = "SOME DATA CONTENT";
+    builder.addFile("HASDATA", 0x00, fileData, sizeof(fileData));
+
+    DOS33CatalogEntry entries[32];
+    int count = DOS33::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+    CHECK(entries[0].sectorCount > 0);
+}
+
+// ---------------------------------------------------------------------------
+// readFile - File data retrieval
+// ---------------------------------------------------------------------------
+
+TEST_CASE("readFile retrieves file data correctly", "[dos33][readFile]") {
+    test::DOS33DiskBuilder builder;
+
+    // Create a file with known content
+    std::vector<uint8_t> fileData(64);
+    for (int i = 0; i < 64; i++) {
+        fileData[i] = static_cast<uint8_t>(i);
+    }
+    builder.addFile("SEQDATA", 0x00, fileData.data(), static_cast<int>(fileData.size()));
+
+    // Read catalog to get the file's first track/sector
+    DOS33CatalogEntry entries[32];
+    int count = DOS33::readCatalog(builder.data(), builder.size(), entries, 32);
+    REQUIRE(count == 1);
+
+    // Read the file data
+    std::vector<uint8_t> outBuf(4096, 0);
+    int bytesRead = DOS33::readFile(builder.data(), builder.size(),
+                                     entries[0].firstTrack, entries[0].firstSector,
+                                     outBuf.data(), static_cast<int>(outBuf.size()));
+    REQUIRE(bytesRead > 0);
+
+    // Verify the data is present in the output
+    // The raw file data starts from the first data sector
+    bool found = false;
+    for (int offset = 0; offset <= bytesRead - 64; offset++) {
+        if (memcmp(&outBuf[offset], fileData.data(), 64) == 0) {
+            found = true;
+            break;
+        }
+    }
+    CHECK(found);
+}
+
+TEST_CASE("readFile returns zero for invalid track/sector", "[dos33][readFile]") {
+    test::DOS33DiskBuilder builder;
+
+    std::vector<uint8_t> outBuf(4096, 0);
+    int bytesRead = DOS33::readFile(builder.data(), builder.size(),
+                                     0, 0, outBuf.data(),
+                                     static_cast<int>(outBuf.size()));
+    CHECK(bytesRead == 0);
+}
+
+// ---------------------------------------------------------------------------
+// getBinaryFileInfo - Binary file header extraction
+// ---------------------------------------------------------------------------
+
+TEST_CASE("getBinaryFileInfo extracts address and length from binary header", "[dos33][binaryInfo]") {
+    // Binary file format: first 4 bytes are [addrLo, addrHi, lenLo, lenHi]
+    uint8_t binaryFile[] = {
+        0x00, 0x20,  // Load address = $2000
+        0x05, 0x00,  // Length = 5 bytes
+        0xEA, 0xEA, 0xEA, 0xEA, 0x60  // NOP NOP NOP NOP RTS
+    };
+
+    uint16_t address = 0, length = 0;
+    bool result = DOS33::getBinaryFileInfo(binaryFile, sizeof(binaryFile),
+                                            &address, &length);
+    REQUIRE(result);
+    CHECK(address == 0x2000);
+    CHECK(length == 5);
+}
+
+TEST_CASE("getBinaryFileInfo returns false for too-small data", "[dos33][binaryInfo]") {
+    uint8_t tinyData[] = {0x00, 0x20};
+
+    uint16_t address = 0, length = 0;
+    bool result = DOS33::getBinaryFileInfo(tinyData, sizeof(tinyData),
+                                            &address, &length);
+    CHECK_FALSE(result);
+}
+
+TEST_CASE("getBinaryFileInfo with various load addresses", "[dos33][binaryInfo]") {
+    SECTION("Zero page address") {
+        uint8_t data[] = {0x00, 0x00, 0x10, 0x00, 0x00};
+        uint16_t addr, len;
+        REQUIRE(DOS33::getBinaryFileInfo(data, sizeof(data), &addr, &len));
+        CHECK(addr == 0x0000);
+        CHECK(len == 0x0010);
+    }
+
+    SECTION("High memory address") {
+        uint8_t data[] = {0x00, 0xBF, 0x00, 0x01, 0x00};
+        uint16_t addr, len;
+        REQUIRE(DOS33::getBinaryFileInfo(data, sizeof(data), &addr, &len));
+        CHECK(addr == 0xBF00);
+        CHECK(len == 0x0100);
+    }
+}