100 lines
2.4 KiB
Go
100 lines
2.4 KiB
Go
package z80
|
|
|
|
import "testing"
|
|
|
|
// Exhaustive LD r,r' matrix (register-register moves) + immediate/memory forms.
|
|
// Also verifies loads do NOT affect flags.
|
|
func TestLD_Register_Matrix_And_Immediates(t *testing.T) {
|
|
cpu, mem, _ := testCPU()
|
|
// Prepare HL memory
|
|
cpu.SetHL(0x4000)
|
|
mem.WriteByte(0x4000, 0xA5)
|
|
|
|
// Fill registers with distinct values
|
|
cpu.A, cpu.B, cpu.C, cpu.D, cpu.E, cpu.H, cpu.L = 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
|
|
flagsStart := cpu.F
|
|
|
|
// LD B,C ; LD D,E ; LD A,B ; LD L,H ; (skip HALT 0x76)
|
|
loadProgram(cpu, mem, 0x0000,
|
|
0x41, // LD B,C
|
|
0x53, // LD D,E
|
|
0x78, // LD A,B
|
|
0x6C, // LD L,H
|
|
0x06, 0x99, // LD B,99
|
|
0x36, 0xFE, // LD (HL),FE
|
|
0x7E, // LD A,(HL)
|
|
0x70, // LD (HL),B
|
|
)
|
|
|
|
// LD B,C
|
|
c := mustStep(t, cpu)
|
|
assertEq(t, c, 4, "LD r,r' cycles")
|
|
assertEq(t, cpu.B, cpu.C, "LD B,C value")
|
|
assertEq(t, cpu.F, flagsStart, "LD r,r' must not alter F")
|
|
|
|
// LD D,E
|
|
mustStep(t, cpu)
|
|
assertEq(t, cpu.D, byte(0x55), "LD D,E value")
|
|
|
|
// LD A,B
|
|
mustStep(t, cpu)
|
|
assertEq(t, cpu.A, cpu.B, "LD A,B value")
|
|
|
|
// LD L,H
|
|
mustStep(t, cpu)
|
|
assertEq(t, cpu.L, cpu.H, "LD L,H value")
|
|
|
|
// LD B,n
|
|
c = mustStep(t, cpu)
|
|
assertEq(t, c, 7, "LD r,n cycles")
|
|
assertEq(t, cpu.B, byte(0x99), "LD B,n value")
|
|
|
|
// LD (HL),n
|
|
c = mustStep(t, cpu)
|
|
assertEq(t, c, 10, "LD (HL),n cycles")
|
|
assertEq(t, mem.ReadByte(cpu.GetHL()), byte(0xFE), "LD (HL),n stored")
|
|
|
|
// LD A,(HL)
|
|
c = mustStep(t, cpu)
|
|
assertEq(t, c, 7, "LD r,(HL) cycles")
|
|
assertEq(t, cpu.A, byte(0xFE), "LD A,(HL) value")
|
|
|
|
// LD (HL),r
|
|
c = mustStep(t, cpu)
|
|
assertEq(t, c, 7, "LD (HL),r cycles")
|
|
assertEq(t, mem.ReadByte(cpu.GetHL()), cpu.B, "LD (HL),B stored B")
|
|
}
|
|
|
|
func TestLD_A_BC_DE_Basics(t *testing.T) {
|
|
cpu, mem, _ := testCPU()
|
|
cpu.SetBC(0x1234)
|
|
cpu.SetDE(0x5678)
|
|
mem.WriteByte(0x1234, 0xAA)
|
|
mem.WriteByte(0x5678, 0xBB)
|
|
|
|
loadProgram(cpu, mem, 0x0000,
|
|
0x0A, // LD A,(BC)
|
|
0x1A, // LD A,(DE)
|
|
0x02, // LD (BC),A
|
|
0x12, // LD (DE),A
|
|
)
|
|
|
|
c := mustStep(t, cpu)
|
|
assertEq(t, c, 7, "LD A,(BC) cycles")
|
|
assertEq(t, cpu.A, byte(0xAA), "LD A,(BC)")
|
|
|
|
c = mustStep(t, cpu)
|
|
assertEq(t, c, 7, "LD A,(DE) cycles")
|
|
assertEq(t, cpu.A, byte(0xBB), "LD A,(DE)")
|
|
|
|
// LD (BC),A
|
|
c = mustStep(t, cpu)
|
|
assertEq(t, c, 7, "LD (BC),A cycles")
|
|
assertEq(t, mem.ReadByte(0x1234), cpu.A, "LD (BC),A wrote A")
|
|
|
|
// LD (DE),A
|
|
c = mustStep(t, cpu)
|
|
assertEq(t, c, 7, "LD (DE),A cycles")
|
|
assertEq(t, mem.ReadByte(0x5678), cpu.A, "LD (DE),A wrote A")
|
|
}
|