public void TestAssignToRegistry()
{
GeneralPurposeRegisters registersMock = new GeneralPurposeRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
XCHG xchg = new XCHG(registersMock);
MOV mov = new MOV(registersMock);
AssignToRegistry assignTo = new AssignToRegistry(registersMock);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
registryCommand.InputCommand("AL 1");
Assert.AreEqual(registersMock.GetRegistry("AL")[0], 1);
Assert.AreEqual(loggerMock.outputResult, "01 assigned into AL.");
registryCommand.InputCommand("AH F");
Assert.AreEqual(registersMock.GetRegistry("AH")[0], 15);
Assert.AreEqual(loggerMock.outputResult, "0F assigned into AH.");
registryCommand.InputCommand("AX 123");
byte[] reg = registersMock.GetRegistry("AX");
Assert.AreEqual(reg[0], 35);
Assert.AreEqual(reg[1], 1);
Assert.AreEqual(loggerMock.outputResult, "0123 assigned into AX.");
}
public void TestSetAndReadBytes() //MOV AL, BH
{
byte[] test;
RegistersController registry = new GeneralPurposeRegisters();
registry.SetBytesToRegistry("AX", 0, 1);
test = registry.GetRegistry("AX");
Assert.AreEqual(BitConverter.ToUInt16(test), 256);
registry.SetBytesToRegistry("BH", 0, 255);
test = registry.GetRegistry("BX");
Assert.AreEqual(BitConverter.ToUInt16(test), 0);
registry.SetBytesToRegistry("CL", 1, 0, 1, 0, 1, 0);
test = registry.GetRegistry("CX");
Assert.AreEqual(BitConverter.ToUInt16(test), 1);
//Only one argument should set to lower byte.
registry.SetBytesToRegistry("DX", 255);
test = registry.GetRegistry("DX");
Assert.AreEqual(BitConverter.ToUInt16(test), 255);
//We've set 255 to lower byte and now we are setting 2 to higher.
//It's becouse we can send even 32bit to DH, then it will take second byte if array may represent 16bit.
registry.SetBytesToRegistry("DH", 2);
test = registry.GetRegistry("DX");
Assert.AreEqual(BitConverter.ToUInt16(test), (255 + 2 * 256));
}
public void AddressRegisterOverflowTests()
{
GeneralPurposeRegisters gpr = MakeRegisters();
Enumerable.Range(0, gpr.Count).Any((i) => { gpr[i] = (Byte)(i + 1); return(false); });
Assert.True(gpr.Count == GeneralPurposeRegisters.DefaultRegistersCount);
Assert.True(Enumerable.Range(0, gpr.Count).All((i) => gpr[i] == (UInt16)(i + 1)));
}
private void panel1_Paint(object sender, PaintEventArgs e)
{
if (mJM == null || !mJM.ValidLoadedProgram)
{
return;
}
Graphics g = e.Graphics;
System.Drawing.Drawing2D.Matrix mx = new System.Drawing.Drawing2D.Matrix(1, 0, 0, 1,
panel1.AutoScrollPosition.X, panel1.AutoScrollPosition.Y);
e.Graphics.Transform = mx;
using (SolidBrush backBrush = new SolidBrush(panel1.BackColor))
using (SolidBrush textBrush = new SolidBrush(panel1.ForeColor))
using (SolidBrush highlightBrush = new SolidBrush(mHighlightColor))
{
for (uint ii = 0; ii < 16; ii++)
{
int ypos = (int)(ii * panel1.Font.Height);
Rectangle bounds = new Rectangle(0, ypos, panel1.ClientRectangle.Width, panel1.Font.Height);
string str = GeneralPurposeRegisters.registerToString(ii);
uint regValue = mJM.GPR[ii];
switch (this.CurrentDisplayBase)
{
case RegisterDisplayBase.Hexadecimal:
str += regValue.ToString("x8"); break;
case RegisterDisplayBase.Signed:
str += ((int)regValue).ToString(); break;
case RegisterDisplayBase.Unsigned:
str += regValue.ToString(); break;
}
g.FillRectangle(backBrush, bounds);
Brush brush = _gpRegistersChanged[ii] ? highlightBrush : textBrush;
// Draw the current item text based on the current Font and the custom brush settings.
e.Graphics.DrawString(str, panel1.Font, brush, bounds, StringFormat.GenericDefault);
}//for ii
RegistersView.DrawLine(g, panel1, 16, textBrush, "------------------");
RegistersView.DrawLine(g, panel1, 17, textBrush, "CPSR Register");
RegistersView.DrawLine(g, panel1, 18, _cpsrChanged[0] ? highlightBrush : textBrush, "Negative(N):" + (mJM.CPSR.nf ? "1" : "0"));
RegistersView.DrawLine(g, panel1, 19, _cpsrChanged[1] ? highlightBrush : textBrush, "Zero(Z) :" + (mJM.CPSR.zf ? "1" : "0"));
RegistersView.DrawLine(g, panel1, 20, _cpsrChanged[2] ? highlightBrush : textBrush, "Carry(C) :" + (mJM.CPSR.cf ? "1" : "0"));
RegistersView.DrawLine(g, panel1, 21, _cpsrChanged[3] ? highlightBrush : textBrush, "Overflow(V):" + (mJM.CPSR.vf ? "1" : "0"));
RegistersView.DrawLine(g, panel1, 22, textBrush, "IRQ Disable:" + (mJM.CPSR.IRQDisable ? "1" : "0"));
RegistersView.DrawLine(g, panel1, 23, textBrush, "FIQ Disable:" + (mJM.CPSR.FIQDisable ? "1" : "0"));
RegistersView.DrawLine(g, panel1, 24, textBrush, "Thumb(T) :" + (mJM.CPSR.tf ? "1" : "0"));
RegistersView.DrawLine(g, panel1, 25, textBrush, "CPU Mode :" + System.Enum.GetName(typeof(CPSR.CPUModeEnum), mJM.CPSR.Mode));
RegistersView.DrawLine(g, panel1, 26, textBrush, "------------------");
RegistersView.DrawLine(g, panel1, 27, textBrush, "0x" + mJM.CPSR.Flags.ToString("x8"));
}
}
/// <summary>
/// Gets the state of the registers in Intel 8080 format.
/// </summary>
/// <exception cref="NotSupportedException">The implementation must have Intel 8080 style registers. I.e. not be a Z80.</exception>
/// <returns></returns>
public Intel8080RegisterState GetIntel8080RegisterState()
=>
new Intel8080RegisterState(GeneralPurposeRegisters.GetRegisterState(),
AccumulatorAndFlagsRegisters.GetRegisterState(),
StackPointer,
ProgramCounter,
InterruptFlipFlop1,
InterruptFlipFlop2,
InterruptMode);
/// <summary>
/// Resets the registers to the specified state.
/// </summary>
/// <typeparam name="TRegisterState">The type of the register state.</typeparam>
/// <param name="state">The state.</param>
public void ResetToState <TRegisterState>(TRegisterState state) where TRegisterState : Intel8080RegisterState
{
GeneralPurposeRegisters.ResetToState(state.GeneralPurposeRegisterState);
AccumulatorAndFlagsRegisters.ResetToState(state.AccumulatorAndFlagsRegisterState);
StackPointer = state.StackPointer;
ProgramCounter = state.ProgramCounter;
InterruptFlipFlop1 = state.InterruptFlipFlop1;
InterruptFlipFlop2 = state.InterruptFlipFlop2;
InterruptMode = state.InterruptMode;
}
public void TestPOP()
{
MemoryModel.SetAddressBusLength = 20;
MemoryModel memory = MemoryModel.GetInstance();
GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters();
SegmentRegisters segmentRegistersMock = new SegmentRegisters();
PointerRegisters pointerRegistersMock = new PointerRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
POP pop = new POP(generalRegistersMock, pointerRegistersMock, segmentRegistersMock);
PUSH push = new PUSH(generalRegistersMock, pointerRegistersMock, segmentRegistersMock);
XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock);
MOV mov = new MOV(generalRegistersMock, segmentRegistersMock);
AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, pointerRegistersMock, segmentRegistersMock);
registryCommand.AddHandler(pop);
registryCommand.AddHandler(push);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
byte[] word;
registryCommand.InputCommand("ax 1122");
registryCommand.InputCommand("push ax");
registryCommand.InputCommand("pop cx");
word = generalRegistersMock.GetRegistry("CX");
Assert.AreEqual(34, word[0]);
Assert.AreEqual(17, word[1]);
Assert.AreEqual("Value 1122h from physical address 0h popped from stack to registry CX.\r\n", loggerMock.outputResult);
word = pointerRegistersMock.GetRegistry("SP");
Assert.AreEqual(0, word[0]);
registryCommand.InputCommand("ax FFEE");
registryCommand.InputCommand("bx AA99");
registryCommand.InputCommand("SS FF");
registryCommand.InputCommand("push ax");
registryCommand.InputCommand("push bx");
registryCommand.InputCommand("pop dx");
word = generalRegistersMock.GetRegistry("DX");
Assert.AreEqual(153, word[0]);
Assert.AreEqual(170, word[1]);
Assert.AreEqual("Value AA99h from physical address FF2h popped from stack to registry DX.\r\n", loggerMock.outputResult);
word = pointerRegistersMock.GetRegistry("SP");
Assert.AreEqual(2, word[0]);
}
private IArithmeticLogicUnit BuildALU()
{
IAddressRegister addressRegister = new AddressRegister();
IGeneralPurposeRegisters generalPurposeRegisters = new GeneralPurposeRegisters();
IInstructionPointerRegister ipr = new InstructionPointerRegister();
IReturnStack returnStack = new ReturnStack();
IArithmeticLogicUnit alu = new ArithmeticLogicUnit(
addressRegister,
generalPurposeRegisters,
ipr,
returnStack
);
return(alu);
}
/// <summary>
/// Gets the state of the registers in Z80 format.
/// Non-applicable state fields are filled with 0's.
/// </summary>
/// <returns></returns>
public Z80RegisterState GetZ80RegisterState()
=>
new Z80RegisterState(GeneralPurposeRegisters.GetRegisterState(),
default(GeneralPurposeRegisterState),
AccumulatorAndFlagsRegisters.GetRegisterState(),
default(AccumulatorAndFlagsRegisterState),
false,
false,
0,
0,
0,
0,
StackPointer,
ProgramCounter,
InterruptFlipFlop1,
InterruptFlipFlop2,
InterruptMode);
public void TestMOVInvalidCommands()
{
MemoryModel.SetAddressBusLength = 20;
GeneralPurposeRegisters registersMock = new GeneralPurposeRegisters();
SegmentRegisters segmentsMock = new SegmentRegisters();
PointerRegisters pointersMock = new PointerRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
MOV mov = new MOV(registersMock, pointersMock, segmentsMock);
AssignToRegistry assign = new AssignToRegistry(registersMock, pointersMock, segmentsMock);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assign);
registryCommand.InputCommand("mov ak, bh");
Assert.AreEqual(loggerMock.outputResult, "AK is unsupported registry name.");
registryCommand.InputCommand("mov ah, bk");
Assert.AreEqual(loggerMock.outputResult, "BK is unsupported registry name.");
registryCommand.InputCommand("mov ah bk");
Assert.AreEqual(loggerMock.outputResult, "MOV arguments must be separated by comma.");
registryCommand.InputCommand("mov ch,");
Assert.AreEqual(loggerMock.outputResult, "Too few arguments to function MOV.");
registryCommand.InputCommand("mov ax, [0");
Assert.AreEqual(loggerMock.outputResult, "Argument is missing bracket.");
registryCommand.InputCommand("mov [0, ax");
Assert.AreEqual(loggerMock.outputResult, "Argument is missing bracket.");
registryCommand.InputCommand("mov [0, ch");
Assert.AreEqual(loggerMock.outputResult, "Argument is missing bracket.");
registryCommand.InputCommand("BP ffff");
registryCommand.InputCommand("DS ffff");
registryCommand.InputCommand("mov [BP], CX");
Assert.AreEqual("Converting arguments into effective address FFFFh.\r\nPhysical address 10FFEFh is out of range memory.\nAborting operation MOV.\r\n", loggerMock.outputResult);
registryCommand.InputCommand("mov CX, [BP]");
Assert.AreEqual("Converting arguments into effective address FFFFh.\r\nPhysical address 10FFEFh is out of range memory.\nAborting operation MOV.\r\n", loggerMock.outputResult);
MemoryModel.SetAddressBusLength = 0;
}
public void TestPUSH()
{
MemoryModel.SetAddressBusLength = 20;
MemoryModel memory = MemoryModel.GetInstance();
GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters();
SegmentRegisters segmentRegistersMock = new SegmentRegisters();
PointerRegisters pointerRegistersMock = new PointerRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
PUSH push = new PUSH(generalRegistersMock, pointerRegistersMock, segmentRegistersMock);
XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock);
MOV mov = new MOV(generalRegistersMock, segmentRegistersMock);
AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, pointerRegistersMock, segmentRegistersMock);
registryCommand.AddHandler(push);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
byte[] word;
registryCommand.InputCommand("ax 1122");
registryCommand.InputCommand("push ax");
word = memory.GetMemoryWord(0);
Assert.AreEqual(word[0], 34);
Assert.AreEqual(word[1], 17);
Assert.AreEqual("Value 1122h from registry AX pushed on stack with physical address 0h.\r\n", loggerMock.outputResult);
word = pointerRegistersMock.GetRegistry("SP");
Assert.AreEqual(word[0], 2);
registryCommand.InputCommand("ax FFEE");
registryCommand.InputCommand("bx AA99");
registryCommand.InputCommand("SS FF");
registryCommand.InputCommand("push ax");
registryCommand.InputCommand("push bx");
word = memory.GetMemoryWord(4083);
Assert.AreEqual(word[0], 255);
Assert.AreEqual(word[1], 153);
Assert.AreEqual("Value AA99h from registry BX pushed on stack with physical address FF4h.\r\n", loggerMock.outputResult);
word = pointerRegistersMock.GetRegistry("SP");
Assert.AreEqual(word[0], 6);
}
public void TestXCHGMemoryRegistry()
{
MemoryModel.SetAddressBusLength = 20;
MemoryModel memory = MemoryModel.GetInstance();
GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters();
SegmentRegisters segmentRegistersMock = new SegmentRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock);
MOV mov = new MOV(generalRegistersMock, segmentRegistersMock);
AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, segmentRegistersMock);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
registryCommand.InputCommand("MoV AL, FFh");
registryCommand.InputCommand("MoV [SI + 0], AL");
registryCommand.InputCommand("MoV AL, 1");
registryCommand.InputCommand("XCHG [0], AL");
byte bytetmp = memory.GetMemoryCell(0);
Assert.AreEqual(bytetmp, 1);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as decimal.\r\nConverting arguments into effective address 0h.\r\nValue 1h from registry AL exchanged with FF at physical address 0h.\r\n");
bytetmp = generalRegistersMock.GetRegistry("AL")[0];
Assert.AreEqual(bytetmp, 255);
segmentRegistersMock.SetBytesToRegistry("DS", 255);
registryCommand.InputCommand("MoV CX, FF11h");
registryCommand.InputCommand("MoV [SI + BP + FFh], CX");
registryCommand.InputCommand("MoV CX, 2233h");
registryCommand.InputCommand("XCHG CX, [100h]");
byte[] word = generalRegistersMock.GetRegistry("CX");
Assert.AreEqual(word[0], 255);
Assert.AreEqual(word[1], 0);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"100\" as hexadecimal.\r\nConverting arguments into effective address 100h.\r\nValue 2233h from registry CX exchanged with FF at physical address 10F0h.\r\n");
word = memory.GetMemoryWord(4336);
Assert.AreEqual(word[0], 51);
Assert.AreEqual(word[1], 34);
MemoryModel.SetAddressBusLength = 0;
}
public MainWindow()
{
InitializeComponent();
MemoryModel.SetAddressBusLength = 20;
MemoryModel.GetInstance().AddObserver(this);
memoryView = new MemoryView();
Go_Click(null, null);
generalPurposeRegisters = new GeneralPurposeRegisters();
indexRegisters = new IndexRegisters();
pointerRegisters = new PointerRegisters();
segmentRegisters = new SegmentRegisters();
commandInterpreter = InitDefaultRegistryCommander();
generalPurposeRegistersView = new GeneralPurposeRegistersView(new HexParser());
indexRegistersView = new IndexRegistersView(new HexParser());
pointerRegistersView = new PointerRegistersView(new HexParser());
segmentRegistersView = new SegmentRegistersView(new HexParser());
if (generalPurposeRegisters is Observable observableGeneralPurposeReg)
{
observableGeneralPurposeReg.AddObserver(generalPurposeRegistersView);
}
if (indexRegisters is Observable observableIndexReg)
{
observableIndexReg.AddObserver(indexRegistersView);
}
if (pointerRegisters is Observable observablePointersReg)
{
observablePointersReg.AddObserver(pointerRegistersView);
}
if (segmentRegisters is Observable observableSegmentsReg)
{
observableSegmentsReg.AddObserver(segmentRegistersView);
}
SetBlockDataContext();
}
public void TestInvalidPOPCommand()
{
GeneralPurposeRegisters registersMock = new GeneralPurposeRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
POP pop = new POP(registersMock);
registryCommand.AddHandler(pop);
registryCommand.InputCommand("pop");
Assert.AreEqual("Popping to registry from stack requires two arguments.", loggerMock.outputResult);
registryCommand.InputCommand("pop ak");
Assert.AreEqual("AK is unsupported registry name.\r\n", loggerMock.outputResult);
registryCommand.InputCommand("pop ax");
Assert.AreEqual("Command interpreter couldn't find SP registry.\r\n", loggerMock.outputResult);
registryCommand = new RegistryCommander(loggerMock);
pop = new POP(registersMock, new PointerRegisters());
registryCommand.AddHandler(pop);
registryCommand.InputCommand("pop ax");
Assert.AreEqual("Command interpreter couldn't find SS registry.\r\n", loggerMock.outputResult);
registryCommand = new RegistryCommander(loggerMock);
pop = new POP(registersMock, new PointerRegisters(), new SegmentRegisters());
registryCommand.AddHandler(pop);
registryCommand.InputCommand("pop al");
Assert.AreEqual("Cannot use command POP for half registers.\r\n", loggerMock.outputResult);
registryCommand.InputCommand("pop ax");
Assert.AreEqual("The stack is empty, cannot perform operation.\r\n", loggerMock.outputResult);
}
public void TestInvalidPUSHCommand()
{
MemoryModel.SetAddressBusLength = 20;
GeneralPurposeRegisters registersMock = new GeneralPurposeRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
PUSH push = new PUSH(registersMock);
registryCommand.AddHandler(push);
registryCommand.InputCommand("push");
Assert.AreEqual(loggerMock.outputResult, "Pushing registry on stack requires two arguments.");
registryCommand.InputCommand("push ak");
Assert.AreEqual(loggerMock.outputResult, "AK is unsupported registry name.\r\n");
registryCommand.InputCommand("push ax");
Assert.AreEqual(loggerMock.outputResult, "Command interpreter couldn't find SP registry.\r\n");
registryCommand = new RegistryCommander(loggerMock);
push = new PUSH(registersMock, new PointerRegisters());
registryCommand.AddHandler(push);
registryCommand.InputCommand("push ax");
Assert.AreEqual(loggerMock.outputResult, "Command interpreter couldn't find SS registry.\r\n");
registryCommand = new RegistryCommander(loggerMock);
push = new PUSH(registersMock, new PointerRegisters(), new SegmentRegisters());
registryCommand.AddHandler(push);
registryCommand.InputCommand("push ah");
Assert.AreEqual(loggerMock.outputResult, "Cannot use command PUSH for half registers.\r\n");
MemoryModel.SetAddressBusLength = 0;
}
public void TestXCHG()
{
GeneralPurposeRegisters registersMock = new GeneralPurposeRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
XCHG xchg = new XCHG(registersMock);
MOV mov = new MOV(registersMock);
AssignToRegistry assignTo = new AssignToRegistry(registersMock);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
byte[] first;
byte[] second;
registersMock.SetBytesToRegistry("AX", BitConverter.GetBytes(Convert.ToUInt16(256)));
registersMock.SetBytesToRegistry("BX", BitConverter.GetBytes(Convert.ToUInt16(255)));
registryCommand.InputCommand("XchG aX, Bx");
first = registersMock.GetRegistry("AX");
second = registersMock.GetRegistry("BX");
Assert.AreEqual(first[0], 255);
Assert.AreEqual(first[1], 0);
Assert.AreEqual(second[0], 0);
Assert.AreEqual(second[1], 1);
Assert.AreEqual(loggerMock.outputResult, "AX exchanged with BX.");
registryCommand.InputCommand("xchG al, cl");
first = registersMock.GetRegistry("AX");
second = registersMock.GetRegistry("CX");
Assert.AreEqual(first[0], 0);
Assert.AreEqual(first[1], 0);
Assert.AreEqual(second[0], 255);
Assert.AreEqual(second[1], 0);
Assert.AreEqual(loggerMock.outputResult, "AL exchanged with CL.");
registersMock.SetBytesToRegistry("DX", BitConverter.GetBytes(65535));
registryCommand.InputCommand("XchG bh, dh");
first = registersMock.GetRegistry("BX");
second = registersMock.GetRegistry("DX");
Assert.AreEqual(first[0], 0);
Assert.AreEqual(first[1], 255);
Assert.AreEqual(second[0], 255);
Assert.AreEqual(second[1], 1);
Assert.AreEqual(loggerMock.outputResult, "BH exchanged with DH.");
registryCommand.InputCommand("xchg cx, dx");
first = registersMock.GetRegistry("CX");
second = registersMock.GetRegistry("DX");
Assert.AreEqual(first[0], 255);
Assert.AreEqual(first[1], 1);
Assert.AreEqual(second[0], 255);
Assert.AreEqual(second[1], 0);
Assert.AreEqual(loggerMock.outputResult, "CX exchanged with DX.");
registryCommand.InputCommand("xchG dl, ch");
first = registersMock.GetRegistry("DX");
second = registersMock.GetRegistry("CX");
Assert.AreEqual(first[0], 1);
Assert.AreEqual(first[1], 0);
Assert.AreEqual(second[0], 255);
Assert.AreEqual(second[1], 255);
Assert.AreEqual(loggerMock.outputResult, "DL exchanged with CH.");
}
GeneralPurposeRegisters MakeRegisters(int count = GeneralPurposeRegisters.DefaultRegistersCount)
{
var gpr = new GeneralPurposeRegisters(count);
return(gpr);
}
public void TestFromToRegistryMemory()
{
MemoryModel.SetAddressBusLength = 20;
MemoryModel memory = MemoryModel.GetInstance();
GeneralPurposeRegisters generalRegistersMock = new GeneralPurposeRegisters();
SegmentRegisters segmentRegistersMock = new SegmentRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
XCHG xchg = new XCHG(generalRegistersMock, segmentRegistersMock);
MOV mov = new MOV(generalRegistersMock, segmentRegistersMock);
AssignToRegistry assignTo = new AssignToRegistry(generalRegistersMock, segmentRegistersMock);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
registryCommand.InputCommand("MoV AL, 255");
registryCommand.InputCommand("MoV [0], AL");
byte bytetmp = memory.GetMemoryCell(0);
Assert.AreEqual(bytetmp, 255);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as decimal.\r\nConverting arguments into effective address 0h.\r\nValue FFh from registry AL assigned to physical address 0h.\r\n");
segmentRegistersMock.SetBytesToRegistry("DS", 255);
registryCommand.InputCommand("MoV AH, AAh");
registryCommand.InputCommand("MoV [FFh], AH");
bytetmp = memory.GetMemoryCell(4335);
Assert.AreEqual(bytetmp, 170);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"FF\" as hexadecimal.\r\nConverting arguments into effective address FFh.\r\nValue AAh from registry AH assigned to physical address 10EFh.\r\n");
segmentRegistersMock.SetBytesToRegistry("DS", 15);
registryCommand.InputCommand("MoV [0h], AX");
byte[] word = memory.GetMemoryWord(240);
Assert.AreEqual(word[0], 255);
Assert.AreEqual(word[1], 170);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as hexadecimal.\r\nConverting arguments into effective address 0h.\r\nValue AAFFh from registry AX assigned to physical address F0h.\r\n");
segmentRegistersMock.SetBytesToRegistry("DS", 0);
registryCommand.InputCommand("MoV AX, [0h]");
word = generalRegistersMock.GetRegistry("AX");
Assert.AreEqual(word[0], 255);
Assert.AreEqual(word[1], 0);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as hexadecimal.\r\nConverting arguments into effective address 0h.\r\nValue FFh assigned to registry AX from physical address 0h.\r\n");
segmentRegistersMock.SetBytesToRegistry("DS", 255);
registryCommand.InputCommand("MoV AX, [FEh]");
word = generalRegistersMock.GetRegistry("AX");
Assert.AreEqual(word[0], 0);
Assert.AreEqual(word[1], 170);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"FE\" as hexadecimal.\r\nConverting arguments into effective address FEh.\r\nValue AA00h assigned to registry AX from physical address 10EEh.\r\n");
segmentRegistersMock.SetBytesToRegistry("DS", 15);
registryCommand.InputCommand("MoV AX, [0h]");
word = generalRegistersMock.GetRegistry("AX");
Assert.AreEqual(word[0], 255);
Assert.AreEqual(word[1], 170);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"0\" as hexadecimal.\r\nConverting arguments into effective address 0h.\r\nValue AAFFh assigned to registry AX from physical address F0h.\r\n");
MemoryModel.SetAddressBusLength = 0;
}
public void TestGeneralRegistersMOV()
{
GeneralPurposeRegisters registersMock = new GeneralPurposeRegisters();
LoggerMock loggerMock = new LoggerMock();
RegistryCommander registryCommand = new RegistryCommander(loggerMock);
XCHG xchg = new XCHG(registersMock);
MOV mov = new MOV(registersMock);
AssignToRegistry assignTo = new AssignToRegistry(registersMock);
registryCommand.AddHandler(xchg);
registryCommand.AddHandler(mov);
registryCommand.AddHandler(assignTo);
byte[] reg;
registryCommand.InputCommand("MoV AL, 16");
reg = registersMock.GetRegistry("AL");
Assert.AreEqual(reg[0], 16);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"16\" as decimal.\r\n10h moved into AL.");
registryCommand.InputCommand("MOV Ch, 255");
reg = registersMock.GetRegistry("CH");
Assert.AreEqual(reg[0], 255);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"255\" as decimal.\r\nFFh moved into CH.");
registryCommand.InputCommand("MOV bx, 65535");
reg = registersMock.GetRegistry("BX");
Assert.AreEqual(reg[0], 255);
Assert.AreEqual(reg[1], 255);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"65535\" as decimal.\r\nFFFFh moved into BX.");
registryCommand.InputCommand("MOV bx, 65536");
reg = registersMock.GetRegistry("BX");
Assert.AreEqual(reg[0], 0);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"65536\" as decimal.\r\nExpected 16bit value.\nData loss due to conversion.\nMoving first and second byte of value.\n00h moved into BX.");
registryCommand.InputCommand("mOV Bx, AX");
reg = registersMock.GetRegistry("BX");
Assert.AreEqual(reg[0], 16);
Assert.AreEqual(reg[1], 0);
Assert.AreEqual(loggerMock.outputResult, "AX moved into BX.");
registryCommand.InputCommand("MOV bL, ch");
reg = registersMock.GetRegistry("BL");
Assert.AreEqual(reg[0], 255);
Assert.AreEqual(loggerMock.outputResult, "CH moved into BL.");
registryCommand.InputCommand("mov DH, 1");
reg = registersMock.GetRegistry("DH");
Assert.AreEqual(reg[0], 1);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"1\" as decimal.\r\n01h moved into DH.");
registryCommand.InputCommand("mov AH, DH");
reg = registersMock.GetRegistry("AH");
Assert.AreEqual(reg[0], 1);
Assert.AreEqual(loggerMock.outputResult, "DH moved into AH.");
registryCommand.InputCommand("mov AX, ff11H");
reg = registersMock.GetRegistry("AX");
Assert.AreEqual(reg[0], 17);
Assert.AreEqual(reg[1], 255);
Assert.AreEqual(loggerMock.outputResult, "Parsing value \"FF11\" as hexadecimal.\r\nFF11h moved into AX.");
}
