public void DataMovOperationsTests_LOADRIND_Success() { // LOADRIND Ra,Rb {F1} R[Ra] <- mem[R[Rb]] byte Ra = 1; byte Rb = 2; string dataHexRa = "9"; string dataHexRb = "40"; string valueInMemory = UnitConverter.IntToHex(52); // setting Registers and Memory values micro.WriteToMemory( UnitConverter.HexToInt(dataHexRb), valueInMemory); Assert.AreEqual(valueInMemory, micro.ReadFromMemory(UnitConverter.HexToInt(dataHexRb))); micro.MicroRegisters.SetRegisterValue(Ra, dataHexRa); micro.MicroRegisters.SetRegisterValue(Rb, dataHexRb); Console.WriteLine(micro.MicroRegisters.ToString()); Assert.AreEqual("Registers[0,9,64,0,0,0,0,0]", micro.MicroRegisters.ToString()); // starting tests MCInstructionF1 i1 = new MCInstructionF1(3, "00101", UnitConverter.IntToBinary(Ra), UnitConverter.IntToBinary(Rb) ); InstructionSetExe.ExecuteInstruction(i1, micro); Console.WriteLine($"Register after execution: {micro.MicroRegisters}"); Assert.AreEqual(valueInMemory, micro.MicroRegisters.GetRegisterValue(Ra)); }
public void DataMovOperationsTests_StoreValueInRegisterToMemory_Success() { // Set register state to Registers[0,0,4,16,0,0,0,0] micro.MicroRegisters.SetRegisterValue(2, "04"); micro.MicroRegisters.SetRegisterValue(3, "10"); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual("Registers[0,0,4,16,0,0,0,0]", micro.MicroRegisters.ToString()); string memoryAddress1 = UnitConverter.IntToBinary(50); string memoryAddress2 = UnitConverter.IntToBinary(51); Console.WriteLine($"Memory1: {UnitConverter.BinaryToInt(memoryAddress1)}"); Console.WriteLine($"Memory1: {UnitConverter.BinaryToInt(memoryAddress2)}"); // {F2} STORE mem, Ra [mem] <- R[Ra] MCInstructionF2 i1 = new MCInstructionF2(3, "00011", "010", memoryAddress1); MCInstructionF2 i2 = new MCInstructionF2(3, "00011", "011", memoryAddress2); // execute store InstructionSetExe.ExecuteInstruction(i1, micro); InstructionSetExe.ExecuteInstruction(i2, micro); Console.WriteLine($"VirtualMemory #{UnitConverter.BinaryToInt(memoryAddress1)}: " + $"{UnitConverter.HexToInt(micro.ReadFromMemory(UnitConverter.BinaryToInt(memoryAddress1)))}"); Console.WriteLine($"VirtualMemory #{UnitConverter.BinaryToInt(memoryAddress2)}: " + $"{UnitConverter.HexToInt(micro.ReadFromMemory(UnitConverter.BinaryToInt(memoryAddress2)))}"); Assert.AreEqual(4, UnitConverter.HexToInt(micro.ReadFromMemory( UnitConverter.BinaryToInt(memoryAddress1) ))); Assert.AreEqual(16, UnitConverter.HexToInt(micro.ReadFromMemory( UnitConverter.BinaryToInt(memoryAddress2) ))); }
public void FlowControlOperationsTests_CALL_Success() { //init // CALL address {F3} // SP <- SP - 2 // mem[SP] <- PC // PC <- address ushort expectedSPVal = 98; string addressOfCall = UnitConverter.ByteToBinary(33); byte initialValueOfPC = 12; micro.StackPointer = 100; micro.ProgramCounter = initialValueOfPC; // address: 2 MCInstructionF3 i1 = new MCInstructionF3(30, "11110", addressOfCall); // execute InstructionSetExe.ExecuteInstruction(i1, micro); Assert.AreEqual(expectedSPVal, micro.StackPointer); // expected data in Address: 33 Assert.AreEqual(UnitConverter.ByteToHex(initialValueOfPC), micro.ReadFromMemory(micro.StackPointer)); // program counter should be equal to 98 Assert.AreEqual(UnitConverter.BinaryToByte(addressOfCall), micro.ProgramCounter); }
public void FlowControlOperationsTests_NEQ_AreNotEqual() { // NEQ Ra, Rb {F1} Cond <- R[Ra] != R[Rb] string ra = "010"; // 2 string rb = "101"; // 5 string valInA = "00101101"; // 45 string valInB = "00101101"; // 45 bool result = false; // set data in register micro.MicroRegisters.SetRegisterValue( UnitConverter.BinaryToByte(ra), UnitConverter.BinaryToHex(valInA)); micro.MicroRegisters.SetRegisterValue( UnitConverter.BinaryToByte(rb), UnitConverter.BinaryToHex(valInB)); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual($"Registers[0,0,45,0,0,45,0,0]", micro.MicroRegisters.ToString()); // start instruction MCInstructionF1 instructionF1 = new MCInstructionF1(4, "11100", ra, rb); Console.WriteLine(instructionF1); InstructionSetExe.ExecuteInstruction(instructionF1, micro); Console.WriteLine(micro); Assert.AreEqual(result, micro.ConditionalBit); }
public void FlowControlOperationsTests_JMPRIND_Success() { // JMPRIND Ra {F1} [pc] <- [R[ra]] byte ra = 1; byte rb = 3; string addressInRa = UnitConverter.ByteToHex(100); string addressInRb = UnitConverter.ByteToHex(8); // set data in Register micro.MicroRegisters.SetRegisterValue(ra, addressInRa); micro.MicroRegisters.SetRegisterValue(rb, addressInRb); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual("Registers[0,100,0,8,0,0,0,0]", micro.MicroRegisters.ToString()); // start instruction MCInstructionF1 i1 = new MCInstructionF1(4, "10100", UnitConverter.ByteToBinary(ra)); MCInstructionF1 i2 = new MCInstructionF1(4, "10100", UnitConverter.ByteToBinary(rb)); Console.WriteLine(i1); Console.WriteLine(i2); // assert that program counter starts at 0 Assert.AreEqual(0, micro.ProgramCounter); InstructionSetExe.ExecuteInstruction(i1, micro); Assert.AreEqual(100, micro.ProgramCounter); InstructionSetExe.ExecuteInstruction(i2, micro); Assert.AreEqual(8, micro.ProgramCounter); }
public void FlowControlOperationsTests_GRT_Success2() { // GRT Ra, Rb {F1} Cond <- R[Ra] > R[Rb] string ra = "001"; // 1 string rb = "010"; // 2 string valInA = "00000101"; // 5 string valInB = "00000111"; // 7 bool result = false; // set data in register micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(ra), UnitConverter.BinaryToHex(valInA)); micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rb), UnitConverter.BinaryToHex(valInB)); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual($"Registers[0,5,7,0,0,0,0,0]", micro.MicroRegisters.ToString()); // start instruction MCInstructionF1 instructionF1 = new MCInstructionF1(4, "11001", ra, rb); Console.WriteLine(instructionF1); InstructionSetExe.ExecuteInstruction(instructionF1, micro); Console.WriteLine(micro); Assert.AreEqual(result, micro.ConditionalBit); }
public void FlowControlOperationsTests_LOOP_Success() { // LOOP Ra, address {F2} // [R[ra]] <- [R[ra]] – 1 //If R[Ra] != 0 [pc] <- address byte ra = 1; sbyte value = 100; string dataInRaBin = UnitConverter.ByteToBinary(value); string addressToGoHex = "AF"; // set register micro.MicroRegisters.SetRegisterValue(ra, UnitConverter.BinaryToHex(dataInRaBin)); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual("Registers[0,100,0,0,0,0,0,0]", micro.MicroRegisters.ToString()); // start instruction MCInstructionF2 i1 = new MCInstructionF2(2, "11000", UnitConverter.ByteToBinary(ra), UnitConverter.HexToBinary(addressToGoHex)); InstructionSetExe.ExecuteInstruction(i1, micro); Console.WriteLine($"Expected PC: {UnitConverter.HexToInt(addressToGoHex)}"); Console.WriteLine(micro); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual(value - 1, UnitConverter.HexToInt(micro.MicroRegisters.GetRegisterValue(ra))); Assert.AreEqual(UnitConverter.HexToInt(addressToGoHex), micro.ProgramCounter); }
public void DataMovOperationsTests_LOADIntoR0_Success() { string value2 = "00010000"; // LOAD R0 02 MCInstructionF2 i1 = new MCInstructionF2(3, "00001", "000", value2); InstructionSetExe.ExecuteInstruction(i1, micro); }
public void FlowControlOperationsTests_JCONDRIN_Success() { // JCONDRIN Ra {F3} If cond then [pc] <- [R[ra]] byte ra = 1; byte rb = 3; byte v1 = 100; byte v2 = 8; string addressInRa = UnitConverter.ByteToHex(v1); string addressInRb = UnitConverter.ByteToHex(v2); // set data in Register micro.MicroRegisters.SetRegisterValue(ra, addressInRa); micro.MicroRegisters.SetRegisterValue(rb, addressInRb); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual($"Registers[0,{v1},0,{v2},0,0,0,0]", micro.MicroRegisters.ToString()); // start instruction MCInstructionF1 i1 = new MCInstructionF1(4, "10110", UnitConverter.ByteToBinary(ra)); MCInstructionF1 i2 = new MCInstructionF1(4, "10110", UnitConverter.ByteToBinary(rb)); Console.WriteLine(i1); Console.WriteLine(i2); // assert that program counter starts at 0 Assert.AreEqual(0, micro.ProgramCounter); // set conditional to true micro.ConditionalBit = true; Console.WriteLine(micro); // when instructions executes PC will change InstructionSetExe.ExecuteInstruction(i1, micro); Console.WriteLine(micro); Assert.AreEqual(v1, micro.ProgramCounter); // cond bit is false, pc will not change InstructionSetExe.ExecuteInstruction(i2, micro); Console.WriteLine($"CondBit False: {micro}"); Assert.AreEqual(v1 + 2, micro.ProgramCounter); // now set to true micro.ConditionalBit = true; InstructionSetExe.ExecuteInstruction(i2, micro); Console.WriteLine(micro); Assert.AreEqual(v2, micro.ProgramCounter); }
public void DataMovOperationsTests_STOREFrom0_Success() { string addrs = "00000010"; // STORE R0 02 MCInstructionF2 i1 = new MCInstructionF2(3, "00011", "000", addrs); InstructionSetExe.ExecuteInstruction(i1, micro); Assert.AreEqual("00", micro.ReadFromMemory( UnitConverter.BinaryToInt(addrs) )); }
public void DataMovOperationsTests_STORERIND_Success() { // STORERIND Ra,Rb {F1} mem[R[Ra]] <- R[Rb] byte registerA = 3; byte registerB = 6; string expectedValueInMem = UnitConverter.IntToHex(40); // data to write in address R[Ra] string dataInBHex = UnitConverter.IntToHex(40); // addres to write data to string dataInAHex = UnitConverter.IntToHex(110); // set data in register and VM //Ra micro.MicroRegisters .SetRegisterValue(registerA, dataInAHex); // Rb micro.MicroRegisters .SetRegisterValue(registerB, dataInBHex); Console.WriteLine(micro.MicroRegisters); // assert that register contain the corret data Assert.AreEqual(dataInAHex, micro.MicroRegisters.GetRegisterValue(registerA)); Assert.AreEqual(dataInBHex, micro.MicroRegisters.GetRegisterValue(registerB)); //// // set instruction MCInstructionF1 instructionF1 = new MCInstructionF1(4, "00110", UnitConverter.IntToBinary(registerA), UnitConverter.IntToBinary(registerB) ); // execute instruction InstructionSetExe.ExecuteInstruction(instructionF1, micro); Console.WriteLine($"After execution: {micro.MicroRegisters}"); Console.WriteLine($"Value in address {dataInBHex}: {UnitConverter.HexToInt(expectedValueInMem)}"); Assert.AreEqual( expectedValueInMem, micro.ReadFromMemory(UnitConverter.HexToInt(dataInAHex)) ); }
public void DataMovOperationsTests_PUSH2_Success() { //init micro.StackPointer = 0; micro.MicroRegisters.SetRegisterValue(4, "05"); MCInstructionF2 i1 = new MCInstructionF2(3, "00100", "100", null); ushort SPNewValue = 4095; //execute InstructionSetExe.ExecuteInstruction(i1, micro); Assert.AreEqual(SPNewValue, micro.StackPointer); Assert.AreEqual("05", micro.ReadFromMemory(micro.StackPointer)); }
public void DataMovOperationsTests_POP3_Success() { //init micro.StackPointer = 4095; micro.WriteToMemory(4095, "FF"); MCInstructionF2 i1 = new MCInstructionF2(3, "00010", "010", null); ushort SPNewValue = 0; //execute InstructionSetExe.ExecuteInstruction(i1, micro); Assert.AreEqual(SPNewValue, micro.StackPointer); Assert.AreEqual("FF", micro.MicroRegisters.GetRegisterValue(2)); }
public void LogicOperationsTests_OR_Success() { // AND Ra, Rb, Rc {F1} R[Ra]<- R[Rb]*R[Rc] string ra = "001"; // 1 string rb = "011"; // 3 string rc = "111"; // 7 string valInB = "00100100"; string valInC = "11101111"; string resultA = "11101111"; // set data in register micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rb), UnitConverter.BinaryToHex(valInB)); micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rc), UnitConverter.BinaryToHex(valInC)); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual( UnitConverter.BinaryToHex(valInB), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(rb)) ); Assert.AreEqual( UnitConverter.BinaryToHex(valInC), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(rc)) ); MCInstructionF1 i1 = new MCInstructionF1(3, "01100", ra, rb, rc); Console.WriteLine(i1); // execute instruction InstructionSetExe.ExecuteInstruction(i1, micro); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual( UnitConverter.BinaryToHex(resultA), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra)) ); }
public void FlowControlOperationsTests_NOP_Success() { //init micro.StackPointer = 100; micro.ProgramCounter = 12; string savedAddresInMemory = "FF"; micro.WriteToMemory(100, savedAddresInMemory); MCInstructionF1 i1 = new MCInstructionF1(31, "11101", null); //execute InstructionSetExe.ExecuteInstruction(i1, micro); Assert.AreEqual(100, micro.StackPointer); Assert.AreEqual(14, micro.ProgramCounter); }
public void FlowControlOperationsTests_RETURN_Success() { //init micro.StackPointer = 100; micro.ProgramCounter = 12; string savedAddresInMemory = "FF"; micro.WriteToMemory(100, savedAddresInMemory); MCInstructionF3 i1 = new MCInstructionF3(31, "11111", null); ushort SPNewValue = 102; //execute InstructionSetExe.ExecuteInstruction(i1, micro); Assert.AreEqual(SPNewValue, micro.StackPointer); Assert.AreEqual(UnitConverter.HexToInt(savedAddresInMemory) + 2, micro.ProgramCounter); }
public void InstructionSetExeTester_SUB_Success() { // ADD Ra, Rb, Rc {F1} R[Ra]<- R[Rb]+R[Rc] string ra = "110"; // 6 string rb = "011"; // 3 string rc = "101"; // 5 sbyte valInB = 20; sbyte valInC = 83; sbyte resultA = (sbyte)(valInB - valInC); // set data in register micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rb), UnitConverter.IntToHex(valInB)); micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rc), UnitConverter.IntToHex(valInC)); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual( UnitConverter.IntToHex(valInB), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(rb)) ); Assert.AreEqual( UnitConverter.IntToHex(valInC), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(rc)) ); MCInstructionF1 i1 = new MCInstructionF1(3, "01000", ra, rb, rc); InstructionSetExe.ExecuteInstruction(i1, micro); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual( UnitConverter.ByteToHex(resultA), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra)) ); }
public void FlowControlOperationsTests_JCONDADDR_Success() { // JCONDADDR addr {F3} If cond then [pc] <- address ushort a1 = 233; ushort a2 = 325; string addressBin1 = UnitConverter.IntToBinary(a1); string addressBin2 = UnitConverter.IntToBinary(a2); // start instruction MCInstructionF3 i1 = new MCInstructionF3(4, "10111", addressBin1); MCInstructionF3 i2 = new MCInstructionF3(4, "10111", addressBin2); Console.WriteLine(i1); Console.WriteLine(i2); // assert that program counter starts at 0 Assert.AreEqual(0, micro.ProgramCounter); // set conditional to true micro.ConditionalBit = true; Console.WriteLine(micro); // when instructions executes PC will change InstructionSetExe.ExecuteInstruction(i1, micro); Console.WriteLine(micro); Assert.AreEqual(a1, micro.ProgramCounter); // cond bit is false, pc will not change InstructionSetExe.ExecuteInstruction(i2, micro); Console.WriteLine($"CondBit False: {micro}"); Assert.AreEqual(a1 + 2, micro.ProgramCounter); // now set to true micro.ConditionalBit = true; InstructionSetExe.ExecuteInstruction(i2, micro); Console.WriteLine(micro); Assert.AreEqual(a2, micro.ProgramCounter); }
public void DataMovOperationsTests_LoadConstantValueToRegister_Success() { string value1 = "00000100"; string value2 = "00010000"; // LOADIM R2 02 MCInstructionF2 i1 = new MCInstructionF2(3, "00001", "010", value1); // LOAD R2 03 MCInstructionF2 i2 = new MCInstructionF2(3, "00001", "011", value2); InstructionSetExe.ExecuteInstruction(i1, micro); Console.WriteLine($"Registers after Execution #1 -> {micro.MicroRegisters}"); InstructionSetExe.ExecuteInstruction(i2, micro); Console.WriteLine($"Registers after Execution #2 -> {micro.MicroRegisters}"); Assert.AreEqual(UnitConverter.BinaryToHex(value1), micro.MicroRegisters.GetRegisterValue(2)); Assert.AreEqual(UnitConverter.BinaryToHex(value2), micro.MicroRegisters.GetRegisterValue(3)); }
public void InstructionSetExeTester_SUBIM_Success() { // SUBIM Ra, cons {F2} R[Ra] <- R[Ra]-cons string ra = "001"; // 1 sbyte valInA = 20; sbyte constVal = -33; sbyte resultA = (sbyte)(valInA - constVal); // set data in register micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(ra), UnitConverter.ByteToHex(valInA)); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual( UnitConverter.IntToHex(valInA), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra)) ); MCInstructionF2 i2 = new MCInstructionF2(3, "01010", ra, UnitConverter.ByteToBinary(constVal) ); Console.WriteLine(i2); // execute instruction InstructionSetExe.ExecuteInstruction(i2, micro); Console.WriteLine(micro.MicroRegisters); Console.WriteLine($"Result in 0x{UnitConverter.ByteToHex((byte)resultA)}"); Console.WriteLine($"Result in binary: {UnitConverter.ByteToHex((byte)resultA)}"); Assert.AreEqual( UnitConverter.ByteToHex((byte)resultA), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra)) ); }
public void LogicOperationsTests_NOT_Success() { // NOT Ra,Rb {F1} R[Ra] <- Complement(R[Rb]) string ra = "001"; // 1 string rb = "011"; // 3 string valInB = "00100100"; string resultA = "11011011"; // set data in register micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rb), UnitConverter.BinaryToHex(valInB)); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual( UnitConverter.BinaryToHex(valInB), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(rb)) ); MCInstructionF1 i1 = new MCInstructionF1(3, "01110", ra, rb); Console.WriteLine(i1); // execute instruction InstructionSetExe.ExecuteInstruction(i1, micro); Console.WriteLine(micro.MicroRegisters); Console.WriteLine($"Expected: {UnitConverter.BinaryToHex(resultA)}," + $"Actual: {micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra))}"); Assert.AreEqual( UnitConverter.BinaryToHex(resultA), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra)) ); }
public void FlowControlOperationsTests_JMPADDR_Success() { // JMPADDR addr {F3} [pc] <- address string addressHex1 = UnitConverter.ByteToHex(6); string addressHex2 = UnitConverter.ByteToHex(44); // start instruction MCInstructionF3 i1 = new MCInstructionF3(4, "10101", UnitConverter.HexToBinary(addressHex1)); MCInstructionF3 i2 = new MCInstructionF3(4, "10101", UnitConverter.HexToBinary(addressHex2)); Console.WriteLine(i1); Console.WriteLine(i2); // assert that program counter starts at 0 Assert.AreEqual(0, micro.ProgramCounter); InstructionSetExe.ExecuteInstruction(i1, micro); Assert.AreEqual(6, micro.ProgramCounter); InstructionSetExe.ExecuteInstruction(i2, micro); Assert.AreEqual(44, micro.ProgramCounter); }
public void InstructionSetExeTester_ADDIM_Success() { // ADDIM Ra, cons {F2} R[Ra] <- R[Ra]+cons string ra = "110"; // 6 sbyte valInA = 20; sbyte constVal = -33; sbyte resultA = (sbyte)(valInA + constVal); // set data in register micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(ra), UnitConverter.ByteToHex(valInA)); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual( UnitConverter.ByteToHex(valInA), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra)) ); MCInstructionF2 i2 = new MCInstructionF2(3, "01001", ra, UnitConverter.ByteToBinary(constVal) ); Console.WriteLine(i2); InstructionSetExe.ExecuteInstruction(i2, micro); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual( UnitConverter.ByteToHex(resultA), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra)) ); }
public void DataMovOperationsTests_LoadVMValueToRegister_Success() { micro.WriteToMemory(2, "05"); micro.WriteToMemory(3, "07"); // LOAD R2 02 MCInstructionF2 i1 = new MCInstructionF2(3, "00000", "010", "00000010"); // LOAD R2 03 MCInstructionF2 i2 = new MCInstructionF2(3, "00000", "011", "00000011"); InstructionSetExe.ExecuteInstruction(i1, micro); Console.WriteLine($"Registers after Execution #1 -> {micro.MicroRegisters}"); Assert.AreEqual("05", micro.MicroRegisters.GetRegisterValue(2)); InstructionSetExe.ExecuteInstruction(i2, micro); Assert.AreEqual("07", micro.MicroRegisters.GetRegisterValue(3)); Console.WriteLine($"Registers after Execution #2 -> {micro.MicroRegisters}"); }
public void LogicOperationsTests_ROTAL_Success() { // ROTAL Ra, Rb, Rc {F1} R[Ra]<- R[Rb] rtl R[Rc] string ra1 = "001"; // 1 string rb1 = "010"; // 2 string rc1 = "011"; // 3 string ra2 = "101"; // 5 string rb2 = "110"; // 6 string rc2 = "111"; // 7 MCInstructionF1 i1 = new MCInstructionF1(3, "10011", ra1, rb1, rc1); MCInstructionF1 i2 = new MCInstructionF1(3, "10011", ra2, rb2, rc2); string valInB1 = "10111100"; string valInC1 = UnitConverter.ByteToBinary(2); string resultA1 = "11110010"; string valInB2 = "10011100"; string valInC2 = UnitConverter.ByteToBinary(2); string resultA2 = "01110010"; // set data in register //////////// /// Test 1 micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rb1), UnitConverter.BinaryToHex(valInB1)); micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rc1), UnitConverter.BinaryToHex(valInC1)); //////////// //////////// /// Test 2 micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rb2), UnitConverter.BinaryToHex(valInB2)); micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rc2), UnitConverter.BinaryToHex(valInC2)); /////////// Console.WriteLine(micro.MicroRegisters); // Assert Registers Assert.AreEqual("Registers[0,0,-68,2,0,0,-100,2]", micro.MicroRegisters.ToString()); Console.WriteLine(i1); Console.WriteLine(i2); // execute instruction InstructionSetExe.ExecuteInstruction(i1, micro); InstructionSetExe.ExecuteInstruction(i2, micro); Console.WriteLine(micro.MicroRegisters); Console.WriteLine($"Expected1: {UnitConverter.BinaryToHex(resultA1)}," + $"Actual: {micro.MicroRegisters.GetRegisterValue(UnitConverter.BinaryToByte(ra1))}"); Console.WriteLine($"Expected1: {UnitConverter.HexToBinary(micro.MicroRegisters.GetRegisterValue(UnitConverter.BinaryToByte(ra1)))}"); Console.WriteLine($"Expected2: {UnitConverter.BinaryToHex(resultA2)}," + $"Actual: {micro.MicroRegisters.GetRegisterValue(UnitConverter.BinaryToByte(ra2))}"); Console.WriteLine($"Expected2: {UnitConverter.HexToBinary(micro.MicroRegisters.GetRegisterValue(UnitConverter.BinaryToByte(ra2)))}"); Assert.AreEqual( UnitConverter.BinaryToHex(resultA1), micro.MicroRegisters.GetRegisterValue(UnitConverter.BinaryToByte(ra1)) ); Assert.AreEqual( UnitConverter.BinaryToHex(resultA2), micro.MicroRegisters.GetRegisterValue(UnitConverter.BinaryToByte(ra2)) ); }
public void LogicOperationsTests_NEG_Success() { // NEG Ra,Rb {F1} R[Ra]<- - R[Rb] string ra1 = "001"; // 1 string rb1 = "011"; // 3 string ra2 = "110"; // 6 string rb2 = "111"; // 7 string valInB1 = UnitConverter.ByteToBinary(-13); string resultA1 = UnitConverter.ByteToBinary(13); string valInB2 = UnitConverter.ByteToBinary(-45); string resultA2 = UnitConverter.ByteToBinary(45); // set data in register micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rb1), UnitConverter.BinaryToHex(valInB1)); micro.MicroRegisters.SetRegisterValue( (byte)UnitConverter.BinaryToInt(rb2), UnitConverter.BinaryToHex(valInB2)); Console.WriteLine(micro.MicroRegisters); Assert.AreEqual( UnitConverter.BinaryToHex(valInB1), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(rb1)) ); Assert.AreEqual( UnitConverter.BinaryToHex(valInB2), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(rb2)) ); MCInstructionF1 i1 = new MCInstructionF1(3, "01111", ra1, rb1); MCInstructionF1 i2 = new MCInstructionF1(3, "01111", ra2, rb2); Console.WriteLine(i1); Console.WriteLine(i2); // execute instruction InstructionSetExe.ExecuteInstruction(i1, micro); InstructionSetExe.ExecuteInstruction(i2, micro); Console.WriteLine(micro.MicroRegisters); Console.WriteLine($"Expected1: {UnitConverter.BinaryToHex(resultA1)}," + $"Actual: {micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra1))}"); Console.WriteLine($"Expected2: {UnitConverter.BinaryToHex(resultA2)}," + $"Actual: {micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra2))}"); Assert.AreEqual( UnitConverter.BinaryToHex(resultA1), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra1)) ); Assert.AreEqual( UnitConverter.BinaryToHex(resultA2), micro.MicroRegisters.GetRegisterValue((byte)UnitConverter.BinaryToInt(ra2)) ); }