aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/controller_test.go119
-rw-r--r--tests/cpu_test.go143
-rw-r--r--tests/dma_test.go78
-rw-r--r--tests/ppu_sprite_test.go291
4 files changed, 623 insertions, 8 deletions
diff --git a/tests/controller_test.go b/tests/controller_test.go
new file mode 100644
index 0000000..026e68a
--- /dev/null
+++ b/tests/controller_test.go
@@ -0,0 +1,119 @@
+package tests
+
+import (
+ "testing"
+
+ "crecher.net/gones/v2/cart"
+ "crecher.net/gones/v2/nes"
+)
+
+func newTestConsole(t *testing.T) *nes.Console {
+ t.Helper()
+ c, err := cart.Load("testdata/nestest.nes")
+ if err != nil {
+ t.Fatal(err)
+ }
+ return nes.New(c)
+}
+
+func strobe(n *nes.Console) {
+ n.Write(0x4016, 1)
+ n.Write(0x4016, 0)
+}
+
+func readBits(n *nes.Console, addr uint16, count int) []uint8 {
+ bits := make([]uint8, count)
+ for i := range bits {
+ bits[i] = n.Read(addr) & 1
+ }
+ return bits
+}
+
+func equalBits(a, b []uint8) bool {
+ if len(a) != len(b) {
+ return false
+ }
+ for i := range a {
+ if a[i] != b[i] {
+ return false
+ }
+ }
+ return true
+}
+
+func TestControllerReadsButtonsInOrder(t *testing.T) {
+ n := newTestConsole(t)
+ n.SetButtons(0, nes.ButtonA|nes.ButtonStart|nes.ButtonRight)
+ strobe(n)
+
+ // +---------------------- A
+ // | +------------------- B
+ // | | +---------------- Select
+ // | | | +------------- Start
+ // | | | | +---------- Up
+ // | | | | | +------- Down
+ // | | | | | | +---- Left
+ // | | | | | | | +- Right
+ // | | | | | | | |
+ want := []uint8{1, 0, 0, 1, 0, 0, 0, 1}
+ if got := readBits(n, 0x4016, 8); !equalBits(got, want) {
+ t.Errorf("bits = %v, want %v", got, want)
+ }
+}
+
+func TestControllerReturnsOneAfterEightReads(t *testing.T) {
+ n := newTestConsole(t)
+ strobe(n)
+ readBits(n, 0x4016, 8)
+ if got := readBits(n, 0x4016, 3); !equalBits(got, []uint8{1, 1, 1}) {
+ t.Errorf("bits after 8 reads = %v, want [1 1 1]", got)
+ }
+}
+
+func TestControllerStrobeHighKeepsReturningA(t *testing.T) {
+ n := newTestConsole(t)
+ n.SetButtons(0, nes.ButtonA)
+ n.Write(0x4016, 1)
+ if got := readBits(n, 0x4016, 3); !equalBits(got, []uint8{1, 1, 1}) {
+ t.Errorf("bits = %v, want [1 1 1]", got)
+ }
+
+ n.SetButtons(0, nes.ButtonB)
+ if got := readBits(n, 0x4016, 2); !equalBits(got, []uint8{0, 0}) {
+ t.Errorf("bits after releasing A = %v, want [0 0]", got)
+ }
+}
+
+func TestControllerLatchesOnStrobe(t *testing.T) {
+ n := newTestConsole(t)
+ n.SetButtons(0, nes.ButtonA)
+ strobe(n)
+ n.SetButtons(0, 0) // released after the latch, the readout should not change
+
+ want := []uint8{1, 0, 0, 0, 0, 0, 0, 0}
+ if got := readBits(n, 0x4016, 8); !equalBits(got, want) {
+ t.Errorf("bits = %v, want %v", got, want)
+ }
+}
+
+func TestControllerPortsAreIndependentWithSharedStrobe(t *testing.T) {
+ n := newTestConsole(t)
+ n.SetButtons(0, nes.ButtonA)
+ n.SetButtons(1, nes.ButtonSelect)
+ strobe(n)
+
+ if got := readBits(n, 0x4016, 3); !equalBits(got, []uint8{1, 0, 0}) {
+ t.Errorf("port 1 bits = %v, want [1 0 0]", got)
+ }
+ if got := readBits(n, 0x4017, 3); !equalBits(got, []uint8{0, 0, 1}) {
+ t.Errorf("port 2 bits = %v, want [0 0 1]", got)
+ }
+}
+
+func TestControllerReadHasOpenBusBit6(t *testing.T) {
+ n := newTestConsole(t)
+ strobe(n)
+ if got := n.Read(0x4016); got != 0x40 {
+ t.Errorf("$4016 with nothing pressed = %#02x, want 0x40", got)
+ }
+}
diff --git a/tests/cpu_test.go b/tests/cpu_test.go
index 269f9ee..e8489f1 100644
--- a/tests/cpu_test.go
+++ b/tests/cpu_test.go
@@ -226,14 +226,18 @@ func TestCompareFlags(t *testing.T) {
}
}
-func TestUnimplementedOpcodePanics(t *testing.T) {
- defer func() {
- if r := recover(); r == nil {
- t.Fatalf("expected panic for illegal opcode")
- }
- }()
- c, _ := newTestCPU([]uint8{0x8B})
- c.Step()
+func TestEveryOpcodeIsDefined(t *testing.T) {
+ for op := 0; op < 256; op++ {
+ func() {
+ defer func() {
+ if r := recover(); r != nil {
+ t.Errorf("opcode 0x%02X panics: %v", op, r)
+ }
+ }()
+ c, _ := newTestCPU([]uint8{uint8(op), 0x00, 0x00})
+ c.Step()
+ }()
+ }
}
func TestJamStopsCPU(t *testing.T) {
@@ -269,3 +273,126 @@ func TestJammedIgnoresInterruptsUntilReset(t *testing.T) {
t.Fatal("Jammed = true after Reset, want false")
}
}
+
+func runSteps(prog []uint8, steps int) (*cpu.CPU, *ramBus) {
+ c, bus := newTestCPU(prog)
+ for i := 0; i < steps; i++ {
+ c.Step()
+ }
+ return c, bus
+}
+
+func TestANC(t *testing.T) {
+ for _, op := range []uint8{0x0B, 0x2B} {
+ c, _ := runSteps([]uint8{0xA9, 0xFF, op, 0x80}, 2) // lda #$ff ; anc #$80
+ if c.A != 0x80 || !has(c, cpu.FlagC) || !has(c, cpu.FlagN) || has(c, cpu.FlagZ) {
+ t.Errorf("op 0x%02X: A = 0x%02X, P = 0x%02X; want A=0x80, C and N set", op, c.A, c.Status)
+ }
+ }
+}
+
+func TestALR(t *testing.T) {
+ c, _ := runSteps([]uint8{0xA9, 0xFF, 0x4B, 0x03}, 2) // lda #$ff ; alr #$03
+ if c.A != 0x01 || !has(c, cpu.FlagC) || has(c, cpu.FlagN) || has(c, cpu.FlagZ) {
+ t.Errorf("A = 0x%02X, P = 0x%02X; want A=0x01, C set", c.A, c.Status)
+ }
+}
+
+func TestARR(t *testing.T) {
+ tests := []struct {
+ name string
+ prog []uint8
+ wantA uint8
+ c, v bool
+ }{
+ {"carry in, bits 6 and 5 set", []uint8{0x38, 0xA9, 0xFF, 0x6B, 0xFF}, 0xFF, true, false},
+ {"no carry in, bit 6 only", []uint8{0x18, 0xA9, 0xFF, 0x6B, 0x80}, 0x40, true, true},
+ }
+ for _, tt := range tests {
+ c, _ := runSteps(tt.prog, 3)
+ if c.A != tt.wantA || has(c, cpu.FlagC) != tt.c || has(c, cpu.FlagV) != tt.v {
+ t.Errorf("%s: A = 0x%02X, P = 0x%02X; want A=0x%02X, C=%v, V=%v", tt.name, c.A, c.Status, tt.wantA, tt.c, tt.v)
+ }
+ }
+}
+
+func TestAXS(t *testing.T) {
+ // lda #$f0 ; ldx #$3c ; axs #imm (a & x = 0x30)
+ c, _ := runSteps([]uint8{0xA9, 0xF0, 0xA2, 0x3C, 0xCB, 0x10}, 3)
+ if c.X != 0x20 || !has(c, cpu.FlagC) {
+ t.Errorf("X = 0x%02X, P = 0x%02X; want X=0x20, C set", c.X, c.Status)
+ }
+ c, _ = runSteps([]uint8{0xA9, 0xF0, 0xA2, 0x3C, 0xCB, 0x40}, 3)
+ if c.X != 0xF0 || has(c, cpu.FlagC) || !has(c, cpu.FlagN) {
+ t.Errorf("X = 0x%02X, P = 0x%02X; want X=0xF0, C clear, N set", c.X, c.Status)
+ }
+}
+
+func TestLAS(t *testing.T) {
+ c, bus := newTestCPU([]uint8{0xA0, 0x01, 0xBB, 0x00, 0x02}) // ldy #1 ; las $0200,y
+ bus.mem[0x0201] = 0xF0
+ c.Step()
+ if cycles := c.Step(); cycles != 4 {
+ t.Errorf("cycles = %d, want 4", cycles)
+ }
+ // 0xF0 & SP(0xFD) = 0xF0
+ if c.A != 0xF0 || c.X != 0xF0 || c.SP != 0xF0 || !has(c, cpu.FlagN) {
+ t.Errorf("A = 0x%02X, X = 0x%02X, SP = 0x%02X; want all 0xF0, N set", c.A, c.X, c.SP)
+ }
+}
+
+func TestANE(t *testing.T) {
+ // lda #$01 ; ldx #$0f ; ane #$ff -> (0x01 | 0xEE) & 0x0F & 0xFF
+ c, _ := runSteps([]uint8{0xA9, 0x01, 0xA2, 0x0F, 0x8B, 0xFF}, 3)
+ if c.A != 0x0F {
+ t.Errorf("A = 0x%02X, want 0x0F", c.A)
+ }
+}
+
+func TestLXA(t *testing.T) {
+ // lda #$01 ; lxa #$f0 -> (0x01 | 0xEE) & 0xF0
+ c, _ := runSteps([]uint8{0xA9, 0x01, 0xAB, 0xF0}, 2)
+ if c.A != 0xE0 || c.X != 0xE0 || !has(c, cpu.FlagN) {
+ t.Errorf("A = 0x%02X, X = 0x%02X; want both 0xE0, N set", c.A, c.X)
+ }
+}
+
+func TestStoreHighAnd(t *testing.T) {
+ tests := []struct {
+ name string
+ prog []uint8
+ zp bool // pointer $0200 at $10 for the (zp),y form
+ steps int
+ addr uint16
+ want uint8
+ }{
+ // the stored value is reg & (high byte of the base + 1) = reg & 0x03
+ {"shx", []uint8{0xA2, 0xFF, 0xA0, 0x01, 0x9E, 0x00, 0x02}, false, 3, 0x0201, 0x03},
+ {"shy", []uint8{0xA0, 0xFF, 0xA2, 0x01, 0x9C, 0x00, 0x02}, false, 3, 0x0201, 0x03},
+ {"ahx abs,y", []uint8{0xA9, 0xFF, 0xA2, 0x0F, 0xA0, 0x01, 0x9F, 0x00, 0x02}, false, 4, 0x0201, 0x03},
+ {"ahx (zp),y", []uint8{0xA9, 0xFF, 0xA2, 0x0F, 0xA0, 0x01, 0x93, 0x10}, true, 4, 0x0201, 0x03},
+ {"tas", []uint8{0xA9, 0xFF, 0xA2, 0x07, 0xA0, 0x01, 0x9B, 0x00, 0x02}, false, 4, 0x0201, 0x03},
+ // $02ff + 1 crosses a page: the value (X & 0x03 = 1) becomes the new high byte
+ {"shx page cross", []uint8{0xA2, 0x01, 0xA0, 0x01, 0x9E, 0xFF, 0x02}, false, 3, 0x0100, 0x01},
+ }
+ for _, tt := range tests {
+ c, bus := newTestCPU(tt.prog)
+ if tt.zp {
+ bus.mem[0x10], bus.mem[0x11] = 0x00, 0x02
+ }
+ for i := 0; i < tt.steps; i++ {
+ c.Step()
+ }
+ if got := bus.mem[tt.addr]; got != tt.want {
+ t.Errorf("%s: mem[0x%04X] = 0x%02X, want 0x%02X", tt.name, tt.addr, got, tt.want)
+ }
+ }
+}
+
+func TestTASSetsStackPointer(t *testing.T) {
+ // lda #$ff ; ldx #$07 ; ldy #$01 ; tas $0200,y
+ c, _ := runSteps([]uint8{0xA9, 0xFF, 0xA2, 0x07, 0xA0, 0x01, 0x9B, 0x00, 0x02}, 4)
+ if c.SP != 0x07 {
+ t.Errorf("SP = 0x%02X, want 0x07", c.SP)
+ }
+}
diff --git a/tests/dma_test.go b/tests/dma_test.go
new file mode 100644
index 0000000..db38d9e
--- /dev/null
+++ b/tests/dma_test.go
@@ -0,0 +1,78 @@
+package tests
+
+import (
+ "testing"
+
+ "crecher.net/gones/v2/nes"
+)
+
+func fillPage(n *nes.Console, page uint8) {
+ for i := 0; i < 256; i++ {
+ n.Write(uint16(page)<<8|uint16(i), uint8(i))
+ }
+}
+
+func TestOAMDMACopiesPage(t *testing.T) {
+ n := newTestConsole(t)
+ fillPage(n, 0x02)
+ n.Write(0x4014, 0x02)
+
+ for i := 0; i < 256; i++ {
+ if n.PPU.OAM[i] != uint8(i) {
+ t.Fatalf("OAM[%d] = %d, want %d", i, n.PPU.OAM[i], i)
+ }
+ }
+}
+
+func TestOAMDMAStartsAtOAMAddr(t *testing.T) {
+ n := newTestConsole(t)
+ fillPage(n, 0x03)
+ n.Write(0x2003, 0x10)
+ n.Write(0x4014, 0x03)
+
+ // source byte 0 lands at OAM[0x10], and the copy wraps around
+ for _, i := range []int{0, 1, 0xF0, 0xFF} {
+ if got := n.PPU.OAM[(0x10+i)&0xFF]; got != uint8(i) {
+ t.Errorf("OAM[0x%02X] = %d, want %d", (0x10+i)&0xFF, got, i)
+ }
+ }
+}
+
+// runs `lda ; sta $4014` from RAM and returns the cycles the sta step took
+func dmaStepCycles(t *testing.T, lda []uint8) int {
+ t.Helper()
+ n := newTestConsole(t)
+ prog := append(lda, 0x8D, 0x14, 0x40) // sta $4014
+ for i, b := range prog {
+ n.Write(0x0200+uint16(i), b)
+ }
+ n.Write(0x0000, 0x02) // for the zero page lda
+ n.CPU.PC = 0x0200
+ n.Step()
+ return n.Step()
+}
+
+func TestOAMDMAStallCycles(t *testing.T) {
+ // reset leaves the cpu at 7 cycles
+ // lda #imm (2): sta ends on cycle 13, odd -> 4 + 514
+ if got := dmaStepCycles(t, []uint8{0xA9, 0x02}); got != 518 {
+ t.Errorf("odd start: sta step = %d cycles, want 518", got)
+ }
+ // lda zp (3): sta ends on cycle 14, even -> 4 + 513
+ if got := dmaStepCycles(t, []uint8{0xA5, 0x00}); got != 517 {
+ t.Errorf("even start: sta step = %d cycles, want 517", got)
+ }
+}
+
+func TestOAMDMAAdvancesCPUCycles(t *testing.T) {
+ n := newTestConsole(t)
+ for i, b := range []uint8{0xA9, 0x02, 0x8D, 0x14, 0x40} {
+ n.Write(0x0200+uint16(i), b)
+ }
+ n.CPU.PC = 0x0200
+ n.Step()
+ n.Step()
+ if n.CPU.Cycles != 7+2+4+514 {
+ t.Errorf("CPU.Cycles = %d, want %d", n.CPU.Cycles, 7+2+4+514)
+ }
+}
diff --git a/tests/ppu_sprite_test.go b/tests/ppu_sprite_test.go
new file mode 100644
index 0000000..13ba1d0
--- /dev/null
+++ b/tests/ppu_sprite_test.go
@@ -0,0 +1,291 @@
+package tests
+
+import (
+ "testing"
+
+ "crecher.net/gones/v2/ppu"
+)
+
+// oam stores y - 1, so a sprite with y shows from scanline y + 1
+func setSprite(p *ppu.PPU, index int, y, tile, attr, x uint8) {
+ p.WriteRegister(0x2003, uint8(index*4))
+ for _, b := range []uint8{y, tile, attr, x} {
+ p.WriteRegister(0x2004, b)
+ }
+ p.WriteRegister(0x2003, 0)
+}
+
+// tile 1 from newSceneWithTile1: row 0 is color 1, row 1 is color 2
+// sprite palette 0: 1 = blue, 2 = red, 3 = white. palette 1: 1 = white
+func newSpriteScene() *ppu.PPU {
+ p := newSceneWithTile1()
+ writeVRAM(p, 0x3F10, 0x0F, 0x21, 0x16, 0x30)
+ writeVRAM(p, 0x3F15, 0x30)
+ for i := 0; i < 64; i++ {
+ setSprite(p, i, 0xFF, 0, 0, 0)
+ }
+ return p
+}
+
+func checkPixels(t *testing.T, p *ppu.PPU, tests []struct {
+ x, y int
+ want uint32
+}) {
+ t.Helper()
+ for _, tt := range tests {
+ if got := pixel(p, tt.x, tt.y); got != tt.want {
+ t.Errorf("pixel(%d,%d) = %#08x, want %#08x", tt.x, tt.y, got, tt.want)
+ }
+ }
+}
+
+type px = struct {
+ x, y int
+ want uint32
+}
+
+func TestSpriteDrawsOneLineBelowOAMY(t *testing.T) {
+ p := newSpriteScene()
+ setSprite(p, 0, 9, 1, 0, 16)
+ p.WriteRegister(0x2001, 0x10)
+ runFrames(p)
+
+ checkPixels(t, p, []px{
+ {16, 9, black},
+ {16, 10, blue},
+ {23, 10, blue},
+ {24, 10, black},
+ {15, 10, black},
+ {16, 11, red},
+ {16, 12, black},
+ })
+}
+
+func TestSpriteWithYZeroFirstShowsOnLineOne(t *testing.T) {
+ p := newSpriteScene()
+ setSprite(p, 0, 0, 1, 0, 16)
+ p.WriteRegister(0x2001, 0x10)
+ runFrames(p)
+
+ checkPixels(t, p, []px{{16, 0, black}, {16, 1, blue}})
+}
+
+func TestSpriteFlipHorizontal(t *testing.T) {
+ p := newSpriteScene()
+ writeVRAM(p, 0x0020, 0x80)
+ setSprite(p, 0, 9, 2, 0, 16)
+ setSprite(p, 1, 9, 2, 0x40, 64)
+ p.WriteRegister(0x2001, 0x10)
+ runFrames(p)
+
+ checkPixels(t, p, []px{
+ {16, 10, blue}, {23, 10, black},
+ {64, 10, black}, {71, 10, blue},
+ })
+}
+
+func TestSpriteFlipVertical(t *testing.T) {
+ p := newSpriteScene()
+ setSprite(p, 0, 9, 1, 0x80, 16)
+ p.WriteRegister(0x2001, 0x10)
+ runFrames(p)
+
+ checkPixels(t, p, []px{{16, 10, black}, {16, 16, red}, {16, 17, blue}})
+}
+
+func TestSpritePaletteSelect(t *testing.T) {
+ p := newSpriteScene()
+ setSprite(p, 0, 9, 1, 0x01, 16)
+ p.WriteRegister(0x2001, 0x10)
+ runFrames(p)
+
+ checkPixels(t, p, []px{{16, 10, white}})
+}
+
+func TestSpritePatternTableSelect(t *testing.T) {
+ p := newSpriteScene()
+ writeVRAM(p, 0x1018, 0xFF)
+ setSprite(p, 0, 9, 1, 0, 16)
+ p.WriteRegister(0x2000, 0x08)
+ p.WriteRegister(0x2001, 0x10)
+ runFrames(p)
+
+ checkPixels(t, p, []px{{16, 10, red}})
+}
+
+func TestSprite8x16(t *testing.T) {
+ p := newSpriteScene()
+ writeVRAM(p, 0x0020, 0xFF)
+ writeVRAM(p, 0x0030, 0xFF)
+ writeVRAM(p, 0x0038, 0xFF)
+ setSprite(p, 0, 9, 2, 0, 16)
+ p.WriteRegister(0x2000, 0x20)
+ p.WriteRegister(0x2001, 0x10)
+ runFrames(p)
+
+ // rows 0-7 come from tile 2, rows 8-15 from tile 3
+ checkPixels(t, p, []px{{16, 10, blue}, {16, 11, black}, {16, 18, white}, {16, 26, black}})
+}
+
+func TestSpritePriority(t *testing.T) {
+ // background tile 1 at x 16-23: line 1 is color 2 (red), line 2 is transparent
+ scene := func(attr uint8) *ppu.PPU {
+ p := newSpriteScene()
+ writeVRAM(p, 0x2002, 1)
+ setSprite(p, 0, 0, 1, attr, 16)
+ p.WriteRegister(0x2001, 0x1E)
+ runFrames(p)
+ return p
+ }
+
+ checkPixels(t, scene(0), []px{{16, 1, blue}, {16, 2, red}})
+ // behind the background it only shows through transparent pixels
+ checkPixels(t, scene(0x20), []px{{16, 1, red}, {16, 2, red}})
+}
+
+func TestSpriteLimitOf8PerLine(t *testing.T) {
+ p := newSpriteScene()
+ for i := 0; i < 9; i++ {
+ setSprite(p, i, 9, 1, 0, uint8(i*12))
+ }
+ p.WriteRegister(0x2001, 0x1E)
+ runFrames(p)
+ runToDot(p, 50, 0)
+
+ checkPixels(t, p, []px{{84, 10, blue}, {96, 10, black}})
+ if p.ReadRegister(0x2002)&0x20 == 0 {
+ t.Error("overflow flag not set with 9 sprites on a line")
+ }
+}
+
+func TestSpriteOverflowNotSetWith8(t *testing.T) {
+ p := newSpriteScene()
+ for i := 0; i < 8; i++ {
+ setSprite(p, i, 9, 1, 0, uint8(i*12))
+ }
+ p.WriteRegister(0x2001, 0x1E)
+ runFrames(p)
+ runToDot(p, 50, 0)
+
+ if p.ReadRegister(0x2002)&0x20 != 0 {
+ t.Error("overflow flag set with only 8 sprites")
+ }
+}
+
+func TestSpriteLeftClip(t *testing.T) {
+ scene := func(mask uint8) *ppu.PPU {
+ p := newSpriteScene()
+ setSprite(p, 0, 9, 1, 0, 0)
+ p.WriteRegister(0x2001, mask)
+ runFrames(p)
+ return p
+ }
+
+ checkPixels(t, scene(0x10), []px{{0, 10, black}, {8, 10, black}})
+ checkPixels(t, scene(0x14), []px{{0, 10, blue}})
+}
+
+func TestSpriteHiddenWhenSpritesDisabled(t *testing.T) {
+ p := newSpriteScene()
+ setSprite(p, 0, 9, 1, 0, 16)
+ p.WriteRegister(0x2001, 0x08)
+ runFrames(p)
+
+ checkPixels(t, p, []px{{16, 10, black}})
+}
+
+func sprite0Hit(p *ppu.PPU) bool {
+ return p.ReadRegister(0x2002)&0x40 != 0
+}
+
+func TestSprite0HitTiming(t *testing.T) {
+ p := newSpriteScene()
+ writeVRAM(p, 0x2002, 1)
+ setSprite(p, 0, 0, 1, 0, 16)
+ p.WriteRegister(0x2001, 0x1E)
+ runFrames(p)
+
+ // first overlap is pixel x = 16 on line 1, which is dot 17
+ runToDot(p, 1, 10)
+ if sprite0Hit(p) {
+ t.Error("hit set before the overlap")
+ }
+ runToDot(p, 1, 20)
+ if !sprite0Hit(p) {
+ t.Error("hit not set after the overlap")
+ }
+ runToDot(p, 261, 2)
+ if sprite0Hit(p) {
+ t.Error("hit not cleared on the pre-render line")
+ }
+}
+
+func TestSprite0HitNeedsOverlap(t *testing.T) {
+ p := newSpriteScene()
+ writeVRAM(p, 0x2002, 1)
+ setSprite(p, 0, 0, 1, 0, 100)
+ p.WriteRegister(0x2001, 0x1E)
+ runFrames(p)
+ runToDot(p, 50, 0)
+
+ if sprite0Hit(p) {
+ t.Error("hit set without a background pixel under sprite 0")
+ }
+}
+
+func TestSprite0HitOnlyForSprite0(t *testing.T) {
+ p := newSpriteScene()
+ writeVRAM(p, 0x2002, 1)
+ setSprite(p, 1, 0, 1, 0, 16)
+ p.WriteRegister(0x2001, 0x1E)
+ runFrames(p)
+ runToDot(p, 50, 0)
+
+ if sprite0Hit(p) {
+ t.Error("hit set by sprite 1")
+ }
+}
+
+func TestSprite0HitWhenBehindBackground(t *testing.T) {
+ p := newSpriteScene()
+ writeVRAM(p, 0x2002, 1)
+ setSprite(p, 0, 0, 1, 0x20, 16)
+ p.WriteRegister(0x2001, 0x1E)
+ runFrames(p)
+ runToDot(p, 50, 0)
+
+ if !sprite0Hit(p) {
+ t.Error("hit not set for a sprite 0 behind the background")
+ }
+}
+
+func TestSprite0HitRespectsLeftClip(t *testing.T) {
+ scene := func(mask uint8) *ppu.PPU {
+ p := newSpriteScene()
+ writeVRAM(p, 0x2000, 1)
+ setSprite(p, 0, 0, 1, 0, 0)
+ p.WriteRegister(0x2001, mask)
+ runFrames(p)
+ runToDot(p, 50, 0)
+ return p
+ }
+
+ if sprite0Hit(scene(0x18)) {
+ t.Error("hit set inside the clipped left 8 pixels")
+ }
+ if !sprite0Hit(scene(0x1E)) {
+ t.Error("hit not set with the left 8 pixels shown")
+ }
+}
+
+func TestSprite0HitNeverAtX255(t *testing.T) {
+ p := newSpriteScene()
+ setSprite(p, 0, 0, 1, 0, 255)
+ p.WriteRegister(0x2001, 0x1E)
+ runFrames(p)
+ runToDot(p, 50, 0)
+
+ if sprite0Hit(p) {
+ t.Error("hit set at x = 255")
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-10-19 15:44:51 +0000