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 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]);
}
static void TipoDeMov()
{
MOV mov = new MOV();
{
mov.Fecha = DateTime.Now;
mov.Proveedor = "ETERNITY";
//mov.TMov = bool;
using (var repos = new Repository <MOV>())
{
repos.Create(mov);
}
Console.WriteLine("FECHA: {0}", mov.Fecha);
Console.WriteLine("PROVEEDOR: {0}", mov.Proveedor);
}
}
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);
}
private CommandInterpreter InitDefaultRegistryCommander()
{
RegistryCommander commander = new RegistryCommander(this);
POP pop = new POP(generalPurposeRegisters, pointerRegisters, segmentRegisters);
PUSH push = new PUSH(generalPurposeRegisters, pointerRegisters, segmentRegisters);
XCHG xchg = new XCHG(generalPurposeRegisters, indexRegisters, pointerRegisters, segmentRegisters);
MOV mov = new MOV(generalPurposeRegisters, indexRegisters, pointerRegisters, segmentRegisters);
AssignToRegistry assignTo = new AssignToRegistry(generalPurposeRegisters, indexRegisters, pointerRegisters, segmentRegisters);
commander.AddHandler(pop);
commander.AddHandler(push);
commander.AddHandler(xchg);
commander.AddHandler(mov);
commander.AddHandler(assignTo);
return(commander);
}
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;
}
private void SetupInstructions()
{
instructions[0x00] = new NOP();
instructions[0x01] = new MOV();
instructions[0x02] = new ADD();
instructions[0x03] = new NOP();
instructions[0x04] = new NOP();
instructions[0x05] = new NOP();
instructions[0x06] = new NOP();
instructions[0x07] = new NOP();
instructions[0x08] = new NOP();
instructions[0x09] = new NOP();
instructions[0x0A] = new NOP();
instructions[0x0B] = new NOP();
instructions[0x0C] = new ADDR();
instructions[0x0D] = new NOP();
instructions[0x0E] = new NOP();
instructions[0x0F] = new INT();
}
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.");
}
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.");
}
/// <summary>
/// Create a single component from XML data
/// </summary>
/// <param name="node">XML node containing component data</param>
/// <returns>Created Component</returns>
private static ComponentBase CreateComponent(XmlNode node)
{
ComponentBase component;
switch (node.LocalName)
{
#region Basic
case "Coil":
Coil coil = new Coil();
coil.Mode = node.Attributes["Mode"].Value.ToEnum <Coil.CoilMode>();
coil.Type = node.Attributes["Type"].Value.ToEnum <Coil.CoilType>();
component = coil;
break;
case "Contact":
Contact contact = new Contact();
contact.IsClosed = node.Attributes["IsClosed"].Value.ToBool();
contact.IsInverted = node.Attributes["IsInverted"].Value.ToBool();
contact.Type = node.Attributes["Type"].Value.ToEnum <Contact.ContactType>();
component = contact;
break;
case "SC": component = new SC(); break;
case "OSF": component = new OSF(); break;
case "OSR": component = new OSR(); break;
#endregion Basic
#region Compare Components
case "EQU": component = new EQU(); break;
case "GEQ": component = new GEQ(); break;
case "GRT": component = new GRT(); break;
case "LEG": component = new LEG(); break;
case "LES": component = new LES(); break;
case "NEQ": component = new NEQ(); break;
#endregion Compare Components
#region Counter Components
case "CTC": component = new CTC(); break;
case "CTD": component = new CTD(); break;
case "CTU": component = new CTU(); break;
case "RES": component = new RES(); break;
#endregion Counter Components
#region Math Components
case "ADD": component = new ADD(); break;
case "DIV": component = new DIV(); break;
case "MUL": component = new MUL(); break;
case "SUB": component = new SUB(); break;
case "MOV": component = new MOV(); break;
#endregion Math Components
#region Analog Components
case "ADC":
ADC adc = new ADC();
adc.Destination = node.Attributes["Destination"].Value;
component = adc;
break;
case "PWM":
PWM pwm = new PWM();
pwm.DudyCycle = node.Attributes["DudyCycle"].Value;
component = pwm;
break;
#endregion Analog Components
#region Function Components
case "ELF":
ELF elf = new ELF();
elf.Name = node.Attributes["Name"].Value;
elf.Code = node.InnerText;
component = elf;
break;
#endregion Function Components
default:
throw new ArgumentException("Unknow Component", "node");
}
component.Comment = node.Attributes["Comment"].Value;
#region Extra Processing based on Components Base Class
if (component is NameableComponent)
{
(component as NameableComponent).Name = node.Attributes["Name"].Value;
}
if (component is CompareComponent)
{
(component as CompareComponent).VarA = node.Attributes["VarA"].Value;
(component as CompareComponent).VarB = node.Attributes["VarB"].Value;
}
else if (component is CounterComponent)
{
(component as CounterComponent).Limit = node.Attributes["Limit"].Value;
}
else if (component is MathComponent)
{
(component as MathComponent).Destination = node.Attributes["Destination"].Value;
(component as MathComponent).VarA = node.Attributes["VarA"].Value;
(component as MathComponent).VarB = node.Attributes["VarB"].Value;
}
#endregion Extra Processing based on Components Base Class
return(component);
}
public void Constants()
{
var TestTable = new LadderDataTable();
Node PowerRail = new Node();
PowerRail.LogicLevel = true;
Trace.WriteLine("Math", "Unit Test");
Trace.Indent();
Trace.WriteLine("StartUP", "ADD");
Trace.Indent();
ADD add = new ADD();
add.DataTable = TestTable;
add.LeftLide = PowerRail;
add.Destination = "Dest";
add.VarA = "1";
add.ValueA = 3;
add.VarB = "2";
add.ValueB = 1;
add.Execute();
Trace.Unindent();
Trace.WriteLine("StartUP", "MOV");
Trace.Indent();
MOV mov = new MOV();
mov.DataTable = TestTable;
mov.LeftLide = PowerRail;
mov.Destination = "Dest";
mov.VarA = "0";
mov.ValueA = 1;
mov.Execute();
Trace.Unindent();
Trace.Unindent();
Trace.WriteLine("Counter", "Unit Test");
Trace.Indent();
Trace.WriteLine("StartUP", "CTC");
Trace.Indent();
CTC ctc = new CTC();
ctc.DataTable = TestTable;
ctc.Name = "1";
ctc.Limit = "2";
ctc.LimitValue = 3;
ctc.LeftLide = PowerRail;
ctc.Execute();
Trace.Unindent();
Trace.WriteLine("StartUP", "CTU");
Trace.Indent();
CTU ctu = new CTU();
ctu.DataTable = TestTable;
ctu.Name = "1";
ctu.Limit = "3";
ctu.LimitValue = 4;
ctu.LeftLide = PowerRail;
ctu.Execute();
Trace.Unindent();
Trace.Unindent();
Trace.WriteLine("Compare", "Unit Test");
Trace.Indent();
EQU equ = new EQU();
equ.DataTable = TestTable;
equ.LeftLide = PowerRail;
equ.VarA = "3";
equ.ValueA = 4;
equ.VarB = "4";
equ.ValueB = 5;
equ.Execute();
Trace.Unindent();
Assert.AreEqual(2, TestTable.Count);
}
public void Math()
{
#region Startup
var TestTable = new LadderDataTable();
Node PowerRail = new Node();
ADD add = new ADD();
add.LeftLide = PowerRail;
add.Destination = "Dest";
add.VarA = "VarA";
add.VarB = "VarB";
add.DataTable = TestTable;
DIV div = new DIV();
div.LeftLide = PowerRail;
div.Destination = "Dest";
div.VarA = "VarA";
div.VarB = "VarB";
div.DataTable = TestTable;
MOV mov = new MOV();
mov.LeftLide = PowerRail;
mov.Destination = "Dest";
mov.VarA = "VarA";
mov.DataTable = TestTable;
MUL mul = new MUL();
mul.LeftLide = PowerRail;
mul.Destination = "Dest";
mul.VarA = "VarA";
mul.VarB = "VarB";
mul.DataTable = TestTable;
SUB sub = new SUB();
sub.LeftLide = PowerRail;
sub.Destination = "Dest";
sub.VarA = "VarA";
sub.VarB = "VarB";
sub.DataTable = TestTable;
#endregion Startup
#region ADD
Trace.WriteLine("ADD", "Unit Test");
Trace.Indent();
Trace.WriteLine("StartUP", "ADD");
Trace.Indent();
TestTable.SetValue("Dest", (short)0);
add.ValueA = 1;
add.ValueB = 2;
Trace.Unindent();
Trace.WriteLine("Input False", "ADD");
Trace.Indent();
PowerRail.LogicLevel = false;
add.Execute();
Assert.IsFalse(add.InternalState);
Assert.AreEqual(TestTable.GetValue("Dest"), (short)0);
Trace.Unindent();
Trace.WriteLine("Input True", "ADD");
Trace.Indent();
PowerRail.LogicLevel = true;
add.Execute();
Assert.IsTrue(add.InternalState);
Assert.AreEqual(TestTable.GetValue("Dest"), (short)3);
Trace.Unindent();
Trace.Unindent();
#endregion ADD
#region DIV
Trace.WriteLine("DIV", "Unit Test");
Trace.Indent();
Trace.WriteLine("StartUP", "DIV");
Trace.Indent();
TestTable.SetValue("Dest", (short)0);
div.ValueA = 10;
div.ValueB = 2;
Trace.Unindent();
Trace.WriteLine("Input False", "DIV");
Trace.Indent();
PowerRail.LogicLevel = false;
div.Execute();
Assert.IsFalse(div.InternalState);
Assert.AreEqual(TestTable.GetValue("Dest"), (short)0);
Trace.Unindent();
Trace.WriteLine("Input True", "DIV");
Trace.Indent();
PowerRail.LogicLevel = true;
div.Execute();
Assert.IsTrue(div.InternalState);
Assert.AreEqual(TestTable.GetValue("Dest"), (short)5);
Trace.Unindent();
Trace.Unindent();
#endregion DIV
#region MOV
Trace.WriteLine("MOV", "Unit Test");
Trace.Indent();
Trace.WriteLine("StartUP", "MOV");
Trace.Indent();
TestTable.SetValue("Dest", (short)0);
mov.ValueA = 10;
Trace.Unindent();
Trace.WriteLine("Input False", "MOV");
Trace.Indent();
PowerRail.LogicLevel = false;
mov.Execute();
Assert.IsFalse(mov.InternalState);
Assert.AreEqual(TestTable.GetValue("Dest"), (short)0);
Trace.Unindent();
Trace.WriteLine("Input True", "MOV");
Trace.Indent();
PowerRail.LogicLevel = true;
mov.Execute();
Assert.IsTrue(mov.InternalState);
Assert.AreEqual(TestTable.GetValue("Dest"), (short)10);
Trace.Unindent();
Trace.Unindent();
#endregion MOV
#region MUL
Trace.WriteLine("MUL", "Unit Test");
Trace.Indent();
Trace.WriteLine("StartUP", "MUL");
Trace.Indent();
TestTable.SetValue("Dest", (short)0);
mul.ValueA = 3;
mul.ValueB = 6;
Trace.Unindent();
Trace.WriteLine("Input False", "MUL");
Trace.Indent();
PowerRail.LogicLevel = false;
mul.Execute();
Assert.IsFalse(mul.InternalState);
Assert.AreEqual(TestTable.GetValue("Dest"), (short)0);
Trace.Unindent();
Trace.WriteLine("Input True", "MUL");
Trace.Indent();
PowerRail.LogicLevel = true;
mul.Execute();
Assert.IsTrue(mul.InternalState);
Assert.AreEqual(TestTable.GetValue("Dest"), (short)18);
Trace.Unindent();
Trace.Unindent();
#endregion MUL
#region SUB
Trace.WriteLine("SUB", "Unit Test");
Trace.Indent();
Trace.WriteLine("StartUP", "SUB");
Trace.Indent();
TestTable.SetValue("Dest", (short)0);
sub.ValueA = 4;
sub.ValueB = 6;
Trace.Unindent();
Trace.WriteLine("Input False", "SUB");
Trace.Indent();
PowerRail.LogicLevel = false;
sub.Execute();
Assert.IsFalse(sub.InternalState);
Assert.AreEqual(TestTable.GetValue("Dest"), (short)0);
Trace.Unindent();
Trace.WriteLine("Input True", "SUB");
Trace.Indent();
PowerRail.LogicLevel = true;
sub.Execute();
Assert.IsTrue(sub.InternalState);
Assert.AreEqual(TestTable.GetValue("Dest"), (short)-2);
Trace.Unindent();
Trace.Unindent();
#endregion SUB
}
