jsbeeb 1.1.1

package/tests/unit/test-adc.js

@@ -0,0 +1,307 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { Adc } from "../../src/adc.js";
+import { AnalogueSource } from "../../src/analogue-source.js";
+
+// Create a mock gamepad source for testing
+class MockGamepadSource extends AnalogueSource {
+    constructor() {
+        super();
+        this.mockValues = {
+            0: 0x3fff, // Channel 0: halfway (0.5) -> 0x3fff
+            1: 0xffff, // Channel 1: max (-1.0) -> 0xffff
+            2: 0x5fff, // Channel 2: quarter (0.25) -> 0x5fff
+            3: 0xdfff, // Channel 3: three quarters (-0.75) -> 0xdfff
+        };
+    }
+
+    getValue(channel) {
+        return this.mockValues[channel] || 0x8000;
+    }
+}
+
+describe("ADC", () => {
+    // Mock dependencies
+    const mockSysvia = {
+        setcb1: vi.fn(),
+    };
+
+    const mockScheduler = {
+        newTask: vi.fn().mockImplementation((callback) => ({
+            schedule: vi.fn(),
+            cancel: vi.fn(),
+            callback,
+        })),
+    };
+
+    let adc;
+    let mockTask;
+    let mockGamepadSource;
+
+    beforeEach(() => {
+        // Reset mocks
+        vi.resetAllMocks();
+
+        // Create a mock task that stores the callback
+        mockTask = {
+            schedule: vi.fn(),
+            cancel: vi.fn(),
+        };
+        mockScheduler.newTask.mockReturnValue(mockTask);
+
+        // Create a fresh ADC instance
+        adc = new Adc(mockSysvia, mockScheduler);
+
+        mockGamepadSource = new MockGamepadSource();
+        adc.setChannelSource(0, mockGamepadSource);
+        adc.setChannelSource(1, mockGamepadSource);
+        adc.setChannelSource(2, mockGamepadSource);
+        adc.setChannelSource(3, mockGamepadSource);
+    });
+
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+
+    describe("Initialization", () => {
+        it("should initialize with default state", () => {
+            expect(adc.status).toBe(0x40);
+            expect(adc.low).toBe(0x00);
+            expect(adc.high).toBe(0x00);
+            expect(mockScheduler.newTask).toHaveBeenCalled();
+        });
+
+        it("should reset to default state", () => {
+            // Change state
+            adc.status = 0xff;
+            adc.low = 0xff;
+            adc.high = 0xff;
+
+            // Reset
+            adc.reset();
+
+            // Check state is back to default
+            expect(adc.status).toBe(0x40);
+            expect(adc.low).toBe(0x00);
+            expect(adc.high).toBe(0x00);
+        });
+    });
+
+    describe("Reading registers", () => {
+        it("should read status register (addr 0)", () => {
+            adc.status = 0x42;
+            expect(adc.read(0)).toBe(0x42);
+        });
+
+        it("should read high byte register (addr 1)", () => {
+            adc.high = 0x42;
+            expect(adc.read(1)).toBe(0x42);
+        });
+
+        it("should read low byte register (addr 2)", () => {
+            adc.low = 0x42;
+            expect(adc.read(2)).toBe(0x42);
+        });
+
+        it("should return 0x40 for undefined register (addr 3)", () => {
+            expect(adc.read(3)).toBe(0x40);
+        });
+
+        it("should correctly mask address when reading", () => {
+            adc.status = 0x42;
+            adc.high = 0x43;
+            adc.low = 0x44;
+
+            expect(adc.read(4)).toBe(0x42); // 4 & 3 = 0
+            expect(adc.read(5)).toBe(0x43); // 5 & 3 = 1
+            expect(adc.read(6)).toBe(0x44); // 6 & 3 = 2
+            expect(adc.read(7)).toBe(0x40); // 7 & 3 = 3
+        });
+    });
+
+    describe("Writing to control register", () => {
+        it("should ignore writes to non-control registers", () => {
+            // Write to addresses 1, 2, 3
+            adc.write(1, 0x42);
+            adc.write(2, 0x42);
+            adc.write(3, 0x42);
+
+            // Verify no conversion was started
+            expect(mockTask.cancel).not.toHaveBeenCalled();
+            expect(mockTask.schedule).not.toHaveBeenCalled();
+            expect(mockSysvia.setcb1).not.toHaveBeenCalled();
+        });
+
+        it("should start 8-bit conversion on write to control register", () => {
+            adc.write(0, 0x00); // 8-bit conversion (bit 3 not set)
+
+            expect(mockTask.cancel).toHaveBeenCalled();
+            expect(mockTask.schedule).toHaveBeenCalledWith(8000); // 8ms for 8-bit
+            expect(adc.status).toBe(0x80); // Busy bit set
+            expect(mockSysvia.setcb1).toHaveBeenCalledWith(true);
+        });
+
+        it("should start 10-bit conversion on write to control register", () => {
+            adc.write(0, 0x08); // 10-bit conversion (bit 3 set)
+
+            expect(mockTask.cancel).toHaveBeenCalled();
+            expect(mockTask.schedule).toHaveBeenCalledWith(20000); // 20ms for 10-bit
+            expect(adc.status).toBe(0x88); // Busy bit set, bit 3 set
+            expect(mockSysvia.setcb1).toHaveBeenCalledWith(true);
+        });
+
+        it("should store channel number in status register", () => {
+            adc.write(0, 0x02); // Channel 2
+            expect(adc.status & 0x0f).toBe(0x02);
+
+            adc.write(0, 0x03); // Channel 3
+            expect(adc.status & 0x0f).toBe(0x03);
+        });
+
+        it("should correctly mask address when writing", () => {
+            adc.write(4, 0x01); // 4 & 3 = 0
+            expect(adc.status & 0x0f).toBe(0x01);
+
+            // These should be ignored
+            adc.write(5, 0x02); // 5 & 3 = 1
+            adc.write(6, 0x03); // 6 & 3 = 2
+            adc.write(7, 0x04); // 7 & 3 = 3
+
+            // Status should still reflect the last valid write
+            expect(adc.status & 0x0f).toBe(0x01);
+        });
+    });
+
+    describe("Analogue sources", () => {
+        it("should set and get a channel source", () => {
+            const newSource = new MockGamepadSource();
+            const result = adc.setChannelSource(1, newSource);
+            expect(result).toBe(true);
+            expect(adc.getChannelSource(1)).toBe(newSource);
+        });
+
+        it("should clear a channel source", () => {
+            const result = adc.clearChannelSource(2);
+            expect(result).toBe(true);
+            expect(adc.getChannelSource(2)).toBe(null);
+        });
+
+        it("should clear all sources", () => {
+            adc.clearSources();
+            for (let i = 0; i < 4; i++) {
+                expect(adc.getChannelSource(i)).toBe(null);
+            }
+        });
+    });
+
+    describe("Conversion completion", () => {
+        it("should handle completion with no source for the channel", () => {
+            adc.clearChannelSource(1);
+
+            // Set up a conversion for channel 1
+            adc.write(0, 0x01);
+
+            // Reset mock to clearly see what happens during completion
+            mockSysvia.setcb1.mockReset();
+
+            // Simulate conversion completion
+            adc.onComplete();
+
+            // Check results
+            expect(adc.status & 0x80).toBe(0); // Busy bit cleared
+            expect(adc.status & 0x40).toBe(0x40); // End of conversion bit set
+            expect(adc.low).toBe(0); // Default value low byte
+            expect(adc.high).toBe(0x80); // Default value high byte (0x8000 >> 8)
+            expect(mockSysvia.setcb1).toHaveBeenCalledWith(false); // Interrupt cleared
+        });
+
+        it("should read from source on channel 0", () => {
+            // Set channel 0
+            adc.write(0, 0x00);
+
+            // Simulate conversion completion
+            adc.onComplete();
+
+            // Check that the mock value was used
+            const expectedValue = mockGamepadSource.getValue(0);
+            expect(adc.low).toBe(expectedValue & 0xff);
+            expect(adc.high).toBe((expectedValue >>> 8) & 0xff);
+        });
+
+        it("should read from source on channel 1", () => {
+            // Set channel 1
+            adc.write(0, 0x01);
+
+            // Simulate conversion completion
+            adc.onComplete();
+
+            // Check that the mock value was used
+            const expectedValue = mockGamepadSource.getValue(1);
+            expect(adc.low).toBe(expectedValue & 0xff);
+            expect(adc.high).toBe((expectedValue >>> 8) & 0xff);
+        });
+
+        it("should use specific source for each channel", () => {
+            // Create a special source for channel 2 with a different value
+            const specialSource = new MockGamepadSource();
+            specialSource.mockValues[2] = 0x1234; // Different value
+
+            // Set it as the source for channel 2
+            adc.setChannelSource(2, specialSource);
+
+            // Set channel 2
+            adc.write(0, 0x02);
+
+            // Simulate conversion completion
+            adc.onComplete();
+
+            // Should use the special source for channel 2
+            const expectedValue = specialSource.getValue(2);
+            expect(adc.low).toBe(expectedValue & 0xff);
+            expect(adc.high).toBe((expectedValue >>> 8) & 0xff);
+        });
+
+        it("should switch between different sources by channel", () => {
+            // Create two different sources with different values
+            const source1 = new MockGamepadSource();
+            source1.mockValues[2] = 0x1111;
+
+            const source2 = new MockGamepadSource();
+            source2.mockValues[3] = 0x2222;
+
+            // Set them for different channels
+            adc.setChannelSource(2, source1);
+            adc.setChannelSource(3, source2);
+
+            // Test channel 2 (should use source1)
+            adc.write(0, 0x02);
+            adc.onComplete();
+            expect(adc.low).toBe(0x11); // 0x1111 & 0xff
+            expect(adc.high).toBe(0x11); // (0x1111 >>> 8) & 0xff
+
+            // Test channel 3 (should use source2)
+            adc.write(0, 0x03);
+            adc.onComplete();
+            expect(adc.low).toBe(0x22); // 0x2222 & 0xff
+            expect(adc.high).toBe(0x22); // (0x2222 >>> 8) & 0xff
+        });
+
+        it("should update status bits correctly after conversion", () => {
+            // Set channel 2
+            adc.write(0, 0x02);
+
+            // Simulate conversion completion
+            adc.onComplete();
+
+            // Get the expected value from our mock source
+            const expectedValue = mockGamepadSource.getValue(2);
+
+            // The status should have:
+            // - bits 0-3: channel number (0)
+            // - bit 6: end of conversion bit (1)
+            // - bits 4-5: ((0x5fff >>> 10) & 0x03) = 0x01 (shifted to bit position)
+            const expectedStatus = (0x00 & 0x0f) | 0x40 | ((expectedValue >>> 10) & 0x03);
+
+            expect(adc.status).toBe(expectedStatus);
+        });
+    });
+});

package/tests/unit/test-bcd.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+
+import { fake65C12 } from "../../src/fake6502.js";
+
+const cpu = fake65C12();
+
+describe("BCD tests", function () {
+    "use strict";
+    it("handles 65c12sbc1", async function () {
+        await cpu.initialise();
+        cpu.p.reset();
+        cpu.p.d = true;
+        cpu.a = 0x90;
+        cpu.sbc(0x0b);
+        expect(cpu.p.v).toBe(false);
+        expect(cpu.p.c).toBe(true);
+        expect(cpu.a).toBe(126);
+    });
+
+    it("handles 65c12sbc2", async function () {
+        await cpu.initialise();
+        cpu.p.reset();
+        cpu.p.d = true;
+        cpu.a = 0x80;
+        cpu.sbc(0x01);
+        expect(cpu.p.v).toBe(true);
+        expect(cpu.p.c).toBe(true);
+        expect(cpu.a).toBe(120);
+    });
+});

package/tests/unit/test-cmos.js

@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { Cmos } from "../../src/cmos.js";
+
+describe("CMOS", () => {
+    // Mock persistence
+    const mockPersistence = {
+        load: vi.fn().mockReturnValue(null),
+        save: vi.fn(),
+    };
+
+    // Test date (2023-04-15T12:34:56)
+    const TEST_DATE = new Date(2023, 3, 15, 12, 34, 56);
+
+    // CMOS register addresses (from BBC Micro documentation)
+    const CMOS_ADDR = {
+        SECONDS: 0,
+        MINUTES: 2,
+        HOURS: 4,
+        DAY_OF_WEEK: 6,
+        DAY_OF_MONTH: 7,
+        MONTH: 8,
+        YEAR: 9,
+        // Non-RTC addresses for testing
+        CONFIG_1: 12,
+        CONFIG_2: 13,
+    };
+
+    // Constants from the hardware implementation
+    const PORT_B_ENABLE = 0x40; // Bit 6 of port B
+    const PORT_B_ADDR_SEL = 0x80; // Bit 7 of port B
+    const IC32_READ = 2; // Bit 1 of IC32
+    const IC32_DATA_SEL = 4; // Bit 2 of IC32
+
+    let cmos;
+
+    beforeEach(() => {
+        // Use fake timers for consistent date/time testing
+        vi.useFakeTimers();
+        vi.setSystemTime(TEST_DATE);
+
+        // Create a fresh CMOS instance for each test
+        cmos = new Cmos(mockPersistence);
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.resetAllMocks();
+    });
+
+    describe("Initialization", () => {
+        it("should initialize with persistence and save default values", () => {
+            expect(mockPersistence.save).toHaveBeenCalled();
+        });
+
+        it("should use custom persistence data if available", () => {
+            const customData = Array(48).fill(0x42);
+            mockPersistence.load.mockReturnValueOnce(customData);
+
+            const customCmos = new Cmos(mockPersistence);
+
+            // Reading from a non-RTC location should return our custom data
+            // First enable CMOS and set it up for reading
+            customCmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, CMOS_ADDR.CONFIG_1, 0);
+            customCmos.writeControl(PORT_B_ENABLE, CMOS_ADDR.CONFIG_1, 0);
+            customCmos.writeControl(PORT_B_ENABLE, 0, IC32_READ | IC32_DATA_SEL);
+
+            expect(customCmos.read()).toBe(0x42);
+        });
+
+        it("should apply CMOS override when provided", () => {
+            const cmosOverride = (store) => {
+                const newStore = [...store];
+                newStore[CMOS_ADDR.CONFIG_1] = 0x42;
+                return newStore;
+            };
+
+            const customCmos = new Cmos(mockPersistence, cmosOverride);
+
+            // Reading from the overridden location should return our custom value
+            // First enable CMOS and set it up for reading
+            customCmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, CMOS_ADDR.CONFIG_1, 0);
+            customCmos.writeControl(PORT_B_ENABLE, CMOS_ADDR.CONFIG_1, 0);
+            customCmos.writeControl(PORT_B_ENABLE, 0, IC32_READ | IC32_DATA_SEL);
+
+            expect(customCmos.read()).toBe(0x42);
+        });
+
+        it("should apply econet settings when provided", () => {
+            const econet = { stationId: 0x42 };
+            const customCmos = new Cmos(mockPersistence, null, econet);
+
+            // First read econet station ID (at address 0x0E)
+            customCmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, 0x0e, 0);
+            customCmos.writeControl(PORT_B_ENABLE, 0x0e, 0);
+            customCmos.writeControl(PORT_B_ENABLE, 0, IC32_READ | IC32_DATA_SEL);
+
+            expect(customCmos.read()).toBe(0x42);
+
+            // Then read FS ID (at address 0x0F)
+            customCmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, 0x0f, 0);
+            customCmos.writeControl(PORT_B_ENABLE, 0x0f, 0);
+            customCmos.writeControl(PORT_B_ENABLE, 0, IC32_READ | IC32_DATA_SEL);
+
+            expect(customCmos.read()).toBe(254);
+        });
+    });
+
+    describe("Reading and Writing non-RTC data", () => {
+        it("should return 0xFF when CMOS is disabled", () => {
+            // Don't enable CMOS (no PORT_B_ENABLE bit)
+            expect(cmos.read()).toBe(0xff);
+        });
+
+        it("should write and read from CMOS memory locations", () => {
+            // Set address to CONFIG_1 (addr 12)
+            cmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, CMOS_ADDR.CONFIG_1, 0);
+            cmos.writeControl(PORT_B_ENABLE, CMOS_ADDR.CONFIG_1, 0);
+
+            // Write value 0x42 to CONFIG_1
+            cmos.writeControl(PORT_B_ENABLE, 0x42, IC32_DATA_SEL);
+            cmos.writeControl(PORT_B_ENABLE, 0x42, 0);
+
+            // Read it back
+            cmos.writeControl(PORT_B_ENABLE, 0, IC32_READ | IC32_DATA_SEL);
+            expect(cmos.read()).toBe(0x42);
+
+            // Check persistence was called
+            expect(mockPersistence.save).toHaveBeenCalled();
+        });
+
+        it("should only read when properly configured", () => {
+            // Set address to CONFIG_2 (different than other tests)
+            cmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, CMOS_ADDR.CONFIG_2, 0);
+            cmos.writeControl(PORT_B_ENABLE, CMOS_ADDR.CONFIG_2, 0);
+
+            // Write a known test value
+            cmos.writeControl(PORT_B_ENABLE, 0x42, IC32_DATA_SEL);
+            cmos.writeControl(PORT_B_ENABLE, 0x42, 0);
+
+            // Without setting the read mode, should return 0xFF
+            expect(cmos.read()).toBe(0xff);
+
+            // With address select high, should return 0xFF
+            cmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, 0, IC32_READ);
+            expect(cmos.read()).toBe(0xff);
+
+            // With data select low, should return 0xFF
+            cmos.writeControl(PORT_B_ENABLE, 0, IC32_READ);
+            expect(cmos.read()).toBe(0xff);
+
+            // Make sure we're still pointing at the right address
+            cmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, CMOS_ADDR.CONFIG_2, 0);
+            cmos.writeControl(PORT_B_ENABLE, CMOS_ADDR.CONFIG_2, 0);
+
+            // With everything set correctly, should return the value
+            cmos.writeControl(PORT_B_ENABLE, 0, IC32_READ | IC32_DATA_SEL);
+            expect(cmos.read()).toBe(0x42);
+        });
+    });
+
+    describe("Reading RTC values", () => {
+        // Helper function to read a specific RTC register
+        function readRtcRegister(register) {
+            // Set address
+            cmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, register, 0);
+            cmos.writeControl(PORT_B_ENABLE, register, 0);
+
+            // Configure for reading
+            cmos.writeControl(PORT_B_ENABLE, 0, IC32_READ | IC32_DATA_SEL);
+
+            return cmos.read();
+        }
+
+        it("should read current time from RTC registers", () => {
+            // Helper function for BCD conversion (same as in cmos.js)
+            function toBcd(value) {
+                return parseInt(value.toString(10), 16);
+            }
+
+            // Test all RTC components
+            expect(readRtcRegister(CMOS_ADDR.SECONDS)).toBe(toBcd(TEST_DATE.getSeconds()));
+            expect(readRtcRegister(CMOS_ADDR.MINUTES)).toBe(toBcd(TEST_DATE.getMinutes()));
+            expect(readRtcRegister(CMOS_ADDR.HOURS)).toBe(toBcd(TEST_DATE.getHours()));
+            expect(readRtcRegister(CMOS_ADDR.DAY_OF_WEEK)).toBe(toBcd(TEST_DATE.getDay() + 1));
+            expect(readRtcRegister(CMOS_ADDR.DAY_OF_MONTH)).toBe(toBcd(TEST_DATE.getDate()));
+            expect(readRtcRegister(CMOS_ADDR.MONTH)).toBe(toBcd(TEST_DATE.getMonth() + 1));
+        });
+    });
+
+    describe("Setting RTC values", () => {
+        // Helper to read a specific RTC register
+        function readRtcRegister(register) {
+            cmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, register, 0);
+            cmos.writeControl(PORT_B_ENABLE, register, 0);
+            cmos.writeControl(PORT_B_ENABLE, 0, IC32_READ | IC32_DATA_SEL);
+            return cmos.read();
+        }
+
+        // Helper to write to a specific RTC register
+        function writeRtcRegister(register, value) {
+            cmos.writeControl(PORT_B_ENABLE | PORT_B_ADDR_SEL, register, 0);
+            cmos.writeControl(PORT_B_ENABLE, register, 0);
+            cmos.writeControl(PORT_B_ENABLE, value, IC32_DATA_SEL);
+            cmos.writeControl(PORT_B_ENABLE, value, 0);
+        }
+
+        it("should update RTC values when written", () => {
+            // Set hours to 10
+            writeRtcRegister(CMOS_ADDR.HOURS, 0x10);
+
+            // Advance time slightly to ensure changes take effect
+            vi.advanceTimersByTime(100);
+
+            // Read back hours
+            expect(readRtcRegister(CMOS_ADDR.HOURS)).toBe(0x10);
+
+            // Set minutes to 45
+            writeRtcRegister(CMOS_ADDR.MINUTES, 0x45);
+
+            // Advance time slightly
+            vi.advanceTimersByTime(100);
+
+            // Read back minutes
+            expect(readRtcRegister(CMOS_ADDR.MINUTES)).toBe(0x45);
+        });
+    });
+
+    describe("BCD Conversion Logic", () => {
+        it("should correctly convert between decimal and BCD", () => {
+            // Helper functions for BCD conversion (same as in cmos.js)
+            const toBcd = (value) => parseInt(value.toString(10), 16);
+            const fromBcd = (value) => parseInt(value.toString(16), 10);
+
+            // Test toBcd conversion
+            expect(toBcd(0)).toBe(0x00);
+            expect(toBcd(9)).toBe(0x09);
+            expect(toBcd(10)).toBe(0x10);
+            expect(toBcd(42)).toBe(0x42);
+            expect(toBcd(99)).toBe(0x99);
+
+            // Test fromBcd conversion
+            expect(fromBcd(0x00)).toBe(0);
+            expect(fromBcd(0x09)).toBe(9);
+            expect(fromBcd(0x10)).toBe(10);
+            expect(fromBcd(0x42)).toBe(42);
+            expect(fromBcd(0x99)).toBe(99);
+
+            // Test round-trips
+            for (let i = 0; i < 100; i++) {
+                expect(fromBcd(toBcd(i))).toBe(i);
+            }
+        });
+
+        it("should handle year century threshold correctly", () => {
+            const fromBcd = (value) => parseInt(value.toString(16), 10);
+
+            // Years 80-99 should use 1900 as base
+            expect(fromBcd(0x80) >= 80 ? 1900 : 2000).toBe(1900);
+            expect(fromBcd(0x99) >= 80 ? 1900 : 2000).toBe(1900);
+
+            // Years 00-79 should use 2000 as base
+            expect(fromBcd(0x00) >= 80 ? 1900 : 2000).toBe(2000);
+            expect(fromBcd(0x79) >= 80 ? 1900 : 2000).toBe(2000);
+        });
+    });
+});

package/tests/unit/test-disc-drive.js

@@ -0,0 +1,85 @@
+import { describe, it, expect } from "vitest";
+
+import { Disc, IbmDiscFormat } from "../../src/disc.js";
+import { DiscDrive } from "../../src/disc-drive.js";
+import { Scheduler } from "../../src/scheduler.js";
+
+describe("Disc drive tests", function () {
+    it("starts empty", () => {
+        const scheduler = new Scheduler();
+        const drive = new DiscDrive(0, scheduler);
+        expect(drive.trackLength).toBe(IbmDiscFormat.bytesPerTrack);
+        expect(drive.disc).toBeFalsy();
+        expect(drive.spinning).toBe(false);
+        drive.setPulsesCallback(() => {
+            expect.fail("no callbacks expected");
+        });
+        scheduler.polltime(1000000);
+    });
+    it("sets a disc", () => {
+        const scheduler = new Scheduler();
+        const drive = new DiscDrive(0, scheduler);
+        const disc = Disc.createBlank();
+        drive.setDisc(disc);
+        expect(drive.disc).toBe(disc);
+    });
+    it("calls back with pulses after spinning starts", () => {
+        const scheduler = new Scheduler();
+        const drive = new DiscDrive(0, scheduler);
+        drive.setDisc(0, Disc.createBlank());
+        drive.setPulsesCallback(() => {
+            expect.fail("no callbacks expected");
+        });
+        scheduler.polltime(1000000);
+        drive.startSpinning();
+        let numPulses = 0;
+        drive.setPulsesCallback(() => numPulses++);
+        scheduler.polltime(500);
+        expect(numPulses).toBe(4);
+        drive.stopSpinning();
+        drive.setPulsesCallback(() => {
+            expect.fail("no callbacks expected");
+        });
+        scheduler.polltime(1000000);
+    });
+    it("generates quasi random pulses with a blank disc", () => {
+        const scheduler = new Scheduler();
+        const drive = new DiscDrive(0, scheduler);
+        drive.setDisc(Disc.createBlank());
+        drive.getQuasiRandomPulses = () => {
+            return 0xdeadbeef;
+        };
+        let called = false;
+        drive.setPulsesCallback((pulses, numPulses) => {
+            called = true;
+            expect(numPulses).toBe(32);
+            expect(pulses).toBe(0xdeadbeef);
+        });
+        drive.startSpinning();
+        scheduler.polltime(1000000);
+        expect(called).toBe(true);
+    });
+    it("asserts index all the time with no disc", () => {
+        const scheduler = new Scheduler();
+        const drive = new DiscDrive(0, scheduler);
+        expect(drive.indexPulse).toBe(true);
+    });
+    it("asserts index periodically with a spinning disc", () => {
+        const scheduler = new Scheduler();
+        const drive = new DiscDrive(0, scheduler);
+        drive.setDisc(Disc.createBlank());
+        drive.startSpinning();
+        let previousIndex = drive.indexPulse;
+        let risingEdges = 0;
+        const cyclesPerSecond = 2 * 1000 * 1000;
+        const cyclesPerIter = cyclesPerSecond / 60;
+        const rpm = 300;
+        const testSeconds = 5;
+        for (let cycle = 0; cycle < testSeconds * cyclesPerSecond; cycle += cyclesPerIter) {
+            scheduler.polltime(cyclesPerIter);
+            if (drive.indexPulse && !previousIndex) risingEdges++;
+            previousIndex = drive.indexPulse;
+        }
+        expect(risingEdges).toBe((rpm / 60) * testSeconds);
+    });
+});