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

            m.InitCode(new byte[]
            {
                0xED, 0xB9 // CPDR
            });
            var regs = m.Cpu.Registers;

            regs.BC = 0x0003;
            regs.HL = 0x1002;
            regs.A  = 0xA6;
            m.Memory[regs.HL - 2] = 0xA5;
            m.Memory[regs.HL - 1] = 0xA6;
            m.Memory[regs.HL]     = 0xA7;

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

            // --- Assert

            regs.BC.ShouldBe((ushort)0x0001);
            regs.HL.ShouldBe((ushort)0x1000);

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

            regs.NFlag.ShouldBeTrue();
            regs.CFlag.ShouldBeFalse();
            m.ShouldKeepRegisters(except: "F, BC, HL");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(37L);
        }
Ejemplo n.º 2
0
        public void INDR_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0xED, 0xBA // INDR
            });
            var regs = m.Cpu.Registers;

            regs.BC = 0x03CC;
            regs.HL = 0x1002;
            m.IoInputSequence.Add(0x69);
            m.IoInputSequence.Add(0x6A);
            m.IoInputSequence.Add(0x6B);

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

            // --- Assert

            m.Memory[0x1000].ShouldBe((byte)0x6B);
            m.Memory[0x1001].ShouldBe((byte)0x6A);
            m.Memory[0x1002].ShouldBe((byte)0x69);
            regs.B.ShouldBe((byte)0x00);
            regs.C.ShouldBe((byte)0xCC);
            regs.HL.ShouldBe((ushort)0x0FFF);

            regs.ZFlag.ShouldBeTrue();
            regs.NFlag.ShouldBeTrue();
            regs.CFlag.ShouldBeFalse();
            m.ShouldKeepRegisters(except: "F, BC, HL");
            m.ShouldKeepMemory(except: "1000-1002");

            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(58L);
        }
Ejemplo n.º 3
0
        public void OUTD_WorksWithZeroedCounter()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0xED, 0xAB // OUTD
            });
            var regs = m.Cpu.Registers;

            regs.BC           = 0x01CC;
            regs.HL           = 0x1000;
            m.Memory[regs.HL] = 0x29;

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

            // --- Assert

            regs.B.ShouldBe((byte)0x00);
            regs.C.ShouldBe((byte)0xCC);
            regs.HL.ShouldBe((ushort)0x0FFF);

            regs.ZFlag.ShouldBeTrue();
            regs.NFlag.ShouldBeTrue();
            regs.CFlag.ShouldBeTrue();
            m.ShouldKeepRegisters(except: "F, BC, HL");
            m.ShouldKeepMemory(except: "1000");

            m.IoAccessLog.Count.ShouldBe(1);
            m.IoAccessLog[0].Address.ShouldBe((ushort)0x00CC);
            m.IoAccessLog[0].Value.ShouldBe((byte)0x29);
            m.IoAccessLog[0].IsOutput.ShouldBeTrue();

            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(16L);
        }
Ejemplo n.º 4
0
        public void LD_SP_NN_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0x31, 0x26, 0xA9 // LD SP,A926H
            });

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

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

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

            regs.SP.ShouldBe((ushort)0xA926);
            regs.PC.ShouldBe((ushort)0x0003);
            m.Cpu.Tacts.ShouldBe(10L);
        }
Ejemplo n.º 5
0
        public void DJNX_E_WorksWithJump()
        {
            // --- 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 regs = m.Cpu.Registers;

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

            regs.PC.ShouldBe((ushort)0x0006);
            m.Cpu.Tacts.ShouldBe(20L);
        }
Ejemplo n.º 6
0
        public void JR_C_E_WorksWithJump()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

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

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

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

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

            regs.PC.ShouldBe((ushort)0x0005);
            m.Cpu.Tacts.ShouldBe(16L);
        }
Ejemplo n.º 7
0
        public void LD_L_N_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0x3E, 0x26 // LD A,26H
            });

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

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

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

            regs.A.ShouldBe((byte)0x26);
            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(7L);
        }
Ejemplo n.º 8
0
        public void LDI_WorksWithZeroedCounter()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0xED, 0xA0 // LDI
            });
            var regs = m.Cpu.Registers;

            regs.BC           = 0x0001;
            regs.HL           = 0x1000;
            regs.DE           = 0x1001;
            m.Memory[regs.HL] = 0xA5;
            m.Memory[regs.DE] = 0x11;

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

            // --- Assert

            m.Memory[0x1001].ShouldBe((byte)0xA5);
            regs.BC.ShouldBe((ushort)0x0000);
            regs.HL.ShouldBe((ushort)0x1001);
            regs.DE.ShouldBe((ushort)0x1002);
            regs.PFlag.ShouldBeFalse();

            regs.HFlag.ShouldBeFalse();
            regs.NFlag.ShouldBeFalse();
            regs.CFlag.ShouldBeFalse();
            m.ShouldKeepRegisters(except: "F, BC, DE, HL");
            m.ShouldKeepMemory(except: "1001");

            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(16L);
        }
Ejemplo n.º 9
0
        public void CPI_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0xED, 0xA1 // CPI
            });
            var regs = m.Cpu.Registers;

            regs.BC           = 0x0010;
            regs.HL           = 0x1000;
            regs.A            = 0x11;
            m.Memory[regs.HL] = 0xA5;

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

            // --- Assert

            regs.BC.ShouldBe((ushort)0x000F);
            regs.HL.ShouldBe((ushort)0x1001);

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

            regs.NFlag.ShouldBeTrue();
            regs.CFlag.ShouldBeFalse();
            m.ShouldKeepRegisters(except: "F, BC, HL");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(16L);
        }
Ejemplo n.º 10
0
        public void CCF_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x37, // SCF
                0x3F  // CCF
            });

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

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

            m.ShouldKeepRegisters(except: "F");
            m.ShouldKeepMemory();
            regs.CFlag.ShouldBeFalse();

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

            m.InitCode(new byte[]
            {
                0x31, 0x26, 0xA9, // LD SP,A926H
                0x3B              // DEC SP
            });

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

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

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

            regs.SP.ShouldBe((ushort)0xA925);
            regs.PC.ShouldBe((ushort)0x0004);
            m.Cpu.Tacts.ShouldBe(16L);
        }
Ejemplo n.º 12
0
        public void LD_A_NNi_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

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

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

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

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

            regs.A.ShouldBe((byte)0x34);
            regs.PC.ShouldBe((ushort)0x0003);
            m.Cpu.Tacts.ShouldBe(13L);
        }
Ejemplo n.º 13
0
        public void LD_HLi_N_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x21, 0x00, 0x10, // LD HL,1000H
                0x36, 0x56        // LD (HL),56H
            });

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

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

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

            regs.PC.ShouldBe((ushort)0x0005);
            m.Cpu.Tacts.ShouldBe(20L);
        }
Ejemplo n.º 14
0
        public void LD_A_BCi_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x01, 0x03, 0x00, // LD BC,0003H
                0x0A              // LD A,(BC)
            });

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

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

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

            regs.A.ShouldBe((byte)0x0A);
            regs.PC.ShouldBe((ushort)0x0004);
            m.Cpu.Tacts.ShouldBe(17L);
        }
Ejemplo n.º 15
0
        public void INC_BC_WorksAsExpected2()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x01, 0xFF, 0xFF, // LD BC,FFFFH
                0x03              // INC BC
            });

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

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

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

            regs.BC.ShouldBe((ushort)0x0000);
            regs.PC.ShouldBe((ushort)0x0004);
            m.Cpu.Tacts.ShouldBe(16L);
        }
Ejemplo n.º 16
0
        public void CPD_WorksWithByteFoundAndZeroedCounter()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.OneInstruction);

            m.InitCode(new byte[]
            {
                0xED, 0xA9 // CPD
            });
            var regs = m.Cpu.Registers;

            regs.BC           = 0x0001;
            regs.HL           = 0x1000;
            regs.A            = 0xA5;
            m.Memory[regs.HL] = 0xA5;

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

            // --- Assert

            regs.BC.ShouldBe((ushort)0x0000);
            regs.HL.ShouldBe((ushort)0x0FFF);

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

            regs.NFlag.ShouldBeTrue();
            regs.CFlag.ShouldBeFalse();
            m.ShouldKeepRegisters(except: "F, BC, HL");
            m.ShouldKeepMemory();

            regs.PC.ShouldBe((ushort)0x0002);
            m.Cpu.Tacts.ShouldBe(16L);
        }
Ejemplo n.º 17
0
        public void JP_HLi_WorksAsExpected()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

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

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

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

            regs.PC.ShouldBe((ushort)0x1000);

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

            m.Cpu.Tacts.ShouldBe(14L);
        }
Ejemplo n.º 18
0
        public void INC_DE_WorksAsExpected1()
        {
            // --- Arrange
            var m = new Z80TestMachine(RunMode.UntilEnd);

            m.InitCode(new byte[]
            {
                0x11, 0x26, 0xA9, // LD DE,A926H
                0x13              // INC DE
            });

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

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

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

            regs.DE.ShouldBe((ushort)0xA927);
            regs.PC.ShouldBe((ushort)0x0004);
            m.Cpu.Tacts.ShouldBe(16L);
        }