public void CheckAnd_Ani_() { // ANDI #<data>,<ea> // 0000 0010 0001 1001 0x0219 // 0000 0000 0000 0101 0x000A // ANDI #10,(A1) byte[] data = new byte[] { 0x02, 0x19, 0x00, 0x0A }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteAReg(0x1, 0x00FF0000); state.WriteByte(0x00FF0000, 0xFF); state.WriteByte(0x00FF0002, 0xAA); state.WriteDReg(0x1, 0xFF); state.FetchOpCode(); var opcode = new ANDI(state); Assert.That(opcode.Assembly, Is.EqualTo("ANDI #10,(A1)+")); Assert.That(state.PC, Is.EqualTo(0x04)); Assert.That(state.ReadAReg(0x1), Is.EqualTo(0x00FF0001)); Assert.That(state.ReadByte(0x00FF0000), Is.EqualTo(0x0000000A)); }
/// <summary> /// Initializes a new instance of the <see cref="ANDI"/> class. /// </summary> /// <param name="state">machine state.</param> public ANDI(MegadriveState state) : base("00000010ssmmmxxx", state) { var allowedModes = new[] { EffectiveAddressMode.DataRegister, EffectiveAddressMode.Address, EffectiveAddressMode.AddressPostIncrement, EffectiveAddressMode.AddressPreDecrement, EffectiveAddressMode.AddressWithDisplacement, EffectiveAddressMode.AddressWithIndex, EffectiveAddressMode.AbsoluteWord, EffectiveAddressMode.AbsoluteLong, }; this.ValidateEffectiveAddress(this.DecodeEffectiveAddressMode(), allowedModes); this.EffectiveAddress = this.FetchEffectiveAddress(); this.immediate = this.ReadImmediate(); var val = this.ReadValueForEffectiveAddress(); val &= this.immediate; this.WriteValueToEffectiveAddress(this.DecodeEffectiveAddressMode(), this.GetXn(), val); this.state.Condition_N = this.IsNegative(val); this.state.Condition_Z = this.IsZero(val); this.state.Condition_V = false; this.state.Condition_C = false; }
private OpCode decode_4XX0(MegadriveState state) { if (state.OpCode.CheckBits("0100100xxxxxxxxx") || state.OpCode.CheckBits("0100110xxxxxxxxx")) { if (state.OpCode.CheckBits("0100100xxx000xxx") || state.OpCode.CheckBits("0100110xxx000xxx")) { throw new NotImplementedException("EXT"); } else { return(new MOVEM(state)); } } if (state.OpCode.CheckBits("0100011xxxxxxxxx")) { if (state.OpCode.CheckBits("0100011011xxxxxx")) { return(new MOVEtoSR(state)); } else { throw new NotImplementedException(); } } throw new NotImplementedException(); }
public OpCode Decode(MegadriveState state) { switch (state.OpCode & 0xF000) { // 0000 case 0x0000: return(decode_0000(state)); // 0001 // 0010 // 0011 case 0x1000: case 0x2000: case 0x3000: return(decode_X000(state)); // 0100 case 0x4000: return(decode_4000(state)); // 0101 case 0x5000: return(decode_5000(state)); // 0110 case 0x6000: return(decode_6000(state)); // 0111 case 0x7000: return(decode_7000(state)); // 1000 case 0x8000: return(decode_8000(state)); // 1001 case 0x9000: return(decode_9000(state)); // 1011 case 0xB000: return(decode_B000(state)); // 1100 case 0xC000: return(decode_C000(state)); // 1101 case 0xD000: return(decode_D000(state)); // 1110 case 0xE000: return(decode_E000(state)); default: return(new Invalid(state)); } }
public void CheckIsZeroSetsZ() { // TST <ea> // 0100 1010 1011 1001 0x4AB9 // 0000 0000 1111 1111 0x00FF // 0000 0000 0000 0000 0x0000 // TST 0x00FF0000 byte[] data = new byte[] { 0x4A, 0xB9, 0x00, 0xFF, 0x00, 0x00 }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteByte(0xFF0000, 0x00); state.FetchOpCode(); state.SR |= 0x0011; var opcode = new TST(state); Assert.That(opcode.Assembly, Is.EqualTo("TST.l $00FF0000")); Assert.That(opcode.Size, Is.EqualTo(Size.Long)); Assert.That(state.PC, Is.EqualTo(0x00000006)); Assert.That(state.Condition_X, Is.True); // not affected Assert.That(state.Condition_N, Is.False); Assert.That(state.Condition_Z, Is.True); Assert.That(state.Condition_V, Is.False); // always cleared Assert.That(state.Condition_C, Is.False); // always cleared }
public void CheckAddD1To_A0i_() { // ADD Dn,<ea> // 1101 dddD ssmm mxxx // 1101 0011 0001 1000 0xD318 // ADD D1,(A0)+ byte[] data = new byte[] { 0xD3, 0x18 }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteDReg(0x1, 0x22221111); state.WriteAReg(0x0, 0x00FF0000); state.WriteByte(0x00FF0000, 0x22); state.FetchOpCode(); var opcode = new ADD(state); Assert.That(opcode.Assembly, Is.EqualTo("ADD.B D1,(A0)+")); Assert.That(state.PC, Is.EqualTo(0x02)); Assert.That(state.ReadAReg(0x0), Is.EqualTo(0x00FF0001)); Assert.That(state.ReadDReg(0x1), Is.EqualTo(0x22221111)); Assert.That(state.ReadByte(0x00FF0000), Is.EqualTo(0x33)); }
public void CheckMove_d16A0_ToD1() { // MOVE <ea>,<ea> // 0001 0010 0010 1000 0x1228 // 0000 0000 0000 0002 0x0002 // MOVE (d16,A0),D1 byte[] data = new byte[] { 0x12, 0x28, 0x00, 0x02 }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteAReg(0x0, 0x00FF0000); state.WriteByte(0x00FF0002, 0xAA); state.FetchOpCode(); var opcode = new MOVE(state); Assert.That(opcode.Assembly, Is.EqualTo("MOVE.b ($0002,A0),D1")); Assert.That(state.PC, Is.EqualTo(0x04)); Assert.That(state.ReadAReg(0x0), Is.EqualTo(0x00FF0000)); Assert.That(state.ReadDReg(0x1), Is.EqualTo(0x000000AA)); }
public void CheckLoad_A0_ToA1() { // LEA <ea>,An // 0100 0011 1101 0000 0x43D0 // LEA (A0),A1 byte[] data = new byte[] { 0x43, 0xD0 }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteAReg(0x0, 0x00FF0000); state.WriteByte(0x00FF0000, 0xAA); state.FetchOpCode(); var opcode = new LEA(state); Assert.That(opcode.Assembly, Is.EqualTo("LEA (A0),A1")); Assert.That(opcode.Size, Is.EqualTo(Size.Long)); Assert.That(state.PC, Is.EqualTo(0x00000002)); Assert.That(state.ReadAReg(0x0), Is.EqualTo(0x00FF0000)); Assert.That(state.ReadAReg(0x1), Is.EqualTo(0x00FF0000)); }
public void CheckMoveNumberToDRegister(byte number, DataRegister register) { // 0111ddd0bbbbbbbb // MOVEQ #0,D0 byte hi = 0x70; byte lo = number; hi |= (byte)((byte)register << 1); byte[] data = new byte[] { hi, lo }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteAReg(0x5, 0xFF0000); for (int i = 0; i < 16; i++) { state.WriteByte((uint)(0xFF0000 + i), (byte)(0x00 + i)); } state.FetchOpCode(); var opcode = new MOVEQ(state); Assert.That(opcode.Assembly, Is.EqualTo($"MOVEQ #{number},{register}")); Assert.That(opcode.Size, Is.EqualTo(Size.Long)); Assert.That(state.ReadDReg((byte)register), Is.EqualTo(number)); }
public void CheckMove_dA0_ToA1() { // 00ss aaa0 01mm mxxx // 0010 0010 0110 0000 0x2260 // MOVEM <ea>,An // MOVEM -(A0),A1 byte[] data = new byte[] { 0x22, 0x60 }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteByte(0x00FF0000, 0xAA); state.WriteByte(0x00FF0001, 0xBB); state.WriteByte(0x00FF0002, 0xCC); state.WriteByte(0x00FF0003, 0xDD); state.WriteAReg(0x0, 0x00FF0004); state.FetchOpCode(); var opcode = new MOVEA(state); Assert.That(opcode.Assembly, Is.EqualTo($"MOVEA -(A0),A1")); Assert.That(opcode.Size, Is.EqualTo(Size.Long)); Assert.That(state.ReadAReg(0x0), Is.EqualTo(0x00FF0000)); Assert.That(state.ReadAReg(0x1), Is.EqualTo(0xAABBCCDD)); }
public void CheckAdd_dA0_ToD1() { // ADD Dn,<ea> // 1101 dddD ssmm mxxx // 1101 0010 0010 0000 0xD220 // ADD -(A0),D1 byte[] data = new byte[] { 0xD2, 0x20 }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteDReg(0x1, 0x22221111); state.WriteAReg(0x0, 0x00FF0001); state.WriteByte(0x00FF0000, 0x22); state.FetchOpCode(); var opcode = new ADD(state); Assert.That(opcode.Assembly, Is.EqualTo("ADD.B -(A0),D1")); Assert.That(state.PC, Is.EqualTo(0x02)); Assert.That(state.ReadAReg(0x0), Is.EqualTo(0x00FF0000)); Assert.That(state.ReadDReg(0x1), Is.EqualTo(0x00000033)); Assert.That(state.ReadByte(0x00FF0000), Is.EqualTo(0x22)); }
public void CheckLoad_d16PC_ToA5() { // LEA <ea>,An // 0100 1011 1111 1010 0x4BFA // 0000 0000 0111 1100 0x007C // LEA (d16,PC),A5 // LEA (124,PC),A5 byte[] data = new byte[] { 0x4B, 0xFA, 0x00, 0x7C }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.FetchOpCode(); var opcode = new LEA(state); Assert.That(opcode.Assembly, Is.EqualTo("LEA ($007C,PC),A5")); Assert.That(opcode.Size, Is.EqualTo(Size.Long)); Assert.That(state.PC, Is.EqualTo(0x00000004)); Assert.That(state.ReadAReg(0x5), Is.EqualTo(0x7E)); }
public void CheckMove_A0i_ToA1() { // 00ss aaa0 01mm mxxx // 0001 0010 0101 1000 0x1258 // MOVEM <ea>,An // MOVEM (A0)+,A1 byte[] data = new byte[] { 0x12, 0x58 }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteByte(0x00FF0000, 0xAA); state.WriteByte(0x00FF0001, 0xBB); state.WriteAReg(0x0, 0x00FF0000); state.FetchOpCode(); var opcode = new MOVEA(state); Assert.That(opcode.Assembly, Is.EqualTo($"MOVEA (A0)+,A1")); Assert.That(opcode.Size, Is.EqualTo(Size.Word)); Assert.That(state.ReadAReg(0x0), Is.EqualTo(0x00FF0002)); Assert.That(state.ReadAReg(0x1), Is.EqualTo(0xAABB)); }
/// <summary> /// Initializes a new instance of the <see cref="MOVEUSP"/> class. /// </summary> /// <param name="state">machine state.</param> public MOVEUSP(MegadriveState state) : base("010011100110Daaa", state) { this.direction = this.GetDirection(); this.register = this.GetAn(); if (this.state.Condition_Supervisor) { switch (this.direction) { case MoveDirection.MemoryToRegister: throw new NotImplementedException(); break; case MoveDirection.RegisterToMemory: throw new NotImplementedException(); break; default: throw new InvalidStateException(); } } else { Writer.Write("TRAP", ConsoleColor.Red); } }
private OpCode decode_8000(MegadriveState state) { // divu // 1000 ddd0 11mm mxxx if (state.OpCode.CheckBits("1000xxx011xxxxxx")) { throw new NotImplementedException("DIVU"); } // divs // 1000 ddd1 11mm mxxx if (state.OpCode.CheckBits("1000xxx111xxxxxx")) { throw new NotImplementedException("DIVS"); } // sbcd // 1000 xxx1 0000 Mxxx if (state.OpCode.CheckBits("1000xxx10000xxxx")) { throw new NotImplementedException("SBCD"); } // or // 1000 dddD ssmm mxxx throw new NotImplementedException("OR"); }
/// <summary> /// Initializes a new instance of the <see cref="Bcc"/> class. /// </summary> /// <param name="state">machine state.</param> public Bcc(MegadriveState state) : base("0110ccccbbbbbbbb", state) { if (this.Size == Size.Word) { this.EffectiveAddress = this.FetchEffectiveAddress(EffectiveAddressMode.Immediate, 0x00); } if (this.Size == Size.Byte) { this.EffectiveAddress = (byte)this.GetImmediate(); } if (this.CheckCondition()) { if (this.Size == Size.Word) { this.state.PC += (uint)((short)this.EffectiveAddress - 2); } if (this.Size == Size.Byte) { this.state.PC += (uint)((sbyte)this.EffectiveAddress); } } }
private OpCode decode_E000(MegadriveState state) { if (state.OpCode.CheckBits("1110xxxx11xxxxxx")) { return(decode_E0C0(state)); } return(decode_E0X0(state)); }
private OpCode decode_50C0(MegadriveState state) { if (state.OpCode.CheckBits("0101xxxx11001xxx")) { return(new DBcc(state)); } // 0101 xxxx 11?? ?xxx throw new NotImplementedException("Scc?"); }
private OpCode decode_X000(MegadriveState state) { if (state.OpCode.GetBits(6, 3) == 0x0001) { return(new MOVEA(state)); } else { return(new MOVE(state)); } }
/// <summary> /// Initializes a new instance of the <see cref="ADDX"/> class. /// </summary> /// <param name="state">machine state.</param> public ADDX(MegadriveState state) : base("1101xxx1ss00Dyyy", state) { throw new NotImplementedException(); //X — Set the same as the carry bit. //N — Set if the result is negative; cleared otherwise. //Z — Cleared if the result is nonzero; unchanged otherwise. //V — Set if an overflow occurs; cleared otherwise. //C — Set if a carry is generated; cleared otherwise. }
/// <summary> /// Initializes a new instance of the <see cref="TST"/> class. /// </summary> /// <param name="state">machine state.</param> public TST(MegadriveState state) : base("01001010ssmmmxxx", state) { this.EffectiveAddress = this.FetchEffectiveAddress(); var val = this.ReadValueForEffectiveAddress(); state.Condition_N = this.IsNegative(val); state.Condition_Z = this.IsZero(val); state.Condition_V = false; state.Condition_C = false; }
/// <summary> /// Initializes a new instance of the <see cref="MOVEQ"/> class. /// </summary> /// <param name="state">machine state</param> public MOVEQ(MegadriveState state) : base("0111ddd0bbbbbbbb", state) { this.immediate = this.GetImmediate(); this.register = this.GetDn(); this.state.WriteDReg((byte)this.register, this.immediate); this.state.Condition_N = this.IsNegative(this.immediate); this.state.Condition_Z = this.IsZero(this.immediate); this.state.Condition_V = false; this.state.Condition_C = false; }
private OpCode decode_6000(MegadriveState state) { if (state.OpCode.CheckBits("01100000xxxxxxxx")) { return(new BRA(state)); } if (state.OpCode.CheckBits("01100001xxxxxxxx")) { throw new NotImplementedException("BSR"); } return(new Bcc(state)); }
private OpCode decode_D000(MegadriveState state) { if (state.OpCode.CheckBits("1101xxxx11xxxxxx")) { throw new NotImplementedException("ADDA"); } if (state.OpCode.CheckBits("1101xxx1xx000xxx") || state.OpCode.CheckBits("1101xxx1xx001xxx")) { return(new ADDX(state)); } // add return(new ADD(state)); }
/// <summary> /// Initializes a new instance of the <see cref="MOVE"/> class. /// </summary> /// <param name="state">machine state.</param> public MOVE(MegadriveState state) : base("00ss______mmmxxx", state) { this.SrcEA = this.FetchEffectiveAddress(this.DecodeEffectiveAddressMode(this.GetSrcM(), this.GetSrcXn()), this.GetSrcXn()); this.DstEA = this.FetchEffectiveAddress(this.DecodeEffectiveAddressMode(this.GetDstM(), this.GetDstXn()), this.GetDstXn()); var srcVal = this.ReadValueForEffectiveAddress(this.DecodeEffectiveAddressMode(this.GetSrcM(), this.GetSrcXn()), this.SrcEA, this.GetSrcXn()); this.WriteValueToEffectiveAddress(this.DecodeEffectiveAddressMode(this.GetDstM(), this.GetDstXn()), this.DstEA, this.GetDstXn(), srcVal, false); this.state.Condition_N = this.IsNegative(srcVal); this.state.Condition_Z = this.IsZero(srcVal); this.state.Condition_V = false; this.state.Condition_C = false; }
/// <summary> /// Initializes a new instance of the <see cref="DBcc"/> class. /// </summary> /// <param name="state">machine state.</param> public DBcc(MegadriveState state) : base("0101cccc11001ddd", state) { this.displacement = (short)this.ReadDataUsingPC(this.Size); // always WORD if (!this.CheckCondition()) { short dn = (short)(this.state.ReadDReg((byte)this.GetDn()) - 1); this.state.WriteDReg((byte)this.GetDn(), (uint)dn); if (dn != -1) { this.state.PC = (uint)(this.state.PC - 2 + this.displacement); } } }
private OpCode decode_0200(MegadriveState state) { switch (state.OpCode.GetBits(0, 8)) { // 0000 0010 0011 1100 case 0x023C: throw new NotImplementedException("ANDItoCCR"); // 0000 0010 0111 1100 case 0x027C: throw new NotImplementedException("ANDItoSR"); default: return(new ANDI(state)); } }
private OpCode decode_0000(MegadriveState state) { if (state.OpCode.GetBits(8, 1) == 0x1) { // MOVEP if (state.OpCode.GetBits(3, 3) == 0x1) { throw new NotImplementedException("MOVEP"); } // BTST, BCHG, BCLR, BSET switch (state.OpCode.GetBits(6, 2)) { case 0x00: return(new BTST(state)); case 0x01: throw new NotImplementedException("BCHG"); case 0x02: return(new BCLR(state)); case 0x03: throw new NotImplementedException("BSET"); } } switch (state.OpCode.GetBits(8, 4)) { // 0000 0110 xxxx xxxx case 0x0006: throw new NotImplementedException("ADDI"); // 0000 1100 xxxx xxxx case 0x000C: throw new NotImplementedException("CMPI"); // 0000 0010 xxxx xxxx case 0x0002: return(decode_0200(state)); // TODO: BTST default: throw new NotImplementedException(); } }
public void CheckA5PostIncMoveLongToReg() { // MOVEM <ea>,<ea> // 0100 1100 1101 1101 0x4CDD // 0001 1111 0000 0000 0x1F00 // MOVEM (A5)+,0001111100000000 byte[] data = new byte[] { 0x4C, 0xDD, 0x1F, 0x00 }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteAReg(0x5, 0xFF0000); for (int i = 0; i < 64; i++) { state.WriteByte((uint)(0xFF0000 + i), (byte)(0x00 + i)); } state.FetchOpCode(); var opcode = new MOVEM(state); Assert.That(opcode.Assembly, Is.EqualTo("MOVEM (A5)+,%0001111100000000")); Assert.That(opcode.Size, Is.EqualTo(Size.Long)); Assert.That(state.ReadAReg(0x0), Is.EqualTo(0x00010203)); Assert.That(state.ReadAReg(0x1), Is.EqualTo(0x04050607)); Assert.That(state.ReadAReg(0x2), Is.EqualTo(0x08090A0B)); Assert.That(state.ReadAReg(0x3), Is.EqualTo(0x0C0D0E0F)); Assert.That(state.ReadAReg(0x4), Is.EqualTo(0x10111213)); Assert.That(state.ReadAReg(0x5), Is.EqualTo(0x00FF0014)); Assert.That(state.ReadAReg(0x6), Is.EqualTo(0x0000)); Assert.That(state.ReadAReg(0x7), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x0), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x1), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x2), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x3), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x4), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x5), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x6), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x7), Is.EqualTo(0x0000)); Assert.That(state.PC, Is.EqualTo(0x00000004)); Assert.That(state.ReadAReg(0x5), Is.EqualTo(0x00FF0014)); }
public void CheckA5PostIncMoveWordToReg() { // MOVEM <ea>,<ea> // 0100 1100 1001 1101 0x4C9D // 0000 0000 1110 0000 0x00E0 // MOVEM (A5)+,0000000011100000 byte[] data = new byte[] { 0x4C, 0x9D, 0x00, 0xE0 }; MegadriveState state = new MegadriveState(new Data(data), 0x00000000, 0x00000000, 0x000000, 0x3FFFFF, 0x0FF0000, 0xFFFFFF); state.WriteAReg(0x5, 0xFF0000); for (int i = 0; i < 16; i++) { state.WriteByte((uint)(0xFF0000 + i), (byte)(0x00 + i)); } state.FetchOpCode(); var opcode = new MOVEM(state); Assert.That(opcode.Assembly, Is.EqualTo("MOVEM (A5)+,%0000000011100000")); Assert.That(opcode.Size, Is.EqualTo(Size.Word)); Assert.That(state.ReadAReg(0x0), Is.EqualTo(0x0000)); Assert.That(state.ReadAReg(0x1), Is.EqualTo(0x0000)); Assert.That(state.ReadAReg(0x2), Is.EqualTo(0x0000)); Assert.That(state.ReadAReg(0x3), Is.EqualTo(0x0000)); Assert.That(state.ReadAReg(0x4), Is.EqualTo(0x0000)); Assert.That(state.ReadAReg(0x5), Is.EqualTo(0xFF0006)); Assert.That(state.ReadAReg(0x6), Is.EqualTo(0x0000)); Assert.That(state.ReadAReg(0x7), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x0), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x1), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x2), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x3), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x4), Is.EqualTo(0x0000)); Assert.That(state.ReadDReg(0x5), Is.EqualTo(0x0001)); Assert.That(state.ReadDReg(0x6), Is.EqualTo(0x0203)); Assert.That(state.ReadDReg(0x7), Is.EqualTo(0x0405)); Assert.That(state.PC, Is.EqualTo(0x00000004)); Assert.That(state.ReadAReg(0x5), Is.EqualTo(0x00FF0006)); }