bee_python 0.0.3 → 0.0.4

data/tools/logilab/logilab/astng/test/unittest_inference.py

@@ -1,1112 +0,0 @@
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU Lesser General Public License as published by the Free Software
-# Foundation; either version 2 of the License, or (at your option) any later
-# version.
-# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
-# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
-# copyright 2003-2010 Sylvain Thenault, all rights reserved.
-# contact mailto:thenault@gmail.com
-#
-# This file is part of logilab-astng.
-#
-# logilab-astng is free software: you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License as published by the
-# Free Software Foundation, either version 2.1 of the License, or (at your
-# option) any later version.
-#
-# logilab-astng is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
-# for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License along
-# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
-
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
-
-# You should have received a copy of the GNU Lesser General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-"""tests for the astng inference capabilities
-"""
-from os.path import join
-import sys
-from StringIO import StringIO
-from logilab.common.testlib import TestCase, unittest_main
-
-from logilab.astng import InferenceError, builder, nodes, inference
-from logilab.astng.bases import YES, Instance, BoundMethod, UnboundMethod, path_wrapper
-
-def get_name_node(start_from, name, index=0):
-    return [n for n in start_from.nodes_of_class(nodes.Name) if n.name == name][index]
-
-def get_node_of_class(start_from, klass):
-    return start_from.nodes_of_class(klass).next()
-
-builder = builder.ASTNGBuilder()
-
-class InferenceUtilsTC(TestCase):
-
-    def test_path_wrapper(self):
-        def infer_default(self, *args):
-            raise InferenceError
-        infer_default = path_wrapper(infer_default)
-        infer_end = path_wrapper(inference.infer_end)
-        self.failUnlessRaises(InferenceError,
-                              infer_default(1).next)
-        self.failUnlessEqual(infer_end(1).next(), 1)
-
-class InferenceTC(TestCase):
-
-    CODE = '''
-import exceptions
-
-class C(object):
-    "new style"
-    attr = 4
-
-    def meth1(self, arg1, optarg=0):
-        var = object()
-        print "yo", arg1, optarg
-        self.iattr = "hop"
-        return var
-
-    def meth2(self):
-        self.meth1(*self.meth3)
-
-    def meth3(self, d=attr):
-        b = self.attr
-        c = self.iattr
-        return b, c
-
-ex = exceptions.Exception("msg")
-v = C().meth1(1)
-m_unbound = C.meth1
-m_bound = C().meth1
-a, b, c = ex, 1, "bonjour"
-[d, e, f] = [ex, 1.0, ("bonjour", v)]
-g, h = f
-i, (j, k) = u"glup", f
-
-a, b= b, a # Gasp !
-'''
-
-    def setUp(self):
-        self.astng = builder.string_build(self.CODE, __name__, __file__)
-
-    def test_module_inference(self):
-        infered = self.astng.infer()
-        obj = infered.next()
-        self.failUnlessEqual(obj.name, __name__)
-        self.failUnlessEqual(obj.root().name, __name__)
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_class_inference(self):
-        infered = self.astng['C'].infer()
-        obj = infered.next()
-        self.failUnlessEqual(obj.name, 'C')
-        self.failUnlessEqual(obj.root().name, __name__)
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_function_inference(self):
-        infered = self.astng['C']['meth1'].infer()
-        obj = infered.next()
-        self.failUnlessEqual(obj.name, 'meth1')
-        self.failUnlessEqual(obj.root().name, __name__)
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_builtin_name_inference(self):
-        infered = self.astng['C']['meth1']['var'].infer()
-        var = infered.next()
-        self.failUnlessEqual(var.name, 'object')
-        self.failUnlessEqual(var.root().name, '__builtin__')
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_tupleassign_name_inference(self):
-        infered = self.astng['a'].infer()
-        exc = infered.next()
-        self.assertIsInstance(exc, Instance)
-        self.failUnlessEqual(exc.name, 'Exception')
-        self.failUnlessEqual(exc.root().name, 'exceptions')
-        self.failUnlessRaises(StopIteration, infered.next)
-        infered = self.astng['b'].infer()
-        const = infered.next()
-        self.assertIsInstance(const, nodes.Const)
-        self.failUnlessEqual(const.value, 1)
-        self.failUnlessRaises(StopIteration, infered.next)
-        infered = self.astng['c'].infer()
-        const = infered.next()
-        self.assertIsInstance(const, nodes.Const)
-        self.failUnlessEqual(const.value, "bonjour")
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_listassign_name_inference(self):
-        infered = self.astng['d'].infer()
-        exc = infered.next()
-        self.assertIsInstance(exc, Instance)
-        self.failUnlessEqual(exc.name, 'Exception')
-        self.failUnlessEqual(exc.root().name, 'exceptions')
-        self.failUnlessRaises(StopIteration, infered.next)
-        infered = self.astng['e'].infer()
-        const = infered.next()
-        self.assertIsInstance(const, nodes.Const)
-        self.failUnlessEqual(const.value, 1.0)
-        self.failUnlessRaises(StopIteration, infered.next)
-        infered = self.astng['f'].infer()
-        const = infered.next()
-        self.assertIsInstance(const, nodes.Tuple)
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_advanced_tupleassign_name_inference1(self):
-        infered = self.astng['g'].infer()
-        const = infered.next()
-        self.assertIsInstance(const, nodes.Const)
-        self.failUnlessEqual(const.value, "bonjour")
-        self.failUnlessRaises(StopIteration, infered.next)
-        infered = self.astng['h'].infer()
-        var = infered.next()
-        self.failUnlessEqual(var.name, 'object')
-        self.failUnlessEqual(var.root().name, '__builtin__')
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_advanced_tupleassign_name_inference2(self):
-        infered = self.astng['i'].infer()
-        const = infered.next()
-        self.assertIsInstance(const, nodes.Const)
-        self.failUnlessEqual(const.value, u"glup")
-        self.failUnlessRaises(StopIteration, infered.next)
-        infered = self.astng['j'].infer()
-        const = infered.next()
-        self.assertIsInstance(const, nodes.Const)
-        self.failUnlessEqual(const.value, "bonjour")
-        self.failUnlessRaises(StopIteration, infered.next)
-        infered = self.astng['k'].infer()
-        var = infered.next()
-        self.failUnlessEqual(var.name, 'object')
-        self.failUnlessEqual(var.root().name, '__builtin__')
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_swap_assign_inference(self):
-        infered = self.astng.locals['a'][1].infer()
-        const = infered.next()
-        self.assertIsInstance(const, nodes.Const)
-        self.failUnlessEqual(const.value, 1)
-        self.failUnlessRaises(StopIteration, infered.next)
-        infered = self.astng.locals['b'][1].infer()
-        exc = infered.next()
-        self.assertIsInstance(exc, Instance)
-        self.failUnlessEqual(exc.name, 'Exception')
-        self.failUnlessEqual(exc.root().name, 'exceptions')
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_getattr_inference1(self):
-        infered = self.astng['ex'].infer()
-        exc = infered.next()
-        self.assertIsInstance(exc, Instance)
-        self.failUnlessEqual(exc.name, 'Exception')
-        self.failUnlessEqual(exc.root().name, 'exceptions')
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_getattr_inference2(self):
-        infered = get_node_of_class(self.astng['C']['meth2'], nodes.Getattr).infer()
-        meth1 = infered.next()
-        self.failUnlessEqual(meth1.name, 'meth1')
-        self.failUnlessEqual(meth1.root().name, __name__)
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_getattr_inference3(self):
-        infered = self.astng['C']['meth3']['b'].infer()
-        const = infered.next()
-        self.assertIsInstance(const, nodes.Const)
-        self.failUnlessEqual(const.value, 4)
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_getattr_inference4(self):
-        infered = self.astng['C']['meth3']['c'].infer()
-        const = infered.next()
-        self.assertIsInstance(const, nodes.Const)
-        self.failUnlessEqual(const.value, "hop")
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_callfunc_inference(self):
-        infered = self.astng['v'].infer()
-        meth1 = infered.next()
-        self.assertIsInstance(meth1, Instance)
-        self.failUnlessEqual(meth1.name, 'object')
-        self.failUnlessEqual(meth1.root().name, '__builtin__')
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_unbound_method_inference(self):
-        infered = self.astng['m_unbound'].infer()
-        meth1 = infered.next()
-        self.assertIsInstance(meth1, UnboundMethod)
-        self.failUnlessEqual(meth1.name, 'meth1')
-        self.failUnlessEqual(meth1.parent.frame().name, 'C')
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_bound_method_inference(self):
-        infered = self.astng['m_bound'].infer()
-        meth1 = infered.next()
-        self.assertIsInstance(meth1, BoundMethod)
-        self.failUnlessEqual(meth1.name, 'meth1')
-        self.failUnlessEqual(meth1.parent.frame().name, 'C')
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_args_default_inference1(self):
-        optarg = get_name_node(self.astng['C']['meth1'], 'optarg')
-        infered = optarg.infer()
-        obj1 = infered.next()
-        self.assertIsInstance(obj1, nodes.Const)
-        self.failUnlessEqual(obj1.value, 0)
-        obj1 = infered.next()
-        self.assertIs(obj1, YES, obj1)
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_args_default_inference2(self):
-        infered = self.astng['C']['meth3'].ilookup('d')
-        obj1 = infered.next()
-        self.assertIsInstance(obj1, nodes.Const)
-        self.failUnlessEqual(obj1.value, 4)
-        obj1 = infered.next()
-        self.assertIs(obj1, YES, obj1)
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_inference_restrictions(self):
-        infered = get_name_node(self.astng['C']['meth1'], 'arg1').infer()
-        obj1 = infered.next()
-        self.assertIs(obj1, YES, obj1)
-        self.failUnlessRaises(StopIteration, infered.next)
-
-    def test_ancestors_inference(self):
-        code = '''
-class A:
-    pass
-
-class A(A):
-    pass
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        a1 = astng.locals['A'][0]
-        a2 = astng.locals['A'][1]
-        a2_ancestors = list(a2.ancestors())
-        self.failUnlessEqual(len(a2_ancestors), 1)
-        self.failUnless(a2_ancestors[0] is a1)
-
-    def test_ancestors_inference2(self):
-        code = '''
-class A:
-    pass
-
-class B(A): pass
-
-class A(B):
-    pass
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        a1 = astng.locals['A'][0]
-        a2 = astng.locals['A'][1]
-        a2_ancestors = list(a2.ancestors())
-        self.failUnlessEqual(len(a2_ancestors), 2)
-        self.failUnless(a2_ancestors[0] is astng.locals['B'][0])
-        self.failUnless(a2_ancestors[1] is a1, a2_ancestors[1])
-
-
-    def test_f_arg_f(self):
-        code = '''
-def f(f=1):
-    return f
-
-a = f()
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        a = astng['a']
-        a_infer = a.infer()
-        self.failUnlessEqual(a_infer.next().value, 1)
-        self.failUnlessRaises(StopIteration, a_infer.next)
-
-    def test_exc_ancestors(self):
-        code = '''
-def f():
-    raise NotImplementedError
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        names = astng.nodes_of_class(nodes.Name)
-        nie = names.next().infer().next()
-        self.assertIsInstance(nie, nodes.Class)
-        nie_ancestors = [c.name for c in nie.ancestors()]
-        if sys.version_info < (2, 5):
-            self.failUnlessEqual(nie_ancestors, ['RuntimeError', 'StandardError', 'Exception'])
-        else:
-            self.failUnlessEqual(nie_ancestors, ['RuntimeError', 'StandardError', 'Exception', 'BaseException', 'object'])
-
-    def test_except_inference(self):
-        code = '''
-try:
-    print hop
-except NameError, ex:
-    ex1 = ex
-except Exception, ex:
-    ex2 = ex
-    raise
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        ex1 = astng['ex1']
-        ex1_infer = ex1.infer()
-        ex1 = ex1_infer.next()
-        self.assertIsInstance(ex1, Instance)
-        self.failUnlessEqual(ex1.name, 'NameError')
-        self.failUnlessRaises(StopIteration, ex1_infer.next)
-        ex2 = astng['ex2']
-        ex2_infer = ex2.infer()
-        ex2 = ex2_infer.next()
-        self.assertIsInstance(ex2, Instance)
-        self.failUnlessEqual(ex2.name, 'Exception')
-        self.failUnlessRaises(StopIteration, ex2_infer.next)
-
-    def test_del1(self):
-        code = '''
-del undefined_attr
-        '''
-        delete = builder.string_build(code, __name__, __file__).body[0]
-        self.failUnlessRaises(InferenceError, delete.infer)
-
-    def test_del2(self):
-        code = '''
-a = 1
-b = a
-del a
-c = a
-a = 2
-d = a
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        n = astng['b']
-        n_infer = n.infer()
-        infered = n_infer.next()
-        self.assertIsInstance(infered, nodes.Const)
-        self.failUnlessEqual(infered.value, 1)
-        self.failUnlessRaises(StopIteration, n_infer.next)
-        n = astng['c']
-        n_infer = n.infer()
-        self.failUnlessRaises(InferenceError, n_infer.next)
-        n = astng['d']
-        n_infer = n.infer()
-        infered = n_infer.next()
-        self.assertIsInstance(infered, nodes.Const)
-        self.failUnlessEqual(infered.value, 2)
-        self.failUnlessRaises(StopIteration, n_infer.next)
-
-    def test_builtin_types(self):
-        code = '''
-l = [1]
-t = (2,)
-d = {}
-s = ''
-u = u''
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        n = astng['l']
-        infered = n.infer().next()
-        self.assertIsInstance(infered, nodes.List)
-        self.assertIsInstance(infered, Instance)
-        self.failUnlessEqual(infered.getitem(0).value, 1)
-        self.assertIsInstance(infered._proxied, nodes.Class)
-        self.failUnlessEqual(infered._proxied.name, 'list')
-        self.failUnless('append' in infered._proxied.locals)
-        n = astng['t']
-        infered = n.infer().next()
-        self.assertIsInstance(infered, nodes.Tuple)
-        self.assertIsInstance(infered, Instance)
-        self.failUnlessEqual(infered.getitem(0).value, 2)
-        self.assertIsInstance(infered._proxied, nodes.Class)
-        self.failUnlessEqual(infered._proxied.name, 'tuple')
-        n = astng['d']
-        infered = n.infer().next()
-        self.assertIsInstance(infered, nodes.Dict)
-        self.assertIsInstance(infered, Instance)
-        self.assertIsInstance(infered._proxied, nodes.Class)
-        self.failUnlessEqual(infered._proxied.name, 'dict')
-        self.failUnless('get' in infered._proxied.locals)
-        n = astng['s']
-        infered = n.infer().next()
-        self.assertIsInstance(infered, nodes.Const)
-        self.assertIsInstance(infered, Instance)
-        self.failUnlessEqual(infered.name, 'str')
-        self.failUnless('lower' in infered._proxied.locals)
-        n = astng['u']
-        infered = n.infer().next()
-        self.assertIsInstance(infered, nodes.Const)
-        self.assertIsInstance(infered, Instance)
-        self.failUnlessEqual(infered.name, 'unicode')
-        self.failUnless('lower' in infered._proxied.locals)
-
-    def test_descriptor_are_callable(self):
-        code = '''
-class A:
-    statm = staticmethod(open)
-    clsm = classmethod('whatever')
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        statm = astng['A'].igetattr('statm').next()
-        self.failUnless(statm.callable())
-        clsm = astng['A'].igetattr('clsm').next()
-        self.failUnless(clsm.callable())
-
-    def test_bt_ancestor_crash(self):
-        code = '''
-class Warning(Warning):
-    pass
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        w = astng['Warning']
-        ancestors = w.ancestors()
-        ancestor = ancestors.next()
-        self.failUnlessEqual(ancestor.name, 'Warning')
-        self.failUnlessEqual(ancestor.root().name, 'exceptions')
-        ancestor = ancestors.next()
-        self.failUnlessEqual(ancestor.name, 'Exception')
-        self.failUnlessEqual(ancestor.root().name, 'exceptions')
-        if sys.version_info >= (2, 5):
-            ancestor = ancestors.next()
-            self.failUnlessEqual(ancestor.name, 'BaseException')
-            self.failUnlessEqual(ancestor.root().name, 'exceptions')
-            ancestor = ancestors.next()
-            self.failUnlessEqual(ancestor.name, 'object')
-            self.failUnlessEqual(ancestor.root().name, '__builtin__')
-        self.failUnlessRaises(StopIteration, ancestors.next)
-
-    def test_qqch(self):
-        code = '''
-from logilab.common.modutils import load_module_from_name
-xxx = load_module_from_name('__pkginfo__')
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        xxx = astng['xxx']
-        infered = list(xxx.infer())
-        self.failUnlessEqual(sorted([n.__class__ for n in infered]),
-                             sorted([nodes.Const, YES.__class__]))
-
-    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
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        arg = get_name_node(astng['ErudiEntitySchema']['__init__'], 'e_type')
-        self.failUnlessEqual([n.__class__ for n in arg.infer()],
-                             [YES.__class__])
-        arg = get_name_node(astng['ErudiEntitySchema']['__init__'], 'kwargs')
-        self.failUnlessEqual([n.__class__ for n in arg.infer()],
-                             [nodes.Dict])
-        arg = get_name_node(astng['ErudiEntitySchema']['meth'], 'e_type')
-        self.failUnlessEqual([n.__class__ for n in arg.infer()],
-                             [YES.__class__])
-        arg = get_name_node(astng['ErudiEntitySchema']['meth'], 'args')
-        self.failUnlessEqual([n.__class__ for n in arg.infer()],
-                             [nodes.Tuple])
-        arg = get_name_node(astng['ErudiEntitySchema']['meth'], 'kwargs')
-        self.failUnlessEqual([n.__class__ for n in arg.infer()],
-                             [nodes.Dict])
-
-
-    def test_tuple_then_list(self):
-        code = '''
-def test_view(rql, vid, tags=()):
-    tags = list(tags)
-    tags.append(vid)
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        name = get_name_node(astng['test_view'], 'tags', -1)
-        it = name.infer()
-        tags = it.next()
-        self.failUnlessEqual(tags.__class__, Instance)
-        self.failUnlessEqual(tags._proxied.name, 'list')
-        self.failUnlessRaises(StopIteration, it.next)
-
-
-
-    def test_mulassign_inference(self):
-        code = '''
-
-def first_word(line):
-    """Return the first word of a line"""
-
-    return line.split()[0]
-
-def last_word(line):
-    """Return last word of a line"""
-
-    return line.split()[-1]
-
-def process_line(word_pos):
-    """Silly function: returns (ok, callable) based on argument.
-
-       For test purpose only.
-    """
-
-    if word_pos > 0:
-        return (True, first_word)
-    elif word_pos < 0:
-        return  (True, last_word)
-    else:
-        return (False, None)
-
-if __name__ == '__main__':
-
-    line_number = 0
-    for a_line in file('test_callable.py'):
-        tupletest  = process_line(line_number)
-        (ok, fct)  = process_line(line_number)
-        if ok:
-            fct(a_line)
-'''
-        astng = builder.string_build(code, __name__, __file__)
-        self.failUnlessEqual(len(list(astng['process_line'].infer_call_result(
-                                                                None))), 3)
-        self.failUnlessEqual(len(list(astng['tupletest'].infer())), 3)
-        values = ['Function(first_word)', 'Function(last_word)', 'Const(NoneType)']
-        self.failUnlessEqual([str(infered)
-                              for infered in astng['fct'].infer()], values)
-
-    def test_float_complex_ambiguity(self):
-        code = '''
-def no_conjugate_member(magic_flag):
-    """should not raise E1101 on something.conjugate"""
-    if magic_flag:
-        something = 1.0
-    else:
-        something = 1.0j
-    if isinstance(something, float):
-        return something
-    return something.conjugate()
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        self.failUnlessEqual([i.value for i in
-            astng['no_conjugate_member'].ilookup('something')], [1.0, 1.0j])
-        self.failUnlessEqual([i.value for i in
-                get_name_node(astng, 'something', -1).infer()], [1.0, 1.0j])
-
-    def test_lookup_cond_branches(self):
-        code = '''
-def no_conjugate_member(magic_flag):
-    """should not raise E1101 on something.conjugate"""
-    something = 1.0
-    if magic_flag:
-        something = 1.0j
-    return something.conjugate()
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        self.failUnlessEqual([i.value for i in
-                get_name_node(astng, 'something', -1).infer()], [1.0, 1.0j])
-
-
-    def test_simple_subscript(self):
-        code = '''
-a = [1, 2, 3][0]
-b = (1, 2, 3)[1]
-c = (1, 2, 3)[-1]
-d = a + b + c
-print d
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        self.failUnlessEqual([i.value for i in
-                                get_name_node(astng, 'a', -1).infer()], [1])
-        self.failUnlessEqual([i.value for i in
-                                get_name_node(astng, 'b', -1).infer()], [2])
-        self.failUnlessEqual([i.value for i in
-                                get_name_node(astng, 'c', -1).infer()], [3])
-        self.failUnlessEqual([i.value for i in
-                                get_name_node(astng, 'd', -1).infer()], [6])
-
-    #def test_simple_tuple(self):
-        #"""test case for a simple tuple value"""
-        ## XXX tuple inference is not implemented ...
-        #code = """
-#a = (1,)
-#b = (22,)
-#some = a + b
-#"""
-        #astng = builder.string_build(code, __name__, __file__)
-        #self.failUnlessEqual(astng['some'].infer.next().as_string(), "(1, 22)")
-
-    def test_simple_for(self):
-        code = '''
-for a in [1, 2, 3]:
-    print a
-for b,c in [(1,2), (3,4)]:
-    print b
-    print c
-
-print [(d,e) for e,d in ([1,2], [3,4])]
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        self.failUnlessEqual([i.value for i in
-                            get_name_node(astng, 'a', -1).infer()], [1, 2, 3])
-        self.failUnlessEqual([i.value for i in
-                            get_name_node(astng, 'b', -1).infer()], [1, 3])
-        self.failUnlessEqual([i.value for i in
-                            get_name_node(astng, 'c', -1).infer()], [2, 4])
-        self.failUnlessEqual([i.value for i in
-                            get_name_node(astng, 'd', -1).infer()], [2, 4])
-        self.failUnlessEqual([i.value for i in
-                            get_name_node(astng, 'e', -1).infer()], [1, 3])
-
-
-    def test_simple_for_genexpr(self):
-        if sys.version_info < (2, 4):
-            return
-        code = '''
-print ((d,e) for e,d in ([1,2], [3,4]))
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        self.failUnlessEqual([i.value for i in
-                            get_name_node(astng, 'd', -1).infer()], [2, 4])
-        self.failUnlessEqual([i.value for i in
-                            get_name_node(astng, 'e', -1).infer()], [1, 3])
-
-
-    def test_builtin_help(self):
-        code = '''
-help()
-        '''
-        # XXX failing with python > 2.3 since __builtin__.help assignment has
-        #     been moved into a function...
-        astng = builder.string_build(code, __name__, __file__)
-        node = get_name_node(astng, 'help', -1)
-        infered = list(node.infer())
-        self.failUnlessEqual(len(infered), 1, infered)
-        self.assertIsInstance(infered[0], Instance)
-        self.failUnlessEqual(str(infered[0]),
-                             'Instance of site._Helper')
-
-    def test_builtin_open(self):
-        code = '''
-open("toto.txt")
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        node = get_name_node(astng, 'open', -1)
-        infered = list(node.infer())
-        self.failUnlessEqual(len(infered), 1)
-        if open is file:
-            # On python < 2.5 open and file are the same thing.
-            self.assertIsInstance(infered[0], nodes.Class)
-            self.failUnlessEqual(infered[0].name, 'file')
-        else:
-            # On python >= 2.5 open is a builtin function.
-            self.assertIsInstance(infered[0], nodes.Function)
-            self.failUnlessEqual(infered[0].name, 'open')
-
-    def test_callfunc_context_func(self):
-        code = '''
-def mirror(arg=None):
-    return arg
-
-un = mirror(1)
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        infered = list(astng.igetattr('un'))
-        self.failUnlessEqual(len(infered), 1)
-        self.assertIsInstance(infered[0], nodes.Const)
-        self.failUnlessEqual(infered[0].value, 1)
-
-    def test_callfunc_context_lambda(self):
-        code = '''
-mirror = lambda x=None: x
-
-un = mirror(1)
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        infered = list(astng.igetattr('mirror'))
-        self.failUnlessEqual(len(infered), 1)
-        self.assertIsInstance(infered[0], nodes.Lambda)
-        infered = list(astng.igetattr('un'))
-        self.failUnlessEqual(len(infered), 1)
-        self.assertIsInstance(infered[0], nodes.Const)
-        self.failUnlessEqual(infered[0].value, 1)
-
-    def test_factory_method(self):
-        if sys.version_info < (2, 4):
-            self.skip('this test require python >= 2.4')
-        code = '''
-class Super(object):
-      @classmethod
-      def instance(cls):
-              return cls()
-
-class Sub(Super):
-      def method(self):
-              print 'method called'
-
-sub = Sub.instance()
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        infered = list(astng.igetattr('sub'))
-        self.failUnlessEqual(len(infered), 1)
-        self.assertIsInstance(infered[0], Instance)
-        self.failUnlessEqual(infered[0]._proxied.name, 'Sub')
-
-
-    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
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        infered = list(astng.igetattr('osp'))
-        self.failUnlessEqual(len(infered), 1)
-        self.assertIsInstance(infered[0], nodes.Module)
-        self.failUnlessEqual(infered[0].name, 'os.path')
-        infered = list(astng.igetattr('e'))
-        self.failUnlessEqual(len(infered), 1)
-        self.assertIsInstance(infered[0], nodes.Function)
-        self.failUnlessEqual(infered[0].name, 'exists')
-        infered = list(astng.igetattr('make_code'))
-        self.failUnlessEqual(len(infered), 1)
-        self.assertIsInstance(infered[0], Instance)
-        self.failUnlessEqual(str(infered[0]), 'Instance of __builtin__.type')
-
-    def _test_const_infered(self, node, value):
-        infered = list(node.infer())
-        self.failUnlessEqual(len(infered), 1)
-        self.assertIsInstance(infered[0], nodes.Const)
-        self.failUnlessEqual(infered[0].value, value)
-
-    def test_unary_not(self):
-        for code in ('a = not (1,); b = not ()',
-                     'a = not {1:2}; b = not {}'):
-            astng = builder.string_build(code, __name__, __file__)
-            self._test_const_infered(astng['a'], False)
-            self._test_const_infered(astng['b'], True)
-
-    def test_binary_op_int_add(self):
-        astng = builder.string_build('a = 1 + 2', __name__, __file__)
-        self._test_const_infered(astng['a'], 3)
-
-    def test_binary_op_int_sub(self):
-        astng = builder.string_build('a = 1 - 2', __name__, __file__)
-        self._test_const_infered(astng['a'], -1)
-
-    def test_binary_op_float_div(self):
-        astng = builder.string_build('a = 1 / 2.', __name__, __file__)
-        self._test_const_infered(astng['a'], 1 / 2.)
-
-    def test_binary_op_str_mul(self):
-        astng = builder.string_build('a = "*" * 40', __name__, __file__)
-        self._test_const_infered(astng['a'], "*" * 40)
-
-    def test_binary_op_bitand(self):
-        astng = builder.string_build('a = 23&20', __name__, __file__)
-        self._test_const_infered(astng['a'], 23&20)
-
-    def test_binary_op_bitor(self):
-        astng = builder.string_build('a = 23|8', __name__, __file__)
-        self._test_const_infered(astng['a'], 23|8)
-
-    def test_binary_op_bitxor(self):
-        astng = builder.string_build('a = 23^9', __name__, __file__)
-        self._test_const_infered(astng['a'], 23^9)
-
-    def test_binary_op_shiftright(self):
-        astng = builder.string_build('a = 23 >>1', __name__, __file__)
-        self._test_const_infered(astng['a'], 23>>1)
-
-    def test_binary_op_shiftleft(self):
-        astng = builder.string_build('a = 23 <<1', __name__, __file__)
-        self._test_const_infered(astng['a'], 23<<1)
-
-
-    def test_binary_op_list_mul(self):
-        for code in ('a = [[]] * 2', 'a = 2 * [[]]'):
-            astng = builder.string_build(code, __name__, __file__)
-            infered = list(astng['a'].infer())
-            self.failUnlessEqual(len(infered), 1)
-            self.assertIsInstance(infered[0], nodes.List)
-            self.failUnlessEqual(len(infered[0].elts), 2)
-            self.assertIsInstance(infered[0].elts[0], nodes.List)
-            self.assertIsInstance(infered[0].elts[1], nodes.List)
-
-    def test_binary_op_tuple_add(self):
-        astng = builder.string_build('a = (1,) + (2,)', __name__, __file__)
-        infered = list(astng['a'].infer())
-        self.failUnlessEqual(len(infered), 1)
-        self.assertIsInstance(infered[0], nodes.Tuple)
-        self.failUnlessEqual(len(infered[0].elts), 2)
-        self.failUnlessEqual(infered[0].elts[0].value, 1)
-        self.failUnlessEqual(infered[0].elts[1].value, 2)
-
-    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)
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        infered = list(astng.igetattr('x'))
-        self.failUnlessEqual(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.assertEquals(value, ['Instance of %s.myarray' % (__name__,),
-                                  'Instance of __builtin__.int'])
-
-    def test_nonregr_lambda_arg(self):
-        code = '''
-def f(g = lambda: None):
-        g().x
-'''
-        astng = builder.string_build(code, __name__, __file__)
-        callfuncnode = astng['f'].body[0].value.expr
-        infered = list(callfuncnode.infer())
-        self.failUnlessEqual(len(infered), 2, infered)
-        infered.remove(YES)
-        self.assertIsInstance(infered[0], nodes.Const)
-        self.failUnlessEqual(infered[0].value, None)
-
-    def test_nonregr_getitem_empty_tuple(self):
-        code = '''
-def f(x):
-        a = ()[x]
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        infered = list(astng['f'].ilookup('a'))
-        self.failUnlessEqual(len(infered), 1)
-        self.failUnlessEqual(infered[0], YES)
-
-    def test_python25_generator_exit(self):
-        sys.stderr = StringIO()
-        data = "b = {}[str(0)+''].a"
-        astng = builder.string_build(data, __name__, __file__)
-        list(astng['b'].infer())
-        output = sys.stderr.getvalue()
-        # I have no idea how to test for this in another way...
-        self.failIf("RuntimeError" in output, "Exception exceptions.RuntimeError: 'generator ignored GeneratorExit' in <generator object> ignored")
-        sys.stderr = sys.__stderr__
-
-    def test_python25_relative_import(self):
-        if sys.version_info < (2, 5):
-            self.skip('require py >= 2.5')
-        data = "from ...common import date; print date"
-        astng = builder.string_build(data, 'logilab.astng.test.unittest_inference', __file__)
-        infered = get_name_node(astng, 'date').infer().next()
-        self.assertIsInstance(infered, nodes.Module)
-        self.assertEquals(infered.name, 'logilab.common.date')
-
-    def test_python25_no_relative_import(self):
-        if sys.version_info < (2, 5):
-            self.skip('require py >= 2.5')
-        # data = 'import unittest_lookup; print unittest_lookup'
-        # astng = builder.string_build(data, 'logilab.astng.test.unittest_inference', __file__)
-        # self.failIf(astng.absolute_import_activated())
-        # infered = get_name_node(astng, 'unittest_lookup').infer().next()
-        # self.assertIsInstance(infered, nodes.Module)
-        data = 'from __future__ import absolute_import; import unittest_lookup; print unittest_lookup'
-        astng = builder.file_build(join('regrtest_data', 'absimport.py'), 'absimport')
-        self.failUnless(astng.absolute_import_activated(), True)
-        infered = get_name_node(astng, 'import_package_subpackage_module').infer().next()
-        # failed to import since absolute_import is activated
-        self.failUnless(infered is YES)
-
-#     def test_mechanize_open(self):
-#         try:
-#             import mechanize
-#         except ImportError:
-#             self.skip('require mechanize installed')
-#         data = '''from mechanize import Browser
-# print Browser
-# b = Browser()
-# print b
-# '''
-#         astng = builder.string_build(data, __name__, __file__)
-#         browser = get_name_node(astng, 'Browser').infer().next()
-#         self.assertIsInstance(browser, nodes.Class)
-#         print '*'*80
-#         bopen = list(browser.igetattr('open'))
-#         self.assertEquals(len(bopen), 1)
-#         self.assertIsInstance(bopen[0], nodes.Function)
-#         self.failUnless(bopen[0].callable())
-#         print '*'*80
-#         b = get_name_node(astng, 'b').infer().next()
-#         self.assertIsInstance(b, Instance)
-#         bopen = list(b.igetattr('open'))
-#         self.assertEquals(len(bopen), 1)
-#         self.assertIsInstance(bopen[0], BoundMethod)
-#         self.failUnless(bopen[0].callable())
-
-    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
-
-print SendMailController().smtp
-print SendMailController().me
-'''
-        astng = builder.string_build(code, __name__, __file__)
-        self.assertEquals(astng['SendMailController']['smtp'].decoratornames(),
-                          set(('__builtin__.property',)))
-        propinfered = list(astng.body[2].values[0].infer())
-        self.assertEquals(len(propinfered), 1)
-        propinfered = propinfered[0]
-        self.assertIsInstance(propinfered, Instance)
-        self.assertEquals(propinfered.name, 'SMTP')
-        self.assertEquals(propinfered.root().name, 'smtplib')
-        self.assertEquals(astng['SendMailController']['me'].decoratornames(),
-                          set(('__builtin__.property',)))
-        propinfered = list(astng.body[3].values[0].infer())
-        self.assertEquals(len(propinfered), 1)
-        propinfered = propinfered[0]
-        self.assertIsInstance(propinfered, Instance)
-        self.assertEquals(propinfered.name, 'SendMailController')
-        self.assertEquals(propinfered.root().name, __name__)
-
-
-    def test_im_func_unwrap(self):
-        code = '''
-class EnvBasedTC:
-    def pactions(self):
-        print "hop"
-pactions = EnvBasedTC.pactions.im_func
-print pactions
-
-class EnvBasedTC2:
-    pactions = EnvBasedTC.pactions.im_func
-    print pactions
-
-'''
-        astng = builder.string_build(code, __name__, __file__)
-        pactions = get_name_node(astng, 'pactions')
-        infered = list(pactions.infer())
-        self.assertEquals(len(infered), 1)
-        self.assertIsInstance(infered[0], nodes.Function)
-        pactions = get_name_node(astng['EnvBasedTC2'], 'pactions')
-        infered = list(pactions.infer())
-        self.assertEquals(len(infered), 1)
-        self.assertIsInstance(infered[0], nodes.Function)
-
-    def test_augassign(self):
-        code = '''
-a = 1
-a += 2
-print a
-'''
-        astng = builder.string_build(code, __name__, __file__)
-        infered = list(get_name_node(astng, 'a').infer())
-
-        self.assertEquals(len(infered), 1)
-        self.assertIsInstance(infered[0], nodes.Const)
-        self.assertEquals(infered[0].value, 3)
-
-    def test_nonregr_func_arg(self):
-        code = '''
-def foo(self, bar):
-    def baz():
-        pass
-    def qux():
-        return baz
-    spam = bar(None, qux)
-    print spam
-'''
-        astng = builder.string_build(code, __name__, __file__)
-        infered = list(get_name_node(astng['foo'], 'spam').infer())
-        self.assertEquals(len(infered), 1)
-        self.assertIs(infered[0], YES)
-
-    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
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        infered = list(Instance(astng['DataManager']).igetattr('app'))
-        self.assertEquals(len(infered), 2, infered) # None / Instance(Application)
-        infered = list(get_name_node(astng['DataManager']['test'], 'p').infer())
-        self.assertEquals(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_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()
-        '''
-        astng = builder.string_build(code, __name__, __file__)
-        infered = list(astng['Z'].infer())
-        self.assertEquals(len(infered), 1, infered)
-        self.assertIsInstance(infered[0], Instance)
-        self.assertIsInstance(infered[0]._proxied, nodes.Class)
-        self.assertEquals(infered[0]._proxied.name, 'list')
-
-if __name__ == '__main__':
-    unittest_main()