def test_set_ops(self): code = makecode(""" |class A(object): | def __init__(self): | self.x=4 |s={1,2,3} |t={2,3,4} |z= s and t |z.pop() |a=A() |z.add(a) |b=z.pop() |b.x """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) #self.assertTrue(self.finalParser.nondet) self.assertEqual(len(self.finalParser.problems), 0) self.assertEqual(len(self.finalParser.warnings), 1) warning_symbols = { problem.symbol for problem in self.finalParser.warnings } self.assertEqual(warning_symbols, {'x'})
def test_bool_ops(self): code = makecode(""" |x=8 |y=False |z=True |u=1568 |res=False |if x and y or u and z: | res=True |else: | res="test" | |if y or z: | x="test" """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) res = module_scope.resolve('res') self.assertIsBool(res) x = module_scope.resolve('x') self.assertIsStr(x)
def test_bool_ops(self): code = makecode(""" |x=8 |y=False |z=True |u=1568 |res=False |if x and y or u and z: | res=True |else: | res="test" | |if y or z: | x="test" """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) res=module_scope.resolve('res') self.assertIsBool(res) x=module_scope.resolve('x') self.assertIsStr(x)
def test_for_and_while(self): code = makecode(""" |class A: | x=4 | def test_funkcia(self): | print("nieco") | |a = 'jozo' |a = t | |for x in range(l,5): | c = x | a.test_funkcia() | |cc = x | |count = 0 |while count < 10: | print('hocico') | print(count) | b.test_funkcia() | """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) #self.assertEqual(len(self.parser.problems), 2) for problem in self.parser.problems: print(str(problem)) module_scope = self.parser.root_scope c = module_scope.resolve('c') print("C: "+str(c))
def test_optional_args(self): code = makecode(""" |class A: | x=4 | |def optionalArgs(a,b=1,c=True): | print(a.x) | return b | |o=A() |x=optionalArgs(o) |y=optionalArgs(o,'test') |z=optionalArgs(o,3,5) |u=optionalArgs(o,3,5,9) """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope x = module_scope.resolve('x') self.assertIsNum(x) y = module_scope.resolve('y') self.assertIsStr(y) for problem in self.parser.problems: print(str(problem)) self.assertEqual(len(self.parser.problems), 1)
def test_finally(self): code = makecode(""" |class MyError(Exception): | pass | |def doBadStuff(): | raise MyError() | |try: | y="test" | doBadStuff() | y=1 |finally: | z=1 """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope y=module_scope.resolve('y') self.assertIsStr(y) z=module_scope.resolve('z') self.assertIsNum(z) self.assertEqual(len(self.parser.problems),1) print(self.parser.problems)
def test_except(self): code = makecode(""" |class MyError(Exception): | pass | |def doBadStuff(): | raise MyError() | |z=1 |x="smth" |t="fasfas" |try: | y="test" | doBadStuff() | y=1 |except MyError: | x=1 |else: | t=False |z="something" """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope y = module_scope.resolve('y') self.assertIsStr(y) x = module_scope.resolve('x') self.assertIsNum(x) z = module_scope.resolve('z') self.assertIsStr(z) t = module_scope.resolve('t') self.assertIsStr(t)
def test_complex_example(self): code = makecode(""" |class EmptyWareHouseException: | pass |class FullWareHouseException(Exception): | pass |class Farm: | def __init__(self,name,size): | self.name = name | self.sizeOfWareHouse = size | self.currentSize = 0 | def produceOneUnit(self): | if self.currentSize==self.sizeOfWareHouse: | raise FullWareHouseException() | self.currentSize += 1 | def consumeOneUnit(self): | if self.currentSize==0: | raise EmptyWareHouseException() | self.currentSize -= 1 | |farm = Farm(size=50,name='Farm from wonderland') |farm.produceOneUnit() |farm.consumeOneUnit() |farm.produceOneUnit() """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) print("P:" +str(self.finalParser.problems)) print("W:" +str(self.finalParser.warnings))
def test_num_equal(self): code = makecode(""" |x=1 |y=3 |z="test" |if y==x: | z=2 |else: | z=False |v=1 |if x==1: | v="test" |w=x+y |if w==4: | w=p |else: | w=q """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) #self.assertTrue(self.finalParser.nondet) self.assertEqual(len(self.finalParser.problems), 2) self.assertEqual(len(self.finalParser.warnings), 0) problem_symbols = { problem.symbol for problem in self.finalParser.problems } self.assertEqual(problem_symbols, {'p', 'q'})
def test_finally(self): code = makecode(""" |class MyError(Exception): | pass | |def doBadStuff(): | raise MyError() | |try: | y="test" | doBadStuff() | y=1 |finally: | z=1 """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope y = module_scope.resolve('y') self.assertIsStr(y) z = module_scope.resolve('z') self.assertIsNum(z) self.assertEqual(len(self.parser.problems), 1) print(self.parser.problems)
def test_num_equal(self): code = makecode(""" |x=1 |y=3 |z="test" |if y==x: | z=2 |else: | z=False |v=1 |if x==1: | v="test" |w=x+y |if w==4: | w=p |else: | w=q """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) #self.assertTrue(self.finalParser.nondet) self.assertEqual(len(self.finalParser.problems), 2) self.assertEqual(len(self.finalParser.warnings), 0) problem_symbols = {problem.symbol for problem in self.finalParser.problems} self.assertEqual(problem_symbols, {'p','q'})
def test_list(self): code = makecode(""" |class A: | x=4 | def test_funkcia(self): | print("nieco") | |a = A() |l = [a,'test'] |l[0].test_funkcia() |b = ['jozo',l] |b[1][0].test_funkcia() |test = t |b[0]=1 """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) self.assertTrue(self.finalParser.nondet) self.assertEqual(len(self.finalParser.problems), 1) self.assertEqual(len(self.finalParser.warnings), 2) warning_symbols = { problem.symbol for problem in self.finalParser.warnings } self.assertEqual(warning_symbols, {'test_funkcia'})
def test_for_and_while(self): code = makecode(""" |class A: | x=4 | def test_funkcia(self): | print("nieco") | |a = 'jozo' |a = t | |for x in range(l,5): | c = x | a.test_funkcia() | |cc = x | |count = 0 |while count < 10: | print('hocico') | print(count) | b.test_funkcia() | """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) #self.assertEqual(len(self.parser.problems), 2) for problem in self.parser.problems: print(str(problem)) module_scope = self.parser.root_scope c = module_scope.resolve('c') print("C: " + str(c))
def test_optional_args(self): code = makecode(""" |class A: | x=4 | |def optionalArgs(a,b=1,c=True): | print(a.x) | return b | |o=A() |x=optionalArgs(o) |y=optionalArgs(o,'test') |z=optionalArgs(o,3,5) |u=optionalArgs(o,3,5,9) """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope x = module_scope.resolve('x') self.assertIsNum(x) y = module_scope.resolve('y') self.assertIsStr(y) for problem in self.parser.problems: print(str(problem)) self.assertEqual(len(self.parser.problems), 1)
def test_complex_example(self): code = makecode(""" |class EmptyWareHouseException: | pass |class FullWareHouseException(Exception): | pass |class Farm: | def __init__(self,name,size): | self.name = name | self.sizeOfWareHouse = size | self.currentSize = 0 | def produceOneUnit(self): | if self.currentSize==self.sizeOfWareHouse: | raise FullWareHouseException() | self.currentSize += 1 | def consumeOneUnit(self): | if self.currentSize==0: | raise EmptyWareHouseException() | self.currentSize -= 1 | |farm = Farm(size=50,name='Farm from wonderland') |farm.produceOneUnit() |farm.consumeOneUnit() |farm.produceOneUnit() """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) print("P:" + str(self.finalParser.problems)) print("W:" + str(self.finalParser.warnings))
def test_except(self): code = makecode(""" |class MyError(Exception): | pass | |def doBadStuff(): | raise MyError() | |z=1 |x="smth" |t="fasfas" |try: | y="test" | doBadStuff() | y=1 |except MyError: | x=1 |else: | t=False |z="something" """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope y=module_scope.resolve('y') self.assertIsStr(y) x=module_scope.resolve('x') self.assertIsNum(x) z=module_scope.resolve('z') self.assertIsStr(z) t=module_scope.resolve('t') self.assertIsStr(t)
def test_set(self): code = makecode(""" |set1 = {1,2,3} |set2 = {5,6,7} | | """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node)
def test_set(self): code = makecode(""" |set1 = {1,2,3} |set2 = {5,6,7} | | """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node)
def test_set_repr(self): code = makecode(""" |s={1,2,3} |x=s.pop() """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope self.assertEqual(len(self.parser.problems), 0) x = module_scope.resolve('x') self.assertIsNum(x)
def test_set_repr(self): code = makecode(""" |s={1,2,3} |x=s.pop() """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope self.assertEqual(len(self.parser.problems), 0) x = module_scope.resolve('x') self.assertIsNum(x)
def test_tuple_assign(self): code = makecode(''' |def makePair(x,y): | return (x,y) |a,b = makePair(5,'five') ''') node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem))
def test_tuple_assign(self): code = makecode(''' |def makePair(x,y): | return (x,y) |a,b = makePair(5,'five') ''') node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem))
def test_complex_args(self): code = makecode(""" |class A: | def __init__(self,x,y=1,z=True): | self.x=x | self.y=y | self.z=z | |a=A("test",z=1,y=True) |x=a.x |y=a.y |z=a.z | |b=A("test") |x1=b.x |y1=b.y |z1=b.z | |c=A("test",z=1) |x2=c.x |y2=c.y |z2=c.z | |d=A(z=1,b=2,y=3) |e=A(1,z=1,x=True) |f=A(1,2,3,4) """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope x = module_scope.resolve('x') self.assertIsStr(x) y = module_scope.resolve('y') self.assertIsBool(y) z = module_scope.resolve('z') self.assertIsNum(z) x1 = module_scope.resolve('x1') self.assertIsStr(x1) y1 = module_scope.resolve('y1') self.assertIsNum(y1) z1 = module_scope.resolve('z1') self.assertIsBool(z1) x2 = module_scope.resolve('x2') self.assertIsStr(x2) y2 = module_scope.resolve('y2') self.assertIsNum(y2) z2 = module_scope.resolve('z2') self.assertIsNum(z2) for problem in self.parser.problems: print(str(problem)) self.assertEqual(len(self.parser.problems), 3)
def test_complex_args(self): code = makecode(""" |class A: | def __init__(self,x,y=1,z=True): | self.x=x | self.y=y | self.z=z | |a=A("test",z=1,y=True) |x=a.x |y=a.y |z=a.z | |b=A("test") |x1=b.x |y1=b.y |z1=b.z | |c=A("test",z=1) |x2=c.x |y2=c.y |z2=c.z | |d=A(z=1,b=2,y=3) |e=A(1,z=1,x=True) |f=A(1,2,3,4) """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope x = module_scope.resolve('x') self.assertIsStr(x) y = module_scope.resolve('y') self.assertIsBool(y) z = module_scope.resolve('z') self.assertIsNum(z) x1 = module_scope.resolve('x1') self.assertIsStr(x1) y1 = module_scope.resolve('y1') self.assertIsNum(y1) z1 = module_scope.resolve('z1') self.assertIsBool(z1) x2 = module_scope.resolve('x2') self.assertIsStr(x2) y2 = module_scope.resolve('y2') self.assertIsNum(y2) z2 = module_scope.resolve('z2') self.assertIsNum(z2) for problem in self.parser.problems: print(str(problem)) self.assertEqual(len(self.parser.problems), 3)
def test_complex_example2(self): code = makecode(''' |class Element(object): | def __init__(self): | self.data = 10 | def printX(self): | print(self.x) #error | |instanceOfElement = Element() |testList = [instanceOfElement, "test"] |testList[0].printX() |10 + testList[1] #error ''') node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) print("P:" + str(self.finalParser.problems)) print("W:" + str(self.finalParser.warnings))
def test_multiple_targets_assign(self): code = makecode(""" |class A(object): | def __init__(self): | x="test" |a=A() |a.x=b=c=1 """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope a = module_scope.resolve('a') self.assertIsNum(a.scope['x']) b = module_scope.resolve('b') self.assertIsNum(b) c = module_scope.resolve('c') self.assertIsNum(c)
def test_dict(self): code = makecode(""" |class A(object): | def __init__(self): | self.x = 5 |a=A() |d={1:"test1"} |d[1] = a |print(d[1].x) """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) #self.assertTrue(self.finalParser.nondet) #self.assertEqual(len(self.finalParser.problems), 1) self.assertEqual(len(self.finalParser.warnings), 1) warning_symbols = {problem.symbol for problem in self.finalParser.warnings} self.assertEqual(warning_symbols, {'x'})
def test_complex_example2(self): code = makecode(''' |class Element(object): | def __init__(self): | self.data = 10 | def printX(self): | print(self.x) #error | |instanceOfElement = Element() |testList = [instanceOfElement, "test"] |testList[0].printX() |10 + testList[1] #error ''') node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) print("P:" +str(self.finalParser.problems)) print("W:" +str(self.finalParser.warnings))
def test_multiple_targets_assign(self): code = makecode(""" |class A(object): | def __init__(self): | x="test" |a=A() |a.x=b=c=1 """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope a=module_scope.resolve('a') self.assertIsNum(a.scope['x']) b=module_scope.resolve('b') self.assertIsNum(b) c=module_scope.resolve('c') self.assertIsNum(c)
def test_help(self): code = makecode(''' |def func(): | """ | vnjvndfkvns cnscksdcnsj | """ | x=4 |i[3] ''') node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) f = module_scope.resolve('func') if hasattr(f,'docstring'): print(f.docstring)
def test_help(self): code = makecode(''' |def func(): | """ | vnjvndfkvns cnscksdcnsj | """ | x=4 |i[3] ''') node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) f = module_scope.resolve('func') if hasattr(f, 'docstring'): print(f.docstring)
def test_break_continue(self): code = makecode(""" |z="test" |for x in [1,2,3,4]: | print(x) | y=2 | break | z=2 """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) y = module_scope.resolve('y') self.assertIsNum(y) z = module_scope.resolve('z') self.assertIsStr(z)
def test_break_continue(self): code = makecode(""" |z="test" |for x in [1,2,3,4]: | print(x) | y=2 | break | z=2 """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) y = module_scope.resolve('y') self.assertIsNum(y) z = module_scope.resolve('z') self.assertIsStr(z)
def test_externs(self): code = makecode(""" |f=3.5 |x=5 |y=3 |s="retazec" |z=x+s |b=s+x """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope problem_symbols = {problem.symbol for problem in self.parser.problems} for problem in self.parser.problems: print(problem) self.assertEqual(problem_symbols, {'s', 'x'}) z = module_scope.resolve('z') self.assertEqual(z, any_type) x = module_scope.resolve('x') print(str(x))
def test_nonexistent_class(self): code = makecode(""" |class A: | def __init__(self, x, y): | self.x = x | self.y = y | |class B: | pass | |a = A(1,2) |b = B() |c = C() |a = D() """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) problem_symbols = {problem.symbol for problem in self.parser.problems} self.assertEqual(problem_symbols, {'C', 'D'})
def test_dict(self): code = makecode(""" |class A(object): | def __init__(self): | self.x = 5 |a=A() |d={1:"test1"} |d[1] = a |print(d[1].x) """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) #self.assertTrue(self.finalParser.nondet) #self.assertEqual(len(self.finalParser.problems), 1) self.assertEqual(len(self.finalParser.warnings), 1) warning_symbols = { problem.symbol for problem in self.finalParser.warnings } self.assertEqual(warning_symbols, {'x'})
def test_externs(self): code = makecode(""" |f=3.5 |x=5 |y=3 |s="retazec" |z=x+s |b=s+x """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope problem_symbols = {problem.symbol for problem in self.parser.problems} for problem in self.parser.problems: print(problem) self.assertEqual(problem_symbols, {'s','x'}) z=module_scope.resolve('z') self.assertEqual(z, any_type) x=module_scope.resolve('x') print(str(x))
def test_bin_ops(self): code = makecode(""" |x = 3 |y = 5 |zz = y-x |a = True |b=5<6 """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope zz = module_scope.resolve('zz') a = module_scope.resolve('a') print("zz: " + str(zz.value)) self.assertIsNum(zz) self.assertTrue(a) self.assertIsBool(a) print("a: " + str(a)) b = module_scope.resolve('b') self.assertIsBool(b)
def test_nonexistent_class(self): code = makecode(""" |class A: | def __init__(self, x, y): | self.x = x | self.y = y | |class B: | pass | |a = A(1,2) |b = B() |c = C() |a = D() """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) problem_symbols = {problem.symbol for problem in self.parser.problems} self.assertEqual(problem_symbols, {'C', 'D'})
def test_keyword_args(self): code = makecode(""" |class A: | x=4 | |def func(a,b,c): | print(a.x) | print(b.x) | print(c) | |z=A() |func(z,c=3,b=z) |func(z,c=3,a=1) |func(a=z,c=1,d=3) """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem))
def test_bin_ops(self): code = makecode(""" |x = 3 |y = 5 |zz = y-x |a = True |b=5<6 """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope zz = module_scope.resolve('zz') a = module_scope.resolve('a') print("zz: " + str(zz.value)) self.assertIsNum(zz) self.assertTrue(a) self.assertIsBool(a) print("a: " + str(a)) b = module_scope.resolve('b') self.assertIsBool(b)
def test_keyword_args(self): code = makecode(""" |class A: | x=4 | |def func(a,b,c): | print(a.x) | print(b.x) | print(c) | |z=A() |func(z,c=3,b=z) |func(z,c=3,a=1) |func(a=z,c=1,d=3) """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem))
def test_inc_dec(self): code = makecode(""" |class A: | def __init__(self): | self.x = 4 |x=1 |z=2 |x+=z |a=A() |a.x+=1 """) node=ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) x = module_scope.resolve('x') print("x"+str(x)) a = module_scope.resolve('a') self.assertIsNum(a.scope['x']) print("a.x: " + str(a.scope['x']))
def test_set_ops(self): code = makecode(""" |class A(object): | def __init__(self): | self.x=4 |s={1,2,3} |t={2,3,4} |z= s and t |z.pop() |a=A() |z.add(a) |b=z.pop() |b.x """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) #self.assertTrue(self.finalParser.nondet) self.assertEqual(len(self.finalParser.problems), 0) self.assertEqual(len(self.finalParser.warnings), 1) warning_symbols = {problem.symbol for problem in self.finalParser.warnings} self.assertEqual(warning_symbols, {'x'})
def test_inc_dec(self): code = makecode(""" |class A: | def __init__(self): | self.x = 4 |x=1 |z=2 |x+=z |a=A() |a.x+=1 """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) x = module_scope.resolve('x') print("x" + str(x)) a = module_scope.resolve('a') self.assertIsNum(a.scope['x']) print("a.x: " + str(a.scope['x']))
def test_unary_ops(self): code = makecode(""" |x=1 |y=-x |z=+x |u=~x |w=not x """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) y = module_scope.resolve('y') self.assertIsNum(y) z = module_scope.resolve('z') self.assertIsNum(z) u = module_scope.resolve('u') self.assertIsNum(u) w = module_scope.resolve('w') self.assertIsBool(w) print(w)
def test_scope_merging(self): code = makecode(""" |class A: | def __init__(self): | self.x=4 | |c=5+6 |a=A() |if c: | a.y=1 |else: | a.z=2 | """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) #self.assertTrue(self.finalParser.nondet) self.assertEqual(len(self.finalParser.problems), 0) self.assertEqual(len(self.finalParser.warnings), 0) #module_scope=self.finalParser.finalScope a_atrs = self.finalParser.get_all_possible_attr('a') self.assertEqual(len(a_atrs),8)
def test_tuple(self): code = makecode(""" |t = (1,2,3,4) |s = ("TEST",) |v = [5] |u = t+s |x = u[2] |m = u[4] |y = u[0:3] |z = t+v """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) x = module_scope.resolve('x') self.assertIsNum(x) print("x: " + str(x)) m = module_scope.resolve('m') print("m: " + str(m)) self.assertIsStr(m)
def test_scope_merging(self): code = makecode(""" |class A: | def __init__(self): | self.x=4 | |c=5+6 |a=A() |if c: | a.y=1 |else: | a.z=2 | """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) #self.assertTrue(self.finalParser.nondet) self.assertEqual(len(self.finalParser.problems), 0) self.assertEqual(len(self.finalParser.warnings), 0) #module_scope=self.finalParser.finalScope a_atrs = self.finalParser.get_all_possible_attr('a') self.assertEqual(len(a_atrs), 8)
def test_unary_ops(self): code = makecode(""" |x=1 |y=-x |z=+x |u=~x |w=not x """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) y = module_scope.resolve('y') self.assertIsNum(y) z = module_scope.resolve('z') self.assertIsNum(z) u = module_scope.resolve('u') self.assertIsNum(u) w= module_scope.resolve('w') self.assertIsBool(w) print(w)
def test_tuple(self): code = makecode(""" |t = (1,2,3,4) |s = ("TEST",) |v = [5] |u = t+s |x = u[2] |m = u[4] |y = u[0:3] |z = t+v """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope for problem in self.parser.problems: print(str(problem)) x = module_scope.resolve('x') self.assertIsNum(x) print("x: " + str(x)) m = module_scope.resolve('m') print("m: "+ str(m)) self.assertIsStr(m)
def test_obj_const(self): code = makecode(""" |class A: | x=4 | |a=A() |a.z="string" |y=3 """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope problem_symbols = {problem.symbol for problem in self.parser.problems} for problem in self.parser.problems: print(problem) #self.assertEqual(problem_symbols, {'s'}) a=module_scope.resolve('a') self.assertIsStr(a.scope['z']) self.assertEqual('obj', a.scope['z'].kind) y=module_scope.resolve('y') self.assertIsNum(y) self.assertEqual('obj', y.kind)
def test_obj_const(self): code = makecode(""" |class A: | x=4 | |a=A() |a.z="string" |y=3 """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope problem_symbols = {problem.symbol for problem in self.parser.problems} for problem in self.parser.problems: print(problem) #self.assertEqual(problem_symbols, {'s'}) a = module_scope.resolve('a') self.assertIsStr(a.scope['z']) self.assertEqual('obj', a.scope['z'].kind) y = module_scope.resolve('y') self.assertIsNum(y) self.assertEqual('obj', y.kind)
def test_list(self): code = makecode(""" |class A: | x=4 | def test_funkcia(self): | print("nieco") | |a = A() |l = [a,'test'] |l[0].test_funkcia() |b = ['jozo',l] |b[1][0].test_funkcia() |test = t |b[0]=1 """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.finalParser.eval_in_root(node) self.assertTrue(self.finalParser.nondet) self.assertEqual(len(self.finalParser.problems), 1) self.assertEqual(len(self.finalParser.warnings), 2) warning_symbols = {problem.symbol for problem in self.finalParser.warnings} self.assertEqual(warning_symbols, {'test_funkcia'})
def test_if(self): code = makecode(""" |c=True |if c: | c1=1 |v="True" |if v: | v1=1 |n="False" |if n: | n1=1 |m=False |m1="test" |if m: | m1=1 |a=None |a1="test" |if a: | a1=1 |s="None" |if s: | s1=1 |d=0 |d1="test" |if d: | d1=1 |f=1 |if f: | f1=1 |h="" |h1="test" |if h: | h1=1 |j="0" |if j: | j1=1 |k="1" |if k: | k1=1 |g=-1 |if g: | g1=1 """) node = ast.parse(code, mode='exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope c1 = module_scope.resolve('c1') self.assertIsNum(c1) v1 = module_scope.resolve('v1') self.assertIsNum(v1) n1 = module_scope.resolve('n1') self.assertIsNum(n1) m1 = module_scope.resolve('m1') self.assertIsStr(m1) a1 = module_scope.resolve('a1') self.assertIsStr(a1) s1 = module_scope.resolve('s1') self.assertIsNum(s1) d1 = module_scope.resolve('d1') self.assertIsStr(d1) f1 = module_scope.resolve('f1') self.assertIsNum(f1) g1 = module_scope.resolve('g1') self.assertIsNum(g1) h1 = module_scope.resolve('h1') self.assertIsStr(h1) j1 = module_scope.resolve('j1') self.assertIsNum(j1) k1 = module_scope.resolve('k1') self.assertIsNum(k1)
def test_if(self): code = makecode(""" |c=True |if c: | c1=1 |v="True" |if v: | v1=1 |n="False" |if n: | n1=1 |m=False |m1="test" |if m: | m1=1 |a=None |a1="test" |if a: | a1=1 |s="None" |if s: | s1=1 |d=0 |d1="test" |if d: | d1=1 |f=1 |if f: | f1=1 |h="" |h1="test" |if h: | h1=1 |j="0" |if j: | j1=1 |k="1" |if k: | k1=1 |g=-1 |if g: | g1=1 """) node = ast.parse(code, mode = 'exec') print(utils.astNode_to_tree(node)) self.parser.eval_in_root(node) module_scope = self.parser.root_scope c1=module_scope.resolve('c1') self.assertIsNum(c1) v1=module_scope.resolve('v1') self.assertIsNum(v1) n1=module_scope.resolve('n1') self.assertIsNum(n1) m1=module_scope.resolve('m1') self.assertIsStr(m1) a1=module_scope.resolve('a1') self.assertIsStr(a1) s1=module_scope.resolve('s1') self.assertIsNum(s1) d1=module_scope.resolve('d1') self.assertIsStr(d1) f1=module_scope.resolve('f1') self.assertIsNum(f1) g1=module_scope.resolve('g1') self.assertIsNum(g1) h1=module_scope.resolve('h1') self.assertIsStr(h1) j1=module_scope.resolve('j1') self.assertIsNum(j1) k1=module_scope.resolve('k1') self.assertIsNum(k1)