def test_import_as(self):
code = '''
import os.path as osp
print (osp.dirname(__file__))
from os.path import exists as e
assert e(__file__)
from new import code as make_code
print (make_code)
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid.igetattr('osp'))
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.Module)
self.assertEqual(infered[0].name, 'os.path')
infered = list(astroid.igetattr('e'))
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.Function)
self.assertEqual(infered[0].name, 'exists')
if sys.version_info >= (3, 0):
self.skipTest('<new> module has been removed')
infered = list(astroid.igetattr('make_code'))
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], Instance)
self.assertEqual(str(infered[0]),
'Instance of %s.type' % BUILTINS)
def test_nonregr_instance_attrs(self):
"""non regression for instance_attrs infinite loop : pylint / #4"""
code = """
class Foo(object):
def set_42(self):
self.attr = 42
class Bar(Foo):
def __init__(self):
self.attr = 41
"""
astroid = builder.string_build(code, __name__, __file__)
foo_class = astroid['Foo']
bar_class = astroid['Bar']
bar_self = astroid['Bar']['__init__']['self']
assattr = bar_class.instance_attrs['attr'][0]
self.assertEqual(len(foo_class.instance_attrs['attr']), 1)
self.assertEqual(len(bar_class.instance_attrs['attr']), 1)
self.assertEqual(bar_class.instance_attrs, {'attr': [assattr]})
# call 'instance_attr' via 'Instance.getattr' to trigger the bug:
instance = bar_self.infered()[0]
_attr = instance.getattr('attr')
self.assertEqual(len(bar_class.instance_attrs['attr']), 1)
self.assertEqual(len(foo_class.instance_attrs['attr']), 1)
self.assertEqual(bar_class.instance_attrs, {'attr': [assattr]})
def test_nonregr_func_global(self):
code = '''
active_application = None
def get_active_application():
global active_application
return active_application
class Application(object):
def __init__(self):
global active_application
active_application = self
class DataManager(object):
def __init__(self, app=None):
self.app = get_active_application()
def test(self):
p = self.app
print (p)
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(Instance(astroid['DataManager']).igetattr('app'))
self.assertEqual(len(infered), 2, infered) # None / Instance(Application)
infered = list(get_name_node(astroid['DataManager']['test'], 'p').infer())
self.assertEqual(len(infered), 2, infered)
for node in infered:
if isinstance(node, Instance) and node.name == 'Application':
break
else:
self.fail('expected to find an instance of Application in %s' % infered)
def test_except_inference(self):
code = '''
try:
print (hop)
except NameError, ex:
ex1 = ex
except Exception, ex:
ex2 = ex
raise
'''
if sys.version_info >= (3, 0):
code = code.replace(', ex:', ' as ex:')
astroid = builder.string_build(code, __name__, __file__)
ex1 = astroid['ex1']
ex1_infer = ex1.infer()
ex1 = ex1_infer.next()
self.assertIsInstance(ex1, Instance)
self.assertEqual(ex1.name, 'NameError')
self.assertRaises(StopIteration, ex1_infer.next)
ex2 = astroid['ex2']
ex2_infer = ex2.infer()
ex2 = ex2_infer.next()
self.assertIsInstance(ex2, Instance)
self.assertEqual(ex2.name, 'Exception')
self.assertRaises(StopIteration, ex2_infer.next)
def test_except_inference(self):
code = """
try:
print (hop)
except NameError, ex:
ex1 = ex
except Exception, ex:
ex2 = ex
raise
"""
if sys.version_info >= (3, 0):
code = code.replace(", ex:", " as ex:")
astroid = builder.string_build(code, __name__, __file__)
ex1 = astroid["ex1"]
ex1_infer = ex1.infer()
ex1 = ex1_infer.next()
self.assertIsInstance(ex1, Instance)
self.assertEqual(ex1.name, "NameError")
self.assertRaises(StopIteration, ex1_infer.next)
ex2 = astroid["ex2"]
ex2_infer = ex2.infer()
ex2 = ex2_infer.next()
self.assertIsInstance(ex2, Instance)
self.assertEqual(ex2.name, "Exception")
self.assertRaises(StopIteration, ex2_infer.next)
def test_nonregr_func_global(self):
code = """
active_application = None
def get_active_application():
global active_application
return active_application
class Application(object):
def __init__(self):
global active_application
active_application = self
class DataManager(object):
def __init__(self, app=None):
self.app = get_active_application()
def test(self):
p = self.app
print (p)
"""
astroid = builder.string_build(code, __name__, __file__)
infered = list(Instance(astroid["DataManager"]).igetattr("app"))
self.assertEqual(len(infered), 2, infered) # None / Instance(Application)
infered = list(get_name_node(astroid["DataManager"]["test"], "p").infer())
self.assertEqual(len(infered), 2, infered)
for node in infered:
if isinstance(node, Instance) and node.name == "Application":
break
else:
self.fail("expected to find an instance of Application in %s" % infered)
def test_import_as(self):
code = '''
import os.path as osp
print (osp.dirname(__file__))
from os.path import exists as e
assert e(__file__)
from new import code as make_code
print (make_code)
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid.igetattr('osp'))
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.Module)
self.assertEqual(infered[0].name, 'os.path')
infered = list(astroid.igetattr('e'))
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.Function)
self.assertEqual(infered[0].name, 'exists')
if sys.version_info >= (3, 0):
self.skipTest('<new> module has been removed')
infered = list(astroid.igetattr('make_code'))
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], Instance)
self.assertEqual(str(infered[0]), 'Instance of %s.type' % BUILTINS)
def test_list_inference(self):
"""#20464"""
code = '''
import optparse
A = []
B = []
def test():
xyz = [
"foobar=%s" % options.ca,
] + A + B
if options.bind is not None:
xyz.append("bind=%s" % options.bind)
return xyz
def main():
global options
parser = optparse.OptionParser()
(options, args) = parser.parse_args()
Z = test()
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid['Z'].infer())
self.assertEqual(len(infered), 1, infered)
self.assertIsInstance(infered[0], Instance)
self.assertIsInstance(infered[0]._proxied, nodes.Class)
self.assertEqual(infered[0]._proxied.name, 'list')
def test_nonregr_instance_attrs(self):
"""non regression for instance_attrs infinite loop : pylint / #4"""
code = """
class Foo(object):
def set_42(self):
self.attr = 42
class Bar(Foo):
def __init__(self):
self.attr = 41
"""
astroid = builder.string_build(code, __name__, __file__)
foo_class = astroid['Foo']
bar_class = astroid['Bar']
bar_self = astroid['Bar']['__init__']['self']
assattr = bar_class.instance_attrs['attr'][0]
self.assertEqual(len(foo_class.instance_attrs['attr']), 1)
self.assertEqual(len(bar_class.instance_attrs['attr']), 1)
self.assertEqual(bar_class.instance_attrs, {'attr': [assattr]})
# call 'instance_attr' via 'Instance.getattr' to trigger the bug:
instance = bar_self.infered()[0]
_attr = instance.getattr('attr')
self.assertEqual(len(bar_class.instance_attrs['attr']), 1)
self.assertEqual(len(foo_class.instance_attrs['attr']), 1)
self.assertEqual(bar_class.instance_attrs, {'attr': [assattr]})
def test_binary_op_custom_class(self):
code = '''
class myarray:
def __init__(self, array):
self.array = array
def __mul__(self, x):
return myarray([2,4,6])
def astype(self):
return "ASTYPE"
def randint(maximum):
if maximum is not None:
return myarray([1,2,3]) * 2
else:
return int(5)
x = randint(1)
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid.igetattr('x'))
self.assertEqual(len(infered), 2)
value = [str(v) for v in infered]
# The __name__ trick here makes it work when invoked directly
# (__name__ == '__main__') and through pytest (__name__ ==
# 'unittest_inference')
self.assertEqual(value, [
'Instance of %s.myarray' % __name__,
'Instance of %s.int' % BUILTINS
])
def test_list_inference(self):
"""#20464"""
code = '''
import optparse
A = []
B = []
def test():
xyz = [
"foobar=%s" % options.ca,
] + A + B
if options.bind is not None:
xyz.append("bind=%s" % options.bind)
return xyz
def main():
global options
parser = optparse.OptionParser()
(options, args) = parser.parse_args()
Z = test()
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid['Z'].infer())
self.assertEqual(len(infered), 1, infered)
self.assertIsInstance(infered[0], Instance)
self.assertIsInstance(infered[0]._proxied, nodes.Class)
self.assertEqual(infered[0]._proxied.name, 'list')
def test_property(self):
code = """
from smtplib import SMTP
class SendMailController(object):
@property
def smtp(self):
return SMTP(mailhost, port)
@property
def me(self):
return self
my_smtp = SendMailController().smtp
my_me = SendMailController().me
"""
decorators = set(["%s.property" % BUILTINS])
astroid = builder.string_build(code, __name__, __file__)
self.assertEqual(astroid["SendMailController"]["smtp"].decoratornames(), decorators)
propinfered = list(astroid.body[2].value.infer())
self.assertEqual(len(propinfered), 1)
propinfered = propinfered[0]
self.assertIsInstance(propinfered, Instance)
self.assertEqual(propinfered.name, "SMTP")
self.assertEqual(propinfered.root().name, "smtplib")
self.assertEqual(astroid["SendMailController"]["me"].decoratornames(), decorators)
propinfered = list(astroid.body[3].value.infer())
self.assertEqual(len(propinfered), 1)
propinfered = propinfered[0]
self.assertIsInstance(propinfered, Instance)
self.assertEqual(propinfered.name, "SendMailController")
self.assertEqual(propinfered.root().name, __name__)
def test_import_as(self):
code = """
import os.path as osp
print (osp.dirname(__file__))
from os.path import exists as e
assert e(__file__)
from new import code as make_code
print (make_code)
"""
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid.igetattr("osp"))
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.Module)
self.assertEqual(infered[0].name, "os.path")
infered = list(astroid.igetattr("e"))
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.Function)
self.assertEqual(infered[0].name, "exists")
if sys.version_info >= (3, 0):
self.skipTest("<new> module has been removed")
infered = list(astroid.igetattr("make_code"))
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], Instance)
self.assertEqual(str(infered[0]), "Instance of %s.type" % BUILTINS)
def test_simple_for_genexpr(self):
code = """
print ((d,e) for e,d in ([1,2], [3,4]))
"""
astroid = builder.string_build(code, __name__, __file__)
self.assertEqual([i.value for i in get_name_node(astroid, "d", -1).infer()], [2, 4])
self.assertEqual([i.value for i in get_name_node(astroid, "e", -1).infer()], [1, 3])
def test_set_comp_closure(self):
astroid = builder.string_build("""
ten = { var for var in range(10) }
var
""")
var = astroid.body[1].value
self.assertRaises(UnresolvableName, var.infered)
def test_if(self):
astroid = builder.string_build(
"""
if 1:
a = 1
a = 2
elif 2:
a = 12
a = 13
else:
a = 3
a = 4
"""
)
a1 = astroid.locals["a"][0]
a2 = astroid.locals["a"][1]
a3 = astroid.locals["a"][2]
a4 = astroid.locals["a"][3]
a5 = astroid.locals["a"][4]
a6 = astroid.locals["a"][5]
self.assertEqual(are_exclusive(a1, a2), False)
self.assertEqual(are_exclusive(a1, a3), True)
self.assertEqual(are_exclusive(a1, a5), True)
self.assertEqual(are_exclusive(a3, a5), True)
self.assertEqual(are_exclusive(a3, a4), False)
self.assertEqual(are_exclusive(a5, a6), False)
def test_except_inference(self):
code = '''
try:
print (hop)
except NameError, ex:
ex1 = ex
except Exception, ex:
ex2 = ex
raise
'''
if sys.version_info >= (3, 0):
code = code.replace(', ex:', ' as ex:')
astroid = builder.string_build(code, __name__, __file__)
ex1 = astroid['ex1']
ex1_infer = ex1.infer()
ex1 = ex1_infer.next()
self.assertIsInstance(ex1, Instance)
self.assertEqual(ex1.name, 'NameError')
self.assertRaises(StopIteration, ex1_infer.next)
ex2 = astroid['ex2']
ex2_infer = ex2.infer()
ex2 = ex2_infer.next()
self.assertIsInstance(ex2, Instance)
self.assertEqual(ex2.name, 'Exception')
self.assertRaises(StopIteration, ex2_infer.next)
def test_property(self):
code = '''
from smtplib import SMTP
class SendMailController(object):
@property
def smtp(self):
return SMTP(mailhost, port)
@property
def me(self):
return self
my_smtp = SendMailController().smtp
my_me = SendMailController().me
'''
decorators = set(['%s.property' % BUILTINS])
astroid = builder.string_build(code, __name__, __file__)
self.assertEqual(
astroid['SendMailController']['smtp'].decoratornames(), decorators)
propinfered = list(astroid.body[2].value.infer())
self.assertEqual(len(propinfered), 1)
propinfered = propinfered[0]
self.assertIsInstance(propinfered, Instance)
self.assertEqual(propinfered.name, 'SMTP')
self.assertEqual(propinfered.root().name, 'smtplib')
self.assertEqual(astroid['SendMailController']['me'].decoratornames(),
decorators)
propinfered = list(astroid.body[3].value.infer())
self.assertEqual(len(propinfered), 1)
propinfered = propinfered[0]
self.assertIsInstance(propinfered, Instance)
self.assertEqual(propinfered.name, 'SendMailController')
self.assertEqual(propinfered.root().name, __name__)
def test_set_comp_closure(self):
astroid = builder.string_build("""
ten = { var for var in range(10) }
var
""")
var = astroid.body[1].value
self.assertRaises(UnresolvableName, var.infered)
def test_method_argument(self):
code = '''
class ErudiEntitySchema:
"""a entity has a type, a set of subject and or object relations"""
def __init__(self, e_type, **kwargs):
kwargs['e_type'] = e_type.capitalize().encode()
def meth(self, e_type, *args, **kwargs):
kwargs['e_type'] = e_type.capitalize().encode()
print(args)
'''
astroid = builder.string_build(code, __name__, __file__)
arg = get_name_node(astroid['ErudiEntitySchema']['__init__'], 'e_type')
self.assertEqual([n.__class__ for n in arg.infer()],
[YES.__class__])
arg = get_name_node(astroid['ErudiEntitySchema']['__init__'], 'kwargs')
self.assertEqual([n.__class__ for n in arg.infer()],
[nodes.Dict])
arg = get_name_node(astroid['ErudiEntitySchema']['meth'], 'e_type')
self.assertEqual([n.__class__ for n in arg.infer()],
[YES.__class__])
arg = get_name_node(astroid['ErudiEntitySchema']['meth'], 'args')
self.assertEqual([n.__class__ for n in arg.infer()],
[nodes.Tuple])
arg = get_name_node(astroid['ErudiEntitySchema']['meth'], 'kwargs')
self.assertEqual([n.__class__ for n in arg.infer()],
[nodes.Dict])
def test_limit(self):
code = '''
l = [a
for a,b in list]
a = 1
b = a
a = None
def func():
c = 1
'''
astroid = builder.string_build(code, __name__, __file__)
# a & b
a = astroid.nodes_of_class(nodes.Name).next()
self.assertEqual(a.lineno, 2)
if sys.version_info < (3, 0):
self.assertEqual(len(astroid.lookup('b')[1]), 2)
self.assertEqual(len(astroid.lookup('a')[1]), 3)
b = astroid.locals['b'][1]
else:
self.assertEqual(len(astroid.lookup('b')[1]), 1)
self.assertEqual(len(astroid.lookup('a')[1]), 2)
b = astroid.locals['b'][0]
stmts = a.lookup('a')[1]
self.assertEqual(len(stmts), 1)
self.assertEqual(b.lineno, 6)
b_infer = b.infer()
b_value = b_infer.next()
self.assertEqual(b_value.value, 1)
# c
self.assertRaises(StopIteration, b_infer.next)
func = astroid.locals['func'][0]
self.assertEqual(len(func.lookup('c')[1]), 1)
def test_del2(self):
code = '''
a = 1
b = a
del a
c = a
a = 2
d = a
'''
astroid = builder.string_build(code, __name__, __file__)
n = astroid['b']
n_infer = n.infer()
infered = n_infer.next()
self.assertIsInstance(infered, nodes.Const)
self.assertEqual(infered.value, 1)
self.assertRaises(StopIteration, n_infer.next)
n = astroid['c']
n_infer = n.infer()
self.assertRaises(InferenceError, n_infer.next)
n = astroid['d']
n_infer = n.infer()
infered = n_infer.next()
self.assertIsInstance(infered, nodes.Const)
self.assertEqual(infered.value, 2)
self.assertRaises(StopIteration, n_infer.next)
def test_limit(self):
code = '''
l = [a
for a,b in list]
a = 1
b = a
a = None
def func():
c = 1
'''
astroid = builder.string_build(code, __name__, __file__)
# a & b
a = next(astroid.nodes_of_class(nodes.Name))
self.assertEqual(a.lineno, 2)
if sys.version_info < (3, 0):
self.assertEqual(len(astroid.lookup('b')[1]), 2)
self.assertEqual(len(astroid.lookup('a')[1]), 3)
b = astroid.locals['b'][1]
else:
self.assertEqual(len(astroid.lookup('b')[1]), 1)
self.assertEqual(len(astroid.lookup('a')[1]), 2)
b = astroid.locals['b'][0]
stmts = a.lookup('a')[1]
self.assertEqual(len(stmts), 1)
self.assertEqual(b.lineno, 6)
b_infer = b.infer()
b_value = next(b_infer)
self.assertEqual(b_value.value, 1)
# c
self.assertRaises(StopIteration, b_infer.__next__)
func = astroid.locals['func'][0]
self.assertEqual(len(func.lookup('c')[1]), 1)
def test_try_except(self):
astroid = builder.string_build(
"""
try:
def exclusive_func2():
"docstring"
except TypeError:
def exclusive_func2():
"docstring"
except:
def exclusive_func2():
"docstring"
else:
def exclusive_func2():
"this one redefine the one defined line 42"
"""
)
f1 = astroid.locals["exclusive_func2"][0]
f2 = astroid.locals["exclusive_func2"][1]
f3 = astroid.locals["exclusive_func2"][2]
f4 = astroid.locals["exclusive_func2"][3]
self.assertEqual(are_exclusive(f1, f2), True)
self.assertEqual(are_exclusive(f1, f3), True)
self.assertEqual(are_exclusive(f1, f4), False)
self.assertEqual(are_exclusive(f2, f4), True)
self.assertEqual(are_exclusive(f3, f4), True)
self.assertEqual(are_exclusive(f3, f2), True)
self.assertEqual(are_exclusive(f2, f1), True)
self.assertEqual(are_exclusive(f4, f1), False)
self.assertEqual(are_exclusive(f4, f2), True)
def test_del2(self):
code = '''
a = 1
b = a
del a
c = a
a = 2
d = a
'''
astroid = builder.string_build(code, __name__, __file__)
n = astroid['b']
n_infer = n.infer()
infered = n_infer.next()
self.assertIsInstance(infered, nodes.Const)
self.assertEqual(infered.value, 1)
self.assertRaises(StopIteration, n_infer.next)
n = astroid['c']
n_infer = n.infer()
self.assertRaises(InferenceError, n_infer.next)
n = astroid['d']
n_infer = n.infer()
infered = n_infer.next()
self.assertIsInstance(infered, nodes.Const)
self.assertEqual(infered.value, 2)
self.assertRaises(StopIteration, n_infer.next)
def test_binary_op_custom_class(self):
code = '''
class myarray:
def __init__(self, array):
self.array = array
def __mul__(self, x):
return myarray([2,4,6])
def astype(self):
return "ASTYPE"
def randint(maximum):
if maximum is not None:
return myarray([1,2,3]) * 2
else:
return int(5)
x = randint(1)
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid.igetattr('x'))
self.assertEqual(len(infered), 2)
value = [str(v) for v in infered]
# The __name__ trick here makes it work when invoked directly
# (__name__ == '__main__') and through pytest (__name__ ==
# 'unittest_inference')
self.assertEqual(value, ['Instance of %s.myarray' % __name__,
'Instance of %s.int' % BUILTINS])
def test_try_except(self):
astroid = builder.string_build('''
try:
def exclusive_func2():
"docstring"
except TypeError:
def exclusive_func2():
"docstring"
except:
def exclusive_func2():
"docstring"
else:
def exclusive_func2():
"this one redefine the one defined line 42"
''')
f1 = astroid.locals['exclusive_func2'][0]
f2 = astroid.locals['exclusive_func2'][1]
f3 = astroid.locals['exclusive_func2'][2]
f4 = astroid.locals['exclusive_func2'][3]
self.assertEqual(are_exclusive(f1, f2), True)
self.assertEqual(are_exclusive(f1, f3), True)
self.assertEqual(are_exclusive(f1, f4), False)
self.assertEqual(are_exclusive(f2, f4), True)
self.assertEqual(are_exclusive(f3, f4), True)
self.assertEqual(are_exclusive(f3, f2), True)
self.assertEqual(are_exclusive(f2, f1), True)
self.assertEqual(are_exclusive(f4, f1), False)
self.assertEqual(are_exclusive(f4, f2), True)
def test_if(self):
astroid = builder.string_build('''
if 1:
a = 1
a = 2
elif 2:
a = 12
a = 13
else:
a = 3
a = 4
''')
a1 = astroid.locals['a'][0]
a2 = astroid.locals['a'][1]
a3 = astroid.locals['a'][2]
a4 = astroid.locals['a'][3]
a5 = astroid.locals['a'][4]
a6 = astroid.locals['a'][5]
self.assertEqual(are_exclusive(a1, a2), False)
self.assertEqual(are_exclusive(a1, a3), True)
self.assertEqual(are_exclusive(a1, a5), True)
self.assertEqual(are_exclusive(a3, a5), True)
self.assertEqual(are_exclusive(a3, a4), False)
self.assertEqual(are_exclusive(a5, a6), False)
def test_property(self):
code = '''
from smtplib import SMTP
class SendMailController(object):
@property
def smtp(self):
return SMTP(mailhost, port)
@property
def me(self):
return self
my_smtp = SendMailController().smtp
my_me = SendMailController().me
'''
decorators = set(['%s.property' % BUILTINS])
astroid = builder.string_build(code, __name__, __file__)
self.assertEqual(astroid['SendMailController']['smtp'].decoratornames(),
decorators)
propinfered = list(astroid.body[2].value.infer())
self.assertEqual(len(propinfered), 1)
propinfered = propinfered[0]
self.assertIsInstance(propinfered, Instance)
self.assertEqual(propinfered.name, 'SMTP')
self.assertEqual(propinfered.root().name, 'smtplib')
self.assertEqual(astroid['SendMailController']['me'].decoratornames(),
decorators)
propinfered = list(astroid.body[3].value.infer())
self.assertEqual(len(propinfered), 1)
propinfered = propinfered[0]
self.assertIsInstance(propinfered, Instance)
self.assertEqual(propinfered.name, 'SendMailController')
self.assertEqual(propinfered.root().name, __name__)
def test_nonregr_func_global(self):
code = '''
active_application = None
def get_active_application():
global active_application
return active_application
class Application(object):
def __init__(self):
global active_application
active_application = self
class DataManager(object):
def __init__(self, app=None):
self.app = get_active_application()
def test(self):
p = self.app
print (p)
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(Instance(astroid['DataManager']).igetattr('app'))
self.assertEqual(len(infered), 2,
infered) # None / Instance(Application)
infered = list(
get_name_node(astroid['DataManager']['test'], 'p').infer())
self.assertEqual(len(infered), 2, infered)
for node in infered:
if isinstance(node, Instance) and node.name == 'Application':
break
else:
self.fail('expected to find an instance of Application in %s' %
infered)
def test_binary_op_tuple_add(self):
astroid = builder.string_build('a = (1,) + (2,)', __name__, __file__)
infered = list(astroid['a'].infer())
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.Tuple)
self.assertEqual(len(infered[0].elts), 2)
self.assertEqual(infered[0].elts[0].value, 1)
self.assertEqual(infered[0].elts[1].value, 2)
def test_qqch(self):
code = """
from logilab.common.modutils import load_module_from_name
xxx = load_module_from_name('__pkginfo__')
"""
astroid = builder.string_build(code, __name__, __file__)
xxx = astroid["xxx"]
self.assertSetEqual(set(n.__class__ for n in xxx.infered()), set([nodes.Const, YES.__class__]))
def test_binary_op_tuple_add(self):
astroid = builder.string_build('a = (1,) + (2,)', __name__, __file__)
infered = list(astroid['a'].infer())
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.Tuple)
self.assertEqual(len(infered[0].elts), 2)
self.assertEqual(infered[0].elts[0].value, 1)
self.assertEqual(infered[0].elts[1].value, 2)
def test_function_module_special(self):
astroid = builder.string_build('''
def initialize(linter):
"""initialize linter with checkers in this package """
package_load(linter, __path__[0])
''', 'data.__init__', 'data/__init__.py')
path = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == '__path__'][0]
self.assertEqual(len(path.lookup('__path__')[1]), 1)
def test_function_module_special(self):
astroid = builder.string_build('''
def initialize(linter):
"""initialize linter with checkers in this package """
package_load(linter, __path__[0])
''', 'data.__init__', 'data/__init__.py')
path = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == '__path__'][0]
self.assertEqual(len(path.lookup('__path__')[1]), 1)
def test_python25_relative_import(self):
data = "from ...logilab.common import date; print (date)"
# !! FIXME also this relative import would not work 'in real' (no __init__.py in test/)
# the test works since we pretend we have a package by passing the full modname
astroid = builder.string_build(data, 'astroid.test.unittest_inference', __file__)
infered = get_name_node(astroid, 'date').infer().next()
self.assertIsInstance(infered, nodes.Module)
self.assertEqual(infered.name, 'logilab.common.date')
def test_builtin_types_py27(self):
code = "s = {1}"
astroid = builder.string_build(code, __name__, __file__)
n = astroid["s"]
infered = n.infer().next()
self.assertIsInstance(infered, nodes.Set)
self.assertIsInstance(infered, Instance)
self.assertEqual(infered.name, "set")
self.assertIn("remove", infered._proxied.locals)
def test_two_parents_from_same_module(self):
code = '''
from data import nonregr
class Xxx(nonregr.Aaa, nonregr.Ccc):
"doc"
'''
astroid = builder.string_build(code, __name__, __file__)
parents = list(astroid['Xxx'].ancestors())
self.assertEqual(len(parents), 3, parents) # Aaa, Ccc, object
def test_qqch(self):
code = '''
from astroid.modutils import load_module_from_name
xxx = load_module_from_name('__pkginfo__')
'''
astroid = builder.string_build(code, __name__, __file__)
xxx = astroid['xxx']
self.assertSetEqual(set(n.__class__ for n in xxx.infered()),
set([nodes.Const, YES.__class__]))
def test_two_parents_from_same_module(self):
code = '''
from data import nonregr
class Xxx(nonregr.Aaa, nonregr.Ccc):
"doc"
'''
astroid = builder.string_build(code, __name__, __file__)
parents = list(astroid['Xxx'].ancestors())
self.assertEqual(len(parents), 3, parents) # Aaa, Ccc, object
def test_builtin_types_py27(self):
code = 's = {1}'
astroid = builder.string_build(code, __name__, __file__)
n = astroid['s']
infered = n.infer().next()
self.assertIsInstance(infered, nodes.Set)
self.assertIsInstance(infered, Instance)
self.assertEqual(infered.name, 'set')
self.assertIn('remove', infered._proxied.locals)
def test_binary_op_list_mul_none(self):
'test correct handling on list multiplied by None'
astroid = builder.string_build( 'a = [1] * None\nb = [1] * "r"')
infered = astroid['a'].infered()
self.assertEqual(len(infered), 1)
self.assertEqual(infered[0], YES)
infered = astroid['b'].infered()
self.assertEqual(len(infered), 1)
self.assertEqual(infered[0], YES)
def test_python25_generator_exit(self):
sys.stderr = StringIO()
data = "b = {}[str(0)+''].a"
astroid = builder.string_build(data, __name__, __file__)
list(astroid['b'].infer())
output = sys.stderr.getvalue()
# I have no idea how to test for this in another way...
self.assertNotIn("RuntimeError", output, "Exception exceptions.RuntimeError: 'generator ignored GeneratorExit' in <generator object> ignored")
sys.stderr = sys.__stderr__
def test_nonregr_getitem_empty_tuple(self):
code = '''
def f(x):
a = ()[x]
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid['f'].ilookup('a'))
self.assertEqual(len(infered), 1)
self.assertEqual(infered[0], YES)
def test_builtin_types_py27(self):
code = 's = {1}'
astroid = builder.string_build(code, __name__, __file__)
n = astroid['s']
infered = n.infer().next()
self.assertIsInstance(infered, nodes.Set)
self.assertIsInstance(infered, Instance)
self.assertEqual(infered.name, 'set')
self.assertIn('remove', infered._proxied.locals)
def test_binary_op_list_mul(self):
for code in ('a = [[]] * 2', 'a = 2 * [[]]'):
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid['a'].infer())
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.List)
self.assertEqual(len(infered[0].elts), 2)
self.assertIsInstance(infered[0].elts[0], nodes.List)
self.assertIsInstance(infered[0].elts[1], nodes.List)
def test_python25_relative_import(self):
data = "from ...logilab.common import date; print (date)"
# !! FIXME also this relative import would not work 'in real' (no __init__.py in test/)
# the test works since we pretend we have a package by passing the full modname
astroid = builder.string_build(data, 'astroid.test.unittest_inference',
__file__)
infered = get_name_node(astroid, 'date').infer().next()
self.assertIsInstance(infered, nodes.Module)
self.assertEqual(infered.name, 'logilab.common.date')
def test_binary_op_list_mul(self):
for code in ('a = [[]] * 2', 'a = 2 * [[]]'):
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid['a'].infer())
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.List)
self.assertEqual(len(infered[0].elts), 2)
self.assertIsInstance(infered[0].elts[0], nodes.List)
self.assertIsInstance(infered[0].elts[1], nodes.List)
def test_nonregr_getitem_empty_tuple(self):
code = '''
def f(x):
a = ()[x]
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid['f'].ilookup('a'))
self.assertEqual(len(infered), 1)
self.assertEqual(infered[0], YES)
def test_binary_op_list_mul_none(self):
'test correct handling on list multiplied by None'
astroid = builder.string_build('a = [1] * None\nb = [1] * "r"')
infered = astroid['a'].infered()
self.assertEqual(len(infered), 1)
self.assertEqual(infered[0], YES)
infered = astroid['b'].infered()
self.assertEqual(len(infered), 1)
self.assertEqual(infered[0], YES)
def test_simple_for_genexpr(self):
code = '''
print ((d,e) for e,d in ([1,2], [3,4]))
'''
astroid = builder.string_build(code, __name__, __file__)
self.assertEqual(
[i.value for i in get_name_node(astroid, 'd', -1).infer()], [2, 4])
self.assertEqual(
[i.value for i in get_name_node(astroid, 'e', -1).infer()], [1, 3])
def test_qqch(self):
code = '''
from logilab.common.modutils import load_module_from_name
xxx = load_module_from_name('__pkginfo__')
'''
astroid = builder.string_build(code, __name__, __file__)
xxx = astroid['xxx']
self.assertSetEqual(set(n.__class__ for n in xxx.infered()),
set([nodes.Const, YES.__class__]))
def test_set_comps(self):
astroid = builder.string_build("""
print ({ i for i in range(10) })
print ({ i for i in range(10) })
""", __name__, __file__)
xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == 'i']
self.assertEqual(len(xnames[0].lookup('i')[1]), 1)
self.assertEqual(xnames[0].lookup('i')[1][0].lineno, 2)
self.assertEqual(len(xnames[1].lookup('i')[1]), 1)
self.assertEqual(xnames[1].lookup('i')[1][0].lineno, 3)
def test_builtin_open(self):
code = '''
open("toto.txt")
'''
astroid = builder.string_build(code, __name__, __file__)
node = get_name_node(astroid, 'open', -1)
infered = list(node.infer())
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.Function)
self.assertEqual(infered[0].name, 'open')
def test_list_comp_target(self):
"""test the list comprehension target"""
astroid = builder.string_build("""
ten = [ var for var in range(10) ]
var
""")
var = astroid.body[1].value
if sys.version_info < (3, 0):
self.assertEqual(var.infered(), [YES])
else:
self.assertRaises(UnresolvableName, var.infered)
def test_unicode_type(self):
if sys.version_info >= (3, 0):
self.skipTest('unicode removed on py >= 3.0')
code = '''u = u""'''
astroid = builder.string_build(code, __name__, __file__)
n = astroid['u']
infered = n.infer().next()
self.assertIsInstance(infered, nodes.Const)
self.assertIsInstance(infered, Instance)
self.assertEqual(infered.name, 'unicode')
self.assertIn('lower', infered._proxied.locals)
def test_descriptor_are_callable(self):
code = '''
class A:
statm = staticmethod(open)
clsm = classmethod('whatever')
'''
astroid = builder.string_build(code, __name__, __file__)
statm = astroid['A'].igetattr('statm').next()
self.assertTrue(statm.callable())
clsm = astroid['A'].igetattr('clsm').next()
self.assertTrue(clsm.callable())
def test_python25_generator_exit(self):
sys.stderr = StringIO()
data = "b = {}[str(0)+''].a"
astroid = builder.string_build(data, __name__, __file__)
list(astroid['b'].infer())
output = sys.stderr.getvalue()
# I have no idea how to test for this in another way...
self.assertNotIn(
"RuntimeError", output,
"Exception exceptions.RuntimeError: 'generator ignored GeneratorExit' in <generator object> ignored"
)
sys.stderr = sys.__stderr__
def test_nonregr_lambda_arg(self):
code = '''
def f(g = lambda: None):
g().x
'''
astroid = builder.string_build(code, __name__, __file__)
callfuncnode = astroid['f'].body[0].value.expr
infered = list(callfuncnode.infer())
self.assertEqual(len(infered), 2, infered)
infered.remove(YES)
self.assertIsInstance(infered[0], nodes.Const)
self.assertIsNone(infered[0].value)
def test_callfunc_context_func(self):
code = '''
def mirror(arg=None):
return arg
un = mirror(1)
'''
astroid = builder.string_build(code, __name__, __file__)
infered = list(astroid.igetattr('un'))
self.assertEqual(len(infered), 1)
self.assertIsInstance(infered[0], nodes.Const)
self.assertEqual(infered[0].value, 1)
