web-a2e 1.0.0

package/tests/unit/test_video.cpp

@@ -0,0 +1,319 @@
+/*
+ * test_video.cpp - Unit tests for Video output generation
+ *
+ * Tests the video subsystem including mode detection, framebuffer
+ * management, display options, page switching, text rendering,
+ * and dirty flag management.
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include "video/video.hpp"
+#include "mmu/mmu.hpp"
+#include "roms.cpp"
+
+using namespace a2e;
+
+// Helper: create an MMU with ROMs loaded and a Video instance
+struct VideoTestFixture {
+    MMU mmu;
+    std::unique_ptr<Video> video;
+
+    VideoTestFixture() {
+        mmu.loadROM(roms::ROM_SYSTEM, roms::ROM_SYSTEM_SIZE,
+                     roms::ROM_CHAR, roms::ROM_CHAR_SIZE);
+        video = std::make_unique<Video>(mmu);
+    }
+};
+
+// ============================================================================
+// Default state
+// ============================================================================
+
+TEST_CASE("Video default mode is TEXT_40", "[video][mode]") {
+    VideoTestFixture f;
+
+    // Default soft switches: text=true, col80=false
+    CHECK(f.video->getCurrentMode() == VideoMode::TEXT_40);
+}
+
+// ============================================================================
+// Framebuffer
+// ============================================================================
+
+TEST_CASE("Video getFramebufferSize returns 860160", "[video][framebuffer]") {
+    // 560 * 384 * 4 (RGBA) = 860160
+    CHECK(Video::getFramebufferSize() == 860160);
+}
+
+TEST_CASE("Video getFramebuffer returns non-null pointer", "[video][framebuffer]") {
+    VideoTestFixture f;
+
+    CHECK(f.video->getFramebuffer() != nullptr);
+}
+
+TEST_CASE("Video const getFramebuffer returns non-null pointer", "[video][framebuffer]") {
+    VideoTestFixture f;
+
+    const Video& constVideo = *f.video;
+    CHECK(constVideo.getFramebuffer() != nullptr);
+}
+
+// ============================================================================
+// forceRenderFrame
+// ============================================================================
+
+TEST_CASE("Video forceRenderFrame does not crash", "[video][render]") {
+    VideoTestFixture f;
+
+    // Should complete without error
+    f.video->forceRenderFrame();
+}
+
+TEST_CASE("Video forceRenderFrame sets frame dirty", "[video][render]") {
+    VideoTestFixture f;
+
+    f.video->clearFrameDirty();
+    CHECK_FALSE(f.video->isFrameDirty());
+
+    f.video->forceRenderFrame();
+    // After rendering, the dirty flag should reflect the render occurred
+    // (forceRenderFrame renders regardless of dirty state)
+}
+
+// ============================================================================
+// Mode detection via soft switch toggling
+// ============================================================================
+
+TEST_CASE("Video mode: text=true, col80=false -> TEXT_40", "[video][mode]") {
+    VideoTestFixture f;
+
+    // Ensure text mode
+    f.mmu.write(0xC051, 0);  // TEXT on (write also toggles)
+    f.mmu.write(0xC00C, 0);  // 80COL off
+
+    CHECK(f.video->getCurrentMode() == VideoMode::TEXT_40);
+}
+
+TEST_CASE("Video mode: text=true, col80=true -> TEXT_80", "[video][mode]") {
+    VideoTestFixture f;
+
+    f.mmu.write(0xC051, 0);  // TEXT on
+    f.mmu.write(0xC00D, 0);  // 80COL on
+
+    CHECK(f.video->getCurrentMode() == VideoMode::TEXT_80);
+}
+
+TEST_CASE("Video mode: text=false, hires=false -> LORES", "[video][mode]") {
+    VideoTestFixture f;
+
+    f.mmu.read(0xC050);   // TEXT off (graphics mode)
+    f.mmu.read(0xC056);   // HIRES off
+
+    CHECK(f.video->getCurrentMode() == VideoMode::LORES);
+}
+
+TEST_CASE("Video mode: text=false, hires=true -> HIRES", "[video][mode]") {
+    VideoTestFixture f;
+
+    f.mmu.read(0xC050);   // TEXT off (graphics mode)
+    f.mmu.read(0xC057);   // HIRES on
+
+    CHECK(f.video->getCurrentMode() == VideoMode::HIRES);
+}
+
+TEST_CASE("Video mode: DOUBLE_LORES requires AN3 off + 80COL", "[video][mode]") {
+    VideoTestFixture f;
+
+    f.mmu.read(0xC050);   // TEXT off (graphics)
+    f.mmu.read(0xC056);   // HIRES off
+    f.mmu.write(0xC00D, 0);  // 80COL on
+    f.mmu.read(0xC05E);   // AN3 off
+
+    CHECK(f.video->getCurrentMode() == VideoMode::DOUBLE_LORES);
+}
+
+TEST_CASE("Video mode: DOUBLE_HIRES requires AN3 off + 80COL + HIRES", "[video][mode]") {
+    VideoTestFixture f;
+
+    f.mmu.read(0xC050);   // TEXT off (graphics)
+    f.mmu.read(0xC057);   // HIRES on
+    f.mmu.write(0xC00D, 0);  // 80COL on
+    f.mmu.read(0xC05E);   // AN3 off
+
+    CHECK(f.video->getCurrentMode() == VideoMode::DOUBLE_HIRES);
+}
+
+// ============================================================================
+// Display options: monochrome
+// ============================================================================
+
+TEST_CASE("Video setMonochrome/isMonochrome toggle", "[video][options]") {
+    VideoTestFixture f;
+
+    CHECK_FALSE(f.video->isMonochrome());
+
+    f.video->setMonochrome(true);
+    CHECK(f.video->isMonochrome());
+
+    f.video->setMonochrome(false);
+    CHECK_FALSE(f.video->isMonochrome());
+}
+
+// ============================================================================
+// Display options: green phosphor
+// ============================================================================
+
+TEST_CASE("Video setGreenPhosphor/isGreenPhosphor toggle", "[video][options]") {
+    VideoTestFixture f;
+
+    CHECK_FALSE(f.video->isGreenPhosphor());
+
+    f.video->setGreenPhosphor(true);
+    CHECK(f.video->isGreenPhosphor());
+
+    f.video->setGreenPhosphor(false);
+    CHECK_FALSE(f.video->isGreenPhosphor());
+}
+
+// ============================================================================
+// Display options: UK character set
+// ============================================================================
+
+TEST_CASE("Video setUKCharacterSet/isUKCharacterSet toggle", "[video][options]") {
+    VideoTestFixture f;
+
+    CHECK_FALSE(f.video->isUKCharacterSet());
+
+    f.video->setUKCharacterSet(true);
+    CHECK(f.video->isUKCharacterSet());
+
+    f.video->setUKCharacterSet(false);
+    CHECK_FALSE(f.video->isUKCharacterSet());
+}
+
+// ============================================================================
+// Page switching
+// ============================================================================
+
+TEST_CASE("Video page switching via $C055/$C054", "[video][page]") {
+    VideoTestFixture f;
+
+    // Default: page1
+    CHECK_FALSE(f.mmu.getSoftSwitches().page2);
+
+    // Switch to page 2
+    f.mmu.write(0xC055, 0);
+    CHECK(f.mmu.getSoftSwitches().page2);
+
+    // Switch back to page 1
+    f.mmu.write(0xC054, 0);
+    CHECK_FALSE(f.mmu.getSoftSwitches().page2);
+}
+
+// ============================================================================
+// Text rendering
+// ============================================================================
+
+TEST_CASE("Video text rendering: writing ASCII to $0400 produces non-zero pixels", "[video][render]") {
+    VideoTestFixture f;
+
+    // Fill text page 1 with a visible character (inverse '@' = 0x00, normal 'A' = 0xC1)
+    // Use normal 'A' character (0xC1 in Apple II encoding)
+    for (int i = 0; i < 40; ++i) {
+        f.mmu.write(0x0400 + i, 0xC1);  // 'A' in normal video
+    }
+
+    // Render the frame
+    f.video->forceRenderFrame();
+
+    // Check that framebuffer has some non-zero pixels in the first row area
+    const uint8_t* fb = f.video->getFramebuffer();
+    bool hasNonZero = false;
+    // Check the first few scanlines (each text row is 16 pixels tall in 560x384)
+    // 384 / 24 = 16 pixels per text row
+    for (size_t i = 0; i < 560 * 16 * 4; ++i) {
+        if (fb[i] != 0) {
+            hasNonZero = true;
+            break;
+        }
+    }
+
+    CHECK(hasNonZero);
+}
+
+TEST_CASE("Video text rendering: blank screen has predictable output", "[video][render]") {
+    VideoTestFixture f;
+
+    // Text page is all zeros (inverse '@' on Apple IIe)
+    // Even with all zeros, the character ROM should produce some pixel output
+    f.video->forceRenderFrame();
+
+    const uint8_t* fb = f.video->getFramebuffer();
+    // Framebuffer should exist and have been written to
+    CHECK(fb != nullptr);
+}
+
+// ============================================================================
+// Frame dirty flag
+// ============================================================================
+
+TEST_CASE("Video isFrameDirty/clearFrameDirty/setFrameDirty", "[video][dirty]") {
+    VideoTestFixture f;
+
+    // Initially dirty
+    CHECK(f.video->isFrameDirty());
+
+    f.video->clearFrameDirty();
+    CHECK_FALSE(f.video->isFrameDirty());
+
+    f.video->setFrameDirty();
+    CHECK(f.video->isFrameDirty());
+}
+
+// ============================================================================
+// Mixed mode
+// ============================================================================
+
+TEST_CASE("Video mixed mode: $C053 sets mixed, $C052 clears", "[video][mode]") {
+    VideoTestFixture f;
+
+    // Default: mixed off
+    CHECK_FALSE(f.mmu.getSoftSwitches().mixed);
+
+    f.mmu.read(0xC053);  // MIXSET
+    CHECK(f.mmu.getSoftSwitches().mixed);
+
+    f.mmu.read(0xC052);  // MIXCLR
+    CHECK_FALSE(f.mmu.getSoftSwitches().mixed);
+}
+
+// ============================================================================
+// Mode transitions
+// ============================================================================
+
+TEST_CASE("Video mode transitions work correctly", "[video][mode]") {
+    VideoTestFixture f;
+
+    // Start in TEXT_40
+    CHECK(f.video->getCurrentMode() == VideoMode::TEXT_40);
+
+    // Switch to HIRES
+    f.mmu.read(0xC050);  // TEXT off
+    f.mmu.read(0xC057);  // HIRES on
+    CHECK(f.video->getCurrentMode() == VideoMode::HIRES);
+
+    // Switch to LORES
+    f.mmu.read(0xC056);  // HIRES off
+    CHECK(f.video->getCurrentMode() == VideoMode::LORES);
+
+    // Switch to TEXT_80
+    f.mmu.read(0xC051);     // TEXT on
+    f.mmu.write(0xC00D, 0); // 80COL on
+    CHECK(f.video->getCurrentMode() == VideoMode::TEXT_80);
+
+    // Back to TEXT_40
+    f.mmu.write(0xC00C, 0); // 80COL off
+    CHECK(f.video->getCurrentMode() == VideoMode::TEXT_40);
+}

package/tests/unit/test_woz_disk_image.cpp

@@ -0,0 +1,257 @@
+/*
+ * test_woz_disk_image.cpp - Unit tests for WozDiskImage
+ *
+ * Tests the WOZ 1.0/2.0 bit-accurate disk image format including:
+ * - Loading with invalid data
+ * - Creating blank WOZ2 images
+ * - Bit read/write operations
+ * - Track count and head positioning
+ * - Format and metadata queries
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include "woz_disk_image.hpp"
+
+#include <cstring>
+#include <vector>
+
+using namespace a2e;
+
+// ---------------------------------------------------------------------------
+// Loading with invalid data
+// ---------------------------------------------------------------------------
+
+TEST_CASE("WozDiskImage load with empty data returns false", "[woz]") {
+    WozDiskImage img;
+    bool ok = img.load(nullptr, 0, "empty.woz");
+    REQUIRE_FALSE(ok);
+    REQUIRE_FALSE(img.isLoaded());
+}
+
+TEST_CASE("WozDiskImage load with too-small data returns false", "[woz]") {
+    WozDiskImage img;
+    std::vector<uint8_t> tiny(10, 0x00);
+    bool ok = img.load(tiny.data(), tiny.size(), "tiny.woz");
+    REQUIRE_FALSE(ok);
+    REQUIRE_FALSE(img.isLoaded());
+}
+
+TEST_CASE("WozDiskImage load with random garbage returns false", "[woz]") {
+    WozDiskImage img;
+    std::vector<uint8_t> garbage(8192, 0xAA);
+    bool ok = img.load(garbage.data(), garbage.size(), "garbage.woz");
+    REQUIRE_FALSE(ok);
+    REQUIRE_FALSE(img.isLoaded());
+}
+
+TEST_CASE("WozDiskImage load with wrong signature returns false", "[woz]") {
+    WozDiskImage img;
+    // Build a buffer that looks like a file header but has wrong signature
+    std::vector<uint8_t> badSig(256, 0x00);
+    badSig[0] = 'W'; badSig[1] = 'O'; badSig[2] = 'Z'; badSig[3] = '9';
+    badSig[4] = 0xFF;
+    badSig[5] = 0x0A; badSig[6] = 0x0D; badSig[7] = 0x0A;
+
+    bool ok = img.load(badSig.data(), badSig.size(), "badsig.woz");
+    REQUIRE_FALSE(ok);
+}
+
+// ---------------------------------------------------------------------------
+// Creating blank images
+// ---------------------------------------------------------------------------
+
+TEST_CASE("WozDiskImage createBlank creates a valid image", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    REQUIRE(img.isLoaded());
+    REQUIRE(img.getFormat() == DiskImage::Format::WOZ2);
+}
+
+TEST_CASE("WozDiskImage createBlank has 35 tracks", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    REQUIRE(img.getTrackCount() == 35);
+}
+
+TEST_CASE("WozDiskImage createBlank starts at track 0", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    REQUIRE(img.getTrack() == 0);
+    REQUIRE(img.getQuarterTrack() == 0);
+}
+
+TEST_CASE("WozDiskImage createBlank reports 5.25 inch disk type", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    REQUIRE(img.getDiskType() == 1); // 1 = 5.25"
+}
+
+TEST_CASE("WozDiskImage createBlank has valid disk type string", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    std::string typeStr = img.getDiskTypeString();
+    REQUIRE_FALSE(typeStr.empty());
+}
+
+TEST_CASE("WozDiskImage createBlank has default bit timing", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    // Default optimal bit timing is 32 (= 4 microseconds per bit)
+    REQUIRE(img.getOptimalBitTiming() == 32);
+}
+
+TEST_CASE("WozDiskImage createBlank is not write-protected", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    REQUIRE_FALSE(img.isWriteProtected());
+}
+
+TEST_CASE("WozDiskImage createBlank is marked as modified", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    // createBlank marks the image as modified so it will be saved
+    REQUIRE(img.isModified());
+}
+
+TEST_CASE("WozDiskImage createBlank hasData returns true", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    REQUIRE(img.hasData());
+}
+
+// ---------------------------------------------------------------------------
+// Bit read/write operations
+// ---------------------------------------------------------------------------
+
+TEST_CASE("WozDiskImage readBit on blank image returns 0 or 1", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    // Blank disk is filled with sync bytes, so bits should be valid
+    uint8_t bit = img.readBit();
+    REQUIRE((bit == 0 || bit == 1));
+}
+
+TEST_CASE("WozDiskImage readBit advances position", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    size_t pos1 = img.getCurrentNibblePosition();
+    // Read enough bits to shift nibble position
+    for (int i = 0; i < 8; ++i) {
+        img.readBit();
+    }
+    size_t pos2 = img.getCurrentNibblePosition();
+    REQUIRE(pos2 > pos1);
+}
+
+TEST_CASE("WozDiskImage writeBit modifies the image", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    // Write some bits
+    img.writeBit(1);
+    img.writeBit(0);
+    img.writeBit(1);
+    img.writeBit(1);
+
+    REQUIRE(img.isModified());
+}
+
+TEST_CASE("WozDiskImage readNibble on blank image returns sync-like nibble", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    // Blank disk is filled with sync bytes (0xFF typically)
+    uint8_t nibble = img.readNibble();
+    // Valid nibbles have bit 7 set
+    REQUIRE((nibble & 0x80) != 0);
+}
+
+// ---------------------------------------------------------------------------
+// Head positioning
+// ---------------------------------------------------------------------------
+
+TEST_CASE("WozDiskImage setQuarterTrack changes position", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    img.setQuarterTrack(12);
+    REQUIRE(img.getQuarterTrack() == 12);
+    REQUIRE(img.getTrack() == 3);
+}
+
+TEST_CASE("WozDiskImage setPhase stepping moves head", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    REQUIRE(img.getQuarterTrack() == 0);
+
+    // Step outward: phase 0 on, phase 1 on, phase 0 off
+    img.setPhase(0, true);
+    img.setPhase(1, true);
+    img.setPhase(0, false);
+
+    REQUIRE(img.getQuarterTrack() > 0);
+}
+
+// ---------------------------------------------------------------------------
+// Reset state
+// ---------------------------------------------------------------------------
+
+TEST_CASE("WozDiskImage resetState resets head position", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    img.setQuarterTrack(20);
+    REQUIRE(img.getQuarterTrack() == 20);
+
+    img.resetState();
+    REQUIRE(img.getQuarterTrack() == 0);
+}
+
+// ---------------------------------------------------------------------------
+// Format name
+// ---------------------------------------------------------------------------
+
+TEST_CASE("WozDiskImage getFormatName returns non-empty string", "[woz]") {
+    WozDiskImage img;
+    img.createBlank();
+
+    std::string name = img.getFormatName();
+    REQUIRE_FALSE(name.empty());
+}
+
+// ---------------------------------------------------------------------------
+// Move semantics
+// ---------------------------------------------------------------------------
+
+TEST_CASE("WozDiskImage is move-constructible", "[woz]") {
+    WozDiskImage img1;
+    img1.createBlank();
+    REQUIRE(img1.isLoaded());
+
+    WozDiskImage img2(std::move(img1));
+    REQUIRE(img2.isLoaded());
+    REQUIRE(img2.getTrackCount() == 35);
+}
+
+TEST_CASE("WozDiskImage is move-assignable", "[woz]") {
+    WozDiskImage img1;
+    img1.createBlank();
+
+    WozDiskImage img2;
+    img2 = std::move(img1);
+    REQUIRE(img2.isLoaded());
+}

package/vite.config.js

@@ -0,0 +1,96 @@
+import { defineConfig } from "vite";
+import { resolve } from "path";
+import { copyFileSync, mkdirSync } from "fs";
+
+// Plugin to copy audio worklet file (can't be bundled)
+const copyAudioWorklet = () => ({
+  name: "copy-audio-worklet",
+  writeBundle() {
+    mkdirSync(resolve(__dirname, "dist"), { recursive: true });
+    copyFileSync(
+      resolve(__dirname, "src/js/audio/audio-worklet.js"),
+      resolve(__dirname, "dist/audio-worklet.js"),
+    );
+  },
+});
+
+export default defineConfig({
+  root: "public",
+  publicDir: "../public",
+
+  server: {
+    port: 3000,
+    open: true,
+    headers: {
+      // Required for SharedArrayBuffer (if needed for AudioWorklet)
+      "Cross-Origin-Opener-Policy": "same-origin",
+      "Cross-Origin-Embedder-Policy": "require-corp",
+      "Cache-Control": "no-store",
+    },
+  },
+
+  build: {
+    outDir: "../dist",
+    emptyOutDir: true,
+    rollupOptions: {
+      input: {
+        main: resolve(__dirname, "public/index.html"),
+      },
+      output: {
+        manualChunks: {
+          debug: [
+            "/src/js/debug/cpu-debugger-window.js",
+            "/src/js/debug/memory-browser-window.js",
+            "/src/js/debug/memory-heat-map-window.js",
+            "/src/js/debug/memory-map-window.js",
+            "/src/js/debug/stack-viewer-window.js",
+            "/src/js/debug/zero-page-watch-window.js",
+            "/src/js/debug/soft-switch-window.js",
+            "/src/js/debug/mockingboard-window.js",
+            "/src/js/debug/mouse-card-window.js",
+            "/src/js/debug/basic-program-window.js",
+            "/src/js/debug/rule-builder-window.js",
+            "/src/js/debug/assembler-editor-window.js",
+          ],
+          display: [
+            "/src/js/display/index.js",
+            "/src/js/display/webgl-renderer.js",
+            "/src/js/display/display-settings-window.js",
+            "/src/js/display/screen-window.js",
+          ],
+          "disk-manager": [
+            "/src/js/disk-manager/index.js",
+            "/src/js/disk-manager/disk-operations.js",
+            "/src/js/disk-manager/disk-persistence.js",
+            "/src/js/disk-manager/disk-surface-renderer.js",
+            "/src/js/disk-manager/disk-drives-window.js",
+            "/src/js/disk-manager/drive-sounds.js",
+          ],
+          "file-explorer": [
+            "/src/js/file-explorer/index.js",
+            "/src/js/file-explorer/dos33.js",
+            "/src/js/file-explorer/prodos.js",
+            "/src/js/file-explorer/disassembler.js",
+            "/src/js/file-explorer/file-viewer.js",
+            "/src/js/file-explorer/utils.js",
+          ],
+        },
+      },
+    },
+  },
+
+  resolve: {
+    alias: {
+      "/src": resolve(__dirname, "src"),
+    },
+  },
+
+  // Handle WASM files
+  assetsInclude: ["**/*.wasm"],
+
+  optimizeDeps: {
+    exclude: ["a2e.js"],
+  },
+
+  plugins: [copyAudioWorklet()],
+});