jsbeeb 1.1.1

package/tests/unit/test-gzip.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from "vitest";
+import * as fs from "fs";
+import * as utils from "../../src/utils.js";
+
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function testOneFile(file) {
+    const compressed = new Uint8Array(fs.readFileSync(`${file}.gz`));
+    const expected = new Uint8Array(fs.readFileSync(file));
+    expect(utils.ungzip(compressed)).toEqual(expected);
+}
+
+describe("gzip tests", function () {
+    for (let fileIndex = 1; ; fileIndex++) {
+        let file = join(__dirname, "gzip", `test-${fileIndex}`);
+        if (!fs.existsSync(file)) break;
+        it("handles test case " + file, () => testOneFile(file));
+    }
+});

package/tests/unit/test-intel-fdc.js

@@ -0,0 +1,93 @@
+import { describe, it, expect } from "vitest";
+
+import { Scheduler } from "../../src/scheduler.js";
+import { IntelFdc } from "../../src/intel-fdc.js";
+import { fake6502 } from "../../src/fake6502.js";
+
+class FakeDrive {
+    constructor() {
+        this.spinning = false;
+        this.pulsesCallback = null;
+        this.upperSide = false;
+        this.track = 0;
+    }
+    selectSide(side) {
+        this.upperSide = side;
+    }
+    setPulsesCallback(callback) {
+        this.pulsesCallback = callback;
+    }
+    startSpinning() {
+        this.spinning = true;
+    }
+    stopSpinning() {
+        this.spinning = false;
+    }
+    seekOneTrack(dir) {
+        this.track = this.track + dir;
+    }
+    notifySeek() {}
+}
+
+/**
+ * @param {IntelFdc} fdc
+ * @param  {Number} command
+ * @param  {...Number} params
+ */
+function sendCommand(fdc, command, ...params) {
+    fdc.write(0, command);
+    for (const param of params) fdc.write(1, param);
+}
+
+describe("Intel 8271 tests", function () {
+    it("should contruct and start out idle", () => {
+        const fakeCpu = fake6502();
+        const scheduler = new Scheduler();
+        const fdc = new IntelFdc(fakeCpu, scheduler);
+        expect(fdc.internalStatus).toBe(0);
+        expect(scheduler.headroom()).toBe(Scheduler.MaxHeadroom);
+    });
+
+    it("should go busy as soon as a command is registered", () => {
+        const fakeCpu = fake6502();
+        const scheduler = new Scheduler();
+        const fdc = new IntelFdc(fakeCpu, scheduler);
+        fdc.write(0, 0x3a);
+        expect(fdc.internalStatus).toBe(0x80); // 0x80 = busy
+    });
+
+    const loadHead = 0x08;
+    const select1 = 0x40;
+    const writeRegCmd = 0x3a;
+    const mmioWrite = 0x23;
+    const seekCmd = (0x0a << 2) | select1 | 1;
+
+    it("should spin up when poked", () => {
+        const fakeCpu = fake6502();
+        const scheduler = new Scheduler();
+        const fakeDrive = new FakeDrive();
+        const fdc = new IntelFdc(fakeCpu, scheduler, [fakeDrive]);
+        expect(fdc._driveOut & loadHead).toBe(0);
+        expect(fakeDrive.spinning).toBe(false);
+        sendCommand(fdc, writeRegCmd, mmioWrite, loadHead | select1);
+        expect(fdc._driveOut & loadHead).toBe(loadHead);
+        expect(fakeDrive.spinning).toBe(true);
+    });
+    it("should seek to a track", () => {
+        const fakeCpu = fake6502();
+        const scheduler = new Scheduler();
+        const fakeDrive = new FakeDrive();
+        const fdc = new IntelFdc(fakeCpu, scheduler, [fakeDrive]);
+        sendCommand(fdc, writeRegCmd, mmioWrite, loadHead | select1);
+        // nb will seek two more due to bad track nonsense
+        sendCommand(fdc, seekCmd, 2);
+        expect(fakeDrive.track).toBe(1);
+        // We should have some 3ms step scheduled
+        expect(scheduler.headroom()).toBe(6000);
+        scheduler.polltime(6000);
+        expect(fakeDrive.track).toBe(2);
+        // We should reach and stop at track 4.
+        scheduler.polltime(6000 * 10);
+        expect(fakeDrive.track).toBe(4);
+    });
+});

package/tests/unit/test-keyboard.js

@@ -0,0 +1,410 @@
+import { expect, describe, test, beforeEach, vi } from "vitest";
+import { Keyboard } from "../../src/keyboard.js";
+import * as utils from "../../src/utils.js";
+
+describe("Keyboard", () => {
+    let keyboard;
+    let mockProcessor;
+    let mockSysvia;
+    let mockInputEnabledFunction;
+
+    // Helper function to create an async event tester
+    const waitForEvent = (eventName) => {
+        return new Promise((resolve) => {
+            keyboard.on(eventName, (...args) => {
+                resolve(args);
+            });
+        });
+    };
+
+    // Helper to trigger an event and wait for the result
+    const triggerAndWaitForEvent = async (eventName, action) => {
+        const eventPromise = waitForEvent(eventName);
+        action();
+        return await eventPromise;
+    };
+
+    beforeEach(() => {
+        mockSysvia = {
+            keyDown: vi.fn(),
+            keyUp: vi.fn(),
+            clearKeys: vi.fn(),
+            disableKeyboard: vi.fn(),
+            enableKeyboard: vi.fn(),
+            keyToggleRaw: vi.fn(),
+            setKeyLayout: vi.fn(),
+            capsLockLight: false,
+            shiftLockLight: false,
+        };
+
+        mockProcessor = {
+            sysvia: mockSysvia,
+            debugInstruction: {
+                add: vi.fn().mockReturnValue({
+                    remove: vi.fn(),
+                }),
+            },
+            setReset: vi.fn(),
+            cpuMultiplier: 1,
+            cycleSeconds: 0,
+            currentCycles: 0,
+        };
+
+        mockInputEnabledFunction = vi.fn().mockReturnValue(false);
+
+        keyboard = new Keyboard({
+            processor: mockProcessor,
+            inputEnabledFunction: mockInputEnabledFunction,
+            keyLayout: "physical",
+            dbgr: {
+                enabled: vi.fn().mockReturnValue(false),
+                keyPress: vi.fn(),
+                hide: vi.fn(),
+            },
+        });
+    });
+
+    test("should create a keyboard instance", () => {
+        expect(keyboard).toBeDefined();
+    });
+
+    test("keyCode should handle location properly", () => {
+        // Test SHIFT key
+        const shiftEvent = { which: utils.keyCodes.SHIFT, location: 1 };
+        expect(keyboard.keyCode(shiftEvent)).toBe(utils.keyCodes.SHIFT_LEFT);
+
+        const shiftEvent2 = { which: utils.keyCodes.SHIFT, location: 2 };
+        expect(keyboard.keyCode(shiftEvent2)).toBe(utils.keyCodes.SHIFT_RIGHT);
+
+        // Test CTRL key
+        const ctrlEvent = { which: utils.keyCodes.CTRL, location: 1 };
+        expect(keyboard.keyCode(ctrlEvent)).toBe(utils.keyCodes.CTRL_LEFT);
+
+        const ctrlEvent2 = { which: utils.keyCodes.CTRL, location: 2 };
+        expect(keyboard.keyCode(ctrlEvent2)).toBe(utils.keyCodes.CTRL_RIGHT);
+
+        // Test ALT key
+        const altEvent = { which: utils.keyCodes.ALT, location: 1 };
+        expect(keyboard.keyCode(altEvent)).toBe(utils.keyCodes.ALT_LEFT);
+
+        const altEvent2 = { which: utils.keyCodes.ALT, location: 2 };
+        expect(keyboard.keyCode(altEvent2)).toBe(utils.keyCodes.ALT_RIGHT);
+
+        // Test numpad
+        const enterEvent = { which: utils.keyCodes.ENTER, location: 3 };
+        expect(keyboard.keyCode(enterEvent)).toBe(utils.keyCodes.NUMPADENTER);
+
+        const deleteEvent = { which: utils.keyCodes.DELETE, location: 3 };
+        expect(keyboard.keyCode(deleteEvent)).toBe(utils.keyCodes.NUMPAD_DECIMAL_POINT);
+
+        // Test normal key
+        const normalEvent = { which: utils.keyCodes.A, location: 0 };
+        expect(keyboard.keyCode(normalEvent)).toBe(utils.keyCodes.A);
+    });
+
+    test("keyCode should remember last modifier key locations", () => {
+        // First, set modifier locations to known values
+        keyboard.keyCode({ which: utils.keyCodes.SHIFT, location: 1 });
+        keyboard.keyCode({ which: utils.keyCodes.CTRL, location: 1 });
+        keyboard.keyCode({ which: utils.keyCodes.ALT, location: 1 });
+
+        // When location = 0 (like in keyUp events), should return based on last location
+        expect(keyboard.keyCode({ which: utils.keyCodes.SHIFT, location: 0 })).toBe(utils.keyCodes.SHIFT_LEFT);
+        expect(keyboard.keyCode({ which: utils.keyCodes.CTRL, location: 0 })).toBe(utils.keyCodes.CTRL_LEFT);
+        expect(keyboard.keyCode({ which: utils.keyCodes.ALT, location: 0 })).toBe(utils.keyCodes.ALT_LEFT);
+
+        // Change the locations to right side
+        keyboard.keyCode({ which: utils.keyCodes.SHIFT, location: 2 });
+        keyboard.keyCode({ which: utils.keyCodes.CTRL, location: 2 });
+        keyboard.keyCode({ which: utils.keyCodes.ALT, location: 2 });
+
+        // Should now use the updated locations
+        expect(keyboard.keyCode({ which: utils.keyCodes.SHIFT, location: 0 })).toBe(utils.keyCodes.SHIFT_RIGHT);
+        expect(keyboard.keyCode({ which: utils.keyCodes.CTRL, location: 0 })).toBe(utils.keyCodes.CTRL_RIGHT);
+        expect(keyboard.keyCode({ which: utils.keyCodes.ALT, location: 0 })).toBe(utils.keyCodes.ALT_RIGHT);
+    });
+
+    test("keyDown should handle normal key press", () => {
+        const event = {
+            which: utils.keyCodes.A,
+            location: 0,
+            preventDefault: vi.fn(),
+            ctrlKey: false,
+            altKey: false,
+            shiftKey: false,
+        };
+
+        keyboard.setRunning(true);
+        keyboard.keyDown(event);
+
+        expect(mockSysvia.keyDown).toHaveBeenCalledWith(utils.keyCodes.A, false);
+        expect(event.preventDefault).toHaveBeenCalled();
+    });
+
+    test("keyDown should not handle keys when not running", () => {
+        const event = {
+            which: utils.keyCodes.A,
+            location: 0,
+            preventDefault: vi.fn(),
+            ctrlKey: false,
+            altKey: false,
+            shiftKey: false,
+        };
+
+        keyboard.setRunning(false);
+        keyboard.keyDown(event);
+
+        expect(mockSysvia.keyDown).not.toHaveBeenCalled();
+    });
+
+    test("keyDown should not handle keys when input is enabled", () => {
+        const event = {
+            which: utils.keyCodes.A,
+            location: 0,
+            preventDefault: vi.fn(),
+            ctrlKey: false,
+            altKey: false,
+            shiftKey: false,
+        };
+
+        // Set input enabled to true
+        mockInputEnabledFunction.mockReturnValueOnce(true);
+
+        keyboard.setRunning(true);
+        keyboard.keyDown(event);
+
+        expect(mockInputEnabledFunction).toHaveBeenCalled();
+        expect(mockSysvia.keyDown).not.toHaveBeenCalled();
+    });
+
+    test("keyDown should handle F12/BREAK and emit break event", async () => {
+        const event = {
+            which: utils.keyCodes.F12,
+            location: 0,
+            preventDefault: vi.fn(),
+            ctrlKey: false,
+            altKey: false,
+            shiftKey: false,
+        };
+
+        keyboard.setRunning(true);
+
+        const [breakState] = await triggerAndWaitForEvent("break", () => {
+            keyboard.keyDown(event);
+        });
+
+        expect(mockProcessor.setReset).toHaveBeenCalledWith(true);
+        expect(event.preventDefault).toHaveBeenCalled();
+        expect(breakState).toBe(true);
+    });
+
+    test("keyUp should call sysvia.keyUp", () => {
+        const event = {
+            which: utils.keyCodes.A,
+            location: 0,
+            preventDefault: vi.fn(),
+            altKey: false,
+        };
+
+        keyboard.setRunning(true);
+        keyboard.keyUp(event);
+
+        expect(mockSysvia.keyUp).toHaveBeenCalledWith(utils.keyCodes.A);
+        expect(event.preventDefault).toHaveBeenCalled();
+    });
+
+    test("keyUp should not proceed when input is enabled", () => {
+        const event = {
+            which: utils.keyCodes.A,
+            location: 0,
+            preventDefault: vi.fn(),
+            altKey: false,
+        };
+
+        // Set input enabled to true
+        mockInputEnabledFunction.mockReturnValueOnce(true);
+
+        keyboard.setRunning(true);
+        keyboard.keyUp(event);
+
+        expect(mockInputEnabledFunction).toHaveBeenCalled();
+        expect(mockSysvia.keyUp).not.toHaveBeenCalled();
+        expect(event.preventDefault).not.toHaveBeenCalled();
+    });
+
+    test("keyUp should handle F12/BREAK and emit break event", async () => {
+        const event = {
+            which: utils.keyCodes.F12,
+            location: 0,
+            preventDefault: vi.fn(),
+            altKey: false,
+        };
+
+        keyboard.setRunning(true);
+
+        const [breakState] = await triggerAndWaitForEvent("break", () => {
+            keyboard.keyUp(event);
+        });
+
+        expect(mockProcessor.setReset).toHaveBeenCalledWith(false);
+        expect(event.preventDefault).toHaveBeenCalled();
+        expect(breakState).toBe(false);
+    });
+
+    test("clearKeys should call sysvia.clearKeys", () => {
+        keyboard.clearKeys();
+        expect(mockSysvia.clearKeys).toHaveBeenCalled();
+    });
+
+    test("setKeyLayout should update config and call processor to update layout", () => {
+        keyboard.setKeyLayout("gaming");
+        expect(mockSysvia.setKeyLayout).toHaveBeenCalledWith("gaming");
+    });
+
+    test("keyPress should not proceed when input is enabled", () => {
+        const event = {
+            which: 103, // lowercase g key
+            location: 0,
+            preventDefault: vi.fn(),
+        };
+
+        // Set input enabled to true
+        mockInputEnabledFunction.mockReturnValueOnce(true);
+
+        // Add a resume event listener to check it's not called
+        const resumeListener = vi.fn();
+        keyboard.on("resume", resumeListener);
+
+        keyboard.keyPress(event);
+
+        expect(mockInputEnabledFunction).toHaveBeenCalled();
+        // No events should be emitted when input is enabled
+        expect(resumeListener).not.toHaveBeenCalled();
+    });
+
+    test("keyPress should emit resume event when lowercase g pressed in pause mode", async () => {
+        const event = {
+            which: 103, // lowercase g key
+            location: 0,
+            preventDefault: vi.fn(),
+        };
+
+        keyboard.pauseEmu = true;
+
+        const eventPromise = waitForEvent("resume");
+        keyboard.keyPress(event);
+        await eventPromise;
+
+        expect(keyboard.pauseEmu).toBe(false);
+    });
+
+    test("keyPress should handle debugger g key and emit resume event", async () => {
+        const event = {
+            which: 103, // lowercase g key
+            location: 0,
+            preventDefault: vi.fn(),
+        };
+
+        // Mock debugger enabled
+        const mockDbgr = {
+            enabled: vi.fn().mockReturnValue(true),
+            keyPress: vi.fn(),
+            hide: vi.fn(),
+        };
+        keyboard.dbgr = mockDbgr;
+
+        const eventPromise = waitForEvent("resume");
+        keyboard.keyPress(event);
+        await eventPromise;
+
+        expect(mockDbgr.hide).toHaveBeenCalled();
+    });
+
+    test("registerKeyHandler should add a handler for a key with Alt modifier", () => {
+        const mockHandler = vi.fn();
+        keyboard.registerKeyHandler(utils.keyCodes.Q, mockHandler, { alt: true, ctrl: false });
+
+        const event = {
+            which: utils.keyCodes.Q,
+            location: 0,
+            preventDefault: vi.fn(),
+            ctrlKey: false,
+            altKey: true,
+            shiftKey: false,
+        };
+
+        keyboard.setRunning(true);
+        keyboard.keyDown(event);
+
+        expect(mockHandler).toHaveBeenCalledWith(true, utils.keyCodes.Q);
+    });
+
+    test("registerKeyHandler should add a handler for a key with Ctrl modifier", () => {
+        const mockHandler = vi.fn();
+        keyboard.registerKeyHandler(utils.keyCodes.E, mockHandler, { alt: false, ctrl: true });
+
+        const event = {
+            which: utils.keyCodes.E,
+            location: 0,
+            preventDefault: vi.fn(),
+            ctrlKey: true,
+            altKey: false,
+            shiftKey: false,
+        };
+
+        keyboard.setRunning(true);
+        keyboard.keyDown(event);
+
+        expect(mockHandler).toHaveBeenCalledWith(true, utils.keyCodes.E);
+    });
+
+    test("sendRawKeyboardToBBC should setup the keyboard input", () => {
+        keyboard.sendRawKeyboardToBBC([utils.BBC.A], false);
+
+        expect(mockSysvia.disableKeyboard).toHaveBeenCalled();
+        expect(mockProcessor.debugInstruction.add).toHaveBeenCalled();
+    });
+
+    test("postFrameShouldPause should handle single step", () => {
+        // Initially should not pause
+        expect(keyboard.postFrameShouldPause()).toBe(false);
+
+        // Set step to true
+        keyboard.stepEmuWhenPaused = true;
+
+        // Should pause and reset flag
+        expect(keyboard.postFrameShouldPause()).toBe(true);
+
+        // Flag should be reset
+        expect(keyboard.stepEmuWhenPaused).toBe(false);
+
+        // Subsequent call should not pause
+        expect(keyboard.postFrameShouldPause()).toBe(false);
+    });
+
+    test("requestStep should set the step flag", () => {
+        expect(keyboard.stepEmuWhenPaused).toBe(false);
+        keyboard.requestStep();
+        expect(keyboard.stepEmuWhenPaused).toBe(true);
+    });
+
+    test("pauseEmulation should set pause flag and emit pause event", async () => {
+        const eventPromise = waitForEvent("pause");
+        keyboard.pauseEmulation();
+        await eventPromise;
+
+        expect(keyboard.pauseEmu).toBe(true);
+    });
+
+    test("resumeEmulation should clear pause flag and emit resume event", async () => {
+        keyboard.pauseEmu = true;
+
+        const eventPromise = waitForEvent("resume");
+        keyboard.resumeEmulation();
+        await eventPromise;
+
+        expect(keyboard.pauseEmu).toBe(false);
+    });
+
+    // We don't test Mac-specific code as it requires global mocking
+});

package/tests/unit/test-mouse-joystick-source.js

@@ -0,0 +1,128 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { MouseJoystickSource } from "../../src/mouse-joystick-source.js";
+
+describe("MouseJoystickSource", () => {
+    let canvas, source, mockVia;
+
+    beforeEach(() => {
+        // Create a mock canvas element (simpler since we don't use event listeners)
+        canvas = {
+            addEventListener: vi.fn(),
+            removeEventListener: vi.fn(),
+        };
+
+        mockVia = {
+            setJoystickButton: vi.fn(),
+        };
+
+        source = new MouseJoystickSource(canvas);
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    it("should initialize with center position", () => {
+        expect(source.mouseX).toBe(0.5);
+        expect(source.mouseY).toBe(0.5);
+        expect(source.isActive).toBe(false);
+    });
+
+    it("should return center value initially", () => {
+        // Mouse starts at center position (0.5, 0.5)
+        // Math.floor((1 - 0.5) * 0xffff) = Math.floor(0.5 * 0xffff) = 32767
+        expect(source.getValue(0)).toBe(32767);
+        expect(source.getValue(1)).toBe(32767);
+    });
+
+    it("should handle mouse position tracking via API", () => {
+        // Use the API method to set mouse position
+        source.onMouseMove(0, 0); // top-left corner
+        expect(source.isActive).toBe(true);
+        expect(source.mouseX).toBe(0);
+        expect(source.mouseY).toBe(0);
+        expect(source.getValue(0)).toBe(0xffff); // X channel (left = max)
+        expect(source.getValue(1)).toBe(0xffff); // Y channel (top = max)
+
+        // Use the API method to move to bottom-right corner
+        source.onMouseMove(1, 1); // bottom-right corner
+        expect(source.mouseX).toBe(1);
+        expect(source.mouseY).toBe(1);
+        expect(source.getValue(0)).toBe(0); // X channel (right = min)
+        expect(source.getValue(1)).toBe(0); // Y channel (bottom = min)
+    });
+
+    it("should track active state via API", () => {
+        expect(source.isActive).toBe(false);
+
+        // Using the API method sets the source as active
+        source.onMouseMove(0.8, 0.3);
+        expect(source.isActive).toBe(true);
+        expect(source.mouseX).toBe(0.8);
+        expect(source.mouseY).toBe(0.3);
+    });
+
+    it("should handle fire button clicks via API", () => {
+        source.setVia(mockVia);
+
+        // Use API method for mouse button down
+        source.onMouseDown(0); // left button
+        expect(mockVia.setJoystickButton).toHaveBeenCalledWith(0, true);
+
+        // Use API method for mouse button up
+        source.onMouseUp(0); // left button
+        expect(mockVia.setJoystickButton).toHaveBeenCalledWith(0, false);
+    });
+
+    it("should ignore non-left mouse buttons via API", () => {
+        source.setVia(mockVia);
+
+        // Use API method with right button (button 2)
+        source.onMouseDown(2);
+        expect(mockVia.setJoystickButton).not.toHaveBeenCalled();
+    });
+
+    it("should return correct values for all channels", () => {
+        // Use API method to set position
+        source.onMouseMove(0.25, 0.75);
+
+        expect(source.getValue(0)).toBe(Math.floor((1 - 0.25) * 0xffff)); // X channel (inverted)
+        expect(source.getValue(1)).toBe(Math.floor((1 - 0.75) * 0xffff)); // Y channel (inverted)
+        expect(source.getValue(2)).toBe(0x8000); // Unused channel
+        expect(source.getValue(3)).toBe(0x8000); // Unused channel
+        expect(source.getValue(99)).toBe(0x8000); // Invalid channel
+    });
+
+    it("should validate input range via API", () => {
+        // Test boundary clamping in API method
+        source.onMouseMove(-0.5, 1.5); // Out of bounds values
+
+        // Should be clamped to valid range [0, 1]
+        expect(source.mouseX).toBe(0);
+        expect(source.mouseY).toBe(1);
+        expect(source.getValue(0)).toBe(0xffff); // X channel (left = max)
+        expect(source.getValue(1)).toBe(0); // Y channel (bottom = min)
+    });
+
+    it("should reset state on dispose", () => {
+        source.setVia(mockVia);
+        source.onMouseMove(0.8, 0.3);
+
+        source.dispose();
+
+        expect(source.via).toBe(null);
+        expect(source.isActive).toBe(false);
+        // No event listeners to remove since we don't register any
+        expect(canvas.removeEventListener).not.toHaveBeenCalled();
+    });
+
+    it("should report enabled state correctly", () => {
+        expect(source.isEnabled()).toBe(false);
+
+        source.setVia(mockVia);
+        expect(source.isEnabled()).toBe(true);
+
+        source.setVia(null);
+        expect(source.isEnabled()).toBe(false);
+    });
+});