public void Test_LoadAndStoreFlags()
{
i8086CPU cpu = GetCPU(new byte[] { 0x9f, 0x9e });
cpu.EU.CondReg.Register = 0x14d7;
cpu.NextInstruction();
Assert.AreEqual(0xd7, cpu.EU.Registers.AH, "LAHF result failed");
Assert.AreEqual(0x14d7, cpu.EU.CondReg.Register, "LAHF result failed");
cpu.EU.CondReg.Register = 0xf82e;
cpu.NextInstruction();
Assert.AreEqual(0xd7, cpu.EU.Registers.AH, "SAHF result failed");
Assert.AreEqual(0xf8d7, cpu.EU.CondReg.Register, "SAHF result failed");
}
public void Testc6()
{
// MOV [100],28
i8086CPU cpu = GetCPU(new byte[] { 0xc6, 0x06, 0x00, 0x01, 0x28 });
cpu.NextInstruction();
Assert.AreEqual(0x28, cpu.Bus.GetData8(0x100), "Instruction c6 failed");
// MOV [si],39
cpu = GetCPU(new byte[] { 0xc6, 0x04, 0x39 });
cpu.EU.Registers.SI = 0x350;
cpu.NextInstruction();
Assert.AreEqual(0x39, cpu.Bus.GetData8(cpu.EU.Registers.SI), "Instruction c6 failed (2)");
}
public void Testc7()
{
// MOV [100],28fa
i8086CPU cpu = GetCPU(new byte[] { 0xc7, 0x06, 0x00, 0x01, 0xfa, 0x28 });
cpu.NextInstruction();
Assert.AreEqual(0x28fa, cpu.Bus.GetData16(0x100), "Instruction c7 failed");
// MOV [si],3902
cpu = GetCPU(new byte[] { 0xc7, 0x04, 0x02, 0x39 });
cpu.EU.Registers.SI = 0x350;
cpu.NextInstruction();
Assert.AreEqual(0x3902, cpu.Bus.GetData16(cpu.EU.Registers.SI), "Instruction c7 failed (2)");
}
public void Test_SAR()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd0, 0xf8, /* SAR AL,1 */
0xd2, 0xfb }); /* SAR BL, CL */
cpu.EU.Registers.AL = 0xe0;
cpu.EU.Registers.BL = 0x4c;
cpu.EU.Registers.CL = 0x01;
cpu.NextInstruction();
Assert.AreEqual(0xf0, cpu.EU.Registers.AL, "SAR 1 result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "SAR 1 CF failed");
cpu.NextInstruction();
Assert.AreEqual(0x26, cpu.EU.Registers.BL, "SAR 2 result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "SAR 2 CF failed");
}
public void Test_CBW()
{
i8086CPU cpu = GetCPU(new byte[] { 0x98 });
cpu.EU.Registers.AX = 0x00fb;
cpu.NextInstruction();
Assert.AreEqual(0xfffb, cpu.EU.Registers.AX, "CBW result failed");
}
public void Testa2()
{
i8086CPU cpu = GetCPU(new byte[] { 0xa2, 0x23, 0x98 });
cpu.EU.Registers.AL = 0xc4;
cpu.NextInstruction();
Assert.AreEqual(0xc4, cpu.Bus.GetData8(0x9823), "Instruction a2 failed");
}
public void Testa3()
{
i8086CPU cpu = GetCPU(new byte[] { 0xa3, 0x23, 0x98 });
cpu.EU.Registers.AX = 0xc42f;
cpu.NextInstruction();
Assert.AreEqual(0xc42f, cpu.Bus.GetData16(0x9823), "Instruction a3 failed");
}
public void Test_SODS()
{
i8086CPU cpu = GetCPU(new byte[] { 0xaa, 0xab });
cpu.EU.Registers.DI = 0x200;
cpu.EU.Registers.AL = 0xf8;
cpu.NextInstruction();
Assert.AreEqual(0xf8, cpu.Bus.GetDestString8(0x200), "STOSB result failed");
Assert.AreEqual(0x201, cpu.EU.Registers.DI, "STOSB DI failed");
cpu.EU.Registers.DI = 0x300;
cpu.EU.Registers.AX = 0x12fe;
cpu.NextInstruction();
Assert.AreEqual(0x12fe, cpu.Bus.GetDestString16(0x300), "STOSW result failed");
Assert.AreEqual(0x302, cpu.EU.Registers.DI, "STOSW DI failed");
}
public void Testa0()
{
i8086CPU cpu = GetCPU(new byte[] { 0xa0, 0x23, 0x98 });
cpu.Bus.SaveData8(0x9823, 0x65);
cpu.NextInstruction();
Assert.AreEqual(0x65, cpu.EU.Registers.AL, "Instruction a0 failed");
}
public void Testa1()
{
i8086CPU cpu = GetCPU(new byte[] { 0xa1, 0x23, 0x98 });
cpu.Bus.SaveData16(0x9823, 0x65fe);
cpu.NextInstruction();
Assert.AreEqual(0x65fe, cpu.EU.Registers.AX, "Instruction a1 failed");
}
public void Test8b()
{
i8086CPU cpu = GetCPU(new byte[] { 0x8b, 0xc8 } /* MOV cx,ax (16 bit) */);
cpu.EU.Registers.AX = 0x11ab;
cpu.EU.Registers.CX = 0x22fe;
cpu.NextInstruction();
Assert.AreEqual(0x11ab, cpu.EU.Registers.CX, "Instruction 0x8b failed");
}
public void Test89()
{
i8086CPU cpu = GetCPU(new byte[] { 0x89, 0xd8, 0x10 } /* MOV ax,bx */);
cpu.EU.Registers.AX = 0x11ab;
cpu.EU.Registers.BX = 0x22fe;
cpu.NextInstruction();
Assert.AreEqual(0x22fe, cpu.EU.Registers.AX, "Instruction 0x89 failed");
}
public void Test83()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x83, 0xf8, 0x63, /* CMP AX, 63 */
0x83, 0xf8, 0x63 /* CMP AX, 63 */
});
cpu.EU.Registers.AX = 0x1000;
cpu.NextInstruction();
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "CMP (1) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "CMP (1) zero flag failed");
cpu.EU.Registers.AX = 0x0058;
cpu.NextInstruction();
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "CMP (2) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "CMP (2) zero flag failed");
}
protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
{
if (keyData == (Keys.F5))
{
_cpu.NextInstruction();
RefreshData();
return(true);
}
return(base.ProcessCmdKey(ref msg, keyData));
}
public void TestMUL()
{
i8086CPU cpu = GetCPU(new byte[] { 0xf6, 0xe3 }); /* MUL BL */
cpu.EU.Registers.AL = 0xc8;
cpu.EU.Registers.BL = 0x04;
cpu.NextInstruction();
Assert.AreEqual(0x0320, cpu.EU.Registers.AX, "MUL AX result failed");
cpu = GetCPU(new byte[] { 0xf7, 0xe3 }); /* MUL BX */
cpu.EU.Registers.AX = 0x2000;
cpu.EU.Registers.BX = 0x0100;
cpu.NextInstruction();
Assert.AreEqual(0x0020, cpu.EU.Registers.DX, "MUL 2 DX result failed");
Assert.AreEqual(0x0000, cpu.EU.Registers.AX, "MUL 2 AX result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "MUL 2 CF failed");
}
public void Test_SAL()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd0, 0xe0 });/* SAL AL,1 */
cpu.EU.Registers.AL = 0xe0;
cpu.NextInstruction();
Assert.AreEqual(0xc0, cpu.EU.Registers.AL, "SAL result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "SAL CF failed");
}
public void Test_SHR()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd0, 0xe8 });/* SHR AL,1 */
cpu.EU.Registers.AL = 0x07;
cpu.NextInstruction();
Assert.AreEqual(0x03, cpu.EU.Registers.AL, "SHR result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "SHR CF failed");
}
public void Test_ROR()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd0, 0xc8 });/* ROR AL,1 */
cpu.EU.Registers.AL = 0x1c;
cpu.NextInstruction();
Assert.AreEqual(0x0e, cpu.EU.Registers.AL, "ROR result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "ROR CF failed");
}
public void Test_LODS()
{
i8086CPU cpu = GetCPU(new byte[] { 0xac, 0xad });
cpu.EU.Registers.SI = 0x200;
cpu.EU.Registers.AX = 0x0e00;
cpu.Bus.SaveData8(cpu.EU.Registers.SI, 0xc7);
cpu.NextInstruction();
Assert.AreEqual(0xc7, cpu.EU.Registers.AL, "LODSB 1 result failed");
Assert.AreEqual(0x201, cpu.EU.Registers.SI, "LODSB 2 result failed");
cpu.EU.Registers.SI = 0x300;
cpu.EU.Registers.AX = 0xffff;
cpu.Bus.SaveData16(cpu.EU.Registers.SI, 0xa965);
cpu.NextInstruction();
Assert.AreEqual(0xa965, cpu.EU.Registers.AX, "LODSW 2 result failed");
Assert.AreEqual(0x302, cpu.EU.Registers.SI, "LODSW 2 result failed");
}
public void Test_RCL()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd0, 0xd0 });/* RCL AL,1 */
cpu.EU.CondReg.CarryFlag = true;
cpu.EU.Registers.AL = 0x1c;
cpu.NextInstruction();
Assert.AreEqual(0x39, cpu.EU.Registers.AL, "RCL result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "RCL CF failed");
}
public void Test8c()
{
i8086CPU cpu = GetCPU(new byte[] { 0x8c, 0x5f, 0x35 } /* MOV bx+35, ds (16 bit) */);
cpu.Bus.DS = 0x76d2;
cpu.EU.Registers.BX = 0x1015;
cpu.NextInstruction();
Assert.AreEqual(0x76d2, cpu.Bus.GetData16(cpu.EU.Registers.BX + 0x35), "Instruction 0x8c failed");
}
public void Test_AAS()
{
i8086CPU cpu = GetCPU(new byte[] { 0x3f });
cpu.EU.Registers.AX = 0x2ff;
cpu.NextInstruction();
Assert.AreEqual(0x01, cpu.EU.Registers.AH, "AAA AH result failed");
Assert.AreEqual(0x09, cpu.EU.Registers.AL, "AAA AL result failed");
Assert.AreEqual(true, cpu.EU.CondReg.AuxCarryFlag, "AAA auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "AAA carry flag failed");
}
public void Test8e()
{
i8086CPU cpu = GetCPU(new byte[] { 0x8e, 0x45, 0x35 } /* MOV es, di+35 (16 bit) */);
cpu.Bus.ES = 0xffff;
cpu.EU.Registers.DI = 0x1015;
cpu.Bus.SaveData16(cpu.EU.Registers.DI + 0x35, 0x9f23);
cpu.NextInstruction();
Assert.AreEqual(0x9f23, cpu.Bus.ES, "Instruction 0x8e failed");
}
public void Test_A5_MOVS16()
{
i8086CPU cpu = GetCPU(new byte[] { 0xa5, 0xa5, 0xa5, 0xa5, 0xa5 });
cpu.Bus.SegmentOverride = i8086BusInterfaceUnit.SegmentOverrideState.UseDS;
cpu.EU.Registers.SI = 0x100;
cpu.EU.Registers.DI = 0x200;
// write a bunch of source data to DS:offset
byte value = 0xa1;
for (int ii = cpu.EU.Registers.SI; ii <= 0x120; ii++)
{
cpu.Bus.SaveData8(ii, value++);
}
// write a bunch of data to ES:offset (to show the correct data is overwritten)
cpu.Bus.SegmentOverride = i8086BusInterfaceUnit.SegmentOverrideState.UseES;
value = 0x55;
for (int ii = cpu.EU.Registers.DI; ii <= 0x220; ii++)
{
cpu.Bus.SaveData8(ii, value++);
}
cpu.Bus.SegmentOverride = i8086BusInterfaceUnit.SegmentOverrideState.NoOverride;
cpu.NextInstruction();
cpu.NextInstruction();
cpu.NextInstruction();
cpu.NextInstruction();
cpu.NextInstruction();
cpu.Bus.SegmentOverride = i8086BusInterfaceUnit.SegmentOverrideState.UseES;
Assert.AreEqual(0xa2a1, cpu.Bus.GetData16(0x200), "MOVSW 1 result failed");
Assert.AreEqual(0xa4a3, cpu.Bus.GetData16(0x202), "MOVSW 2 result failed");
Assert.AreEqual(0xa6a5, cpu.Bus.GetData16(0x204), "MOVSW 3 result failed");
Assert.AreEqual(0xa8a7, cpu.Bus.GetData16(0x206), "MOVSW 4 result failed");
Assert.AreEqual(0xaaa9, cpu.Bus.GetData16(0x208), "MOVSW 5 result failed");
}
public void Test_AAM()
{
i8086CPU cpu = GetCPU(new byte[] { 0xd4 });
cpu.EU.Registers.AL = 0x0f;
cpu.NextInstruction();
Assert.AreEqual(0x01, cpu.EU.Registers.AH, "AAM AH result failed");
Assert.AreEqual(0x05, cpu.EU.Registers.AL, "AAM AL result failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "AAM sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "AAM zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "AAM parity flag failed");
}
public void Test86()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x86, 0xd1 }); // XCHG CL,DL
cpu.EU.Registers.CL = 0x57;
cpu.EU.Registers.DL = 0xf3;
cpu.NextInstruction();
Assert.AreEqual(0x57, cpu.EU.Registers.DL, "XCHG (1) DL failed");
Assert.AreEqual(0xf3, cpu.EU.Registers.CL, "XCHG (1) CL failed");
cpu = GetCPU(new byte[] { 0x86, 0x36, 0x15, 0x01 }); /* XCHG [0115],DH */
cpu.EU.Registers.DH = 0x57;
cpu.Bus.SaveData8(0x0115, 0xf3);
cpu.NextInstruction();
Assert.AreEqual(0x57, cpu.Bus.GetData8(0x0115), "XCHG (2) [0115] failed");
Assert.AreEqual(0xf3, cpu.EU.Registers.DH, "XCHG (2) DH failed");
}
public void Test87()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x87, 0xd1 }); // XCHG CX,DX
cpu.EU.Registers.CX = 0x1057;
cpu.EU.Registers.DX = 0x23f3;
cpu.NextInstruction();
Assert.AreEqual(0x1057, cpu.EU.Registers.DX, "XCHG (1) DX failed");
Assert.AreEqual(0x23f3, cpu.EU.Registers.CX, "XCHG (1) CX failed");
cpu = GetCPU(new byte[] { 0x87, 0x36, 0x15, 0x01 }); /* XCHG [0115],SI */
cpu.EU.Registers.SI = 0x1057;
cpu.Bus.SaveData16(0x0115, 0x23f3);
cpu.NextInstruction();
Assert.AreEqual(0x1057, cpu.Bus.GetData16(0x0115), "XCHG (2) [0115] failed");
Assert.AreEqual(0x23f3, cpu.EU.Registers.SI, "XCHG (2) SI failed");
}
public void Test14()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x14, 0x28, /* ADC AL,28H */
0x14, 0x80, /* ADC AL,80H */
0x14, 0x40 /* ADC BH,40H */
});
cpu.EU.Registers.AL = 0xf7; // F7+28=11F. Carry=1, Parity=0, Zero=0, Sign=0, AuxCarry=0, Overflow=0
cpu.NextInstruction();
Assert.AreEqual(0x1f, cpu.EU.Registers.AL, "ADC (1) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "ADC (1) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "ADC (1) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (1) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "ADC (1) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (1) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "ADC (1) overflow flag failed");
cpu.EU.Registers.AL = 0x80; // 80+80+1=101. Carry=1, Parity=0, Zero=0, Sign=0, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x01, cpu.EU.Registers.AL, "ADC (2) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "ADC (2) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "ADC (2) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (2) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "ADC (2) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (2) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "ADC (2) overflow flag failed");
cpu.EU.Registers.AL = 0x40; // 40+40+1=81. Carry=0, Parity=1, Zero=0, Sign=1, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x81, cpu.EU.Registers.AL, "ADC (3) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "ADC (3) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "ADC (3) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (3) zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "ADC (3) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (3) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "ADC (3) overflow flag failed");
}
public void Test15()
{
// Test Flags
i8086CPU cpu = GetCPU(new byte[] { 0x15, 0x00, 0x28, /* ADC AX,2800H */
0x15, 0x00, 0x80, /* ADC AX,8000H */
0x15, 0x00, 0x40 /* ADC AX,4000H */
});
cpu.EU.Registers.AX = 0xf700; // F700+2800=11F00. Carry=1, Parity=0, Zero=0, Sign=0, AuxCarry=0, Overflow=0
cpu.NextInstruction();
Assert.AreEqual(0x1f00, cpu.EU.Registers.AX, "ADC (1) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "ADC (1) carry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.ParityFlag, "ADC (1) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (1) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "ADC (1) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (1) auxcarry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.OverflowFlag, "ADC (1) overflow flag failed");
cpu.EU.Registers.AX = 0x8000; // 80+80+1=10001. Carry=1, Parity=0, Zero=0, Sign=0, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x0001, cpu.EU.Registers.AX, "ADC (2) result failed");
Assert.AreEqual(true, cpu.EU.CondReg.CarryFlag, "ADC (2) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "ADC (2) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (2) zero flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.SignFlag, "ADC (2) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (2) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "ADC (2) overflow flag failed");
cpu.EU.Registers.AX = 0x4000; // 4000+4000+1=8001. Carry=0, Parity=0, Zero=0, Sign=1, AuxCarry=0, Overflow=1
cpu.NextInstruction();
Assert.AreEqual(0x8001, cpu.EU.Registers.AX, "ADC (3) result failed");
Assert.AreEqual(false, cpu.EU.CondReg.CarryFlag, "ADC (3) carry flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ParityFlag, "ADC (3) parity flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.ZeroFlag, "ADC (3) zero flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.SignFlag, "ADC (3) sign flag failed");
Assert.AreEqual(false, cpu.EU.CondReg.AuxCarryFlag, "ADC (3) auxcarry flag failed");
Assert.AreEqual(true, cpu.EU.CondReg.OverflowFlag, "ADC (3) overflow flag failed");
}
public void Test88()
{
byte value8;
i8086CPU cpu = GetCPU(new byte[] { 0x88, 0x4f, 0x10 } /* MOV [bx+10],CL */);
value8 = 0x2f;
cpu.EU.Registers.CL = value8;
cpu.NextInstruction();
Assert.AreEqual(value8, cpu.Bus.GetData8(cpu.EU.Registers.BX + 0x10), "Instruction 0x88 failed");
cpu.Boot(new byte[] { 0x88, 0x8f, 0x10, 0x00 } /* MOV [bx+10],CL using 16 bit displacement */);
value8 = 0x2f;
cpu.EU.Registers.CL = value8;
cpu.NextInstruction();
Assert.AreEqual(value8, cpu.Bus.GetData8(cpu.EU.Registers.BX + 0x10), "Instruction 0x88 failed");
// Test with segment override
cpu.Boot(new byte[] { 0x26, 0x88, 0x8f, 0x10, 0x00 } /* MOV [bx+10],CL using 16 bit displacement with ES override */);
value8 = 0x2f;
cpu.EU.Registers.CL = value8;
cpu.NextInstruction();
Assert.AreEqual(i8086BusInterfaceUnit.SegmentOverrideState.UseES, cpu.Bus.SegmentOverride, "Invalid segment override value");
cpu.NextInstruction();
// after the instruction the override should be turned off
Assert.AreEqual(i8086BusInterfaceUnit.SegmentOverrideState.NoOverride, cpu.Bus.SegmentOverride, "Invalid segment override value");
// now set the override again so the correct memory segment is accessed
cpu.Bus.SegmentOverride = i8086BusInterfaceUnit.SegmentOverrideState.UseES;
Assert.AreEqual(value8, cpu.Bus.GetData8(cpu.EU.Registers.BX + 0x10), "Instruction 0x88 failed");
}
