jsbeeb 1.1.1

package/tests/unit/test-scheduler.js

@@ -0,0 +1,190 @@
+import { describe, it, expect } from "vitest";
+import { Scheduler } from "../../src/scheduler.js";
+
+describe("Scheduler tests", function () {
+    "use strict";
+    it("creates", function () {
+        new Scheduler();
+    });
+
+    it("handles simple cases", function () {
+        const s = new Scheduler();
+        let called = false;
+        const t = s.newTask(function () {
+            expect(called).toBe(false);
+            called = true;
+        });
+        t.schedule(2);
+        expect(called).toBe(false);
+        s.polltime(1);
+        expect(called).toBe(false);
+        s.polltime(1);
+        expect(called).toBe(true);
+        s.polltime(1);
+    });
+
+    it("handles simple cases with a big step", function () {
+        const s = new Scheduler();
+        let called = false;
+        const t = s.newTask(function () {
+            expect(called).toBe(false);
+            called = true;
+        });
+        t.schedule(2);
+        expect(called).toBe(false);
+        s.polltime(2);
+        expect(called).toBe(true);
+        s.polltime(2);
+    });
+
+    it("handles simple cases with a big step past", function () {
+        const s = new Scheduler();
+        let called = false;
+        const t = s.newTask(function () {
+            expect(called).toBe(false);
+            called = true;
+        });
+        t.schedule(2);
+        expect(called).toBe(false);
+        s.polltime(3);
+        expect(called).toBe(true);
+        s.polltime(3);
+    });
+
+    it("calls callbacks in the order registered when occurring on same cycle", function () {
+        const s = new Scheduler();
+        let called = "";
+        s.newTask(function () {
+            called += "a";
+        }).schedule(2);
+        s.newTask(function () {
+            called += "b";
+        }).schedule(2);
+        s.newTask(function () {
+            called += "c";
+        }).schedule(2);
+        expect(called).toBe("");
+        s.polltime(1);
+        expect(called).toBe("");
+        s.polltime(1);
+        expect(called).toBe("abc");
+        s.polltime(1);
+    });
+
+    it("cancels first occurring event", function () {
+        const s = new Scheduler();
+        let called = "";
+        const a = s.newTask(function () {
+            called += "a";
+        });
+        a.schedule(2);
+        s.newTask(function () {
+            called += "b";
+        }).schedule(2);
+        s.newTask(function () {
+            called += "c";
+        }).schedule(2);
+        a.cancel();
+        s.polltime(2);
+        expect(called).toBe("bc");
+    });
+
+    it("cancels middle occurring event", function () {
+        const s = new Scheduler();
+        let called = "";
+        s.newTask(function () {
+            called += "a";
+        }).schedule(2);
+        const b = s.newTask(function () {
+            called += "b";
+        });
+        b.schedule(2);
+        s.newTask(function () {
+            called += "c";
+        }).schedule(2);
+        b.cancel();
+        s.polltime(2);
+        expect(called).toBe("ac");
+    });
+
+    it("cancels last occurring event", function () {
+        const s = new Scheduler();
+        let called = "";
+        s.newTask(function () {
+            called += "a";
+        }).schedule(2);
+        s.newTask(function () {
+            called += "b";
+        }).schedule(2);
+        const c = s.newTask(function () {
+            called += "c";
+        });
+        c.schedule(2);
+        c.cancel();
+        s.polltime(2);
+        expect(called).toBe("ab");
+    });
+
+    it("handle events registered in reverse (CBA) order", function () {
+        const s = new Scheduler();
+        let called = "";
+        s.newTask(function () {
+            called += "a";
+        }).schedule(4);
+        s.newTask(function () {
+            called += "b";
+        }).schedule(3);
+        s.newTask(function () {
+            called += "c";
+        }).schedule(2);
+        s.polltime(10);
+        expect(called).toBe("cba");
+    });
+
+    it("handle events registered in CAB order", function () {
+        const s = new Scheduler();
+        let called = "";
+        s.newTask(function () {
+            called += "a";
+        }).schedule(3);
+        s.newTask(function () {
+            called += "b";
+        }).schedule(4);
+        s.newTask(function () {
+            called += "c";
+        }).schedule(2);
+        s.polltime(10);
+        expect(called).toBe("cab");
+    });
+
+    it("works properly with epochs", function () {
+        const s = new Scheduler();
+        s.polltime(12346);
+        const epochBefore = s.epoch;
+        let epochAtCall = 0;
+        s.newTask(function () {
+            epochAtCall = s.epoch;
+        }).schedule(4);
+        s.polltime(9974);
+        expect(epochAtCall - epochBefore).toBe(4);
+    });
+
+    it("allows you to reschedule from within a callback", function () {
+        const s = new Scheduler();
+        s.polltime(12346);
+        const times = [1000, 1000, 100000, 1000];
+        const called = [];
+        const task = s.newTask(function () {
+            called.push(s.epoch);
+            const next = times.shift();
+            if (next) {
+                task.schedule(next);
+            }
+        });
+        task.schedule(10);
+        for (let i = 0; i < 500000; ++i) {
+            s.polltime(3);
+        }
+        expect(called).toEqual([12356, 13356, 14356, 114356, 115356]);
+    });
+});

package/tests/unit/test-serial.js

@@ -0,0 +1,154 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { Serial } from "../../src/serial.js";
+
+describe("Serial", () => {
+    // Create mock for the ACIA dependency
+    const mockAcia = {
+        setSerialReceive: vi.fn(),
+        setMotor: vi.fn(),
+        selectRs423: vi.fn(),
+    };
+
+    // The baud rate table as defined in serial.js
+    const baudRateTable = [19200, 9600, 4800, 2400, 1200, 300, 150, 75];
+
+    let serial;
+
+    beforeEach(() => {
+        // Reset mocks before each test
+        vi.resetAllMocks();
+
+        // Create a fresh Serial instance
+        serial = new Serial(mockAcia);
+    });
+
+    describe("Initialization", () => {
+        it("should initialize with default state", () => {
+            expect(serial.reg).toBe(0);
+            expect(serial.transmitRate).toBe(0);
+            expect(serial.receiveRate).toBe(0);
+        });
+
+        it("should reset to default state", () => {
+            // Change state
+            serial.reg = 0xff;
+            serial.transmitRate = 7;
+            serial.receiveRate = 7;
+
+            // Reset
+            serial.reset();
+
+            // Check state is back to default
+            expect(serial.reg).toBe(0);
+            expect(serial.transmitRate).toBe(0);
+            expect(serial.receiveRate).toBe(0);
+        });
+    });
+
+    describe("Register write operation", () => {
+        it("should store value and update rates on write", () => {
+            // Write value 0x2A to register (00101010)
+            // - transmitRate = 010 = 2
+            // - receiveRate = 101 = 5
+            serial.write(0, 0x2a);
+
+            expect(serial.reg).toBe(0x2a);
+            expect(serial.transmitRate).toBe(2);
+            expect(serial.receiveRate).toBe(5);
+        });
+
+        it("should mask value to 8 bits on write", () => {
+            // Write value 0x1FF to register, should be masked to 0xFF
+            serial.write(0, 0x1ff);
+
+            expect(serial.reg).toBe(0xff);
+        });
+
+        it("should set correct receive baud rate", () => {
+            // Test all possible receive rate values
+            for (let i = 0; i < 8; i++) {
+                // Create a value where receiveRate = i (bits 3-5)
+                const val = i << 3;
+                serial.write(0, val);
+
+                // Check rate is set correctly
+                expect(serial.receiveRate).toBe(i);
+                // Check correct baud rate was passed to ACIA
+                expect(mockAcia.setSerialReceive).toHaveBeenLastCalledWith(baudRateTable[i]);
+            }
+        });
+
+        it("should set motor state based on bit 7", () => {
+            // Test with bit 7 = 0
+            serial.write(0, 0x00);
+            expect(mockAcia.setMotor).toHaveBeenLastCalledWith(false);
+
+            // Test with bit 7 = 1
+            serial.write(0, 0x80);
+            expect(mockAcia.setMotor).toHaveBeenLastCalledWith(true);
+        });
+
+        it("should select RS-423 based on bit 6", () => {
+            // Test with bit 6 = 0
+            serial.write(0, 0x00);
+            expect(mockAcia.selectRs423).toHaveBeenLastCalledWith(false);
+
+            // Test with bit 6 = 1
+            serial.write(0, 0x40);
+            expect(mockAcia.selectRs423).toHaveBeenLastCalledWith(true);
+        });
+
+        it("should handle complex register values", () => {
+            // Write value 0xEA to register (11101010)
+            // - transmitRate = 010 = 2
+            // - receiveRate = 101 = 5
+            // - bit 6 = 1 (select RS-423)
+            // - bit 7 = 1 (motor on)
+            serial.write(0, 0xea);
+
+            expect(serial.reg).toBe(0xea);
+            expect(serial.transmitRate).toBe(2);
+            expect(serial.receiveRate).toBe(5);
+            expect(mockAcia.setSerialReceive).toHaveBeenCalledWith(baudRateTable[5]);
+            expect(mockAcia.setMotor).toHaveBeenCalledWith(true);
+            expect(mockAcia.selectRs423).toHaveBeenCalledWith(true);
+        });
+    });
+
+    describe("Register read operation", () => {
+        it("should reset register to 0xFE on read", () => {
+            // Set initial state
+            serial.write(0, 0x2a);
+
+            // Read should reset to 0xFE
+            const result = serial.read();
+
+            // Check result is 0
+            expect(result).toBe(0);
+
+            // Check register was updated
+            expect(serial.reg).toBe(0xfe);
+            // Check rates were updated
+            expect(serial.transmitRate).toBe(6); // 0xFE & 0x07 = 6
+            expect(serial.receiveRate).toBe(7); // (0xFE >>> 3) & 0x07 = 7
+            // Check ACIA was updated
+            expect(mockAcia.setSerialReceive).toHaveBeenLastCalledWith(baudRateTable[7]);
+            expect(mockAcia.setMotor).toHaveBeenLastCalledWith(true);
+            expect(mockAcia.selectRs423).toHaveBeenLastCalledWith(true);
+        });
+    });
+
+    describe("Edge cases", () => {
+        it("should ignore address in write", () => {
+            // Write to different addresses should have same effect
+            serial.write(0, 0x2a);
+            expect(serial.reg).toBe(0x2a);
+
+            serial.write(1, 0x3b);
+            expect(serial.reg).toBe(0x3b);
+
+            serial.write(0xff, 0x4c);
+            expect(serial.reg).toBe(0x4c);
+        });
+    });
+});

package/tests/unit/test-teletext-adaptor.js

@@ -0,0 +1,359 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import { TeletextAdaptor } from "../../src/teletext_adaptor.js";
+
+describe("TeletextAdaptor", () => {
+    // Constants
+    const TELETEXT_IRQ = 5;
+
+    // Mock CPU
+    const mockCpu = {
+        interrupt: 0,
+        resetLine: true,
+    };
+
+    let teletext;
+
+    beforeEach(() => {
+        // Reset mocks
+        vi.clearAllMocks();
+        mockCpu.interrupt = 0;
+        mockCpu.resetLine = true;
+
+        // Create fresh teletext adaptor
+        teletext = new TeletextAdaptor(mockCpu);
+
+        // Silence console logs during tests
+        vi.spyOn(console, "log").mockImplementation(() => {});
+
+        // Override loadChannelStream to avoid actual network calls
+        teletext.loadChannelStream = vi.fn();
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    describe("Initialization", () => {
+        it("should initialize with default state", () => {
+            expect(teletext.teletextStatus).toBe(0x0f);
+            expect(teletext.teletextInts).toBe(false);
+            expect(teletext.teletextEnable).toBe(false);
+            expect(teletext.channel).toBe(0);
+            expect(teletext.currentFrame).toBe(0);
+            expect(teletext.totalFrames).toBe(0);
+            expect(teletext.rowPtr).toBe(0);
+            expect(teletext.colPtr).toBe(0);
+            expect(teletext.frameBuffer.length).toBe(16);
+            expect(teletext.frameBuffer[0].length).toBe(64);
+            expect(teletext.streamData).toBe(null);
+            expect(teletext.pollCount).toBe(0);
+        });
+
+        it("should call loadChannelStream on hard reset", () => {
+            // Hard reset
+            teletext.reset(true);
+
+            // Check if loadChannelStream was called with channel 0
+            expect(teletext.loadChannelStream).toHaveBeenCalledWith(0);
+        });
+
+        it("should not call loadChannelStream on soft reset", () => {
+            // Soft reset
+            teletext.reset(false);
+
+            // Check if loadChannelStream was not called
+            expect(teletext.loadChannelStream).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("Register operations", () => {
+        describe("Read operations", () => {
+            it("should read status register (addr 0)", () => {
+                teletext.teletextStatus = 0x42;
+                expect(teletext.read(0)).toBe(0x42);
+            });
+
+            it("should read row register (addr 1)", () => {
+                // Row register reads always return 0
+                expect(teletext.read(1)).toBe(0);
+            });
+
+            it("should read from frame buffer and increment column pointer (addr 2)", () => {
+                // Set up known values in frame buffer
+                teletext.rowPtr = 5;
+                teletext.colPtr = 10;
+                teletext.frameBuffer[5][10] = 0xaa;
+                teletext.frameBuffer[5][11] = 0xbb;
+
+                // First read should return value at current position and increment column
+                expect(teletext.read(2)).toBe(0xaa);
+                expect(teletext.colPtr).toBe(11);
+
+                // Second read should return next value
+                expect(teletext.read(2)).toBe(0xbb);
+                expect(teletext.colPtr).toBe(12);
+            });
+
+            it("should clear status and interrupt on addr 3 read", () => {
+                // Set status and interrupt
+                teletext.teletextStatus = 0xff;
+                mockCpu.interrupt = 1 << TELETEXT_IRQ;
+
+                // Read from addr 3
+                teletext.read(3);
+
+                // Status should be cleared (INT, DOR, and FSYN latches)
+                expect(teletext.teletextStatus & 0xd0).toBe(0);
+
+                // Interrupt should be cleared
+                expect(mockCpu.interrupt & (1 << TELETEXT_IRQ)).toBe(0);
+            });
+        });
+
+        describe("Write operations", () => {
+            it("should update control bits on status register write (addr 0)", () => {
+                // Write with teletext enabled, interrupts enabled, channel 2
+                teletext.write(0, 0x0c | 2); // 0x0E
+
+                expect(teletext.teletextEnable).toBe(true);
+                expect(teletext.teletextInts).toBe(true);
+                expect(teletext.channel).toBe(2);
+
+                // Check if loadChannelStream was called
+                expect(teletext.loadChannelStream).toHaveBeenCalledWith(2);
+            });
+
+            it("should not reload channel if channel doesn't change", () => {
+                // Set initial state
+                teletext.channel = 1;
+                teletext.teletextEnable = true;
+
+                // Write same channel
+                teletext.write(0, 0x0c | 1); // 0x0D
+
+                // Check loadChannelStream wasn't called
+                expect(teletext.loadChannelStream).not.toHaveBeenCalled();
+            });
+
+            it("should not change channel or load channel if teletext not enabled", () => {
+                // Set initial values
+                teletext.channel = 1;
+                teletext.loadChannelStream.mockClear();
+
+                // Write with teletext disabled, channel 2
+                teletext.write(0, 2); // 0x02
+
+                // Teletext should be disabled
+                expect(teletext.teletextEnable).toBe(false);
+
+                // Channel should remain unchanged since teletext is disabled
+                // According to the implementation in write method, channel is only updated
+                // if teletext is enabled: if ((value & 0x03) !== this.channel && this.teletextEnable)
+                expect(teletext.channel).toBe(1);
+
+                // Check loadChannelStream wasn't called
+                expect(teletext.loadChannelStream).not.toHaveBeenCalled();
+            });
+
+            it("should set interrupt flag if INT and interrupts enabled", () => {
+                // Set INT latch
+                teletext.teletextStatus = 0x80;
+
+                // Enable interrupts
+                teletext.write(0, 0x08);
+
+                // Check if interrupt was set
+                expect(mockCpu.interrupt & (1 << TELETEXT_IRQ)).toBe(1 << TELETEXT_IRQ);
+            });
+
+            it("should clear interrupt flag if interrupts disabled", () => {
+                // Set interrupt
+                mockCpu.interrupt = 1 << TELETEXT_IRQ;
+
+                // Disable interrupts
+                teletext.write(0, 0x00);
+
+                // Check if interrupt was cleared
+                expect(mockCpu.interrupt & (1 << TELETEXT_IRQ)).toBe(0);
+            });
+
+            it("should update row pointer and reset column pointer (addr 1)", () => {
+                // Set initial state
+                teletext.rowPtr = 0;
+                teletext.colPtr = 10;
+
+                // Write to row register
+                teletext.write(1, 5);
+
+                expect(teletext.rowPtr).toBe(5);
+                expect(teletext.colPtr).toBe(0);
+            });
+
+            it("should write to frame buffer and increment column (addr 2)", () => {
+                // Set initial position
+                teletext.rowPtr = 3;
+                teletext.colPtr = 7;
+
+                // Write to data register
+                teletext.write(2, 0xaa);
+
+                // Check if value was written and column incremented
+                expect(teletext.frameBuffer[3][7]).toBe(0xaa);
+                expect(teletext.colPtr).toBe(8);
+            });
+
+            it("should clear status and interrupt on addr 3 write", () => {
+                // Set status and interrupt
+                teletext.teletextStatus = 0xff;
+                mockCpu.interrupt = 1 << TELETEXT_IRQ;
+
+                // Write to addr 3
+                teletext.write(3, 0);
+
+                // Status should be cleared (INT, DOR, and FSYN latches)
+                expect(teletext.teletextStatus & 0xd0).toBe(0);
+
+                // Interrupt should be cleared
+                expect(mockCpu.interrupt & (1 << TELETEXT_IRQ)).toBe(0);
+            });
+        });
+    });
+
+    describe("Update and polling", () => {
+        // Create a mock implementation of update() that doesn't access streamData
+        // This avoids trying to access the null streamData property
+        let originalUpdate;
+
+        beforeEach(() => {
+            // Save original update method
+            originalUpdate = teletext.update;
+
+            // Replace with mock that only updates the status and frame counter
+            teletext.update = function () {
+                // Set status latches
+                this.teletextStatus &= 0x0f;
+                this.teletextStatus |= 0xd0;
+
+                // Increment frame counter
+                if (this.currentFrame >= this.totalFrames - 1) {
+                    this.currentFrame = 0;
+                } else {
+                    this.currentFrame++;
+                }
+
+                // Reset pointers
+                this.rowPtr = 0;
+                this.colPtr = 0;
+
+                // Set interrupt if enabled
+                if (this.teletextInts) {
+                    this.cpu.interrupt |= 1 << TELETEXT_IRQ;
+                }
+            };
+        });
+
+        afterEach(() => {
+            // Restore original update method
+            teletext.update = originalUpdate;
+        });
+
+        it("should update status and frame counter on update()", () => {
+            // Set initial state
+            teletext.teletextEnable = true;
+            teletext.currentFrame = 2;
+            teletext.totalFrames = 5;
+
+            // Call update
+            teletext.update();
+
+            // Check status latches were set
+            expect(teletext.teletextStatus & 0xd0).toBe(0xd0);
+
+            // Check frame was incremented
+            expect(teletext.currentFrame).toBe(3);
+
+            // Check pointers were reset
+            expect(teletext.rowPtr).toBe(0);
+            expect(teletext.colPtr).toBe(0);
+        });
+
+        it("should wrap to frame 0 when reaching end of frames", () => {
+            // Set to last frame
+            teletext.currentFrame = 4;
+            teletext.totalFrames = 5;
+
+            // Call update
+            teletext.update();
+
+            // Check frame wrapped to 0
+            expect(teletext.currentFrame).toBe(0);
+        });
+
+        it("should generate interrupt if interrupts enabled", () => {
+            // Enable interrupts
+            teletext.teletextInts = true;
+
+            // Clear interrupt
+            mockCpu.interrupt = 0;
+
+            // Call update
+            teletext.update();
+
+            // Check interrupt was generated
+            expect(mockCpu.interrupt & (1 << TELETEXT_IRQ)).toBe(1 << TELETEXT_IRQ);
+        });
+
+        it("should not generate interrupt if interrupts disabled", () => {
+            // Disable interrupts
+            teletext.teletextInts = false;
+
+            // Clear interrupt
+            mockCpu.interrupt = 0;
+
+            // Call update
+            teletext.update();
+
+            // Check interrupt wasn't generated
+            expect(mockCpu.interrupt & (1 << TELETEXT_IRQ)).toBe(0);
+        });
+
+        it("should trigger update when poll cycles exceed threshold", () => {
+            // Mock update method
+            const updateSpy = vi.spyOn(teletext, "update");
+
+            // Poll with cycles just below threshold (50000)
+            teletext.pollCount = 0;
+            teletext.polltime(49999);
+
+            // Check update wasn't called
+            expect(updateSpy).not.toHaveBeenCalled();
+
+            // Poll with cycles to exceed threshold
+            teletext.polltime(2);
+
+            // Check update was called
+            expect(updateSpy).toHaveBeenCalled();
+
+            // Check poll count was reset
+            expect(teletext.pollCount).toBe(0);
+        });
+
+        it("should not update when CPU reset line is low", () => {
+            // Set CPU reset line low
+            mockCpu.resetLine = false;
+
+            // Mock update method
+            const updateSpy = vi.spyOn(teletext, "update");
+
+            // Poll with cycles to exceed threshold
+            teletext.pollCount = 0;
+            teletext.polltime(50001);
+
+            // Check update wasn't called
+            expect(updateSpy).not.toHaveBeenCalled();
+
+            // Check poll count was set to negative value
+            expect(teletext.pollCount).toBeLessThan(0);
+        });
+    });
+});