def test_smoke2(self, pcv):
prog2 = Conditional(BinaryOperation(Number(4), "=", Number(5)), [
Print(Number(123)),
], [
Number(456),
])
assert pcv(prog2) == False
def test_embed_in_true(self, nrcv):
prog = Conditional(Number(0), [
FunctionDefinition("foo1", Function([], [])),
FunctionDefinition("foo2", Function([], [Number(1)])),
Conditional(Number(0), [], [])
], None)
assert nrcv(prog) == set(["foo1"])
def test_embed_in_false(self, nrcv):
prog = Conditional(Number(0), None, [
FunctionDefinition("foo3", Function([], [])),
FunctionDefinition("foo4", Function([], [Number(3)])),
Conditional(Number(0), [], [])
])
assert nrcv(prog) == set(["foo3"])
def test_smoke1(self, pcv):
prog1 = Conditional(BinaryOperation(Number(4), "=", Number(5)), [
Number(123),
], [
Number(456),
])
assert pcv(prog1) == True
def test_embed_in_cond(self, nrcv):
bad_cond = Conditional(Number(0), [
FunctionDefinition("foo", Function([], [])),
Number(0)
])
prog = Conditional(bad_cond, [], [])
assert nrcv(prog) == set(["foo"])
def test_embedded_in_bad_if(self, nrcv):
prog = Conditional(Number(0), [
FunctionDefinition("foo1", Function([], [])),
FunctionDefinition("foo2", Function([], [Number(1)])),
Conditional(Number(0), [], [])
], [
FunctionDefinition("foo3", Function([], [])),
FunctionDefinition("foo4", Function([], [Number(3)])),
Conditional(Number(0), [], [])
])
assert nrcv(prog) == set(["foo1", "foo3"])
def test_embedded(self, nrcv):
prog = FunctionDefinition("foo1", Function([], [
Conditional(Number(0), [], []),
FunctionDefinition("foo2", Function([], [
FunctionDefinition("foo3", Function([], [])),
])),
FunctionDefinition("foo4", Function([], [
FunctionDefinition("foo5", Function([], [])),
Conditional(Number(0), [], [])
])),
FunctionDefinition("foo6", Function([], []))
]))
assert nrcv(prog) == set(["foo3", "foo4", "foo5", "foo6"])
def visitBinaryOperation(self, binop):
lhs = binop.lhs.visit(self)
rhs = binop.rhs.visit(self)
if isinstance(lhs, Number) and isinstance(rhs, Number):
return BinaryOperation(lhs, binop.op, rhs).evaluate(Scope())
if ((isinstance(lhs, Number) and lhs.value == 0
and isinstance(rhs, Reference)) or
(isinstance(rhs, Number) and rhs.value == 0
and isinstance(lhs, Reference))) and binop.op == '*':
return Number(0)
if isinstance(lhs, Reference) and isinstance(
rhs, Reference) and lhs.name == rhs.name and binop.op == '-':
return Number(0)
return BinaryOperation(lhs, binop.op, rhs)
def visitBinaryOperation(self, boper):
boper.lhs = self.visit(boper.lhs)
boper.rhs = self.visit(boper.rhs)
left = boper.lhs
right = boper.rhs
if isinstance(left, Number) and isinstance(right, Number):
return BinaryOperation(left, boper.op, right).evaluate(Scope())
if boper.op == '*' and (isinstance(left, Number) and left.value == 0
or isinstance(right, Number)
and right.value == 0):
return Number(0)
if isinstance(left, Reference) and isinstance(
right, Reference) and right.name == left.name:
return Number(0)
return boper
def test_embed_in_last(self, nrcv):
def func_def(name):
return FunctionCall(FunctionDefinition(name, Function([], [])), [])
def comb_func_def(name1, name2):
return Conditional(Number(0), [func_def(name1)], [func_def(name2)])
prog = Conditional(Number(0), [comb_func_def("foo1", "foo2")], [comb_func_def("foo3", "foo4")])
assert nrcv(prog) == set(["foo1", "foo2", "foo3", "foo4"])
def visitBinaryOperation(self, binary):
binary.lhs = binary.lhs.visit(self)
binary.rhs = binary.rhs.visit(self)
if isinstance(binary.lhs, Number) and isinstance(binary.rhs, Number):
return Number(binary.operations[binary.op](binary.lhs.value,
binary.rhs.value))
if isinstance(binary.rhs, Number) and binary.rhs.value == 0 and\
isinstance(binary.lhs, Reference) and binary.op == '*':
return Number(0)
if isinstance(binary.lhs, Number) and binary.lhs.value == 0 and\
isinstance(binary.rhs, Reference) and binary.op == '*':
return Number(0)
if isinstance(binary.lhs, Reference) and\
isinstance(binary.rhs, Reference) and\
binary.op == '-' and binary.lhs.name == binary.rhs.name:
return Number(0)
return binary
def visitBinaryOperation(self, binaryOperation):
left_part = binaryOperation.left.accept(self)
right_part = binaryOperation.right.accept(self)
op = binaryOperation.op
left_is_num = isinstance(left_part, Number)
right_is_num = isinstance(right_part, Number)
if left_is_num and right_is_num:
scope = Scope()
bin_operation_with_number = BinaryOperation(
left_part, op, right_part)
return bin_operation_with_number.evaluate(scope)
if op == "*" and (left_is_num and left_part.value == 0
or right_is_num and right_part.value == 0):
return Number(0)
if op == "-" and left_part == right_part:
return Number(0)
return BinaryOperation(left_part, binaryOperation.op, right_part)
def test_embedded(self, nrcv):
prog = Conditional(Number(0), [
Conditional(Number(0), [], []),
FunctionDefinition("foo1", Function([], [])),
FunctionDefinition("foo2", Function([], [Number(1)])),
Number(2),
], [
Conditional(Number(0), [], []),
FunctionDefinition("foo3", Function([], [])),
FunctionDefinition("foo4", Function([], [Number(3)])),
Number(4),
])
assert nrcv(prog) == set(["foo1", "foo3"])
def my_tests():
reader = Print(Read('n'))
print_binary = Print(
BinaryOperation(
Reference('x'), '/',
UnaryOperation('!', BinaryOperation(Reference('y'), '%',
Number(2)))))
conditional = Conditional(
BinaryOperation(BinaryOperation(Reference('x'), '*', Number(2)), '<',
UnaryOperation('-', Reference('y'))),
[
print_binary,
UnaryOperation('-', UnaryOperation('!', Reference('s')))
], [])
definition_max3 = FunctionDefinition(
'max3',
Function(["a", "b", "c"], [
Conditional(BinaryOperation(Reference("a"), ">", Reference("b")), [
Conditional(
BinaryOperation(Reference("a"), ">=", Reference("c")),
[Reference("a")], [Reference("c")])
], [
Conditional(
BinaryOperation(Reference("b"), "<", Reference("c")),
[Reference("c")], [Reference("b")])
])
]))
fun_call = Print(FunctionCall(definition_max3, [Number(1), Number(2)]))
definition_log2 = FunctionDefinition(
"log2",
Function(["k", "n", "step"], [
Conditional(
BinaryOperation(
BinaryOperation(Reference("k"), "*", Number(2)), "<=",
Reference("n")), [
FunctionCall(Reference("log_2_def"), [
BinaryOperation(Reference("k"), "*", Number(2)),
Reference("n"),
BinaryOperation(Reference("step"), "+", Number(1))
])
], [Reference("step")])
]))
empty_func = FunctionDefinition("emptyFunc", Function([], []))
printer = PrettyPrinter()
printer.visit(reader)
printer.visit(conditional)
printer.visit(print_binary)
printer.visit(definition_max3)
printer.visit(fun_call)
printer.visit(definition_log2)
printer.visit(empty_func)
def test():
f1 = Conditional(FunctionCall(Reference('x'), [Number(22)]), [Conditional(BinaryOperation(Number(0), '-', Number(6)), [],[Conditional(Number(0), [Conditional(UnaryOperation('-', Number(20)), [],[FunctionDefinition('foobar', Function(['ab', 'cd'], [
Print(BinaryOperation(UnaryOperation('-', Number(120)), '*', BinaryOperation(UnaryOperation('-', Number(20)), '+', Reference('z')))), Read('x')
]))])],[])])],[Conditional(Number(0), [Conditional(Number(0), [],[Read('xxx')])],[])])
f = FunctionDefinition('foo', Function(['a', 'b'], [
FunctionDefinition('bar', Function(['c', 'd'], [
Read('c')
])),
Conditional(Number(6), [Conditional(Number(5), [Read('x')])],[f1])
]))
pr = PrettyPrinter()
pr.visit(f)
def test_smoke(self, nrcv):
prog = (
Conditional(Number(1), [
FunctionDefinition("foo", Function([], [
Number(123),
Conditional(Number(1), [
Number(2),
])
])),
FunctionDefinition("bar", Function([], [
Number(123)
])),
FunctionDefinition("baz", Function([], [
])),
FunctionDefinition("foobar", Function([], [
Conditional(Number(1), [
Number(2),
]),
Number(123)
])),
])
)
assert nrcv(prog) == set(["foo", "baz"])
def test_function_call_pure_args(self, pcv):
assert pcv(FunctionCall(Reference("foo"), [Number(10), Number(20)])) == True
def test_print(self, pcv):
assert pcv(Print(Number(10))) == False
def test_conditional_unpure_cond_empty(self, pcv):
assert pcv(Conditional(Print(Number(0)), [], [])) == False
def test_conditional_unpure_cond_non_empty(self, pcv):
assert pcv(Conditional(Print(Number(0)), [Number(10), Number(20)], [Number(30), Number(0), Number(40)])) == False
def test_conditional_unpure_false_empty(self, pcv):
assert pcv(Conditional(Number(0), [], [Number(30), Print(Number(0)), Number(40)])) == False
def test_binary_operation_pure(self, pcv):
return pcv(BinaryOperation(Number(10), "+", Number(20))) == True
def test_conditional_none(self, pcv):
assert pcv(Conditional(Number(0), None, None)) == True
def test_conditional_empty(self, pcv):
assert pcv(Conditional(Number(0), [], [])) == True
def test_function_definition(self, pcv):
assert pcv(FunctionDefinition("name", Function([], [Number(5)]))) == True
def test_function_call_unpure_args(self, pcv):
assert pcv(FunctionCall(Reference("foo"), [Number(10), Print(Number(0)), Number(20)])) == False
def test_function_call_unpure_expr(self, pcv):
cond = Conditional(Number(1), [Print(Number(1)), Reference("foo")])
assert pcv(FunctionCall(cond, [])) == False
def test_conditional_non_empty(self, pcv):
assert pcv(Conditional(Number(0), [Number(10), Number(20)], [Number(30), Number(40)])) == True
def test_binary_operation_unpure_rhs(self, pcv):
return pcv(BinaryOperation(Number(10), "+", Print(Number(20)))) == False
def test_conditional_unpure_true_empty(self, pcv):
assert pcv(Conditional(Number(0), [Number(10), Print(Number(0)), Number(20)], [])) == False
