def test_inOut(self):
box1 = box.Box("global")
box2 = conditionalBox.ConditionalBox("local")
bl = Bool()
make = MakeOne()
dmp = Dump()
plus = PlusOne()
box1.addBlock(box2)
box1.addBlock(bl)
box1.addBlock(dmp)
box1.addBlock(make)
box2.addBlock(plus)
workerManager.WorkerManager.SetUseProcess(False)
in_p = box2.addInputProxy(int, "in")
out_p = box2.addOutputProxy(int, "out")
self.assertIsNotNone(proxy.ProxyChain(make.output(0), in_p.inPort()))
self.assertIsNotNone(proxy.ProxyChain(in_p.outPort(), plus.input(0)))
self.assertIsNotNone(proxy.ProxyChain(plus.output(0), out_p.inPort()))
self.assertIsNotNone(proxy.ProxyChain(out_p.outPort(), dmp.input(0)))
self.assertIsNotNone(chain.Chain(bl.output(0), box2.input(0)))
schedules = box1.getSchedule()
bl.param("do").set(False)
workerManager.WorkerManager.RunSchedule(schedules)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, [])
dmp.flush()
bl.param("do").set(True)
workerManager.WorkerManager.RunSchedule(schedules)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, [1])
workerManager.WorkerManager.SetUseProcess(True)
dmp.useProcess(True)
bl.param("do").set(False)
workerManager.WorkerManager.RunSchedule(schedules)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, [])
dmp.flush()
bl.param("do").set(True)
workerManager.WorkerManager.RunSchedule(schedules)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, [1])
def test_conditional(self):
box1 = box.Box("global")
box2 = conditionalBox.ConditionalBox("local")
num = MakeNumbers()
dmp = Dump()
bl = Bool()
box1.addBlock(box2)
box1.addBlock(bl)
box2.addBlock(num)
box2.addBlock(dmp)
self.assertIsNotNone(chain.Chain(bl.output(0), box2.input(0)))
self.assertIsNotNone(chain.Chain(num.output(0), dmp.input(0)))
schedules = box1.getSchedule()
workerManager.WorkerManager.RunSchedule(schedules)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, [])
bl.param("do").set(True)
workerManager.WorkerManager.RunSchedule(schedules)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, range(10))
workerManager.WorkerManager.SetUseProcess(True)
dmp.useProcess(True)
bl.param("do").set(False)
workerManager.WorkerManager.RunSchedule(schedules)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, [])
dmp.flush()
bl.param("do").set(True)
workerManager.WorkerManager.RunSchedule(schedules)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, range(10))
def test_custom_block2(self):
ms = MakeString()
ss = SplitString()
ps = DumpString()
c1 = chain.Chain(ms.output(0), ss.input(0))
self.assertIsNotNone(c1)
c2 = chain.Chain(ss.output(0), ps.input(0))
self.assertIsNotNone(c2)
processes = []
ps.activate()
p = threading.Thread(target=ps.run)
p.daemon = True
p.start()
processes.append((p, ps))
ss.activate()
p = threading.Thread(target=ss.run)
p.daemon = True
p.start()
processes.append((p, ss))
ms.activate()
p = threading.Thread(target=ms.run)
p.daemon = True
p.start()
processes.append((p, ms))
while (True):
working = False
for p, b in processes:
if p.is_alive():
working = True
else:
if not b.isTerminated():
b.terminate()
if working is False:
break
result = []
while (not ps.dmp.empty()):
result.append(ps.dmp.get())
self.assertEqual(result, ['Hello', 'World.', 'My', 'Name', 'is', 'MakeString'])
def test_subnet(self):
g = box.Box()
num1 = MakeNumbers(name="OutsideNum")
dmp1 = Dump(name="OutSideDmp")
self.assertTrue(g.addBlock(num1))
self.assertTrue(g.addBlock(dmp1))
self.assertIsNotNone(chain.Chain(num1.output(0), dmp1.input(0)))
c = box.Box()
self.assertTrue(g.addBlock(c))
num2 = MakeNumbers(name="InsideNum")
add = AddOne("InsideAdd")
dmp2 = Dump(name="InSideDmp")
self.assertTrue(c.addBlock(num2))
self.assertTrue(c.addBlock(dmp2))
self.assertTrue(c.addBlock(add))
self.assertIsNotNone(chain.Chain(num2.output(0), add.input(0)))
self.assertIsNotNone(chain.Chain(add.output(0), dmp2.input(0)))
workerManager.WorkerManager.SetUseProcess(True)
dmp1.useProcess(True)
dmp2.useProcess(True)
workerManager.WorkerManager.RunSchedule(g.getSchedule())
out_dmp = []
out_value = []
in_dmp = []
in_value = []
for i in range(100):
out_value.append(float(i))
in_value.append(int(i + 1))
while (not dmp1.dmp.empty()):
out_dmp.append(dmp1.dmp.get())
while (not dmp2.dmp.empty()):
in_dmp.append(dmp2.dmp.get())
self.assertEqual(out_dmp, out_value)
self.assertEqual(in_dmp, in_value)
def test_send(self):
src_port = port.OutPort(str)
dst_port = port.InPort(str)
chain.Chain(src_port, dst_port)
src_port.activate()
self.assertTrue(src_port.send("a"))
self.assertFalse(src_port.send(1))
self.assertFalse(src_port.send(True))
self.assertFalse(src_port.send(1.2))
def test_custom_block(self):
ms = MakeString()
ss = SplitString()
ps = DumpString()
c1 = chain.Chain(ms.output(0), ss.input(0))
self.assertIsNotNone(c1)
c2 = chain.Chain(ss.output(0), ps.input(0))
self.assertIsNotNone(c2)
ms.activate()
ms.run()
ms.terminate()
ss.activate()
ss.run()
ss.terminate()
ps.activate()
ps.run()
ps.terminate()
self.assertEqual(ps.lst, ['Hello', 'World.', 'My', 'Name', 'is', 'MakeString'])
def test_chain_add_remove(self):
b = box.Box()
mn = MakeNumbers()
dp = Dump()
mt = Mult()
b.addBlock(mn)
b.addBlock(dp)
b.addBlock(mt)
chn1 = chain.Chain(mn.output(0), dp.input(0))
self.assertIsNotNone(chn1)
self.assertTrue(chn1.isConnected())
chn2 = chain.Chain(mt.output(0), dp.input(0))
self.assertIsNotNone(chn2)
self.assertTrue(chn2.isConnected())
self.assertFalse(chn1.isConnected())
def test_chain(self):
box1 = box.Box("bigBox")
box2 = box.Box("smallBox")
num1 = MakeNumber()
num2 = MakeNumber()
doub1 = Double()
doub2 = Double()
add1 = Add()
add2 = Add()
box1.addBlock(box2)
box1.addBlock(num1)
box1.addBlock(num2)
box2.addBlock(doub1)
box2.addBlock(doub2)
box1.addBlock(add1)
box1.addBlock(add2)
box2.addInputProxy(float, "in")
box2.addOutputProxy(float, "out")
self.assertIsNotNone(
chain.Chain(num1.output(0), box2.inputProxyIn("in")))
self.assertTrue(num1.output(0).isConnected())
self.assertIsNotNone(
chain.Chain(num2.output(0), box2.inputProxyIn("in")))
self.assertFalse(num1.output(0).isConnected())
self.assertTrue(num2.output(0).isConnected())
self.assertIsNotNone(
chain.Chain(box2.inputProxyOut("in"), doub1.input(0)))
self.assertTrue(doub1.input(0).isConnected())
self.assertIsNotNone(
chain.Chain(box2.inputProxyOut("in"), doub2.input(0)))
self.assertTrue(doub1.input(0).isConnected())
self.assertTrue(doub2.input(0).isConnected())
self.assertIsNotNone(
chain.Chain(doub1.output(0), box2.outputProxyIn("out")))
self.assertTrue(doub1.output(0).isConnected())
self.assertIsNotNone(
chain.Chain(doub2.output(0), box2.outputProxyIn("out")))
self.assertFalse(doub1.output(0).isConnected())
self.assertTrue(doub2.output(0).isConnected())
self.assertIsNotNone(
chain.Chain(box2.outputProxyOut("out"), add1.input(0)))
self.assertTrue(add1.input(0).isConnected())
self.assertIsNotNone((chain.Chain(box2.outputProxyOut("out"),
add2.input(0))))
self.assertTrue(add1.input(0).isConnected())
self.assertTrue(add2.input(0).isConnected())
def test_port_queue2(self):
src_port1 = port.OutPort(int)
src_port2 = port.OutPort(int)
dst_port = port.InPort(int)
self.assertEqual(workerManager.WorkerManager.QueueCount(), 0)
chan1 = chain.Chain(src_port1, dst_port)
src_port1.activate()
dst_port.activate()
chan2 = chain.Chain(src_port2, dst_port)
src_port2.activate()
self.assertEqual(workerManager.WorkerManager.QueueCount(), 4)
src_port1.terminate()
self.assertEqual(workerManager.WorkerManager.QueueCount(), 3)
src_port2.terminate()
self.assertEqual(workerManager.WorkerManager.QueueCount(), 2)
dst_port.receive()
self.assertEqual(workerManager.WorkerManager.QueueCount(), 2)
dst_port.terminate()
self.assertEqual(workerManager.WorkerManager.QueueCount(), 0)
def test_link_process(self):
g = box.Box()
num1 = NumberGen()
num2 = NumberGen()
num1.param("number").set(10)
num1.param("count").set(1)
num2.param("number").set(1)
num2.param("count").set(3)
lp = LinkParam()
self.assertTrue(g.addBlock(num1))
self.assertTrue(g.addBlock(num2))
self.assertTrue(g.addBlock(lp))
c1 = chain.Chain(num1.output("output"), lp.input("in1"))
c2 = chain.Chain(num2.output("output"), lp.input("in2"))
self.assertIsNotNone(c1)
self.assertIsNotNone(c2)
schedule = g.getSchedule()
workerManager.WorkerManager.RunSchedule(schedule)
workerManager.WorkerManager.SetUseProcess(True)
self.assertTrue(lp.eop.value)
self.assertEqual(lp._getDumped(), [11])
workerManager.WorkerManager.RunSchedule(schedule)
self.assertTrue(lp.eop.value)
self.assertEqual(lp._getDumped(), [11])
c1.disconnect()
lp.param("integer").set(10)
workerManager.WorkerManager.RunSchedule(schedule)
workerManager.WorkerManager.SetUseProcess(True)
self.assertFalse(lp.eop.value)
self.assertEqual(lp._getDumped(), [11, 11, 11])
workerManager.WorkerManager.RunSchedule(schedule)
self.assertFalse(lp.eop.value)
self.assertEqual(lp._getDumped(), [11, 11, 11])
def test(self):
b = box.Box()
dmp = Dump()
r = RaiseError()
b.addBlock(dmp)
b.addBlock(r)
self.assertIsNotNone(chain.Chain(r.output("success"), dmp.input(0)))
schedule = b.getSchedule()
workerManager.WorkerManager.SetLogLevel(const.LogLevel.NoLog)
workerManager.WorkerManager.SetUseProcess(False)
for i in range(5):
dmp.flush()
workerManager.WorkerManager.RunSchedule(schedule)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, [True])
r.param("error").set(True)
for i in range(5):
dmp.flush()
workerManager.WorkerManager.RunSchedule(schedule)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, [False])
workerManager.WorkerManager.SetUseProcess(True)
r.param("error").set(False)
dmp.useProcess(True)
for i in range(5):
dmp.flush()
workerManager.WorkerManager.RunSchedule(schedule)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, [True])
r.param("error").set(True)
for i in range(5):
dmp.flush()
workerManager.WorkerManager.RunSchedule(schedule)
results = []
while (not dmp.dmp.empty()):
results.append(dmp.dmp.get())
self.assertEqual(results, [False])
def test_error(self):
workerManager.WorkerManager.SetUseProcess(False)
workerManager.WorkerManager.SetLogLevel(const.LogLevel.NoLog)
b = box.Box()
m = MakeNumbers()
e = RaiseError()
b.addBlock(m)
b.addBlock(e)
e.param("value").set(5)
chain.Chain(m.output(0), e.input(0))
workerManager.WorkerManager.RunSchedule(b.getSchedule())
self.assertTrue(e.isFailed())
self.assertFalse(e.isTerminated())
def test_logging(self):
workerManager.WorkerManager.SetLogLevel(const.LogLevel.NoLog)
workerManager.WorkerManager.SetUseProcess(True)
b = box.Box("scene")
m = MakeNumbers()
e = RaiseError()
e2 = RaiseError()
b.addBlock(m)
b.addBlock(e)
b.addBlock(e2)
e.param("value").set(5)
chain.Chain(m.output(0), e.input(0))
chain.Chain(m.output(0), e2.input(0))
workerManager.WorkerManager.RunSchedule(b.getSchedule())
self.assertEqual(len(workerManager.WorkerManager.ErrorLogs().keys()),
2)
self.assertEqual(len(workerManager.WorkerManager.ErrorLog(e2.path())),
2)
self.assertEqual(len(workerManager.WorkerManager.WarnLogs().keys()), 1)
self.assertEqual(len(workerManager.WorkerManager.WarnLog(m.path())), 1)
self.assertEqual(len(workerManager.WorkerManager.DebugLog(e.path())),
6)
self.assertEqual(len(workerManager.WorkerManager.DebugLog(e2.path())),
1)
workerManager.WorkerManager.SetUseProcess(False)
workerManager.WorkerManager.RunSchedule(b.getSchedule())
self.assertEqual(len(workerManager.WorkerManager.ErrorLogs().keys()),
2)
self.assertEqual(len(workerManager.WorkerManager.ErrorLog(e2.path())),
2)
self.assertEqual(len(workerManager.WorkerManager.WarnLogs().keys()), 1)
self.assertEqual(len(workerManager.WorkerManager.WarnLog(m.path())), 1)
self.assertEqual(len(workerManager.WorkerManager.DebugLog(e.path())),
6)
self.assertEqual(len(workerManager.WorkerManager.DebugLog(e2.path())),
1)
def test_connect(self):
box1 = box.Box("bigBox")
box2 = box.Box("smallBox")
in_prx = box2.addInputProxy(float, "inFloat")
self.assertTrue(box2.hasInputProxy("inFloat"))
out_prx = box2.addOutputProxy(float, "outFloat")
self.assertTrue(box2.hasOutputProxy("outFloat"))
num = MakeNumber()
double = Double()
dmp = DmpFloat()
add = Add()
box2.addBlock(double)
box1.addBlock(num)
box1.addBlock(dmp)
box1.addBlock(box2)
box1.addBlock(add)
chain.Chain(add.output(0), dmp.input(0))
self.assertIsNotNone(
proxy.ProxyChain(box2.inputProxyOut("inFloat"), double.input(0)))
self.assertIsNotNone(
chain.Chain(double.output(0), box2.outputProxyIn("outFloat")))
self.assertIsNotNone(
chain.Chain(box2.outputProxyOut("outFloat"), dmp.input(0)))
self.assertFalse(add.output(0).isConnected())
self.assertIsNotNone(
chain.Chain(add.output(0), box2.inputProxyIn("inFloat")))
self.assertIsNotNone(
proxy.ProxyChain(box2.outputProxyOut("outFloat"), add.input(0)))
self.assertTrue(double.input(0).isConnected())
self.assertTrue(double.output(0).isConnected())
self.assertTrue(dmp.input(0).isConnected())
self.assertTrue(add.input(0).isConnected())
self.assertTrue(add.output(0).isConnected())
self.assertIsNotNone(box2.inputProxyIn("inFloat"))
self.assertIsNotNone(box2.outputProxyOut("outFloat"))
def test_dasPort(self):
src_port1 = port.OutPort(dastype.DasType("dasTest.struct"))
dst_port1 = port.InPort(dastype.DasType("dasTest.struct"))
dst_port2 = port.InPort(dastype.DasType("dasTest.intType"))
self.assertIsNotNone(src_port1)
self.assertIsNotNone(dst_port1)
self.assertIsNotNone(dst_port2)
self.assertIsNotNone(chain.Chain(src_port1, dst_port1))
self.assertIsNone(chain.Chain(src_port1, dst_port2))
src_port1.activate()
self.assertTrue(
src_port1.send({
"i": 1,
"f": 1.0,
"s": "string",
"trash": "aa"
}))
p = dst_port1.receive()
self.assertFalse(p.isEOP())
self.assertEqual(p.value(), {"i": 1, "f": 1.0, "s": "string"})
self.assertTrue(src_port1.match(dst_port1))
self.assertFalse(src_port1.match(dst_port2))
def test_run(self):
box1 = box.Box("bigBox")
box2 = box.Box("smallBox")
num = MakeNumber()
double = Double()
dmp = DmpFloat()
add = Add()
box1.addBlock(num)
box1.addBlock(dmp)
box1.addBlock(box2)
box1.addBlock(add)
box2.addBlock(double)
box2.addInputProxy(float, "inFloat")
box2.addOutputProxy(float, "outFloat")
self.assertIsNotNone(
chain.Chain(num.output(0), box2.inputProxyIn("inFloat")))
self.assertIsNotNone(
chain.Chain(box2.inputProxyOut("inFloat"), double.input(0)))
self.assertIsNotNone(
chain.Chain(double.output(0), box2.outputProxyIn("outFloat")))
self.assertIsNotNone(
chain.Chain(box2.outputProxyOut("outFloat"), add.input(0)))
self.assertIsNotNone(chain.Chain(add.output(0), dmp.input(0)))
workerManager.WorkerManager.RunSchedule(box1.getSchedule())
vals = []
for i in range(100):
vals.append(float(i * 2) + 1)
dmped = []
while (not dmp.dmp.empty()):
dmped.append(dmp.dmp.get())
self.assertEqual(vals, dmped)
def test_two_way(self):
g = box.Box()
two = MakeTwoWay()
add1 = AddOne()
add2 = AddOne()
dmp1 = Dump()
dmp2 = Dump()
g.addBlock(two)
g.addBlock(add1)
g.addBlock(add2)
g.addBlock(dmp1)
g.addBlock(dmp2)
chain.Chain(two.output(0), add1.input(0))
chain.Chain(two.output(1), add2.input(0))
chain.Chain(add1.output(0), dmp1.input(0))
chain.Chain(add2.output(0), dmp2.input(0))
workerManager.WorkerManager.SetUseProcess(False)
workerManager.WorkerManager.RunSchedule(g.getSchedule())
d1 = []
d2 = []
while (not dmp1.dmp.empty()):
d1.append(dmp1.dmp.get())
while (not dmp2.dmp.empty()):
d2.append(dmp2.dmp.get())
v1 = []
v2 = []
for i in range(10):
v1.append(float(i + 1))
v2.append(float(i * 2) + 1)
self.assertEqual(d1, v1)
self.assertEqual(d2, v2)
def test_send_and_receive(self):
src_port = port.OutPort(int)
dst_port = port.InPort(int)
chan1 = chain.Chain(src_port, dst_port)
src_port.activate()
for i in range(5):
self.assertTrue(src_port.send(i))
time.sleep(0.01)
pack1 = dst_port.receive()
self.assertEqual(pack1.value(), 0)
self.assertEqual(pack1.refCount(), 1)
self.assertTrue(pack1.drop())
self.assertEqual(dst_port.receive().value(), 1)
self.assertEqual(dst_port.receive().value(), 2)
self.assertEqual(dst_port.receive().value(), 3)
self.assertEqual(dst_port.receive().value(), 4)
self.assertTrue(chan1.empty())
def test_packetHistory(self):
src_port = port.OutPort(int)
dst_port = port.InPort(int)
chan = chain.Chain(src_port, dst_port)
src_port.activate()
dst_port.activate()
src_port.send(1)
time.sleep(0.1)
src_port.send(2)
time.sleep(0.1)
dst_port.receive()
time.sleep(0.1)
src_port.terminate()
dst_port.terminate()
self.assertEqual(src_port.packetHistory(), [1, 2])
self.assertEqual(dst_port.packetHistory(), [1])
self.assertEqual(workerManager.WorkerManager.QueueCount(), 0)
def test_connect(self):
src_port1 = port.OutPort(str)
dst_port1 = port.InPort(str)
chan1 = chain.Chain(src_port1, dst_port1)
self.assertIsNotNone(chan1)
self.assertTrue(chan1.isConnected())
src_port2 = port.OutPort(str)
chan2 = chain.Chain(src_port2, dst_port1)
self.assertIsNotNone(chan2)
self.assertTrue(chan2.isConnected())
self.assertFalse(chan1.isConnected())
src_port3 = port.OutPort(int)
chan3 = chain.Chain(src_port3, dst_port1)
self.assertIsNone(chan3)
self.assertTrue(chan2.isConnected())
dst_port2 = port.InPort(bool)
chan4 = chain.Chain(src_port3, dst_port2)
self.assertIsNotNone(chan4)
self.assertTrue(chan4.isConnected())
src_port4 = port.OutPort(bool)
chan5 = chain.Chain(src_port4, dst_port2)
self.assertIsNotNone(chan5)
self.assertTrue(chan5.isConnected())
self.assertFalse(chan4.isConnected())
dst_port3 = port.InPort(bool)
chan6 = chain.Chain(src_port4, dst_port3)
self.assertIsNotNone(chan6)
self.assertTrue(chan6.isConnected())
chan7 = chain.Chain(dst_port2, dst_port3)
self.assertIsNone(chan7)
def test_init(self):
src_port1 = port.OutPort(str)
dst_port1 = port.InPort(str)
self.assertIsNotNone(chain.Chain(src_port1, dst_port1))
self.assertIsNone(chain.Chain(dst_port1, src_port1))
self.assertIsNone(chain.Chain(dst_port1, dst_port1))
self.assertIsNone(chain.Chain(src_port1, src_port1))
src_port2 = port.OutPort(int)
src_port3 = port.OutPort(float)
src_port4 = port.OutPort(bool)
self.assertIsNone(chain.Chain(src_port2, dst_port1))
self.assertIsNone(chain.Chain(src_port3, dst_port1))
self.assertIsNone(chain.Chain(src_port4, dst_port1))
dst_port2 = port.InPort(int)
self.assertIsNotNone(chain.Chain(src_port2, dst_port2))
self.assertIsNotNone(chain.Chain(src_port3, dst_port2))
self.assertIsNotNone(chain.Chain(src_port4, dst_port2))
dst_port3 = port.InPort(float)
self.assertIsNotNone(chain.Chain(src_port2, dst_port3))
self.assertIsNotNone(chain.Chain(src_port3, dst_port3))
self.assertIsNotNone(chain.Chain(src_port4, dst_port3))
dst_port4 = port.InPort(bool)
self.assertIsNotNone(chain.Chain(src_port2, dst_port4))
self.assertIsNotNone(chain.Chain(src_port3, dst_port4))
self.assertIsNotNone(chain.Chain(src_port4, dst_port4))
