def test_simple_parse(self):
code = makecode("""
|x = 3
|a = 'ahoj'
|y = 6
|z = 3 + x
|zz = x + y
|b = 'jozo'
|c = a + b
|x = 'mumly'
""")
node = ast.parse(code, mode = 'exec')
parser = Parser()
module_scope = parser.eval_code(node)
x = module_scope.resolve('x')
y = module_scope.resolve('y')
z = module_scope.resolve('z')
zz = module_scope.resolve('zz')
a = module_scope.resolve('a')
b = module_scope.resolve('b')
c = module_scope.resolve('c')
self.assertIsStr(x)
self.assertIsNum(y)
self.assertIsNum(z)
self.assertIsNum(zz)
self.assertIsStr(a)
self.assertIsStr(b)
self.assertIsStr(c)
def test_fun_parse(self):
code = makecode("""
|def mean(x,y):
| return (x+y)/2
|def gean(x,y):
| return x+y
|x = 3
|y = x+2
|z = mean(x,y)
|x = "jozo"
|zz = gean(x,"fero")
""")
node = ast.parse(code, mode = 'exec')
parser = Parser()
module_scope = parser.eval_code(node)
x = module_scope.resolve('x')
y = module_scope.resolve('y')
z = module_scope.resolve('z')
zz = module_scope.resolve('zz')
self.assertIsStr(x)
self.assertIsNum(y)
self.assertIsNum(z)
self.assertIsStr(zz)
def test_method_lookup(self):
code = makecode("""
|class A:
| def __init__(self, x):
| self.x = x
| def get_x(self):
| return self.x
|a = A('jozo')
|b = a.get_x()
|a = A(3)
|c = a.get_x()
""")
node = ast.parse(code, mode = 'exec')
parser = Parser()
module_scope = parser.eval_code(node)
self.assertEqual(len(parser.problems), 0)
a = module_scope.resolve('a')
A = module_scope.resolve('A')
self.assertNotIn('get_x', a.scope)
self.assertIn('get_x', A.scope)
b = module_scope.resolve('b')
c = module_scope.resolve('c')
self.assertIsStr(b)
self.assertIsNum(c)
def test_class_closure(self):
code = makecode("""
|class A:
| def __init__(self, x):
| self.x = x
| def get_x(self):
| return self.x
|a = A('jozo')
|getx = a.get_x
|getx_class1 = A.get_x
|getx_class2 = A.get_x
|x1 = getx()
|x2 = getx_class1()
|x3 = getx_class2(a)
""")
node = ast.parse(code, mode = 'exec')
parser = Parser()
module_scope = parser.eval_code(node)
self.assertEqual(1, len(parser.problems))
self.assertEqual('getx_class1', parser.problems[0].symbol)
x1 = module_scope.resolve('x1')
x3 = module_scope.resolve('x3')
self.assertIsStr(x1)
self.assertIsStr(x3)
def test_inheritance(self):
code = makecode("""
|class A:
| def __init__(self):
| pass
|
| def get_x(self):
| return self.x
|class B(A):
| def __init__(self):
| pass
|
| def get_y(self):
| return self.y
|b = B()
|b.x = 'jozo'
|b.y = 4
""")
node = ast.parse(code, mode = 'exec')
parser = Parser()
module_scope = parser.eval_code(node)
self.assertEqual(len(parser.problems), 0)
b = module_scope.resolve('b')
self.assertIsNum(b.scope['y'])
self.assertIsStr(b.scope['x'])
self.assertEqual(b.resolve('get_x', 'class').kind, 'func')
def test_default_object(self):
code = makecode("""
|class A():
| pass
|a = A()
""")
node = ast.parse(code, mode = 'exec')
parser = Parser()
module_scope = parser.eval_code(node)
a = module_scope.resolve('a')
__setattr__ = a.resolve('__setattr__', 'straight')
self.assertEqual(__setattr__, None)
__setattr__ = a.resolve('__setattr__', mode = 'class')
self.assertEqual(__setattr__.node.name, '__setattr__')
def load_externs():
from inf.inference.parse_ast import Parser
parser = Parser()
f = open("inf/inference/externs.py", "r")
source = f.read()
node = ast.parse(source, filename = 'externs.py', mode = 'exec')
scope = Scope(is_root = True)
logger.info('parsing externs')
extern_scope = inf.inference.typez.extern_scope = parser.eval_code(node, scope)
inf.inference.typez.inf_setattr = extern_scope['inf_setattr']
inf.inference.typez.inf_getattr = extern_scope['inf_getattr']
#extern_scope['int'] = extern_scope['inf_num']
#extern_scope['str'] = extern_scope['inf_str']
#extern_scope['object'] = extern_scope['inf_object']
logger.info('externs parsed')
def test_nonexistent_attribute(self):
code = makecode("""
|class A:
| def __init__(self, x, y):
| self.x = x
| self.y = y
|
|a = A(3,4)
|a.x = a.z
|a.z = a.x
|a.y = a.z
|a.w = a.w
""")
node = ast.parse(code, mode = 'exec')
parser = Parser()
parser.eval_code(node)
problem_symbols = {problem.symbol for problem in parser.problems}
self.assertEqual(problem_symbols, {'w', 'z'})
def test_class(self):
code = makecode("""
|class A:
| def __init__(self, x, y, z):
| self.x = x
| self.y = y
|w = 'johnie'
|
|a = A(3,"ahoj", "svet")
""")
node = ast.parse(code, mode = 'exec')
parser = Parser()
module_scope = parser.eval_code(node)
a = module_scope.resolve('a')
self.assertEqual(len(parser.problems), 0)
self.assertIsNum(a.scope['x'])
self.assertIsStr(a.scope['y'])
self.assertNotIn('w', a.scope)
self.assertNotIn('z', a.scope)
self.assertEqual(a.scope.resolve('z'),None)
def test_closure(self):
code = makecode("""
|def f(x):
| z = x
| def g(y):
| return(x+y)
| return g
|g1 = f(3)
|g2 = f('jozo')
|a = g1(4)
|b = g2('fero')
""")
node = ast.parse(code, mode = 'exec')
parser = Parser()
module_scope = parser.eval_code(node)
a = module_scope.resolve('a')
b = module_scope.resolve('b')
self.assertIsNum(a)
self.assertIsStr(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')
parser = Parser()
parser.eval_code(node)
problem_symbols = {problem.symbol for problem in parser.problems}
self.assertEqual(problem_symbols, {'C', 'D'})
def test_override_setattr(self):
code = makecode("""
|class A:
| def __init__(self, x, y):
| pass
|
| def __setattr__(self, attr, val):
| object.__setattr__(self, attr, 4)
|
|
|a = A(3,4)
|a.x = 'jozo'
|key = 'z'
|object.__setattr__(a,key,'jozo')
""")
node = ast.parse(code, mode = 'exec')
parser = Parser()
module_scope = parser.eval_code(node)
a = module_scope.resolve('a')
self.assertEqual(len(parser.problems), 0)
self.assertIsNum(a.scope['x'])
self.assertIsStr(a.scope['z'])
def setUp(self):
self.parser = Parser()
self.num_class = self.parser.extern_scope['num']
self.str_class = self.parser.extern_scope['str']
def setUp(self):
self.parser = Parser()
self.num_class = self.parser.extern_scope['num']
self.str_class = self.parser.extern_scope['str']
class TestWarnings(InferTestCase): #{{{
def setUp(self):
self.parser = Parser()
self.num_class = self.parser.extern_scope['num']
self.str_class = self.parser.extern_scope['str']
def test_nonexistent_attribute(self):
code = makecode("""
|class A:
| def __init__(self, x, y):
| self.x = x
| self.y = y
|
|a = A(3,4)
|a.x = a.z
|a.z = a.x
|a.y = a.z
|a.w = a.w
|a.t = t
|t = a.u
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
problem_symbols = {problem.symbol for problem in self.parser.problems}
print(problem_symbols)
self.assertEqual(problem_symbols, {'w', 'z' , 'u', 't'})
def test_nonexistent_function(self):
code = makecode("""
|class A:
| def __init__(self, x, y):
| self.x = x
| self.y = y
|
| def fun1(self):
| return self.x+self.y
|
|a = A(3,4)
|a.z = a.fun1()
|a.gun1()
|a.fun2 = a.fun1
|a.fun2()
|# since the problem with nonexistent gun1 is already reported, gun1 and gun2 are to be considered as
|# any_type making all invocations and other manipulations with it legal
|a.gun2 = a.gun1
|a.gun2()
|a.gun3()
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
#problem_symbols = {problem.symbol for problem in self.parser.problems}
#self.assertEqual(problem_symbols, {'gun1', 'gun3'})
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 setUp(self):
self.parser = Parser()
self.finalParser = FinalParser()
self.num_class = self.parser.extern_scope['num']
self.str_class = self.parser.extern_scope['str']
self.bool_class = self.parser.extern_scope['bool']
class TestInfer(InferTestCase): #{{{
def setUp(self):
self.parser = Parser()
self.finalParser = FinalParser()
self.num_class = self.parser.extern_scope['num']
self.str_class = self.parser.extern_scope['str']
self.bool_class = self.parser.extern_scope['bool']
def test_simple_parse(self):
code = makecode("""
|x = 3
|a = 'ahoj'
|y = 6
|z = 3 + x
|zz = x + y
|b = 'jozo'
|c = a + b
|x = 'mumly'
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
x = module_scope.resolve('x')
y = module_scope.resolve('y')
z = module_scope.resolve('z')
zz = module_scope.resolve('zz')
a = module_scope.resolve('a')
b = module_scope.resolve('b')
c = module_scope.resolve('c')
self.assertIsStr(x)
self.assertIsNum(y)
self.assertIsNum(z)
self.assertIsNum(zz)
self.assertIsStr(a)
self.assertIsStr(b)
self.assertIsStr(c)
def test_fun_parse(self):
code = makecode("""
|def mean(x,y):
| return (x+y)/2
|def gean(x,y):
| return x+y
|x = 3
|y = x+2
|z = mean(x,y)
|x = "jozo"
|zz = gean(x,"fero")
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
x = module_scope.resolve('x')
y = module_scope.resolve('y')
z = module_scope.resolve('z')
zz = module_scope.resolve('zz')
self.assertIsStr(x)
self.assertIsNum(y)
self.assertIsNum(z)
self.assertIsStr(zz)
def test_default_object(self):
code = makecode("""
|class A():
| pass
|a = A()
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
__setattr__ = a.resolve('__setattr__', 'straight')
self.assertEqual(__setattr__, None)
__setattr__ = a.resolve('__setattr__', mode = 'class')
self.assertEqual(__setattr__.node.name, '__setattr__')
def test_closure(self):
code = makecode("""
|def f(x):
| z = x
| def g(y):
| return(x+y)
| return g
|g1 = f(3)
|g2 = f('jozo')
|a = g1(4)
|b = g2('fero')
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
b = module_scope.resolve('b')
self.assertIsNum(a)
self.assertIsStr(b)
def test_class(self):
code = makecode("""
|class A:
| def __init__(self, x, y, z):
| self.x = x
| self.y = y
| w = 'johnie'
|
|a = A(3,"ahoj", "svet")
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
self.assert_no_problem();
self.assertIsNum(a.scope['x'])
self.assertIsStr(a.scope['y'])
self.assertNotIn('w', a.scope)
self.assertNotIn('z', a.scope)
self.assertEqual(a.scope.resolve('z'),None)
def test_override_setattr(self):
code = makecode("""
|class A:
| def __init__(self, x, y):
| pass
|
| def __setattr__(self, attr, val):
| object.__setattr__(self, attr, 4)
|
|
|a = A(3,4)
|a.x = 'jozo'
|key = 'z'
|object.__setattr__(a,key,'jozo')
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
self.assert_no_problem();
self.assertIsNum(a.scope['x'])
self.assertIsStr(a.scope['z'])
def test_method_lookup(self):
code = makecode("""
|class A:
| def __init__(self, x):
| self.x = x
| def get_x(self):
| return self.x
|a = A('jozo')
|b = a.get_x()
|a = A(3)
|c = a.get_x()
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
self.assert_no_problem();
a = module_scope.resolve('a')
A = module_scope.resolve('A')
self.assertNotIn('get_x', a.scope)
self.assertIn('get_x', A.scope)
b = module_scope.resolve('b')
c = module_scope.resolve('c')
self.assertIsStr(b)
self.assertIsNum(c)
def test_method_manipulation(self):
code = makecode("""
|class A:
| def __init__(self, x, y):
| self.x = x
| self.y = y
|
| def fun1(self):
| return self.x+self.y
|
|
|a = A(3,4)
|a.fun1()
|fun2 = a.fun1
|a.fun3 = a.fun1
|z2 = fun2()
|z3 = a.fun3()
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
z2 = module_scope.resolve('z2')
self.assertIsNum(z2)
z3 = module_scope.resolve('z3')
self.assertIsNum(z3)
def test_class_closure(self):
code = makecode("""
|class A:
| def __init__(self, x):
| self.x = x
| def get_x(self):
| return self.x
|a = A('jozo')
|getx = a.get_x
|getx_class1 = A.get_x
|getx_class2 = A.get_x
|x1 = getx()
|x2 = getx_class1()
|x3 = getx_class2(a)
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
self.assertEqual(1, len(self.parser.problems))
self.assertEqual('getx_class1', self.parser.problems[0].symbol)
x1 = module_scope.resolve('x1')
x3 = module_scope.resolve('x3')
self.assertIsStr(x1)
self.assertIsStr(x3)
def test_inheritance(self):
code = makecode("""
|class A:
| def __init__(self):
| pass
|
| def get_x(self):
| return self.x
|class B(A):
| def __init__(self):
| pass
|
| def get_y(self):
| return self.y
|b = B()
|b.x = 'jozo'
|b.y = 4
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
self.assertEqual(len(self.parser.problems), 0)
b = module_scope.resolve('b')
print(b)
self.assertIsNum(b.scope['y'])
self.assertIsStr(b.scope['x'])
self.assertEqual(b.resolve('get_x', 'class').kind, 'funcdef')
def test_function_return(self):
code = makecode("""
|def g():
| return "ahoj"
|
|
|def f():
| x=1
| y=2
| g()
| return x+y;
|
|z = f()
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
self.assertEqual(len(self.parser.problems), 0)
z = module_scope.resolve('z')
self.assertIsNum(z)
def test_finalParser(self):
code = makecode("""
|class A:
| x = 5+1
|
|a = A()
|
|b = a.something
|
|if a.x:
| a.y=1
|else:
| a.z=1
|
|if a.x:
| a.y
|else:
| a. z
""")
node = ast.parse(code, mode = 'exec')
#self.parser.eval_in_root(node)
self.finalParser.eval_in_root(node)
#module_scope = self.parser.root_scope
#module_scope = self.finalParser.parser.root_scope
self.assertTrue(self.finalParser.nondet)
self.assertEqual(len(self.finalParser.problems), 1)
self.assertEqual(len(self.finalParser.warnings), 2)
problem_symbols = {problem.symbol for problem in self.finalParser.problems}
self.assertEqual(problem_symbols, {'something'})
warning_symbols = {problem.symbol for problem in self.finalParser.warnings}
self.assertEqual(warning_symbols, {'y','z'})
def test_correct_inheritance(self):
code = makecode("""
|class A:
| x = 5
|
|class B:
| x = 'test'
|
|class C(A,B):
| pass
|
|class D(B,A):
| pass
|
|class E(A):
| pass
|
|class F(E,B):
| pass
|
|a = C()
|b = D()
|c = F()
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
b = module_scope.resolve('b')
c = module_scope.resolve('c')
self.assertIsNum(a.resolve('x', 'class'))
self.assertIsStr(b.resolve('x', 'class'))
self.assertIsNum(c.resolve('x', 'class'))
def test_isinstance_simple(self):
code = makecode("""
|class A:
| x = 4
|
|class B(A):
| y = 3
|
|class C:
| x = 2
|
|b = B()
|a = A()
|
|c = isinstance(b,A)
|d = isinstance(b,C)
|
|b.y
|b.x
|b.z
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
print("a value: "+ str(a))
c = module_scope.resolve('c')
print("c value: "+ str(c))
d = module_scope.resolve('d')
print("d value: "+ str(d))
#problem_symbols = {problem.symbol for problem in self.parser.problems}
#print("PROBLEM: "+str(problem_symbols))
def test_isinstance_expert(self):
code = makecode("""
|class A:
| x = 4
|
|class B(A):
| y = 3
|
|def returnInstanceOfA():
| a = A()
| return a
|
|def returnA():
| return A
|
|def returnB():
| return B
|
|a = A()
|b = B()
|
|c = isinstance(returnInstanceOfA(),returnA())
|d = isinstance(b,returnB())
|e = isinstance(b,returnA())
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
c = module_scope.resolve('c')
d = module_scope.resolve('d')
e = module_scope.resolve('e')
self.assertTrue(c.value)
self.assertTrue(d.value)
self.assertTrue(e.value)
#problem_symbols = {problem.symbol for problem in self.parser.problems}
#print("PROBLEM: "+str(problem_symbols))
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)
#self.assertIsNum(a)
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_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_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_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_raise(self):
code = makecode("""
|raise 1
""")
node = ast.parse(code, mode = 'exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
problem_symbols = {problem.symbol for problem in self.parser.problems}
self.assertEqual(problem_symbols, {'raise'})
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_try_statement(self):
code = makecode("""
|class MyError(Exception):
| pass
|
|class MyNextError(Exception):
| pass
|
|def doBadStuff():
| raise MyError()
|
|def executeRiskyStuff():
| try:
| doBadStuff()
| except MyNextError:
| pass
| finally:
| pass
|
|z=1
|x="smth"
|t="fasfas"
|try:
| y="test"
| executeRiskyStuff()
| 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_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_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)
#self.assertEqual(len(self.finalParser.problems), 2)
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_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_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_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_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_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_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_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_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_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)
#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_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_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_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))
#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_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_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_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 setUp(self):
self.parser = Parser()
self.finalParser = FinalParser()
self.num_class = self.parser.extern_scope['num']
self.str_class = self.parser.extern_scope['str']
self.bool_class = self.parser.extern_scope['bool']
class TestWarnings(InferTestCase): #{{{
def setUp(self):
self.parser = Parser()
self.num_class = self.parser.extern_scope['num']
self.str_class = self.parser.extern_scope['str']
def test_nonexistent_attribute(self):
code = makecode("""
|class A:
| def __init__(self, x, y):
| self.x = x
| self.y = y
|
|a = A(3,4)
|a.x = a.z
|a.z = a.x
|a.y = a.z
|a.w = a.w
|a.t = t
|t = a.u
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
problem_symbols = {problem.symbol for problem in self.parser.problems}
print(problem_symbols)
self.assertEqual(problem_symbols, {'w', 'z', 'u', 't'})
def test_nonexistent_function(self):
code = makecode("""
|class A:
| def __init__(self, x, y):
| self.x = x
| self.y = y
|
| def fun1(self):
| return self.x+self.y
|
|a = A(3,4)
|a.z = a.fun1()
|a.gun1()
|a.fun2 = a.fun1
|a.fun2()
|# since the problem with nonexistent gun1 is already reported, gun1 and gun2 are to be considered as
|# any_type making all invocations and other manipulations with it legal
|a.gun2 = a.gun1
|a.gun2()
|a.gun3()
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
#problem_symbols = {problem.symbol for problem in self.parser.problems}
#self.assertEqual(problem_symbols, {'gun1', 'gun3'})
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 parseAndValidate(connection):
try:
arrayOfProblems = None
arrayOfProblems = []
# Decode the data
#data = anArg.decode("utf-8")
data = bufferToString(buffer)
print("DATA: ",data)
#print("TOTO VALIDUJEM: "+ anArg)
#data = anArg
lexer = python_lexer.PythonLexer()
lexer.input(data)
#for token in lexer:
#print(token.value)
lexer = python_lexer.PythonLexer()
res = python_parser.parse_data(data,lexer)
tree, delParts = utils.traverse_ast_test(res)
try:
ast_tree = utils.parse_with_ast(res)
#print(utils.astNode_to_tree(ast_tree))
except Exception as error:
print("Error in part which that be valid: ",error)
parser=Parser()
module_scope=parser.eval_code(ast_tree)
delLines = []
for delPart in delParts:
for i in range(delPart[0],delPart[1]+1):
#tuto su veci
delLines.append(i)
#processing syntax problems
for line in delLines:
p = []
p.append(line)
p.append('invalid syntax')
arrayOfProblems.append(p)
delLines+=res.emptyLinesNums
temp={line for line in delLines}
delLines = [line for line in temp]
delLines.sort()
print("DEL LINES:", delLines)
problem_symbols={problem for problem in parser.problems}
listOfLines = []
for problem in problem_symbols:
if not hasattr(problem.node, 'processed'):
problem.node.lineno=utils.getOriginLineNum(problem.node.lineno,delLines)
problem.node.processed=1
print('P: ', problem,'at line: ',problem.node.lineno)
if not (problem.node.lineno in listOfLines):
b = []
b.append(problem.node.lineno)
b.append(str(problem))
arrayOfProblems.append(b)
listOfLines.append(problem.node.lineno)
#pickleProblems = pickleListOfProblems(arrayOfProblems)
pickleProblems = pickleListOfProblems(arrayOfProblems)
pickleProblemsStr = pickle.dumps(pickleProblems, 2)
connection.sendall(pickleProblemsStr)
return (ast_tree, delLines)
except:
traceback.print_exc()
#sock.close()
connection.sendall(bytes("endOfValidation", "utf-8"))
class TestInfer(InferTestCase): #{{{
def setUp(self):
self.parser = Parser()
self.finalParser = FinalParser()
self.num_class = self.parser.extern_scope['num']
self.str_class = self.parser.extern_scope['str']
self.bool_class = self.parser.extern_scope['bool']
def test_simple_parse(self):
code = makecode("""
|x = 3
|a = 'ahoj'
|y = 6
|z = 3 + x
|zz = x + y
|b = 'jozo'
|c = a + b
|x = 'mumly'
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
x = module_scope.resolve('x')
y = module_scope.resolve('y')
z = module_scope.resolve('z')
zz = module_scope.resolve('zz')
a = module_scope.resolve('a')
b = module_scope.resolve('b')
c = module_scope.resolve('c')
self.assertIsStr(x)
self.assertIsNum(y)
self.assertIsNum(z)
self.assertIsNum(zz)
self.assertIsStr(a)
self.assertIsStr(b)
self.assertIsStr(c)
def test_fun_parse(self):
code = makecode("""
|def mean(x,y):
| return (x+y)/2
|def gean(x,y):
| return x+y
|x = 3
|y = x+2
|z = mean(x,y)
|x = "jozo"
|zz = gean(x,"fero")
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
x = module_scope.resolve('x')
y = module_scope.resolve('y')
z = module_scope.resolve('z')
zz = module_scope.resolve('zz')
self.assertIsStr(x)
self.assertIsNum(y)
self.assertIsNum(z)
self.assertIsStr(zz)
def test_default_object(self):
code = makecode("""
|class A():
| pass
|a = A()
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
__setattr__ = a.resolve('__setattr__', 'straight')
self.assertEqual(__setattr__, None)
__setattr__ = a.resolve('__setattr__', mode='class')
self.assertEqual(__setattr__.node.name, '__setattr__')
def test_closure(self):
code = makecode("""
|def f(x):
| z = x
| def g(y):
| return(x+y)
| return g
|g1 = f(3)
|g2 = f('jozo')
|a = g1(4)
|b = g2('fero')
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
b = module_scope.resolve('b')
self.assertIsNum(a)
self.assertIsStr(b)
def test_class(self):
code = makecode("""
|class A:
| def __init__(self, x, y, z):
| self.x = x
| self.y = y
| w = 'johnie'
|
|a = A(3,"ahoj", "svet")
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
self.assert_no_problem()
self.assertIsNum(a.scope['x'])
self.assertIsStr(a.scope['y'])
self.assertNotIn('w', a.scope)
self.assertNotIn('z', a.scope)
self.assertEqual(a.scope.resolve('z'), None)
def test_override_setattr(self):
code = makecode("""
|class A:
| def __init__(self, x, y):
| pass
|
| def __setattr__(self, attr, val):
| object.__setattr__(self, attr, 4)
|
|
|a = A(3,4)
|a.x = 'jozo'
|key = 'z'
|object.__setattr__(a,key,'jozo')
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
self.assert_no_problem()
self.assertIsNum(a.scope['x'])
self.assertIsStr(a.scope['z'])
def test_method_lookup(self):
code = makecode("""
|class A:
| def __init__(self, x):
| self.x = x
| def get_x(self):
| return self.x
|a = A('jozo')
|b = a.get_x()
|a = A(3)
|c = a.get_x()
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
self.assert_no_problem()
a = module_scope.resolve('a')
A = module_scope.resolve('A')
self.assertNotIn('get_x', a.scope)
self.assertIn('get_x', A.scope)
b = module_scope.resolve('b')
c = module_scope.resolve('c')
self.assertIsStr(b)
self.assertIsNum(c)
def test_method_manipulation(self):
code = makecode("""
|class A:
| def __init__(self, x, y):
| self.x = x
| self.y = y
|
| def fun1(self):
| return self.x+self.y
|
|
|a = A(3,4)
|a.fun1()
|fun2 = a.fun1
|a.fun3 = a.fun1
|z2 = fun2()
|z3 = a.fun3()
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
z2 = module_scope.resolve('z2')
self.assertIsNum(z2)
z3 = module_scope.resolve('z3')
self.assertIsNum(z3)
def test_class_closure(self):
code = makecode("""
|class A:
| def __init__(self, x):
| self.x = x
| def get_x(self):
| return self.x
|a = A('jozo')
|getx = a.get_x
|getx_class1 = A.get_x
|getx_class2 = A.get_x
|x1 = getx()
|x2 = getx_class1()
|x3 = getx_class2(a)
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
self.assertEqual(1, len(self.parser.problems))
self.assertEqual('getx_class1', self.parser.problems[0].symbol)
x1 = module_scope.resolve('x1')
x3 = module_scope.resolve('x3')
self.assertIsStr(x1)
self.assertIsStr(x3)
def test_inheritance(self):
code = makecode("""
|class A:
| def __init__(self):
| pass
|
| def get_x(self):
| return self.x
|class B(A):
| def __init__(self):
| pass
|
| def get_y(self):
| return self.y
|b = B()
|b.x = 'jozo'
|b.y = 4
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
self.assertEqual(len(self.parser.problems), 0)
b = module_scope.resolve('b')
print(b)
self.assertIsNum(b.scope['y'])
self.assertIsStr(b.scope['x'])
self.assertEqual(b.resolve('get_x', 'class').kind, 'funcdef')
def test_function_return(self):
code = makecode("""
|def g():
| return "ahoj"
|
|
|def f():
| x=1
| y=2
| g()
| return x+y;
|
|z = f()
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
self.assertEqual(len(self.parser.problems), 0)
z = module_scope.resolve('z')
self.assertIsNum(z)
def test_finalParser(self):
code = makecode("""
|class A:
| x = 5+1
|
|a = A()
|
|b = a.something
|
|if a.x:
| a.y=1
|else:
| a.z=1
|
|if a.x:
| a.y
|else:
| a. z
""")
node = ast.parse(code, mode='exec')
#self.parser.eval_in_root(node)
self.finalParser.eval_in_root(node)
#module_scope = self.parser.root_scope
#module_scope = self.finalParser.parser.root_scope
self.assertTrue(self.finalParser.nondet)
self.assertEqual(len(self.finalParser.problems), 1)
self.assertEqual(len(self.finalParser.warnings), 2)
problem_symbols = {
problem.symbol
for problem in self.finalParser.problems
}
self.assertEqual(problem_symbols, {'something'})
warning_symbols = {
problem.symbol
for problem in self.finalParser.warnings
}
self.assertEqual(warning_symbols, {'y', 'z'})
def test_correct_inheritance(self):
code = makecode("""
|class A:
| x = 5
|
|class B:
| x = 'test'
|
|class C(A,B):
| pass
|
|class D(B,A):
| pass
|
|class E(A):
| pass
|
|class F(E,B):
| pass
|
|a = C()
|b = D()
|c = F()
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
b = module_scope.resolve('b')
c = module_scope.resolve('c')
self.assertIsNum(a.resolve('x', 'class'))
self.assertIsStr(b.resolve('x', 'class'))
self.assertIsNum(c.resolve('x', 'class'))
def test_isinstance_simple(self):
code = makecode("""
|class A:
| x = 4
|
|class B(A):
| y = 3
|
|class C:
| x = 2
|
|b = B()
|a = A()
|
|c = isinstance(b,A)
|d = isinstance(b,C)
|
|b.y
|b.x
|b.z
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
a = module_scope.resolve('a')
print("a value: " + str(a))
c = module_scope.resolve('c')
print("c value: " + str(c))
d = module_scope.resolve('d')
print("d value: " + str(d))
#problem_symbols = {problem.symbol for problem in self.parser.problems}
#print("PROBLEM: "+str(problem_symbols))
def test_isinstance_expert(self):
code = makecode("""
|class A:
| x = 4
|
|class B(A):
| y = 3
|
|def returnInstanceOfA():
| a = A()
| return a
|
|def returnA():
| return A
|
|def returnB():
| return B
|
|a = A()
|b = B()
|
|c = isinstance(returnInstanceOfA(),returnA())
|d = isinstance(b,returnB())
|e = isinstance(b,returnA())
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
c = module_scope.resolve('c')
d = module_scope.resolve('d')
e = module_scope.resolve('e')
self.assertTrue(c.value)
self.assertTrue(d.value)
self.assertTrue(e.value)
#problem_symbols = {problem.symbol for problem in self.parser.problems}
#print("PROBLEM: "+str(problem_symbols))
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)
#self.assertIsNum(a)
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_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_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_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_raise(self):
code = makecode("""
|raise 1
""")
node = ast.parse(code, mode='exec')
self.parser.eval_in_root(node)
module_scope = self.parser.root_scope
problem_symbols = {problem.symbol for problem in self.parser.problems}
self.assertEqual(problem_symbols, {'raise'})
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_try_statement(self):
code = makecode("""
|class MyError(Exception):
| pass
|
|class MyNextError(Exception):
| pass
|
|def doBadStuff():
| raise MyError()
|
|def executeRiskyStuff():
| try:
| doBadStuff()
| except MyNextError:
| pass
| finally:
| pass
|
|z=1
|x="smth"
|t="fasfas"
|try:
| y="test"
| executeRiskyStuff()
| 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_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_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)
#self.assertEqual(len(self.finalParser.problems), 2)
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_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_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_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_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_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_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_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_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_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)
#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_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_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_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))
#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_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_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_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)
