public void JPnn_nc_NC()
{
var ob = OpcodeByte.New(x: 3, z: 2, y: 2);
var cpu = ExecuteTest(ob, (r) => {
return(true);
});
cpu.AssertRegisters(pc: JumpAddress);
}
protected override void OnLastCycleLastM()
{
base.OnLastCycleLastM();
if (!IsWrite)
{
var val16 = OpcodeByte.MakeUInt16(_readInstructionLo.Data, _readInstructionHi.Data);
Registers[AffectedRegisters] = val16;
}
}
public void Ld_HL_H()
{
var ob = OpcodeByte.New(x: 1, z: 4, y: 6);
var model = ExecuteTest(ob, (cpu) => {
cpu.Registers.HL = Address;
});
model.Memory.Assert(Address, 0x00);
}
public void JPnn_z_NZ()
{
var ob = OpcodeByte.New(x: 3, z: 2, y: 1);
var cpu = ExecuteTest(ob, (r) => {
return(false);
});
cpu.AssertRegisters(pc: Address);
}
public void EI()
{
var ob = OpcodeByte.New(x: 3, z: 3, y: 7);
var model = ExecuteTest(ob);
model.Cpu.Registers.Interrupt.IFF1.Should().BeTrue("IFF1");
model.Cpu.Registers.Interrupt.IFF2.Should().BeTrue("IFF2");
model.Cpu.Registers.Interrupt.IsEnabled.Should().BeFalse("IsEnabled");
model.Cpu.Registers.Interrupt.IsSuspended.Should().BeTrue("IsSuspended");
}
public void PushIY()
{
var push = OpcodeByte.New(x: 3, z: 5, p: 2);
var model = ExecuteTest(push,
(m) => m.Cpu.FillRegisters(sp: Stack, iy: Value), 0xFD);
model.Cpu.AssertRegisters(sp: Stack - 2, iy: Value);
model.Memory.Assert(Stack - 1, ValueMsb);
model.Memory.Assert(Stack - 2, ValueLsb);
}
public void Ex_SP_HL()
{
var ob = OpcodeByte.New(x: 3, z: 3, y: 4);
var model = ExecuteTest(ob);
model.Cpu.AssertRegisters(hl: 0);
model.Memory.Assert(Stack, ExpectedLo);
model.Memory.Assert(Stack + 1, ExpectedHi);
}
public void DAA_NoFlags_NoOverflow()
{
var ob = OpcodeByte.New(z: 7, y: 4);
var cpu = ExecuteTest(ob, (cpuZ80) =>
{
cpuZ80.Registers.A = Value1;
});
cpu.Registers.A.Should().Be(Value1);
}
public void JP_IY()
{
var ob = OpcodeByte.New(x: 3, z: 1, q: 1, p: 2);
var cpu = ExecuteTest(ob, (r) => {
r.IY = JumpAddress;
}, 0xFD);
cpu.AssertRegisters(pc: JumpAddress, iy: JumpAddress);
}
public void JP_HL()
{
var ob = OpcodeByte.New(x: 3, z: 1, q: 1, p: 2);
var cpu = ExecuteTest(ob, (r) => {
r.HL = JumpAddress;
});
cpu.AssertRegisters(pc: JumpAddress, hl: JumpAddress);
}
private static SimulationModel CreateModel()
{
var ob = OpcodeByte.New(x: 1, z: 6, y: 6);
var cpuZ80 = new CpuZ80();
var model = cpuZ80.Initialize(new byte[] { ob.Value });
cpuZ80.FillRegisters();
return(model);
}
public void CPL()
{
var ob = OpcodeByte.New(z: 7, y: 5);
var cpu = ExecuteTest(ob, (cpuZ80) =>
{
cpuZ80.Registers.A = Value1;
});
cpu.Registers.A.Should().Be(unchecked ((byte)~Value1));
}
public void LdRA()
{
var ob = OpcodeByte.New(x: 1, z: 7, y: 1);
var cpu = ExecuteTest(ob, (z80) =>
{
z80.Registers.A = Value;
});
cpu.AssertRegisters(a: Value, r: Value);
}
public bool AddOpcodeByte(OpcodeByte opcodeByte)
{
var valid = _opcodeBuilder.Add(opcodeByte);
if (valid)
{
_cycles.OpcodeDefinition = _opcodeBuilder.Opcode.Definition;
}
return(valid);
}
private ushort GetAddress()
{
if (IsIndirect)
{
return(OpcodeByte.MakeUInt16(
_readIndirectPart.Data,
new OpcodeByte(Registers.A)));
}
return(Registers.BC);
}
public void Ld_HL_E()
{
var ob = OpcodeByte.New(x: 1, z: 3, y: 6);
var model = ExecuteTest(ob, (cpu) => {
cpu.Registers.HL = Address;
cpu.Registers.E = Value;
});
model.Memory.Assert(Address, Value);
}
public void Ld_IYd_A()
{
var ob = OpcodeByte.New(x: 1, z: 7, y: 6);
var model = ExecuteTest(ob, (cpu) => {
cpu.Registers.IY = Address;
cpu.Registers.A = Value;
}, 0xFD);
model.Memory.Assert(Address + Offset, Value);
}
public void Ld_DE_A()
{
var ob = OpcodeByte.New(z: 2, q: 0, p: 1);
var model = ExecuteTest(ob, (cpu) => {
cpu.Registers.DE = Address;
cpu.Registers.A = Value;
});
model.Memory.Assert(Address, Value);
}
public void LdSpIy()
{
var ob = OpcodeByte.New(x: 3, z: 1, q: 1, p: 3);
var cpu = ExecuteTest(ob, (z80) =>
{
z80.Registers.HL = 0;
}, 0xFD);
cpu.AssertRegisters(sp: 0, hl: 0);
}
public void Ld_IXd_L()
{
var ob = OpcodeByte.New(x: 1, z: 5, y: 6);
var model = ExecuteTest(ob, (cpu) => {
cpu.Registers.IX = Address;
cpu.Registers.L = Value;
}, 0xDD);
model.Memory.Assert(Address + Offset, Value);
}
public void Out_C_0()
{
var ob = OpcodeByte.New(x: 1, z: 1, y: 6);
var model = ExecuteTest(ob, (cpu) =>
{
cpu.Registers.BC = IoAddress;
}, 0xED);
model.Cpu.AssertRegisters(bc: IoAddress);
model.IoSpace.Assert(IoAddress, 0);
}
public void JPnn_nc_C()
{
var ob = OpcodeByte.New(x: 3, z: 2, y: 2);
var cpu = ExecuteTest(ob, (r) => {
r.Flags.C = true;
return(false);
});
cpu.AssertRegisters(pc: Address);
}
public void JPnn_z_Z()
{
var ob = OpcodeByte.New(x: 3, z: 2, y: 1);
var cpu = ExecuteTest(ob, (r) => {
r.Flags.Z = true;
return(true);
});
cpu.AssertRegisters(pc: JumpAddress);
}
public void DecHL()
{
var ob = OpcodeByte.New(z: 5, y: 6);
var model = ExecuteTest(ob, (m) => {
m.Cpu.FillRegisters(hl: Address2);
m.Memory.Set(Address2, Value2);
});
model.Cpu.AssertRegisters(hl: Address2);
model.Memory.Assert(Address2, Value2 - 1);
}
public void OUTDR()
{
var ob = OpcodeByte.New(x: 2, z: 3, y: 7);
var model = ExecuteTest(ob, (cpu) =>
{
cpu.Registers.HL = Address;
cpu.Registers.BC = IoAddress;
}, true);
model.Cpu.AssertRegisters(hl: Address - 1, bc: 0xFF00 | IoAddress);
model.IoSpace.Assert(IoAddress, Value);
}
public void Out_C_L()
{
var ob = OpcodeByte.New(x: 1, z: 1, y: 5);
var model = ExecuteTest(ob, (cpu) =>
{
cpu.Registers.BC = IoAddress;
cpu.Registers.HL = 0xAA55;
}, 0xED);
model.Cpu.AssertRegisters(bc: IoAddress, hl: 0xAA55);
model.IoSpace.Assert(IoAddress, 0x55);
}
public void OUTI()
{
var ob = OpcodeByte.New(x: 2, z: 3, y: 4);
var model = ExecuteTest(ob, (cpu) =>
{
cpu.Registers.HL = Address;
cpu.Registers.BC = 0x01 << 8 | IoAddress;
}, true);
model.Cpu.AssertRegisters(hl: Address + 1, bc: IoAddress);
model.IoSpace.Assert(IoAddress, Value);
}
public void INIR()
{
var ob = OpcodeByte.New(x: 2, z: 2, y: 6);
var model = ExecuteTest(ob, (cpu) =>
{
cpu.Registers.HL = Address;
cpu.Registers.BC = 0x0100 | IoAddress;
}, true);
model.Cpu.AssertRegisters(hl: Address + 1, bc: IoAddress);
model.Memory.Assert(Address, Value);
}
public void INDR()
{
var ob = OpcodeByte.New(x: 2, z: 2, y: 7);
var model = ExecuteTest(ob, (cpu) =>
{
cpu.Registers.HL = Address;
cpu.Registers.BC = IoAddress;
}, true);
model.Cpu.AssertRegisters(hl: Address - 1, bc: 0xFF02);
model.Memory.Assert(Address, Value);
}
public void AddCarryHL_SP_c()
{
var ob = OpcodeByte.New(x: 1, z: 2, q: 1, p: 3);
var cpuZ80 = ExecuteTest(ob, (cpu) =>
{
cpu.FillRegisters(sp: Value);
cpu.Registers.Flags.C = true;
}, extension: 0xED);
cpuZ80.AssertRegisters(hl: ExpectedValue + 1, sp: Value);
cpuZ80.Registers.Flags.C.Should().BeFalse();
}
