def test_tuple(): ir = transform(""" def test_tuple(): assert (1, 2) == (3, 4, 5) """) assert ir == [ AutowrapTest("test_tuple", [ Assertion( Sequence([NumLiteral(1), NumLiteral(2)]), Sequence([NumLiteral(3), NumLiteral(4), NumLiteral(5)]), ) ]) ]
def test_one_assertion_literals_0(): ir = transform(""" def random_function(): pass def test_foo(): assert 1 == 2 """) assert ir == [ AutowrapTest("test_foo", [ Assertion(NumLiteral(1), NumLiteral(2)), ]) ]
def test_assertion_call_function(): ir = transform(""" def test_func(): from mod import func assert func(7) == 42 """) assert ir == [ AutowrapTest("test_func", [ Import('mod', ['func']), Assertion( FunctionCall("func", [NumLiteral(7)]), NumLiteral(42), ), ]) ]
def test_assertion_call_method_on_lvalue(): ir = transform(""" def test_func(): obj.func(42, 3.3) """) assert ir == [ AutowrapTest("test_func", [ FunctionCall( Attribute( 'obj', 'func', ), [NumLiteral(42), NumLiteral(3.3)], ), ]) ]
def test_subscript(): ir = transform(""" def test_subscript(): arr = [1, 2, 3] fst = arr[1] """) assert ir == [ AutowrapTest("test_subscript", [ Assignment( 'arr', Sequence([ NumLiteral(1), NumLiteral(2), NumLiteral(3), ])), Assignment('fst', Index('arr', NumLiteral(1))) ]) ]
def test_assign_to_var(): ir = transform(""" def test_assign(): foo = 42 """) assert ir == [ AutowrapTest("test_assign", [Assignment('foo', NumLiteral(42))]) ]
def test_assign_to_list(): ir = transform(""" def test_assign_to_list(): [foo, bar] = 42 """) assert ir == [ AutowrapTest("test_assign_to_list", [Assignment(Sequence(['foo', 'bar']), NumLiteral(42))]) ]
def test_assertion_call_method_on_rvalue(): ir = transform(""" def test_func(): from mod import Klass Klass('ctor_arg').func(42, 3.3) """) assert ir == [ AutowrapTest("test_func", [ Import('mod', ['Klass']), FunctionCall( Attribute( FunctionCall('Klass', [StringLiteral('ctor_arg')]), 'func', ), [NumLiteral(42), NumLiteral(3.3)], ), ]) ]
def test_attribute(): ir = transform(""" def test_func(): foo.value = 42 """) assert ir == [ AutowrapTest("test_func", [Assignment( Attribute('foo', 'value'), NumLiteral(42), )]) ]
def visit_Constant(self, node): from ir import NumLiteral, StringLiteral, BytesLiteral value = node.value if type(value) == int or type(value) == float: self.value = NumLiteral(value) elif type(value) == str: self.value = StringLiteral(value) elif type(value) == bytes: self.value = BytesLiteral(value) else: raise Exception( f"Cannot handle constant of type {type(value)} {value}")
def visit_Subscript(self, node): from ir import Index, NumLiteral import ast if type(node.slice) is ast.Index: name = _run_visitor(node.value, ExpressionVisitor) index = _run_visitor(node.slice.value, ExpressionVisitor) self.value = Index(name, index) elif type(node.slice) is ast.Constant: name = _run_visitor(node.value, ExpressionVisitor) self.value = Index(name, NumLiteral(node.slice.value)) else: raise TypeError(f"Cannot handle index of type {type(node.slice)}")
def test_one_assertion_literals_1(): ir = transform(""" def random_function(): pass def test_bar(): assert 3 == 'foo' """) assert ir == [ AutowrapTest("test_bar", [ Assertion(NumLiteral(3), StringLiteral("foo")), ]) ]
def test_length(): ir = transform(""" def test_length(): lst = [1] len(lst) """) assert ir == [ AutowrapTest( "test_length", [ Assignment('lst', Sequence([NumLiteral(1)])), FunctionCall( Attribute( 'lst', 'length', ), [], # args ) ]) ]