internal static void WriteDataTable(LadderDataTable dataTable, XmlWriter writer)
{
Trace.WriteLine("Data Table Started", "DiagramWriter");
Trace.Indent();
writer.WriteStartElement("DataTable");
writer.WriteStartAttribute("Count");
writer.WriteValue(dataTable.Count);
writer.WriteEndAttribute();
#region Variable Loop
//Write every variable in table to file.
//Tag name is the variable type without the "System." prefix
foreach (var variable in dataTable.ListAllData())
{
string type = variable.Item2.ToString().Replace("System.", string.Empty);
writer.WriteStartElement(type);
writer.WriteStartAttribute("Name");
writer.WriteValue(variable.Item1);
writer.WriteEndAttribute();
//So far not needed
//writer.WriteStartAttribute("Class");
//writer.WriteValue(variable.Item3.ToString());
//writer.WriteEndAttribute();
if (variable.Item3 != LDVarClass.OutFunction && variable.Item3 != LDVarClass.OutFunction)
{
writer.WriteStartAttribute("Value");
writer.WriteValue(variable.Item4);
writer.WriteEndAttribute();
}
else
{
writer.WriteString((string)variable.Item4);
}
writer.WriteEndElement();
Trace.WriteLine("Written: " + type + ", Name=" + variable.Item1 + ", Value=" + variable.Item4, "DataTable");
}
#endregion Variable Loop
writer.WriteEndElement();//Data table end
Trace.Unindent();
Trace.WriteLine("Data Table Ended", "DiagramWriter");
}
public void Analog()
{
#region Startup
var TestTable = new LadderDataTable();
Node PowerRail = new Node();
PowerRail.LogicLevel = false;
PWM pwm = new PWM("1", PowerRail);
pwm.DataTable = TestTable;
ADC adc = new ADC("1", PowerRail);
adc.DataTable = TestTable;
#endregion Startup
#region PWM
pwm.DudyCycle = "255";
pwm.Execute();
Assert.IsFalse(pwm.InternalState);
PowerRail.LogicLevel = true;
pwm.Execute();
Assert.IsTrue(pwm.InternalState);
PowerRail.LogicLevel = false;
pwm.DudyCycle = "DudyCycle";
pwm.DudyCycleValue = (byte)128;
pwm.Execute();
Assert.IsFalse(pwm.InternalState);
PowerRail.LogicLevel = true;
pwm.Execute();
Assert.IsTrue(pwm.InternalState);
#endregion PWM
#region ADC
PowerRail.LogicLevel = false;
adc.Execute();
Assert.IsFalse(adc.InternalState);
adc.InputValue = (short)1023;
adc.Execute();
Assert.IsFalse(adc.InternalState);
PowerRail.LogicLevel = true;
adc.Execute();
Assert.IsTrue(adc.InternalState);
#endregion ADC
}
public void BasicTests()
{
LadderDataTable TestTable = new LadderDataTable();
TestTable.Add("Var1", typeof(int));
TestTable.Add("Var1", typeof(int), LDVarClass.Data, 10);
TestTable.Add("Var2", typeof(bool));
TestTable.Add("Var3", typeof(byte));
TestTable.Add("Var4", typeof(short));
TestTable.Add("Var5", typeof(int));
Assert.AreEqual(5, TestTable.Count, "Stored Variable number incorrect");
TestTable.Rename("Var1", "Var6");
TestTable.Rename("Var6", "Var5");
TestTable.Remove("Var1");
TestTable.SetValue(0, true);
TestTable.SetValue("Var3", (byte)255);
TestTable.SetValue(TestTable.GetIndexOf("Var4"), (short)777);
Assert.AreEqual(4, TestTable.Count, "Stored Variable number incorrect");
}
/// <summary>
/// Generate code from data table variables
/// </summary>
/// <param name="table"></param>
/// <param name="codeBuffer"></param>
internal static void CompileDataTable(LadderDataTable table, CompilerBuffer codeBuffer)
{
List <Tuple <string, Type, LDVarClass, object> > tuples = table.ListAllData().OrderBy(x => x.Item1).ToList();
codeBuffer.Globals.Add("//Inputs");
StringBuilder inputList = new StringBuilder();
foreach (var tuple in tuples.Where(x => x.Item3 == LDVarClass.Input))
{
codeBuffer.Globals.Add("boolean " + tuple.Item1 + ";");
}
codeBuffer.Globals.Add(string.Empty);
codeBuffer.Globals.Add("//Outputs");
foreach (var tuple in tuples.Where(x => x.Item3 == LDVarClass.Output))
{
codeBuffer.Globals.Add("boolean " + tuple.Item1 + ";");
}
codeBuffer.Globals.Add(string.Empty);
codeBuffer.Globals.Add("//Data");
foreach (var tuple in tuples.Where(x => x.Item3 == LDVarClass.Data))
{
switch (tuple.Item2.ToString().Replace("System.", string.Empty))
{
case "Boolean":
codeBuffer.Globals.Add("boolean " + tuple.Item1 + " = " + (((bool)tuple.Item4) ? "true;" : "false;"));
break;
case "Int16":
codeBuffer.Globals.Add("int " + tuple.Item1 + " = " + tuple.Item4.ToString() + ";");
break;
case "Byte":
codeBuffer.Globals.Add("byte " + tuple.Item1 + " = " + tuple.Item4.ToString() + ";");
break;
default:
throw new FormatException("Unrecognized variable type in data table");
}
}
foreach (var tuple in tuples.Where(x => x.Item3 == LDVarClass.InFunction))
{
List <string> buffer = new List <string>();
buffer.Add("boolean " + tuple.Item1 + "(boolean input)");
buffer.Add("{");
foreach (string line in tuple.Item4.ToString().Split('\n'))
{
buffer.Add(INDENT + line);
}
buffer.Add("}");
codeBuffer.Functions.Add(buffer);
}
foreach (var tuple in tuples.Where(x => x.Item3 == LDVarClass.OutFunction))
{
List <string> buffer = new List <string>();
buffer.Add("void " + tuple.Item1 + "()");
buffer.Add("{");
foreach (string line in tuple.Item4.ToString().Split('\n'))
{
buffer.Add(INDENT + line);
}
buffer.Add("}");
codeBuffer.Functions.Add(buffer);
}
}
public void WrongArgsTests()
{
LadderDataTable TestTable = new LadderDataTable();
TestTable.Add("Var1", typeof(int));
try
{
TestTable.Add("", typeof(int));
throw new AssertFailedException("Exception expected");
}
catch (ArgumentNullException ex)
{
StringAssert.Equals(ex.ParamName, "name");
}
try
{
TestTable.Add("Var2", null);
throw new AssertFailedException("Exception expected");
}
catch (ArgumentNullException ex)
{
StringAssert.Equals(ex.ParamName, "type");
}
try
{
TestTable.Add("", typeof(int), LDVarClass.Data, 10);
throw new AssertFailedException("Exception expected");
}
catch (ArgumentNullException ex)
{
StringAssert.Equals(ex.ParamName, "name");
}
try
{
TestTable.Add("Var2", null, LDVarClass.Data, 10);
throw new AssertFailedException("Exception expected");
}
catch (ArgumentNullException ex)
{
StringAssert.Equals(ex.ParamName, "type");
}
try
{
TestTable.Remove("");
throw new AssertFailedException("Exception expected");
}
catch (ArgumentNullException ex)
{
StringAssert.Equals(ex.ParamName, "name");
}
try
{
TestTable.Remove("Var3");
throw new AssertFailedException("Exception expected");
}
catch (ArgumentException ex)
{
StringAssert.Equals(ex.ParamName, "name");
}
try
{
TestTable.Rename("", "Var4");
throw new AssertFailedException("Exception expected");
}
catch (ArgumentNullException ex)
{
StringAssert.Equals(ex.ParamName, "oldName");
}
try
{
TestTable.Rename("Var3", "");
throw new AssertFailedException("Exception expected");
}
catch (ArgumentNullException ex)
{
StringAssert.Equals(ex.ParamName, "newName");
}
try
{
TestTable.Rename("Var3", "Var4");
throw new AssertFailedException("Exception expected");
}
catch (ArgumentException ex)
{
StringAssert.Equals(ex.Message, "Variable not found");
StringAssert.Equals(ex.ParamName, "oldName");
}
try
{
TestTable.GetIndexOf("Var3");
throw new AssertFailedException("Exception expected");
}
catch (ArgumentException ex)
{
StringAssert.Equals(ex.Message, "Variable not found");
StringAssert.Equals(ex.ParamName, "name");
}
try
{
TestTable.GetValue("Var3");
throw new AssertFailedException("Exception expected");
}
catch (ArgumentException ex)
{
StringAssert.Equals(ex.Message, "Variable not found");
StringAssert.Equals(ex.ParamName, "name");
}
}
public void IndexOfRangeTest()
{
LadderDataTable TestTable = new LadderDataTable();
TestTable.GetValue(1);
}
public void TypeSafetyTests()
{
LadderDataTable TestTable = new LadderDataTable();
TestTable.Add("Var1", typeof(int));
TestTable.Add("Var2", typeof(bool));
try
{
TestTable.Add("Var1", typeof(bool));
throw new AssertFailedException("Exception expected");
}
catch (ArgumentException ex)
{
StringAssert.Equals(ex.ParamName, "name");
Assert.IsInstanceOfType(ex.InnerException, typeof(FormatException));
}
try
{
TestTable.Add("Var1", typeof(bool), LDVarClass.Data, false);
throw new AssertFailedException("Exception expected");
}
catch (ArgumentException ex)
{
StringAssert.Equals(ex.ParamName, "name");
Assert.IsInstanceOfType(ex.InnerException, typeof(FormatException));
}
try
{
TestTable.Add("Var3", typeof(int), LDVarClass.Data, null);
throw new AssertFailedException("Exception expected");
}
catch (ArgumentNullException ex)
{
StringAssert.Contains(ex.Message, "non-nullable");
StringAssert.Equals(ex.ParamName, "value");
}
try
{
TestTable.Rename("Var2", "Var1");
throw new AssertFailedException("Exception expected");
}
catch (ArgumentException ex)
{
StringAssert.Equals(ex.ParamName, "newName");
Assert.IsInstanceOfType(ex.InnerException, typeof(FormatException));
}
try
{
TestTable.SetValue("Var1", "Var1");
throw new AssertFailedException("Exception expected");
}
catch (FormatException ex)
{
StringAssert.Equals(ex.Message, "Value Type Mismatch");
}
try
{
TestTable.SetValue(0, "Var1");
throw new AssertFailedException("Exception expected");
}
catch (FormatException ex)
{
StringAssert.Equals(ex.Message, "Value Type Mismatch");
}
}
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
}
public void Counter()
{
#region Startup
var TestTable = new LadderDataTable();
Node PowerRail = new Node();
CTC ctc = new CTC();
ctc.Name = "1";
ctc.Limit = "Limit";
ctc.LeftLide = PowerRail;
ctc.DataTable = TestTable;
CTD ctd = new CTD();
ctd.Name = "1";
ctd.Limit = "Limit";
ctd.LeftLide = PowerRail;
ctd.DataTable = TestTable;
CTU ctu = new CTU();
ctu.Name = "1";
ctu.Limit = "Limit";
ctu.LeftLide = PowerRail;
ctu.DataTable = TestTable;
RES res = new RES();
res.Name = "1";
res.LeftLide = PowerRail;
res.DataTable = TestTable;
#endregion Startup
#region CTC
Trace.WriteLine("CTC", "Unit Test");
Trace.Indent();
Trace.WriteLine("StartUP", "CTC");
Trace.Indent();
PowerRail.LogicLevel = true;
ctc.CurrentValue = 1;
ctc.LimitValue = 2;
res.Execute();
Trace.Unindent();
Trace.WriteLine("Input False", "CTC");
Trace.Indent();
PowerRail.LogicLevel = false;
ctc.Execute();
ctc.Execute();
ctc.Execute();
Assert.IsFalse(ctc.InternalState);
Trace.Unindent();
Trace.WriteLine("Input True", "CTC");
Trace.Indent();
PowerRail.LogicLevel = false;
ctc.Execute();
PowerRail.LogicLevel = true;
ctc.Execute();
Assert.IsFalse(ctc.InternalState, "Fail First Cycle");
PowerRail.LogicLevel = false;
ctc.Execute();
PowerRail.LogicLevel = true;
ctc.Execute();
Assert.IsTrue(ctc.InternalState, "Fail Second Cycle");
PowerRail.LogicLevel = false;
ctc.Execute();
PowerRail.LogicLevel = true;
ctc.Execute();
Assert.IsFalse(ctc.InternalState, "Fail Third Cycle");
PowerRail.LogicLevel = false;
ctc.Execute();
PowerRail.LogicLevel = true;
ctc.Execute();
Assert.IsFalse(ctc.InternalState, "Fail Fourth Cycle");
Trace.Unindent();
Trace.Unindent();
#endregion CTC
#region CTD
Trace.WriteLine("CTD", "Unit Test");
Trace.Indent();
Trace.WriteLine("StartUP", "CTD");
Trace.Indent();
PowerRail.LogicLevel = true;
ctc.CurrentValue = 3;
ctc.LimitValue = 1;
Trace.Unindent();
Trace.WriteLine("Input False", "CTD");
Trace.Indent();
PowerRail.LogicLevel = false;
ctd.Execute();
ctd.Execute();
ctd.Execute();
Assert.IsFalse(ctc.InternalState);
Trace.Unindent();
Trace.WriteLine("Input True", "CTD");
Trace.Indent();
PowerRail.LogicLevel = false;
ctd.Execute();
PowerRail.LogicLevel = true;
ctd.Execute();
Assert.IsTrue(ctd.InternalState, "Fail First Cycle");
PowerRail.LogicLevel = false;
ctd.Execute();
PowerRail.LogicLevel = true;
ctd.Execute();
Assert.IsTrue(ctd.InternalState, "Fail Second Cycle");
PowerRail.LogicLevel = false;
ctd.Execute();
PowerRail.LogicLevel = true;
ctd.Execute();
Assert.IsFalse(ctd.InternalState, "Fail Third Cycle");
PowerRail.LogicLevel = false;
ctd.Execute();
PowerRail.LogicLevel = true;
ctd.Execute();
Assert.IsFalse(ctd.InternalState, "Fail Fourth Cycle");
Trace.Unindent();
Trace.Unindent();
#endregion CTD
#region CTU
Trace.WriteLine("CTU", "Unit Test");
Trace.Indent();
Trace.WriteLine("StartUP", "CTU");
Trace.Indent();
PowerRail.LogicLevel = true;
ctu.CurrentValue = 1;
ctu.LimitValue = 3;
res.Execute();
Trace.Unindent();
Trace.WriteLine("Input False", "CTU");
Trace.Indent();
PowerRail.LogicLevel = false;
ctu.Execute();
ctu.Execute();
ctu.Execute();
Assert.IsFalse(ctu.InternalState);
Trace.Unindent();
Trace.WriteLine("Input True", "CTU");
Trace.Indent();
PowerRail.LogicLevel = false;
ctu.Execute();
PowerRail.LogicLevel = true;
ctu.Execute();
Assert.IsFalse(ctu.InternalState, "Fail First Cycle");
PowerRail.LogicLevel = false;
ctu.Execute();
PowerRail.LogicLevel = true;
ctu.Execute();
Assert.IsFalse(ctu.InternalState, "Fail Second Cycle");
PowerRail.LogicLevel = false;
ctu.Execute();
PowerRail.LogicLevel = true;
ctu.Execute();
Assert.IsTrue(ctu.InternalState, "Fail Third Cycle");
PowerRail.LogicLevel = false;
ctu.Execute();
Assert.IsFalse(ctu.InternalState, "Fail Fourth Cycle");
PowerRail.LogicLevel = true;
ctu.Execute();
Assert.IsTrue(ctu.InternalState, "Fail Fourth Cycle");
Trace.Unindent();
Trace.Unindent();
#endregion CTU
}
public void Compare()
{
#region Startup
var TestTable = new LadderDataTable();
Node PowerRail = new Node();
EQU equ = new EQU();
equ.LeftLide = PowerRail;
equ.VarA = "VarA";
equ.VarB = "VarB";
equ.DataTable = TestTable;
GEQ geq = new GEQ();
geq.LeftLide = PowerRail;
geq.VarA = "VarA";
geq.VarB = "VarB";
geq.DataTable = TestTable;
GRT grt = new GRT();
grt.LeftLide = PowerRail;
grt.VarA = "VarA";
grt.VarB = "VarB";
grt.DataTable = TestTable;
LEG leg = new LEG();
leg.LeftLide = PowerRail;
leg.VarA = "VarA";
leg.VarB = "VarB";
leg.DataTable = TestTable;
LES les = new LES();
les.LeftLide = PowerRail;
les.VarA = "VarA";
les.VarB = "VarB";
les.DataTable = TestTable;
NEQ neq = new NEQ();
neq.LeftLide = PowerRail;
neq.VarA = "VarA";
neq.VarB = "VarB";
neq.DataTable = TestTable;
#endregion Startup
#region EQU
Trace.WriteLine("EQU", "Unit Test");
Trace.Indent();
Trace.WriteLine("Input False", "EQU");
Trace.Indent();
PowerRail.LogicLevel = false;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(equ.Execute());
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(equ.Execute());
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
Assert.IsFalse(equ.Execute());
Trace.Unindent();
Trace.WriteLine("Input True", "EQU");
Trace.Indent();
PowerRail.LogicLevel = true;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
Assert.IsTrue(equ.Execute());
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(equ.Execute());
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
Assert.IsFalse(equ.Execute());
Trace.Unindent();
Trace.Unindent();
#endregion EQU
#region GEQ
Trace.WriteLine("GEQ", "Unit Test");
Trace.Indent();
Trace.WriteLine("Input False", "GEQ");
Trace.Indent();
PowerRail.LogicLevel = false;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(geq.Execute());
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(geq.Execute());
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
Assert.IsFalse(geq.Execute());
Trace.Unindent();
Trace.WriteLine("Input True", "GEQ");
Trace.Indent();
PowerRail.LogicLevel = true;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
Assert.IsTrue(geq.Execute());
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(geq.Execute());
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
Assert.IsTrue(geq.Execute());
Trace.Unindent();
Trace.Unindent();
#endregion GEQ
#region GRT
Trace.WriteLine("GRT", "Unit Test");
Trace.Indent();
Trace.WriteLine("Input False", "GRT");
Trace.Indent();
PowerRail.LogicLevel = false;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
grt.Execute();
Assert.IsFalse(grt.InternalState);
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
grt.Execute();
Assert.IsFalse(grt.InternalState);
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
grt.Execute();
Assert.IsFalse(grt.InternalState);
Trace.Unindent();
Trace.WriteLine("Input True", "GRT");
Trace.Indent();
PowerRail.LogicLevel = true;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
grt.Execute();
Assert.IsFalse(grt.InternalState);
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
grt.Execute();
Assert.IsFalse(grt.InternalState);
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
grt.Execute();
Assert.IsTrue(grt.InternalState);
Trace.Unindent();
Trace.Unindent();
#endregion GRT
#region LEG
Trace.WriteLine("LEG", "Unit Test");
Trace.Indent();
Trace.WriteLine("Input False", "LEG");
Trace.Indent();
PowerRail.LogicLevel = false;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
leg.Execute();
Assert.IsFalse(leg.InternalState);
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
leg.Execute();
Assert.IsFalse(leg.InternalState);
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
leg.Execute();
Assert.IsFalse(leg.InternalState);
Trace.Unindent();
Trace.WriteLine("Input True", "LEG");
Trace.Indent();
PowerRail.LogicLevel = true;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
leg.Execute();
Assert.IsTrue(leg.InternalState);
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
leg.Execute();
Assert.IsTrue(leg.InternalState);
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
leg.Execute();
Assert.IsFalse(leg.InternalState);
Trace.Unindent();
Trace.Unindent();
#endregion LEG
#region LES
Trace.WriteLine("LES", "Unit Test");
Trace.Indent();
Trace.WriteLine("Input False", "LES");
Trace.Indent();
PowerRail.LogicLevel = false;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(les.Execute());
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(les.Execute());
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
Assert.IsFalse(les.Execute());
Trace.Unindent();
Trace.WriteLine("Input True", "LES");
Trace.Indent();
PowerRail.LogicLevel = true;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(les.Execute());
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
Assert.IsTrue(les.Execute());
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
Assert.IsFalse(les.Execute());
Trace.Unindent();
Trace.Unindent();
#endregion LES
#region NEQ
Trace.WriteLine("NEQ", "Unit Test");
Trace.Indent();
Trace.WriteLine("Input False", "NEQ");
Trace.Indent();
PowerRail.LogicLevel = false;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(neq.Execute());
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(neq.Execute());
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
Assert.IsFalse(neq.Execute());
Trace.Unindent();
Trace.WriteLine("Input True", "NEQ");
Trace.Indent();
PowerRail.LogicLevel = true;
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)1);
Assert.IsFalse(neq.Execute());
TestTable.SetValue(0, (short)0);
TestTable.SetValue(1, (short)1);
Assert.IsTrue(neq.Execute());
TestTable.SetValue(0, (short)1);
TestTable.SetValue(1, (short)0);
Assert.IsTrue(neq.Execute());
Trace.Unindent();
Trace.Unindent();
#endregion NEQ
}
