ac6502 1.0.0

package/src/tests/Cart.test.ts

@@ -0,0 +1,149 @@
+import { Cart } from '../components/Cart'
+
+describe('Cart', () => {
+  let cart: Cart
+
+  beforeEach(() => {
+    cart = new Cart()
+  })
+
+  describe('Static Properties', () => {
+    test('should have correct START address', () => {
+      expect(Cart.START).toBe(0x8000)
+    })
+
+    test('should have correct END address', () => {
+      expect(Cart.END).toBe(0xFFFF)
+    })
+
+    test('should have correct CODE address', () => {
+      expect(Cart.CODE).toBe(0xC000)
+    })
+
+    test('should have correct SIZE', () => {
+      expect(Cart.SIZE).toBe(0x8000)
+      expect(Cart.SIZE).toBe(Cart.END - Cart.START + 1)
+    })
+  })
+
+  describe('Initialization', () => {
+    test('should create a new Cart instance', () => {
+      expect(cart).not.toBeNull()
+      expect(cart).toBeInstanceOf(Cart)
+    })
+
+    test('should initialize data array with correct size', () => {
+      expect(cart.data).toHaveLength(Cart.SIZE)
+    })
+
+    test('should initialize all data to 0x00', () => {
+      for (let i = 0; i < cart.data.length; i++) {
+        expect(cart.data[i]).toBe(0x00)
+      }
+    })
+  })
+
+  describe('read()', () => {
+    test('should read data from address', () => {
+      cart.data[0x0000] = 0x42
+      expect(cart.read(0x0000)).toBe(0x42)
+    })
+
+    test('should read 0x00 from uninitialized address', () => {
+      expect(cart.read(0x1000)).toBe(0x00)
+    })
+
+    test('should read from first address', () => {
+      cart.data[0] = 0xAA
+      expect(cart.read(0)).toBe(0xAA)
+    })
+
+    test('should read from last address', () => {
+      cart.data[Cart.SIZE - 1] = 0xBB
+      expect(cart.read(Cart.SIZE - 1)).toBe(0xBB)
+    })
+
+    test('should read multiple different values', () => {
+      cart.data[0x1000] = 0x12
+      cart.data[0x2000] = 0x34
+      cart.data[0x3000] = 0x56
+      
+      expect(cart.read(0x1000)).toBe(0x12)
+      expect(cart.read(0x2000)).toBe(0x34)
+      expect(cart.read(0x3000)).toBe(0x56)
+    })
+  })
+
+  describe('load()', () => {
+    test('should load data array with correct size', () => {
+      const testData = new Array(Cart.SIZE).fill(0xFF)
+      cart.load(testData)
+      
+      expect(cart.data).toBe(testData)
+      expect(cart.data[0]).toBe(0xFF)
+      expect(cart.data[Cart.SIZE - 1]).toBe(0xFF)
+    })
+
+    test('should not load data array with incorrect size (too small)', () => {
+      const originalData = [...cart.data]
+      const testData = new Array(Cart.SIZE - 1).fill(0xFF)
+      
+      cart.load(testData)
+      
+      expect(cart.data).toEqual(originalData)
+      expect(cart.data).not.toBe(testData)
+    })
+
+    test('should not load data array with incorrect size (too large)', () => {
+      const originalData = [...cart.data]
+      const testData = new Array(Cart.SIZE + 1).fill(0xFF)
+      
+      cart.load(testData)
+      
+      expect(cart.data).toEqual(originalData)
+      expect(cart.data).not.toBe(testData)
+    })
+
+    test('should not load empty array', () => {
+      const originalData = [...cart.data]
+      cart.load([])
+      
+      expect(cart.data).toEqual(originalData)
+    })
+
+    test('should load data with specific pattern', () => {
+      const testData = new Array(Cart.SIZE).fill(0x00).map((_, i) => i & 0xFF)
+      cart.load(testData)
+      
+      for (let i = 0; i < 256; i++) {
+        expect(cart.read(i)).toBe(i)
+      }
+    })
+
+    test('should replace existing data when loading', () => {
+      // Set some initial data directly
+      cart.data[0x0000] = 0xAA
+      cart.data[0x1000] = 0xBB
+      cart.data[0x2000] = 0xCC
+      
+      // Load new data
+      const testData = new Array(Cart.SIZE).fill(0x55)
+      cart.load(testData)
+      
+      expect(cart.read(0x0000)).toBe(0x55)
+      expect(cart.read(0x1000)).toBe(0x55)
+      expect(cart.read(0x2000)).toBe(0x55)
+    })
+
+    test('should allow reading loaded data', () => {
+      const testData = new Array(Cart.SIZE).fill(0x00)
+      testData[0x1234] = 0xAB
+      testData[0x5678] = 0xCD
+      
+      cart.load(testData)
+      
+      expect(cart.read(0x1234)).toBe(0xAB)
+      expect(cart.read(0x5678)).toBe(0xCD)
+    })
+  })
+})

package/src/tests/IO/GPIOAttachments/GPIOAttachment.test.ts

@@ -0,0 +1,413 @@
+import { GPIOAttachment, GPIOAttachmentBase } from '../../../components/IO/GPIOAttachments/GPIOAttachment'
+
+/**
+ * Concrete implementation of GPIOAttachmentBase for testing
+ */
+class TestGPIOAttachment extends GPIOAttachmentBase {
+  public portAValue: number = 0xFF
+  public portBValue: number = 0xFF
+  public tickCount: number = 0
+  public writeAValue: number = 0
+  public writeBValue: number = 0
+
+  constructor(
+    priority: number = 0,
+    ca1Interrupt: boolean = false,
+    ca2Interrupt: boolean = false,
+    cb1Interrupt: boolean = false,
+    cb2Interrupt: boolean = false
+  ) {
+    super(priority, ca1Interrupt, ca2Interrupt, cb1Interrupt, cb2Interrupt)
+  }
+
+  readPortA(ddr: number, or: number): number {
+    return this.portAValue
+  }
+
+  readPortB(ddr: number, or: number): number {
+    return this.portBValue
+  }
+
+  writePortA(value: number, ddr: number): void {
+    this.writeAValue = value
+  }
+
+  writePortB(value: number, ddr: number): void {
+    this.writeBValue = value
+  }
+
+  tick(cpuFrequency: number): void {
+    this.tickCount++
+  }
+
+  // Expose protected members for testing
+  public setCA1Interrupt(value: boolean): void {
+    this.ca1Interrupt = value
+  }
+
+  public setCA2Interrupt(value: boolean): void {
+    this.ca2Interrupt = value
+  }
+
+  public setCB1Interrupt(value: boolean): void {
+    this.cb1Interrupt = value
+  }
+
+  public setCB2Interrupt(value: boolean): void {
+    this.cb2Interrupt = value
+  }
+
+  public setEnabled(value: boolean): void {
+    this.enabled = value
+  }
+}
+
+describe('GPIOAttachmentBase', () => {
+  let attachment: TestGPIOAttachment
+
+  beforeEach(() => {
+    attachment = new TestGPIOAttachment()
+  })
+
+  describe('Initialization', () => {
+    it('should initialize with default priority 0', () => {
+      expect(attachment.getPriority()).toBe(0)
+    })
+
+    it('should initialize with custom priority', () => {
+      const customAttachment = new TestGPIOAttachment(5)
+      expect(customAttachment.getPriority()).toBe(5)
+    })
+
+    it('should initialize as enabled', () => {
+      expect(attachment.isEnabled()).toBe(true)
+    })
+
+    it('should initialize with no interrupts pending', () => {
+      expect(attachment.hasCA1Interrupt()).toBe(false)
+      expect(attachment.hasCA2Interrupt()).toBe(false)
+      expect(attachment.hasCB1Interrupt()).toBe(false)
+      expect(attachment.hasCB2Interrupt()).toBe(false)
+    })
+
+    it('should initialize with specified interrupt states', () => {
+      const interruptAttachment = new TestGPIOAttachment(0, true, true, true, true)
+      expect(interruptAttachment.hasCA1Interrupt()).toBe(true)
+      expect(interruptAttachment.hasCA2Interrupt()).toBe(true)
+      expect(interruptAttachment.hasCB1Interrupt()).toBe(true)
+      expect(interruptAttachment.hasCB2Interrupt()).toBe(true)
+    })
+  })
+
+  describe('Reset', () => {
+    it('should reset to enabled state', () => {
+      attachment.setEnabled(false)
+      attachment.reset()
+      expect(attachment.isEnabled()).toBe(true)
+    })
+
+    it('should clear all interrupt flags', () => {
+      attachment.setCA1Interrupt(true)
+      attachment.setCA2Interrupt(true)
+      attachment.setCB1Interrupt(true)
+      attachment.setCB2Interrupt(true)
+
+      attachment.reset()
+
+      expect(attachment.hasCA1Interrupt()).toBe(false)
+      expect(attachment.hasCA2Interrupt()).toBe(false)
+      expect(attachment.hasCB1Interrupt()).toBe(false)
+      expect(attachment.hasCB2Interrupt()).toBe(false)
+    })
+
+    it('should maintain priority after reset', () => {
+      const priorityAttachment = new TestGPIOAttachment(10)
+      priorityAttachment.reset()
+      expect(priorityAttachment.getPriority()).toBe(10)
+    })
+  })
+
+  describe('Priority', () => {
+    it('should return correct priority value', () => {
+      const lowPriority = new TestGPIOAttachment(0)
+      const highPriority = new TestGPIOAttachment(10)
+
+      expect(lowPriority.getPriority()).toBe(0)
+      expect(highPriority.getPriority()).toBe(10)
+    })
+
+    it('should support negative priority values', () => {
+      const negativePriority = new TestGPIOAttachment(-5)
+      expect(negativePriority.getPriority()).toBe(-5)
+    })
+  })
+
+  describe('Enable/Disable', () => {
+    it('should start enabled', () => {
+      expect(attachment.isEnabled()).toBe(true)
+    })
+
+    it('should be disableable', () => {
+      attachment.setEnabled(false)
+      expect(attachment.isEnabled()).toBe(false)
+    })
+
+    it('should be re-enableable', () => {
+      attachment.setEnabled(false)
+      attachment.setEnabled(true)
+      expect(attachment.isEnabled()).toBe(true)
+    })
+  })
+
+  describe('Tick', () => {
+    it('should call tick method', () => {
+      attachment.tick(1000000)
+      expect(attachment.tickCount).toBe(1)
+    })
+
+    it('should call tick multiple times', () => {
+      attachment.tick(1000000)
+      attachment.tick(1000000)
+      attachment.tick(1000000)
+      expect(attachment.tickCount).toBe(3)
+    })
+
+    it('should accept different CPU frequencies', () => {
+      attachment.tick(1000000)
+      attachment.tick(2000000)
+      attachment.tick(4000000)
+      expect(attachment.tickCount).toBe(3)
+    })
+  })
+
+  describe('Port Reading', () => {
+    it('should read from Port A', () => {
+      attachment.portAValue = 0xAA
+      expect(attachment.readPortA(0xFF, 0x00)).toBe(0xAA)
+    })
+
+    it('should read from Port B', () => {
+      attachment.portBValue = 0x55
+      expect(attachment.readPortB(0xFF, 0x00)).toBe(0x55)
+    })
+
+    it('should handle DDR parameter in Port A read', () => {
+      attachment.portAValue = 0xFF
+      expect(attachment.readPortA(0x00, 0x00)).toBe(0xFF)
+      expect(attachment.readPortA(0xFF, 0x00)).toBe(0xFF)
+    })
+
+    it('should handle OR parameter in Port A read', () => {
+      attachment.portAValue = 0xFF
+      expect(attachment.readPortA(0xFF, 0x00)).toBe(0xFF)
+      expect(attachment.readPortA(0xFF, 0xFF)).toBe(0xFF)
+    })
+  })
+
+  describe('Port Writing', () => {
+    it('should write to Port A', () => {
+      attachment.writePortA(0xAA, 0xFF)
+      expect(attachment.writeAValue).toBe(0xAA)
+    })
+
+    it('should write to Port B', () => {
+      attachment.writePortB(0x55, 0xFF)
+      expect(attachment.writeBValue).toBe(0x55)
+    })
+
+    it('should handle DDR parameter in Port A write', () => {
+      attachment.writePortA(0xAA, 0x0F)
+      expect(attachment.writeAValue).toBe(0xAA)
+    })
+
+    it('should handle DDR parameter in Port B write', () => {
+      attachment.writePortB(0x55, 0xF0)
+      expect(attachment.writeBValue).toBe(0x55)
+    })
+
+    it('should handle multiple writes to same port', () => {
+      attachment.writePortA(0xAA, 0xFF)
+      attachment.writePortA(0x55, 0xFF)
+      expect(attachment.writeAValue).toBe(0x55)
+    })
+  })
+
+  describe('Interrupt Management - CA1', () => {
+    it('should check CA1 interrupt flag', () => {
+      expect(attachment.hasCA1Interrupt()).toBe(false)
+      attachment.setCA1Interrupt(true)
+      expect(attachment.hasCA1Interrupt()).toBe(true)
+    })
+
+    it('should clear CA1 interrupt', () => {
+      attachment.setCA1Interrupt(true)
+      attachment.clearInterrupts(true, false, false, false)
+      expect(attachment.hasCA1Interrupt()).toBe(false)
+    })
+
+    it('should not clear CA1 when clearing other interrupts', () => {
+      attachment.setCA1Interrupt(true)
+      attachment.clearInterrupts(false, true, true, true)
+      expect(attachment.hasCA1Interrupt()).toBe(true)
+    })
+  })
+
+  describe('Interrupt Management - CA2', () => {
+    it('should check CA2 interrupt flag', () => {
+      expect(attachment.hasCA2Interrupt()).toBe(false)
+      attachment.setCA2Interrupt(true)
+      expect(attachment.hasCA2Interrupt()).toBe(true)
+    })
+
+    it('should clear CA2 interrupt', () => {
+      attachment.setCA2Interrupt(true)
+      attachment.clearInterrupts(false, true, false, false)
+      expect(attachment.hasCA2Interrupt()).toBe(false)
+    })
+
+    it('should not clear CA2 when clearing other interrupts', () => {
+      attachment.setCA2Interrupt(true)
+      attachment.clearInterrupts(true, false, true, true)
+      expect(attachment.hasCA2Interrupt()).toBe(true)
+    })
+  })
+
+  describe('Interrupt Management - CB1', () => {
+    it('should check CB1 interrupt flag', () => {
+      expect(attachment.hasCB1Interrupt()).toBe(false)
+      attachment.setCB1Interrupt(true)
+      expect(attachment.hasCB1Interrupt()).toBe(true)
+    })
+
+    it('should clear CB1 interrupt', () => {
+      attachment.setCB1Interrupt(true)
+      attachment.clearInterrupts(false, false, true, false)
+      expect(attachment.hasCB1Interrupt()).toBe(false)
+    })
+
+    it('should not clear CB1 when clearing other interrupts', () => {
+      attachment.setCB1Interrupt(true)
+      attachment.clearInterrupts(true, true, false, true)
+      expect(attachment.hasCB1Interrupt()).toBe(true)
+    })
+  })
+
+  describe('Interrupt Management - CB2', () => {
+    it('should check CB2 interrupt flag', () => {
+      expect(attachment.hasCB2Interrupt()).toBe(false)
+      attachment.setCB2Interrupt(true)
+      expect(attachment.hasCB2Interrupt()).toBe(true)
+    })
+
+    it('should clear CB2 interrupt', () => {
+      attachment.setCB2Interrupt(true)
+      attachment.clearInterrupts(false, false, false, true)
+      expect(attachment.hasCB2Interrupt()).toBe(false)
+    })
+
+    it('should not clear CB2 when clearing other interrupts', () => {
+      attachment.setCB2Interrupt(true)
+      attachment.clearInterrupts(true, true, true, false)
+      expect(attachment.hasCB2Interrupt()).toBe(true)
+    })
+  })
+
+  describe('Interrupt Management - Multiple', () => {
+    it('should clear multiple interrupts at once', () => {
+      attachment.setCA1Interrupt(true)
+      attachment.setCA2Interrupt(true)
+      attachment.setCB1Interrupt(true)
+      attachment.setCB2Interrupt(true)
+
+      attachment.clearInterrupts(true, true, false, false)
+
+      expect(attachment.hasCA1Interrupt()).toBe(false)
+      expect(attachment.hasCA2Interrupt()).toBe(false)
+      expect(attachment.hasCB1Interrupt()).toBe(true)
+      expect(attachment.hasCB2Interrupt()).toBe(true)
+    })
+
+    it('should clear all interrupts', () => {
+      attachment.setCA1Interrupt(true)
+      attachment.setCA2Interrupt(true)
+      attachment.setCB1Interrupt(true)
+      attachment.setCB2Interrupt(true)
+
+      attachment.clearInterrupts(true, true, true, true)
+
+      expect(attachment.hasCA1Interrupt()).toBe(false)
+      expect(attachment.hasCA2Interrupt()).toBe(false)
+      expect(attachment.hasCB1Interrupt()).toBe(false)
+      expect(attachment.hasCB2Interrupt()).toBe(false)
+    })
+
+    it('should handle clearing when no interrupts are set', () => {
+      attachment.clearInterrupts(true, true, true, true)
+
+      expect(attachment.hasCA1Interrupt()).toBe(false)
+      expect(attachment.hasCA2Interrupt()).toBe(false)
+      expect(attachment.hasCB1Interrupt()).toBe(false)
+      expect(attachment.hasCB2Interrupt()).toBe(false)
+    })
+  })
+
+  describe('Control Lines', () => {
+    it('should call updateControlLines', () => {
+      // Default implementation does nothing, just verify it doesn't crash
+      expect(() => {
+        attachment.updateControlLines(true, false, true, false)
+      }).not.toThrow()
+    })
+
+    it('should accept all control line combinations', () => {
+      expect(() => {
+        attachment.updateControlLines(false, false, false, false)
+        attachment.updateControlLines(true, true, true, true)
+        attachment.updateControlLines(true, false, true, false)
+        attachment.updateControlLines(false, true, false, true)
+      }).not.toThrow()
+    })
+  })
+
+  describe('Edge Cases', () => {
+    it('should handle rapid enable/disable cycles', () => {
+      for (let i = 0; i < 100; i++) {
+        attachment.setEnabled(i % 2 === 0)
+      }
+      // Last iteration (i=99) sets enabled to false (99 % 2 !== 0)
+      expect(attachment.isEnabled()).toBe(false)
+    })
+
+    it('should handle rapid interrupt set/clear cycles', () => {
+      for (let i = 0; i < 100; i++) {
+        attachment.setCA1Interrupt(true)
+        attachment.clearInterrupts(true, false, false, false)
+      }
+      expect(attachment.hasCA1Interrupt()).toBe(false)
+    })
+
+    it('should handle reset during active interrupts', () => {
+      attachment.setCA1Interrupt(true)
+      attachment.setCA2Interrupt(true)
+      attachment.setCB1Interrupt(true)
+      attachment.setCB2Interrupt(true)
+
+      attachment.reset()
+
+      expect(attachment.hasCA1Interrupt()).toBe(false)
+      expect(attachment.hasCA2Interrupt()).toBe(false)
+      expect(attachment.hasCB1Interrupt()).toBe(false)
+      expect(attachment.hasCB2Interrupt()).toBe(false)
+    })
+
+    it('should maintain state across multiple operations', () => {
+      attachment.setCA1Interrupt(true)
+      attachment.tick(1000000)
+      attachment.writePortA(0xAA, 0xFF)
+      
+      expect(attachment.hasCA1Interrupt()).toBe(true)
+      expect(attachment.tickCount).toBe(1)
+      expect(attachment.writeAValue).toBe(0xAA)
+    })
+  })
+})

package/src/tests/IO/GPIOAttachments/GPIOJoystickAttachment.test.ts

@@ -0,0 +1,147 @@
+import { GPIOJoystickAttachment } from '../../../components/IO/GPIOAttachments/GPIOJoystickAttachment'
+
+describe('GPIOJoystickAttachment', () => {
+  let joystick: GPIOJoystickAttachment
+
+  beforeEach(() => {
+    joystick = new GPIOJoystickAttachment(true, 0)
+  })
+
+  describe('constructor and reset', () => {
+    it('should initialize with no buttons pressed', () => {
+      expect(joystick.getButtonState()).toBe(0x00)
+    })
+
+    it('should reset button state', () => {
+      joystick.updateJoystick(0xFF)
+      joystick.reset()
+      expect(joystick.getButtonState()).toBe(0x00)
+    })
+  })
+
+  describe('button state management', () => {
+    it('should update joystick state', () => {
+      joystick.updateJoystick(0x55)
+      expect(joystick.getButtonState()).toBe(0x55)
+    })
+
+    it('should check if button is pressed', () => {
+      joystick.pressButton(GPIOJoystickAttachment.BUTTON_A)
+      expect(joystick.isButtonPressed(GPIOJoystickAttachment.BUTTON_A)).toBe(true)
+      expect(joystick.isButtonPressed(GPIOJoystickAttachment.BUTTON_B)).toBe(false)
+    })
+
+    it('should press a button', () => {
+      joystick.pressButton(GPIOJoystickAttachment.BUTTON_START)
+      expect(joystick.getButtonState()).toBe(GPIOJoystickAttachment.BUTTON_START)
+    })
+
+    it('should release a button', () => {
+      joystick.updateJoystick(0xFF)
+      joystick.releaseButton(GPIOJoystickAttachment.BUTTON_A)
+      expect(joystick.getButtonState()).toBe(0xFF & ~GPIOJoystickAttachment.BUTTON_A)
+    })
+
+    it('should release all buttons', () => {
+      joystick.updateJoystick(0xFF)
+      joystick.releaseAllButtons()
+      expect(joystick.getButtonState()).toBe(0x00)
+    })
+  })
+
+  describe('port reading - Port A', () => {
+    beforeEach(() => {
+      joystick = new GPIOJoystickAttachment(true, 0) // Attach to Port A
+    })
+
+    it('should return inverted button state on Port A when attached', () => {
+      joystick.updateJoystick(0x00) // No buttons pressed
+      expect(joystick.readPortA(0x00, 0x00)).toBe(0xFF) // All bits high (active-low)
+    })
+
+    it('should return active-low values when buttons pressed', () => {
+      joystick.updateJoystick(0xFF) // All buttons pressed
+      expect(joystick.readPortA(0x00, 0x00)).toBe(0x00) // All bits low
+    })
+
+    it('should return FF on Port B when attached to Port A', () => {
+      joystick.updateJoystick(0xFF)
+      expect(joystick.readPortB(0x00, 0x00)).toBe(0xFF)
+    })
+
+    it('should handle individual button presses correctly', () => {
+      joystick.updateJoystick(GPIOJoystickAttachment.BUTTON_UP)
+      const result = joystick.readPortA(0x00, 0x00)
+      expect(result & 0x01).toBe(0x00) // UP button bit should be low (pressed)
+      expect(result & 0xFE).toBe(0xFE) // Other bits should be high (not pressed)
+    })
+  })
+
+  describe('port reading - Port B', () => {
+    beforeEach(() => {
+      joystick = new GPIOJoystickAttachment(false, 0) // Attach to Port B
+    })
+
+    it('should return inverted button state on Port B when attached', () => {
+      joystick.updateJoystick(0x00)
+      expect(joystick.readPortB(0x00, 0x00)).toBe(0xFF)
+    })
+
+    it('should return active-low values when buttons pressed on Port B', () => {
+      joystick.updateJoystick(0xFF)
+      expect(joystick.readPortB(0x00, 0x00)).toBe(0x00)
+    })
+
+    it('should return FF on Port A when attached to Port B', () => {
+      joystick.updateJoystick(0xFF)
+      expect(joystick.readPortA(0x00, 0x00)).toBe(0xFF)
+    })
+  })
+
+  describe('button constants', () => {
+    it('should have correct button bit values', () => {
+      expect(GPIOJoystickAttachment.BUTTON_UP).toBe(0x01)
+      expect(GPIOJoystickAttachment.BUTTON_DOWN).toBe(0x02)
+      expect(GPIOJoystickAttachment.BUTTON_LEFT).toBe(0x04)
+      expect(GPIOJoystickAttachment.BUTTON_RIGHT).toBe(0x08)
+      expect(GPIOJoystickAttachment.BUTTON_A).toBe(0x10)
+      expect(GPIOJoystickAttachment.BUTTON_B).toBe(0x20)
+      expect(GPIOJoystickAttachment.BUTTON_SELECT).toBe(0x40)
+      expect(GPIOJoystickAttachment.BUTTON_START).toBe(0x80)
+    })
+  })
+
+  describe('priority and enabled', () => {
+    it('should return correct priority', () => {
+      const j = new GPIOJoystickAttachment(true, 5)
+      expect(j.getPriority()).toBe(5)
+    })
+
+    it('should be enabled by default', () => {
+      expect(joystick.isEnabled()).toBe(true)
+    })
+  })
+
+  describe('interrupts', () => {
+    it('should not have any interrupts by default', () => {
+      expect(joystick.hasCA1Interrupt()).toBe(false)
+      expect(joystick.hasCA2Interrupt()).toBe(false)
+      expect(joystick.hasCB1Interrupt()).toBe(false)
+      expect(joystick.hasCB2Interrupt()).toBe(false)
+    })
+
+    it('should clear interrupts (no-op for joystick)', () => {
+      expect(() => {
+        joystick.clearInterrupts(true, true, true, true)
+      }).not.toThrow()
+    })
+  })
+
+  describe('tick', () => {
+    it('should not throw on tick', () => {
+      expect(() => {
+        joystick.tick(1000000)
+      }).not.toThrow()
+    })
+  })
+})