internal void ElementListAddFirst(PortElement <T> Item)
{
if (Elements == null)
{
Elements = Item;
Item._next = Item;
Item._previous = Item;
ElementCount++;
return;
}
if (Elements._next == Elements)
{
PortElement <T> elements = Elements;
Elements = Item;
Elements._next = elements;
Elements._previous = elements;
elements._next = Elements;
elements._previous = Elements;
ElementCount++;
return;
}
PortElement <T> elements2 = Elements;
Elements = Item;
Item._next = elements2;
Item._previous = elements2._previous;
elements2._previous._next = Item;
elements2._previous = Item;
ElementCount++;
}
public void inverterTest()
{
ElementsFactory factory = ElementsFactory.getInstance();
PortElement a = factory.createPortElement(PortDirection.Input, "a");
PortElement b = factory.createPortElement(PortDirection.Output, "b");
ILogicalElement inverter = factory.createLogicalElement(LibraryElementKind.Enum.Inverter, 1);
Utils.Evaluator evaluator = new Utils.Evaluator(inverter, new PortList {
b
});
inverter.makeConnection(a, 0, 0);
b.makeConnection(inverter, 0, 0);
a.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(b.Value, LogicValue.Enum.Low);
a.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(b.Value, LogicValue.Enum.High);
a.Value = LogicValue.Enum.Unknown;
evaluator.evaluate();
Assert.AreEqual(b.Value, LogicValue.Enum.Unknown);
a.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(b.Value, LogicValue.Enum.DontCare);
}
public void TwoArgsCtor()
{
var port = new Port<int> ();
var pe = new PortElement<int> (10, port);
Assert.AreEqual (10, pe.TypedItem, "#1");
Assert.AreEqual (10, pe.Item, "#2");
Assert.AreEqual (port, pe.Owner, "#3");
}
internal bool TestInternal(out PortElement <T> node)
{
node = null;
lock (Store)
{
node = Store.ElementListRemoveFirst();
}
return(node != null);
}
protected virtual void RegisterReceiver(ReceiverTask receiver)
{
lock (Store)
{
if (!Store.IsElementListEmpty)
{
PortElement <T> portElement = Store.ElementListFirst;
int num = Store.ElementCount;
while (true)
{
PortElement <T> next = portElement._next;
ITask task = null;
bool flag2 = receiver.Evaluate(portElement, ref task);
if (task != null)
{
receiver.TaskQueue.Enqueue(task);
}
if (flag2)
{
Store.ElementListRemove(portElement);
}
if (receiver.State != ReceiverTaskState.Persistent)
{
if (flag2)
{
break;
}
if (task != null)
{
goto IL_88;
}
}
portElement = next;
num--;
if (num <= 0)
{
goto IL_88;
}
}
return;
}
IL_88:
if (_mode == PortMode.OptimizedSingleReissueReceiver && Store.ReceiverCount == 1)
{
throw new InvalidOperationException("PortMode.OptimizedSingleReissueReceiver allows only a single receiver");
}
Store.AddReceiver(receiver);
}
}
public void simpleOutputPortElement()
{
ElementsFactory factory = ElementsFactory.getInstance();
PortElement portElement = factory.createPortElement(PortDirection.Output, "out");
Assert.AreEqual(portElement.Name, "out");
Assert.AreEqual(portElement.ID, 1);
Assert.AreEqual(portElement.PortKind, PortDirection.Output);
Assert.AreEqual(portElement.Value, LogicValue.Enum.Unknown);
Assert.AreEqual(portElement.Inputs.Size, 1);
}
internal void ElementListRemove(PortElement <T> Item)
{
ElementCount--;
if (Item == Elements)
{
if (ElementCount == 0)
{
Elements = null;
return;
}
Elements = Item._next;
}
Item._previous._next = Item._next;
Item._next._previous = Item._previous;
}
internal void ElementListAddLast(PortElement <T> Item)
{
if (Elements == null)
{
Elements = Item;
Item._next = Item;
Item._previous = Item;
}
else
{
Elements._previous._next = Item;
Item._previous = Elements._previous;
Item._next = Elements;
Elements._previous = Item;
}
ElementCount++;
}
public void simple_2_1_Mux()
{
ElementsFactory factory = ElementsFactory.getInstance();
factory.reset();
ILogicalElement mux = factory.createLogicalElement(LibraryElementKind.Enum.MUX, 1);
PortElement a_port = factory.createPortElement(PortDirection.Input, "a");
PortElement b_port = factory.createPortElement(PortDirection.Input, "b");
PortElement address = factory.createPortElement(PortDirection.Input, "adr");
PortElement c_port = factory.createPortElement(PortDirection.Output, "c");
Utils.Evaluator evaluator = new Utils.Evaluator(mux, new PortList {
c_port
});
mux.makeConnection(a_port, 0, 0);
mux.makeConnection(b_port, 1, 0);
mux.makeConnection(address, 2, 0);
c_port.makeConnection(mux, 1, 0);
address.Value = LogicValue.Enum.Low;
a_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(c_port.Value, LogicValue.Enum.Unknown);
a_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(c_port.Value, LogicValue.Enum.Unknown);
address.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(c_port.Value, LogicValue.Enum.Unknown);
b_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
b_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(c_port.Value, LogicValue.Enum.High);
}
public void CtorSideEffect()
{
IteratorHandler handler = () => null;
var task = new IterativeTask (handler);
Assert.IsNull (task.ArbiterCleanupHandler, "#1");
try {
var x = task [0];
Assert.Fail ("#2");
} catch (NotSupportedException) {}
try {
task [0] = new PortElement<int> (10);
Assert.Fail ("#2");
} catch (NotSupportedException) {}
Assert.AreEqual (handler, task.Handler, "#3");
Assert.IsNull (task.LinkedIterator, "#4");
Assert.IsNull (task.LinkedIterator, "#5");
Assert.IsNull (task.TaskQueue, "#6");
}
public void Execute()
{
int cnt = 1;
var task = new VariableArgumentTask<int> (2, (a) => cnt += a.Length);
try {
task.Execute ();
Assert.Fail ("#1");
} catch (NullReferenceException) {}
task [0] = new PortElement<int> (10);
try {
task.Execute ();
Assert.Fail ("#2");
} catch (NullReferenceException) {}
task [1] = new PortElement<int> (20);
Assert.IsNull (task.Execute (), "#3");
Assert.AreEqual (3, cnt, "#4");
}
internal PortElement <T> ElementListRemoveFirst()
{
if (Elements == null)
{
return(null);
}
if (Elements._next == Elements)
{
PortElement <T> elements = Elements;
Elements = null;
ElementCount--;
return(elements);
}
PortElement <T> elements2 = Elements;
Elements = Elements._next;
Elements._previous = elements2._previous;
Elements._previous._next = Elements;
ElementCount--;
return(elements2);
}
public void simpleInputPortElement()
{
ElementsFactory factory = ElementsFactory.getInstance();
factory.reset();
PortElement portElement = factory.createPortElement(PortDirection.Input, "port");
Assert.AreEqual(portElement.Name, "port");
Assert.AreEqual(portElement.ID, 0);
Assert.AreEqual(portElement.PortKind, PortDirection.Input);
portElement.Value = LogicValue.Enum.High;
Assert.AreEqual(portElement.Outputs[0].Value, LogicValue.Enum.High);
portElement.Value = LogicValue.Enum.Low;
Assert.AreEqual(portElement.Outputs[0].Value, LogicValue.Enum.Low);
}
public void simple2AND()
{
ElementsFactory factory = ElementsFactory.getInstance();
factory.reset();
PortElement a = factory.createPortElement(PortDirection.Input, "a");
PortElement b = factory.createPortElement(PortDirection.Input, "b");
PortElement c = factory.createPortElement(PortDirection.Output, "c");
ILogicalElement and2 = factory.createLogicalElement(LibraryElementKind.Enum.AND, 2);
Utils.Evaluator evaluator = new Utils.Evaluator(and2, new PortList {
c
});
and2.makeConnection(a, 0, 0);
and2.makeConnection(b, 1, 0);
c.makeConnection(and2, 0, 0);
a.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(c.Value, LogicValue.Enum.Unknown);
b.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(c.Value, LogicValue.Enum.Low);
a.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(c.Value, LogicValue.Enum.High);
a.Value = LogicValue.Enum.Unknown;
evaluator.evaluate();
Assert.AreEqual(c.Value, LogicValue.Enum.Unknown);
}
internal void PostInternal(bool insertAtHead, PortElement <T> node)
{
bool flag = false;
ITask task = null;
DispatcherQueue dispatcherQueue = null;
lock (Store)
{
if (insertAtHead)
{
Store.ElementListAddFirst(node);
}
else
{
Store.ElementListAddLast(node);
}
if (Store.ReceiverCount == 0)
{
return;
}
int num = 1;
if (Store.ActiveReceiver == null)
{
num = Store.ReceiverCount;
}
ReceiverTask receiverTask = Store.ActiveReceiver;
int i = 0;
while (i < num)
{
if (num != 1)
{
receiverTask = Store.GetReceiverAtIndex(i);
}
task = null;
flag = receiverTask.Evaluate(node, ref task);
dispatcherQueue = receiverTask.TaskQueue;
if (flag)
{
Store.ElementListRemove(node);
if (receiverTask.State != ReceiverTaskState.Persistent)
{
Store.RemoveReceiver(receiverTask);
if (i > 1)
{
i--;
}
else
{
receiverTask = Store.ActiveReceiver;
}
num = Store.ReceiverCount;
break;
}
break;
}
else
{
if (task != null)
{
dispatcherQueue.Enqueue(task);
}
i++;
}
}
}
if (flag && task != null)
{
dispatcherQueue.Enqueue(task);
}
}
public void PostElementThenTestForElement()
{
int tmp;
var p = new Port<int> ();
; var elem = new PortElement<int> (99);
p.PostElement (elem);
Assert.AreEqual (1, p.ItemCount, "#1");
var res = p.TestForElement ();
Assert.AreEqual (elem, res, "#2");
Assert.AreEqual (0, p.ItemCount, "#3");
Assert.AreEqual (null, res.Owner, "#4");
}
public void PostElementBad()
{
var p = new Port<int> ();
; var elem = new PortElement<double> (99);
try {
p.PostElement (elem);
Assert.Fail ("#1");
} catch (InvalidCastException) {} /*LAMEIMPL, stupid exception to throw*/
try {
p.PostElement (null);
Assert.Fail ("#2");
} catch (NullReferenceException) {} /*LAMEIMPL, stupid exception to throw*/
}
public void simple_2_4_DC()
{
ElementsFactory factory = ElementsFactory.getInstance();
factory.reset();
ILogicalElement dc = factory.createLogicalElement(LibraryElementKind.Enum.DC, 2);
PortElement addressLow = factory.createPortElement(PortDirection.Input, "a0");
PortElement addressHigh = factory.createPortElement(PortDirection.Input, "a1");
PortElement enable = factory.createPortElement(PortDirection.Input, "en");
PortElement b_port = factory.createPortElement(PortDirection.Output, "b");
PortElement c_port = factory.createPortElement(PortDirection.Output, "c");
PortElement d_port = factory.createPortElement(PortDirection.Output, "d");
PortElement e_port = factory.createPortElement(PortDirection.Output, "e");
dc.makeConnection(addressLow, 0, 0);
dc.makeConnection(addressHigh, 1, 0);
dc.makeConnection(enable, 2, 0);
b_port.makeConnection(dc, 0, 0);
c_port.makeConnection(dc, 0, 1);
d_port.makeConnection(dc, 0, 2);
e_port.makeConnection(dc, 0, 3);
Assert.AreEqual(b_port.Value, LogicValue.Enum.Unknown);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Unknown);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Unknown);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Unknown);
// enable = X
enable.Value = LogicValue.Enum.DontCare;
addressHigh.Value = LogicValue.Enum.Low;
addressLow.Value = LogicValue.Enum.Low;
Assert.AreEqual(b_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(c_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(d_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
addressHigh.Value = LogicValue.Enum.High;
addressLow.Value = LogicValue.Enum.High;
Assert.AreEqual(b_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(c_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(d_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
// enable low
enable.Value = LogicValue.Enum.Low;
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
addressHigh.Value = LogicValue.Enum.DontCare;
addressLow.Value = LogicValue.Enum.DontCare;
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
//enable high
// 00
enable.Value = LogicValue.Enum.High;
addressHigh.Value = LogicValue.Enum.Low;
addressLow.Value = LogicValue.Enum.Low;
Assert.AreEqual(b_port.Value, LogicValue.Enum.High);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
addressHigh.Value = LogicValue.Enum.Low;
addressLow.Value = LogicValue.Enum.High;
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.High);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
// 10
addressHigh.Value = LogicValue.Enum.High;
addressLow.Value = LogicValue.Enum.Low;
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.High);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
// 11
addressHigh.Value = LogicValue.Enum.High;
addressLow.Value = LogicValue.Enum.High;
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
// X1
addressHigh.Value = LogicValue.Enum.DontCare;
addressLow.Value = LogicValue.Enum.High;
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
// XX
addressHigh.Value = LogicValue.Enum.DontCare;
addressLow.Value = LogicValue.Enum.DontCare;
Assert.AreEqual(b_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(c_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(d_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
}
public void simple_4_1_Mux()
{
ElementsFactory factory = ElementsFactory.getInstance();
factory.reset();
ILogicalElement mux = factory.createLogicalElement(LibraryElementKind.Enum.MUX, 2);
PortElement a_port = factory.createPortElement(PortDirection.Input, "a");
PortElement b_port = factory.createPortElement(PortDirection.Input, "b");
PortElement c_port = factory.createPortElement(PortDirection.Input, "c");
PortElement d_port = factory.createPortElement(PortDirection.Input, "d");
PortElement addressLow = factory.createPortElement(PortDirection.Input, "adr_l");
PortElement addressHigh = factory.createPortElement(PortDirection.Input, "adr_h");
PortElement e_port = factory.createPortElement(PortDirection.Output, "e");
Utils.Evaluator evaluator = new Utils.Evaluator(mux, new PortList {
e_port
});
mux.makeConnection(a_port, 0, 0);
mux.makeConnection(b_port, 1, 0);
mux.makeConnection(c_port, 2, 0);
mux.makeConnection(d_port, 3, 0);
mux.makeConnection(addressLow, 4, 0);
mux.makeConnection(addressHigh, 5, 0);
e_port.makeConnection(mux, 1, 0);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Unknown);
// 000U
// 00
addressHigh.Value = LogicValue.Enum.Low;
addressLow.Value = LogicValue.Enum.Low;
a_port.Value = LogicValue.Enum.Unknown;
b_port.Value = LogicValue.Enum.Low;
c_port.Value = LogicValue.Enum.Low;
d_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Unknown);
//dcba
//0000
//1X
addressHigh.Value = LogicValue.Enum.High;
addressLow.Value = LogicValue.Enum.DontCare;
a_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
// 01
addressHigh.Value = LogicValue.Enum.Low;
addressLow.Value = LogicValue.Enum.High;
b_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
//1000
//1X
addressHigh.Value = LogicValue.Enum.High;
addressLow.Value = LogicValue.Enum.DontCare;
d_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
//1100
// 1X
c_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
//11X0
// 1X
b_port.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
//11XX
// 1X
a_port.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
//11XX
//X0
addressHigh.Value = LogicValue.Enum.DontCare;
addressLow.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
//11X0
//X0
a_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
// 11X1
// X0
a_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
// 11X1
// XX
addressLow.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
// 1101
// XX
b_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
// 1111
// XX
b_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
// 0000
// XX
a_port.Value = LogicValue.Enum.Low;
b_port.Value = LogicValue.Enum.Low;
c_port.Value = LogicValue.Enum.Low;
d_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
// 0000
// 00
addressLow.Value = LogicValue.Enum.Low;
addressHigh.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
//0001
//00
a_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
//0001
//01
addressLow.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
//0011
//01
b_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
//0011
//11
addressHigh.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
//1011
//11
d_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
//1011
//10
addressLow.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
//1111
//10
c_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
}
public void ExecuteWithBoundFirstArg()
{
double cntA = 1;
int cntB = 1;
var task = new VariableArgumentTask<double, int> (1, (a, b) => { cntA += a; cntB += b.Length; });
task [0] = new PortElement <double> (4);
task [1] = new PortElement <int> (2);
Assert.IsNull (task.Execute (), "#1");
Assert.AreEqual (5, cntA, "#2");
Assert.AreEqual (2, cntB, "#3");
}
public void PortElementCountAndItemProperties()
{
int cnt = 0;
Task tk = new Task (() => ++cnt);
Assert.AreEqual (0, tk.PortElementCount, "#1");
try {
tk [0] = new PortElement<int> (10);
Assert.Fail ("#2");
} catch (NotSupportedException) {}
try {
object f = tk [0];
Assert.Fail ("#3");
} catch (NotSupportedException) {}
}
public void Task1ExecuteWithBoundObject()
{
int cnt = 0;
var tk = new Task<int> (5, (a) => cnt += a);
tk.Execute ();
Assert.AreEqual (5, cnt, "#1");
tk.Execute ();
Assert.AreEqual (10, cnt, "#2");
Assert.IsNotNull (tk [0], "#3");
tk [0] = new PortElement<int> (2);
tk.Execute ();
Assert.AreEqual (12, cnt, "#4");
}
public void Task1PartialCloneDoesntCloneArgument()
{
int cnt = 0;
Handler<int> h = (a) => cnt += a;
PortElement<int> pe = new PortElement<int> (10);
var tk = new Task<int> (h);
tk [0] = pe;
ITask it = tk.PartialClone ();
Assert.IsTrue (it is Task<int>, "#1");
var tk2 = (Task<int>)it;
Assert.IsNull (tk2 [0], "#2");
tk = new Task<int> (99, h);
it = tk.PartialClone ();
Assert.IsNull (it [0], "#3");
}
public void simple_1_4_DMX()
{
ElementsFactory factory = ElementsFactory.getInstance();
factory.reset();
ILogicalElement dmx = factory.createLogicalElement(LibraryElementKind.Enum.DMX, 2);
PortElement addressLow = factory.createPortElement(PortDirection.Input, "a0");
PortElement addressHigh = factory.createPortElement(PortDirection.Input, "a1");
PortElement data = factory.createPortElement(PortDirection.Input, "data");
PortElement enable = factory.createPortElement(PortDirection.Input, "en");
PortElement b_port = factory.createPortElement(PortDirection.Output, "b");
PortElement c_port = factory.createPortElement(PortDirection.Output, "c");
PortElement d_port = factory.createPortElement(PortDirection.Output, "d");
PortElement e_port = factory.createPortElement(PortDirection.Output, "e");
Utils.Evaluator evaluator = new Utils.Evaluator(dmx, new PortList {
b_port, c_port, d_port, e_port
});
dmx.makeConnection(addressLow, 0, 0);
dmx.makeConnection(addressHigh, 1, 0);
dmx.makeConnection(data, 2, 0);
dmx.makeConnection(enable, 3, 0);
b_port.makeConnection(dmx, 0, 0);
c_port.makeConnection(dmx, 0, 1);
d_port.makeConnection(dmx, 0, 2);
e_port.makeConnection(dmx, 0, 3);
Assert.AreEqual(b_port.Value, LogicValue.Enum.Unknown);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Unknown);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Unknown);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Unknown);
// enable = X
enable.Value = LogicValue.Enum.DontCare;
addressHigh.Value = LogicValue.Enum.Low;
addressLow.Value = LogicValue.Enum.Low;
data.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
addressHigh.Value = LogicValue.Enum.High;
addressLow.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
// enable low
enable.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
addressHigh.Value = LogicValue.Enum.DontCare;
addressLow.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
//enable high
// 00
enable.Value = LogicValue.Enum.High;
addressHigh.Value = LogicValue.Enum.Low;
addressLow.Value = LogicValue.Enum.Low;
data.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
data.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.High);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
data.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
// 01
addressHigh.Value = LogicValue.Enum.Low;
addressLow.Value = LogicValue.Enum.High;
data.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
data.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.High);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
data.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
// 10
addressHigh.Value = LogicValue.Enum.High;
addressLow.Value = LogicValue.Enum.Low;
data.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
data.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.High);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
data.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
// 11
addressHigh.Value = LogicValue.Enum.High;
addressLow.Value = LogicValue.Enum.High;
data.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
data.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
data.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
// X1
addressHigh.Value = LogicValue.Enum.DontCare;
addressLow.Value = LogicValue.Enum.High;
data.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
data.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
data.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
// XX
addressHigh.Value = LogicValue.Enum.DontCare;
addressLow.Value = LogicValue.Enum.DontCare;
data.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(c_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(d_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
data.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(c_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(d_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
data.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
Assert.AreEqual(b_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(c_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(d_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
/***************************************************************************/
}
public void Task1Execute()
{
int cnt = 0;
var tk = new Task<int> ((a) => cnt += a);
try {
tk.Execute ();
Assert.Fail ("#1"); //no value at port 1
} catch (NullReferenceException) {}
var pe = new PortElement<int> (10);
tk [0] = pe;
tk.Execute ();
Assert.AreEqual (10, cnt, "#2");
Assert.AreEqual (pe, tk [0], "#3");
tk [0] = new PortElement<int> (2);
tk.Execute ();
Assert.AreEqual (12, cnt, "#3");
}
public void simple3AND()
{
ElementsFactory factory = ElementsFactory.getInstance();
PortElement a = factory.createPortElement(PortDirection.Input, "a");
PortElement b = factory.createPortElement(PortDirection.Input, "b");
PortElement c = factory.createPortElement(PortDirection.Input, "c");
PortElement d = factory.createPortElement(PortDirection.Output, "d");
ILogicalElement and3 = factory.createLogicalElement(LibraryElementKind.Enum.AND, 3);
Utils.Evaluator evaluator = new Utils.Evaluator(and3, new PortList {
d
});
and3.makeConnection(a, 0, 0);
and3.makeConnection(b, 1, 0);
and3.makeConnection(c, 2, 0);
d.makeConnection(and3, 0, 0);
a.Value = LogicValue.Enum.Unknown;
b.Value = LogicValue.Enum.Low;
c.Value = LogicValue.Enum.Low;
evaluator.evaluate();
// U00
Assert.AreEqual(d.Value, LogicValue.Enum.Unknown);
a.Value = LogicValue.Enum.Low;
b.Value = LogicValue.Enum.Unknown;
c.Value = LogicValue.Enum.High;
evaluator.evaluate();
// 0U1
Assert.AreEqual(d.Value, LogicValue.Enum.Unknown);
a.Value = LogicValue.Enum.DontCare;
b.Value = LogicValue.Enum.High;
c.Value = LogicValue.Enum.Unknown;
evaluator.evaluate();
// X1U
Assert.AreEqual(d.Value, LogicValue.Enum.Unknown);
a.Value = LogicValue.Enum.DontCare;
b.Value = LogicValue.Enum.High;
c.Value = LogicValue.Enum.High;
evaluator.evaluate();
// X00
Assert.AreEqual(d.Value, LogicValue.Enum.DontCare);
a.Value = LogicValue.Enum.DontCare;
b.Value = LogicValue.Enum.High;
c.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
// X0X
Assert.AreEqual(d.Value, LogicValue.Enum.DontCare);
a.Value = LogicValue.Enum.Low;
b.Value = LogicValue.Enum.DontCare;
c.Value = LogicValue.Enum.DontCare;
evaluator.evaluate();
// 0XX
Assert.AreEqual(d.Value, LogicValue.Enum.Low);
a.Value = LogicValue.Enum.DontCare;
b.Value = LogicValue.Enum.Low;
c.Value = LogicValue.Enum.DontCare;
// X0X
Assert.AreEqual(d.Value, LogicValue.Enum.Low);
a.Value = LogicValue.Enum.DontCare;
b.Value = LogicValue.Enum.DontCare;
c.Value = LogicValue.Enum.Low;
evaluator.evaluate();
// XX0
Assert.AreEqual(d.Value, LogicValue.Enum.Low);
a.Value = LogicValue.Enum.High;
b.Value = LogicValue.Enum.High;
c.Value = LogicValue.Enum.High;
evaluator.evaluate();
// 111
Assert.AreEqual(d.Value, LogicValue.Enum.High);
a.Value = LogicValue.Enum.Low;
b.Value = LogicValue.Enum.Low;
c.Value = LogicValue.Enum.High;
evaluator.evaluate();
// 001
Assert.AreEqual(d.Value, LogicValue.Enum.Low);
a.Value = LogicValue.Enum.High;
b.Value = LogicValue.Enum.High;
c.Value = LogicValue.Enum.Low;
evaluator.evaluate();
// 110
Assert.AreEqual(d.Value, LogicValue.Enum.Low);
a.Value = LogicValue.Enum.High;
b.Value = LogicValue.Enum.Low;
c.Value = LogicValue.Enum.High;
evaluator.evaluate();
// 101
Assert.AreEqual(d.Value, LogicValue.Enum.Low);
}
public void simple_4_2_CD()
{
ElementsFactory factory = ElementsFactory.getInstance();
factory.reset();
ILogicalElement cd = factory.createLogicalElement(LibraryElementKind.Enum.ENC, 2);
PortElement a_port = factory.createPortElement(PortDirection.Input, "a");
PortElement b_port = factory.createPortElement(PortDirection.Input, "b");
PortElement c_port = factory.createPortElement(PortDirection.Input, "c");
PortElement d_port = factory.createPortElement(PortDirection.Input, "d");
PortElement enable = factory.createPortElement(PortDirection.Input, "en");
PortElement e_port = factory.createPortElement(PortDirection.Output, "e");
PortElement f_port = factory.createPortElement(PortDirection.Output, "f");
Utils.Evaluator evaluator = new Utils.Evaluator(cd, new PortList {
e_port, f_port
});
cd.makeConnection(a_port, 0, 0);
cd.makeConnection(b_port, 1, 0);
cd.makeConnection(c_port, 2, 0);
cd.makeConnection(d_port, 3, 0);
cd.makeConnection(enable, 4, 0);
e_port.makeConnection(cd, 0, 0);
f_port.makeConnection(cd, 0, 1);
Assert.AreEqual(e_port.Value, LogicValue.Enum.Unknown);
Assert.AreEqual(f_port.Value, LogicValue.Enum.Unknown);
// enable = X
enable.Value = LogicValue.Enum.DontCare;
a_port.Value = LogicValue.Enum.Low;
b_port.Value = LogicValue.Enum.Low;
c_port.Value = LogicValue.Enum.Low;
d_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(f_port.Value, LogicValue.Enum.DontCare);
a_port.Value = LogicValue.Enum.High;
b_port.Value = LogicValue.Enum.High;
c_port.Value = LogicValue.Enum.High;
d_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(f_port.Value, LogicValue.Enum.DontCare);
// enable low
enable.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(f_port.Value, LogicValue.Enum.Low);
a_port.Value = LogicValue.Enum.High;
b_port.Value = LogicValue.Enum.High;
c_port.Value = LogicValue.Enum.High;
d_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(f_port.Value, LogicValue.Enum.Low);
//enable high
// 1XXX
enable.Value = LogicValue.Enum.High;
a_port.Value = LogicValue.Enum.DontCare;
b_port.Value = LogicValue.Enum.DontCare;
c_port.Value = LogicValue.Enum.DontCare;
d_port.Value = LogicValue.Enum.High;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
Assert.AreEqual(f_port.Value, LogicValue.Enum.High);
// 1010
a_port.Value = LogicValue.Enum.Low;
b_port.Value = LogicValue.Enum.High;
c_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
Assert.AreEqual(f_port.Value, LogicValue.Enum.High);
// 01XX
a_port.Value = LogicValue.Enum.DontCare;
b_port.Value = LogicValue.Enum.DontCare;
c_port.Value = LogicValue.Enum.High;
d_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(f_port.Value, LogicValue.Enum.High);
// 0111
a_port.Value = LogicValue.Enum.High;
b_port.Value = LogicValue.Enum.High;
c_port.Value = LogicValue.Enum.High;
d_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(f_port.Value, LogicValue.Enum.High);
// 001X
a_port.Value = LogicValue.Enum.DontCare;
b_port.Value = LogicValue.Enum.High;
c_port.Value = LogicValue.Enum.Low;
d_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
Assert.AreEqual(f_port.Value, LogicValue.Enum.Low);
// 0011
a_port.Value = LogicValue.Enum.High;
b_port.Value = LogicValue.Enum.High;
c_port.Value = LogicValue.Enum.Low;
d_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.High);
Assert.AreEqual(f_port.Value, LogicValue.Enum.Low);
// 0001
a_port.Value = LogicValue.Enum.High;
b_port.Value = LogicValue.Enum.Low;
c_port.Value = LogicValue.Enum.Low;
d_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.Low);
Assert.AreEqual(f_port.Value, LogicValue.Enum.Low);
// 0X01
a_port.Value = LogicValue.Enum.High;
b_port.Value = LogicValue.Enum.Low;
c_port.Value = LogicValue.Enum.DontCare;
d_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(f_port.Value, LogicValue.Enum.DontCare);
// 0000
a_port.Value = LogicValue.Enum.Low;
b_port.Value = LogicValue.Enum.Low;
c_port.Value = LogicValue.Enum.Low;
d_port.Value = LogicValue.Enum.Low;
evaluator.evaluate();
Assert.AreEqual(e_port.Value, LogicValue.Enum.DontCare);
Assert.AreEqual(f_port.Value, LogicValue.Enum.DontCare);
/***************************************************************************/
}
public void ItemPropertyBounds()
{
int cnt = 1;
var task = new VariableArgumentTask<int> (5, (a) => cnt += a.Length);
try {
task [-1] = new PortElement<int> (10);
Assert.Fail ("#1");
} catch (IndexOutOfRangeException) {}
try {
task [5] = new PortElement<int> (10);
Assert.Fail ("#2");
} catch (IndexOutOfRangeException) {}
try {
var obj = task [-1];
Assert.Fail ("#3");
} catch (IndexOutOfRangeException) {}
try {
var obj = task [5];
Assert.Fail ("#4");
} catch (IndexOutOfRangeException) {}
}
internal void Clear()
{
ElementCount = 0;
Elements = null;
}
public void Task1SetInvalidItem()
{
int cnt = 0;
var tk = new Task<int> ((a) => cnt += a);
try {
tk [1] = new PortElement<int> (2);
Assert.Fail ("#1");
} catch (ArgumentException) {}
try {
var obj = tk [1];
Assert.Fail ("#2");
} catch (ArgumentException) {}
try {
tk [0] = new PortElement<double> (2);
Assert.Fail ("#3");
} catch (InvalidCastException) {} //LAMEIMPL it should report a better error and take any IPortElement<T>
}
public void ItemProperty()
{
var pa = new Port<int> ();
var pb = new Port<string> ();
var ra = Arbiter.Receive (false, pa, (i) => {});
var rb = Arbiter.Receive (false, pb, (s) => {});
var c = new Choice (ra, rb);
try {
c [0] = new PortElement<int> (10);
Assert.Fail ("#1");
} catch (NotSupportedException) {}
try {
var x = c [1];
Assert.Fail ("#2");
} catch (NotSupportedException) {}
}
public void PartialCloneEmptyElements()
{
int cnt = 1;
var task = new VariableArgumentTask<int> (2, (a) => cnt += a.Length);
task [0] = new PortElement<int> (10);
task [1] = new PortElement<int> (20);
var tk = task.PartialClone ();
Assert.IsNull (tk [0], "#1");
Assert.IsNull (tk [0], "#2");
}
