def test_refine(self):
# t = True
# if t:
# x = 1
# else:
# x = 2
# return x
g = G(
T(1, tasks.ConstTask(True)),
C(1, "value", 2, "$test"),
T(2, tasks.IfTask(G(
T(1, tasks.ConstTask(1)),
C(1, "value", FINAL_TICK, "x")
), G(
T(1, tasks.ConstTask(2)),
C(1, "value", FINAL_TICK, "x")
))),
C(2, "x", FINAL_TICK, "retval")
)
target = g.get_task(START_TICK + 2)
target.refine(g, START_TICK + 2, {"$test":True})
expected = G(
T(1, tasks.ConstTask(True)),
T((2,1), tasks.ConstTask(1)),
C((2,1), "value", FINAL_TICK, "retval")
)
utils.assert_graph_equal(expected, g)
def visit_Name(self, node):
assert not isinstance(node, ast.Store)
if node.id == "None":
return self.factory_stack[-1].exec_expr(tasks.ConstTask(None),
quick=True,
syncpoint=False)
elif node.id == "True":
return self.factory_stack[-1].exec_expr(tasks.ConstTask(True),
quick=True,
syncpoint=False)
elif node.id == "False":
return self.factory_stack[-1].exec_expr(tasks.ConstTask(False),
quick=True,
syncpoint=False)
elif node.id == "__pydron_unbound__":
return self.factory_stack[-1].exec_expr(tasks.ConstTask(
builtins.__pydron_unbound__),
quick=True,
syncpoint=False)
elif node.id == "__pydron_unbound_nocheck__":
return self.factory_stack[-1].exec_expr(tasks.ConstTask(
builtins.__pydron_unbound_nocheck__),
quick=True,
syncpoint=False)
elif node.id.startswith("__pydron"):
raise ValueError("Unrecognized builtin: %r" % node.id)
else:
return self.factory_stack[-1].read_variable(node.id)
def test_no_inputs_task_ready(self):
g = G(
T(1, tasks.ConstTask(None)),
C(1, "value", FINAL_TICK, "retval")
)
self.target.execute(g, {})
self.assertEqual((TICK1, tasks.ConstTask(None), {}), self.next_ready()[1:-1])
self.assertEqual(None, self.next_ready())
def test_refine_body_twice(self):
# def f(lst, x):
# for x in lst:
# pass
# return x
with graph_factory():
g = G(
C(START_TICK, "lst", 1, "iterable"),
T(1, tasks.IterTask()),
C(1, "value", 2, "$iterator"),
C(START_TICK, "x", 2, "x"),
T(2, tasks.ForTask(False, False, G("body",
C(START_TICK, "$target",1 , "x"),
C(START_TICK, "$iterator", 1, "$iterator"),
T(1, tasks.ForTask(True, False, G("body"), G("else"))),
C(1, "x", FINAL_TICK, "x")
), G("else"))),
C(2, "x", FINAL_TICK, "retval")
)
it = iter([1,2,3])
target_tick = START_TICK + 2
target = g.get_task(target_tick)
target.refine(g, target_tick, {"$iterator":it})
target_tick = Tick.parse_tick((2,1,2,1))
target = g.get_task(target_tick)
target.refine(g, target_tick, {"$iterator":it})
with graph_factory():
expected = G(
C(START_TICK, "lst", 1, "iterable"),
T(1, tasks.IterTask()),
T((2,1,1), tasks.ConstTask(1)),
T((2,2,1), tasks.ConstTask(2)),
C(1, "value", (2,2,2,1), "$iterator"),
C((2,2,1), "value", (2,2,2,1), "x"),
T((2,2,2,1), tasks.ForTask(True, False, G("body",
C(START_TICK, "$target",1 , "x"),
C(START_TICK, "$iterator", 1, "$iterator"),
T(1, tasks.ForTask(True, False, G("body"), G("else"))),
C(1, "x", FINAL_TICK, "x")
), G("else"))),
C((2,2,2,1), "x", FINAL_TICK, "retval")
)
utils.assert_graph_equal(expected, g)
def test_refine_body_break(self):
# def f(lst, x):
# for x in lst:
# if True:
# break
# return x
with graph_factory():
g = G(
C(START_TICK, "lst", 1, "iterable"),
T(1, tasks.IterTask()),
C(1, "value", 2, "$iterator"),
C(START_TICK, "x", 2, "x"),
T(2, tasks.ForTask(False, False, G("body",
T(1, tasks.ConstTask(True)),
C(1, "value", 2, "$breaked"),
C(START_TICK, "$target",2 , "x"),
C(START_TICK, "$iterator", 2, "$iterator"),
T(2, tasks.ForTask(True, True, G("body"), G("else"))),
C(2, "x", FINAL_TICK, "x")
), G("else"))),
C(2, "x", FINAL_TICK, "retval")
)
target = g.get_task(START_TICK + 2)
target.refine(g, START_TICK + 2, {"$iterator":iter([1,2,3])})
with graph_factory():
expected = G(
C(START_TICK, "lst", 1, "iterable"),
T(1, tasks.IterTask()),
C(1, "value", (2,1,2,2), "$iterator"),
T((2,1,1), tasks.ConstTask(1)),
T((2,1,2,1), tasks.ConstTask(True)),
C((2,1,1), "value", (2,1,2,2), "x"),
C((2,1,2,1), "value", (2,1,2,2), "$breaked"),
T((2,1,2,2), tasks.ForTask(True, True, G("body",
T(1, tasks.ConstTask(True)),
C(1, "value", 2, "$breaked"),
C(START_TICK, "$target",2 , "x"),
C(START_TICK, "$iterator", 2, "$iterator"),
T(2, tasks.ForTask(True, True, G("body"), G("else"))),
C(2, "x", FINAL_TICK, "x")
), G("else"))),
C((2,1,2,2), "x", FINAL_TICK, "retval")
)
utils.assert_graph_equal(expected, g)
def test_while_break(self):
def f(x):
while x:
if True:
break
return x
with graph_factory():
expected = G(
C(START_TICK, "x", 1, "$test"), C(START_TICK, "x", 1, "x"),
T(
1,
tasks.WhileTask(
False, False,
G(
"body",
C(START_TICK, "x", 2, "$test"),
C(START_TICK, "x", 2, "x"),
T(1, tasks.ConstTask(True), {'quick': True}),
C(1, "value", 2, "$breaked"),
T(
2,
tasks.WhileTask(True, True, G("body"),
G("else"))),
), G("else"))), C(START_TICK, "x", FINAL_TICK,
"retval"))
callee = translator.translate_function(f, "scheduler", False)
utils.assert_graph_equal(expected, callee.graph)
def test_for_break(self):
def f(lst, x):
for x in lst:
if True:
break
return x
with graph_factory():
expected = G(
C(START_TICK, "lst", 1, "iterable"),
T(1, tasks.IterTask(), {'quick': True}),
C(1, "value", 2, "$iterator"), C(START_TICK, "x", 2, "x"),
T(
2,
tasks.ForTask(
False, False,
G(
"body", T(1, tasks.ConstTask(True),
{'quick': True}),
C(1, "value", 2, "$breaked"),
C(START_TICK, "$target", 2, "x"),
C(START_TICK, "$iterator", 2, "$iterator"),
T(2, tasks.ForTask(True, True, G("body"),
G("else"))),
C(2, "x", FINAL_TICK, "x")), G("else"))),
C(2, "x", FINAL_TICK, "retval"))
callee = translator.translate_function(f, "scheduler", False)
utils.assert_graph_equal(expected, callee.graph)
def test_str(self):
def f():
return "Hello World!"
expected = G(T(1, tasks.ConstTask("Hello World!"), {'quick': True}),
C(1, "value", FINAL_TICK, "retval"))
callee = translator.translate_function(f, "scheduler", False)
utils.assert_graph_equal(expected, callee.graph)
def test_get_task_state_waiting_for_inputs(self):
g = G(
T(1, tasks.ConstTask(None)),
C(1, "value", 2, "in"),
T(2, "task"),
C(2, "out", FINAL_TICK, "retval")
)
self.target.execute(g, {})
self.assertEqual(traverser.TaskState.WAITING_FOR_INPUTS, self.target.get_task_state(TICK2))
def test_injest_result(self):
g = G(
T(1, tasks.ConstTask(None)),
C(1, "value", 2, "in"),
T(2, "task"),
C(2, "out", FINAL_TICK, "retval")
)
self.target.execute(g, {})
self.next_ready()[-1].callback(traverser.EvalResult({"value":"Hello"}))
self.assertEqual((TICK2, "task", {"in":"Hello"}), self.next_ready()[1:-1])
def test_finish(self):
g = G(
T(1, tasks.ConstTask(None)),
C(1, "value", FINAL_TICK, "retval")
)
d = self.target.execute(g, {})
self.next_ready()[-1].callback(traverser.EvalResult({"value":"Hello"}))
outputs = extract(d)
self.assertEqual({"retval":"Hello"}, outputs)
def test_get_task_state_evaluated(self):
g = G(
T(1, tasks.ConstTask(None)),
C(1, "value", 2, "in"),
T(2, "task"),
C(2, "out", FINAL_TICK, "retval")
)
self.target.execute(g, {})
self.next_ready()[-1].callback(traverser.EvalResult({"value":"Hello"}))
self.assertEqual(traverser.TaskState.EVALUATED, self.target.get_task_state(TICK1))
def test_finish_nomoretasks(self):
g = G(
T(1, tasks.ConstTask(None)),
C(1, "value", FINAL_TICK, "retval")
)
self.target.execute(g, {})
self.next_ready()[-1].callback({"value":"Hello"})
self.assertIsNone(self.next_ready())
def test_get_task_state_waiting_for_refiner(self):
task = MockTask("in")
g = G(
T(1, tasks.ConstTask(None)),
C(1, "value", 2, "in"),
T(2, task),
C(2, "out", FINAL_TICK, "retval")
)
self.target.execute(g, {"a": "refinedata"})
self.assertEqual(traverser.TaskState.WAITING_FOR_REFINE_INPUTS, self.target.get_task_state(TICK2))
def test_readglobal(self):
def f():
return __pydron_read_global__(
"TestTranslator") #@UndefinedVariable
expected = G(T(1, tasks.ConstTask("TestTranslator"), {'quick': True}),
C(1, "value", 2, "var"),
T(2, tasks.ReadGlobal(__name__), {'quick': True}),
C(2, "value", FINAL_TICK, "retval"))
callee = translator.translate_function(f, "scheduler", False)
utils.assert_graph_equal(expected, callee.graph)
def test_call_builtin(self):
def f():
return __pydron_new_cell__("x") #@UndefinedVariable
expected = G(
T(1, tasks.ConstTask("x"), {'quick': True}),
C(1, "value", 2, "arg0"),
T(2, tasks.BuiltinCallTask(builtins.__pydron_new_cell__, 1),
{'quick': True}), C(2, "value", FINAL_TICK, "retval"))
callee = translator.translate_function(f, "scheduler", False)
utils.assert_graph_equal(expected, callee.graph)
def test_if_inputs(self):
def f():
t = True
c = 42
if t:
x = c
else:
x = c
return x
expected = G(
T(1, tasks.ConstTask(True), {'quick': True}),
T(2, tasks.ConstTask(42), {'quick': True}),
C(1, "value", 3, "$test"), C(2, "value", 3, "c"),
T(
3,
tasks.IfTask(G(C(START_TICK, "c", FINAL_TICK, "x")),
G(C(START_TICK, "c", FINAL_TICK, "x")))),
C(3, "x", FINAL_TICK, "retval"))
callee = translator.translate_function(f, "scheduler", False)
utils.assert_graph_equal(expected, callee.graph)
def test_eval_fail(self):
g = G(
T(1, tasks.ConstTask(None)),
C(1, "value", FINAL_TICK, "retval")
)
d = self.target.execute(g, {})
self.next_ready()[-1].errback(failure.Failure(MockError()))
f = twistit.extract_failure(d)
self.assertTrue(f.check(traverser.EvaluationError))
self.assertTrue(f.value.cause.check(MockError))
self.assertEqual(Tick.parse_tick(1), f.value.tick)
def test_raise(self):
def f(x):
raise x
return x
expected = G(T(1, tasks.ConstTask(None), {'quick': True}),
C(1, "value", 2, "inst"), C(START_TICK, "x", 2, "type"),
C(1, "value", 2, "tback"),
T(2, tasks.RaiseTask(), {'quick': True}),
C(START_TICK, "x", FINAL_TICK, "retval"))
callee = translator.translate_function(f, "scheduler", False)
utils.assert_graph_equal(expected, callee.graph)
def test_if(self):
def f():
t = True
if t:
x = 1
else:
x = 2
return x
expected = G(
T(1, tasks.ConstTask(True), {'quick': True}),
C(1, "value", 2, "$test"),
T(
2,
tasks.IfTask(
G(T(1, tasks.ConstTask(1), {'quick': True}),
C(1, "value", FINAL_TICK, "x")),
G(T(1, tasks.ConstTask(2), {'quick': True}),
C(1, "value", FINAL_TICK, "x")))),
C(2, "x", FINAL_TICK, "retval"))
callee = translator.translate_function(f, "scheduler", False)
utils.assert_graph_equal(expected, callee.graph)
def visit_Raise(self, node):
if any(n is None for n in [node.type, node.inst, node.tback]):
noneval = self.factory_stack[-1].exec_expr(tasks.ConstTask(None), quick=True)
def default_to_none(node):
if node is None:
return noneval
else:
return self.visit(node)
t = default_to_none(node.type)
i = default_to_none(node.inst)
tb = default_to_none(node.tback)
self.factory_stack[-1].exec_task(tasks.RaiseTask(), inputs=[(t, "type"), (i, "inst"), (tb, "tback")], quick=True)
def test_nested_FunctionDef(self):
def f():
def g():
return None
return g
expected = G(
T(
1,
tasks.FunctionDefTask(
"scheduler", 'g', [], None, None, 0,
G(T(1, tasks.ConstTask(None), {'quick': True}),
C(1, "value", FINAL_TICK, "retval"))), {'quick': True}),
C(1, "function", FINAL_TICK, "retval"))
callee = translator.translate_function(f, "scheduler", False)
utils.assert_graph_equal(expected, callee.graph)
def visit_Str(self, node):
return self.factory_stack[-1].exec_expr(tasks.ConstTask(node.s),
quick=True,
syncpoint=False)
def test_evaluate(self):
target = tasks.ConstTask(value=42)
actual = target.evaluate({})
self.assertEqual({'value':42}, actual)
