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_incomp(self):
box1 = box.Box("bigBox")
box2 = box.Box("smallBox")
num = MakeNumber()
double = Double()
dmp = DmpFloat()
add = Add()
box1.addBlock(box2)
box1.addBlock(num)
box2.addBlock(double)
box1.addBlock(add)
box1.addBlock(dmp)
box2.addInputProxy(float, "inFloat")
box2.addOutputProxy(float, "outFloat")
cn1 = proxy.ProxyChain(box2.inputProxyOut("inFloat"), double.input(0))
cn2 = proxy.ProxyChain(box2.outputProxyOut("outFloat"), dmp.input(0))
workerManager.WorkerManager.SetUseProcess(True)
workerManager.WorkerManager.RunSchedule(box1.getSchedule())
cn1.disconnect()
cn2.disconnect()
cn1 = proxy.ProxyChain(num.output(0), box2.inputProxyIn("inFloat"))
cn2 = proxy.ProxyChain(double.output(0),
box2.outputProxyIn("outFloat"))
workerManager.WorkerManager.RunSchedule(box1.getSchedule())
proxy.ProxyChain(num.output(0), box2.inputProxyIn("inFloat"))
proxy.ProxyChain(box2.inputProxyOut("inFloat"), double.input(0))
proxy.ProxyChain(double.output(0), box2.outputProxyIn("outFloat"))
proxy.ProxyChain(box2.outputProxyOut("outFloat"), add.input(0))
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_state(self):
workerManager.WorkerManager.SetUseProcess(False)
workerManager.WorkerManager.SetLogLevel(const.LogLevel.NoLog)
b = box.Box("scene")
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.assertEqual(workerManager.WorkerManager.ExecutionCount(), 5)
self.assertTrue(workerManager.WorkerManager.TotalTime() > 0)
self.assertEqual(
workerManager.WorkerManager.AverageTime(),
workerManager.WorkerManager.TotalTime() /
float(workerManager.WorkerManager.ExecutionCount()))
self.assertTrue(workerManager.WorkerManager.TimeLog(e.path()) > 0)
self.assertTrue(workerManager.WorkerManager.TimeLog(m.path()) > 0)
workerManager.WorkerManager.SetUseProcess(True)
workerManager.WorkerManager.RunSchedule(b.getSchedule())
self.assertEqual(workerManager.WorkerManager.ExecutionCount(), 5)
self.assertTrue(workerManager.WorkerManager.TotalTime() > 0)
self.assertEqual(
workerManager.WorkerManager.AverageTime(),
workerManager.WorkerManager.TotalTime() /
float(workerManager.WorkerManager.ExecutionCount()))
self.assertTrue(workerManager.WorkerManager.TimeLog(e.path()) > 0)
self.assertTrue(workerManager.WorkerManager.TimeLog(m.path()) > 0)
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_bloc(self):
box1 = box.Box()
for i in range(multiprocessing.cpu_count() * 3):
box1.addBlock(Sub())
workerManager.WorkerManager.RunSchedule(box1.getSchedule())
workerManager.WorkerManager.SetUseProcess(True)
workerManager.WorkerManager.RunSchedule(box1.getSchedule())
def test_connect(self):
box1 = box.Box("bigBox")
box2 = box.Box("smallBox")
ip, op = box2.addInputProxy(float, "inFloat")
self.assertIsNotNone(ip)
self.assertIsNotNone(op)
self.assertTrue(box2.hasInputProxy("inFloat"))
ip, op = box2.addOutputProxy(float, "outFloat")
self.assertIsNotNone(ip)
self.assertIsNotNone(op)
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(
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"), dmp.input(0)))
self.assertFalse(add.output(0).isConnected())
self.assertIsNotNone(
chain.Chain(add.output(0), box2.inputProxyIn("inFloat")))
self.assertIsNotNone(
chain.Chain(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_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_box_to_box(self):
box1 = box.Box("bigBox")
box2 = box.Box("mulBox")
box3 = box.Box("addBox")
num = MakeNumber()
double = Double()
dmp = DmpFloat()
add = Add()
box1.addBlock(num)
box1.addBlock(dmp)
box1.addBlock(box2)
box1.addBlock(box3)
box2.addBlock(double)
box3.addBlock(add)
box2.addInputProxy(float, "inFloat")
box2.addOutputProxy(float, "outFloat")
box3.addInputProxy(float, "inFloat")
box3.addOutputProxy(float, "outFloat")
chain.Chain(num.output(0), box2.inputProxyIn("inFloat"))
chain.Chain(box2.inputProxyOut("inFloat"), double.input(0))
chain.Chain(double.output(0), box2.outputProxyIn("outFloat"))
chain.Chain(box2.outputProxyOut("outFloat"),
box3.inputProxyIn("inFloat"))
chain.Chain(box3.inputProxyOut("inFloat"), add.input(0))
chain.Chain(add.output(0), box3.outputProxyIn("outFloat"))
chain.Chain(box3.outputProxyOut("outFloat"), 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_add_bloc(self):
g = box.Box()
num = MakeNumbers(name="MakeNumber")
dmp = Dump(name="Dump")
# dmp.useProcess(False)
self.assertTrue(g.addBlock(dmp))
self.assertTrue(g.addBlock(num))
last = num.output(0)
aa = None
for i in range(100):
add = AddOne(name="AddOne{}".format(i))
if i == 0:
aa = add
doub = Mult(name="Mult{}".format(i))
self.assertTrue(g.addBlock(doub))
self.assertTrue(g.addBlock(add))
self.assertIsNotNone(chain.Chain(last, add.input(0)))
self.assertIsNotNone(chain.Chain(add.output(0), doub.input(0)))
last = doub.output(0)
self.assertIsNotNone(chain.Chain(last, dmp.input(0)))
v1 = []
for i in range(100):
for j in range(100):
i = int(i + 1)
i *= 1.1
v1.append(i)
schedule = g.getSchedule()
workerManager.WorkerManager.RunSchedule(schedule)
v2 = []
while (not dmp.dmp.empty()):
v2.append(dmp.dmp.get())
self.assertEqual(v1, v2)
# try it agian
dmp.useProcess(True)
workerManager.WorkerManager.SetUseProcess(True)
self.assertTrue(dmp.dmp.empty())
workerManager.WorkerManager.RunSchedule(schedule)
v2 = []
while (not dmp.dmp.empty()):
v2.append(dmp.dmp.get())
self.assertEqual(v1, v2)
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_100_times(self):
b = box.Box()
m = Make()
a = Add()
mt = Mult()
a.param(0).set(1.0)
b.addBlock(m)
b.addBlock(a)
b.addBlock(mt)
chain.Chain(m.output(0), a.input(0))
chain.Chain(a.output(0), mt.input(0))
s = b.getSchedule()
workerManager.WorkerManager.SetUseProcess(True)
for i in range(128):
workerManager.WorkerManager.RunSchedule(s)
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_init(self):
box1 = box.Box()
prx = box1.addInputProxy(int, "intProxy")
self.assertIsNotNone(prx.inPort())
self.assertIsNotNone(prx.outPort())
self.assertTrue(box1.hasInputProxy("intProxy"))
prx = box1.addInputProxy(bool, "boolProxy")
self.assertIsNotNone(prx.inPort())
self.assertIsNotNone(prx.outPort())
self.assertTrue(box1.hasInputProxy("boolProxy"))
prx = box1.addOutputProxy(int, "intProxy")
self.assertIsNotNone(prx.inPort())
self.assertIsNotNone(prx.outPort())
self.assertTrue(box1.hasOutputProxy("intProxy"))
prx = box1.addOutputProxy(bool, "boolProxy")
self.assertIsNotNone(prx.inPort())
self.assertIsNotNone(prx.outPort())
self.assertTrue(box1.hasOutputProxy("boolProxy"))
self.assertEqual(len(box1.inputProxies()), 2)
self.assertEqual(len(box1.outputProxies()), 2)
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_init(self):
box1 = box.Box()
ip, op = box1.addInputProxy(int, "intProxy")
self.assertIsNotNone(ip)
self.assertIsNotNone(op)
self.assertTrue(box1.hasInputProxy("intProxy"))
ip, op = box1.addInputProxy(bool, "boolProxy")
self.assertIsNotNone(ip)
self.assertIsNotNone(op)
self.assertTrue(box1.hasInputProxy("boolProxy"))
ip, op = box1.addOutputProxy(int, "intProxy")
self.assertIsNotNone(ip)
self.assertIsNotNone(op)
self.assertTrue(box1.hasOutputProxy("intProxy"))
op, op = box1.addOutputProxy(bool, "boolProxy")
self.assertIsNotNone(ip)
self.assertIsNotNone(op)
self.assertTrue(box1.hasOutputProxy("boolProxy"))
self.assertEqual(len(box1.inputProxies()), 2)
self.assertEqual(len(box1.outputProxies()), 2)
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_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_run(self):
box1 = box.Box()
dmp_str = DmpStr()
dmp_int = DmpInt()
self.assertTrue(box1.addBlock(dmp_str))
self.assertTrue(box1.addBlock(dmp_int))
dmp_str.param("testStr").set("HELLO")
dmp_int.param("testInt").set(23)
schedule = box1.getSchedule()
workerManager.WorkerManager.RunSchedule(schedule)
str_val = []
while (not dmp_str.dmp.empty()):
str_val.append(dmp_str.dmp.get())
self.assertEqual(str_val, ["HELLO"])
int_val = []
while (not dmp_int.dmp.empty()):
int_val.append(dmp_int.dmp.get())
self.assertEqual(int_val, [23])
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_context(self):
box1 = box.Box("main")
box2 = box.Box("subn")
box1.addBlock(box2)
box1.addParam(str, "str")
box2.addParam(int, "int")
box1.param("str").set("WORLD")
box2.param("int").set(20)
dump = DumpParam()
box2.addBlock(dump)
self.assertIsNotNone(box1.createContext())
self.assertIsNone(box1.createContext())
self.assertIsNone(box2.createContext())
self.assertEqual(box1.getContext(), {})
self.assertIsNotNone(box1.addContext(str, "contextStr"))
self.assertIsNotNone(box1.addContext(int, "contextInt"))
self.assertIsNone(box2.addContext(str, "contextStr"))
self.assertIsNone(box2.addContext(int, "contextInt"))
self.assertEqual(box1.getContext(), {"contextStr": "", "contextInt": 0})
self.assertIsNotNone(box1.context("contextStr"))
self.assertIsNotNone(box1.context("contextInt"))
self.assertIsNone(box2.context("contextStr"))
self.assertIsNone(box2.context("contextInt"))
for p in box2.contexts():
self.assertTrue(False)
c1 = box1.context("contextStr")
self.assertTrue(box1.removeContext(c1))
self.assertFalse(box1.removeContext("contextStr"))
c2 = box1.context("contextInt")
self.assertTrue(box1.removeContext("contextInt"))
self.assertFalse(box1.removeContext(c2))
self.assertIsNotNone(box1.addContext(str, "contextStr"))
self.assertIsNotNone(box1.addContext(int, "contextInt"))
self.assertEqual(box1.getContext(), {"contextStr": "", "contextInt": 0})
c1 = box1.context("contextStr")
c2 = box1.context("contextInt")
c1.set("HELLO")
c2.set(5)
self.assertEqual(box1.getContext(), {"contextStr": "HELLO", "contextInt": 5})
self.assertTrue(dump.param("str1").setExpression("= '$contextStr'"))
self.assertTrue(dump.param("str1").setExpression("= '$contextStr'.lower()"))
self.assertEqual(dump.param("str1").get(), "hello")
self.assertTrue(dump.param("float1").setExpression("= $contextInt * 2"))
self.assertEqual(dump.param("float1").get(), 10.0)
self.assertTrue(dump.param("str1").setExpression("= '$contextStr' + ' ../../@str'"))
self.assertTrue(dump.param("float1").setExpression("= $contextInt * ../@int"))
self.assertEqual(dump.param("str1").get(), "HELLO WORLD")
self.assertEqual(dump.param("float1").get(), 100.0)
workerManager.WorkerManager.RunSchedule(box1.getSchedule())
res = []
while (not dump.dmp.empty()):
res.append(dump.dmp.get())
self.assertEqual(res, ["HELLO WORLD", 100.0])
os.environ["TEST_ENV_STR"] = "!!!"
os.environ["TEST_ENV_FLT"] = "0.5"
self.assertTrue(dump.param("str1").setExpression("= '$contextStr' + ' ../../@str' + '$TEST_ENV_STR'"))
self.assertTrue(dump.param("float1").setExpression("= $contextInt * ../@int * $TEST_ENV_FLT"))
dump.flush()
workerManager.WorkerManager.RunSchedule(box1.getSchedule())
res = []
while (not dump.dmp.empty()):
res.append(dump.dmp.get())
self.assertEqual(res, ["HELLO WORLD!!!", 50.0])
def test_expression_path(self):
box1 = box.Box("main")
box2 = box.Box("subn")
box1.addParam(str, "v1")
box2.addParam(str, "v1")
box1.addParam(float, "v2")
box2.addParam(float, "v2")
box1.param("v1").set("HELLO")
box2.param("v1").set("WORLD")
box1.param("v2").set(2.5)
box2.param("v2").set(3.5)
param_bloc = DumpParam()
param_bloc.useProcess(False)
box2.addBlock(param_bloc)
box1.addBlock(box2)
param_bloc.param("str1").set("no expr")
param_bloc.param("str2").set("Hello")
self.assertFalse(param_bloc.param("str1").hasExpression())
self.assertFalse(param_bloc.param("str1").setExpression("1 * 2"))
self.assertTrue(param_bloc.param("str1").setExpression("= 1 * 2"))
self.assertTrue(param_bloc.param("str1").hasExpression())
self.assertFalse(param_bloc.param("str1").validExpression())
self.assertTrue(param_bloc.param("str1").setExpression("= 'asda'.upper()"))
self.assertTrue(param_bloc.param("str1").hasExpression())
self.assertEqual(param_bloc.param("str1").get(), "ASDA")
self.assertTrue(param_bloc.param("str1").validExpression())
self.assertTrue(param_bloc.param("str1").setExpression("= './@str2'"))
self.assertEqual(param_bloc.param("str1").getExpression(), "= './@str2'")
self.assertEqual(param_bloc.param("str1").get(), param_bloc.param("str2").get())
self.assertTrue(param_bloc.param("str1").setExpression("= '../@v1'"))
self.assertEqual(param_bloc.param("str1").getExpression(), "= '../@v1'")
self.assertEqual(param_bloc.param("str1").get(), box2.param("v1").get())
self.assertTrue(param_bloc.param("str1").setExpression(None))
self.assertFalse(param_bloc.param("str1").hasExpression())
self.assertEqual(param_bloc.param("str1").get(), "no expr")
self.assertTrue(param_bloc.param("str1").setExpression("= '{} {}'.format('/main@v1', '/main/subn@v1')"))
self.assertEqual(param_bloc.param("str1").getExpression(), "= '{} {}'.format('/main@v1', '/main/subn@v1')")
self.assertEqual(param_bloc.param("str1").get(), "{} {}".format(box1.param("v1").get(), box2.param("v1").get()))
self.assertTrue(param_bloc.param("str1").hasExpression())
param_bloc.param("float1").set(1.1)
param_bloc.param("float2").set(2.2)
self.assertFalse(param_bloc.param("float1").hasExpression())
self.assertFalse(param_bloc.param("float1").setExpression("1 * 2"))
self.assertTrue(param_bloc.param("float1").setExpression("= 1 * 2"))
self.assertEqual(param_bloc.param("float1").get(), 2.0)
self.assertTrue(param_bloc.param("float1").setExpression("= ./@float2"))
self.assertEqual(param_bloc.param("float1").get(), param_bloc.param("float2").get())
self.assertEqual(param_bloc.param("float1").get(), param_bloc.param("float2").get())
self.assertTrue(param_bloc.param("float1").setExpression(None))
self.assertFalse(param_bloc.param("float1").hasExpression())
self.assertEqual(param_bloc.param("float1").get(), 1.1)
self.assertTrue(param_bloc.param("float1").setExpression("= ../@v2"))
self.assertEqual(param_bloc.param("float1").get(), box2.param("v2").get())
self.assertTrue(param_bloc.param("float1").setExpression("= ../@v2 * ../../@v2"))
self.assertEqual(param_bloc.param("float1").get(), box2.param("v2").get() * box1.param("v2").get())
self.assertTrue(param_bloc.param("float1").hasExpression())
param_bloc.flush()
workerManager.WorkerManager.RunSchedule(box1.getSchedule())
res = []
while (not param_bloc.dmp.empty()):
res.append(param_bloc.dmp.get())
self.assertEqual(res, ["{} {}".format(box1.param("v1").get(), box2.param("v1").get()), box1.param("v2").get() * box2.param("v2").get()])
workerManager.WorkerManager.SetUseProcess(True)
param_bloc.useProcess(True)
param_bloc.flush()
workerManager.WorkerManager.RunSchedule(box1.getSchedule())
res = []
while (not param_bloc.dmp.empty()):
res.append(param_bloc.dmp.get())
self.assertEqual(res, ["{} {}".format(box1.param("v1").get(), box2.param("v1").get()), box1.param("v2").get() * box2.param("v2").get()])
def test_init(self):
g = box.Box()
self.assertIsNotNone(g)
