diff options
| -rw-r--r-- | .hgtags | 2 | ||||
| -rw-r--r-- | ChangeLog | 7 | ||||
| -rw-r--r-- | __pkginfo__.py | 2 | ||||
| -rw-r--r-- | _nodes_compiler.py | 14 | ||||
| -rw-r--r-- | bases.py | 4 | ||||
| -rw-r--r-- | builder.py | 2 | ||||
| -rw-r--r-- | debian/changelog | 6 | ||||
| -rw-r--r-- | mixins.py | 3 | ||||
| -rw-r--r-- | node_classes.py | 8 | ||||
| -rw-r--r-- | nodes.py | 14 | ||||
| -rw-r--r-- | nodes_as_string.py | 6 | ||||
| -rw-r--r-- | raw_building.py | 1 | ||||
| -rw-r--r-- | rebuilder.py | 4 | ||||
| -rw-r--r-- | scoped_nodes.py | 15 | ||||
| -rw-r--r-- | test/regrtest.py | 16 | ||||
| -rw-r--r-- | test/unittest_builder.py | 260 | ||||
| -rw-r--r-- | test/unittest_inference.py | 50 | ||||
| -rw-r--r-- | test/unittest_lookup.py | 56 | ||||
| -rw-r--r-- | test/unittest_manager.py | 40 | ||||
| -rw-r--r-- | test/unittest_nodes.py | 86 | ||||
| -rw-r--r-- | test/unittest_scoped_nodes.py | 172 | ||||
| -rw-r--r-- | test/unittest_utils.py | 34 | ||||
| -rw-r--r-- | utils.py | 2 |
23 files changed, 410 insertions, 394 deletions
@@ -21,3 +21,5 @@ f7b51764cde673f8775522decb19f97a939c5b70 logilab-astng-version-0.20.1 c863d9cc6c48a2588a18f75c4a3434a91aa121c7 logilab-astng-debian-version-0.20.1-1 85f38bd9cd775d1916691d5953356a73dea488e3 logilab-astng-version-0.20.2 83a9e1804d17ada2234b5cceac6a77cd867e645f logilab-astng-debian-version-0.20.2-1 +24cc9d8273ce8c15e7e73020aa3ed2d8c4d6b76d logilab-astng-version-0.20.3 +f2022f47efb0d0d9d41cd6f1e4445d51fac204dc logilab-astng-debian-version-0.20.3-1 @@ -1,6 +1,13 @@ Change log for the astng package ================================ + -- + * restored python 2.3 compatibility + + * fix #45959: AttributeError: 'NoneType' object has no attribute 'frame', due + to handling of __class__ when importing from living object (because of missing + source code or C-compiled object) + 2010-09-10 -- 0.20.2 * fix astng building bug: we've to set module.package flag at the node creation time otherwise we'll miss this information when infering relative diff --git a/__pkginfo__.py b/__pkginfo__.py index 2b50fa99..e23bd1ca 100644 --- a/__pkginfo__.py +++ b/__pkginfo__.py @@ -24,7 +24,7 @@ distname = 'logilab-astng' modname = 'astng' subpackage_of = 'logilab' -numversion = (0, 20, 2) +numversion = (0, 20, 3) version = '.'.join([str(num) for num in numversion]) install_requires = ['logilab-common >= 0.49.0'] diff --git a/_nodes_compiler.py b/_nodes_compiler.py index 506fbdc2..54766689 100644 --- a/_nodes_compiler.py +++ b/_nodes_compiler.py @@ -33,12 +33,12 @@ [1] http://docs.python.org/lib/module-compiler.ast.html - """ __docformat__ = "restructuredtext en" -from compiler.ast import Const, Node, Sliceobj +from compiler.ast import Const, Node, Sliceobj, Function +import sys # nodes which are not part of astng from compiler.ast import And as _And, Or as _Or,\ @@ -51,7 +51,7 @@ from compiler.ast import And as _And, Or as _Or,\ from logilab.astng import nodes as new from logilab.astng.rebuilder import RebuildVisitor - +from logilab.common.compat import set CONST_NAME_TRANSFORMS = {'None': None, 'True': True, @@ -399,9 +399,10 @@ class TreeRebuilder(RebuildVisitor): def visit_discard(self, node, parent): """visit a Discard node by returning a fresh instance of it""" newnode = new.Discard() - if node.lineno is None: + if sys.version_info >= (2, 4) and node.lineno is None: # ignore dummy Discard introduced when a statement # is ended by a semi-colon: remove it at the end of rebuilding + # however, it does also happen in regular Discard nodes on 2.3 self._remove_nodes.append((newnode, parent)) self._set_infos(node, newnode, parent) self.asscontext = "Dis" @@ -457,7 +458,8 @@ class TreeRebuilder(RebuildVisitor): """visit a Function node by returning a fresh instance of it""" newnode = new.Function(node.name, node.doc) self._set_infos(node, newnode, parent) - newnode.decorators = self.visit(node.decorators, newnode) + if hasattr(node, 'decorators'): + newnode.decorators = self.visit(node.decorators, newnode) newnode.args = self.visit_arguments(node, newnode) newnode.body = [self.visit(child, newnode) for child in node.code.nodes] return newnode @@ -480,7 +482,7 @@ class TreeRebuilder(RebuildVisitor): newnode.expr = self.visit(node.expr, newnode) newnode.attrname = node.attrname return newnode - + def visit_if(self, node, parent): """visit an If node by returning a fresh instance of it""" newnode = subnode = new.If() @@ -51,8 +51,8 @@ except ImportError: pass from logilab.common.compat import set -from logilab.astng._exceptions import (InferenceError, ASTNGError, - NotFoundError, UnresolvableName) +from logilab.astng._exceptions import InferenceError, ASTNGError, \ + NotFoundError, UnresolvableName class Proxy(BaseClass): @@ -190,6 +190,8 @@ class ASTNGBuilder: class_node = object_build_class(node, member, name) # recursion self.object_build(class_node, member) + if name == '__class__' and class_node.parent is None: + class_node.parent = self._done[self._module] elif ismethoddescriptor(member): assert isinstance(member, object) object_build_methoddescriptor(node, member, name) diff --git a/debian/changelog b/debian/changelog index aed93630..d6763e60 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,9 @@ +logilab-astng (0.20.3-1) unstable; urgency=low + + * new upstream release + + -- Sylvain Thénault <sylvain.thenault@logilab.fr> Tue, 28 Sep 2010 14:30:03 +0200 + logilab-astng (0.20.2-1) unstable; urgency=low * new upstream release @@ -33,8 +33,7 @@ """ -from logilab.astng import (ASTNGBuildingException, InferenceError, - NotFoundError) +from logilab.astng import ASTNGBuildingException, InferenceError, NotFoundError from logilab.astng.bases import BaseClass # /!\ We cannot build a StmtNode(NodeNG) class since modifying "__bases__" diff --git a/node_classes.py b/node_classes.py index c5e4dcec..c9311759 100644 --- a/node_classes.py +++ b/node_classes.py @@ -23,10 +23,10 @@ from logilab.common.compat import chain, imap from logilab.astng import NoDefault -from logilab.astng.bases import (NodeNG, BaseClass, Instance, copy_context, - _infer_stmts, YES) -from logilab.astng.mixins import (StmtMixIn, BlockRangeMixIn, AssignTypeMixin, - ParentAssignTypeMixin, FromImportMixIn) +from logilab.astng.bases import NodeNG, BaseClass, Instance, copy_context, \ + _infer_stmts, YES +from logilab.astng.mixins import StmtMixIn, BlockRangeMixIn, AssignTypeMixin, \ + ParentAssignTypeMixin, FromImportMixIn def unpack_infer(stmt, context=None): """return an iterator on nodes inferred by the given statement if the @@ -51,13 +51,13 @@ on From and Import : __docformat__ = "restructuredtext en" -from logilab.astng.node_classes import (Arguments, AssAttr, Assert, - Assign, AssName, AugAssign, Backquote, BinOp, BoolOp, Break, CallFunc, Compare, - Comprehension, Const, Continue, Decorators, DelAttr, DelName, Delete, - Dict, Discard, Ellipsis, EmptyNode, ExceptHandler, Exec, ExtSlice, For, - From, Getattr, Global, If, IfExp, Import, Index, Keyword, - List, ListComp, Name, Pass, Print, Raise, Return, Slice, Subscript, - TryExcept, TryFinally, Tuple, UnaryOp, While, With, Yield, const_factory ) +from logilab.astng.node_classes import Arguments, AssAttr, Assert, Assign, \ + AssName, AugAssign, Backquote, BinOp, BoolOp, Break, CallFunc, Compare, \ + Comprehension, Const, Continue, Decorators, DelAttr, DelName, Delete, \ + Dict, Discard, Ellipsis, EmptyNode, ExceptHandler, Exec, ExtSlice, For, \ + From, Getattr, Global, If, IfExp, Import, Index, Keyword, \ + List, ListComp, Name, Pass, Print, Raise, Return, Slice, Subscript, \ + TryExcept, TryFinally, Tuple, UnaryOp, While, With, Yield, const_factory from logilab.astng.scoped_nodes import Module, GenExpr, Lambda, Function, Class ALL_NODE_CLASSES = ( diff --git a/nodes_as_string.py b/nodes_as_string.py index 6bb7d5fb..0a0f287f 100644 --- a/nodes_as_string.py +++ b/nodes_as_string.py @@ -63,7 +63,7 @@ class AsStringVisitor(ASTVisitor): def _stmt_list(self, stmts): """return a list of nodes to string""" - stmts = '\n'.join([nstr for nstr in (n.accept(self) for n in stmts) if nstr]) + stmts = '\n'.join([nstr for nstr in [n.accept(self) for n in stmts] if nstr]) return INDENT + stmts.replace('\n', '\n'+INDENT) @@ -167,7 +167,7 @@ class AsStringVisitor(ASTVisitor): def visit_decorators(self, node): """return an astng.Decorators node as string""" - return '@%s\n' % '\n@'.join(item.accept(self) for item in node.nodes) + return '@%s\n' % '\n@'.join([item.accept(self) for item in node.nodes]) def visit_dict(self, node): """return an astng.Dict node as string""" @@ -210,7 +210,7 @@ class AsStringVisitor(ASTVisitor): def visit_extslice(self, node): """return an astng.ExtSlice node as string""" - return ','.join( dim.accept(self) for dim in node.dims ) + return ','.join( [dim.accept(self) for dim in node.dims] ) def visit_for(self, node): """return an astng.For node as string""" fors = 'for %s in %s:\n%s' % (node.target.accept(self), diff --git a/raw_building.py b/raw_building.py index f34961d9..534f58c5 100644 --- a/raw_building.py +++ b/raw_building.py @@ -31,7 +31,6 @@ # with logilab-astng. If not, see <http://www.gnu.org/licenses/>. """this module contains a set of functions to create astng trees from scratch (build_* functions) or from living object (object_build_* functions) - """ __docformat__ = "restructuredtext en" diff --git a/rebuilder.py b/rebuilder.py index d902875e..4bdbc6ca 100644 --- a/rebuilder.py +++ b/rebuilder.py @@ -214,11 +214,11 @@ class RebuildVisitor(object): for name in imported.wildcard_import_names(): node.parent.set_local(name, node) if delayed: - node.parent.scope().locals[name].sort(cmp=cmp_nodes) + node.parent.scope().locals[name].sort(cmp_nodes) else: node.parent.set_local(asname or name, node) if delayed: - node.parent.scope().locals[asname or name].sort(cmp=cmp_nodes) + node.parent.scope().locals[asname or name].sort(cmp_nodes) def visit_function(self, node, parent): diff --git a/scoped_nodes.py b/scoped_nodes.py index c890661f..9238983d 100644 --- a/scoped_nodes.py +++ b/scoped_nodes.py @@ -34,12 +34,12 @@ from logilab.common.decorators import cached from logilab.astng import MANAGER, NotFoundError, NoDefault, \ ASTNGBuildingException, InferenceError -from logilab.astng.node_classes import (Const, DelName, DelAttr, - Dict, From, List, Name, Pass, Raise, Return, Tuple, Yield, - are_exclusive, LookupMixIn, const_factory as cf, unpack_infer) -from logilab.astng.bases import (NodeNG, BaseClass, InferenceContext, Instance, - YES, Generator, UnboundMethod, BoundMethod, _infer_stmts, copy_context) -from logilab.astng.mixins import (StmtMixIn, FilterStmtsMixin) +from logilab.astng.node_classes import Const, DelName, DelAttr, \ + Dict, From, List, Name, Pass, Raise, Return, Tuple, Yield, \ + are_exclusive, LookupMixIn, const_factory as cf, unpack_infer +from logilab.astng.bases import NodeNG, BaseClass, InferenceContext, Instance,\ + YES, Generator, UnboundMethod, BoundMethod, _infer_stmts, copy_context +from logilab.astng.mixins import StmtMixIn, FilterStmtsMixin from logilab.astng.nodes_as_string import as_string @@ -519,7 +519,6 @@ class Function(StmtMixIn, Lambda): # (e.g. pylint...) when is_method() return True return self.type != 'function' and isinstance(self.parent.frame(), Class) - @cached def decoratornames(self): """return a list of decorator qualified names""" result = set() @@ -531,7 +530,7 @@ class Function(StmtMixIn, Lambda): for infnode in decnode.infer(): result.add(infnode.qname()) return result - + decoratornames = cached(decoratornames) def is_bound(self): """return true if the function is bound to an Instance or a class""" diff --git a/test/regrtest.py b/test/regrtest.py index 3f2267f7..5443cfe7 100644 --- a/test/regrtest.py +++ b/test/regrtest.py @@ -55,7 +55,7 @@ class NonRegressionTC(TestCase): try: import pygtk except ImportError: - self.skip('test skipped: pygtk is not available') + self.skipTest('test skipped: pygtk is not available') else: # XXX may fail on some pygtk version, because objects in # gobject._gobject have __module__ set to gobject :( @@ -94,27 +94,27 @@ if __name__ == "__main__": try: from pylint import lint except ImportError: - self.skip('pylint not available') + self.skipTest('pylint not available') mod = m.astng_from_module_name('pylint.lint') pylinter = mod['PyLinter'] - self.assertEquals([c.name for c in pylinter.ancestors()], + self.assertEqual([c.name for c in pylinter.ancestors()], ['OptionsManagerMixIn', 'object', 'MessagesHandlerMixIn', 'ReportsHandlerMixIn', 'BaseRawChecker', 'BaseChecker', 'OptionsProviderMixIn', 'ASTWalker']) self.assert_(list(Instance(pylinter).getattr('config'))) infered = list(Instance(pylinter).igetattr('config')) - self.assertEquals(len(infered), 2) + self.assertEqual(len(infered), 2) infered = [c for c in infered if not c is YES] - self.assertEquals(len(infered), 1) - self.assertEquals(infered[0].root().name, 'optparse') - self.assertEquals(infered[0].name, 'Values') + self.assertEqual(len(infered), 1) + self.assertEqual(infered[0].root().name, 'optparse') + self.assertEqual(infered[0].name, 'Values') def test_numpy_crash(self): try: import numpy except ImportError: - self.skip('test skipped: numpy is not available') + self.skipTest('test skipped: numpy is not available') else: builder = ASTNGBuilder() data = """ diff --git a/test/unittest_builder.py b/test/unittest_builder.py index c40572bc..31cd333f 100644 --- a/test/unittest_builder.py +++ b/test/unittest_builder.py @@ -61,24 +61,24 @@ class FromToLineNoTC(TestCase): # earzer', hop) discard = stmts[0] self.assertIsInstance(discard, nodes.Discard) - self.assertEquals(discard.fromlineno, 4) - self.assertEquals(discard.tolineno, 5) + self.assertEqual(discard.fromlineno, 4) + self.assertEqual(discard.tolineno, 5) callfunc = discard.value self.assertIsInstance(callfunc, nodes.CallFunc) - self.assertEquals(callfunc.fromlineno, 4) - self.assertEquals(callfunc.tolineno, 5) + self.assertEqual(callfunc.fromlineno, 4) + self.assertEqual(callfunc.tolineno, 5) name = callfunc.func self.assertIsInstance(name, nodes.Name) - self.assertEquals(name.fromlineno, 4) - self.assertEquals(name.tolineno, 4) + self.assertEqual(name.fromlineno, 4) + self.assertEqual(name.tolineno, 4) strarg = callfunc.args[0] self.assertIsInstance(strarg, nodes.Const) - self.assertEquals(strarg.fromlineno, 5) # no way for this one (is 4 actually) - self.assertEquals(strarg.tolineno, 5) + self.assertEqual(strarg.fromlineno, 5) # no way for this one (is 4 actually) + self.assertEqual(strarg.tolineno, 5) namearg = callfunc.args[1] self.assertIsInstance(namearg, nodes.Name) - self.assertEquals(namearg.fromlineno, 5) - self.assertEquals(namearg.tolineno, 5) + self.assertEqual(namearg.fromlineno, 5) + self.assertEqual(namearg.tolineno, 5) # on line 10: # fonction(1, # 2, @@ -86,20 +86,20 @@ class FromToLineNoTC(TestCase): # 4) discard = stmts[2] self.assertIsInstance(discard, nodes.Discard) - self.assertEquals(discard.fromlineno, 10) - self.assertEquals(discard.tolineno, 13) + self.assertEqual(discard.fromlineno, 10) + self.assertEqual(discard.tolineno, 13) callfunc = discard.value self.assertIsInstance(callfunc, nodes.CallFunc) - self.assertEquals(callfunc.fromlineno, 10) - self.assertEquals(callfunc.tolineno, 13) + self.assertEqual(callfunc.fromlineno, 10) + self.assertEqual(callfunc.tolineno, 13) name = callfunc.func self.assertIsInstance(name, nodes.Name) - self.assertEquals(name.fromlineno, 10) - self.assertEquals(name.tolineno, 10) + self.assertEqual(name.fromlineno, 10) + self.assertEqual(name.tolineno, 10) for i, arg in enumerate(callfunc.args): self.assertIsInstance(arg, nodes.Const) - self.assertEquals(arg.fromlineno, 10+i) - self.assertEquals(arg.tolineno, 10+i) + self.assertEqual(arg.fromlineno, 10+i) + self.assertEqual(arg.tolineno, 10+i) def test_function_lineno(self): stmts = self.astng.body @@ -110,17 +110,17 @@ class FromToLineNoTC(TestCase): # return a + b + c function = stmts[3] self.assertIsInstance(function, nodes.Function) - self.assertEquals(function.fromlineno, 15) - self.assertEquals(function.tolineno, 18) - self.assertEquals(function.blockstart_tolineno, 17) + self.assertEqual(function.fromlineno, 15) + self.assertEqual(function.tolineno, 18) + self.assertEqual(function.blockstart_tolineno, 17) return_ = function.body[0] self.assertIsInstance(return_, nodes.Return) - self.assertEquals(return_.fromlineno, 18) - self.assertEquals(return_.tolineno, 18) + self.assertEqual(return_.fromlineno, 18) + self.assertEqual(return_.tolineno, 18) def test_decorated_function_lineno(self): if sys.version_info < (2, 4): - self.skip('require python >=2.4') + self.skipTest('require python >=2.4') astng = builder.ASTNGBuilder().string_build(''' @decorator def function( @@ -128,11 +128,11 @@ def function( print arg ''', __name__, __file__) function = astng['function'] - self.assertEquals(function.fromlineno, 3) # XXX discussable, but that's what is expected by pylint right now - self.assertEquals(function.tolineno, 5) - self.assertEquals(function.blockstart_tolineno, 4) - self.assertEquals(function.decorators.fromlineno, 2) - self.assertEquals(function.decorators.tolineno, 2) + self.assertEqual(function.fromlineno, 3) # XXX discussable, but that's what is expected by pylint right now + self.assertEqual(function.tolineno, 5) + self.assertEqual(function.blockstart_tolineno, 4) + self.assertEqual(function.decorators.fromlineno, 2) + self.assertEqual(function.decorators.tolineno, 2) def test_class_lineno(self): @@ -143,13 +143,13 @@ def function( # pass class_ = stmts[4] self.assertIsInstance(class_, nodes.Class) - self.assertEquals(class_.fromlineno, 20) - self.assertEquals(class_.tolineno, 22) - self.assertEquals(class_.blockstart_tolineno, 21) + self.assertEqual(class_.fromlineno, 20) + self.assertEqual(class_.tolineno, 22) + self.assertEqual(class_.blockstart_tolineno, 21) pass_ = class_.body[0] self.assertIsInstance(pass_, nodes.Pass) - self.assertEquals(pass_.fromlineno, 22) - self.assertEquals(pass_.tolineno, 22) + self.assertEqual(pass_.fromlineno, 22) + self.assertEqual(pass_.tolineno, 22) def test_if_lineno(self): stmts = self.astng.body @@ -160,11 +160,11 @@ def function( # aaaa,bbbb = bbbb,aaaa if_ = stmts[5] self.assertIsInstance(if_, nodes.If) - self.assertEquals(if_.fromlineno, 24) - self.assertEquals(if_.tolineno, 27) - self.assertEquals(if_.blockstart_tolineno, 24) - self.assertEquals(if_.orelse[0].fromlineno, 26) - self.assertEquals(if_.orelse[1].tolineno, 27) + self.assertEqual(if_.fromlineno, 24) + self.assertEqual(if_.tolineno, 27) + self.assertEqual(if_.blockstart_tolineno, 24) + self.assertEqual(if_.orelse[0].fromlineno, 26) + self.assertEqual(if_.orelse[1].tolineno, 27) def test_for_while_lineno(self): for code in (''' @@ -183,11 +183,11 @@ else: ): astng = builder.ASTNGBuilder().string_build(code, __name__, __file__) stmt = astng.body[0] - self.assertEquals(stmt.fromlineno, 2) - self.assertEquals(stmt.tolineno, 6) - self.assertEquals(stmt.blockstart_tolineno, 2) - self.assertEquals(stmt.orelse[0].fromlineno, 6) # XXX - self.assertEquals(stmt.orelse[0].tolineno, 6) + self.assertEqual(stmt.fromlineno, 2) + self.assertEqual(stmt.tolineno, 6) + self.assertEqual(stmt.blockstart_tolineno, 2) + self.assertEqual(stmt.orelse[0].fromlineno, 6) # XXX + self.assertEqual(stmt.orelse[0].tolineno, 6) def test_try_except_lineno(self): @@ -200,15 +200,15 @@ else: print "bouh" ''', __name__, __file__) try_ = astng.body[0] - self.assertEquals(try_.fromlineno, 2) - self.assertEquals(try_.tolineno, 7) - self.assertEquals(try_.blockstart_tolineno, 2) - self.assertEquals(try_.orelse[0].fromlineno, 7) # XXX - self.assertEquals(try_.orelse[0].tolineno, 7) + self.assertEqual(try_.fromlineno, 2) + self.assertEqual(try_.tolineno, 7) + self.assertEqual(try_.blockstart_tolineno, 2) + self.assertEqual(try_.orelse[0].fromlineno, 7) # XXX + self.assertEqual(try_.orelse[0].tolineno, 7) hdlr = try_.handlers[0] - self.assertEquals(hdlr.fromlineno, 4) - self.assertEquals(hdlr.tolineno, 5) - self.assertEquals(hdlr.blockstart_tolineno, 4) + self.assertEqual(hdlr.fromlineno, 4) + self.assertEqual(hdlr.tolineno, 5) + self.assertEqual(hdlr.blockstart_tolineno, 4) def test_try_finally_lineno(self): @@ -219,16 +219,16 @@ finally: print "bouh" ''', __name__, __file__) try_ = astng.body[0] - self.assertEquals(try_.fromlineno, 2) - self.assertEquals(try_.tolineno, 5) - self.assertEquals(try_.blockstart_tolineno, 2) - self.assertEquals(try_.finalbody[0].fromlineno, 5) # XXX - self.assertEquals(try_.finalbody[0].tolineno, 5) + self.assertEqual(try_.fromlineno, 2) + self.assertEqual(try_.tolineno, 5) + self.assertEqual(try_.blockstart_tolineno, 2) + self.assertEqual(try_.finalbody[0].fromlineno, 5) # XXX + self.assertEqual(try_.finalbody[0].tolineno, 5) def test_try_finally_25_lineno(self): if sys.version_info < (2, 5): - self.skip('require python >= 2.5') + self.skipTest('require python >= 2.5') astng = builder.ASTNGBuilder().string_build(''' try: print a @@ -238,25 +238,25 @@ finally: print "bouh" ''', __name__, __file__) try_ = astng.body[0] - self.assertEquals(try_.fromlineno, 2) - self.assertEquals(try_.tolineno, 7) - self.assertEquals(try_.blockstart_tolineno, 2) - self.assertEquals(try_.finalbody[0].fromlineno, 7) # XXX - self.assertEquals(try_.finalbody[0].tolineno, 7) + self.assertEqual(try_.fromlineno, 2) + self.assertEqual(try_.tolineno, 7) + self.assertEqual(try_.blockstart_tolineno, 2) + self.assertEqual(try_.finalbody[0].fromlineno, 7) # XXX + self.assertEqual(try_.finalbody[0].tolineno, 7) def test_with_lineno(self): if sys.version_info < (2, 5): - self.skip('require python >=2.5') + self.skipTest('require python >=2.5') astng = builder.ASTNGBuilder().string_build(''' from __future__ import with_statement with file("/tmp/pouet") as f: print f ''', __name__, __file__) with_ = astng.body[1] - self.assertEquals(with_.fromlineno, 3) - self.assertEquals(with_.tolineno, 4) - self.assertEquals(with_.blockstart_tolineno, 3) + self.assertEqual(with_.fromlineno, 3) + self.assertEqual(with_.tolineno, 4) + self.assertEqual(with_.blockstart_tolineno, 3) @@ -283,7 +283,7 @@ class BuilderTC(TestCase): self.assertIsInstance(fclass['read'], nodes.Function) # check builtin function has args.args == None dclass = builtin_astng['dict'] - self.assertEquals(dclass['has_key'].args.args, None) + self.assertEqual(dclass['has_key'].args.args, None) # just check type and object are there builtin_astng.getattr('type') builtin_astng.getattr('object') @@ -303,14 +303,14 @@ class BuilderTC(TestCase): def test_inspect_build1(self): time_astng = MANAGER.astng_from_module_name('time') self.assert_(time_astng) - self.assertEquals(time_astng['time'].args.defaults, []) + self.assertEqual(time_astng['time'].args.defaults, []) def test_inspect_build2(self): """test astng tree build from a living object""" try: from mx import DateTime except ImportError: - self.skip('test skipped: mxDateTime is not available') + self.skipTest('test skipped: mxDateTime is not available') else: dt_astng = self.builder.inspect_build(DateTime) dt_astng.getattr('DateTime') @@ -339,25 +339,25 @@ class BuilderTC(TestCase): builtin_astng = MANAGER.astng_from_module_name('__builtin__') infered = list(builtin_astng.igetattr('object')) - self.assertEquals(len(infered), 1) + self.assertEqual(len(infered), 1) infered = infered[0] - self.assertEquals(infered.name, 'object') + self.assertEqual(infered.name, 'object') as_string(infered) infered = list(builtin_astng.igetattr('type')) - self.assertEquals(len(infered), 1) + self.assertEqual(len(infered), 1) infered = infered[0] - self.assertEquals(infered.name, 'type') + self.assertEqual(infered.name, 'type') as_string(infered) def test_package_name(self): """test base properties and method of a astng module""" datap = self.builder.file_build('data/__init__.py', 'data') - self.assertEquals(datap.name, 'data') - self.assertEquals(datap.package, 1) + self.assertEqual(datap.name, 'data') + self.assertEqual(datap.package, 1) datap = self.builder.file_build('data/__init__.py', 'data.__init__') - self.assertEquals(datap.name, 'data') - self.assertEquals(datap.package, 1) + self.assertEqual(datap.name, 'data') + self.assertEqual(datap.package, 1) def test_yield_parent(self): """check if we added discard nodes as yield parent (w/ compiler)""" @@ -465,18 +465,18 @@ class FileBuildTC(TestCase): def test_module_base_props(self): """test base properties and method of a astng module""" module = self.module - self.assertEquals(module.name, 'data.module') - self.assertEquals(module.doc, "test module for astng\n") - self.assertEquals(module.fromlineno, 0) - self.assertEquals(module.parent, None) - self.assertEquals(module.frame(), module) - self.assertEquals(module.root(), module) - self.assertEquals(module.file, join(abspath(data.__path__[0]), 'module.py')) - self.assertEquals(module.pure_python, 1) - self.assertEquals(module.package, 0) + self.assertEqual(module.name, 'data.module') + self.assertEqual(module.doc, "test module for astng\n") + self.assertEqual(module.fromlineno, 0) + self.assertEqual(module.parent, None) + self.assertEqual(module.frame(), module) + self.assertEqual(module.root(), module) + self.assertEqual(module.file, join(abspath(data.__path__[0]), 'module.py')) + self.assertEqual(module.pure_python, 1) + self.assertEqual(module.package, 0) self.assert_(not module.is_statement) - self.assertEquals(module.statement(), module) - self.assertEquals(module.statement(), module) + self.assertEqual(module.statement(), module) + self.assertEqual(module.statement(), module) def test_module_locals(self): """test the 'locals' dictionary of a astng module""" @@ -490,43 +490,43 @@ class FileBuildTC(TestCase): 'os', 'redirect', 'spawn', 'LocalsVisitor', 'ASTWalker', 'ASTVisitor'] should.sort() - self.assertEquals(keys, should) + self.assertEqual(keys, should) def test_function_base_props(self): """test base properties and method of a astng function""" module = self.module function = module['global_access'] - self.assertEquals(function.name, 'global_access') - self.assertEquals(function.doc, 'function test') - self.assertEquals(function.fromlineno, 15) + self.assertEqual(function.name, 'global_access') + self.assertEqual(function.doc, 'function test') + self.assertEqual(function.fromlineno, 15) self.assert_(function.parent) - self.assertEquals(function.frame(), function) - self.assertEquals(function.parent.frame(), module) - self.assertEquals(function.root(), module) - self.assertEquals([n.name for n in function.args.args], ['key', 'val']) - self.assertEquals(function.type, 'function') + self.assertEqual(function.frame(), function) + self.assertEqual(function.parent.frame(), module) + self.assertEqual(function.root(), module) + self.assertEqual([n.name for n in function.args.args], ['key', 'val']) + self.assertEqual(function.type, 'function') def test_function_locals(self): """test the 'locals' dictionary of a astng function""" _locals = self.module['global_access'].locals - self.assertEquals(len(_locals), 4) + self.assertEqual(len(_locals), 4) keys = _locals.keys() keys.sort() - self.assertEquals(keys, ['i', 'key', 'local', 'val']) + self.assertEqual(keys, ['i', 'key', 'local', 'val']) def test_class_base_props(self): """test base properties and method of a astng class""" module = self.module klass = module['YO'] - self.assertEquals(klass.name, 'YO') - self.assertEquals(klass.doc, 'hehe') - self.assertEquals(klass.fromlineno, 28) + self.assertEqual(klass.name, 'YO') + self.assertEqual(klass.doc, 'hehe') + self.assertEqual(klass.fromlineno, 28) self.assert_(klass.parent) - self.assertEquals(klass.frame(), klass) - self.assertEquals(klass.parent.frame(), module) - self.assertEquals(klass.root(), module) - self.assertEquals(klass.basenames, []) - self.assertEquals(klass.newstyle, False) + self.assertEqual(klass.frame(), klass) + self.assertEqual(klass.parent.frame(), module) + self.assertEqual(klass.root(), module) + self.assertEqual(klass.basenames, []) + self.assertEqual(klass.newstyle, False) def test_class_locals(self): """test the 'locals' dictionary of a astng class""" @@ -535,56 +535,56 @@ class FileBuildTC(TestCase): locals1 = klass1.locals keys = locals1.keys() keys.sort() - self.assertEquals(keys, ['__init__', 'a']) + self.assertEqual(keys, ['__init__', 'a']) klass2 = module['YOUPI'] locals2 = klass2.locals keys = locals2.keys() keys.sort() - self.assertEquals(keys, ['__init__', 'class_attr', 'class_method', + self.assertEqual(keys, ['__init__', 'class_attr', 'class_method', 'method', 'static_method']) def test_class_instance_attrs(self): module = self.module klass1 = module['YO'] klass2 = module['YOUPI'] - self.assertEquals(klass1.instance_attrs.keys(), ['yo']) - self.assertEquals(klass2.instance_attrs.keys(), ['member']) + self.assertEqual(klass1.instance_attrs.keys(), ['yo']) + self.assertEqual(klass2.instance_attrs.keys(), ['member']) def test_class_basenames(self): module = self.module klass1 = module['YO'] klass2 = module['YOUPI'] - self.assertEquals(klass1.basenames, []) - self.assertEquals(klass2.basenames, ['YO']) + self.assertEqual(klass1.basenames, []) + self.assertEqual(klass2.basenames, ['YO']) def test_method_base_props(self): """test base properties and method of a astng method""" klass2 = self.module['YOUPI'] # "normal" method method = klass2['method'] - self.assertEquals(method.name, 'method') - self.assertEquals([n.name for n in method.args.args], ['self']) - self.assertEquals(method.doc, 'method test') - self.assertEquals(method.fromlineno, 48) - self.assertEquals(method.type, 'method') + self.assertEqual(method.name, 'method') + self.assertEqual([n.name for n in method.args.args], ['self']) + self.assertEqual(method.doc, 'method test') + self.assertEqual(method.fromlineno, 48) + self.assertEqual(method.type, 'method') # class method method = klass2['class_method'] - self.assertEquals([n.name for n in method.args.args], ['cls']) - self.assertEquals(method.type, 'classmethod') + self.assertEqual([n.name for n in method.args.args], ['cls']) + self.assertEqual(method.type, 'classmethod') # static method method = klass2['static_method'] - self.assertEquals(method.args.args, []) - self.assertEquals(method.type, 'staticmethod') + self.assertEqual(method.args.args, []) + self.assertEqual(method.type, 'staticmethod') def test_method_locals(self): """test the 'locals' dictionary of a astng method""" klass2 = self.module['YOUPI'] method = klass2['method'] _locals = method.locals - self.assertEquals(len(_locals), 5) + self.assertEqual(len(_locals), 5) keys = _locals.keys() keys.sort() - self.assertEquals(keys, ['a', 'autre', 'b', 'local', 'self']) + self.assertEqual(keys, ['a', 'autre', 'b', 'local', 'self']) class ModuleBuildTC(FileBuildTC): @@ -609,7 +609,7 @@ A.ass_type = A_ass_type ''' astng = self.builder.string_build(code) lclass = list(astng.igetattr('A')) - self.assertEquals(len(lclass), 1) + self.assertEqual(len(lclass), 1) lclass = lclass[0] self.assert_('ass_type' in lclass.locals, lclass.locals.keys()) self.assert_('type' in lclass.locals.keys()) @@ -621,7 +621,7 @@ A.ass_type = A_ass_type # astastng = astng.MANAGER.astng_from_file(join(compiler.__path__[0], 'ast.py')) # # check monkey patching of the compiler module has been inferred # lclass = list(astastng.igetattr('Function')) -# self.assertEquals(len(lclass), 1) +# self.assertEqual(len(lclass), 1) # lclass = lclass[0] # self.assert_('ass_type' in lclass.locals, lclass.locals.keys()) @@ -674,10 +674,10 @@ def func(): astng = self.builder.string_build(code) none, nothing, chain = [ret.value for ret in astng.body[0].body] self.assertIsInstance(none, nodes.Const) - self.assertEquals(none.value, None) - self.assertEquals(nothing, None) + self.assertEqual(none.value, None) + self.assertEqual(nothing, None) self.assertIsInstance(chain, nodes.Const) - self.assertEquals(chain.value, 'None') + self.assertEqual(chain.value, 'None') if __name__ == '__main__': diff --git a/test/unittest_inference.py b/test/unittest_inference.py index 86b7654d..92dbd0de 100644 --- a/test/unittest_inference.py +++ b/test/unittest_inference.py @@ -720,7 +720,7 @@ un = mirror(1) def test_factory_method(self): if sys.version_info < (2, 4): - self.skip('this test require python >= 2.4') + self.skipTest('this test require python >= 2.4') code = ''' class Super(object): @classmethod @@ -870,7 +870,7 @@ x = randint(1) # 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__,), + self.assertEqual(value, ['Instance of %s.myarray' % (__name__,), 'Instance of __builtin__.int']) def test_nonregr_lambda_arg(self): @@ -908,16 +908,16 @@ def f(x): def test_python25_relative_import(self): if sys.version_info < (2, 5): - self.skip('require py >= 2.5') + self.skipTest('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') + self.assertEqual(infered.name, 'logilab.common.date') def test_python25_no_relative_import(self): if sys.version_info < (2, 5): - self.skip('require py >= 2.5') + self.skipTest('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()) @@ -934,7 +934,7 @@ def f(x): # try: # import mechanize # except ImportError: -# self.skip('require mechanize installed') +# self.skipTest('require mechanize installed') # data = '''from mechanize import Browser # print Browser # b = Browser() @@ -945,14 +945,14 @@ def f(x): # self.assertIsInstance(browser, nodes.Class) # print '*'*80 # bopen = list(browser.igetattr('open')) -# self.assertEquals(len(bopen), 1) +# self.assertEqual(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.assertEqual(len(bopen), 1) # self.assertIsInstance(bopen[0], BoundMethod) # self.failUnless(bopen[0].callable()) @@ -973,22 +973,22 @@ print SendMailController().smtp print SendMailController().me ''' astng = builder.string_build(code, __name__, __file__) - self.assertEquals(astng['SendMailController']['smtp'].decoratornames(), + self.assertEqual(astng['SendMailController']['smtp'].decoratornames(), set(('__builtin__.property',))) propinfered = list(astng.body[2].values[0].infer()) - self.assertEquals(len(propinfered), 1) + self.assertEqual(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(), + self.assertEqual(propinfered.name, 'SMTP') + self.assertEqual(propinfered.root().name, 'smtplib') + self.assertEqual(astng['SendMailController']['me'].decoratornames(), set(('__builtin__.property',))) propinfered = list(astng.body[3].values[0].infer()) - self.assertEquals(len(propinfered), 1) + self.assertEqual(len(propinfered), 1) propinfered = propinfered[0] self.assertIsInstance(propinfered, Instance) - self.assertEquals(propinfered.name, 'SendMailController') - self.assertEquals(propinfered.root().name, __name__) + self.assertEqual(propinfered.name, 'SendMailController') + self.assertEqual(propinfered.root().name, __name__) def test_im_func_unwrap(self): @@ -1007,11 +1007,11 @@ class EnvBasedTC2: astng = builder.string_build(code, __name__, __file__) pactions = get_name_node(astng, 'pactions') infered = list(pactions.infer()) - self.assertEquals(len(infered), 1) + self.assertEqual(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.assertEqual(len(infered), 1) self.assertIsInstance(infered[0], nodes.Function) def test_augassign(self): @@ -1023,9 +1023,9 @@ print a astng = builder.string_build(code, __name__, __file__) infered = list(get_name_node(astng, 'a').infer()) - self.assertEquals(len(infered), 1) + self.assertEqual(len(infered), 1) self.assertIsInstance(infered[0], nodes.Const) - self.assertEquals(infered[0].value, 3) + self.assertEqual(infered[0].value, 3) def test_nonregr_func_arg(self): code = ''' @@ -1039,7 +1039,7 @@ def foo(self, bar): ''' astng = builder.string_build(code, __name__, __file__) infered = list(get_name_node(astng['foo'], 'spam').infer()) - self.assertEquals(len(infered), 1) + self.assertEqual(len(infered), 1) self.assertIs(infered[0], YES) def test_nonregr_func_global(self): @@ -1064,9 +1064,9 @@ class DataManager(object): ''' astng = builder.string_build(code, __name__, __file__) infered = list(Instance(astng['DataManager']).igetattr('app')) - self.assertEquals(len(infered), 2, infered) # None / Instance(Application) + self.assertEqual(len(infered), 2, infered) # None / Instance(Application) infered = list(get_name_node(astng['DataManager']['test'], 'p').infer()) - self.assertEquals(len(infered), 2, infered) + self.assertEqual(len(infered), 2, infered) for node in infered: if isinstance(node, Instance) and node.name == 'Application': break @@ -1100,10 +1100,10 @@ Z = test() ''' astng = builder.string_build(code, __name__, __file__) infered = list(astng['Z'].infer()) - self.assertEquals(len(infered), 1, infered) + self.assertEqual(len(infered), 1, infered) self.assertIsInstance(infered[0], Instance) self.assertIsInstance(infered[0]._proxied, nodes.Class) - self.assertEquals(infered[0]._proxied.name, 'list') + self.assertEqual(infered[0]._proxied.name, 'list') if __name__ == '__main__': unittest_main() diff --git a/test/unittest_lookup.py b/test/unittest_lookup.py index 6878a45d..ae6d9bc9 100644 --- a/test/unittest_lookup.py +++ b/test/unittest_lookup.py @@ -78,14 +78,14 @@ def func(): astng = builder.string_build('pass', __name__, __file__) # built-in objects none = astng.ilookup('None').next() - self.assertEquals(none.value, None) + self.assertEqual(none.value, None) obj = astng.ilookup('object').next() self.assertIsInstance(obj, nodes.Class) - self.assertEquals(obj.name, 'object') + self.assertEqual(obj.name, 'object') self.assertRaises(InferenceError, astng.ilookup('YOAA').next) # XXX - self.assertEquals(len(list(NONREGR.ilookup('enumerate'))), 2) + self.assertEqual(len(list(NONREGR.ilookup('enumerate'))), 2) def test_class_ancestor_name(self): code = ''' @@ -99,7 +99,7 @@ class A(A): cls1 = astng.locals['A'][0] cls2 = astng.locals['A'][1] name = cls2.nodes_of_class(nodes.Name).next() - self.assertEquals(name.infer().next(), cls1) + self.assertEqual(name.infer().next(), cls1) ### backport those test to inline code def test_method(self): @@ -107,7 +107,7 @@ class A(A): my_dict = method.ilookup('MY_DICT').next() self.assert_(isinstance(my_dict, nodes.Dict), my_dict) none = method.ilookup('None').next() - self.assertEquals(none.value, None) + self.assertEqual(none.value, None) self.assertRaises(InferenceError, method.ilookup('YOAA').next) @@ -115,8 +115,8 @@ class A(A): make_class = MODULE2['make_class'] base = make_class.ilookup('base').next() self.assert_(isinstance(base, nodes.Class), base.__class__) - self.assertEquals(base.name, 'YO') - self.assertEquals(base.root().name, 'data.module') + self.assertEqual(base.name, 'YO') + self.assertEqual(base.root().name, 'data.module') def test_class(self): @@ -124,16 +124,16 @@ class A(A): my_dict = klass.ilookup('MY_DICT').next() self.assertIsInstance(my_dict, nodes.Dict) none = klass.ilookup('None').next() - self.assertEquals(none.value, None) + self.assertEqual(none.value, None) obj = klass.ilookup('object').next() self.assertIsInstance(obj, nodes.Class) - self.assertEquals(obj.name, 'object') + self.assertEqual(obj.name, 'object') self.assertRaises(InferenceError, klass.ilookup('YOAA').next) def test_inner_classes(self): ccc = NONREGR['Ccc'] - self.assertEquals(ccc.ilookup('Ddd').next().name, 'Ddd') + self.assertEqual(ccc.ilookup('Ddd').next().name, 'Ddd') def test_loopvar_hiding(self): @@ -147,26 +147,26 @@ if x > 0: """, __name__, __file__) xnames = [n for n in astng.nodes_of_class(nodes.Name) if n.name == 'x'] # inside the loop, only one possible assignment - self.assertEquals(len(xnames[0].lookup('x')[1]), 1) + self.assertEqual(len(xnames[0].lookup('x')[1]), 1) # outside the loop, two possible assignments - self.assertEquals(len(xnames[1].lookup('x')[1]), 2) - self.assertEquals(len(xnames[2].lookup('x')[1]), 2) + self.assertEqual(len(xnames[1].lookup('x')[1]), 2) + self.assertEqual(len(xnames[2].lookup('x')[1]), 2) def test_list_comps(self): if sys.version_info < (2, 4): - self.skip('this test require python >= 2.4') + self.skipTest('this test require python >= 2.4') astng = builder.string_build(""" print [ i for i in range(10) ] print [ i for i in range(10) ] print list( i for i in range(10) ) """, __name__, __file__) xnames = [n for n in astng.nodes_of_class(nodes.Name) if n.name == 'i'] - self.assertEquals(len(xnames[0].lookup('i')[1]), 1) - self.assertEquals(xnames[0].lookup('i')[1][0].lineno, 2) - self.assertEquals(len(xnames[1].lookup('i')[1]), 1) - self.assertEquals(xnames[1].lookup('i')[1][0].lineno, 3) - self.assertEquals(len(xnames[2].lookup('i')[1]), 1) - self.assertEquals(xnames[2].lookup('i')[1][0].lineno, 4) + 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) + self.assertEqual(len(xnames[2].lookup('i')[1]), 1) + self.assertEqual(xnames[2].lookup('i')[1][0].lineno, 4) def test_explicit___name__(self): @@ -198,21 +198,21 @@ def initialize(linter): package_load(linter, __path__[0]) ''', 'data.__init__', 'data/__init__.py') path = [n for n in astng.nodes_of_class(nodes.Name) if n.name == '__path__'][0] - self.assertEquals(len(path.lookup('__path__')[1]), 1) + self.assertEqual(len(path.lookup('__path__')[1]), 1) def test_builtin_lookup(self): - self.assertEquals(builtin_lookup('__dict__')[1], ()) + self.assertEqual(builtin_lookup('__dict__')[1], ()) intstmts = builtin_lookup('int')[1] - self.assertEquals(len(intstmts), 1) + self.assertEqual(len(intstmts), 1) self.assertIsInstance(intstmts[0], nodes.Class) - self.assertEquals(intstmts[0].name, 'int') + self.assertEqual(intstmts[0].name, 'int') self.assertIs(intstmts[0], nodes.const_factory(1)._proxied) def test_decorator_arguments_lookup(self): if sys.version_info < (2, 4): - self.skip('this test require python >= 2.4') + self.skipTest('this test require python >= 2.4') code = ''' def decorator(value): def wrapper(function): @@ -231,13 +231,13 @@ class foo: it = member.infer() obj = it.next() self.assertIsInstance(obj, nodes.Const) - self.assertEquals(obj.value, 10) + self.assertEqual(obj.value, 10) self.assertRaises(StopIteration, it.next) def test_inner_decorator_member_lookup(self): if sys.version_info < (2, 4): - self.skip('this test require python >= 2.4') + self.skipTest('this test require python >= 2.4') code = ''' class FileA: def decorator(bla): @@ -257,7 +257,7 @@ class FileA: def test_static_method_lookup(self): if sys.version_info < (2, 4): - self.skip('this test require python >= 2.4') + self.skipTest('this test require python >= 2.4') code = ''' class FileA: @staticmethod diff --git a/test/unittest_manager.py b/test/unittest_manager.py index 51c926ac..faf7e519 100644 --- a/test/unittest_manager.py +++ b/test/unittest_manager.py @@ -30,19 +30,19 @@ class ASTNGManagerTC(unittest.TestCase): def test_astng_from_module(self): astng = self.manager.astng_from_module(unittest) - self.assertEquals(astng.pure_python, True) + self.assertEqual(astng.pure_python, True) import time astng = self.manager.astng_from_module(time) - self.assertEquals(astng.pure_python, False) + self.assertEqual(astng.pure_python, False) def test_astng_from_class(self): astng = self.manager.astng_from_class(file) - self.assertEquals(astng.name, 'file') - self.assertEquals(astng.parent.frame().name, '__builtin__') + self.assertEqual(astng.name, 'file') + self.assertEqual(astng.parent.frame().name, '__builtin__') astng = self.manager.astng_from_class(object) - self.assertEquals(astng.name, 'object') - self.assertEquals(astng.parent.frame().name, '__builtin__') + self.assertEqual(astng.name, 'object') + self.assertEqual(astng.parent.frame().name, '__builtin__') self.failUnless('__setattr__' in astng) def _test_astng_from_zip(self, archive): @@ -51,7 +51,7 @@ class ASTNGManagerTC(unittest.TestCase): sys.path.insert(0, join(dirname(__file__), 'data', archive)) try: module = self.manager.astng_from_module_name('mypypa') - self.assertEquals(module.name, 'mypypa') + self.assertEqual(module.name, 'mypypa') self.failUnless(module.file.endswith('%s/mypypa' % archive), module.file) finally: @@ -65,8 +65,8 @@ class ASTNGManagerTC(unittest.TestCase): def test_from_directory(self): obj = self.manager.from_directory('data') - self.assertEquals(obj.name, 'data') - self.assertEquals(obj.path, join(os.getcwd(), 'data')) + self.assertEqual(obj.name, 'data') + self.assertEqual(obj.path, join(os.getcwd(), 'data')) def test_package_node(self): obj = self.manager.from_directory('data') @@ -75,20 +75,20 @@ class ASTNGManagerTC(unittest.TestCase): expected_long = ['SSL1', 'data', 'data.all', 'appl', 'data.format', 'data.module', 'data.module2', 'data.noendingnewline', 'data.nonregr', 'data.notall'] - self.assertEquals(obj.keys(), expected_short) - self.assertEquals([m.name for m in obj.values()], expected_long) - self.assertEquals([m for m in list(obj)], expected_short) - self.assertEquals([(name, m.name) for name, m in obj.items()], + self.assertEqual(obj.keys(), expected_short) + self.assertEqual([m.name for m in obj.values()], expected_long) + self.assertEqual([m for m in list(obj)], expected_short) + self.assertEqual([(name, m.name) for name, m in obj.items()], zip(expected_short, expected_long)) - self.assertEquals([(name, m.name) for name, m in obj.items()], + self.assertEqual([(name, m.name) for name, m in obj.items()], zip(expected_short, expected_long)) - self.assertEquals('module' in obj, True) - self.assertEquals(obj.has_key('module'), True) - self.assertEquals(obj.get('module').name, 'data.module') - self.assertEquals(obj['module'].name, 'data.module') - self.assertEquals(obj.get('whatever'), None) - self.assertEquals(obj.fullname(), 'data') + self.assertEqual('module' in obj, True) + self.assertEqual(obj.has_key('module'), True) + self.assertEqual(obj.get('module').name, 'data.module') + self.assertEqual(obj['module'].name, 'data.module') + self.assertEqual(obj.get('whatever'), None) + self.assertEqual(obj.fullname(), 'data') # FIXME: test fullname on a subpackage diff --git a/test/unittest_nodes.py b/test/unittest_nodes.py index bec815d1..5a82d73b 100644 --- a/test/unittest_nodes.py +++ b/test/unittest_nodes.py @@ -82,7 +82,7 @@ else: def test_if_elif_else_node(self): """test transformation for If node""" - self.assertEquals(len(self.astng.body), 4) + self.assertEqual(len(self.astng.body), 4) for stmt in self.astng.body: self.assertIsInstance( stmt, nodes.If) self.failIf(self.astng.body[0].orelse) # simple If @@ -92,12 +92,12 @@ else: def test_block_range(self): # XXX ensure expected values - self.assertEquals(self.astng.block_range(1), (0, 22)) - self.assertEquals(self.astng.block_range(10), (0, 22)) # XXX (10, 22) ? - self.assertEquals(self.astng.body[1].block_range(5), (5, 6)) - self.assertEquals(self.astng.body[1].block_range(6), (6, 6)) - self.assertEquals(self.astng.body[1].orelse[0].block_range(7), (7, 8)) - self.assertEquals(self.astng.body[1].orelse[0].block_range(8), (8, 8)) + self.assertEqual(self.astng.block_range(1), (0, 22)) + self.assertEqual(self.astng.block_range(10), (0, 22)) # XXX (10, 22) ? + self.assertEqual(self.astng.body[1].block_range(5), (5, 6)) + self.assertEqual(self.astng.body[1].block_range(6), (6, 6)) + self.assertEqual(self.astng.body[1].orelse[0].block_range(7), (7, 8)) + self.assertEqual(self.astng.body[1].orelse[0].block_range(8), (8, 8)) class TryExceptNodeTC(_NodeTC): @@ -113,14 +113,14 @@ else: """ def test_block_range(self): # XXX ensure expected values - self.assertEquals(self.astng.body[0].block_range(1), (1, 8)) - self.assertEquals(self.astng.body[0].block_range(2), (2, 2)) - self.assertEquals(self.astng.body[0].block_range(3), (3, 8)) - self.assertEquals(self.astng.body[0].block_range(4), (4, 4)) - self.assertEquals(self.astng.body[0].block_range(5), (5, 5)) - self.assertEquals(self.astng.body[0].block_range(6), (6, 6)) - self.assertEquals(self.astng.body[0].block_range(7), (7, 7)) - self.assertEquals(self.astng.body[0].block_range(8), (8, 8)) + self.assertEqual(self.astng.body[0].block_range(1), (1, 8)) + self.assertEqual(self.astng.body[0].block_range(2), (2, 2)) + self.assertEqual(self.astng.body[0].block_range(3), (3, 8)) + self.assertEqual(self.astng.body[0].block_range(4), (4, 4)) + self.assertEqual(self.astng.body[0].block_range(5), (5, 5)) + self.assertEqual(self.astng.body[0].block_range(6), (6, 6)) + self.assertEqual(self.astng.body[0].block_range(7), (7, 7)) + self.assertEqual(self.astng.body[0].block_range(8), (8, 8)) class TryFinallyNodeTC(_NodeTC): @@ -132,10 +132,10 @@ finally: """ def test_block_range(self): # XXX ensure expected values - self.assertEquals(self.astng.body[0].block_range(1), (1, 4)) - self.assertEquals(self.astng.body[0].block_range(2), (2, 2)) - self.assertEquals(self.astng.body[0].block_range(3), (3, 4)) - self.assertEquals(self.astng.body[0].block_range(4), (4, 4)) + self.assertEqual(self.astng.body[0].block_range(1), (1, 4)) + self.assertEqual(self.astng.body[0].block_range(2), (2, 2)) + self.assertEqual(self.astng.body[0].block_range(3), (3, 4)) + self.assertEqual(self.astng.body[0].block_range(4), (4, 4)) class TryFinally25NodeTC(_NodeTC): @@ -149,14 +149,14 @@ finally: """ def test_block_range(self): if sys.version_info < (2, 5): - self.skip('require python >= 2.5') + self.skipTest('require python >= 2.5') # XXX ensure expected values - self.assertEquals(self.astng.body[0].block_range(1), (1, 6)) - self.assertEquals(self.astng.body[0].block_range(2), (2, 2)) - self.assertEquals(self.astng.body[0].block_range(3), (3, 4)) - self.assertEquals(self.astng.body[0].block_range(4), (4, 4)) - self.assertEquals(self.astng.body[0].block_range(5), (5, 5)) - self.assertEquals(self.astng.body[0].block_range(6), (6, 6)) + self.assertEqual(self.astng.body[0].block_range(1), (1, 6)) + self.assertEqual(self.astng.body[0].block_range(2), (2, 2)) + self.assertEqual(self.astng.body[0].block_range(3), (3, 4)) + self.assertEqual(self.astng.body[0].block_range(4), (4, 4)) + self.assertEqual(self.astng.body[0].block_range(5), (5, 5)) + self.assertEqual(self.astng.body[0].block_range(6), (6, 6)) MODULE = abuilder.module_build(test_module) @@ -186,25 +186,25 @@ class ImportNodeTC(testlib.TestCase): def test_real_name(self): from_ = MODULE['spawn'] - self.assertEquals(from_.real_name('spawn'), 'Execute') + self.assertEqual(from_.real_name('spawn'), 'Execute') imp_ = MODULE['os'] - self.assertEquals(imp_.real_name('os'), 'os') + self.assertEqual(imp_.real_name('os'), 'os') self.assertRaises(NotFoundError, imp_.real_name, 'os.path') imp_ = MODULE['spawn'] - self.assertEquals(imp_.real_name('spawn'), 'Execute') + self.assertEqual(imp_.real_name('spawn'), 'Execute') self.assertRaises(NotFoundError, imp_.real_name, 'Execute') imp_ = MODULE2['YO'] - self.assertEquals(imp_.real_name('YO'), 'YO') + self.assertEqual(imp_.real_name('YO'), 'YO') self.assertRaises(NotFoundError, imp_.real_name, 'data') def test_as_string(self): ast = MODULE['modutils'] - self.assertEquals(as_string(ast), "from logilab.common import modutils") + self.assertEqual(as_string(ast), "from logilab.common import modutils") ast = MODULE['spawn'] - self.assertEquals(as_string(ast), "from logilab.common.shellutils import Execute as spawn") + self.assertEqual(as_string(ast), "from logilab.common.shellutils import Execute as spawn") ast = MODULE['os'] - self.assertEquals(as_string(ast), "import os.path") + self.assertEqual(as_string(ast), "import os.path") def test_module_as_string(self): """just check as_string on a whole module doesn't raise an exception @@ -216,7 +216,7 @@ class ImportNodeTC(testlib.TestCase): class CmpNodeTC(testlib.TestCase): def test_as_string(self): ast = abuilder.string_build("a == 2") - self.assertEquals(as_string(ast), "a == 2") + self.assertEqual(as_string(ast), "a == 2") class ConstNodeTC(testlib.TestCase): @@ -224,10 +224,10 @@ class ConstNodeTC(testlib.TestCase): def _test(self, value): node = nodes.const_factory(value) self.assertIsInstance(node._proxied, nodes.Class) - self.assertEquals(node._proxied.name, value.__class__.__name__) + self.assertEqual(node._proxied.name, value.__class__.__name__) self.assertIs(node.value, value) self.failUnless(node._proxied.parent) - self.assertEquals(node._proxied.root().name, value.__class__.__module__) + self.assertEqual(node._proxied.root().name, value.__class__.__module__) def test_none(self): self._test(None) @@ -258,12 +258,12 @@ def func(a, b): pass x = lambda x: None ''') - self.assertEquals(ast['func'].args.fromlineno, 2) - self.assertEquals(ast['func'].args.tolineno, 3) + self.assertEqual(ast['func'].args.fromlineno, 2) + self.assertEqual(ast['func'].args.tolineno, 3) self.failIf(ast['func'].args.is_statement) xlambda = ast['x'].infer().next() - self.assertEquals(xlambda.args.fromlineno, 4) - self.assertEquals(xlambda.args.tolineno, 4) + self.assertEqual(xlambda.args.fromlineno, 4) + self.assertEqual(xlambda.args.tolineno, 4) self.failIf(xlambda.args.is_statement) @@ -272,7 +272,7 @@ class SliceNodeTC(testlib.TestCase): for code in ('a[0]', 'a[1:3]', 'a[:-1:step]', 'a[:,newaxis]', 'a[newaxis,:]', 'del L[::2]', 'del A[1]', 'del Br[:]'): ast = abuilder.string_build(code) - self.assertEquals(ast.as_string(), code) + self.assertEqual(ast.as_string(), code) def test_slice_and_subscripts(self): code = """a[:1] = bord[2:] @@ -291,12 +291,12 @@ del (ccok, (name.thing, foo.attrib.value)), Fee.form[left:] if all[1] == bord[0:]: pass""" ast = abuilder.string_build(code) - self.assertEquals(ast.as_string(), code) + self.assertEqual(ast.as_string(), code) class EllipsisNodeTC(testlib.TestCase): def test(self): ast = abuilder.string_build('a[...]') - self.assertEquals(ast.as_string(), 'a[...]') + self.assertEqual(ast.as_string(), 'a[...]') if __name__ == '__main__': testlib.unittest_main() diff --git a/test/unittest_scoped_nodes.py b/test/unittest_scoped_nodes.py index 38a2a9f3..2853bf20 100644 --- a/test/unittest_scoped_nodes.py +++ b/test/unittest_scoped_nodes.py @@ -49,19 +49,19 @@ def _test_dict_interface(self, node, test_attr): class ModuleNodeTC(TestCase): def test_special_attributes(self): - self.assertEquals(len(MODULE.getattr('__name__')), 1) + self.assertEqual(len(MODULE.getattr('__name__')), 1) self.assertIsInstance(MODULE.getattr('__name__')[0], nodes.Const) - self.assertEquals(MODULE.getattr('__name__')[0].value, 'data.module') - self.assertEquals(len(MODULE.getattr('__doc__')), 1) + self.assertEqual(MODULE.getattr('__name__')[0].value, 'data.module') + self.assertEqual(len(MODULE.getattr('__doc__')), 1) self.assertIsInstance(MODULE.getattr('__doc__')[0], nodes.Const) - self.assertEquals(MODULE.getattr('__doc__')[0].value, 'test module for astng\n') - self.assertEquals(len(MODULE.getattr('__file__')), 1) + self.assertEqual(MODULE.getattr('__doc__')[0].value, 'test module for astng\n') + self.assertEqual(len(MODULE.getattr('__file__')), 1) self.assertIsInstance(MODULE.getattr('__file__')[0], nodes.Const) - self.assertEquals(MODULE.getattr('__file__')[0].value, abspath(join('data', 'module.py'))) - self.assertEquals(len(MODULE.getattr('__dict__')), 1) + self.assertEqual(MODULE.getattr('__file__')[0].value, abspath(join('data', 'module.py'))) + self.assertEqual(len(MODULE.getattr('__dict__')), 1) self.assertIsInstance(MODULE.getattr('__dict__')[0], nodes.Dict) self.assertRaises(NotFoundError, MODULE.getattr, '__path__') - self.assertEquals(len(PACK.getattr('__path__')), 1) + self.assertEqual(len(PACK.getattr('__path__')), 1) self.assertIsInstance(PACK.getattr('__path__')[0], nodes.List) def test_dict_interface(self): @@ -70,34 +70,34 @@ class ModuleNodeTC(TestCase): def test_getattr(self): yo = MODULE.getattr('YO')[0] self.assertIsInstance(yo, nodes.Class) - self.assertEquals(yo.name, 'YO') + self.assertEqual(yo.name, 'YO') red = MODULE.igetattr('redirect').next() self.assertIsInstance(red, nodes.Function) - self.assertEquals(red.name, 'nested_args') + self.assertEqual(red.name, 'nested_args') spawn = MODULE.igetattr('spawn').next() self.assertIsInstance(spawn, nodes.Class) - self.assertEquals(spawn.name, 'Execute') + self.assertEqual(spawn.name, 'Execute') # resolve packageredirection sys.path.insert(1, 'data') try: m = abuilder.file_build('data/appl/myConnection.py', 'appl.myConnection') cnx = m.igetattr('SSL1').next().igetattr('Connection').next() - self.assertEquals(cnx.__class__, nodes.Class) - self.assertEquals(cnx.name, 'Connection') - self.assertEquals(cnx.root().name, 'SSL1.Connection1') + self.assertEqual(cnx.__class__, nodes.Class) + self.assertEqual(cnx.name, 'Connection') + self.assertEqual(cnx.root().name, 'SSL1.Connection1') finally: del sys.path[1] - self.assertEquals(len(NONREGR.getattr('enumerate')), 2) + self.assertEqual(len(NONREGR.getattr('enumerate')), 2) # raise ResolveError self.assertRaises(InferenceError, MODULE.igetattr, 'YOAA') def test_wildard_import_names(self): m = abuilder.file_build('data/all.py', 'all') - self.assertEquals(m.wildcard_import_names(), ['Aaa', '_bla', 'name']) + self.assertEqual(m.wildcard_import_names(), ['Aaa', '_bla', 'name']) m = abuilder.file_build('data/notall.py', 'notall') res = m.wildcard_import_names() res.sort() - self.assertEquals(res, ['Aaa', 'func', 'name', 'other']) + self.assertEqual(res, ['Aaa', 'func', 'name', 'other']) def test_module_getattr(self): data = ''' @@ -107,7 +107,7 @@ del appli ''' astng = abuilder.string_build(data, __name__, __file__) # test del statement not returned by getattr - self.assertEquals(len(astng.getattr('appli')), 2, + self.assertEqual(len(astng.getattr('appli')), 2, astng.getattr('appli')) @@ -115,13 +115,13 @@ class FunctionNodeTC(TestCase): def test_special_attributes(self): func = MODULE2['make_class'] - self.assertEquals(len(func.getattr('__name__')), 1) + self.assertEqual(len(func.getattr('__name__')), 1) self.assertIsInstance(func.getattr('__name__')[0], nodes.Const) - self.assertEquals(func.getattr('__name__')[0].value, 'make_class') - self.assertEquals(len(func.getattr('__doc__')), 1) + self.assertEqual(func.getattr('__name__')[0].value, 'make_class') + self.assertEqual(len(func.getattr('__doc__')), 1) self.assertIsInstance(func.getattr('__doc__')[0], nodes.Const) - self.assertEquals(func.getattr('__doc__')[0].value, 'check base is correctly resolved to Concrete0') - self.assertEquals(len(MODULE.getattr('__dict__')), 1) + self.assertEqual(func.getattr('__doc__')[0].value, 'check base is correctly resolved to Concrete0') + self.assertEqual(len(MODULE.getattr('__dict__')), 1) self.assertIsInstance(MODULE.getattr('__dict__')[0], nodes.Dict) def test_dict_interface(self): @@ -135,11 +135,11 @@ class FunctionNodeTC(TestCase): self.assertRaises(scoped_nodes.NoDefault, func.args.default_value, 'any') #self.assertIsInstance(func.mularg_class('args'), nodes.Tuple) #self.assertIsInstance(func.mularg_class('kwargs'), nodes.Dict) - #self.assertEquals(func.mularg_class('base'), None) + #self.assertEqual(func.mularg_class('base'), None) def test_navigation(self): function = MODULE['global_access'] - self.assertEquals(function.statement(), function) + self.assertEqual(function.statement(), function) l_sibling = function.previous_sibling() # check taking parent if child is not a stmt self.assertIsInstance(l_sibling, nodes.Assign) @@ -147,27 +147,27 @@ class FunctionNodeTC(TestCase): self.assert_(l_sibling is child.previous_sibling()) r_sibling = function.next_sibling() self.assertIsInstance(r_sibling, nodes.Class) - self.assertEquals(r_sibling.name, 'YO') + self.assertEqual(r_sibling.name, 'YO') self.assert_(r_sibling is child.next_sibling()) last = r_sibling.next_sibling().next_sibling().next_sibling() self.assertIsInstance(last, nodes.Assign) - self.assertEquals(last.next_sibling(), None) + self.assertEqual(last.next_sibling(), None) first = l_sibling.previous_sibling().previous_sibling().previous_sibling().previous_sibling().previous_sibling() - self.assertEquals(first.previous_sibling(), None) + self.assertEqual(first.previous_sibling(), None) def test_nested_args(self): func = MODULE['nested_args'] - #self.assertEquals(func.args.args, ['a', ('b', 'c', 'd')]) + #self.assertEqual(func.args.args, ['a', ('b', 'c', 'd')]) local = func.keys() local.sort() - self.assertEquals(local, ['a', 'b', 'c', 'd']) - self.assertEquals(func.type, 'function') + self.assertEqual(local, ['a', 'b', 'c', 'd']) + self.assertEqual(func.type, 'function') def test_format_args(self): func = MODULE2['make_class'] - self.assertEquals(func.args.format_args(), 'any, base=data.module.YO, *args, **kwargs') + self.assertEqual(func.args.format_args(), 'any, base=data.module.YO, *args, **kwargs') func = MODULE['nested_args'] - self.assertEquals(func.args.format_args(), 'a, (b, c, d)') + self.assertEqual(func.args.format_args(), 'a, (b, c, d)') def test_is_abstract(self): method = MODULE2['AbstractClass']['to_override'] @@ -182,13 +182,13 @@ class FunctionNodeTC(TestCase): ## def test_raises(self): ## method = MODULE2['AbstractClass']['to_override'] -## self.assertEquals([str(term) for term in method.raises()], +## self.assertEqual([str(term) for term in method.raises()], ## ["CallFunc(Name('NotImplementedError'), [], None, None)"] ) ## def test_returns(self): ## method = MODULE2['AbstractClass']['return_something'] ## # use string comp since Node doesn't handle __cmp__ -## self.assertEquals([str(term) for term in method.returns()], +## self.assertEqual([str(term) for term in method.returns()], ## ["Const('toto')", "Const(None)"]) def test_lambda_pytype(self): @@ -202,7 +202,7 @@ def f(): def test_is_method(self): if sys.version_info < (2, 4): - self.skip('this test require python >= 2.4') + self.skipTest('this test require python >= 2.4') data = ''' class A: def meth1(self): @@ -231,7 +231,7 @@ def sfunction(): def test_argnames(self): code = 'def f(a, (b, c), *args, **kwargs): pass' astng = abuilder.string_build(code, __name__, __file__) - self.assertEquals(astng['f'].argnames(), ['a', 'b', 'c', 'args', 'kwargs']) + self.assertEqual(astng['f'].argnames(), ['a', 'b', 'c', 'args', 'kwargs']) class ClassNodeTC(TestCase): @@ -241,26 +241,26 @@ class ClassNodeTC(TestCase): def test_cls_special_attributes_1(self): cls = MODULE['YO'] - self.assertEquals(len(cls.getattr('__bases__')), 1) - self.assertEquals(len(cls.getattr('__name__')), 1) + self.assertEqual(len(cls.getattr('__bases__')), 1) + self.assertEqual(len(cls.getattr('__name__')), 1) self.assertIsInstance(cls.getattr('__name__')[0], nodes.Const) - self.assertEquals(cls.getattr('__name__')[0].value, 'YO') - self.assertEquals(len(cls.getattr('__doc__')), 1) + self.assertEqual(cls.getattr('__name__')[0].value, 'YO') + self.assertEqual(len(cls.getattr('__doc__')), 1) self.assertIsInstance(cls.getattr('__doc__')[0], nodes.Const) - self.assertEquals(cls.getattr('__doc__')[0].value, 'hehe') - self.assertEquals(len(cls.getattr('__module__')), 1) + self.assertEqual(cls.getattr('__doc__')[0].value, 'hehe') + self.assertEqual(len(cls.getattr('__module__')), 1) self.assertIsInstance(cls.getattr('__module__')[0], nodes.Const) - self.assertEquals(cls.getattr('__module__')[0].value, 'data.module') - self.assertEquals(len(cls.getattr('__dict__')), 1) + self.assertEqual(cls.getattr('__module__')[0].value, 'data.module') + self.assertEqual(len(cls.getattr('__dict__')), 1) self.assertRaises(NotFoundError, cls.getattr, '__mro__') for cls in (nodes.List._proxied, nodes.Const(1)._proxied): - self.assertEquals(len(cls.getattr('__bases__')), 1) - self.assertEquals(len(cls.getattr('__name__')), 1) - self.assertEquals(len(cls.getattr('__doc__')), 1, (cls, cls.getattr('__doc__'))) - self.assertEquals(cls.getattr('__doc__')[0].value, cls.doc) - self.assertEquals(len(cls.getattr('__module__')), 1) - self.assertEquals(len(cls.getattr('__dict__')), 1) - self.assertEquals(len(cls.getattr('__mro__')), 1) + self.assertEqual(len(cls.getattr('__bases__')), 1) + self.assertEqual(len(cls.getattr('__name__')), 1) + self.assertEqual(len(cls.getattr('__doc__')), 1, (cls, cls.getattr('__doc__'))) + self.assertEqual(cls.getattr('__doc__')[0].value, cls.doc) + self.assertEqual(len(cls.getattr('__module__')), 1) + self.assertEqual(len(cls.getattr('__dict__')), 1) + self.assertEqual(len(cls.getattr('__mro__')), 1) def test_cls_special_attributes_2(self): astng = abuilder.string_build(''' @@ -269,7 +269,7 @@ class B: pass A.__bases__ += (B,) ''', __name__, __file__) - self.assertEquals(len(astng['A'].getattr('__bases__')), 2) + self.assertEqual(len(astng['A'].getattr('__bases__')), 2) self.assertIsInstance(astng['A'].getattr('__bases__')[0], nodes.Tuple) self.assertIsInstance(astng['A'].getattr('__bases__')[1], nodes.AssAttr) @@ -278,25 +278,25 @@ A.__bases__ += (B,) self.assertRaises(NotFoundError, inst.getattr, '__mro__') self.assertRaises(NotFoundError, inst.getattr, '__bases__') self.assertRaises(NotFoundError, inst.getattr, '__name__') - self.assertEquals(len(inst.getattr('__dict__')), 1) - self.assertEquals(len(inst.getattr('__doc__')), 1) + self.assertEqual(len(inst.getattr('__dict__')), 1) + self.assertEqual(len(inst.getattr('__doc__')), 1) def test_navigation(self): klass = MODULE['YO'] - self.assertEquals(klass.statement(), klass) + self.assertEqual(klass.statement(), klass) l_sibling = klass.previous_sibling() self.assert_(isinstance(l_sibling, nodes.Function), l_sibling) - self.assertEquals(l_sibling.name, 'global_access') + self.assertEqual(l_sibling.name, 'global_access') r_sibling = klass.next_sibling() self.assertIsInstance(r_sibling, nodes.Class) - self.assertEquals(r_sibling.name, 'YOUPI') + self.assertEqual(r_sibling.name, 'YOUPI') def test_local_attr_ancestors(self): klass2 = MODULE['YOUPI'] it = klass2.local_attr_ancestors('__init__') anc_klass = it.next() self.assertIsInstance(anc_klass, nodes.Class) - self.assertEquals(anc_klass.name, 'YO') + self.assertEqual(anc_klass.name, 'YO') self.assertRaises(StopIteration, it.next) it = klass2.local_attr_ancestors('method') self.assertRaises(StopIteration, it.next) @@ -306,7 +306,7 @@ A.__bases__ += (B,) it = klass2.instance_attr_ancestors('yo') anc_klass = it.next() self.assertIsInstance(anc_klass, nodes.Class) - self.assertEquals(anc_klass.name, 'YO') + self.assertEqual(anc_klass.name, 'YO') self.assertRaises(StopIteration, it.next) klass2 = MODULE['YOUPI'] it = klass2.instance_attr_ancestors('member') @@ -316,23 +316,23 @@ A.__bases__ += (B,) klass2 = MODULE['YOUPI'] methods = [m.name for m in klass2.methods()] methods.sort() - self.assertEquals(methods, ['__init__', 'class_method', + self.assertEqual(methods, ['__init__', 'class_method', 'method', 'static_method']) methods = [m.name for m in klass2.mymethods()] methods.sort() - self.assertEquals(methods, ['__init__', 'class_method', + self.assertEqual(methods, ['__init__', 'class_method', 'method', 'static_method']) klass2 = MODULE2['Specialization'] methods = [m.name for m in klass2.mymethods()] methods.sort() - self.assertEquals(methods, []) + self.assertEqual(methods, []) method_locals = klass2.local_attr('method') - self.assertEquals(len(method_locals), 1) - self.assertEquals(method_locals[0].name, 'method') + self.assertEqual(len(method_locals), 1) + self.assertEqual(method_locals[0].name, 'method') self.assertRaises(NotFoundError, klass2.local_attr, 'nonexistant') methods = [m.name for m in klass2.methods()] methods.sort() - self.assertEquals(methods, ['__init__', 'class_method', + self.assertEqual(methods, ['__init__', 'class_method', 'method', 'static_method']) #def test_rhs(self): @@ -341,27 +341,27 @@ A.__bases__ += (B,) # a = MODULE['YO']['a'] # value = a.rhs() # self.assertIsInstance(value, nodes.Const) - # self.assertEquals(value.value, 1) + # self.assertEqual(value.value, 1) def test_ancestors(self): klass = MODULE['YOUPI'] ancs = [a.name for a in klass.ancestors()] - self.assertEquals(ancs, ['YO']) + self.assertEqual(ancs, ['YO']) klass = MODULE2['Specialization'] ancs = [a.name for a in klass.ancestors()] - self.assertEquals(ancs, ['YOUPI', 'YO', 'YO']) + self.assertEqual(ancs, ['YOUPI', 'YO', 'YO']) def test_type(self): klass = MODULE['YOUPI'] - self.assertEquals(klass.type, 'class') + self.assertEqual(klass.type, 'class') klass = MODULE2['Metaclass'] - self.assertEquals(klass.type, 'metaclass') + self.assertEqual(klass.type, 'metaclass') klass = MODULE2['MyException'] - self.assertEquals(klass.type, 'exception') + self.assertEqual(klass.type, 'exception') klass = MODULE2['MyIFace'] - self.assertEquals(klass.type, 'interface') + self.assertEqual(klass.type, 'interface') klass = MODULE2['MyError'] - self.assertEquals(klass.type, 'exception') + self.assertEqual(klass.type, 'exception') def test_interfaces(self): for klass, interfaces in (('Concrete0', ['MyIFace']), @@ -369,7 +369,7 @@ A.__bases__ += (B,) ('Concrete2', ['MyIFace', 'AnotherIFace']), ('Concrete23', ['MyIFace', 'AnotherIFace'])): klass = MODULE2[klass] - self.assertEquals([i.name for i in klass.interfaces()], + self.assertEqual([i.name for i in klass.interfaces()], interfaces) def test_concat_interfaces(self): @@ -389,12 +389,12 @@ class InterfaceCanNowBeFound: __implements__ = BadArgument.__implements__ + Correct2.__implements__ ''') - self.assertEquals([i.name for i in astng['InterfaceCanNowBeFound'].interfaces()], + self.assertEqual([i.name for i in astng['InterfaceCanNowBeFound'].interfaces()], ['IMachin']) def test_inner_classes(self): eee = NONREGR['Ccc']['Eee'] - self.assertEquals([n.name for n in eee.ancestors()], ['Ddd', 'Aaa', 'object']) + self.assertEqual([n.name for n in eee.ancestors()], ['Ddd', 'Aaa', 'object']) def test_classmethod_attributes(self): @@ -409,7 +409,7 @@ class WebAppObject(object): ''' astng = abuilder.string_build(data, __name__, __file__) cls = astng['WebAppObject'] - self.assertEquals(sorted(cls.locals.keys()), + self.assertEqual(sorted(cls.locals.keys()), ['appli', 'config', 'registered', 'schema']) @@ -423,7 +423,7 @@ class WebAppObject(object): astng = abuilder.string_build(data, __name__, __file__) cls = astng['WebAppObject'] # test del statement not returned by getattr - self.assertEquals(len(cls.getattr('appli')), 2) + self.assertEqual(len(cls.getattr('appli')), 2) def test_instance_getattr(self): @@ -437,7 +437,7 @@ class WebAppObject(object): astng = abuilder.string_build(data, __name__, __file__) inst = Instance(astng['WebAppObject']) # test del statement not returned by getattr - self.assertEquals(len(inst.getattr('appli')), 2) + self.assertEqual(len(inst.getattr('appli')), 2) def test_instance_getattr_with_class_attr(self): @@ -460,9 +460,9 @@ class Klass(Parent): ''' astng = abuilder.string_build(data, __name__, __file__) inst = Instance(astng['Klass']) - self.assertEquals(len(inst.getattr('aa')), 3, inst.getattr('aa')) - self.assertEquals(len(inst.getattr('bb')), 1, inst.getattr('bb')) - self.assertEquals(len(inst.getattr('cc')), 2, inst.getattr('cc')) + self.assertEqual(len(inst.getattr('aa')), 3, inst.getattr('aa')) + self.assertEqual(len(inst.getattr('bb')), 1, inst.getattr('bb')) + self.assertEqual(len(inst.getattr('cc')), 2, inst.getattr('cc')) def test_getattr_method_transform(self): @@ -486,13 +486,13 @@ inst.m4 = func # test del statement not returned by getattr for method in ('m1', 'm2', 'm3'): inferred = list(cls.igetattr(method)) - self.assertEquals(len(inferred), 1) + self.assertEqual(len(inferred), 1) self.assertIsInstance(inferred[0], UnboundMethod) inferred = list(Instance(cls).igetattr(method)) - self.assertEquals(len(inferred), 1) + self.assertEqual(len(inferred), 1) self.assertIsInstance(inferred[0], BoundMethod) inferred = list(Instance(cls).igetattr('m4')) - self.assertEquals(len(inferred), 1) + self.assertEqual(len(inferred), 1) self.assertIsInstance(inferred[0], nodes.Function) __all__ = ('ModuleNodeTC', 'ImportNodeTC', 'FunctionNodeTC', 'ClassNodeTC') diff --git a/test/unittest_utils.py b/test/unittest_utils.py index a1606f34..ba19de37 100644 --- a/test/unittest_utils.py +++ b/test/unittest_utils.py @@ -39,8 +39,8 @@ if x > 0: xnames = [n for n in astng.nodes_of_class(nodes.Name) if n.name == 'x'] assert len(xnames) == 3 assert xnames[1].lineno == 6 - self.assertEquals(are_exclusive(xass1, xnames[1]), False) - self.assertEquals(are_exclusive(xass1, xnames[2]), False) + self.assertEqual(are_exclusive(xass1, xnames[1]), False) + self.assertEqual(are_exclusive(xass1, xnames[2]), False) def test_if(self): astng = builder.string_build(''' @@ -61,12 +61,12 @@ else: a4 = astng.locals['a'][3] a5 = astng.locals['a'][4] a6 = astng.locals['a'][5] - self.assertEquals(are_exclusive(a1, a2), False) - self.assertEquals(are_exclusive(a1, a3), True) - self.assertEquals(are_exclusive(a1, a5), True) - self.assertEquals(are_exclusive(a3, a5), True) - self.assertEquals(are_exclusive(a3, a4), False) - self.assertEquals(are_exclusive(a5, a6), False) + 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_try_except(self): astng = builder.string_build(''' @@ -88,16 +88,16 @@ else: f2 = astng.locals['exclusive_func2'][1] f3 = astng.locals['exclusive_func2'][2] f4 = astng.locals['exclusive_func2'][3] - self.assertEquals(are_exclusive(f1, f2), True) - self.assertEquals(are_exclusive(f1, f3), True) - self.assertEquals(are_exclusive(f1, f4), False) - self.assertEquals(are_exclusive(f2, f4), True) - self.assertEquals(are_exclusive(f3, f4), True) - self.assertEquals(are_exclusive(f3, f2), True) + 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.assertEquals(are_exclusive(f2, f1), True) - self.assertEquals(are_exclusive(f4, f1), False) - self.assertEquals(are_exclusive(f4, f2), True) + self.assertEqual(are_exclusive(f2, f1), True) + self.assertEqual(are_exclusive(f4, f1), False) + self.assertEqual(are_exclusive(f4, f2), True) if __name__ == '__main__': unittest_main() @@ -37,7 +37,7 @@ extract information from it __docformat__ = "restructuredtext en" from logilab.astng._exceptions import IgnoreChild, ASTNGBuildingException - +from logilab.common.compat import set class ASTVisitor(object): """Abstract Base Class for Python AST Visitors. |