public void TestPCHL()
{
var rom = AssembleSource($@"
org 00h
PCHL ; $0000
NOP ; $0001
NOP ; $0002
HLT ; $0003
");
var initialState = new CPUConfig()
{
Registers = new CPURegisters()
{
HL = 0x003,
},
};
var state = Execute(rom, initialState);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 5, state.Cycles);
Assert.Equal(0x0003, state.ProgramCounter);
}
public void TestPUSH(RegisterPair pair)
{
var rom = AssembleSource($@"
org 00h
PUSH {pair.GetUpperRegister()}
HLT
");
var registers = new CPURegisters()
{
[pair] = 0x2477,
};
var initialState = new CPUConfig()
{
Registers = registers,
StackPointer = 0x3000,
};
var state = Execute(rom, initialState);
Assert.Equal(0x2477, state.Registers[pair]);
Assert.Equal(0x00, state.Memory[0x3000]);
Assert.Equal(0x24, state.Memory[0x2FFF]);
Assert.Equal(0x77, state.Memory[0x2FFE]);
Assert.Equal(0x2FFE, state.StackPointer);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 11, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestSUB_A_ZeroAndParityFlag()
{
var rom = AssembleSource($@"
org 00h
SUB A
HLT
");
var registers = new CPURegisters();
registers.A = 0x80;
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(0x00, state.Registers.A);
Assert.True(state.Flags.Zero);
Assert.False(state.Flags.Sign);
Assert.True(state.Flags.Parity);
Assert.False(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 4, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestADD_NoFlags(Register sourceReg)
{
var rom = AssembleSource($@"
org 00h
ADD {sourceReg}
HLT
");
var registers = new CPURegisters();
registers.A = 0x42;
registers[sourceReg] = 0x16;
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(0x58, state.Registers.A);
Assert.Equal(0x16, state.Registers[sourceReg]);
Assert.False(state.Flags.Zero);
Assert.False(state.Flags.Sign);
Assert.False(state.Flags.Parity);
Assert.False(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 4, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestDAD_Carry(RegisterPair pair)
{
var rom = AssembleSource($@"
org 00h
DAD {pair.GetUpperRegister()}
HLT
");
var registers = new CPURegisters()
{
HL = 0xFFFE,
[pair] = 0x0005,
};
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(0x0005, state.Registers[pair]);
Assert.Equal(0x0003, state.Registers.HL);
Assert.False(state.Flags.Zero);
Assert.False(state.Flags.Sign);
Assert.False(state.Flags.Parity);
Assert.True(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 10, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestDAD_SP_Carry()
{
var rom = AssembleSource($@"
org 00h
DAD SP
HLT
");
var registers = new CPURegisters()
{
HL = 0xFFFE,
};
var initialState = new CPUConfig()
{
Registers = registers,
StackPointer = 0x0005,
};
var state = Execute(rom, initialState);
Assert.Equal(0x0005, state.StackPointer);
Assert.Equal(0x0003, state.Registers.HL);
Assert.False(state.Flags.Zero);
Assert.False(state.Flags.Sign);
Assert.False(state.Flags.Parity);
Assert.True(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 10, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestDCR_SignFlag(Register sourceReg)
{
var rom = AssembleSource($@"
org 00h
DCR {sourceReg}
HLT
");
var registers = new CPURegisters()
{
[sourceReg] = 0x81,
};
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(0x80, state.Registers[sourceReg]);
Assert.False(state.Flags.Zero);
Assert.True(state.Flags.Sign);
Assert.False(state.Flags.Parity);
Assert.False(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 5, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestSTA()
{
var rom = AssembleSource($@"
org 00h
STA 2477h
HLT
");
var registers = new CPURegisters();
registers.A = 0x42;
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(0x42, state.Memory[0x2477]);
Assert.Equal(0x42, state.Registers.A);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 13, state.Cycles);
Assert.Equal(0x03, state.ProgramCounter);
}
public void TestDCR_M_NoFlags()
{
var rom = AssembleSource($@"
org 00h
DCR M
HLT
");
var registers = new CPURegisters()
{
HL = 0x2477,
};
var memory = new byte[16384];
memory[0x2477] = 0x44;
var initialState = new CPUConfig()
{
Registers = registers,
MemorySize = memory.Length,
};
var state = Execute(rom, memory, initialState);
Assert.Equal(0x43, state.Memory[0x2477]);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 10, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestDCR_NoFlags(Register sourceReg)
{
var rom = AssembleSource($@"
org 00h
DCR {sourceReg}
HLT
");
var registers = new CPURegisters()
{
[sourceReg] = 0x44,
};
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(0x43, state.Registers[sourceReg]);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 5, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestMVIToMemory()
{
var rom = AssembleSource($@"
org 00h
MVI M, 42h
HLT
");
var registers = new CPURegisters();
registers[Register.H] = 0x22;
registers[Register.L] = 0x33;
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(0x42, state.Memory[0x2233]);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(10 + 7, state.Cycles);
Assert.Equal(0x02, state.ProgramCounter);
}
public void TestXCHG_NoFlags()
{
var rom = AssembleSource($@"
org 00h
XCHG
HLT
");
var initialState = new CPUConfig()
{
Registers = new CPURegisters()
{
H = 0x42,
D = 0x99,
L = 0x77,
E = 0x88,
},
};
var state = Execute(rom, initialState);
Assert.Equal(0x99, state.Registers.H);
Assert.Equal(0x42, state.Registers.D);
Assert.Equal(0x88, state.Registers.L);
Assert.Equal(0x77, state.Registers.E);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 5, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
protected CPUResults Execute(byte[] rom, byte[] memory, CPUConfig cpuConfig = null)
{
// Map the ROM into the memory space.
Array.Copy(rom, memory, rom.Length);
return(Execute(memory, cpuConfig));
}
public void TestSHLD()
{
var rom = AssembleSource($@"
org 00h
SHLD 2477h
HLT
");
var initialState = new CPUConfig()
{
Registers = new CPURegisters()
{
H = 0x66,
L = 0x77,
},
};
var state = Execute(rom, initialState);
Assert.Equal(0x77, state.Memory[0x2477]);
Assert.Equal(0x66, state.Memory[0x2478]);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 16, state.Cycles);
Assert.Equal(0x03, state.ProgramCounter);
}
public void TestSTAX(Register destReg, Register destReg2)
{
var rom = AssembleSource($@"
org 00h
STAX {destReg}
HLT
");
var registers = new CPURegisters();
registers.A = 0x42;
registers[destReg] = 0x24;
registers[destReg2] = 0x77;
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(0x42, state.Memory[0x2477]);
Assert.Equal(0x42, state.Registers.A);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 7, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestANA_ParityFlag(Register sourceReg)
{
var rom = AssembleSource($@"
org 00h
ANA {sourceReg}
HLT
");
var registers = new CPURegisters();
registers.A = 0b11100101;
registers[sourceReg] = 0b00101110;
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(0b00100100, state.Registers.A);
Assert.Equal(0b00101110, state.Registers[sourceReg]);
Assert.False(state.Flags.Zero);
Assert.False(state.Flags.Sign);
Assert.True(state.Flags.Parity);
Assert.False(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 4, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestADI_NoFlags()
{
var rom = AssembleSource($@"
org 00h
ADI 19h
HLT
");
var initialState = new CPUConfig()
{
Registers = new CPURegisters()
{
A = 0x42,
},
};
var state = Execute(rom, initialState);
Assert.Equal(0x5B, state.Registers.A);
Assert.False(state.Flags.Zero);
Assert.False(state.Flags.Sign);
Assert.False(state.Flags.Parity);
Assert.False(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 7, state.Cycles);
Assert.Equal(0x02, state.ProgramCounter);
}
public void TestINX_SP()
{
var rom = AssembleSource($@"
org 00h
DCX SP
DCX SP
DCX SP
HLT
");
var initialState = new CPUConfig()
{
StackPointer = 0x3902,
};
var state = Execute(rom, initialState);
Assert.Equal(0x38FF, state.StackPointer);
AssertFlagsFalse(state);
Assert.Equal(4, state.Iterations);
Assert.Equal(7 + (5 * 3), state.Cycles);
Assert.Equal(0x03, state.ProgramCounter);
}
public void TestSTC_SetsFalseToTrue()
{
var rom = AssembleSource($@"
org 00h
STC
HLT
");
var initialState = new CPUConfig()
{
Flags = new ConditionFlags()
{
Carry = false,
},
};
var state = Execute(rom, initialState);
Assert.False(state.Flags.Zero);
Assert.False(state.Flags.Sign);
Assert.False(state.Flags.Parity);
Assert.True(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 4, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestMOVFromRegisterToRegister(Register destReg, Register sourceReg)
{
var rom = AssembleSource($@"
org 00h
MOV {destReg}, {sourceReg}
HLT
");
var registers = new CPURegisters();
registers[sourceReg] = 42;
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(42, state.Registers[destReg]);
Assert.Equal(42, state.Registers[sourceReg]);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(5 + 7, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestDCX(RegisterPair pair)
{
var rom = AssembleSource($@"
org 00h
DCX {pair.GetUpperRegister()}
DCX {pair.GetUpperRegister()}
DCX {pair.GetUpperRegister()}
HLT
");
var registers = new CPURegisters()
{
[pair] = 0x3902,
};
var initialState = new CPUConfig()
{
Registers = registers,
};
var state = Execute(rom, initialState);
Assert.Equal(0x38FF, state.Registers[pair]);
AssertFlagsFalse(state);
Assert.Equal(4, state.Iterations);
Assert.Equal(7 + (5 * 3), state.Cycles);
Assert.Equal(0x03, state.ProgramCounter);
}
public void TestSPHL()
{
var rom = AssembleSource($@"
org 00h
SPHL
HLT
");
var initialState = new CPUConfig()
{
Registers = new CPURegisters()
{
HL = 0x2477,
},
};
var state = Execute(rom, initialState);
AssertFlagsFalse(state);
Assert.Equal(0x2477, state.StackPointer);
Assert.Equal(0x2477, state.Registers.HL);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 5, state.Cycles);
Assert.Equal(0x0001, state.ProgramCounter);
}
public void TestLDA()
{
var rom = AssembleSource($@"
org 00h
LDA 2477h
HLT
");
var memory = new byte[16384];
memory[0x2477] = 0x42;
var initialState = new CPUConfig()
{
MemorySize = memory.Length,
};
var state = Execute(rom, memory, initialState);
Assert.Equal(0x42, state.Memory[0x2477]);
Assert.Equal(0x42, state.Registers.A);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 13, state.Cycles);
Assert.Equal(0x03, state.ProgramCounter);
}
public void TestSBI_DoesNotSubtractOneIfCarryFalse()
{
var rom = AssembleSource($@"
org 00h
SBI 19h
HLT
");
var initialState = new CPUConfig()
{
Registers = new CPURegisters()
{
A = 0x42,
},
Flags = new ConditionFlags()
{
Carry = false,
},
};
var state = Execute(rom, initialState);
Assert.Equal(0x29, state.Registers.A);
Assert.False(state.Flags.Zero);
Assert.False(state.Flags.Sign);
Assert.False(state.Flags.Parity);
Assert.False(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 7, state.Cycles);
Assert.Equal(0x02, state.ProgramCounter);
}
public void TestRAR(byte initialValue, bool initialCarryFlag, byte expectedValue, bool expectedCarryFlag)
{
var rom = AssembleSource($@"
org 00h
RAR
HLT
");
var initialState = new CPUConfig()
{
Registers = new CPURegisters()
{
A = initialValue,
},
Flags = new ConditionFlags()
{
Carry = initialCarryFlag,
}
};
var state = Execute(rom, initialState);
Assert.Equal(expectedValue, state.Registers.A);
Assert.False(state.Flags.Zero);
Assert.False(state.Flags.Sign);
Assert.False(state.Flags.Parity);
Assert.Equal(expectedCarryFlag, state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 4, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestSBI_ZeroFlag()
{
var rom = AssembleSource($@"
org 00h
SBI 11h
HLT
");
var initialState = new CPUConfig()
{
Registers = new CPURegisters()
{
A = 0x12,
},
Flags = new ConditionFlags()
{
Carry = true,
},
};
var state = Execute(rom, initialState);
Assert.Equal(0x00, state.Registers.A);
Assert.True(state.Flags.Zero);
Assert.False(state.Flags.Sign);
Assert.True(state.Flags.Parity);
Assert.False(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 7, state.Cycles);
Assert.Equal(0x02, state.ProgramCounter);
}
public void TestADC_A_SignFlag()
{
var rom = AssembleSource($@"
org 00h
ADC A
HLT
");
var registers = new CPURegisters();
registers.A = 0x44;
var flags = new ConditionFlags()
{
Carry = true,
};
var initialState = new CPUConfig()
{
Registers = registers,
Flags = flags,
};
var state = Execute(rom, initialState);
Assert.Equal(0x89, state.Registers.A);
Assert.False(state.Flags.Zero);
Assert.True(state.Flags.Sign);
Assert.False(state.Flags.Parity);
Assert.False(state.Flags.Carry);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 4, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestPop(RegisterPair pair)
{
var rom = AssembleSource($@"
org 00h
POP {pair.GetUpperRegister()}
HLT
");
var memory = new byte[16384];
memory[0x2FFE] = 0x77;
memory[0x2FFF] = 0x24;
var initialState = new CPUConfig()
{
StackPointer = 0x2FFE,
MemorySize = memory.Length,
};
var state = Execute(rom, memory, initialState);
Assert.Equal(0x2477, state.Registers[pair]);
Assert.Equal(0x00, state.Memory[0x3000]);
Assert.Equal(0x24, state.Memory[0x2FFF]);
Assert.Equal(0x77, state.Memory[0x2FFE]);
Assert.Equal(0x3000, state.StackPointer);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 10, state.Cycles);
Assert.Equal(0x01, state.ProgramCounter);
}
public void TestRST(int resetIndex, UInt16 expectedProgramCounterValue)
{
var rom = AssembleSource($@"
org 00h
HLT
org 08h
HLT
org 010h
HLT
org 018h
HLT
org 20h
HLT
org 28h
HLT
org 30h
HLT
org 38h
HLT
org 40h
RST {resetIndex}
");
var memory = new byte[16384];
memory[0x2720] = 0xFF;
memory[0x271F] = 0xFF;
memory[0x271E] = 0xFF;
memory[0x271D] = 0xFF;
var initialState = new CPUConfig()
{
ProgramCounter = 0x0040,
StackPointer = 0x2720,
MemorySize = memory.Length,
};
var state = Execute(rom, memory, initialState);
Assert.Equal(0x271E, state.StackPointer);
Assert.Equal(0xFF, state.Memory[0x2720]);
Assert.Equal(0x00, state.Memory[0x271F]);
Assert.Equal(0x41, state.Memory[0x271E]);
Assert.Equal(0xFF, state.Memory[0x271D]);
AssertFlagsFalse(state);
Assert.Equal(2, state.Iterations);
Assert.Equal(7 + 11, state.Cycles);
Assert.Equal(expectedProgramCounterValue, state.ProgramCounter);
}
protected void AssertFlagsSame(CPUConfig initialState, CPUResults stats)
{
Assert.Equal(initialState.Flags.AuxCarry, stats.Flags.AuxCarry);
Assert.Equal(initialState.Flags.Carry, stats.Flags.Carry);
Assert.Equal(initialState.Flags.Parity, stats.Flags.Parity);
Assert.Equal(initialState.Flags.Sign, stats.Flags.Sign);
Assert.Equal(initialState.Flags.Zero, stats.Flags.Zero);
}
