Esempio n. 1
0
        public void CP_D_HandlesHPlag()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x16, 0xB3, // LD D,B3H
                0xBA        // CP D
            });
            m.Cpu.Registers.A = 0x61;

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            regs.SFlag.ShouldBeTrue();
            regs.ZFlag.ShouldBeFalse();
            regs.HFlag.ShouldBeTrue();
            regs.PFlag.ShouldBeTrue();
            regs.CFlag.ShouldBeTrue();

            regs.NFlag.ShouldBeTrue();
            m.ShouldKeepRegisters(except: "F, D");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0003);
            m.Cpu.Tacts.ShouldBe(11L);
        }
Esempio n. 2
0
        public void CPL_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x3E, 0x81, // LD A,81H
                0x2F        // CPL
            });

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            m.ShouldKeepRegisters(except: "A, F");
            m.ShouldKeepMemory();
            m.ShouldKeepSFlag();
            m.ShouldKeepZFlag();
            m.ShouldKeepPVFlag();
            m.ShouldKeepCFlag();
            regs.HFlag.ShouldBeTrue();
            regs.NFlag.ShouldBeTrue();

            regs.A.ShouldBe((byte)0x7E);
            regs.PC.ShouldBe((ushort)0x0003);
            m.Cpu.Tacts.ShouldBe(11L);
        }
Esempio n. 3
0
        public void RR_A_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0xCB, 0x1F // RR A
            });
            var regs = m.Cpu.Registers;

            regs.A = 0x08;

            // --- Act
            m.Run();

            // --- Assert
            regs.A.ShouldBe((byte)0x04);

            regs.SFlag.ShouldBeFalse();
            regs.ZFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeFalse();
            regs.PFlag.ShouldBeFalse();

            regs.HFlag.ShouldBeFalse();
            regs.NFlag.ShouldBeFalse();
            m.ShouldKeepRegisters(except: "F, A");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(8L);
        }
Esempio n. 4
0
        public void INC_H_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x26, 0x43, // LD H,43H
                0x24        // INC H
            });

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            m.ShouldKeepRegisters(except: "H, F");
            m.ShouldKeepMemory();
            m.ShouldKeepCFlag();
            regs.NFlag.ShouldBeFalse();

            regs.H.ShouldBe((byte)0x44);
            regs.PC.ShouldBe((ushort)0x0003);
            m.Cpu.Tacts.ShouldBe(11L);
        }
Esempio n. 5
0
        public void LD_HL_NNi_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x2A, 0x00, 0x10 // LD HL,(1000H)
            });
            m.Memory[0x1000] = 0x34;
            m.Memory[0x1001] = 0x12;

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            m.ShouldKeepRegisters(except: "HL");
            m.ShouldKeepMemory();

            regs.HL.ShouldBe((ushort)0x1234);
            regs.PC.ShouldBe((ushort)0x0003);
            m.Cpu.Tacts.ShouldBe(16L);
        }
        public void JP_M_CollectsDebugInfo()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilHalt);

            m.InitCode(new byte[]
            {
                0x3E, 0xC0,       // LD A,C0H
                0x87,             // ADD A
                0xFA, 0x07, 0x00, // JP M,0007H
                0x76,             // HALT
                0x3E, 0xAA,       // LD A,AAH
                0x76              // HALT
            });

            // --- Act
            m.Run();

            // --- Assert
            var brLog = m.BranchEvents;

            brLog.Count.ShouldBe(1);
            var brManip = brLog[0];

            brManip.OperationAddress.ShouldBe((ushort)0x0003);
            brManip.Operation.ShouldBe("jp m,0007H");
            brManip.JumpAddress.ShouldBe((ushort)0x0007);
            brManip.Tacts.ShouldBe(21);
        }
        public void JR_NZ_CollectsDebugInfo()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x3E, 0x02, // LD A,02H
                0x3D,       // DEC A
                0x20, 0x02  // JR NZ,02H
            });

            // --- Act
            m.Run();

            // --- Assert
            var brLog = m.BranchEvents;

            brLog.Count.ShouldBe(1);
            var brManip = brLog[0];

            brManip.OperationAddress.ShouldBe((ushort)0x0003);
            brManip.Operation.ShouldBe("jr nz,0007H");
            brManip.JumpAddress.ShouldBe((ushort)0x0007);
            brManip.Tacts.ShouldBe(23);
        }
        public void LD_HLi_D_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x21, 0x00, 0x10, // LD HL,1000H
                0x16, 0xB9,       // LD D,B9H
                0x72              // LD (HL),D
            });

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            m.Memory[0x1000].ShouldBe((byte)0xB9);
            m.ShouldKeepRegisters(except: "HL, D");
            m.ShouldKeepMemory(except: "1000");

            regs.PC.ShouldBe((ushort)0x0006);
            m.Cpu.Tacts.ShouldBe(24L);
        }
Esempio n. 9
0
        public void SRL_L_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0xCB, 0x3D // SRL L
            });
            var regs = m.Cpu.Registers;

            regs.F |= FlagsSetMask.C;
            regs.L  = 0x10;

            // --- Act
            m.Run();

            // --- Assert
            regs.L.ShouldBe((byte)0x08);

            regs.SFlag.ShouldBeFalse();
            regs.ZFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeFalse();
            regs.PFlag.ShouldBeFalse();

            regs.HFlag.ShouldBeFalse();
            regs.NFlag.ShouldBeFalse();
            m.ShouldKeepRegisters(except: "F, L");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(8L);
        }
        public void LD_A_L_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x2E, 0xB9, // LD L,B9H
                0x7D        // LD A,L
            });

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            regs.A.ShouldBe((byte)0xB9);

            m.ShouldKeepRegisters(except: "A, L");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0003);
            m.Cpu.Tacts.ShouldBe(11L);
        }
        public void LD_A_HLi_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x21, 0x00, 0x10, // LD HL,1000H
                0x7E              // LD A,(HL)
            });
            m.Memory[0x1000] = 0xB9;

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            regs.A.ShouldBe((byte)0xB9);

            m.ShouldKeepRegisters(except: "A, HL");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0004);
            m.Cpu.Tacts.ShouldBe(17L);
        }
        public void XSRL_WorksAsExpected()
        {
            // --- Arrange
            const byte OFFS = 0x32;
            var        m    = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0xFD, 0xCB, OFFS, 0x3E // SRL (IY+32H)
            });
            var regs = m.Cpu.Registers;

            regs.IY = 0x1000;
            regs.F |= FlagsSetMask.C;
            m.Memory[regs.IY + OFFS] = 0x10;

            // --- Act
            m.Run();

            // --- Assert
            m.Memory[regs.IY + OFFS].ShouldBe((byte)0x08);

            regs.SFlag.ShouldBeFalse();
            regs.ZFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeFalse();
            regs.PFlag.ShouldBeFalse();

            regs.HFlag.ShouldBeFalse();
            regs.NFlag.ShouldBeFalse();
            m.ShouldKeepRegisters(except: "F, A");
            m.ShouldKeepMemory(except: "1032");

            regs.PC.ShouldBe((ushort)0x0004);
            m.Cpu.Tacts.ShouldBe(23L);
        }
Esempio n. 13
0
        public void RET_M_SetsStepOutValues()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x00,             // NOP
                0x3E, 0xC0,       // LD A,C0H
                0x87,             // ADD A
                0xF8,             // RET M
                0xC4, 0x01, 0x00, // CALL NZ,0001H
            }, 0x0000, 0x0005);

            // --- Act
            m.Run();

            // --- Assert
            m.CallStepOutEvents.Count.ShouldBe(1);
            m.CallStepOutEvents[0].ShouldBe((ushort)0x0001);
            m.StepOutPushEvents.Count.ShouldBe(1);
            m.StepOutPushEvents[0].ShouldBe((ushort)0x0008);

            m.RetStepOutEvents.Count.ShouldBe(1);
            m.StepOutPopEvents.Count.ShouldBe(1);
            m.StepOutPopEvents[0].ShouldBe((ushort)0x0008);
            m.StepOutAddress.ShouldBe((ushort)0x0008);
        }
Esempio n. 14
0
        public void CP_E_HandlesCarryFlag()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x1E, 0x60, // LD E,60H
                0xBB        // CP E
            });
            m.Cpu.Registers.A = 0x40;

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            regs.SFlag.ShouldBeTrue();
            regs.ZFlag.ShouldBeFalse();
            regs.HFlag.ShouldBeFalse();
            regs.PFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeTrue();

            regs.NFlag.ShouldBeTrue();
            m.ShouldKeepRegisters(except: "F, E");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0003);
            m.Cpu.Tacts.ShouldBe(11L);
        }
        public void JP_CollectsDebugInfo()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilHalt);

            m.InitCode(new byte[]
            {
                0x3E, 0x16,       // LD A,16H
                0xC3, 0x06, 0x00, // JP 0006H
                0x76,             // HALT
                0x3E, 0xAA,       // LD A,AAH
                0x76              // HALT
            });

            // --- Act
            m.Run();

            // --- Assert
            var brLog = m.BranchEvents;

            brLog.Count.ShouldBe(1);
            var brManip = brLog[0];

            brManip.OperationAddress.ShouldBe((ushort)0x0002);
            brManip.Operation.ShouldBe("jp 0006H");
            brManip.JumpAddress.ShouldBe((ushort)0x0006);
            brManip.Tacts.ShouldBe(17);
        }
Esempio n. 16
0
        public void SUB_L_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x3E, 0x36, // LD A,36H
                0x2E, 0x24, // LD L,24H
                0x95        // SUB L
            });

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            regs.A.ShouldBe((byte)0x12);
            regs.SFlag.ShouldBeFalse();
            regs.ZFlag.ShouldBeFalse();
            regs.HFlag.ShouldBeFalse();
            regs.PFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeFalse();

            regs.NFlag.ShouldBeTrue();
            m.ShouldKeepRegisters(except: "AF, L");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0005);
            m.Cpu.Tacts.ShouldBe(18L);
        }
        public void JR_E_CollectsDebugInfo()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x3E, 0x20, // LD A,20H
                0x18, 0x20  // JR 20H
            });

            // --- Act
            m.Run();

            // --- Assert
            var brLog = m.BranchEvents;

            brLog.Count.ShouldBe(1);
            var brManip = brLog[0];

            brManip.OperationAddress.ShouldBe((ushort)0x0002);
            brManip.Operation.ShouldBe("jr 0024H");
            brManip.JumpAddress.ShouldBe((ushort)0x0024);
            brManip.Tacts.ShouldBe(19);
        }
Esempio n. 18
0
        public void SBC_B_HandlesPFlag()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x3E, 0x61, // LD A,61H
                0x06, 0xB3, // LD B,B3H
                0x37,       // SCF
                0x98        // SBC B
            });

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            regs.A.ShouldBe((byte)0xAD);
            regs.SFlag.ShouldBeTrue();
            regs.ZFlag.ShouldBeFalse();
            regs.HFlag.ShouldBeTrue();
            regs.PFlag.ShouldBeTrue();
            regs.CFlag.ShouldBeTrue();

            regs.NFlag.ShouldBeTrue();
            m.ShouldKeepRegisters(except: "AF, B");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0006);
            m.Cpu.Tacts.ShouldBe(22L);
        }
        public void JP_IYi_CollectsDebugInfo()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0xFD, 0x21, 0x00, 0x10, // LD IY, 1000H
                0xFD, 0xE9              // JP (IY)
            });

            // --- Act
            m.Run();

            // --- Assert
            var brLog = m.BranchEvents;

            brLog.Count.ShouldBe(1);
            var brManip = brLog[0];

            brManip.OperationAddress.ShouldBe((ushort)0x0004);
            brManip.Operation.ShouldBe("jp (iy)");
            brManip.JumpAddress.ShouldBe((ushort)0x1000);
            brManip.Tacts.ShouldBe(22);
        }
Esempio n. 20
0
        public void SBC_HLi_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x3E, 0x36,       // LD A,36H
                0x21, 0x00, 0x10, // LD HL,1000H
                0x37,             // SCF
                0x9E              // SBC (HL)
            });
            m.Memory[0x1000] = 0x24;

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            regs.A.ShouldBe((byte)0x11);
            regs.SFlag.ShouldBeFalse();
            regs.ZFlag.ShouldBeFalse();
            regs.HFlag.ShouldBeFalse();
            regs.PFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeFalse();

            regs.NFlag.ShouldBeTrue();
            m.ShouldKeepRegisters(except: "AF, HL");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0007);
            m.Cpu.Tacts.ShouldBe(28L);
        }
Esempio n. 21
0
        public void LD_NNi_HL_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x21, 0x26, 0xA9, // LD HL,A926H
                0x22, 0x00, 0x10  // LD (1000H),HL
            });

            // --- Act
            var lBefore = m.Memory[0x1000];
            var hBefore = m.Memory[0x1001];

            m.Run();
            var lAfter = m.Memory[0x1000];
            var hAfter = m.Memory[0x1001];
            // --- Assert
            var regs = m.Cpu.Registers;

            m.ShouldKeepRegisters(except: "HL");
            m.ShouldKeepMemory(except: "1000-1001");

            regs.HL.ShouldBe((ushort)0xA926);
            lBefore.ShouldBe((byte)0x00);
            hBefore.ShouldBe((byte)0x00);
            lAfter.ShouldBe((byte)0x26);
            hAfter.ShouldBe((byte)0xA9);

            regs.PC.ShouldBe((ushort)0x0006);
            m.Cpu.Tacts.ShouldBe(26L);
        }
Esempio n. 22
0
        public void SBC_A_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x3E, 0x36, // LD A,36H
                0x37,       // SCF
                0x9F        // SBC A
            });

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            regs.A.ShouldBe((byte)0xFF);
            regs.SFlag.ShouldBeTrue();
            regs.ZFlag.ShouldBeFalse();
            regs.HFlag.ShouldBeTrue();
            regs.PFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeTrue();

            regs.NFlag.ShouldBeTrue();
            m.ShouldKeepRegisters(except: "AF");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0004);
            m.Cpu.Tacts.ShouldBe(15L);
        }
Esempio n. 23
0
        public void ADD_HL_HL_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x21, 0x34, 0x12, // LD HL,1234H
                0x29              // ADD HL,HL
            });

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            m.ShouldKeepRegisters(except: "F, HL");
            m.ShouldKeepMemory();
            m.ShouldKeepSFlag();
            m.ShouldKeepZFlag();
            m.ShouldKeepPVFlag();
            regs.NFlag.ShouldBeFalse();

            regs.CFlag.ShouldBeFalse();
            regs.HFlag.ShouldBeFalse();

            regs.HL.ShouldBe((ushort)0x2468);
            regs.PC.ShouldBe((ushort)0x0004);
            m.Cpu.Tacts.ShouldBe(21L);
        }
Esempio n. 24
0
        public void SUB_B_HandlesZeroFlag()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x3E, 0x40, // LD A,40H
                0x06, 0x40, // LD B,40H
                0x90        // SUB B
            });

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            regs.A.ShouldBe((byte)0x00);
            regs.SFlag.ShouldBeFalse();
            regs.ZFlag.ShouldBeTrue();
            regs.HFlag.ShouldBeFalse();
            regs.PFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeFalse();

            regs.NFlag.ShouldBeTrue();
            m.ShouldKeepRegisters(except: "AF, B");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0005);
            m.Cpu.Tacts.ShouldBe(18L);
        }
Esempio n. 25
0
        public void DEC_L_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x2E, 0x43, // LD L,43H
                0x2D        // DEC L
            });

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            m.ShouldKeepRegisters(except: "L, F");
            m.ShouldKeepMemory();
            m.ShouldKeepCFlag();
            regs.NFlag.ShouldBeTrue();

            regs.L.ShouldBe((byte)0x42);
            regs.PC.ShouldBe((ushort)0x0003);
            m.Cpu.Tacts.ShouldBe(11L);
        }
        public void DJNX_CollectsDebugInfo()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x06, 0x02, // LD B,02H
                0x10, 0x02  // DJNZ 02H
            });

            // --- Act
            m.Run();

            // --- Assert
            var brLog = m.BranchEvents;

            brLog.Count.ShouldBe(1);
            var brManip = brLog[0];

            brManip.OperationAddress.ShouldBe((ushort)0x0002);
            brManip.Operation.ShouldBe("djnz 0006H");
            brManip.JumpAddress.ShouldBe((ushort)0x0006);
            brManip.Tacts.ShouldBe(20);
        }
Esempio n. 27
0
        public void RR_HLi_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0xCB, 0x1E // RR (HL)
            });
            var regs = m.Cpu.Registers;

            regs.HL           = 0x1000;
            m.Memory[regs.HL] = 0x08;

            // --- Act
            m.Run();

            // --- Assert
            m.Memory[regs.HL].ShouldBe((byte)0x04);

            regs.SFlag.ShouldBeFalse();
            regs.ZFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeFalse();
            regs.PFlag.ShouldBeFalse();

            regs.HFlag.ShouldBeFalse();
            regs.NFlag.ShouldBeFalse();
            m.ShouldKeepRegisters(except: "F");
            m.ShouldKeepMemory(except: "1000");

            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(15L);
        }
        public void JR_C_CollectsDebugInfo()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x37,       // SCF
                0x38, 0x02  // JR C,02H
            });

            // --- Act
            m.Run();

            // --- Assert
            var brLog = m.BranchEvents;

            brLog.Count.ShouldBe(1);
            var brManip = brLog[0];

            brManip.OperationAddress.ShouldBe((ushort)0x0001);
            brManip.Operation.ShouldBe("jr c,0005H");
            brManip.JumpAddress.ShouldBe((ushort)0x0005);
            brManip.Tacts.ShouldBe(16);
        }
Esempio n. 29
0
        public void RL_B_SetsZeroFlag()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0xCB, 0x10 // RL B
            });
            var regs = m.Cpu.Registers;

            regs.B = 0x00;

            // --- Act
            m.Run();

            // --- Assert
            regs.B.ShouldBe((byte)0x00);

            regs.SFlag.ShouldBeFalse();
            regs.ZFlag.ShouldBeTrue();
            regs.CFlag.ShouldBeFalse();
            regs.PFlag.ShouldBeTrue();

            regs.HFlag.ShouldBeFalse();
            regs.NFlag.ShouldBeFalse();
            m.ShouldKeepRegisters(except: "F, B");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(8L);
        }
Esempio n. 30
0
        public void CP_C_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x0E, 0x24, // LD C,24H
                0xB9        // CP C
            });
            m.Cpu.Registers.A = 0x36;

            // --- Act
            m.Run();

            // --- Assert
            var regs = m.Cpu.Registers;

            regs.SFlag.ShouldBeFalse();
            regs.ZFlag.ShouldBeFalse();
            regs.HFlag.ShouldBeFalse();
            regs.PFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeFalse();

            regs.NFlag.ShouldBeTrue();
            m.ShouldKeepRegisters(except: "F, C");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0003);
            m.Cpu.Tacts.ShouldBe(11L);
        }