def test_inline_return(): def target(): if True: x = 1 return x assert False assert False return 3 def prog(): assert target() == 1 def outp(): if True: x = 1 if "target_ret" not in globals(): target_ret = x if "target_ret" not in globals(): assert False if "target_ret" not in globals(): assert False if "target_ret" not in globals(): target_ret = 3 assert target_ret == 1 run_inline_harness(prog, target, outp, locals())
def test_inline_args(): def target(a, b, c=1, d=2, *args, **kwargs): assert (a == 1) assert (b == 2) assert (c == 2) assert (d == 2) assert (len(args) == 0) assert (kwargs["f"] == 4) def prog(): target(1, b=2, c=2, f=4) def outp(): a___target = 1 b___target = 2 c___target = 2 d___target = 2 args___target = [] kwargs___target = {"f": 4} assert (a___target == 1) assert (b___target == 2) assert (c___target == 2) assert (d___target == 2) assert (len(args___target) == 0) assert (kwargs___target["f"] == 4) if "target_ret" not in globals(): target_ret = None target_ret run_inline_harness(prog, target, outp, locals())
def test_inline_import_same_file(): from api import nested_reference def prog(): assert nested_reference() == 1 def outp(): from api import f if "nested_reference_ret" not in globals(): nested_reference_ret = f() assert nested_reference_ret == 1 run_inline_harness(prog, nested_reference, outp, locals())
def test_inline_import(): import api def prog(): api.use_json() def outp(): import json assert json.dumps({}) == '{}' if "use_json_ret" not in globals(): use_json_ret = None use_json_ret run_inline_harness(prog, api, outp, locals())
def test_inline_basic(): def target(x): return x + 1 def prog(): assert target(1) == 2 def outp(): x___target = 1 if "target_ret" not in globals(): target_ret = x___target + 1 assert target_ret == 2 run_inline_harness(prog, target, outp, locals())
def test_inline_comprehension_noop(): def target(x): return x + 1 def prog(): l = [target(i) for i in range(3)] assert sum(l) == 6 # target SHOULD NOT be inlined, since that would be unsafe # before comprehension is expanded def outp(): l = [target(i) for i in range(3)] assert sum(l) == 6 run_inline_harness(prog, target, outp, locals())
def test_inline_cursor(): def target(): pass def prog(): # first line target() def outp(): # first line pass if "target_ret" not in globals(): target_ret = None target_ret run_inline_harness(prog, CursorTarget((2, 0)), outp, locals())
def test_inline_nested(): def target(x): return x + 1 def prog(): assert target(target(1)) == 3 def outp(): x___target = 1 if "target_ret" not in globals(): target_ret = x___target + 1 x___target_2 = target_ret if "target_ret_2" not in globals(): target_ret_2 = x___target_2 + 1 assert target_ret_2 == 3 run_inline_harness(prog, target, outp, locals())
def test_inline_class_constructor(): class Test: def __init__(self, x): self.x = x def prog(): t = Test(1) assert t.x == 1 def outp(): Test_ret = Test.__new__(Test) self_____init__ = Test_ret x_____init__ = 1 self_____init__.x = x_____init__ t = Test_ret assert t.x == 1 run_inline_harness(prog, Test, outp, locals())
def test_inline_source_function(): def dummy_target(): pass def prog(): def actual_target(): pass actual_target() def outp(): def actual_target(): pass pass if "actual_target_ret" not in globals(): actual_target_ret = None actual_target_ret run_inline_harness(prog, dummy_target, outp, locals())
def test_inline_preserve_comments(): def target(): # hello world pass # yep def prog(): # oh no target() def outp(): # oh no # hello world pass # yep if "target_ret" not in globals(): target_ret = None target_ret run_inline_harness(prog, target, outp, locals())
def test_inline_generator(): def gen(): for i in range(10): yield i def prog(): for i, j in zip(gen(), range(10)): assert i == j def outp(): gen_ret = [] for i in range(10): gen_ret.append(i) if "gen_ret" not in globals(): gen_ret = None for i, j in zip(gen_ret, range(10)): assert i == j run_inline_harness(prog, gen, outp, locals())
def test_inline_property(): class Target: def __init__(self): self.foo = 1 @property def bar(self): return self.foo @bar.setter def bar(self, foo): self.foo = foo def prog(): t = Target() assert t.bar == 1 t.bar = 2 assert t.bar == 2 def outp(): Target_ret = Target.__new__(Target) self_____init__ = Target_ret self_____init__.foo = 1 t = Target_ret self___bar_2 = t if "bar" not in globals(): bar = self___bar_2.foo assert bar == 1 self___bar_4 = t foo___bar_4 = 2 self___bar_4.foo = foo___bar_4 if "bar_3" not in globals(): bar_3 = None self___bar_6 = t if "bar_5" not in globals(): bar_5 = self___bar_6.foo assert bar_5 == 2 run_inline_harness(prog, Target, outp, locals())
def test_inline_decorator(): def dec_test(f): @functools.wraps(f) def newf(*args, **kwargs): return f(*args, **kwargs) + 2 return newf @dec_test def function_decorator(x): return x + 1 def prog(): assert function_decorator(1) == 4 # yapf: disable def outp(): def function_decorator(x): return x + 1 f___dec_test = function_decorator def newf(*args, **kwargs): return f___dec_test(*args, **kwargs) + 2 if "dec_test_ret" not in globals(): dec_test_ret = newf args___newf = [1] kwargs___newf = {} if "dec_test_ret_ret" not in globals(): x___function_decorator = args___newf[0] if "f___dec_test_ret" not in globals(): f___dec_test_ret = x___function_decorator + 1 dec_test_ret_ret = f___dec_test_ret + 2 function_decorator_ret = dec_test_ret_ret assert function_decorator_ret == 4 run_inline_harness(prog, [function_decorator, dec_test], outp, locals(), fixpoint=True)
def test_inline_class_super(): class A: def __init__(self): self.x = 1 class B(A): def __init__(self): super().__init__() self.y = 1 def prog(): b = B() assert b.x + b.y == 2 def outp(): B_ret = B.__new__(B) self_____init__ = B_ret A.__init__(self_____init__) self_____init__.y = 1 b = B_ret assert b.x + b.y == 2 run_inline_harness(prog, B, outp, locals())
def test_inline_class_staticmethod(): class Cls: @staticmethod def foo(x): return x + 1 @classmethod def bar(cls, x): return cls.foo(x) + x def prog(): assert Cls.bar(1) == 3 def outp(): cls___bar = Cls x___bar = 1 if "bar_ret" not in globals(): x___foo = x___bar if "foo_ret" not in globals(): foo_ret = x___foo + 1 bar_ret = foo_ret + x___bar assert bar_ret == 3 run_inline_harness(prog, Cls, outp, locals(), fixpoint=True)
def test_inline_generator_method(): class Cls: def gen(self): for i in range(10): yield i def prog(): c = Cls() for i, j in zip(c.gen(), range(10)): assert i == j def outp(): Cls_ret = Cls.__new__(Cls) c = Cls_ret gen_ret = [] self___gen = c for i in range(10): gen_ret.append(i) if "gen_ret" not in globals(): gen_ret = None for i, j in zip(gen_ret, range(10)): assert i == j run_inline_harness(prog, Cls, outp, locals())
def test_inline_class_method(): class Test: def __init__(self): self.x = 1 def foo(self, x): return x + self.x def prog(): t = Test() assert t.foo(1) == 2 def outp(): Test_ret = Test.__new__(Test) self_____init__ = Test_ret self_____init__.x = 1 t = Test_ret self___foo = t x___foo = 1 if "foo_ret" not in globals(): foo_ret = x___foo + self___foo.x assert foo_ret == 2 run_inline_harness(prog, Test, outp, locals())