From 9a35259c0ab67e2bac9aa3b2cf4d7d0854ed0673 Mon Sep 17 00:00:00 2001 From: emacsway Date: Thu, 31 Dec 2015 22:39:18 +0200 Subject: [PATCH 01/92] Hinting the type using docstring of functions --- rope/base/oi/docstrings.py | 144 +++++++++++++++++++++++++++++++++++++ rope/base/oi/soi.py | 2 + 2 files changed, 146 insertions(+) create mode 100644 rope/base/oi/docstrings.py diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py new file mode 100644 index 000000000..048a02975 --- /dev/null +++ b/rope/base/oi/docstrings.py @@ -0,0 +1,144 @@ +""" +Hinting the type using docstring of class/function like here +https://www.jetbrains.com/pycharm/help/type-hinting-in-pycharm.html#d290117e333 + +It's a necessary thing if you are using Dependency Injection +(three ways - Constructor Injection, Setter Injection, and Interface Injection): +http://www.martinfowler.com/articles/injection.html + +Some code extracted (or based on code) from: +https://github.com/davidhalter/jedi/blob/b489019f5bd5750051122b94cc767df47751ecb7/jedi/evaluate/docstrings.py +Thanks to @davidhalter for MIT License. +""" +import re +from ast import literal_eval + +from rope.base.evaluate import ScopeNameFinder + +DOCSTRING_PARAM_PATTERNS = [ + r'\s*:type\s+%s:\s*([^\n]+)', # Sphinx + r'\s*:param\s+(\w+)\s+%s:[^\n]+', # Sphinx param with type + r'\s*@type\s+%s:\s*([^\n]+)', # Epydoc +] + +DOCSTRING_RETURN_PATTERNS = [ + re.compile(r'\s*:rtype:\s*([^\n]+)', re.M), # Sphinx + re.compile(r'\s*@rtype:\s*([^\n]+)', re.M), # Epydoc +] + +REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`') + + +try: + from numpydoc.docscrape import NumpyDocString +except ImportError: + def _search_param_in_numpydocstr(docstr, param_str): + return [] +else: + def _search_param_in_numpydocstr(docstr, param_str): + """Search `docstr` (in numpydoc format) for type(-s) of `param_str`.""" + params = NumpyDocString(docstr)._parsed_data['Parameters'] + for p_name, p_type, p_descr in params: + if p_name == param_str: + m = re.match('([^,]+(,[^,]+)*?)(,[ ]*optional)?$', p_type) + if m: + p_type = m.group(1) + + if p_type.startswith('{'): + types = set(type(x).__name__ for x in literal_eval(p_type)) + return list(types) + else: + return [p_type] + return [] + + +def _handle_nonfirst_parameters(pyobject, parameters): + doc_str = pyobject.get_doc() + if not doc_str: + return + + for i, (name, val) in enumerate(zip(pyobject.get_param_names(), parameters)): + if i == 0: + continue + + type_strs = _search_param_in_docstr(doc_str, name) + if type_strs: + type_ = _resolve_type(type_strs[0], pyobject) + if type_ is not None: + val.type = type_ + + +def _resolve_type(type_name, pyobject): + type_ = None + if '.' not in type_name: + try: + type_ = pyobject.get_module().get_scope().get_name(type_name).get_object() + except Exception: + pass + else: + mod_name, attr_name = type_name.rsplit('.', 1) + try: + mod_finder = ScopeNameFinder(pyobject.get_module()) + mod = mod_finder._find_module(mod_name).get_object() + type_ = mod.get_attribute(attr_name).get_object() + except Exception: + pass + return type_ + + +def _search_param_in_docstr(docstr, param_str): + """ + Search `docstr` for type(-s) of `param_str`. + + >>> _search_param_in_docstr(':type param: int', 'param') + ['int'] + >>> _search_param_in_docstr('@type param: int', 'param') + ['int'] + >>> _search_param_in_docstr( + ... ':type param: :class:`threading.Thread`', 'param') + ['threading.Thread'] + >>> bool(_search_param_in_docstr('no document', 'param')) + False + >>> _search_param_in_docstr(':param int param: some description', 'param') + ['int'] + + """ + # look at #40 to see definitions of those params + patterns = [re.compile(p % re.escape(param_str)) + for p in DOCSTRING_PARAM_PATTERNS] + for pattern in patterns: + match = pattern.search(docstr) + if match: + return [_strip_rst_role(match.group(1))] + + return (_search_param_in_numpydocstr(docstr, param_str) or + []) + + +def _strip_rst_role(type_str): + """ + Strip off the part looks like a ReST role in `type_str`. + + >>> _strip_rst_role(':class:`ClassName`') # strip off :class: + 'ClassName' + >>> _strip_rst_role(':py:obj:`module.Object`') # works with domain + 'module.Object' + >>> _strip_rst_role('ClassName') # do nothing when not ReST role + 'ClassName' + + See also: + http://sphinx-doc.org/domains.html#cross-referencing-python-objects + + """ + match = REST_ROLE_PATTERN.match(type_str) + if match: + return match.group(1) + else: + return type_str + + +def _search_return_in_docstr(code): + for p in DOCSTRING_RETURN_PATTERNS: + match = p.search(code) + if match: + return _strip_rst_role(match.group(1)) diff --git a/rope/base/oi/soi.py b/rope/base/oi/soi.py index 5a11b5efd..ce76ce8ca 100644 --- a/rope/base/oi/soi.py +++ b/rope/base/oi/soi.py @@ -8,6 +8,7 @@ import rope.base.pynames import rope.base.pyobjects from rope.base import evaluate, utils, arguments +from rope.base.oi.docstrings import _handle_nonfirst_parameters _ignore_inferred = utils.ignore_exception( @@ -39,6 +40,7 @@ def infer_parameter_objects(pyfunction): if result is None: result = _parameter_objects(pyfunction) _handle_first_parameter(pyfunction, result) + _handle_nonfirst_parameters(pyfunction, result) return result From b3036003c59f4f9c62f71b9cbf69b565b413c78d Mon Sep 17 00:00:00 2001 From: emacsway Date: Fri, 1 Jan 2016 06:09:07 +0200 Subject: [PATCH 02/92] Support for hierarchical tree (Interface) when Hinting the type using docstring of functions --- rope/base/oi/docstrings.py | 47 ++++++++++++++++++++++++++++++-------- 1 file changed, 38 insertions(+), 9 deletions(-) diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index 048a02975..ef61cb941 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -13,17 +13,19 @@ import re from ast import literal_eval +from rope.base.exceptions import AttributeNotFoundError from rope.base.evaluate import ScopeNameFinder +from rope.base.pyobjects import PyObject, PyClass DOCSTRING_PARAM_PATTERNS = [ - r'\s*:type\s+%s:\s*([^\n]+)', # Sphinx - r'\s*:param\s+(\w+)\s+%s:[^\n]+', # Sphinx param with type - r'\s*@type\s+%s:\s*([^\n]+)', # Epydoc + r'\s*:type\s+%s:\s*([^\n, ]+)', # Sphinx + r'\s*:param\s+(\w+)\s+%s:[^\n, ]+', # Sphinx param with type + r'\s*@type\s+%s:\s*([^\n, ]+)', # Epydoc ] DOCSTRING_RETURN_PATTERNS = [ - re.compile(r'\s*:rtype:\s*([^\n]+)', re.M), # Sphinx - re.compile(r'\s*@rtype:\s*([^\n]+)', re.M), # Epydoc + re.compile(r'\s*:rtype:\s*([^\n, ]+)', re.M), # Sphinx + re.compile(r'\s*@rtype:\s*([^\n, ]+)', re.M), # Epydoc ] REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`') @@ -53,21 +55,48 @@ def _search_param_in_numpydocstr(docstr, param_str): def _handle_nonfirst_parameters(pyobject, parameters): - doc_str = pyobject.get_doc() - if not doc_str: - return for i, (name, val) in enumerate(zip(pyobject.get_param_names(), parameters)): if i == 0: continue + if not val or not isinstance(val.get_type(), PyObject): + continue + + type_strs = None + func = pyobject + while not type_strs and func: + if func.get_doc(): + type_strs = _search_param_in_docstr(func.get_doc(), name) + func = _get_superfunc(func) - type_strs = _search_param_in_docstr(doc_str, name) if type_strs: type_ = _resolve_type(type_strs[0], pyobject) if type_ is not None: val.type = type_ +def _get_superfunc(pyobject): + + if not isinstance(pyobject.parent, PyClass): + return + + for cls in _get_mro(pyobject.parent)[1:]: + try: + return cls.get_attribute(pyobject.get_name()).get_object() + except AttributeNotFoundError: + pass + + +def _get_mro(pyclass): + # FIXME: to use real mro() result + l = [pyclass] + for cls in l: + for super_cls in cls.get_superclasses(): + if super_cls not in l: + l.append(super_cls) + return l + + def _resolve_type(type_name, pyobject): type_ = None if '.' not in type_name: From 4790e490d0cd394374eda111409fe543ece23011 Mon Sep 17 00:00:00 2001 From: emacsway Date: Fri, 1 Jan 2016 06:36:53 +0200 Subject: [PATCH 03/92] Hinting the return type using docstring of functions --- rope/base/oi/docstrings.py | 53 ++++++++++++++++++++++++-------------- rope/base/oi/soi.py | 7 +++-- 2 files changed, 38 insertions(+), 22 deletions(-) diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index ef61cb941..3a9ed6cf6 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -54,35 +54,37 @@ def _search_param_in_numpydocstr(docstr, param_str): return [] -def _handle_nonfirst_parameters(pyobject, parameters): - - for i, (name, val) in enumerate(zip(pyobject.get_param_names(), parameters)): +def _handle_nonfirst_parameters(pyfunc, parameters): + for i, (name, val) in enumerate(zip(pyfunc.get_param_names(), parameters)): if i == 0: continue if not val or not isinstance(val.get_type(), PyObject): continue + type_ = hint_param(name, pyfunc) + if type_ is not None: + val.type = type_ + - type_strs = None - func = pyobject - while not type_strs and func: - if func.get_doc(): - type_strs = _search_param_in_docstr(func.get_doc(), name) - func = _get_superfunc(func) +def hint_param(name, pyfunc): + type_strs = None + func = pyfunc + while not type_strs and func: + if func.get_doc(): + type_strs = _search_param_in_docstr(func.get_doc(), name) + func = _get_superfunc(func) - if type_strs: - type_ = _resolve_type(type_strs[0], pyobject) - if type_ is not None: - val.type = type_ + if type_strs: + return _resolve_type(type_strs[0], pyfunc) -def _get_superfunc(pyobject): +def _get_superfunc(pyfunc): - if not isinstance(pyobject.parent, PyClass): + if not isinstance(pyfunc.parent, PyClass): return - for cls in _get_mro(pyobject.parent)[1:]: + for cls in _get_mro(pyfunc.parent)[1:]: try: - return cls.get_attribute(pyobject.get_name()).get_object() + return cls.get_attribute(pyfunc.get_name()).get_object() except AttributeNotFoundError: pass @@ -97,17 +99,17 @@ def _get_mro(pyclass): return l -def _resolve_type(type_name, pyobject): +def _resolve_type(type_name, pyfunc): type_ = None if '.' not in type_name: try: - type_ = pyobject.get_module().get_scope().get_name(type_name).get_object() + type_ = pyfunc.get_module().get_scope().get_name(type_name).get_object() except Exception: pass else: mod_name, attr_name = type_name.rsplit('.', 1) try: - mod_finder = ScopeNameFinder(pyobject.get_module()) + mod_finder = ScopeNameFinder(pyfunc.get_module()) mod = mod_finder._find_module(mod_name).get_object() type_ = mod.get_attribute(attr_name).get_object() except Exception: @@ -166,6 +168,17 @@ def _strip_rst_role(type_str): return type_str +def hint_return(pyfunc): + type_str = None + func = pyfunc + while not type_str and func: + if func.get_doc(): + type_str = _search_return_in_docstr(func.get_doc()) + func = _get_superfunc(func) + if type_str: + return _resolve_type(type_str, pyfunc) + + def _search_return_in_docstr(code): for p in DOCSTRING_RETURN_PATTERNS: match = p.search(code) diff --git a/rope/base/oi/soi.py b/rope/base/oi/soi.py index ce76ce8ca..35733d209 100644 --- a/rope/base/oi/soi.py +++ b/rope/base/oi/soi.py @@ -8,7 +8,7 @@ import rope.base.pynames import rope.base.pyobjects from rope.base import evaluate, utils, arguments -from rope.base.oi.docstrings import _handle_nonfirst_parameters +from rope.base.oi.docstrings import _handle_nonfirst_parameters, hint_return _ignore_inferred = utils.ignore_exception( @@ -29,7 +29,10 @@ def infer_returned_object(pyfunction, args): pyfunction.get_param_names(special_args=False)) object_info.function_called(pyfunction, params, result) return result - return object_info.get_returned(pyfunction, args) + result = object_info.get_returned(pyfunction, args) + if result is not None: + return result + return hint_return(pyfunction) @_ignore_inferred From 1cfe36a8b7e2712dd21607aa6e88b07472a09a06 Mon Sep 17 00:00:00 2001 From: emacsway Date: Fri, 1 Jan 2016 08:27:34 +0200 Subject: [PATCH 04/92] Fixed params order and param names in type hinting for function args, added type hinting for class attrs in rope/base/oi/docstrings.py --- rope/base/oi/docstrings.py | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-) diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index 3a9ed6cf6..1a70b26d5 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -60,17 +60,17 @@ def _handle_nonfirst_parameters(pyfunc, parameters): continue if not val or not isinstance(val.get_type(), PyObject): continue - type_ = hint_param(name, pyfunc) + type_ = hint_param(pyfunc, name) if type_ is not None: val.type = type_ -def hint_param(name, pyfunc): +def hint_param(pyfunc, param_name): type_strs = None func = pyfunc while not type_strs and func: if func.get_doc(): - type_strs = _search_param_in_docstr(func.get_doc(), name) + type_strs = _search_param_in_docstr(func.get_doc(), param_name) func = _get_superfunc(func) if type_strs: @@ -99,17 +99,17 @@ def _get_mro(pyclass): return l -def _resolve_type(type_name, pyfunc): +def _resolve_type(type_name, pyobj): type_ = None if '.' not in type_name: try: - type_ = pyfunc.get_module().get_scope().get_name(type_name).get_object() + type_ = pyobj.get_module().get_scope().get_name(type_name).get_object() except Exception: pass else: mod_name, attr_name = type_name.rsplit('.', 1) try: - mod_finder = ScopeNameFinder(pyfunc.get_module()) + mod_finder = ScopeNameFinder(pyobj.get_module()) mod = mod_finder._find_module(mod_name).get_object() type_ = mod.get_attribute(attr_name).get_object() except Exception: @@ -184,3 +184,14 @@ def _search_return_in_docstr(code): match = p.search(code) if match: return _strip_rst_role(match.group(1)) + + +def hint_attr(pyclass, attr_name): + type_strs = None + for cls in _get_mro(pyclass): + if cls.get_doc(): + type_strs = _search_param_in_docstr(cls.get_doc(), attr_name) + if type_strs: + break + if type_strs: + return _resolve_type(type_strs[0], pyclass) From b40b77dcef1c8c235aa14ee2024d087afba5b578 Mon Sep 17 00:00:00 2001 From: emacsway Date: Fri, 1 Jan 2016 23:23:21 +0200 Subject: [PATCH 05/92] Fixed bug related to cache in rope/base/pyobjects.py(118)get_unknown() --- rope/base/oi/docstrings.py | 3 ++- rope/base/oi/soi.py | 16 ++++++++++++---- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index 1a70b26d5..a99a6a20d 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -55,6 +55,7 @@ def _search_param_in_numpydocstr(docstr, param_str): def _handle_nonfirst_parameters(pyfunc, parameters): + # TODO: Kill me in favor of _parameter_objects() for i, (name, val) in enumerate(zip(pyfunc.get_param_names(), parameters)): if i == 0: continue @@ -62,7 +63,7 @@ def _handle_nonfirst_parameters(pyfunc, parameters): continue type_ = hint_param(pyfunc, name) if type_ is not None: - val.type = type_ + parameters[i] = PyObject(type_) def hint_param(pyfunc, param_name): diff --git a/rope/base/oi/soi.py b/rope/base/oi/soi.py index 35733d209..c1e93d6fd 100644 --- a/rope/base/oi/soi.py +++ b/rope/base/oi/soi.py @@ -8,7 +8,7 @@ import rope.base.pynames import rope.base.pyobjects from rope.base import evaluate, utils, arguments -from rope.base.oi.docstrings import _handle_nonfirst_parameters, hint_return +from rope.base.oi.docstrings import hint_return, hint_param _ignore_inferred = utils.ignore_exception( @@ -32,7 +32,9 @@ def infer_returned_object(pyfunction, args): result = object_info.get_returned(pyfunction, args) if result is not None: return result - return hint_return(pyfunction) + type_ = hint_return(pyfunction) + if type_: + return rope.base.pyobjects.PyObject(type_) @_ignore_inferred @@ -43,7 +45,6 @@ def infer_parameter_objects(pyfunction): if result is None: result = _parameter_objects(pyfunction) _handle_first_parameter(pyfunction, result) - _handle_nonfirst_parameters(pyfunction, result) return result @@ -111,8 +112,15 @@ def _infer_returned(pyobject, args): def _parameter_objects(pyobject): + result = [] params = pyobject.get_param_names(special_args=False) - return [rope.base.pyobjects.get_unknown()] * len(params) + for name in params: + type_ = hint_param(pyobject, name) + if type_ is not None: + result.append(rope.base.pyobjects.PyObject(type_)) + else: + result.append(rope.base.pyobjects.get_unknown()) + return result # handling `rope.base.pynames.AssignmentValue` From 4d36f685b3382e1fbf08a8a145264b1ab8224c43 Mon Sep 17 00:00:00 2001 From: emacsway Date: Fri, 1 Jan 2016 23:29:48 +0200 Subject: [PATCH 06/92] Removed redundant _handle_nonfirst_parameters() --- rope/base/oi/docstrings.py | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index a99a6a20d..e36470fa3 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -15,7 +15,7 @@ from rope.base.exceptions import AttributeNotFoundError from rope.base.evaluate import ScopeNameFinder -from rope.base.pyobjects import PyObject, PyClass +from rope.base.pyobjects import PyClass DOCSTRING_PARAM_PATTERNS = [ r'\s*:type\s+%s:\s*([^\n, ]+)', # Sphinx @@ -54,18 +54,6 @@ def _search_param_in_numpydocstr(docstr, param_str): return [] -def _handle_nonfirst_parameters(pyfunc, parameters): - # TODO: Kill me in favor of _parameter_objects() - for i, (name, val) in enumerate(zip(pyfunc.get_param_names(), parameters)): - if i == 0: - continue - if not val or not isinstance(val.get_type(), PyObject): - continue - type_ = hint_param(pyfunc, name) - if type_ is not None: - parameters[i] = PyObject(type_) - - def hint_param(pyfunc, param_name): type_strs = None func = pyfunc From e6e2f3207c381f24c34b69571a0c67fb71e7601b Mon Sep 17 00:00:00 2001 From: emacsway Date: Fri, 1 Jan 2016 23:33:05 +0200 Subject: [PATCH 07/92] Be sure, that variable is not None, to be completely independent of the special operator overloading methods --- rope/base/oi/soi.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rope/base/oi/soi.py b/rope/base/oi/soi.py index c1e93d6fd..99f74fb80 100644 --- a/rope/base/oi/soi.py +++ b/rope/base/oi/soi.py @@ -33,7 +33,7 @@ def infer_returned_object(pyfunction, args): if result is not None: return result type_ = hint_return(pyfunction) - if type_: + if type_ is not None: return rope.base.pyobjects.PyObject(type_) From d0fd51b5c1e53075094fc4828442c7d49440a76b Mon Sep 17 00:00:00 2001 From: emacsway Date: Sat, 2 Jan 2016 06:12:04 +0200 Subject: [PATCH 08/92] Hinting the attribute type using docstring of class --- rope/base/oi/soi.py | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/rope/base/oi/soi.py b/rope/base/oi/soi.py index 99f74fb80..c762b3a55 100644 --- a/rope/base/oi/soi.py +++ b/rope/base/oi/soi.py @@ -8,7 +8,7 @@ import rope.base.pynames import rope.base.pyobjects from rope.base import evaluate, utils, arguments -from rope.base.oi.docstrings import hint_return, hint_param +from rope.base.oi.docstrings import hint_return, hint_param, hint_attr _ignore_inferred = utils.ignore_exception( @@ -70,6 +70,20 @@ def infer_assigned_object(pyname): result = _infer_assignment(assignment, pyname.module) if result is not None: return result + return _infer_assigned_object_by_hint(pyname) + + +def _infer_assigned_object_by_hint(pyname): + lineno = _get_lineno_for_node(pyname.assignments[0].ast_node) + holding_scope = pyname.module.get_scope().get_inner_scope_for_line(lineno) + pyobject = holding_scope.pyobject + if isinstance(pyobject, rope.base.pyobjects.PyClass): + for name, attr in pyobject.get_attributes().items(): + if attr is pyname: + type_ = hint_attr(pyobject, name) + if type_ is not None: + return rope.base.pyobjects.PyObject(type_) + break def get_passed_objects(pyfunction, parameter_index): From 6da5e53097f561046aefb2c3d6ade7dd3c98ba4c Mon Sep 17 00:00:00 2001 From: emacsway Date: Sat, 2 Jan 2016 06:59:21 +0200 Subject: [PATCH 09/92] Added docs about type hinting using docstring --- CONTRIBUTORS | 1 + docs/overview.rst | 75 +++++++++++++++++++++++++++++++++++++++++++++++ docs/rope.rst | 1 + 3 files changed, 77 insertions(+) diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 1b8a24cff..d78bb1a7a 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -12,3 +12,4 @@ See Mercurial logs and the mailing list for details. * Orestis Markou * Ronny Pfannschmidt * Anton Gritsay +* Ivan Zakrevsky diff --git a/docs/overview.rst b/docs/overview.rst index fe4458482..bcb2e95b5 100644 --- a/docs/overview.rst +++ b/docs/overview.rst @@ -1209,6 +1209,81 @@ Rope uses this feature by default but you can disable it by editing ``config.py``. +Type Hinting +------------ + +If rope cannot detect the type of a function argument correctly (due to the +dynamic nature of Python), you can help it by hinting the type using +one of the following docstring syntax styles: + +**Sphinx style** + +http://sphinx-doc.org/domains.html#info-field-lists + +:: + + def myfunction(node, foo): + """Do something with a ``node``. + + :type node: ProgramNode + :param str foo: foo parameter description + + """ + node.| # complete here + +**Epydoc** + +http://epydoc.sourceforge.net/manual-fields.html + +:: + + def myfunction(node): + """Do something with a ``node``. + + @type node: ProgramNode + + """ + node.| # complete here + +**Numpydoc** + +https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt + +In order to support the numpydoc format, you need to install the `numpydoc +`__ package. + +:: + + def foo(var1, var2, long_var_name='hi'): + r"""A one-line summary that does not use variable names or the + function name. + + ... + + Parameters + ---------- + var1 : array_like + Array_like means all those objects -- lists, nested lists, + etc. -- that can be converted to an array. We can also + refer to variables like `var1`. + var2 : int + The type above can either refer to an actual Python type + (e.g. ``int``), or describe the type of the variable in more + detail, e.g. ``(N,) ndarray`` or ``array_like``. + long_variable_name : {'hi', 'ho'}, optional + Choices in brackets, default first when optional. + + ... + + """ + var2.| # complete here + +Currently supported type hinting for: + +- function parameter type, using function doctring (:type or @type) +- function return type, using function doctring (:rtype or @rtype) +- class attribute type, using class docstring (:type or @type) + Custom Source Folders ===================== diff --git a/docs/rope.rst b/docs/rope.rst index b5798163d..dc8ca5910 100644 --- a/docs/rope.rst +++ b/docs/rope.rst @@ -44,6 +44,7 @@ Features implemented so far: * Static and dynamic object analysis * Handling built-in container types * Saving object information on disk and validating them + * Type hinting using docstring For more information see `overview.rst`_. From a1289d26c66150febc777ba537b6416e82cebab0 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sat, 2 Jan 2016 22:14:12 +0200 Subject: [PATCH 10/92] Added test for hinting type of param --- ropetest/__init__.py | 2 ++ ropetest/docstringstest.py | 58 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) create mode 100644 ropetest/docstringstest.py diff --git a/ropetest/__init__.py b/ropetest/__init__.py index f1cb45925..85badf425 100644 --- a/ropetest/__init__.py +++ b/ropetest/__init__.py @@ -3,6 +3,7 @@ import ropetest.projecttest import ropetest.codeanalyzetest +import ropetest.docstringstest import ropetest.pycoretest import ropetest.pyscopestest import ropetest.objectinfertest @@ -21,6 +22,7 @@ def suite(): result = unittest.TestSuite() result.addTests(ropetest.projecttest.suite()) result.addTests(ropetest.codeanalyzetest.suite()) + result.addTests(ropetest.docstringstest.suite()) result.addTests(ropetest.pycoretest.suite()) result.addTests(ropetest.pyscopestest.suite()) result.addTests(ropetest.objectinfertest.suite()) diff --git a/ropetest/docstringstest.py b/ropetest/docstringstest.py new file mode 100644 index 000000000..cf2222bda --- /dev/null +++ b/ropetest/docstringstest.py @@ -0,0 +1,58 @@ +import unittest + +from rope.contrib.codeassist import code_assist +from ropetest import testutils + + +class HintingTest(unittest.TestCase): + + def setUp(self): + super(HintingTest, self).setUp() + self.project = testutils.sample_project() + + def tearDown(self): + testutils.remove_project(self.project) + super(HintingTest, self).tearDown() + + def _assist(self, code, resource=None, **kwds): + return code_assist(self.project, code, len(code), resource, **kwds) + + def assert_completion_in_result(self, name, scope, result): + for proposal in result: + if proposal.name == name and proposal.scope == scope: + return + self.fail('completion <%s> not proposed' % name) + + def assert_completion_not_in_result(self, name, scope, result): + for proposal in result: + if proposal.name == name and proposal.scope == scope: + self.fail('completion <%s> was proposed' % name) + + def test_hint_param(self): + code = 'class Sample(object):\n' \ + ' def a_method(self, a_arg):\n' \ + ' """:type a_arg: threading.Thread"""\n' \ + ' a_arg.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + def test_hierarchical_hint_param(self): + code = 'class ISample(object):\n' \ + ' def a_method(self, a_arg):\n' \ + ' """:type a_arg: threading.Thread"""\n' \ + '\n\n' \ + 'class Sample(ISample):\n' \ + ' def a_method(self, a_arg):\n' \ + ' a_arg.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + +def suite(): + result = unittest.TestSuite() + result.addTests(unittest.makeSuite(HintingTest)) + return result + + +if __name__ == '__main__': + unittest.main() From ddfded36a97596a536547f68e179744d28fea536 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sat, 2 Jan 2016 22:22:56 +0200 Subject: [PATCH 11/92] Added tests for hinting type of return type and attribute --- ropetest/docstringstest.py | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/ropetest/docstringstest.py b/ropetest/docstringstest.py index cf2222bda..db12b7e27 100644 --- a/ropetest/docstringstest.py +++ b/ropetest/docstringstest.py @@ -47,6 +47,37 @@ def test_hierarchical_hint_param(self): result = self._assist(code) self.assert_completion_in_result('isAlive', 'attribute', result) + def test_hierarchical_hint_rtype(self): + code = 'class ISample(object):\n' \ + ' def b_method(self):\n' \ + ' """:rtype: threading.Thread"""\n' \ + '\n\n' \ + 'class Sample(ISample):\n' \ + ' def a_method(self):\n' \ + ' self.b_method().isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + def test_hint_attr(self): + code = 'class Sample(object):\n' \ + ' """:type a_attr: threading.Thread"""\n' \ + ' a_attr = None\n'\ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + def test_hierarchical_hint_attr(self): + code = 'class ISample(object):\n' \ + ' """:type a_attr: threading.Thread"""\n' \ + ' a_attr = None\n'\ + '\n\n' \ + 'class Sample(ISample):\n' \ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + def suite(): result = unittest.TestSuite() From c7da9b969a91ac7b0255798cd69e844fa85eaa90 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sat, 2 Jan 2016 22:45:47 +0200 Subject: [PATCH 12/92] fixed minor bug in regular expression for Sphinx docstring --- rope/base/oi/docstrings.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index e36470fa3..25fbef1a0 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -19,7 +19,7 @@ DOCSTRING_PARAM_PATTERNS = [ r'\s*:type\s+%s:\s*([^\n, ]+)', # Sphinx - r'\s*:param\s+(\w+)\s+%s:[^\n, ]+', # Sphinx param with type + r'\s*:param\s+(\w+)\s+%s:[^\n]+', # Sphinx param with type r'\s*@type\s+%s:\s*([^\n, ]+)', # Epydoc ] From e650b66b529b46058e814bf76d5fdc58f6faa17a Mon Sep 17 00:00:00 2001 From: emacsway Date: Sun, 3 Jan 2016 00:21:36 +0200 Subject: [PATCH 13/92] Hinting class attribute defined by NotImplemented or None --- rope/base/oi/soi.py | 4 +++- ropetest/docstringstest.py | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/rope/base/oi/soi.py b/rope/base/oi/soi.py index c762b3a55..419b3e808 100644 --- a/rope/base/oi/soi.py +++ b/rope/base/oi/soi.py @@ -68,7 +68,9 @@ def infer_assigned_object(pyname): return for assignment in reversed(pyname.assignments): result = _infer_assignment(assignment, pyname.module) - if result is not None: + if isinstance(result, rope.base.builtins.BuiltinUnknown) and result.get_name() == 'NotImplementedType': + break + elif result is not None: return result return _infer_assigned_object_by_hint(pyname) diff --git a/ropetest/docstringstest.py b/ropetest/docstringstest.py index db12b7e27..24d09d493 100644 --- a/ropetest/docstringstest.py +++ b/ropetest/docstringstest.py @@ -70,9 +70,29 @@ def test_hint_attr(self): def test_hierarchical_hint_attr(self): code = 'class ISample(object):\n' \ ' """:type a_attr: threading.Thread"""\n' \ + '\n\n' \ + 'class Sample(ISample):\n' \ ' a_attr = None\n'\ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + def test_hint_attr_by_notimplemented(self): + code = 'class Sample(object):\n' \ + ' """:type a_attr: threading.Thread"""\n' \ + ' a_attr = NotImplemented\n'\ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + def test_hierarchical_hint_attr_by_notimplemented(self): + code = 'class ISample(object):\n' \ + ' """:type a_attr: threading.Thread"""\n' \ '\n\n' \ 'class Sample(ISample):\n' \ + ' a_attr = NotImplemented\n'\ ' def a_method(self):\n' \ ' self.a_attr.isA' result = self._assist(code) From b924f14c0e55bc858d0ea577c85d73a6359be093 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sun, 3 Jan 2016 00:39:07 +0200 Subject: [PATCH 14/92] Hinting class attribute defined by NotImplemented or None in constructor --- rope/base/oi/soi.py | 19 ++++++++++----- ropetest/docstringstest.py | 48 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 59 insertions(+), 8 deletions(-) diff --git a/rope/base/oi/soi.py b/rope/base/oi/soi.py index 419b3e808..3a739ce4f 100644 --- a/rope/base/oi/soi.py +++ b/rope/base/oi/soi.py @@ -80,12 +80,19 @@ def _infer_assigned_object_by_hint(pyname): holding_scope = pyname.module.get_scope().get_inner_scope_for_line(lineno) pyobject = holding_scope.pyobject if isinstance(pyobject, rope.base.pyobjects.PyClass): - for name, attr in pyobject.get_attributes().items(): - if attr is pyname: - type_ = hint_attr(pyobject, name) - if type_ is not None: - return rope.base.pyobjects.PyObject(type_) - break + pyclass = pyobject + elif (isinstance(pyobject, rope.base.pyobjectsdef.PyFunction) and + pyobject.get_name() == '__init__' and + isinstance(pyobject.parent, rope.base.pyobjects.PyClass)): + pyclass = pyobject.parent + else: + return + for name, attr in pyclass.get_attributes().items(): + if attr is pyname: + type_ = hint_attr(pyclass, name) + if type_ is not None: + return rope.base.pyobjects.PyObject(type_) + break def get_passed_objects(pyfunction, parameter_index): diff --git a/ropetest/docstringstest.py b/ropetest/docstringstest.py index 24d09d493..65720a84a 100644 --- a/ropetest/docstringstest.py +++ b/ropetest/docstringstest.py @@ -78,7 +78,7 @@ def test_hierarchical_hint_attr(self): result = self._assist(code) self.assert_completion_in_result('isAlive', 'attribute', result) - def test_hint_attr_by_notimplemented(self): + def test_hint_attr_defined_by_notimplemented(self): code = 'class Sample(object):\n' \ ' """:type a_attr: threading.Thread"""\n' \ ' a_attr = NotImplemented\n'\ @@ -87,7 +87,7 @@ def test_hint_attr_by_notimplemented(self): result = self._assist(code) self.assert_completion_in_result('isAlive', 'attribute', result) - def test_hierarchical_hint_attr_by_notimplemented(self): + def test_hierarchical_hint_attr_defined_by_notimplemented(self): code = 'class ISample(object):\n' \ ' """:type a_attr: threading.Thread"""\n' \ '\n\n' \ @@ -98,6 +98,50 @@ def test_hierarchical_hint_attr_by_notimplemented(self): result = self._assist(code) self.assert_completion_in_result('isAlive', 'attribute', result) + def test_hint_attr_defined_by_constructor(self): + code = 'class Sample(object):\n' \ + ' """:type a_attr: threading.Thread"""\n' \ + ' def __init__(self):\n' \ + ' self.a_attr = None\n' \ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + def test_hierarchical_hint_attr_by_constructor(self): + code = 'class ISample(object):\n' \ + ' """:type a_attr: threading.Thread"""\n' \ + '\n\n' \ + 'class Sample(ISample):\n' \ + ' def __init__(self):\n' \ + ' self.a_attr = None\n' \ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + def test_hint_attr_defined_by_notimplemented_in_constructor(self): + code = 'class Sample(object):\n' \ + ' """:type a_attr: threading.Thread"""\n' \ + ' def __init__(self):\n' \ + ' self.a_attr = NotImplemented\n' \ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + def test_hierarchical_hint_attr_by_notimplemented_in_constructor(self): + code = 'class ISample(object):\n' \ + ' """:type a_attr: threading.Thread"""\n' \ + '\n\n' \ + 'class Sample(ISample):\n' \ + ' def __init__(self):\n' \ + ' self.a_attr = NotImplemented\n' \ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + def suite(): result = unittest.TestSuite() From e9f02ca6525d96c4fcf11291694cf8c8a458dc7c Mon Sep 17 00:00:00 2001 From: emacsway Date: Sun, 3 Jan 2016 00:52:02 +0200 Subject: [PATCH 15/92] Improved docs, comment for type hinting of attribute --- docs/overview.rst | 2 +- rope/base/oi/docstrings.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/overview.rst b/docs/overview.rst index bcb2e95b5..5265abd9a 100644 --- a/docs/overview.rst +++ b/docs/overview.rst @@ -1282,7 +1282,7 @@ Currently supported type hinting for: - function parameter type, using function doctring (:type or @type) - function return type, using function doctring (:rtype or @rtype) -- class attribute type, using class docstring (:type or @type) +- class attribute type, using class docstring (:type or @type). Attribute should by set to None or NotImplemented in class or constructor of class. Custom Source Folders ===================== diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index 25fbef1a0..9def6a4b4 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -2,13 +2,13 @@ Hinting the type using docstring of class/function like here https://www.jetbrains.com/pycharm/help/type-hinting-in-pycharm.html#d290117e333 -It's a necessary thing if you are using Dependency Injection -(three ways - Constructor Injection, Setter Injection, and Interface Injection): +It's an irreplaceable thing if you are using Dependency Injection with passive class +(when Assembler sets dependency to public attribute of instance): http://www.martinfowler.com/articles/injection.html Some code extracted (or based on code) from: https://github.com/davidhalter/jedi/blob/b489019f5bd5750051122b94cc767df47751ecb7/jedi/evaluate/docstrings.py -Thanks to @davidhalter for MIT License. +Thanks to @davidhalter for this utils under MIT License. """ import re from ast import literal_eval From 2011d4ef5324fb4116564826a88e3dd81dae113b Mon Sep 17 00:00:00 2001 From: emacsway Date: Sun, 3 Jan 2016 01:00:01 +0200 Subject: [PATCH 16/92] fix comment (link to type hinting in pycharm) --- rope/base/oi/docstrings.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index 9def6a4b4..2d081b971 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -1,6 +1,6 @@ """ Hinting the type using docstring of class/function like here -https://www.jetbrains.com/pycharm/help/type-hinting-in-pycharm.html#d290117e333 +https://www.jetbrains.com/pycharm/help/type-hinting-in-pycharm.html It's an irreplaceable thing if you are using Dependency Injection with passive class (when Assembler sets dependency to public attribute of instance): From 15e6a97b350b382ce8e5414e70765b0d2af8ec4c Mon Sep 17 00:00:00 2001 From: emacsway Date: Sun, 3 Jan 2016 03:13:00 +0200 Subject: [PATCH 17/92] Fixed bug Python: AttributeError: 'PyObject' object has no attribute 'get_superclasses' for unknown reasons --- rope/base/oi/docstrings.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index 2d081b971..dac372fb2 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -83,7 +83,7 @@ def _get_mro(pyclass): l = [pyclass] for cls in l: for super_cls in cls.get_superclasses(): - if super_cls not in l: + if isinstance(super_cls, PyClass) and super_cls not in l: l.append(super_cls) return l From 8645f2affca99c70c44d78a50c1b83dd82430cd9 Mon Sep 17 00:00:00 2001 From: emacsway Date: Tue, 5 Jan 2016 02:04:43 +0200 Subject: [PATCH 18/92] Fixed test for hinting the return type using docstring of interface --- ropetest/docstringstest.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ropetest/docstringstest.py b/ropetest/docstringstest.py index 65720a84a..68bd8998a 100644 --- a/ropetest/docstringstest.py +++ b/ropetest/docstringstest.py @@ -53,6 +53,8 @@ def test_hierarchical_hint_rtype(self): ' """:rtype: threading.Thread"""\n' \ '\n\n' \ 'class Sample(ISample):\n' \ + ' def b_method(self):\n' \ + ' pass\n' \ ' def a_method(self):\n' \ ' self.b_method().isA' result = self._assist(code) From 692549a50d8debd534c4a4c5d9e66f451413eb3c Mon Sep 17 00:00:00 2001 From: emacsway Date: Tue, 5 Jan 2016 16:10:59 +0200 Subject: [PATCH 19/92] Type hints using PEP 0484 comments --- rope/base/oi/docstrings.py | 29 ++++++++++++++++++++++++++++- rope/base/oi/soi.py | 5 ++++- ropetest/docstringstest.py | 8 ++++++++ 3 files changed, 40 insertions(+), 2 deletions(-) diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index dac372fb2..8cd824d6f 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -17,6 +17,10 @@ from rope.base.evaluate import ScopeNameFinder from rope.base.pyobjects import PyClass +PEP0484_PATTERN = [ + re.compile(r'type:\s*([^\n, ]+)'), +] + DOCSTRING_PARAM_PATTERNS = [ r'\s*:type\s+%s:\s*([^\n, ]+)', # Sphinx r'\s*:param\s+(\w+)\s+%s:[^\n]+', # Sphinx param with type @@ -30,7 +34,6 @@ REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`') - try: from numpydoc.docscrape import NumpyDocString except ImportError: @@ -54,6 +57,30 @@ def _search_param_in_numpydocstr(docstr, param_str): return [] +def hint_pep0484(pyname): + from rope.base.oi.soi import _get_lineno_for_node + lineno = _get_lineno_for_node(pyname.assignments[0].ast_node) + holding_scope = pyname.module.get_scope().get_inner_scope_for_line(lineno) + line = holding_scope._get_global_scope()._scope_finder.lines.get_line(lineno) + if '#' in line: + type_strs = _search_type_in_pep0484(line.split('#', 1)[1]) + if type_strs: + return _resolve_type(type_strs[0], holding_scope.pyobject) + + +def _search_type_in_pep0484(code): + """ For more info see: + https://www.python.org/dev/peps/pep-0484/#type-comments + + >>> _search_type_in_pep0484('type: int') + ['int'] + """ + for p in PEP0484_PATTERN: + match = p.search(code) + if match: + return [match.group(1)] + + def hint_param(pyfunc, param_name): type_strs = None func = pyfunc diff --git a/rope/base/oi/soi.py b/rope/base/oi/soi.py index 3a739ce4f..9cbb67be5 100644 --- a/rope/base/oi/soi.py +++ b/rope/base/oi/soi.py @@ -8,7 +8,7 @@ import rope.base.pynames import rope.base.pyobjects from rope.base import evaluate, utils, arguments -from rope.base.oi.docstrings import hint_return, hint_param, hint_attr +from rope.base.oi.docstrings import hint_return, hint_param, hint_attr, hint_pep0484 _ignore_inferred = utils.ignore_exception( @@ -72,6 +72,9 @@ def infer_assigned_object(pyname): break elif result is not None: return result + result = hint_pep0484(pyname) + if result is not None: + return result return _infer_assigned_object_by_hint(pyname) diff --git a/ropetest/docstringstest.py b/ropetest/docstringstest.py index 68bd8998a..d68ba0864 100644 --- a/ropetest/docstringstest.py +++ b/ropetest/docstringstest.py @@ -144,6 +144,14 @@ def test_hierarchical_hint_attr_by_notimplemented_in_constructor(self): result = self._assist(code) self.assert_completion_in_result('isAlive', 'attribute', result) + def test_hint_pep0484_attr(self): + code = 'class Sample(object):\n' \ + ' a_attr = None # type: threading.Thread\n'\ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + def suite(): result = unittest.TestSuite() From 2a9ed451476cfd8988b866e84a08fbf752abf62a Mon Sep 17 00:00:00 2001 From: emacsway Date: Tue, 5 Jan 2016 16:19:25 +0200 Subject: [PATCH 20/92] Type hints using PEP 0484 comments, added more tests --- ropetest/docstringstest.py | 30 ++++++++++++++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/ropetest/docstringstest.py b/ropetest/docstringstest.py index d68ba0864..b1a8b00cb 100644 --- a/ropetest/docstringstest.py +++ b/ropetest/docstringstest.py @@ -110,7 +110,7 @@ def test_hint_attr_defined_by_constructor(self): result = self._assist(code) self.assert_completion_in_result('isAlive', 'attribute', result) - def test_hierarchical_hint_attr_by_constructor(self): + def test_hierarchical_hint_attr_defined_by_constructor(self): code = 'class ISample(object):\n' \ ' """:type a_attr: threading.Thread"""\n' \ '\n\n' \ @@ -132,7 +132,7 @@ def test_hint_attr_defined_by_notimplemented_in_constructor(self): result = self._assist(code) self.assert_completion_in_result('isAlive', 'attribute', result) - def test_hierarchical_hint_attr_by_notimplemented_in_constructor(self): + def test_hierarchical_hint_attr_defined_by_notimplemented_in_constructor(self): code = 'class ISample(object):\n' \ ' """:type a_attr: threading.Thread"""\n' \ '\n\n' \ @@ -152,6 +152,32 @@ def test_hint_pep0484_attr(self): result = self._assist(code) self.assert_completion_in_result('isAlive', 'attribute', result) + def test_hint_pep0484_attr_defined_by_constructor(self): + code = 'class Sample(object):\n' \ + ' def __init__(self):\n' \ + ' self.a_attr = None # type: threading.Thread\n' \ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + def test_hint_pep0484_attr_defined_by_notimplemented(self): + code = 'class Sample(object):\n' \ + ' a_attr = NotImplemented # type: threading.Thread\n'\ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + + def test_hint_pep0484_attr_defined_by_notimplemented_in_constructor(self): + code = 'class Sample(object):\n' \ + ' def __init__(self):\n' \ + ' self.a_attr = NotImplemented # type: threading.Thread\n' \ + ' def a_method(self):\n' \ + ' self.a_attr.isA' + result = self._assist(code) + self.assert_completion_in_result('isAlive', 'attribute', result) + def suite(): result = unittest.TestSuite() From b0a0872ef34010ae69e6881f3f5b154372a1fec7 Mon Sep 17 00:00:00 2001 From: emacsway Date: Tue, 5 Jan 2016 16:50:11 +0200 Subject: [PATCH 21/92] Type hinting: support for expressions returned unknown object --- rope/base/oi/soi.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/rope/base/oi/soi.py b/rope/base/oi/soi.py index 9cbb67be5..dd9d2a9f2 100644 --- a/rope/base/oi/soi.py +++ b/rope/base/oi/soi.py @@ -70,12 +70,20 @@ def infer_assigned_object(pyname): result = _infer_assignment(assignment, pyname.module) if isinstance(result, rope.base.builtins.BuiltinUnknown) and result.get_name() == 'NotImplementedType': break + elif result == rope.base.pyobjects.get_unknown(): + break elif result is not None: return result - result = hint_pep0484(pyname) - if result is not None: - return result - return _infer_assigned_object_by_hint(pyname) + + hinting_result = hint_pep0484(pyname) + if hinting_result is not None: + return hinting_result + + hinting_result = _infer_assigned_object_by_hint(pyname) + if hinting_result is not None: + return hinting_result + + return result def _infer_assigned_object_by_hint(pyname): From 99edcf240ebc1520380608745437c8981130998a Mon Sep 17 00:00:00 2001 From: emacsway Date: Tue, 5 Jan 2016 17:25:37 +0200 Subject: [PATCH 22/92] Docs for type hints using type comments PEP 0484 --- docs/overview.rst | 27 ++++++++++++++++++++++----- docs/rope.rst | 2 +- 2 files changed, 23 insertions(+), 6 deletions(-) diff --git a/docs/overview.rst b/docs/overview.rst index 5265abd9a..e43dc9955 100644 --- a/docs/overview.rst +++ b/docs/overview.rst @@ -1212,9 +1212,17 @@ Rope uses this feature by default but you can disable it by editing Type Hinting ------------ +Currently supported type hinting for: + +- function parameter type, using function doctring (:type or @type) +- function return type, using function doctring (:rtype or @rtype) +- class attribute type, using class docstring (:type or @type). Attribute should by set to None or NotImplemented in class or constructor of class. +- any assignment, using type comments of PEP 0484. + If rope cannot detect the type of a function argument correctly (due to the dynamic nature of Python), you can help it by hinting the type using -one of the following docstring syntax styles: +one of the following docstring syntax styles. + **Sphinx style** @@ -1231,6 +1239,7 @@ http://sphinx-doc.org/domains.html#info-field-lists """ node.| # complete here + **Epydoc** http://epydoc.sourceforge.net/manual-fields.html @@ -1245,6 +1254,7 @@ http://epydoc.sourceforge.net/manual-fields.html """ node.| # complete here + **Numpydoc** https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt @@ -1278,11 +1288,18 @@ In order to support the numpydoc format, you need to install the `numpydoc """ var2.| # complete here -Currently supported type hinting for: -- function parameter type, using function doctring (:type or @type) -- function return type, using function doctring (:rtype or @rtype) -- class attribute type, using class docstring (:type or @type). Attribute should by set to None or NotImplemented in class or constructor of class. +**PEP 0484** + +https://www.python.org/dev/peps/pep-0484/#type-comments + +:: + + class Sample(object): + def __init__(self): + self.x = None # type: random.Random + self.x.| # complete here + Custom Source Folders ===================== diff --git a/docs/rope.rst b/docs/rope.rst index dc8ca5910..421494539 100644 --- a/docs/rope.rst +++ b/docs/rope.rst @@ -44,7 +44,7 @@ Features implemented so far: * Static and dynamic object analysis * Handling built-in container types * Saving object information on disk and validating them - * Type hinting using docstring + * Type hints using docstring or type comments PEP 0484 For more information see `overview.rst`_. From 229d2c7f48770f95da015f89d755afedc58e4454 Mon Sep 17 00:00:00 2001 From: emacsway Date: Tue, 5 Jan 2016 21:50:47 +0200 Subject: [PATCH 23/92] fixed docs: type hints using type comments of PEP 0484 supported in limited form --- docs/overview.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/overview.rst b/docs/overview.rst index e43dc9955..d290f5e6d 100644 --- a/docs/overview.rst +++ b/docs/overview.rst @@ -1217,7 +1217,7 @@ Currently supported type hinting for: - function parameter type, using function doctring (:type or @type) - function return type, using function doctring (:rtype or @rtype) - class attribute type, using class docstring (:type or @type). Attribute should by set to None or NotImplemented in class or constructor of class. -- any assignment, using type comments of PEP 0484. +- any assignment, using type comments of PEP 0484 (in limited form). If rope cannot detect the type of a function argument correctly (due to the dynamic nature of Python), you can help it by hinting the type using From 957d63f2fd324448bb58039aeed3de28e979109c Mon Sep 17 00:00:00 2001 From: emacsway Date: Tue, 5 Jan 2016 21:55:57 +0200 Subject: [PATCH 24/92] fix minor typo --- rope/base/oi/docstrings.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rope/base/oi/docstrings.py b/rope/base/oi/docstrings.py index 8cd824d6f..64a81d313 100644 --- a/rope/base/oi/docstrings.py +++ b/rope/base/oi/docstrings.py @@ -17,7 +17,7 @@ from rope.base.evaluate import ScopeNameFinder from rope.base.pyobjects import PyClass -PEP0484_PATTERN = [ +PEP0484_PATTERNS = [ re.compile(r'type:\s*([^\n, ]+)'), ] @@ -75,7 +75,7 @@ def _search_type_in_pep0484(code): >>> _search_type_in_pep0484('type: int') ['int'] """ - for p in PEP0484_PATTERN: + for p in PEP0484_PATTERNS: match = p.search(code) if match: return [match.group(1)] From 6b04a0bd3ebcaa115209a400737121c4906ac139 Mon Sep 17 00:00:00 2001 From: emacsway Date: Wed, 6 Jan 2016 01:41:32 +0200 Subject: [PATCH 25/92] Py3k PyFunction.get_param_names() --- rope/base/pyobjectsdef.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index 5968ff854..7e37ddbf9 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -76,8 +76,12 @@ def get_name(self): def get_param_names(self, special_args=True): # TODO: handle tuple parameters - result = [node.id for node in self.arguments.args - if isinstance(node, ast.Name)] + if hasattr(ast, 'arg'): # Py3 + result = [node.arg for node in self.arguments.args + if isinstance(node, ast.arg)] + else: # Py2 + result = [node.id for node in self.arguments.args + if isinstance(node, ast.Name)] if special_args: if self.arguments.vararg: result.append(self.arguments.vararg) From 9204b67ae83ae53e68ffdabaca84f60b91b0c007 Mon Sep 17 00:00:00 2001 From: emacsway Date: Wed, 6 Jan 2016 01:59:20 +0200 Subject: [PATCH 26/92] Py3k for _ClassVisitor._FunctionDef(). Now type hinting works in python3, tests is passed --- rope/base/pyobjectsdef.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index 7e37ddbf9..49b7865e2 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -474,8 +474,14 @@ def _FunctionDef(self, node): _ScopeVisitor._FunctionDef(self, node) if len(node.args.args) > 0: first = node.args.args[0] - if isinstance(first, ast.Name): - new_visitor = _ClassInitVisitor(self, first.id) + new_visitor = None + if hasattr(ast, 'arg'): # Py3 + if isinstance(first, ast.arg): + new_visitor = _ClassInitVisitor(self, first.arg) + else: # Py2 + if isinstance(first, ast.Name): + new_visitor = _ClassInitVisitor(self, first.id) + if new_visitor is not None: for child in ast.get_child_nodes(node): ast.walk(child, new_visitor) From d67ae685c08fecca591cb0cd08e1614764dfc37f Mon Sep 17 00:00:00 2001 From: emacsway Date: Thu, 7 Jan 2016 03:29:35 +0200 Subject: [PATCH 27/92] Removed useless restriction (limited by constructor) in class attribute hinting. Now works, for example, in TestSample.setUp() --- rope/base/oi/soi.py | 1 - 1 file changed, 1 deletion(-) diff --git a/rope/base/oi/soi.py b/rope/base/oi/soi.py index dd9d2a9f2..f39e6a8a3 100644 --- a/rope/base/oi/soi.py +++ b/rope/base/oi/soi.py @@ -93,7 +93,6 @@ def _infer_assigned_object_by_hint(pyname): if isinstance(pyobject, rope.base.pyobjects.PyClass): pyclass = pyobject elif (isinstance(pyobject, rope.base.pyobjectsdef.PyFunction) and - pyobject.get_name() == '__init__' and isinstance(pyobject.parent, rope.base.pyobjects.PyClass)): pyclass = pyobject.parent else: From e467d3ed963ec411c616ba23a63b3c85668cf5f1 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sat, 9 Jan 2016 05:17:23 +0200 Subject: [PATCH 28/92] Fixed two bugs in PY3 --- rope/base/builtins.py | 3 ++- rope/comp.py | 19 +++++++++++++++++++ ropetest/refactor/patchedasttest.py | 6 +++++- 3 files changed, 26 insertions(+), 2 deletions(-) create mode 100644 rope/comp.py diff --git a/rope/base/builtins.py b/rope/base/builtins.py index 33729d5bd..4cf5768db 100644 --- a/rope/base/builtins.py +++ b/rope/base/builtins.py @@ -6,6 +6,7 @@ raw_input = input import rope.base.evaluate +from rope import comp from rope.base import pynames, pyobjects, arguments, utils, ast @@ -801,4 +802,4 @@ def _input_function(args): builtin=raw_input)), } -builtins = BuiltinModule('__builtin__', initial=_initial_builtins) +builtins = BuiltinModule(comp.builtins.__name__, initial=_initial_builtins) diff --git a/rope/comp.py b/rope/comp.py new file mode 100644 index 000000000..9bb068fe6 --- /dev/null +++ b/rope/comp.py @@ -0,0 +1,19 @@ +import sys + +PY2 = sys.version_info[0] == 2 +PY3 = sys.version_info[0] == 3 +PY34 = sys.version_info[0:2] >= (3, 4) + +try: + str = unicode +except NameError: # PY3 + py3 = True + string_types = (str,) + integer_types = (int,) + import builtins + +else: # PY2 + py3 = False + string_types = (basestring,) + integer_types = (int, long) + builtins = __import__('__builtin__') diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index a885fd9be..ecb3d199c 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -1,5 +1,6 @@ import unittest +from rope import comp from rope.base import ast from rope.refactor import patchedast from ropetest import testutils @@ -668,7 +669,10 @@ def test_print_node(self): ',', ' ', 'Num', '', ',']) def test_printnl_node(self): - source = 'print 1\n' + if comp.PY3: + source = 'print(1)\n' + else: + source = 'print 1\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) checker.check_region('Print', 0, len(source) - 1) From 04ab99cbd352d4f40fc1b61cb8cf3638539985d8 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sat, 9 Jan 2016 05:26:59 +0200 Subject: [PATCH 29/92] minor clean useless variables --- rope/comp.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rope/comp.py b/rope/comp.py index 9bb068fe6..f85ccb594 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -7,13 +7,13 @@ try: str = unicode except NameError: # PY3 - py3 = True + string_types = (str,) integer_types = (int,) import builtins else: # PY2 - py3 = False + string_types = (basestring,) integer_types = (int, long) builtins = __import__('__builtin__') From b3e5ce7b28e19b990ce39c31d9c39bf02ffaea54 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sat, 9 Jan 2016 20:10:32 +0200 Subject: [PATCH 30/92] much more Py3k. Currently only failures=50, errors=43 --- rope/base/oi/doa.py | 4 ++-- rope/base/oi/runmod.py | 16 +++++----------- rope/base/project.py | 11 ++--------- rope/comp.py | 7 +++++++ 4 files changed, 16 insertions(+), 22 deletions(-) diff --git a/rope/base/oi/doa.py b/rope/base/oi/doa.py index de45902b9..3f314c660 100644 --- a/rope/base/oi/doa.py +++ b/rope/base/oi/doa.py @@ -65,7 +65,7 @@ def _init_data_receiving(self): self.receiving_thread.start() def _receive_information(self): - #temp = open('/dev/shm/info', 'w') + #temp = open('/dev/shm/info', 'wb') for data in self.receiver.receive_data(): self.analyze_data(data) #temp.write(str(data) + '\n') @@ -128,7 +128,7 @@ def get_send_info(self): def receive_data(self): conn, addr = self.server_socket.accept() self.server_socket.close() - my_file = conn.makefile('r') + my_file = conn.makefile('rb') while True: try: yield pickle.load(my_file) diff --git a/rope/base/oi/runmod.py b/rope/base/oi/runmod.py index 666df74ce..25d0c7f62 100644 --- a/rope/base/oi/runmod.py +++ b/rope/base/oi/runmod.py @@ -1,10 +1,3 @@ -try: - execfile -except NameError: - def execfile(fn, global_vars, local_vars): - with open(fn) as f: - code = compile(f.read(), fn, 'exec') - exec(code, global_vars, local_vars) def __rope_start_everything(): @@ -19,6 +12,7 @@ def __rope_start_everything(): import inspect import types import threading + import rope.comp as comp class _MessageSender(object): @@ -30,7 +24,7 @@ class _SocketSender(_MessageSender): def __init__(self, port): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(('127.0.0.1', port)) - self.my_file = s.makefile('w') + self.my_file = s.makefile('wb') def send_data(self, data): if not self.my_file.closed: @@ -136,7 +130,7 @@ def _get_persisted_class(self, object_): return ('unknown',) def _get_persisted_builtin(self, object_): - if isinstance(object_, (str, unicode)): + if isinstance(object_, comp.string_types): return ('builtin', 'str') if isinstance(object_, list): holding = None @@ -182,7 +176,7 @@ def _object_to_persisted_form(self, object_): return self._get_persisted_code(object_.__func__.__code__) if isinstance(object_, types.ModuleType): return self._get_persisted_module(object_) - if isinstance(object_, (str, unicode, list, dict, tuple, set)): + if isinstance(object_, comp.string_types + (list, dict, tuple, set)): return self._get_persisted_builtin(object_) if isinstance(object_, type): return self._get_persisted_class(object_) @@ -218,7 +212,7 @@ def _realpath(path): if send_info != '-': data_sender = _FunctionCallDataSender(send_info, project_root) del sys.argv[1:4] - execfile(file_to_run, run_globals) + comp.execfile(file_to_run, run_globals) if send_info != '-': data_sender.close() diff --git a/rope/base/project.py b/rope/base/project.py index 304398aaa..c8c5a462e 100644 --- a/rope/base/project.py +++ b/rope/base/project.py @@ -4,6 +4,7 @@ import warnings import rope.base.fscommands +import rope.comp as comp from rope.base import exceptions, taskhandle, prefs, history, pycore, utils import rope.base.resourceobserver as resourceobserver from rope.base.resources import File, Folder, _ResourceMatcher @@ -13,14 +14,6 @@ import pickle except ImportError: import cPickle as pickle -try: - execfile -except NameError: - def execfile(fn, global_vars, local_vars): - with open(fn) as f: - code = compile(f.read(), fn, 'exec') - exec(code, global_vars, local_vars) - class _Project(object): @@ -269,7 +262,7 @@ def _init_prefs(self, prefs): '__file__': config.real_path}) if config.exists(): config = self.ropefolder.get_child('config.py') - execfile(config.real_path, run_globals) + comp.execfile(config.real_path, run_globals) else: exec(self._default_config(), run_globals) if 'set_prefs' in run_globals: diff --git a/rope/comp.py b/rope/comp.py index f85ccb594..2a738b044 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -12,8 +12,15 @@ integer_types = (int,) import builtins + def execfile(fn, global_vars=None, local_vars=None): + with open(fn) as f: + code = compile(f.read(), fn, 'exec') + exec(code, global_vars or {}, local_vars or {}) + + else: # PY2 string_types = (basestring,) integer_types = (int, long) builtins = __import__('__builtin__') + execfile = execfile From 7141d84eb84dade0aff65a5f0289fdd25ba75ac0 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sat, 9 Jan 2016 20:34:14 +0200 Subject: [PATCH 31/92] Py3k: Fixed (partialy) print statement. Currently failures=50, errors=40 --- rope/base/pyobjects.py | 2 +- rope/contrib/finderrors.py | 2 +- ropetest/codeanalyzetest.py | 51 ++++++++++++++++++++++++------ ropetest/contrib/codeassisttest.py | 6 ++-- 4 files changed, 47 insertions(+), 14 deletions(-) diff --git a/rope/base/pyobjects.py b/rope/base/pyobjects.py index 76be30403..fd4d1c822 100644 --- a/rope/base/pyobjects.py +++ b/rope/base/pyobjects.py @@ -106,7 +106,7 @@ def get_unknown(): write:: if pyname.get_object() == get_unknown(): - print 'cannot determine what this pyname holds' + print('cannot determine what this pyname holds') Rope could have used `None` for indicating unknown objects but we had to check that in many places. So actually this method diff --git a/rope/contrib/finderrors.py b/rope/contrib/finderrors.py index 9ee7dd15f..109a3e8ac 100644 --- a/rope/contrib/finderrors.py +++ b/rope/contrib/finderrors.py @@ -5,7 +5,7 @@ errors = find_errors(project, project.get_resource('mod.py')) for error in errors: - print '%s: %s' % (error.lineno, error.error) + print('%s: %s' % (error.lineno, error.error)) prints possible errors for ``mod.py`` file. diff --git a/ropetest/codeanalyzetest.py b/ropetest/codeanalyzetest.py index 595bfb733..437ad75ec 100644 --- a/ropetest/codeanalyzetest.py +++ b/ropetest/codeanalyzetest.py @@ -4,6 +4,7 @@ import unittest import rope.base.evaluate +import rope.comp as comp from rope.base import libutils from rope.base import exceptions, worder, codeanalyze from rope.base.codeanalyze import (SourceLinesAdapter, @@ -85,24 +86,36 @@ def test_attribute_accesses(self): self.assertEquals('a_var.an_attr', self._find_primary(code, 10)) def test_word_finder_on_word_beginning(self): - code = 'print a_var\n' + if comp.PY3: + code = 'print(a_var)\n' + else: + code = 'print a_var\n' word_finder = worder.Worder(code) result = word_finder.get_word_at(code.index('a_var')) self.assertEquals('a_var', result) def test_word_finder_on_primary_beginning(self): - code = 'print a_var\n' + if comp.PY3: + code = 'print(a_var)\n' + else: + code = 'print a_var\n' result = self._find_primary(code, code.index('a_var')) self.assertEquals('a_var', result) def test_word_finder_on_word_ending(self): - code = 'print a_var\n' + if comp.PY3: + code = 'print(a_var)\n' + else: + code = 'print a_var\n' word_finder = worder.Worder(code) result = word_finder.get_word_at(code.index('a_var') + 5) self.assertEquals('a_var', result) def test_word_finder_on_primary_ending(self): - code = 'print a_var\n' + if comp.PY3: + code = 'print(a_var)\n' + else: + code = 'print a_var\n' result = self._find_primary(code, code.index('a_var') + 5) self.assertEquals('a_var', result) @@ -186,7 +199,10 @@ def test_operators_inside_parens(self): self._find_primary(code, 25)) def test_dictionaries(self): - code = 'print {1: "one", 2: "two"}.keys()' + if comp.PY3: + code = 'print({1: "one", 2: "two"}.keys())' + else: + code = 'print {1: "one", 2: "two"}.keys()' self.assertEquals('{1: "one", 2: "two"}.keys', self._find_primary(code, 29)) @@ -468,21 +484,30 @@ def test_get_pyname_at_on_language_keywords(self): name_finder.get_pyname_at(code.index('pass')) def test_one_liners(self): - code = 'var = 1\ndef f(): var = 2\nprint var\n' + if comp.PY3: + code = 'var = 1\ndef f(): var = 2\nprint(var)\n' + else: + code = 'var = 1\ndef f(): var = 2\nprint var\n' pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) self.assertEquals(pymod['var'], pyname) def test_one_liners_with_line_breaks(self): - code = 'var = 1\ndef f(\n): var = 2\nprint var\n' + if comp.PY3: + code = 'var = 1\ndef f(\n): var = 2\nprint(var)\n' + else: + code = 'var = 1\ndef f(\n): var = 2\nprint var\n' pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) self.assertEquals(pymod['var'], pyname) def test_one_liners_with_line_breaks2(self): - code = 'var = 1\ndef f(\np): var = 2\nprint var\n' + if comp.PY3: + code = 'var = 1\ndef f(\np): var = 2\nprint(var)\n' + else: + code = 'var = 1\ndef f(\np): var = 2\nprint var\n' pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) @@ -517,7 +542,10 @@ def test_implicit_continuation(self): self.assertEquals((1, 3), line_finder.logical_line_in(2)) def test_explicit_continuation(self): - code = 'print 2\na_var = (3 + \n 4, \n 5)\n' + if comp.PY3: + code = 'print(2)\na_var = (3 + \n 4, \n 5)\n' + else: + code = 'print 2\na_var = (3 + \n 4, \n 5)\n' line_finder = self._logical_finder(code) self.assertEquals((2, 4), line_finder.logical_line_in(2)) @@ -543,7 +571,10 @@ def test_generator_expressions_and_fors(self): self.assertEquals((1, 2), line_finder.logical_line_in(2)) def test_fors_and_block_start(self): - code = 'l = range(10)\nfor i in l:\n print i\n' + if comp.PY3: + code = 'l = range(10)\nfor i in l:\n print(i)\n' + else: + code = 'l = range(10)\nfor i in l:\n print i\n' self.assertEquals(2, get_block_start(SourceLinesAdapter(code), 2)) def test_problems_with_inner_indentations(self): diff --git a/ropetest/contrib/codeassisttest.py b/ropetest/contrib/codeassisttest.py index 728cf768b..77306a13a 100644 --- a/ropetest/contrib/codeassisttest.py +++ b/ropetest/contrib/codeassisttest.py @@ -6,6 +6,7 @@ except ImportError: import unittest +import rope.comp as comp from rope.base import exceptions from rope.contrib.codeassist import (get_definition_location, get_doc, starting_expression, code_assist, @@ -398,8 +399,9 @@ def test_get_definition_location_dot_line_break_inside_parens(self): self.assertEquals((None, 2), result) def test_if_scopes_in_other_scopes_for_get_definition_location(self): - code = 'def f(a_var):\n pass\na_var = 10\n' \ - 'if True:\n print a_var\n' + code = 'def f(a_var):\n pass\na_var = 10\n' + \ + 'if True:\n' + \ + (' print(a_var)\n' if comp.PY3 else ' print a_var\n') result = get_definition_location(self.project, code, len(code) - 3) self.assertEquals((None, 3), result) From 8e1043ea3b2ac031c548d2b84439ed9d35e27990 Mon Sep 17 00:00:00 2001 From: emacsway Date: Thu, 28 Jan 2016 21:03:53 +0200 Subject: [PATCH 32/92] Python3 compatibility. Now left only (failures=50, errors=22) --- rope/base/fscommands.py | 20 ++++++++++++-------- rope/comp.py | 1 + rope/contrib/fixsyntax.py | 2 +- ropetest/projecttest.py | 18 +++++++++--------- ropetest/pycoretest.py | 8 ++++---- 5 files changed, 27 insertions(+), 22 deletions(-) diff --git a/rope/base/fscommands.py b/rope/base/fscommands.py index 8c51e6072..5b6c810f0 100644 --- a/rope/base/fscommands.py +++ b/rope/base/fscommands.py @@ -9,6 +9,7 @@ import os import shutil import subprocess +import rope.comp as comp try: unicode @@ -261,23 +262,26 @@ def read_str_coding(source): def _find_coding(text): - if type(text) == bytes: - coding = b'coding' - else: - coding = "coding" + if isinstance(text, comp.str): + text = text.encode('utf-8') + coding = b'coding' + to_chr = chr if comp.PY3 else lambda x: x try: start = text.index(coding) + len(coding) - if text[start] not in '=:': + if text[start] not in b'=:': return start += 1 - while start < len(text) and text[start].isspace(): + while start < len(text) and to_chr(text[start]).isspace(): start += 1 end = start while end < len(text): c = text[end] - if not c.isalnum() and c not in '-_': + if not to_chr(c).isalnum() and c not in b'-_': break end += 1 - return text[start:end] + result = text[start:end] + if isinstance(result, bytes): + result = result.decode('utf-8') + return result except ValueError: pass diff --git a/rope/comp.py b/rope/comp.py index 2a738b044..23c621d40 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -8,6 +8,7 @@ str = unicode except NameError: # PY3 + str = str string_types = (str,) integer_types = (int,) import builtins diff --git a/rope/contrib/fixsyntax.py b/rope/contrib/fixsyntax.py index cc45ad19b..fa2a17d93 100644 --- a/rope/contrib/fixsyntax.py +++ b/rope/contrib/fixsyntax.py @@ -76,7 +76,7 @@ def __init__(self, code): self.code = code self.lines = self.code.split('\n') self.lines.append('\n') - self.origs = range(len(self.lines) + 1) + self.origs = list(range(len(self.lines) + 1)) self.diffs = [0] * (len(self.lines) + 1) def comment(self, lineno): diff --git a/ropetest/projecttest.py b/ropetest/projecttest.py index 5298f0517..7c00f95f8 100644 --- a/ropetest/projecttest.py +++ b/ropetest/projecttest.py @@ -388,29 +388,29 @@ def test_moving_files_and_resource_objects(self): def test_file_encoding_reading(self): sample_file = self.project.root.create_file('my_file.txt') - contents = u'# -*- coding: utf-8 -*-\n' \ - '#\N{LATIN SMALL LETTER I WITH DIAERESIS}\n' - file = open(sample_file.real_path, 'w') + contents = (b'# -*- coding: utf-8 -*-\n' + + b'#\N{LATIN SMALL LETTER I WITH DIAERESIS}\n').decode('utf8') + file = open(sample_file.real_path, 'wb') file.write(contents.encode('utf-8')) file.close() self.assertEquals(contents, sample_file.read()) def test_file_encoding_writing(self): sample_file = self.project.root.create_file('my_file.txt') - contents = u'# -*- coding: utf-8 -*-\n' \ - '\N{LATIN SMALL LETTER I WITH DIAERESIS}\n' + contents = (b'# -*- coding: utf-8 -*-\n' + + b'\N{LATIN SMALL LETTER I WITH DIAERESIS}\n').decode('utf8') sample_file.write(contents) self.assertEquals(contents, sample_file.read()) def test_using_utf8_when_writing_in_case_of_errors(self): sample_file = self.project.root.create_file('my_file.txt') - contents = u'\n\N{LATIN SMALL LETTER I WITH DIAERESIS}\n' + contents = b'\n\N{LATIN SMALL LETTER I WITH DIAERESIS}\n'.decode('utf8') sample_file.write(contents) self.assertEquals(contents, sample_file.read()) def test_encoding_declaration_in_the_second_line(self): sample_file = self.project.root.create_file('my_file.txt') - contents = '\n# -*- coding: latin-1 -*-\n\xa9\n' + contents = b'\n# -*- coding: latin-1 -*-\n\xa9\n' file = open(sample_file.real_path, 'wb') file.write(contents) file.close() @@ -418,7 +418,7 @@ def test_encoding_declaration_in_the_second_line(self): def test_read_bytes(self): sample_file = self.project.root.create_file('my_file.txt') - contents = '\n# -*- coding: latin-1 -*-\n\xa9\n' + contents = b'\n# -*- coding: latin-1 -*-\n\xa9\n' file = open(sample_file.real_path, 'wb') file.write(contents) file.close() @@ -427,7 +427,7 @@ def test_read_bytes(self): # TODO: Detecting utf-16 encoding def xxx_test_using_utf16(self): sample_file = self.project.root.create_file('my_file.txt') - contents = '# -*- coding: utf-16 -*-\n# This is a sample file ...\n' + contents = b'# -*- coding: utf-16 -*-\n# This is a sample file ...\n' file = open(sample_file.real_path, 'w') file.write(contents.encode('utf-16')) file.close() diff --git a/ropetest/pycoretest.py b/ropetest/pycoretest.py index 762b6112d..fc9c1b29d 100644 --- a/ropetest/pycoretest.py +++ b/ropetest/pycoretest.py @@ -561,7 +561,7 @@ def test_holding_error_location_information(self): def test_no_exceptions_on_module_encoding_problems(self): mod = testutils.create_module(self.project, 'mod') - contents = '\nsdsdsd\n\xa9\n' + contents = b'\nsdsdsd\n\xa9\n' file = open(mod.real_path, 'wb') file.write(contents) file.close() @@ -569,7 +569,7 @@ def test_no_exceptions_on_module_encoding_problems(self): def test_syntax_errors_when_cannot_decode_file2(self): mod = testutils.create_module(self.project, 'mod') - contents = '\n\xa9\n' + contents = b'\n\xa9\n' file = open(mod.real_path, 'wb') file.write(contents) file.close() @@ -578,7 +578,7 @@ def test_syntax_errors_when_cannot_decode_file2(self): def test_syntax_errors_when_null_bytes(self): mod = testutils.create_module(self.project, 'mod') - contents = '\n\x00\n' + contents = b'\n\x00\n' file = open(mod.real_path, 'wb') file.write(contents) file.close() @@ -587,7 +587,7 @@ def test_syntax_errors_when_null_bytes(self): def test_syntax_errors_when_bad_strs(self): mod = testutils.create_module(self.project, 'mod') - contents = '\n"\\x0"\n' + contents = b'\n"\\x0"\n' file = open(mod.real_path, 'wb') file.write(contents) file.close() From 1b772d051d6340eddec0fee15688bc39a40c17c7 Mon Sep 17 00:00:00 2001 From: emacsway Date: Fri, 29 Jan 2016 01:52:03 +0200 Subject: [PATCH 33/92] removed PY2 print where it's not required --- ropetest/codeanalyzetest.py | 50 ++++++++----------------------------- 1 file changed, 10 insertions(+), 40 deletions(-) diff --git a/ropetest/codeanalyzetest.py b/ropetest/codeanalyzetest.py index 437ad75ec..760dbe901 100644 --- a/ropetest/codeanalyzetest.py +++ b/ropetest/codeanalyzetest.py @@ -86,36 +86,24 @@ def test_attribute_accesses(self): self.assertEquals('a_var.an_attr', self._find_primary(code, 10)) def test_word_finder_on_word_beginning(self): - if comp.PY3: - code = 'print(a_var)\n' - else: - code = 'print a_var\n' + code = 'print(a_var)\n' word_finder = worder.Worder(code) result = word_finder.get_word_at(code.index('a_var')) self.assertEquals('a_var', result) def test_word_finder_on_primary_beginning(self): - if comp.PY3: - code = 'print(a_var)\n' - else: - code = 'print a_var\n' + code = 'print(a_var)\n' result = self._find_primary(code, code.index('a_var')) self.assertEquals('a_var', result) def test_word_finder_on_word_ending(self): - if comp.PY3: - code = 'print(a_var)\n' - else: - code = 'print a_var\n' + code = 'print(a_var)\n' word_finder = worder.Worder(code) result = word_finder.get_word_at(code.index('a_var') + 5) self.assertEquals('a_var', result) def test_word_finder_on_primary_ending(self): - if comp.PY3: - code = 'print(a_var)\n' - else: - code = 'print a_var\n' + code = 'print(a_var)\n' result = self._find_primary(code, code.index('a_var') + 5) self.assertEquals('a_var', result) @@ -199,10 +187,7 @@ def test_operators_inside_parens(self): self._find_primary(code, 25)) def test_dictionaries(self): - if comp.PY3: - code = 'print({1: "one", 2: "two"}.keys())' - else: - code = 'print {1: "one", 2: "two"}.keys()' + code = 'print({1: "one", 2: "two"}.keys())' self.assertEquals('{1: "one", 2: "two"}.keys', self._find_primary(code, 29)) @@ -484,30 +469,21 @@ def test_get_pyname_at_on_language_keywords(self): name_finder.get_pyname_at(code.index('pass')) def test_one_liners(self): - if comp.PY3: - code = 'var = 1\ndef f(): var = 2\nprint(var)\n' - else: - code = 'var = 1\ndef f(): var = 2\nprint var\n' + code = 'var = 1\ndef f(): var = 2\nprint(var)\n' pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) self.assertEquals(pymod['var'], pyname) def test_one_liners_with_line_breaks(self): - if comp.PY3: - code = 'var = 1\ndef f(\n): var = 2\nprint(var)\n' - else: - code = 'var = 1\ndef f(\n): var = 2\nprint var\n' + code = 'var = 1\ndef f(\n): var = 2\nprint(var)\n' pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) self.assertEquals(pymod['var'], pyname) def test_one_liners_with_line_breaks2(self): - if comp.PY3: - code = 'var = 1\ndef f(\np): var = 2\nprint(var)\n' - else: - code = 'var = 1\ndef f(\np): var = 2\nprint var\n' + code = 'var = 1\ndef f(\np): var = 2\nprint(var)\n' pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) @@ -542,10 +518,7 @@ def test_implicit_continuation(self): self.assertEquals((1, 3), line_finder.logical_line_in(2)) def test_explicit_continuation(self): - if comp.PY3: - code = 'print(2)\na_var = (3 + \n 4, \n 5)\n' - else: - code = 'print 2\na_var = (3 + \n 4, \n 5)\n' + code = 'print(2)\na_var = (3 + \n 4, \n 5)\n' line_finder = self._logical_finder(code) self.assertEquals((2, 4), line_finder.logical_line_in(2)) @@ -571,10 +544,7 @@ def test_generator_expressions_and_fors(self): self.assertEquals((1, 2), line_finder.logical_line_in(2)) def test_fors_and_block_start(self): - if comp.PY3: - code = 'l = range(10)\nfor i in l:\n print(i)\n' - else: - code = 'l = range(10)\nfor i in l:\n print i\n' + code = 'l = range(10)\nfor i in l:\n print(i)\n' self.assertEquals(2, get_block_start(SourceLinesAdapter(code), 2)) def test_problems_with_inner_indentations(self): From 9927d783187bb946f6688a3530d1a27b77d7de8a Mon Sep 17 00:00:00 2001 From: emacsway Date: Fri, 29 Jan 2016 02:17:13 +0200 Subject: [PATCH 34/92] Python3 compatibility. Print statement. Now left only (failures=50, errors=19) --- ropetest/codeanalyzetest.py | 1 - ropetest/contrib/codeassisttest.py | 4 ++-- ropetest/refactor/extracttest.py | 12 ++++++------ ropetest/runmodtest.py | 2 +- 4 files changed, 9 insertions(+), 10 deletions(-) diff --git a/ropetest/codeanalyzetest.py b/ropetest/codeanalyzetest.py index 760dbe901..6b6ff0883 100644 --- a/ropetest/codeanalyzetest.py +++ b/ropetest/codeanalyzetest.py @@ -4,7 +4,6 @@ import unittest import rope.base.evaluate -import rope.comp as comp from rope.base import libutils from rope.base import exceptions, worder, codeanalyze from rope.base.codeanalyze import (SourceLinesAdapter, diff --git a/ropetest/contrib/codeassisttest.py b/ropetest/contrib/codeassisttest.py index 77306a13a..99af16841 100644 --- a/ropetest/contrib/codeassisttest.py +++ b/ropetest/contrib/codeassisttest.py @@ -6,7 +6,6 @@ except ImportError: import unittest -import rope.comp as comp from rope.base import exceptions from rope.contrib.codeassist import (get_definition_location, get_doc, starting_expression, code_assist, @@ -19,6 +18,7 @@ except NameError: unicode = str + class CodeAssistTest(unittest.TestCase): def setUp(self): @@ -401,7 +401,7 @@ def test_get_definition_location_dot_line_break_inside_parens(self): def test_if_scopes_in_other_scopes_for_get_definition_location(self): code = 'def f(a_var):\n pass\na_var = 10\n' + \ 'if True:\n' + \ - (' print(a_var)\n' if comp.PY3 else ' print a_var\n') + ' print(a_var)\n' result = get_definition_location(self.project, code, len(code) - 3) self.assertEquals((None, 3), result) diff --git a/ropetest/refactor/extracttest.py b/ropetest/refactor/extracttest.py index bf87f9598..de48b3895 100644 --- a/ropetest/refactor/extracttest.py +++ b/ropetest/refactor/extracttest.py @@ -717,12 +717,12 @@ def test_extract_method_when_an_attribute_exists_in_function_scope(self): 'a = A()\n' \ 'def f():\n' \ ' func = a.func()\n' \ - ' print func\n' + ' print(func)\n' start, end = self._convert_line_range_to_offset(code, 6, 6) refactored = self.do_extract_method(code, start, end, 'g') refactored = refactored[refactored.index('A()') + 4:] - expected = 'def f():\n func = g()\n print func\n\n' \ + expected = 'def f():\n func = g()\n print(func)\n\n' \ 'def g():\n func = a.func()\n return func\n' self.assertEquals(expected, refactored) @@ -775,12 +775,12 @@ def test_where_to_seach_when_extracting_global_names(self): self.assertEquals(expected, refactored) def test_extracting_pieces_with_distinct_temp_names(self): - code = 'a = 1\nprint a\nb = 1\nprint b\n' + code = 'a = 1\nprint(a)\nb = 1\nprint(b)\n' start = code.index('a') end = code.index('\nb') refactored = self.do_extract_method(code, start, end, 'f', similar=True, global_=True) - expected = '\ndef f():\n a = 1\n print a\n\nf()\nf()\n' + expected = '\ndef f():\n a = 1\n print(a)\n\nf()\nf()\n' self.assertEquals(expected, refactored) def test_extract_methods_in_glob_funcs_should_be_glob(self): @@ -876,12 +876,12 @@ def test_extract_method_with_variables_possibly_written_to(self): code = "def a_func(b):\n" \ " if b > 0:\n" \ " a = 2\n" \ - " print a\n" + " print(a)\n" start, end = self._convert_line_range_to_offset(code, 2, 3) refactored = self.do_extract_method(code, start, end, 'extracted') expected = "def a_func(b):\n" \ " a = extracted(b)\n" \ - " print a\n\n" \ + " print(a)\n\n" \ "def extracted(b):\n" \ " if b > 0:\n" \ " a = 2\n" \ diff --git a/ropetest/runmodtest.py b/ropetest/runmodtest.py index a425488e2..932088e36 100644 --- a/ropetest/runmodtest.py +++ b/ropetest/runmodtest.py @@ -114,7 +114,7 @@ def test_setting_process_output(self): file_path = 'sample.py' self.make_sample_python_file(file_path, "def get_text():" + - "\n print 'output text'" + "\n print('output text')" "\n return 'run'\n") temp_file_name = 'processtest.tmp' try: From 89959f56de08fd836a64826d69f89be0fee85889 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 01:33:24 +0100 Subject: [PATCH 35/92] mostly fixed way how to get param name of the functions, etc --- rope/base/builtins.py | 7 +++++-- rope/base/pyobjectsdef.py | 7 +++++-- rope/comp.py | 11 +++++++++++ rope/contrib/codeassist.py | 24 ++++++++++++++---------- 4 files changed, 35 insertions(+), 14 deletions(-) diff --git a/rope/base/builtins.py b/rope/base/builtins.py index 4cf5768db..a69e28af5 100644 --- a/rope/base/builtins.py +++ b/rope/base/builtins.py @@ -657,8 +657,11 @@ def get_name(self): return 'lambda' def get_param_names(self, special_args=True): - result = [node.id for node in self.arguments.args - if isinstance(node, ast.Name)] + ast_type = ast.Name + if comp.PY3: + ast_type = ast.arg + result = [comp.get_param_name(node) for node in self.arguments.args + if isinstance(node, ast_type)] if self.arguments.vararg: result.append('*' + self.arguments.vararg) if self.arguments.kwarg: diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index 49b7865e2..4ece33e46 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -7,12 +7,15 @@ from rope.base import (pynamesdef as pynames, exceptions, ast, astutils, pyobjects, fscommands, arguments, utils) +from rope import comp + try: unicode except NameError: unicode = str + class PyFunction(pyobjects.PyFunction): def __init__(self, pycore, ast_node, parent): @@ -84,9 +87,9 @@ def get_param_names(self, special_args=True): if isinstance(node, ast.Name)] if special_args: if self.arguments.vararg: - result.append(self.arguments.vararg) + result.append(comp.get_param_name(self.arguments.vararg)) if self.arguments.kwarg: - result.append(self.arguments.kwarg) + result.append(comp.get_param_name(self.arguments.kwarg)) return result def get_kind(self): diff --git a/rope/comp.py b/rope/comp.py index 23c621d40..9dcbd7cd0 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -1,4 +1,6 @@ import sys +import _ast +# from rope.base import ast PY2 = sys.version_info[0] == 2 PY3 = sys.version_info[0] == 3 @@ -25,3 +27,12 @@ def execfile(fn, global_vars=None, local_vars=None): integer_types = (int, long) builtins = __import__('__builtin__') execfile = execfile + + +def get_param_name(param): + if PY3 and isinstance(param, _ast.arg): + return param.arg + if isinstance(param, _ast.Name): + return param.id + raise ValueError('Unknown param type passed') + diff --git a/rope/contrib/codeassist.py b/rope/contrib/codeassist.py index 92c1bfc27..e0d1c83a5 100644 --- a/rope/contrib/codeassist.py +++ b/rope/contrib/codeassist.py @@ -4,15 +4,18 @@ import rope.base.codeanalyze import rope.base.evaluate -from rope.base import builtins -from rope.base import exceptions -from rope.base import libutils -from rope.base import pynames -from rope.base import pynamesdef -from rope.base import pyobjects -from rope.base import pyobjectsdef -from rope.base import pyscopes -from rope.base import worder +import six +from rope.base import ( + builtins, + exceptions, + libutils, + pynames, + pynamesdef, + pyobjects, + pyobjectsdef, + pyscopes, + worder +) from rope.contrib import fixsyntax from rope.refactor import functionutils @@ -407,7 +410,7 @@ def _undotted_completions(self, scope, result, lineno=None): names = scope.get_propagated_names() else: names = scope.get_names() - for name, pyname in names.items(): + for name, pyname in six.viewitems(names): if name.startswith(self.starting): compl_scope = 'local' if scope.get_kind() == 'Module': @@ -563,6 +566,7 @@ def get_calltip(self, pyobject, ignore_unknown=False, remove_self=False): pyobject = pyobject['__call__'].get_object() except exceptions.AttributeNotFoundError: return None + if ignore_unknown and not isinstance(pyobject, pyobjects.PyFunction): return if isinstance(pyobject, pyobjects.AbstractFunction): From ae2f488cfd3221edbce703ad6d037140f9d33521 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 01:36:25 +0100 Subject: [PATCH 36/92] fixed unknown param type passed for python2 --- rope/comp.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rope/comp.py b/rope/comp.py index 9dcbd7cd0..9eb9c645d 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -34,5 +34,5 @@ def get_param_name(param): return param.arg if isinstance(param, _ast.Name): return param.id - raise ValueError('Unknown param type passed') + return param From 352d1e4b9be3b37d333b80ec732fe59826295fca Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 01:44:10 +0100 Subject: [PATCH 37/92] reverted changes back --- rope/contrib/codeassist.py | 24 ++++++++++-------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/rope/contrib/codeassist.py b/rope/contrib/codeassist.py index e0d1c83a5..92c1bfc27 100644 --- a/rope/contrib/codeassist.py +++ b/rope/contrib/codeassist.py @@ -4,18 +4,15 @@ import rope.base.codeanalyze import rope.base.evaluate -import six -from rope.base import ( - builtins, - exceptions, - libutils, - pynames, - pynamesdef, - pyobjects, - pyobjectsdef, - pyscopes, - worder -) +from rope.base import builtins +from rope.base import exceptions +from rope.base import libutils +from rope.base import pynames +from rope.base import pynamesdef +from rope.base import pyobjects +from rope.base import pyobjectsdef +from rope.base import pyscopes +from rope.base import worder from rope.contrib import fixsyntax from rope.refactor import functionutils @@ -410,7 +407,7 @@ def _undotted_completions(self, scope, result, lineno=None): names = scope.get_propagated_names() else: names = scope.get_names() - for name, pyname in six.viewitems(names): + for name, pyname in names.items(): if name.startswith(self.starting): compl_scope = 'local' if scope.get_kind() == 'Module': @@ -566,7 +563,6 @@ def get_calltip(self, pyobject, ignore_unknown=False, remove_self=False): pyobject = pyobject['__call__'].get_object() except exceptions.AttributeNotFoundError: return None - if ignore_unknown and not isinstance(pyobject, pyobjects.PyFunction): return if isinstance(pyobject, pyobjects.AbstractFunction): From f5483b62469d55a4555344723431f40e23b63cb6 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 06:08:59 +0100 Subject: [PATCH 38/92] fixed try..except..finally for py3, fixed stdlib issue for py3 --- rope/base/stdmods.py | 21 +++++++++++++++++---- rope/refactor/importutils/module_imports.py | 19 ++++++++++--------- rope/refactor/suites.py | 21 ++++++++++++++++++--- 3 files changed, 45 insertions(+), 16 deletions(-) diff --git a/rope/base/stdmods.py b/rope/base/stdmods.py index 457a4faca..61bce74ec 100644 --- a/rope/base/stdmods.py +++ b/rope/base/stdmods.py @@ -1,13 +1,19 @@ +import re import os import sys from rope.base import utils +from rope import comp def _stdlib_path(): - import distutils.sysconfig - return distutils.sysconfig.get_python_lib(standard_lib=True, - plat_specific=True) + if comp.PY2: + from distutils import sysconfig + return sysconfig.get_python_lib(standard_lib=True, + plat_specific=True) + elif comp.PY3: + import sysconfig + return sysconfig.get_config_var('LIBDIR') @utils.cached(1) @@ -31,6 +37,13 @@ def python_modules(): return result +def normalize_so_name(name): + """ + Handle different types of python installations + """ + return re.sub('\.cpython-\d+', '', os.path.splitext(name)[0].replace('module', '')) + + @utils.cached(1) def dynload_modules(): result = set(sys.builtin_module_names) @@ -42,5 +55,5 @@ def dynload_modules(): if name.endswith('.dll'): result.add(os.path.splitext(name)[0]) if name.endswith('.so'): - result.add(os.path.splitext(name)[0].replace('module', '')) + result.add(normalize_so_name(name)) return result diff --git a/rope/refactor/importutils/module_imports.py b/rope/refactor/importutils/module_imports.py index c16f5628c..0d7760bdc 100644 --- a/rope/refactor/importutils/module_imports.py +++ b/rope/refactor/importutils/module_imports.py @@ -223,8 +223,10 @@ def _first_import_line(self): if self.pymodule.get_doc() is not None: lineno = 1 if len(nodes) > lineno: - if (isinstance(nodes[lineno], ast.Import) or - isinstance(nodes[lineno], ast.ImportFrom)): + if ( + isinstance(nodes[lineno], ast.Import) or + isinstance(nodes[lineno], ast.ImportFrom) + ): return nodes[lineno].lineno lineno = self.pymodule.logical_lines.logical_line_in( nodes[lineno].lineno)[0] @@ -250,13 +252,13 @@ def _key_imports(self, stm1): str1 = stm1.get_import_statement() return str1.startswith("from "), str1 - #str1 = stmt1.get_import_statement() - #str2 = stmt2.get_import_statement() - #if str1.startswith('from ') and not str2.startswith('from '): + # str1 = stmt1.get_import_statement() + # str2 = stmt2.get_import_statement() + # if str1.startswith('from ') and not str2.startswith('from '): # return 1 - #if not str1.startswith('from ') and str2.startswith('from '): + # if not str1.startswith('from ') and str2.startswith('from '): # return -1 - #return cmp(str1, str2) + # return cmp(str1, str2) def _move_imports(self, imports, index, blank_lines): if imports: @@ -474,8 +476,7 @@ def visit_from(self, node, end_line): self.imports.append(importinfo.ImportStatement( import_info, node.lineno, end_line, self._get_text(start_line, end_line), - blank_lines= - self._count_empty_lines_before(start_line))) + blank_lines=self._count_empty_lines_before(start_line))) def _get_names(self, alias_names): result = [] diff --git a/rope/refactor/suites.py b/rope/refactor/suites.py index 4f9a8c715..dc25c59fa 100644 --- a/rope/refactor/suites.py +++ b/rope/refactor/suites.py @@ -1,4 +1,5 @@ from rope.base import ast +from rope import comp def find_visible(node, lines): @@ -115,13 +116,27 @@ def _With(self, node): self.suites.append(Suite(node.body, node.lineno, self.suite)) def _TryFinally(self, node): - if len(node.finalbody) == 1 and \ - isinstance(node.body[0], ast.TryExcept): - self._TryExcept(node.body[0]) + proceed_to_except_handler = False + if len(node.finalbody) == 1: + if comp.PY2: + proceed_to_except_handler = isinstance(node.body[0], ast.TryExcept) + elif comp.PY3: + try: + proceed_to_except_handler = isinstance(node.handlers[0], ast.ExceptHandler) + except IndexError: + pass + if proceed_to_except_handler: + self._TryExcept(node if comp.PY3 else node.body[0]) else: self.suites.append(Suite(node.body, node.lineno, self.suite)) self.suites.append(Suite(node.finalbody, node.lineno, self.suite)) + def _Try(self, node): + if len(node.finalbody) == 1: + self._TryFinally(node) + else: + self._TryExcept(node) + def _TryExcept(self, node): self.suites.append(Suite(node.body, node.lineno, self.suite)) for handler in node.handlers: From 80b081548c7fe08799689035b3a67a757c47ccb8 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 06:30:18 +0100 Subject: [PATCH 39/92] fixed bunch of issues with python 3 --- rope/base/stdmods.py | 3 +++ rope/refactor/patchedast.py | 11 ++++++++++- ropetest/refactor/patchedasttest.py | 2 +- ropetest/refactor/similarfindertest.py | 4 ++-- 4 files changed, 16 insertions(+), 4 deletions(-) diff --git a/rope/base/stdmods.py b/rope/base/stdmods.py index 61bce74ec..e20f3cba2 100644 --- a/rope/base/stdmods.py +++ b/rope/base/stdmods.py @@ -12,6 +12,9 @@ def _stdlib_path(): return sysconfig.get_python_lib(standard_lib=True, plat_specific=True) elif comp.PY3: + # @todo, it works with this stuff.. maybe it would work well + # on travis, not sure yet + # return '/home/sergeyg/.virtualenvs/rit/lib/python3.4' import sysconfig return sysconfig.get_config_var('LIBDIR') diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index c32342d4c..6552b3389 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -515,13 +515,16 @@ def _DictComp(self, node): children.extend(node.generators) children.append('}') self._handle(node, children) - + def _Module(self, node): self._handle(node, list(node.body), eat_spaces=True) def _Name(self, node): self._handle(node, [node.id]) + def _arg(self, node): + self._handle(node, [node.arg]) + def _Pass(self, node): self._handle(node, ['pass']) @@ -599,6 +602,12 @@ def _TryExcept(self, node): children.extend(node.orelse) self._handle(node, children) + def _Try(self, node): + if len(node.finalbody): + self._TryFinally(node) + else: + self._TryExcept(node) + def _ExceptHandler(self, node): self._excepthandler(node) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index ecb3d199c..49d246107 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -30,7 +30,7 @@ def test_integer_literals_and_sorted_children(self): source = 'a = 10\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) - #start = source.index('10') + # start = source.index('10') checker.check_children('Num', ['10']) def test_ass_name_node(self): diff --git a/ropetest/refactor/similarfindertest.py b/ropetest/refactor/similarfindertest.py index eed515ec1..c8e6c1ff3 100644 --- a/ropetest/refactor/similarfindertest.py +++ b/ropetest/refactor/similarfindertest.py @@ -256,11 +256,11 @@ def test_simple_templates(self): def test_ignoring_matches_in_comments(self): template = similarfinder.CodeTemplate('#${a}\n') - self.assertEquals([], template.get_names()) + self.assertEquals({}.keys(), template.get_names()) def test_ignoring_matches_in_strings(self): template = similarfinder.CodeTemplate("'${a}'\n") - self.assertEquals([], template.get_names()) + self.assertEquals({}.keys(), template.get_names()) def test_simple_substitution(self): template = similarfinder.CodeTemplate('${a}\n') From c971b94acc03b3b40a197596870b74be343579f3 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 07:06:58 +0100 Subject: [PATCH 40/92] fixed one test case in builtins --- rope/base/builtins.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rope/base/builtins.py b/rope/base/builtins.py index a69e28af5..794f3c7e4 100644 --- a/rope/base/builtins.py +++ b/rope/base/builtins.py @@ -663,9 +663,9 @@ def get_param_names(self, special_args=True): result = [comp.get_param_name(node) for node in self.arguments.args if isinstance(node, ast_type)] if self.arguments.vararg: - result.append('*' + self.arguments.vararg) + result.append('*' + comp.get_param_name(self.arguments.vararg)) if self.arguments.kwarg: - result.append('**' + self.arguments.kwarg) + result.append('**' + comp.get_param_name(self.arguments.kwarg)) return result @property From 269a4e13a084f0464a6b7511a57196f5cd67dafb Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 13:13:11 +0100 Subject: [PATCH 41/92] proper way how to get a path to python standart lib --- rope/base/pynamesdef.py | 2 +- rope/base/stdmods.py | 5 +---- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/rope/base/pynamesdef.py b/rope/base/pynamesdef.py index 6dba0a803..1a498ce31 100644 --- a/rope/base/pynamesdef.py +++ b/rope/base/pynamesdef.py @@ -1,6 +1,6 @@ import rope.base.oi.soi from rope.base import pynames -from rope.base.pynames import * +from rope.base.pynames import * # NOQA class AssignedName(pynames.AssignedName): diff --git a/rope/base/stdmods.py b/rope/base/stdmods.py index e20f3cba2..f6eae8738 100644 --- a/rope/base/stdmods.py +++ b/rope/base/stdmods.py @@ -12,11 +12,8 @@ def _stdlib_path(): return sysconfig.get_python_lib(standard_lib=True, plat_specific=True) elif comp.PY3: - # @todo, it works with this stuff.. maybe it would work well - # on travis, not sure yet - # return '/home/sergeyg/.virtualenvs/rit/lib/python3.4' import sysconfig - return sysconfig.get_config_var('LIBDIR') + return sysconfig.get_config_var('LIBDIR') + os.sep + 'python' + '.'.join(map(str, sys.version_info[0:2])) @utils.cached(1) From c943726bfd4c69793f0a37754dabcf697cdaf822 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 14:51:14 +0100 Subject: [PATCH 42/92] some improvements and fixed way how we execute files on python3 --- rope/base/builtins.py | 11 ++++------- rope/base/pyobjectsdef.py | 4 ++-- rope/comp.py | 22 ++++++++++++++-------- 3 files changed, 20 insertions(+), 17 deletions(-) diff --git a/rope/base/builtins.py b/rope/base/builtins.py index 794f3c7e4..7b2b20969 100644 --- a/rope/base/builtins.py +++ b/rope/base/builtins.py @@ -657,15 +657,12 @@ def get_name(self): return 'lambda' def get_param_names(self, special_args=True): - ast_type = ast.Name - if comp.PY3: - ast_type = ast.arg - result = [comp.get_param_name(node) for node in self.arguments.args - if isinstance(node, ast_type)] + result = [comp.get_ast_arg_arg(node) for node in self.arguments.args + if isinstance(node, comp.ast_arg_type)] if self.arguments.vararg: - result.append('*' + comp.get_param_name(self.arguments.vararg)) + result.append('*' + comp.get_ast_arg_arg(self.arguments.vararg)) if self.arguments.kwarg: - result.append('**' + comp.get_param_name(self.arguments.kwarg)) + result.append('**' + comp.get_ast_arg_arg(self.arguments.kwarg)) return result @property diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index 4ece33e46..555906e14 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -87,9 +87,9 @@ def get_param_names(self, special_args=True): if isinstance(node, ast.Name)] if special_args: if self.arguments.vararg: - result.append(comp.get_param_name(self.arguments.vararg)) + result.append(comp.get_ast_arg_arg(self.arguments.vararg)) if self.arguments.kwarg: - result.append(comp.get_param_name(self.arguments.kwarg)) + result.append(comp.get_ast_arg_arg(self.arguments.kwarg)) return result def get_kind(self): diff --git a/rope/comp.py b/rope/comp.py index 9eb9c645d..58165cf99 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -14,11 +14,15 @@ string_types = (str,) integer_types = (int,) import builtins + ast_arg_type = _ast.arg def execfile(fn, global_vars=None, local_vars=None): with open(fn) as f: code = compile(f.read(), fn, 'exec') - exec(code, global_vars or {}, local_vars or {}) + exec_args = [] + if local_vars: + exec_args.append(local_vars) + exec(code, global_vars or {}, *exec_args) else: # PY2 @@ -26,13 +30,15 @@ def execfile(fn, global_vars=None, local_vars=None): string_types = (basestring,) integer_types = (int, long) builtins = __import__('__builtin__') + ast_arg_type = _ast.Name execfile = execfile -def get_param_name(param): - if PY3 and isinstance(param, _ast.arg): - return param.arg - if isinstance(param, _ast.Name): - return param.id - return param - +def get_ast_arg_arg(arg): + if PY3 and isinstance(arg, _ast.arg): + return arg.arg + if isinstance(arg, _ast.Name): + return arg.id + if isinstance(arg, string_types): + return arg + raise ValueError('UnknownType Passed to get_ast_asg_arg') From 1ea5342d0c3e69a6d27719491816968ad2bbd60c Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 15:02:56 +0100 Subject: [PATCH 43/92] fixed problem with python2 --- rope/comp.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/rope/comp.py b/rope/comp.py index 58165cf99..7fa93eb2b 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -19,10 +19,7 @@ def execfile(fn, global_vars=None, local_vars=None): with open(fn) as f: code = compile(f.read(), fn, 'exec') - exec_args = [] - if local_vars: - exec_args.append(local_vars) - exec(code, global_vars or {}, *exec_args) + exec(code, global_vars or {}, local_vars) else: # PY2 From c7c358381cdd2ca58d4dfed1cb0f421e1cae525b Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 15:12:47 +0100 Subject: [PATCH 44/92] fixed with optionalvars for py3 --- rope/base/pyobjectsdef.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index 555906e14..6fe415f37 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -390,9 +390,13 @@ def _update_evaluated(self, targets, assigned, return result def _With(self, node): - if node.optional_vars: - self._update_evaluated(node.optional_vars, - node.context_expr, '.__enter__()') + if comp.PY2: + withitem = node + else: + withitem = node.__dict__['items'][0] + if withitem.optional_vars: + self._update_evaluated(withitem.optional_vars, + withitem.context_expr, '.__enter__()') for child in node.body: ast.walk(child, self) From 1723d4e425048ba3055a87ac907ceee714a03985 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 15:23:28 +0100 Subject: [PATCH 45/92] fixed style of exception for python3 --- ropetest/objectinfertest.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ropetest/objectinfertest.py b/ropetest/objectinfertest.py index 36633d31b..ca8c29a08 100644 --- a/ropetest/objectinfertest.py +++ b/ropetest/objectinfertest.py @@ -286,7 +286,7 @@ def test_list_comprehensions_and_multiple_iters(self): def test_we_know_the_type_of_catched_exceptions(self): code = 'class MyError(Exception):\n pass\n' \ 'try:\n raise MyError()\n' \ - 'except MyError, e:\n pass\n' + 'except MyError as e:\n pass\n' mod = libutils.get_string_module(self.project, code) my_error = mod['MyError'].get_object() e_var = mod['e'].get_object() @@ -295,7 +295,7 @@ def test_we_know_the_type_of_catched_exceptions(self): def test_we_know_the_type_of_catched_multiple_excepts(self): code = 'class MyError(Exception):\n pass\n' \ 'try:\n raise MyError()\n' \ - 'except (MyError, Exception), e:\n pass\n' + 'except (MyError, Exception) as e:\n pass\n' mod = libutils.get_string_module(self.project, code) my_error = mod['MyError'].get_object() e_var = mod['e'].get_object() From a786cde468ff16c58a0c50666a9373d4b734deb3 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 15:53:16 +0100 Subject: [PATCH 46/92] fixed more tests for py3 --- rope/base/pyobjectsdef.py | 5 +---- rope/comp.py | 6 ++++++ rope/refactor/patchedast.py | 9 ++++++--- ropetest/refactor/patchedasttest.py | 8 +++++--- 4 files changed, 18 insertions(+), 10 deletions(-) diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index 6fe415f37..9b3c8b249 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -390,10 +390,7 @@ def _update_evaluated(self, targets, assigned, return result def _With(self, node): - if comp.PY2: - withitem = node - else: - withitem = node.__dict__['items'][0] + withitem = comp.get_ast_with(node) if withitem.optional_vars: self._update_evaluated(withitem.optional_vars, withitem.context_expr, '.__enter__()') diff --git a/rope/comp.py b/rope/comp.py index 7fa93eb2b..bbba919fa 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -39,3 +39,9 @@ def get_ast_arg_arg(arg): if isinstance(arg, string_types): return arg raise ValueError('UnknownType Passed to get_ast_asg_arg') + + +def get_ast_with(node): + if PY2: + return node + return node.items[0] diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 6552b3389..0d1dd6d47 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -3,12 +3,14 @@ import warnings from rope.base import ast, codeanalyze, exceptions +from rope import comp try: basestring except NameError: basestring = (str, bytes) + def get_patched_ast(source, sorted_children=False): """Adds ``region`` and ``sorted_children`` fields to nodes @@ -651,9 +653,10 @@ def _While(self, node): self._handle(node, children) def _With(self, node): - children = ['with', node.context_expr] - if node.optional_vars: - children.extend(['as', node.optional_vars]) + withitem = comp.get_ast_with(node) + children = ['with', withitem.context_expr] + if withitem.optional_vars: + children.extend(['as', withitem.optional_vars]) children.append(':') children.extend(node.body) self._handle(node, children) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index 49d246107..13145c815 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -372,8 +372,9 @@ def test_function_node2(self): 'Function', ['def', ' ', 'f', '', '(', '', 'arguments', '', ')', '', ':', '\n ', 'Expr', '\n ', 'Pass']) + expected_arg_name = comp.ast_arg_type.__name__ checker.check_children( - 'arguments', ['Name', '', ',', + 'arguments', [expected_arg_name, '', ',', ' ', '**', '', 'p2']) def test_function_node_and_tuple_parameters(self): @@ -544,8 +545,9 @@ def test_lambda_node(self): checker.check_region('Lambda', 0, len(source) - 1) checker.check_children( 'Lambda', ['lambda', ' ', 'arguments', '', ':', ' ', 'Name']) + expected_arg_name = comp.ast_arg_type.__name__ checker.check_children( - 'arguments', ['Name', '', ',', ' ', 'Name', '', '=', '', + 'arguments', [expected_arg_name, '', ',', ' ', expected_arg_name, '', '=', '', 'Num', '', ',', ' ', '*', '', 'z']) def test_list_node(self): @@ -782,7 +784,7 @@ def test_try_finally_node(self): '', ':', '\n ', 'Pass']) def test_try_except_node(self): - source = 'try:\n pass\nexcept Exception, e:\n pass\n' + source = 'try:\n pass\nexcept Exception as e:\n pass\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) checker.check_children( From 008d49e4f53737a295203d8f23742954f79e59bb Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 16:00:51 +0100 Subject: [PATCH 47/92] fixed tests for python2 --- ropetest/refactor/patchedasttest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index 13145c815..96595ce6f 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -792,7 +792,7 @@ def test_try_except_node(self): ('excepthandler', 'ExceptHandler')]) checker.check_children( ('excepthandler', 'ExceptHandler'), - ['except', ' ', 'Name', '', ',', ' ', 'Name', '', ':', + ['except', ' ', 'Name', ' ', 'as', ' ', 'Name', '', ':', '\n ', 'Pass']) def test_try_except_node__with_as_syntax(self): From 49aaf52f9cf49b39a8850b3e2d2025f5c5f1a86c Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 16:09:59 +0100 Subject: [PATCH 48/92] fixed tests for python 3 --- ropetest/refactor/patchedasttest.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index 96595ce6f..8af34603e 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -671,14 +671,11 @@ def test_print_node(self): ',', ' ', 'Num', '', ',']) def test_printnl_node(self): - if comp.PY3: - source = 'print(1)\n' - else: - source = 'print 1\n' + source = 'print(1)\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) checker.check_region('Print', 0, len(source) - 1) - checker.check_children('Print', ['print', ' ', 'Num']) + checker.check_children('Print', ['print', '(', 'Num', ')']) def test_raise_node(self): source = 'raise x, y, z\n' From e5c98ee2e8badff7f2d1738f3210a6c102932721 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 16:19:56 +0100 Subject: [PATCH 49/92] skip tests in python3 for python statement --- ropetest/refactor/patchedasttest.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index 8af34603e..b2e7b83ea 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -662,6 +662,7 @@ def test_not_and_or_nodes(self): checker.check_children('Expr', ['BoolOp']) checker.check_children('BoolOp', ['UnaryOp', ' ', 'or', ' ', 'Name']) + @unittest.skipIf(comp.PY3, 'only for python2 because print is no longer statement in python3') def test_print_node(self): source = 'print >>out, 1,\n' ast_frag = patchedast.get_patched_ast(source, True) @@ -670,6 +671,7 @@ def test_print_node(self): checker.check_children('Print', ['print', ' ', '>>', '', 'Name', '', ',', ' ', 'Num', '', ',']) + @unittest.skipIf(comp.PY3, 'only for python2 because print is no longer statement in python3') def test_printnl_node(self): source = 'print(1)\n' ast_frag = patchedast.get_patched_ast(source, True) From c06154ffa7828cb175fdaa6b637212742c73d88a Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 16:34:37 +0100 Subject: [PATCH 50/92] reusing testutils -> support already existed utils in project --- ropetest/refactor/patchedasttest.py | 4 ++-- ropetest/testutils.py | 9 ++++++++- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index b2e7b83ea..ebc4e9d22 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -662,7 +662,7 @@ def test_not_and_or_nodes(self): checker.check_children('Expr', ['BoolOp']) checker.check_children('BoolOp', ['UnaryOp', ' ', 'or', ' ', 'Name']) - @unittest.skipIf(comp.PY3, 'only for python2 because print is no longer statement in python3') + @testutils.only_for_lower_versions('3') def test_print_node(self): source = 'print >>out, 1,\n' ast_frag = patchedast.get_patched_ast(source, True) @@ -671,7 +671,7 @@ def test_print_node(self): checker.check_children('Print', ['print', ' ', '>>', '', 'Name', '', ',', ' ', 'Num', '', ',']) - @unittest.skipIf(comp.PY3, 'only for python2 because print is no longer statement in python3') + @testutils.only_for_lower_versions('3') def test_printnl_node(self): source = 'print(1)\n' ast_frag = patchedast.get_patched_ast(source, True) diff --git a/ropetest/testutils.py b/ropetest/testutils.py index 768e54e2f..9a175b712 100644 --- a/ropetest/testutils.py +++ b/ropetest/testutils.py @@ -74,7 +74,14 @@ def only_for(version): """Should be used as a decorator for a unittest.TestCase test method""" return unittest.skipIf( sys.version < version, - 'This test requires at lest {0} version of Python.'.format(version)) + 'This test requires at least {0} version of Python.'.format(version)) + + +def only_for_lower_versions(version): + """Should be used as a decorator for a unittest.TestCase test method""" + return unittest.skipIf( + sys.version > version, + 'This test requires version of Python lower than {0}'.format(version)) def skipNotPOSIX(): From b7933ecdd47831385fe4791b821582817ed6c54f Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 17:24:09 +0100 Subject: [PATCH 51/92] skip some tests for python3 because of incompatible syntax --- rope/refactor/patchedast.py | 33 +++++++++++++++++++++-------- ropetest/refactor/patchedasttest.py | 22 ++++++++++++++++--- ropetest/testutils.py | 2 +- 3 files changed, 44 insertions(+), 13 deletions(-) diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 0d1dd6d47..180020ece 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -542,15 +542,30 @@ def _Print(self, node): self._handle(node, children) def _Raise(self, node): - children = ['raise'] - if node.type: - children.append(node.type) - if node.inst: - children.append(',') - children.append(node.inst) - if node.tback: - children.append(',') - children.append(node.tback) + + def get_python3_raise_children(node): + children = ['raise'] + if node.exc: + children.append(node.exc) + if node.cause: + children.append(node.cause) + return children + + def get_python2_raise_children(node): + children = ['raise'] + if node.type: + children.append(node.type) + if node.inst: + children.append(',') + children.append(node.inst) + if node.tback: + children.append(',') + children.append(node.tback) + return children + if comp.PY2: + children = get_python2_raise_children(node) + else: + children = get_python3_raise_children(node) self._handle(node, children) def _Return(self, node): diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index ebc4e9d22..25235b25c 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -157,6 +157,7 @@ def test_not_concatenating_strings_on_separate_lines(self): checker = _ResultChecker(self, ast_frag) checker.check_children('Module', ['', 'Expr', '\n', 'Expr', '\n']) + @testutils.only_for_versions_lower('3') def test_long_integer_literals(self): source = "0x1L + a" ast_frag = patchedast.get_patched_ast(source, True) @@ -229,6 +230,7 @@ def test_aug_assign_node(self): checker.check_children( 'AugAssign', ['Name', ' ', '+', '', '=', ' ', 'Num']) + @testutils.only_for_versions_lower('3') def test_back_quotenode(self): source = '`1`\n' ast_frag = patchedast.get_patched_ast(source, True) @@ -377,6 +379,7 @@ def test_function_node2(self): 'arguments', [expected_arg_name, '', ',', ' ', '**', '', 'p2']) + @testutils.only_for_versions_lower('3') def test_function_node_and_tuple_parameters(self): source = 'def f(a, (b, c)):\n pass\n' ast_frag = patchedast.get_patched_ast(source, True) @@ -404,6 +407,7 @@ def test_div_node(self): checker.check_region('BinOp', 0, len(source) - 1) checker.check_children('BinOp', ['Num', ' ', '/', ' ', 'Num']) + @testutils.only_for_versions_lower('3') def test_simple_exec_node(self): source = 'exec ""\n' ast_frag = patchedast.get_patched_ast(source, True) @@ -411,6 +415,7 @@ def test_simple_exec_node(self): checker.check_region('Exec', 0, len(source) - 1) checker.check_children('Exec', ['exec', ' ', 'Str']) + @testutils.only_for_versions_lower('3') def test_exec_node(self): source = 'exec "" in locals(), globals()\n' ast_frag = patchedast.get_patched_ast(source, True) @@ -662,7 +667,7 @@ def test_not_and_or_nodes(self): checker.check_children('Expr', ['BoolOp']) checker.check_children('BoolOp', ['UnaryOp', ' ', 'or', ' ', 'Name']) - @testutils.only_for_lower_versions('3') + @testutils.only_for_versions_lower('3') def test_print_node(self): source = 'print >>out, 1,\n' ast_frag = patchedast.get_patched_ast(source, True) @@ -671,7 +676,7 @@ def test_print_node(self): checker.check_children('Print', ['print', ' ', '>>', '', 'Name', '', ',', ' ', 'Num', '', ',']) - @testutils.only_for_lower_versions('3') + @testutils.only_for_versions_lower('3') def test_printnl_node(self): source = 'print(1)\n' ast_frag = patchedast.get_patched_ast(source, True) @@ -679,7 +684,8 @@ def test_printnl_node(self): checker.check_region('Print', 0, len(source) - 1) checker.check_children('Print', ['print', '(', 'Num', ')']) - def test_raise_node(self): + @testutils.only_for_versions_lower('3') + def test_raise_node_for_python2(self): source = 'raise x, y, z\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) @@ -688,6 +694,15 @@ def test_raise_node(self): 'Raise', ['raise', ' ', 'Name', '', ',', ' ', 'Name', '', ',', ' ', 'Name']) + @testutils.only_for('3') + def test_raise_node_for_python3(self): + source = 'raise x(y)\n' + ast_frag = patchedast.get_patched_ast(source, True) + checker = _ResultChecker(self, ast_frag) + checker.check_region('Raise', 0, len(source) - 1) + checker.check_children( + 'Raise', ['raise', ' ', 'Call']) + def test_return_node(self): source = 'def f():\n return None\n' ast_frag = patchedast.get_patched_ast(source, True) @@ -836,6 +851,7 @@ def test_ignoring_strings_that_start_with_a_char(self): checker.check_children( 'Module', ['', 'Expr', '\n', 'Expr', '\n']) + @testutils.only_for_versions_lower('3') def test_how_to_handle_old_not_equals(self): source = '1 <> 2\n' ast_frag = patchedast.get_patched_ast(source, True) diff --git a/ropetest/testutils.py b/ropetest/testutils.py index 9a175b712..964cefe63 100644 --- a/ropetest/testutils.py +++ b/ropetest/testutils.py @@ -77,7 +77,7 @@ def only_for(version): 'This test requires at least {0} version of Python.'.format(version)) -def only_for_lower_versions(version): +def only_for_versions_lower(version): """Should be used as a decorator for a unittest.TestCase test method""" return unittest.skipIf( sys.version > version, From 6206884f014e8a7808d905f255fe7edd29809dc6 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 17:36:10 +0100 Subject: [PATCH 52/92] fixed try..catch test for py3 --- ropetest/refactor/patchedasttest.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index 25235b25c..abaebae9f 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -797,8 +797,9 @@ def test_try_finally_node(self): 'TryFinally', ['try', '', ':', '\n ', 'Pass', '\n', 'finally', '', ':', '\n ', 'Pass']) + @testutils.only_for_versions_lower('3') def test_try_except_node(self): - source = 'try:\n pass\nexcept Exception as e:\n pass\n' + source = 'try:\n pass\nexcept Exception, e:\n pass\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) checker.check_children( @@ -806,19 +807,21 @@ def test_try_except_node(self): ('excepthandler', 'ExceptHandler')]) checker.check_children( ('excepthandler', 'ExceptHandler'), - ['except', ' ', 'Name', ' ', 'as', ' ', 'Name', '', ':', + ['except', ' ', 'Name', '', ',', ' ', 'Name', '', ':', '\n ', 'Pass']) def test_try_except_node__with_as_syntax(self): source = 'try:\n pass\nexcept Exception as e:\n pass\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) + node_to_test = 'Try' if comp.PY3 else 'TryExcept' + is_catched_exception_ast_type = comp.PY2 checker.check_children( - 'TryExcept', ['try', '', ':', '\n ', 'Pass', '\n', - ('excepthandler', 'ExceptHandler')]) + node_to_test, ['try', '', ':', '\n ', 'Pass', '\n', + ('excepthandler', 'ExceptHandler')]) checker.check_children( ('excepthandler', 'ExceptHandler'), - ['except', ' ', 'Name', ' ', 'as', ' ', 'Name', '', ':', + ['except', ' ', 'Name', ' ', 'as', ' ', 'Name' if is_catched_exception_ast_type else 'e', '', ':', '\n ', 'Pass']) @testutils.only_for('2.5') From dd2bf38841fd9455a98c2cd11cbd235fe67f7d47 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sat, 30 Jan 2016 18:11:48 +0100 Subject: [PATCH 53/92] not sure about these changes, but let's figure it out later @fixme --- rope/refactor/patchedast.py | 16 +++++++++++++++- ropetest/refactor/patchedasttest.py | 20 ++++++++++++++++---- 2 files changed, 31 insertions(+), 5 deletions(-) diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 180020ece..48f42593c 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -602,10 +602,24 @@ def _Slice(self, node): self._handle(node, children) def _TryFinally(self, node): + is_there_except_handler = False + not_empty_body = True + if len(node.finalbody) == 1: + if comp.PY2: + is_there_except_handler = isinstance(node.body[0], ast.TryExcept) + not_empty_body = not bool(len(node.body)) + elif comp.PY3: + try: + is_there_except_handler = isinstance(node.handlers[0], ast.ExceptHandler) + not_empty_body = True + except IndexError: + pass children = [] - if len(node.body) != 1 or not isinstance(node.body[0], ast.TryExcept): + if not_empty_body or not is_there_except_handler: children.extend(['try', ':']) children.extend(node.body) + if comp.PY3: + children.extend(node.handlers) children.extend(['finally', ':']) children.extend(node.finalbody) self._handle(node, children) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index abaebae9f..1403f877d 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -793,9 +793,14 @@ def test_try_finally_node(self): source = 'try:\n pass\nfinally:\n pass\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) + node_to_test = 'Try' if comp.PY3 else 'TryFinally' + if comp.PY3: + expected_children = ['try', '', ':', '\n ', 'Pass', '\n', 'finally', + '', ':', '\n ', 'Pass'] + else: + expected_children = ['try', '', ':', '\n ', 'Pass', '\n', 'finally', '', ':', '\n ', 'Pass'] checker.check_children( - 'TryFinally', ['try', '', ':', '\n ', 'Pass', '\n', 'finally', - '', ':', '\n ', 'Pass']) + node_to_test, expected_children) @testutils.only_for_versions_lower('3') def test_try_except_node(self): @@ -829,9 +834,16 @@ def test_try_except_and_finally_node(self): source = 'try:\n pass\nexcept:\n pass\nfinally:\n pass\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) + node_to_test = 'Try' if comp.PY3 else 'TryFinally' + if comp.PY3: + expected_children = ['try', '', ':', '\n ', 'Pass', '\n', 'ExceptHandler', '\n', + 'finally', '', ':', '\n ', 'Pass'] + else: + expected_children = ['TryExcept', '\n', 'finally', '', ':', '\n ', 'Pass'] checker.check_children( - 'TryFinally', ['TryExcept', '\n', 'finally', - '', ':', '\n ', 'Pass']) + node_to_test, + expected_children + ) def test_ignoring_comments(self): source = '#1\n1\n' From 188e64dc2a7f6c6b8b015426fd83a22d2db3ee1c Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 31 Jan 2016 02:32:32 +0100 Subject: [PATCH 54/92] added @todos and fixed problems in extract module --- rope/comp.py | 1 + rope/refactor/extract.py | 9 +++++---- rope/refactor/patchedast.py | 1 + 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/rope/comp.py b/rope/comp.py index bbba919fa..cbc5ad839 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -42,6 +42,7 @@ def get_ast_arg_arg(arg): def get_ast_with(node): + # @todo fixmee - handle all withitems if PY2: return node return node.items[0] diff --git a/rope/refactor/extract.py b/rope/refactor/extract.py index c6b3648e4..46596d277 100644 --- a/rope/refactor/extract.py +++ b/rope/refactor/extract.py @@ -5,6 +5,7 @@ from rope.base.exceptions import RefactoringError from rope.refactor import (sourceutils, similarfinder, patchedast, suites, usefunction) +from rope import comp # Extract refactoring has lots of special cases. I tried to split it @@ -686,12 +687,12 @@ def _For(self, node): def _get_argnames(arguments): - result = [node.id for node in arguments.args - if isinstance(node, ast.Name)] + result = [comp.get_ast_arg_arg(node) for node in arguments.args + if isinstance(node, comp.ast_arg_type)] if arguments.vararg: - result.append(arguments.vararg) + result.append(comp.get_ast_arg_arg(arguments.vararg)) if arguments.kwarg: - result.append(arguments.kwarg) + result.append(comp.get_ast_arg_arg(arguments.kwarg)) return result diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 48f42593c..921b2f9ec 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -602,6 +602,7 @@ def _Slice(self, node): self._handle(node, children) def _TryFinally(self, node): + # @todo fixme is_there_except_handler = False not_empty_body = True if len(node.finalbody) == 1: From f75796b4f30366e4e9cfef2391be426521d3da2f Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 31 Jan 2016 21:36:50 +0100 Subject: [PATCH 55/92] fixed way how we walk through excepthandler for versions > python2.7 --- rope/base/astutils.py | 3 +++ rope/base/pyobjectsdef.py | 7 +++++++ rope/comp.py | 1 + ropetest/advanced_oi_test.py | 12 +++++++++--- 4 files changed, 20 insertions(+), 3 deletions(-) diff --git a/rope/base/astutils.py b/rope/base/astutils.py index 8ace1a925..6c0b3d78e 100644 --- a/rope/base/astutils.py +++ b/rope/base/astutils.py @@ -40,6 +40,9 @@ def _added(self, node, levels): def _Name(self, node): self._add_node(node) + def _ExceptHandler(self, node): + self.names.append((node.name, [])) + def _Tuple(self, node): new_levels = [] if self.levels is not None: diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index 9b3c8b249..b48bde25c 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -403,6 +403,13 @@ def _excepthandler(self, node): if isinstance(node.type, ast.Tuple) and type_node.elts: type_node = type_node.elts[0] self._update_evaluated(node.name, type_node, eval_type=True) + + if comp.PY27: + # handles case for syntax MyError as e + if node.name is not None and isinstance(node.type, ast.Name): + self._update_evaluated(node, node.type, eval_type=True) + if node.name is not None and isinstance(node.type, ast.Tuple): + self._update_evaluated(node, node, eval_type=True) for child in node.body: ast.walk(child, self) diff --git a/rope/comp.py b/rope/comp.py index cbc5ad839..547239578 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -3,6 +3,7 @@ # from rope.base import ast PY2 = sys.version_info[0] == 2 +PY27 = sys.version_info[0:2] >= (2, 7) PY3 = sys.version_info[0] == 3 PY34 = sys.version_info[0:2] >= (3, 4) diff --git a/ropetest/advanced_oi_test.py b/ropetest/advanced_oi_test.py index 084fe2a77..c530c0c48 100644 --- a/ropetest/advanced_oi_test.py +++ b/ropetest/advanced_oi_test.py @@ -6,6 +6,7 @@ import rope.base.oi import rope.base.libutils from ropetest import testutils +from rope import comp class DynamicOITest(unittest.TestCase): @@ -182,9 +183,14 @@ def test_dict_objects_and_dynamicoi(self): def test_dict_keys_and_dynamicoi(self): mod = testutils.create_module(self.project, 'mod') - code = 'class C(object):\n pass\n' \ - 'def a_func(arg):\n return eval("arg")\n' \ - 'a_var = a_func({C(): 1}).keys()[0]\n' + if comp.PY3: + code = 'class C(object):\n pass\n' \ + 'def a_func(arg):\n return eval("arg")\n' \ + 'a_var = list(a_func({C(): 1}))[0]\n' + else: + code = 'class C(object):\n pass\n' \ + 'def a_func(arg):\n return eval("arg")\n' \ + 'a_var = a_func({C(): 1}).keys()[0]\n' mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) From 632372b28419291b49dca572b6018c5e269a0142 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Mon, 1 Feb 2016 00:18:05 +0100 Subject: [PATCH 56/92] fixed problem with unordered sets and order of variables in function definitions --- rope/abc/__init__.py | 3 ++ rope/abc/_ordered_set.py | 64 ++++++++++++++++++++++++++++++++++++++++ rope/refactor/extract.py | 13 ++++---- 3 files changed, 74 insertions(+), 6 deletions(-) create mode 100644 rope/abc/__init__.py create mode 100644 rope/abc/_ordered_set.py diff --git a/rope/abc/__init__.py b/rope/abc/__init__.py new file mode 100644 index 000000000..e5aeb846d --- /dev/null +++ b/rope/abc/__init__.py @@ -0,0 +1,3 @@ +__all__ = ['OrderedSet'] + +from ._ordered_set import OrderedSet diff --git a/rope/abc/_ordered_set.py b/rope/abc/_ordered_set.py new file mode 100644 index 000000000..df7ece406 --- /dev/null +++ b/rope/abc/_ordered_set.py @@ -0,0 +1,64 @@ +import collections + + +class OrderedSet(collections.MutableSet): + + def __init__(self, iterable=None): + self.end = end = [] + end += [None, end, end] # sentinel + # node for doubly linked list + self.map = {} # key --> [key, prev, next] + if iterable is not None: + self |= iterable + + def __len__(self): + return len(self.map) + + def __contains__(self, key): + return key in self.map + + def add(self, key): + if key not in self.map: + end = self.end + curr = end[1] + curr[2] = end[1] = self.map[key] = [key, curr, end] + + def intersection(self, set_b): + return OrderedSet([item for item in self if item in set_b]) + + def discard(self, key): + if key in self.map: + key, prev, next = self.map.pop(key) + prev[2] = next + next[1] = prev + + def __iter__(self): + end = self.end + curr = end[2] + while curr is not end: + yield curr[0] + curr = curr[2] + + def __reversed__(self): + end = self.end + curr = end[1] + while curr is not end: + yield curr[0] + curr = curr[1] + + def pop(self, last=True): + if not self: + raise KeyError('set is empty') + key = self.end[1][0] if last else self.end[2][0] + self.discard(key) + return key + + def __repr__(self): + if not self: + return '%s()' % (self.__class__.__name__,) + return '%s(%r)' % (self.__class__.__name__, list(self)) + + def __eq__(self, other): + if isinstance(other, OrderedSet): + return len(self) == len(other) and list(self) == list(other) + return set(self) == set(other) diff --git a/rope/refactor/extract.py b/rope/refactor/extract.py index 46596d277..3074d28bd 100644 --- a/rope/refactor/extract.py +++ b/rope/refactor/extract.py @@ -6,6 +6,7 @@ from rope.refactor import (sourceutils, similarfinder, patchedast, suites, usefunction) from rope import comp +from rope.abc import OrderedSet # Extract refactoring has lots of special cases. I tried to split it @@ -599,12 +600,12 @@ def __init__(self, start, end, is_global): self.start = start self.end = end self.is_global = is_global - self.prewritten = set() - self.maybe_written = set() - self.written = set() - self.read = set() - self.postread = set() - self.postwritten = set() + self.prewritten = OrderedSet() + self.maybe_written = OrderedSet() + self.written = OrderedSet() + self.read = OrderedSet() + self.postread = OrderedSet() + self.postwritten = OrderedSet() self.host_function = True self.conditional = False From 9cf18aa71036f25e826b01749e2001c06b593fbb Mon Sep 17 00:00:00 2001 From: emacsway Date: Wed, 3 Feb 2016 21:29:51 +0200 Subject: [PATCH 57/92] Py3k: fixed test_dict_keys_and_dynamicoi(). Currently failures=21 in Python 3.4 --- rope/base/oi/runmod.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rope/base/oi/runmod.py b/rope/base/oi/runmod.py index 25d0c7f62..6eb6cf893 100644 --- a/rope/base/oi/runmod.py +++ b/rope/base/oi/runmod.py @@ -142,7 +142,7 @@ def _get_persisted_builtin(self, object_): keys = None values = None if len(object_) > 0: - keys = object_.keys()[0] + keys = list(object_.keys())[0] values = object_[keys] return ('builtin', 'dict', self._object_to_persisted_form(keys), From 5af9d70f9128d9a5058be34694b7c34ec54d9703 Mon Sep 17 00:00:00 2001 From: emacsway Date: Wed, 3 Feb 2016 22:00:43 +0200 Subject: [PATCH 58/92] Py3k Added support of NameConstant in patched ast. Currently failures=5 --- rope/refactor/patchedast.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 921b2f9ec..6e94b14e8 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -524,6 +524,9 @@ def _Module(self, node): def _Name(self, node): self._handle(node, [node.id]) + def _NameConstant(self, node): + self._handle(node, [str(node.value)]) + def _arg(self, node): self._handle(node, [node.arg]) From 4bb66819a7225e1cb48c77e98e67487b42a159bd Mon Sep 17 00:00:00 2001 From: emacsway Date: Wed, 3 Feb 2016 23:01:11 +0200 Subject: [PATCH 59/92] Py3k fixed vararg, kwarg in patchedast, now failures=2 --- rope/comp.py | 16 +++++++--------- rope/refactor/patchedast.py | 4 ++-- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/rope/comp.py b/rope/comp.py index 547239578..ff748d30d 100644 --- a/rope/comp.py +++ b/rope/comp.py @@ -22,6 +22,9 @@ def execfile(fn, global_vars=None, local_vars=None): code = compile(f.read(), fn, 'exec') exec(code, global_vars or {}, local_vars) + def get_ast_arg_arg(node): + return node.arg + else: # PY2 @@ -31,15 +34,10 @@ def execfile(fn, global_vars=None, local_vars=None): ast_arg_type = _ast.Name execfile = execfile - -def get_ast_arg_arg(arg): - if PY3 and isinstance(arg, _ast.arg): - return arg.arg - if isinstance(arg, _ast.Name): - return arg.id - if isinstance(arg, string_types): - return arg - raise ValueError('UnknownType Passed to get_ast_asg_arg') + def get_ast_arg_arg(node): + if isinstance(node, string_types): # Python2 arguments.vararg, arguments.kwarg + return node + return node.id def get_ast_with(node): diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 6e94b14e8..3a91ac1ec 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -402,11 +402,11 @@ def _arguments(self, node): if node.vararg is not None: if args: children.append(',') - children.extend(['*', node.vararg]) + children.extend(['*', comp.get_ast_arg_arg(node.vararg)]) if node.kwarg is not None: if args or node.vararg is not None: children.append(',') - children.extend(['**', node.kwarg]) + children.extend(['**', comp.get_ast_arg_arg(node.kwarg)]) self._handle(node, children) def _add_args_to_children(self, children, arg, default): From bb6a0d33effc5699a4033b21908fd43a631b203e Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Wed, 3 Feb 2016 22:18:46 +0100 Subject: [PATCH 60/92] added contributors and small things --- CONTRIBUTORS | 1 + README.rst | 4 ++-- setup.py | 2 +- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/CONTRIBUTORS b/CONTRIBUTORS index d78bb1a7a..fe41ebc10 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -13,3 +13,4 @@ See Mercurial logs and the mailing list for details. * Ronny Pfannschmidt * Anton Gritsay * Ivan Zakrevsky +* Sergey Glazyrin diff --git a/README.rst b/README.rst index a7ea020da..062458c1b 100644 --- a/README.rst +++ b/README.rst @@ -18,8 +18,8 @@ Overview New Features ============ -* Under new management! Matěj Cepl takes it hesitantly - over +* Right now Ivan Zakrevsky and Sergey Glazyrin as emacs fans are + working to give the library a new life and support at the same time in a roper package python versions > 2.7 * Merged all availables pull requests and patches to the main codebase * Tests are green again diff --git a/setup.py b/setup.py index eff75f853..258dcc05d 100644 --- a/setup.py +++ b/setup.py @@ -52,7 +52,7 @@ def get_long_description(): long_description=get_long_description(), author='Ali Gholami Rudi', author_email='aligrudi@users.sourceforge.net', - url='https://github.com/python-rope/rope', + url='https://github.com/sergeyglazyrindev/rope', packages=['rope', 'rope.base', 'rope.base.oi', 'rope.refactor', 'rope.refactor.importutils', 'rope.contrib'], license='GNU GPL', From 6050d7493f4cc5dfecd07c9db33517b35d87d7c2 Mon Sep 17 00:00:00 2001 From: emacsway Date: Thu, 4 Feb 2016 01:03:42 +0200 Subject: [PATCH 61/92] rope.comp -> rope.base.utils.pycompat --- rope/base/builtins.py | 14 +++++++------- rope/base/fscommands.py | 7 ++++--- rope/base/oi/runmod.py | 8 ++++---- rope/base/project.py | 8 ++++---- rope/base/pyobjectsdef.py | 16 +++++++--------- rope/base/stdmods.py | 8 ++++---- rope/base/{utils.py => utils/__init__.py} | 0 rope/{comp.py => base/utils/pycompat.py} | 0 rope/refactor/extract.py | 12 ++++++------ rope/refactor/patchedast.py | 16 ++++++++-------- rope/refactor/suites.py | 8 ++++---- ropetest/advanced_oi_test.py | 6 +++--- ropetest/refactor/patchedasttest.py | 18 +++++++++--------- 13 files changed, 60 insertions(+), 61 deletions(-) rename rope/base/{utils.py => utils/__init__.py} (100%) rename rope/{comp.py => base/utils/pycompat.py} (100%) diff --git a/rope/base/builtins.py b/rope/base/builtins.py index 7b2b20969..70d024aed 100644 --- a/rope/base/builtins.py +++ b/rope/base/builtins.py @@ -6,8 +6,8 @@ raw_input = input import rope.base.evaluate -from rope import comp -from rope.base import pynames, pyobjects, arguments, utils, ast +from rope.base.utils import pycompat +from rope.base import pynames, pyobjects, arguments, utils class BuiltinModule(pyobjects.AbstractModule): @@ -657,12 +657,12 @@ def get_name(self): return 'lambda' def get_param_names(self, special_args=True): - result = [comp.get_ast_arg_arg(node) for node in self.arguments.args - if isinstance(node, comp.ast_arg_type)] + result = [pycompat.get_ast_arg_arg(node) for node in self.arguments.args + if isinstance(node, pycompat.ast_arg_type)] if self.arguments.vararg: - result.append('*' + comp.get_ast_arg_arg(self.arguments.vararg)) + result.append('*' + pycompat.get_ast_arg_arg(self.arguments.vararg)) if self.arguments.kwarg: - result.append('**' + comp.get_ast_arg_arg(self.arguments.kwarg)) + result.append('**' + pycompat.get_ast_arg_arg(self.arguments.kwarg)) return result @property @@ -802,4 +802,4 @@ def _input_function(args): builtin=raw_input)), } -builtins = BuiltinModule(comp.builtins.__name__, initial=_initial_builtins) +builtins = BuiltinModule(pycompat.builtins.__name__, initial=_initial_builtins) diff --git a/rope/base/fscommands.py b/rope/base/fscommands.py index 5b6c810f0..3564ed919 100644 --- a/rope/base/fscommands.py +++ b/rope/base/fscommands.py @@ -9,7 +9,8 @@ import os import shutil import subprocess -import rope.comp as comp + +import rope.base.utils.pycompat as pycompat try: unicode @@ -262,10 +263,10 @@ def read_str_coding(source): def _find_coding(text): - if isinstance(text, comp.str): + if isinstance(text, pycompat.str): text = text.encode('utf-8') coding = b'coding' - to_chr = chr if comp.PY3 else lambda x: x + to_chr = chr if pycompat.PY3 else lambda x: x try: start = text.index(coding) + len(coding) if text[start] not in b'=:': diff --git a/rope/base/oi/runmod.py b/rope/base/oi/runmod.py index 6eb6cf893..07cbe4950 100644 --- a/rope/base/oi/runmod.py +++ b/rope/base/oi/runmod.py @@ -12,7 +12,7 @@ def __rope_start_everything(): import inspect import types import threading - import rope.comp as comp + import rope.base.utils.pycompat as pycompat class _MessageSender(object): @@ -130,7 +130,7 @@ def _get_persisted_class(self, object_): return ('unknown',) def _get_persisted_builtin(self, object_): - if isinstance(object_, comp.string_types): + if isinstance(object_, pycompat.string_types): return ('builtin', 'str') if isinstance(object_, list): holding = None @@ -176,7 +176,7 @@ def _object_to_persisted_form(self, object_): return self._get_persisted_code(object_.__func__.__code__) if isinstance(object_, types.ModuleType): return self._get_persisted_module(object_) - if isinstance(object_, comp.string_types + (list, dict, tuple, set)): + if isinstance(object_, pycompat.string_types + (list, dict, tuple, set)): return self._get_persisted_builtin(object_) if isinstance(object_, type): return self._get_persisted_class(object_) @@ -212,7 +212,7 @@ def _realpath(path): if send_info != '-': data_sender = _FunctionCallDataSender(send_info, project_root) del sys.argv[1:4] - comp.execfile(file_to_run, run_globals) + pycompat.execfile(file_to_run, run_globals) if send_info != '-': data_sender.close() diff --git a/rope/base/project.py b/rope/base/project.py index c8c5a462e..2feef36c6 100644 --- a/rope/base/project.py +++ b/rope/base/project.py @@ -4,11 +4,11 @@ import warnings import rope.base.fscommands -import rope.comp as comp -from rope.base import exceptions, taskhandle, prefs, history, pycore, utils import rope.base.resourceobserver as resourceobserver -from rope.base.resources import File, Folder, _ResourceMatcher +import rope.base.utils.pycompat as pycompat +from rope.base import exceptions, taskhandle, prefs, history, pycore, utils from rope.base.exceptions import ModuleNotFoundError +from rope.base.resources import File, Folder, _ResourceMatcher try: import pickle @@ -262,7 +262,7 @@ def _init_prefs(self, prefs): '__file__': config.real_path}) if config.exists(): config = self.ropefolder.get_child('config.py') - comp.execfile(config.real_path, run_globals) + pycompat.execfile(config.real_path, run_globals) else: exec(self._default_config(), run_globals) if 'set_prefs' in run_globals: diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index b48bde25c..fd0bc4b73 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -1,14 +1,12 @@ +import rope.base.builtins import rope.base.codeanalyze import rope.base.evaluate -import rope.base.builtins +import rope.base.libutils import rope.base.oi.soi import rope.base.pyscopes -import rope.base.libutils from rope.base import (pynamesdef as pynames, exceptions, ast, astutils, pyobjects, fscommands, arguments, utils) - -from rope import comp - +from rope.base.utils import pycompat try: unicode @@ -87,9 +85,9 @@ def get_param_names(self, special_args=True): if isinstance(node, ast.Name)] if special_args: if self.arguments.vararg: - result.append(comp.get_ast_arg_arg(self.arguments.vararg)) + result.append(pycompat.get_ast_arg_arg(self.arguments.vararg)) if self.arguments.kwarg: - result.append(comp.get_ast_arg_arg(self.arguments.kwarg)) + result.append(pycompat.get_ast_arg_arg(self.arguments.kwarg)) return result def get_kind(self): @@ -390,7 +388,7 @@ def _update_evaluated(self, targets, assigned, return result def _With(self, node): - withitem = comp.get_ast_with(node) + withitem = pycompat.get_ast_with(node) if withitem.optional_vars: self._update_evaluated(withitem.optional_vars, withitem.context_expr, '.__enter__()') @@ -404,7 +402,7 @@ def _excepthandler(self, node): type_node = type_node.elts[0] self._update_evaluated(node.name, type_node, eval_type=True) - if comp.PY27: + if pycompat.PY27: # handles case for syntax MyError as e if node.name is not None and isinstance(node.type, ast.Name): self._update_evaluated(node, node.type, eval_type=True) diff --git a/rope/base/stdmods.py b/rope/base/stdmods.py index f6eae8738..683f72ebb 100644 --- a/rope/base/stdmods.py +++ b/rope/base/stdmods.py @@ -1,17 +1,17 @@ -import re import os +import re import sys from rope.base import utils -from rope import comp +from rope.base.utils import pycompat def _stdlib_path(): - if comp.PY2: + if pycompat.PY2: from distutils import sysconfig return sysconfig.get_python_lib(standard_lib=True, plat_specific=True) - elif comp.PY3: + elif pycompat.PY3: import sysconfig return sysconfig.get_config_var('LIBDIR') + os.sep + 'python' + '.'.join(map(str, sys.version_info[0:2])) diff --git a/rope/base/utils.py b/rope/base/utils/__init__.py similarity index 100% rename from rope/base/utils.py rename to rope/base/utils/__init__.py diff --git a/rope/comp.py b/rope/base/utils/pycompat.py similarity index 100% rename from rope/comp.py rename to rope/base/utils/pycompat.py diff --git a/rope/refactor/extract.py b/rope/refactor/extract.py index 3074d28bd..35e4a9e36 100644 --- a/rope/refactor/extract.py +++ b/rope/refactor/extract.py @@ -1,12 +1,12 @@ import re +from rope.abc import OrderedSet from rope.base import ast, codeanalyze from rope.base.change import ChangeSet, ChangeContents from rope.base.exceptions import RefactoringError +from rope.base.utils import pycompat from rope.refactor import (sourceutils, similarfinder, patchedast, suites, usefunction) -from rope import comp -from rope.abc import OrderedSet # Extract refactoring has lots of special cases. I tried to split it @@ -688,12 +688,12 @@ def _For(self, node): def _get_argnames(arguments): - result = [comp.get_ast_arg_arg(node) for node in arguments.args - if isinstance(node, comp.ast_arg_type)] + result = [pycompat.get_ast_arg_arg(node) for node in arguments.args + if isinstance(node, pycompat.ast_arg_type)] if arguments.vararg: - result.append(comp.get_ast_arg_arg(arguments.vararg)) + result.append(pycompat.get_ast_arg_arg(arguments.vararg)) if arguments.kwarg: - result.append(comp.get_ast_arg_arg(arguments.kwarg)) + result.append(pycompat.get_ast_arg_arg(arguments.kwarg)) return result diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 3a91ac1ec..84e1870a3 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -3,7 +3,7 @@ import warnings from rope.base import ast, codeanalyze, exceptions -from rope import comp +from rope.base.utils import pycompat try: basestring @@ -402,11 +402,11 @@ def _arguments(self, node): if node.vararg is not None: if args: children.append(',') - children.extend(['*', comp.get_ast_arg_arg(node.vararg)]) + children.extend(['*', pycompat.get_ast_arg_arg(node.vararg)]) if node.kwarg is not None: if args or node.vararg is not None: children.append(',') - children.extend(['**', comp.get_ast_arg_arg(node.kwarg)]) + children.extend(['**', pycompat.get_ast_arg_arg(node.kwarg)]) self._handle(node, children) def _add_args_to_children(self, children, arg, default): @@ -565,7 +565,7 @@ def get_python2_raise_children(node): children.append(',') children.append(node.tback) return children - if comp.PY2: + if pycompat.PY2: children = get_python2_raise_children(node) else: children = get_python3_raise_children(node) @@ -609,10 +609,10 @@ def _TryFinally(self, node): is_there_except_handler = False not_empty_body = True if len(node.finalbody) == 1: - if comp.PY2: + if pycompat.PY2: is_there_except_handler = isinstance(node.body[0], ast.TryExcept) not_empty_body = not bool(len(node.body)) - elif comp.PY3: + elif pycompat.PY3: try: is_there_except_handler = isinstance(node.handlers[0], ast.ExceptHandler) not_empty_body = True @@ -622,7 +622,7 @@ def _TryFinally(self, node): if not_empty_body or not is_there_except_handler: children.extend(['try', ':']) children.extend(node.body) - if comp.PY3: + if pycompat.PY3: children.extend(node.handlers) children.extend(['finally', ':']) children.extend(node.finalbody) @@ -686,7 +686,7 @@ def _While(self, node): self._handle(node, children) def _With(self, node): - withitem = comp.get_ast_with(node) + withitem = pycompat.get_ast_with(node) children = ['with', withitem.context_expr] if withitem.optional_vars: children.extend(['as', withitem.optional_vars]) diff --git a/rope/refactor/suites.py b/rope/refactor/suites.py index dc25c59fa..687850808 100644 --- a/rope/refactor/suites.py +++ b/rope/refactor/suites.py @@ -1,5 +1,5 @@ from rope.base import ast -from rope import comp +from rope.base.utils import pycompat def find_visible(node, lines): @@ -118,15 +118,15 @@ def _With(self, node): def _TryFinally(self, node): proceed_to_except_handler = False if len(node.finalbody) == 1: - if comp.PY2: + if pycompat.PY2: proceed_to_except_handler = isinstance(node.body[0], ast.TryExcept) - elif comp.PY3: + elif pycompat.PY3: try: proceed_to_except_handler = isinstance(node.handlers[0], ast.ExceptHandler) except IndexError: pass if proceed_to_except_handler: - self._TryExcept(node if comp.PY3 else node.body[0]) + self._TryExcept(node if pycompat.PY3 else node.body[0]) else: self.suites.append(Suite(node.body, node.lineno, self.suite)) self.suites.append(Suite(node.finalbody, node.lineno, self.suite)) diff --git a/ropetest/advanced_oi_test.py b/ropetest/advanced_oi_test.py index c530c0c48..9003eed84 100644 --- a/ropetest/advanced_oi_test.py +++ b/ropetest/advanced_oi_test.py @@ -3,10 +3,10 @@ except ImportError: import unittest -import rope.base.oi import rope.base.libutils +import rope.base.oi +from rope.base.utils import pycompat from ropetest import testutils -from rope import comp class DynamicOITest(unittest.TestCase): @@ -183,7 +183,7 @@ def test_dict_objects_and_dynamicoi(self): def test_dict_keys_and_dynamicoi(self): mod = testutils.create_module(self.project, 'mod') - if comp.PY3: + if pycompat.PY3: code = 'class C(object):\n pass\n' \ 'def a_func(arg):\n return eval("arg")\n' \ 'a_var = list(a_func({C(): 1}))[0]\n' diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index 1403f877d..9f9097d7d 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -1,7 +1,7 @@ import unittest -from rope import comp from rope.base import ast +from rope.base.utils import pycompat from rope.refactor import patchedast from ropetest import testutils @@ -374,7 +374,7 @@ def test_function_node2(self): 'Function', ['def', ' ', 'f', '', '(', '', 'arguments', '', ')', '', ':', '\n ', 'Expr', '\n ', 'Pass']) - expected_arg_name = comp.ast_arg_type.__name__ + expected_arg_name = pycompat.ast_arg_type.__name__ checker.check_children( 'arguments', [expected_arg_name, '', ',', ' ', '**', '', 'p2']) @@ -550,7 +550,7 @@ def test_lambda_node(self): checker.check_region('Lambda', 0, len(source) - 1) checker.check_children( 'Lambda', ['lambda', ' ', 'arguments', '', ':', ' ', 'Name']) - expected_arg_name = comp.ast_arg_type.__name__ + expected_arg_name = pycompat.ast_arg_type.__name__ checker.check_children( 'arguments', [expected_arg_name, '', ',', ' ', expected_arg_name, '', '=', '', 'Num', '', ',', ' ', '*', '', 'z']) @@ -793,8 +793,8 @@ def test_try_finally_node(self): source = 'try:\n pass\nfinally:\n pass\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) - node_to_test = 'Try' if comp.PY3 else 'TryFinally' - if comp.PY3: + node_to_test = 'Try' if pycompat.PY3 else 'TryFinally' + if pycompat.PY3: expected_children = ['try', '', ':', '\n ', 'Pass', '\n', 'finally', '', ':', '\n ', 'Pass'] else: @@ -819,8 +819,8 @@ def test_try_except_node__with_as_syntax(self): source = 'try:\n pass\nexcept Exception as e:\n pass\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) - node_to_test = 'Try' if comp.PY3 else 'TryExcept' - is_catched_exception_ast_type = comp.PY2 + node_to_test = 'Try' if pycompat.PY3 else 'TryExcept' + is_catched_exception_ast_type = pycompat.PY2 checker.check_children( node_to_test, ['try', '', ':', '\n ', 'Pass', '\n', ('excepthandler', 'ExceptHandler')]) @@ -834,8 +834,8 @@ def test_try_except_and_finally_node(self): source = 'try:\n pass\nexcept:\n pass\nfinally:\n pass\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) - node_to_test = 'Try' if comp.PY3 else 'TryFinally' - if comp.PY3: + node_to_test = 'Try' if pycompat.PY3 else 'TryFinally' + if pycompat.PY3: expected_children = ['try', '', ':', '\n ', 'Pass', '\n', 'ExceptHandler', '\n', 'finally', '', ':', '\n ', 'Pass'] else: From bc8f684824b4d6b2d04396cc945447fd428bf2e6 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Thu, 4 Feb 2016 23:58:58 +0100 Subject: [PATCH 62/92] minor fix for python3 --- rope/base/utils/pycompat.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/rope/base/utils/pycompat.py b/rope/base/utils/pycompat.py index ff748d30d..de271d431 100644 --- a/rope/base/utils/pycompat.py +++ b/rope/base/utils/pycompat.py @@ -23,6 +23,8 @@ def execfile(fn, global_vars=None, local_vars=None): exec(code, global_vars or {}, local_vars) def get_ast_arg_arg(node): + if isinstance(node, string_types): + return node return node.arg From 9c6834012363d9e4f4d2845b6baf4db8d12a981a Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Fri, 5 Feb 2016 06:03:28 +0100 Subject: [PATCH 63/92] Revert "minor fix for python3" This reverts commit bc8f684824b4d6b2d04396cc945447fd428bf2e6. --- rope/base/utils/pycompat.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/rope/base/utils/pycompat.py b/rope/base/utils/pycompat.py index de271d431..ff748d30d 100644 --- a/rope/base/utils/pycompat.py +++ b/rope/base/utils/pycompat.py @@ -23,8 +23,6 @@ def execfile(fn, global_vars=None, local_vars=None): exec(code, global_vars or {}, local_vars) def get_ast_arg_arg(node): - if isinstance(node, string_types): - return node return node.arg From 3b3f2ac017d249c64c0b47b50c2e0ce61f042e62 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 7 Feb 2016 19:58:00 +0100 Subject: [PATCH 64/92] fixed problem with __getslice__ in rope --- rope/base/builtins.py | 11 +++++++++-- rope/base/evaluate.py | 3 ++- rope/base/oi/memorydb.py | 1 - rope/base/utils/pycompat.py | 2 ++ 4 files changed, 13 insertions(+), 4 deletions(-) diff --git a/rope/base/builtins.py b/rope/base/builtins.py index 70d024aed..63e19b15f 100644 --- a/rope/base/builtins.py +++ b/rope/base/builtins.py @@ -226,6 +226,9 @@ def save_per_name(self, value): pymodule = pyname.get_definition_location()[0] pymodule.pycore.object_info.save_per_name(scope, name, value) + def get_arguments_number(self): + return len(self.args.args) + class _AttributeCollector(object): @@ -269,7 +272,7 @@ def __init__(self, holding=None): argnames=['self', 'iterable']) # Getting methods - collector('__getitem__', function=self._list_get) + collector('__getitem__', function=self._self_get if pycompat.PY3 else self._list_get) collector('pop', function=self._list_get) try: collector('__getslice__', function=self._self_get) @@ -305,7 +308,11 @@ def _iterator_get(self, context): return get_iterator(self._list_get(context)) def _self_get(self, context): - return get_list(self._list_get(context)) + # @todo - refactor, not sure how to implement it properly + if context.get_arguments_number() > 1: + return self._list_get(context) + else: + return get_list(self._list_get(context)) get_list = _create_builtin_getter(List) diff --git a/rope/base/evaluate.py b/rope/base/evaluate.py index faf094075..1032d9d68 100644 --- a/rope/base/evaluate.py +++ b/rope/base/evaluate.py @@ -2,6 +2,7 @@ import rope.base.pynames import rope.base.pyobjects from rope.base import ast, astutils, exceptions, pyobjects, arguments, worder +from rope.base.utils import pycompat BadIdentifierError = exceptions.BadIdentifierError @@ -290,7 +291,7 @@ def _Subscript(self, node): self._call_function(node.value, '__getitem__', [node.slice.value]) elif isinstance(node.slice, ast.Slice): - self._call_function(node.value, '__getslice__') + self._call_function(node.value, '__getitem__' if pycompat.PY3 else '__getslice__') def _call_function(self, node, function_name, other_args=None): pyname = eval_node(self.scope, node) diff --git a/rope/base/oi/memorydb.py b/rope/base/oi/memorydb.py index 01c814ce4..808e33d82 100644 --- a/rope/base/oi/memorydb.py +++ b/rope/base/oi/memorydb.py @@ -97,7 +97,6 @@ def __setitem__(self): raise NotImplementedError() - class ScopeInfo(objectdb.ScopeInfo): def __init__(self): diff --git a/rope/base/utils/pycompat.py b/rope/base/utils/pycompat.py index ff748d30d..de271d431 100644 --- a/rope/base/utils/pycompat.py +++ b/rope/base/utils/pycompat.py @@ -23,6 +23,8 @@ def execfile(fn, global_vars=None, local_vars=None): exec(code, global_vars or {}, local_vars) def get_ast_arg_arg(node): + if isinstance(node, string_types): + return node return node.arg From ba72727aa89991643d42dff578dceb62916fd195 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Fri, 12 Feb 2016 02:40:18 +0100 Subject: [PATCH 65/92] fixed issue with doubled __locals__ in Class declaration --- 2 | 20 ++++++++++++++++++++ error.log | 5 +++++ error2.log | 5 +++++ rope/base/oi/runmod.py | 9 +++++---- test1.py | 6 ++++++ 5 files changed, 41 insertions(+), 4 deletions(-) create mode 100644 2 create mode 100644 error.log create mode 100644 error2.log create mode 100644 test1.py diff --git a/2 b/2 new file mode 100644 index 000000000..b40916af8 --- /dev/null +++ b/2 @@ -0,0 +1,20 @@ +Traceback (most recent call last): + File "/usr/lib64/python3.3/runpy.py", line 160, in _run_module_as_main + "__main__", fname, loader, pkg_name) + File "/usr/lib64/python3.3/runpy.py", line 73, in _run_code + exec(code, run_globals) + File "/usr/lib64/python3.3/unittest/__main__.py", line 19, in + main(module=None) + File "/usr/lib64/python3.3/unittest/main.py", line 124, in __init__ + self.parseArgs(argv) + File "/usr/lib64/python3.3/unittest/main.py", line 168, in parseArgs + self.createTests() + File "/usr/lib64/python3.3/unittest/main.py", line 175, in createTests + self.module) + File "/usr/lib64/python3.3/unittest/loader.py", line 137, in loadTestsFromNames + suites = [self.loadTestsFromName(name, module) for name in names] + File "/usr/lib64/python3.3/unittest/loader.py", line 137, in + suites = [self.loadTestsFromName(name, module) for name in names] + File "/usr/lib64/python3.3/unittest/loader.py", line 96, in loadTestsFromName + module = __import__('.'.join(parts_copy)) +ImportError: No module named '1' diff --git a/error.log b/error.log new file mode 100644 index 000000000..dcf4515ea --- /dev/null +++ b/error.log @@ -0,0 +1,5 @@ +. +---------------------------------------------------------------------- +Ran 1 test in 0.172s + +OK diff --git a/error2.log b/error2.log new file mode 100644 index 000000000..4ea56342e --- /dev/null +++ b/error2.log @@ -0,0 +1,5 @@ +. +---------------------------------------------------------------------- +Ran 1 test in 0.143s + +OK diff --git a/rope/base/oi/runmod.py b/rope/base/oi/runmod.py index 07cbe4950..1daa5e2fa 100644 --- a/rope/base/oi/runmod.py +++ b/rope/base/oi/runmod.py @@ -81,8 +81,9 @@ def on_function_call(self, frame, event, arg): code = frame.f_code for argname in code.co_varnames[:code.co_argcount]: try: - args.append(self._object_to_persisted_form( - frame.f_locals[argname])) + argvalue = self._object_to_persisted_form( + frame.f_locals[argname]) + args.append(argvalue) except (TypeError, AttributeError): args.append(('unknown',)) try: @@ -102,7 +103,6 @@ def _is_an_interesting_call(self, frame): # return False #return not frame.f_back or # not self._is_code_inside_project(frame.f_back.f_code) - if not self._is_code_inside_project(frame.f_code) and \ (not frame.f_back or not self._is_code_inside_project(frame.f_back.f_code)): @@ -142,7 +142,7 @@ def _get_persisted_builtin(self, object_): keys = None values = None if len(object_) > 0: - keys = list(object_.keys())[0] + keys = [key for key in object_.keys() if key != '__locals__'][0] values = object_[keys] return ('builtin', 'dict', self._object_to_persisted_form(keys), @@ -209,6 +209,7 @@ def _realpath(path): run_globals.update({'__name__': '__main__', '__builtins__': __builtins__, '__file__': file_to_run}) + if send_info != '-': data_sender = _FunctionCallDataSender(send_info, project_root) del sys.argv[1:4] diff --git a/test1.py b/test1.py new file mode 100644 index 000000000..c9d476fbe --- /dev/null +++ b/test1.py @@ -0,0 +1,6 @@ +class AClass(object): + pass +def a_func(arg): + return eval("arg()") +a_var = a_func(AClass) +print(a_var) From 9363b23d8c8eed858a1b6edd1316076a9c857057 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Fri, 12 Feb 2016 02:40:41 +0100 Subject: [PATCH 66/92] fixed issue with doubled __locals__ in Class declaration --- 2 | 20 -------------------- error.log | 5 ----- error2.log | 5 ----- test1.py | 6 ------ 4 files changed, 36 deletions(-) delete mode 100644 2 delete mode 100644 error.log delete mode 100644 error2.log delete mode 100644 test1.py diff --git a/2 b/2 deleted file mode 100644 index b40916af8..000000000 --- a/2 +++ /dev/null @@ -1,20 +0,0 @@ -Traceback (most recent call last): - File "/usr/lib64/python3.3/runpy.py", line 160, in _run_module_as_main - "__main__", fname, loader, pkg_name) - File "/usr/lib64/python3.3/runpy.py", line 73, in _run_code - exec(code, run_globals) - File "/usr/lib64/python3.3/unittest/__main__.py", line 19, in - main(module=None) - File "/usr/lib64/python3.3/unittest/main.py", line 124, in __init__ - self.parseArgs(argv) - File "/usr/lib64/python3.3/unittest/main.py", line 168, in parseArgs - self.createTests() - File "/usr/lib64/python3.3/unittest/main.py", line 175, in createTests - self.module) - File "/usr/lib64/python3.3/unittest/loader.py", line 137, in loadTestsFromNames - suites = [self.loadTestsFromName(name, module) for name in names] - File "/usr/lib64/python3.3/unittest/loader.py", line 137, in - suites = [self.loadTestsFromName(name, module) for name in names] - File "/usr/lib64/python3.3/unittest/loader.py", line 96, in loadTestsFromName - module = __import__('.'.join(parts_copy)) -ImportError: No module named '1' diff --git a/error.log b/error.log deleted file mode 100644 index dcf4515ea..000000000 --- a/error.log +++ /dev/null @@ -1,5 +0,0 @@ -. ----------------------------------------------------------------------- -Ran 1 test in 0.172s - -OK diff --git a/error2.log b/error2.log deleted file mode 100644 index 4ea56342e..000000000 --- a/error2.log +++ /dev/null @@ -1,5 +0,0 @@ -. ----------------------------------------------------------------------- -Ran 1 test in 0.143s - -OK diff --git a/test1.py b/test1.py deleted file mode 100644 index c9d476fbe..000000000 --- a/test1.py +++ /dev/null @@ -1,6 +0,0 @@ -class AClass(object): - pass -def a_func(arg): - return eval("arg()") -a_var = a_func(AClass) -print(a_var) From d6b7690e003d2c24587d70334b9b94c2a3613762 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Fri, 12 Feb 2016 03:22:04 +0100 Subject: [PATCH 67/92] fixed issue with evaluating excepthandler --- rope/base/pyobjectsdef.py | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index fd0bc4b73..1d40ac6b7 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -380,11 +380,16 @@ def _assigned(self, name, assignment): def _update_evaluated(self, targets, assigned, evaluation='', eval_type=False): result = {} - names = astutils.get_name_levels(targets) - for name, levels in names: - assignment = pynames.AssignmentValue(assigned, levels, + if isinstance(targets, str): + assignment = pynames.AssignmentValue(assigned, [], evaluation, eval_type) - self._assigned(name, assignment) + self._assigned(targets, assignment) + else: + names = astutils.get_name_levels(targets) + for name, levels in names: + assignment = pynames.AssignmentValue(assigned, levels, + evaluation, eval_type) + self._assigned(name, assignment) return result def _With(self, node): @@ -396,18 +401,13 @@ def _With(self, node): ast.walk(child, self) def _excepthandler(self, node): - if node.name is not None and isinstance(node.name, ast.Name): + node_name_type = str if pycompat.PY3 else ast.Name + if node.name is not None and isinstance(node.name, node_name_type): type_node = node.type if isinstance(node.type, ast.Tuple) and type_node.elts: type_node = type_node.elts[0] self._update_evaluated(node.name, type_node, eval_type=True) - if pycompat.PY27: - # handles case for syntax MyError as e - if node.name is not None and isinstance(node.type, ast.Name): - self._update_evaluated(node, node.type, eval_type=True) - if node.name is not None and isinstance(node.type, ast.Tuple): - self._update_evaluated(node, node, eval_type=True) for child in node.body: ast.walk(child, self) From 6ce97ccaa9f1c01d0ca09a2fd90d5903ed8f6f05 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Fri, 12 Feb 2016 03:28:30 +0100 Subject: [PATCH 68/92] moved ordered_set to datastructures --- rope/abc/__init__.py | 3 --- rope/{abc/_ordered_set.py => base/utils/datastructures.py} | 0 rope/refactor/extract.py | 2 +- 3 files changed, 1 insertion(+), 4 deletions(-) delete mode 100644 rope/abc/__init__.py rename rope/{abc/_ordered_set.py => base/utils/datastructures.py} (100%) diff --git a/rope/abc/__init__.py b/rope/abc/__init__.py deleted file mode 100644 index e5aeb846d..000000000 --- a/rope/abc/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -__all__ = ['OrderedSet'] - -from ._ordered_set import OrderedSet diff --git a/rope/abc/_ordered_set.py b/rope/base/utils/datastructures.py similarity index 100% rename from rope/abc/_ordered_set.py rename to rope/base/utils/datastructures.py diff --git a/rope/refactor/extract.py b/rope/refactor/extract.py index 35e4a9e36..be5753099 100644 --- a/rope/refactor/extract.py +++ b/rope/refactor/extract.py @@ -1,6 +1,6 @@ import re -from rope.abc import OrderedSet +from rope.base.utils.datastructures import OrderedSet from rope.base import ast, codeanalyze from rope.base.change import ChangeSet, ChangeContents from rope.base.exceptions import RefactoringError From 969da2d83d7eab45a6ceefcf79cf8fcfd1448352 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sun, 14 Feb 2016 00:08:58 +0200 Subject: [PATCH 69/92] self.assertEquals() -> self.assertEqual() --- ropetest/advanced_oi_test.py | 132 +++++----- ropetest/builtinstest.py | 104 ++++---- ropetest/codeanalyzetest.py | 190 +++++++-------- ropetest/contrib/autoimporttest.py | 50 ++-- ropetest/contrib/changestacktest.py | 8 +- ropetest/contrib/codeassisttest.py | 80 +++--- ropetest/contrib/finderrorstest.py | 16 +- ropetest/contrib/findittest.py | 38 +-- ropetest/contrib/fixmodnamestest.py | 4 +- ropetest/contrib/generatetest.py | 60 ++--- ropetest/historytest.py | 80 +++--- ropetest/objectdbtest.py | 38 +-- ropetest/objectinfertest.py | 68 +++--- ropetest/projecttest.py | 210 ++++++++-------- ropetest/pycoretest.py | 156 ++++++------ ropetest/pyscopestest.py | 48 ++-- ropetest/refactor/__init__.py | 128 +++++----- ropetest/refactor/change_signature_test.py | 82 +++---- ropetest/refactor/extracttest.py | 154 ++++++------ ropetest/refactor/importutilstest.py | 268 ++++++++++----------- ropetest/refactor/inlinetest.py | 150 ++++++------ ropetest/refactor/movetest.py | 106 ++++---- ropetest/refactor/multiprojecttest.py | 16 +- ropetest/refactor/renametest.py | 172 ++++++------- ropetest/refactor/restructuretest.py | 48 ++-- ropetest/refactor/similarfindertest.py | 82 +++---- ropetest/refactor/suitestest.py | 80 +++--- ropetest/refactor/usefunctiontest.py | 18 +- ropetest/runmodtest.py | 14 +- ropetest/simplifytest.py | 24 +- 30 files changed, 1312 insertions(+), 1312 deletions(-) diff --git a/ropetest/advanced_oi_test.py b/ropetest/advanced_oi_test.py index 9003eed84..838e6988c 100644 --- a/ropetest/advanced_oi_test.py +++ b/ropetest/advanced_oi_test.py @@ -27,7 +27,7 @@ def test_simple_dti(self): mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) - self.assertEquals(pymod['a_func'].get_object(), + self.assertEqual(pymod['a_func'].get_object(), pymod['a_var'].get_object()) def test_module_dti(self): @@ -38,7 +38,7 @@ def test_module_dti(self): mod2.write(code) self.pycore.run_module(mod2).wait_process() pymod2 = self.project.get_pymodule(mod2) - self.assertEquals(self.project.get_pymodule(mod1), + self.assertEqual(self.project.get_pymodule(mod1), pymod2['a_var'].get_object()) def test_class_from_another_module_dti(self): @@ -53,7 +53,7 @@ def test_class_from_another_module_dti(self): self.pycore.run_module(mod2).wait_process() #pymod1 = self.project.get_pymodule(mod1) pymod2 = self.project.get_pymodule(mod2) - self.assertEquals(pymod2['AClass'].get_object(), + self.assertEqual(pymod2['AClass'].get_object(), pymod2['a_var'].get_object()) def test_class_dti(self): @@ -64,7 +64,7 @@ def test_class_dti(self): mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) - self.assertEquals(pymod['AClass'].get_object(), + self.assertEqual(pymod['AClass'].get_object(), pymod['a_var'].get_object()) def test_instance_dti(self): @@ -75,7 +75,7 @@ def test_instance_dti(self): mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) - self.assertEquals(pymod['AClass'].get_object(), + self.assertEqual(pymod['AClass'].get_object(), pymod['a_var'].get_object().get_type()) def test_method_dti(self): @@ -87,7 +87,7 @@ def test_method_dti(self): mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) - self.assertEquals(pymod['AClass'].get_object(), + self.assertEqual(pymod['AClass'].get_object(), pymod['a_var'].get_object().get_type()) def test_function_argument_dti(self): @@ -97,7 +97,7 @@ def test_function_argument_dti(self): mod.write(code) self.pycore.run_module(mod).wait_process() pyscope = self.project.get_pymodule(mod).get_scope() - self.assertEquals(pyscope['a_func'].get_object(), + self.assertEqual(pyscope['a_func'].get_object(), pyscope.get_scopes()[0]['arg'].get_object()) def test_classes_with_the_same_name(self): @@ -109,7 +109,7 @@ def test_classes_with_the_same_name(self): mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) - self.assertEquals(pymod['AClass'].get_object(), + self.assertEqual(pymod['AClass'].get_object(), pymod['a_var'].get_object()) def test_nested_classes(self): @@ -121,7 +121,7 @@ def test_nested_classes(self): mod.write(code) self.pycore.run_module(mod).wait_process() pyscope = self.project.get_pymodule(mod).get_scope() - self.assertEquals(pyscope.get_scopes()[0]['AClass'].get_object(), + self.assertEqual(pyscope.get_scopes()[0]['AClass'].get_object(), pyscope['a_var'].get_object()) def test_function_argument_dti2(self): @@ -131,7 +131,7 @@ def test_function_argument_dti2(self): mod.write(code) self.pycore.run_module(mod).wait_process() pyscope = self.project.get_pymodule(mod).get_scope() - self.assertEquals(pyscope['a_func'].get_object(), + self.assertEqual(pyscope['a_func'].get_object(), pyscope.get_scopes()[0]['arg'].get_object()) def test_dti_and_concluded_data_invalidation(self): @@ -142,7 +142,7 @@ def test_dti_and_concluded_data_invalidation(self): pymod = self.project.get_pymodule(mod) pymod['a_var'].get_object() self.pycore.run_module(mod).wait_process() - self.assertEquals(pymod['a_func'].get_object(), + self.assertEqual(pymod['a_func'].get_object(), pymod['a_var'].get_object()) def test_list_objects_and_dynamicoi(self): @@ -155,7 +155,7 @@ def test_list_objects_and_dynamicoi(self): pymod = self.project.get_pymodule(mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_for_loops_and_dynamicoi(self): mod = testutils.create_module(self.project, 'mod') @@ -167,7 +167,7 @@ def test_for_loops_and_dynamicoi(self): pymod = self.project.get_pymodule(mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_dict_objects_and_dynamicoi(self): mod = testutils.create_module(self.project, 'mod') @@ -179,7 +179,7 @@ def test_dict_objects_and_dynamicoi(self): pymod = self.project.get_pymodule(mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_dict_keys_and_dynamicoi(self): mod = testutils.create_module(self.project, 'mod') @@ -196,7 +196,7 @@ def test_dict_keys_and_dynamicoi(self): pymod = self.project.get_pymodule(mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_dict_keys_and_dynamicoi2(self): mod = testutils.create_module(self.project, 'mod') @@ -210,8 +210,8 @@ def test_dict_keys_and_dynamicoi2(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_strs_and_dynamicoi(self): mod = testutils.create_module(self.project, 'mod') @@ -238,12 +238,12 @@ def complex_to_textual(pyobject): to_pyobject.transform(to_textual.transform(pyobject))) for name in ('C', 'f', 'a_var', 'a_list', 'a_str', 'a_file'): var = pymod[name].get_object() - self.assertEquals(to_textual.transform(var), + self.assertEqual(to_textual.transform(var), complex_to_textual(var)) - self.assertEquals(to_textual.transform(pymod), + self.assertEqual(to_textual.transform(pymod), complex_to_textual(pymod)) enumerate_func = rope.base.builtins.builtins['enumerate'].get_object() - self.assertEquals(to_textual.transform(enumerate_func), + self.assertEqual(to_textual.transform(enumerate_func), complex_to_textual(enumerate_func)) def test_arguments_with_keywords(self): @@ -258,8 +258,8 @@ def test_arguments_with_keywords(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_a_function_with_different_returns(self): mod = testutils.create_module(self.project, 'mod') @@ -273,8 +273,8 @@ def test_a_function_with_different_returns(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_a_function_with_different_returns2(self): mod = testutils.create_module(self.project, 'mod') @@ -289,8 +289,8 @@ def test_a_function_with_different_returns2(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_ignoring_star_args(self): mod = testutils.create_module(self.project, 'mod') @@ -306,8 +306,8 @@ def test_ignoring_star_args(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_ignoring_double_star_args(self): mod = testutils.create_module(self.project, 'mod') @@ -323,8 +323,8 @@ def test_ignoring_double_star_args(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_invalidating_data_after_changing(self): mod = testutils.create_module(self.project, 'mod') @@ -349,7 +349,7 @@ def test_invalidating_data_after_moving(self): mod.move('newmod.py') pymod = self.project.get_module('newmod') pymod2 = self.project.get_pymodule(mod2) - self.assertEquals(pymod2['C'].get_object(), + self.assertEqual(pymod2['C'].get_object(), pymod['a_var'].get_object()) @@ -373,7 +373,7 @@ def test_static_oi_for_simple_function_calls(self): c_class = pymod['C'].get_object() f_scope = pymod['f'].get_object().get_scope() p_type = f_scope['p'].get_object().get_type() - self.assertEquals(c_class, p_type) + self.assertEqual(c_class, p_type) def test_static_oi_not_failing_when_callin_callables(self): code = 'class C(object):\n pass\nC()\n' @@ -389,7 +389,7 @@ def test_static_oi_for_nested_calls(self): c_class = pymod['C'].get_object() f_scope = pymod['f'].get_object().get_scope() p_type = f_scope['p'].get_object().get_type() - self.assertEquals(c_class, p_type) + self.assertEqual(c_class, p_type) def test_static_oi_class_methods(self): code = 'class C(object):\n def f(self, p):\n pass\n' \ @@ -400,7 +400,7 @@ def test_static_oi_class_methods(self): c_class = pymod['C'].get_object() f_scope = c_class['f'].get_object().get_scope() p_type = f_scope['p'].get_object().get_type() - self.assertEquals(c_class, p_type) + self.assertEqual(c_class, p_type) def test_static_oi_preventing_soi_maximum_recursion_exceptions(self): code = 'item = {}\nfor item in item.keys():\n pass\n' @@ -417,7 +417,7 @@ def test_static_oi_for_infer_return_typs_from_funcs_based_on_params(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_a_function_with_different_returns(self): code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ @@ -429,8 +429,8 @@ def test_a_function_with_different_returns(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_not_reporting_out_of_date_information(self): code = 'class C1(object):\n pass\n' \ @@ -439,13 +439,13 @@ def test_not_reporting_out_of_date_information(self): pymod = self.project.get_pymodule(self.mod) c1_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c1_class, a_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) self.mod.write(code.replace('C1', 'C2')) pymod = self.project.get_pymodule(self.mod) c2_class = pymod['C2'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c2_class, a_var.get_type()) + self.assertEqual(c2_class, a_var.get_type()) def test_invalidating_concluded_data_in_a_function(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -458,13 +458,13 @@ def test_invalidating_concluded_data_in_a_function(self): pymod2 = self.project.get_pymodule(mod2) c1_class = pymod2['C1'].get_object() a_var = pymod2['a_var'].get_object() - self.assertEquals(c1_class, a_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) mod2.write(mod2.read()[:mod2.read().rfind('C1()')] + 'C2())\n') pymod2 = self.project.get_pymodule(mod2) c2_class = pymod2['C2'].get_object() a_var = pymod2['a_var'].get_object() - self.assertEquals(c2_class, a_var.get_type()) + self.assertEqual(c2_class, a_var.get_type()) def test_handling_generator_functions_for_strs(self): self.mod.write('class C(object):\n pass\ndef f(p):\n yield p()\n' @@ -472,7 +472,7 @@ def test_handling_generator_functions_for_strs(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) # TODO: Returning a generator for functions that yield unknowns @unittest.skip("Returning a generator that yields unknowns") @@ -493,7 +493,7 @@ def test_static_oi_for_lists_depending_on_append_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_get_item(self): code = 'class C(object):\n pass\nl = list()\n' \ @@ -503,7 +503,7 @@ def test_static_oi_for_lists_per_object_for_get_item(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_fields(self): code = 'class C(object):\n pass\n' \ @@ -516,7 +516,7 @@ def test_static_oi_for_lists_per_object_for_fields(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_set_item(self): code = 'class C(object):\n pass\nl = [None]\n' \ @@ -526,7 +526,7 @@ def test_static_oi_for_lists_per_object_for_set_item(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_extending_lists(self): code = 'class C(object):\n pass\nl = []\n' \ @@ -536,7 +536,7 @@ def test_static_oi_for_lists_per_object_for_extending_lists(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_iters(self): code = 'class C(object):\n pass\n' \ @@ -547,7 +547,7 @@ def test_static_oi_for_lists_per_object_for_iters(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_static_oi_for_dicts_depending_on_append_function(self): code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ @@ -559,8 +559,8 @@ def test_static_oi_for_dicts_depending_on_append_function(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_static_oi_for_dicts_depending_on_for_loops(self): code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ @@ -573,8 +573,8 @@ def test_static_oi_for_dicts_depending_on_for_loops(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_static_oi_for_dicts_depending_on_update(self): code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ @@ -587,8 +587,8 @@ def test_static_oi_for_dicts_depending_on_update(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_static_oi_for_dicts_depending_on_update_on_seqs(self): code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ @@ -600,8 +600,8 @@ def test_static_oi_for_dicts_depending_on_update_on_seqs(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_static_oi_for_sets_per_object_for_set_item(self): code = 'class C(object):\n pass\ns = set()\n' \ @@ -611,7 +611,7 @@ def test_static_oi_for_sets_per_object_for_set_item(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_properties_and_calling_get_property(self): code = 'class C1(object):\n pass\n' \ @@ -622,7 +622,7 @@ def test_properties_and_calling_get_property(self): pymod = self.project.get_pymodule(self.mod) c1_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c1_class, a_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) def test_soi_on_constructors(self): code = 'class C1(object):\n pass\n' \ @@ -634,7 +634,7 @@ def test_soi_on_constructors(self): pymod = self.project.get_pymodule(self.mod) c1_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c1_class, a_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) def test_not_saving_unknown_function_returns(self): mod2 = testutils.create_module(self.project, 'mod2') @@ -650,7 +650,7 @@ def test_not_saving_unknown_function_returns(self): self.assertNotEquals(c_class, a_var.get_object().get_type()) self.pycore.analyze_module(self.mod) - self.assertEquals(c_class, a_var.get_object().get_type()) + self.assertEqual(c_class, a_var.get_object().get_type()) def test_using_the_best_callinfo(self): code = 'class C1(object):\n pass\n' \ @@ -662,7 +662,7 @@ def test_using_the_best_callinfo(self): c1_class = pymod['C1'].get_object() f_scope = pymod['f'].get_object().get_scope() arg2 = f_scope['arg2'].get_object() - self.assertEquals(c1_class, arg2.get_type()) + self.assertEqual(c1_class, arg2.get_type()) def test_call_function_and_parameters(self): code = 'class A(object):\n def __call__(self, p):\n pass\n' \ @@ -685,7 +685,7 @@ def test_report_change_in_libutils(self): c_class = pymod['C'].get_object() f_scope = pymod['f'].get_object().get_scope() p_type = f_scope['p'].get_object().get_type() - self.assertEquals(c_class, p_type) + self.assertEqual(c_class, p_type) def test_report_libutils_and_analyze_all_modules(self): code = 'class C(object):\n pass\ndef f(p):\n pass\nf(C())\n' @@ -695,7 +695,7 @@ def test_report_libutils_and_analyze_all_modules(self): c_class = pymod['C'].get_object() f_scope = pymod['f'].get_object().get_scope() p_type = f_scope['p'].get_object().get_type() - self.assertEquals(c_class, p_type) + self.assertEqual(c_class, p_type) def test_validation_problems_for_objectdb_retrievals(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -709,7 +709,7 @@ def test_validation_problems_for_objectdb_retrievals(self): c_class = pymod2['C'].get_object() pymod1 = self.project.get_pymodule(mod1) var_pyname = pymod1['var'] - self.assertEquals(c_class, var_pyname.get_object().get_type()) + self.assertEqual(c_class, var_pyname.get_object().get_type()) mod2.write('import mod1\n\nmod1.l.append("")\n') self.assertNotEquals(c_class, var_pyname.get_object().get_type(), 'Class `C` no more exists') @@ -732,7 +732,7 @@ def test_always_returning_containing_class_for_selfs(self): a_class = pymod['A'].get_object() f_scope = a_class.get_scope().get_scopes()[0] p_type = f_scope['p'].get_object().get_type() - self.assertEquals(a_class, p_type) + self.assertEqual(a_class, p_type) def test_following_function_calls_when_asked_to(self): code = 'class A(object):\n pass\n' \ @@ -746,7 +746,7 @@ def test_following_function_calls_when_asked_to(self): pymod = self.project.get_pymodule(self.mod) a_class = pymod['A'].get_object() x_var = pymod['x'].get_object().get_type() - self.assertEquals(a_class, x_var) + self.assertEqual(a_class, x_var) def suite(): diff --git a/ropetest/builtinstest.py b/ropetest/builtinstest.py index df365449d..5fe370916 100644 --- a/ropetest/builtinstest.py +++ b/ropetest/builtinstest.py @@ -28,7 +28,7 @@ def test_holding_type_information(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_get_items(self): self.mod.write('class C(object):' @@ -37,14 +37,14 @@ def test_get_items(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_get_items_for_lists(self): self.mod.write('class C(object):\n pass\nl = [C()]\na_var = l[0]\n') pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_get_items_from_slices(self): self.mod.write('class C(object):\n pass' @@ -52,7 +52,7 @@ def test_get_items_from_slices(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_simple_for_loops(self): self.mod.write('class C(object):\n pass\nl = [C()]\n' @@ -60,14 +60,14 @@ def test_simple_for_loops(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_definition_location_for_loop_variables(self): self.mod.write('class C(object):\n pass\nl = [C()]\n' 'for c in l:\n pass\n') pymod = self.project.get_pymodule(self.mod) c_var = pymod['c'] - self.assertEquals((pymod, 4), c_var.get_definition_location()) + self.assertEqual((pymod, 4), c_var.get_definition_location()) def test_simple_case_for_dicts(self): self.mod.write('d = {}\n') @@ -80,7 +80,7 @@ def test_get_item_for_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_popping_dicts(self): self.mod.write('class C(object):\n pass\n' @@ -88,7 +88,7 @@ def test_popping_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_getting_keys_from_dicts(self): self.mod.write('class C1(object):\n pass\n' @@ -97,7 +97,7 @@ def test_getting_keys_from_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_getting_values_from_dicts(self): self.mod.write('class C1(object):\n pass\n' @@ -107,7 +107,7 @@ def test_getting_values_from_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C2'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_getting_iterkeys_from_dicts(self): self.mod.write('class C1(object):\n pass' @@ -116,7 +116,7 @@ def test_getting_iterkeys_from_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_getting_itervalues_from_dicts(self): self.mod.write('class C1(object):\n pass' @@ -126,7 +126,7 @@ def test_getting_itervalues_from_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C2'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_using_copy_for_dicts(self): self.mod.write('class C1(object):\n pass' @@ -135,7 +135,7 @@ def test_using_copy_for_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_tuple_assignments_for_items(self): self.mod.write('class C1(object):\n pass' @@ -146,8 +146,8 @@ def test_tuple_assignments_for_items(self): c2_class = pymod['C2'].get_object() key = pymod['key'].get_object() value = pymod['value'].get_object() - self.assertEquals(c1_class, key.get_type()) - self.assertEquals(c2_class, value.get_type()) + self.assertEqual(c1_class, key.get_type()) + self.assertEqual(c2_class, value.get_type()) def test_tuple_assignment_for_lists(self): self.mod.write('class C(object):\n pass\n' @@ -156,8 +156,8 @@ def test_tuple_assignment_for_lists(self): c_class = pymod['C'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c_class, a_var.get_type()) - self.assertEquals(c_class, b_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) + self.assertEqual(c_class, b_var.get_type()) def test_tuple_assignments_for_iteritems_in_fors(self): self.mod.write('class C1(object):\n pass\n' @@ -169,8 +169,8 @@ def test_tuple_assignments_for_iteritems_in_fors(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_simple_tuple_assignments(self): self.mod.write('class C1(object):' @@ -181,15 +181,15 @@ def test_simple_tuple_assignments(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_overriding_builtin_names(self): self.mod.write('class C(object):\n pass\nlist = C\n') pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() list_var = pymod['list'].get_object() - self.assertEquals(c_class, list_var) + self.assertEqual(c_class, list_var) def test_simple_builtin_scope_test(self): self.mod.write('l = list()\n') @@ -207,7 +207,7 @@ def test_making_lists_using_the_passed_argument_to_init(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_making_tuples_using_the_passed_argument_to_init(self): self.mod.write('class C(object):\n pass\nl1 = [C()]\n' @@ -215,7 +215,7 @@ def test_making_tuples_using_the_passed_argument_to_init(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_making_sets_using_the_passed_argument_to_init(self): self.mod.write('class C(object):\n pass\nl1 = [C()]\n' @@ -223,7 +223,7 @@ def test_making_sets_using_the_passed_argument_to_init(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_making_dicts_using_the_passed_argument_to_init(self): self.mod.write('class C1(object):\n pass\n' @@ -235,8 +235,8 @@ def test_making_dicts_using_the_passed_argument_to_init(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_range_builtin_function(self): self.mod.write('l = range(1)\n') @@ -250,7 +250,7 @@ def test_reversed_builtin_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_sorted_builtin_function(self): self.mod.write('class C(object):\n pass\nl = [C()]\n' @@ -258,7 +258,7 @@ def test_sorted_builtin_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_super_builtin_function(self): self.mod.write( @@ -270,7 +270,7 @@ def test_super_builtin_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_file_builtin_type(self): self.mod.write('for line in open("file.txt"):\n a_var = line\n') @@ -288,7 +288,7 @@ def test_lambda_functions(self): self.mod.write('l = lambda: 1\n') pymod = self.project.get_pymodule(self.mod) l_var = pymod['l'].get_object() - self.assertEquals(pyobjects.get_base_type('Function'), + self.assertEqual(pyobjects.get_base_type('Function'), l_var.get_type()) def test_lambda_function_definition(self): @@ -296,8 +296,8 @@ def test_lambda_function_definition(self): pymod = self.project.get_pymodule(self.mod) l_var = pymod['l'].get_object() self.assertTrue(l_var.get_name() is not None) - self.assertEquals(len(l_var.get_param_names()), 4) - self.assertEquals((pymod, 1), + self.assertEqual(len(l_var.get_param_names()), 4) + self.assertEqual((pymod, 1), pymod['l'].get_definition_location()) def test_lambdas_that_return_unknown(self): @@ -316,8 +316,8 @@ def test_builtin_zip_function(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_builtin_zip_function_with_more_than_two_args(self): self.mod.write( @@ -330,9 +330,9 @@ def test_builtin_zip_function_with_more_than_two_args(self): a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() c_var = pymod['c'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) - self.assertEquals(c1_class, c_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) + self.assertEqual(c1_class, c_var.get_type()) def test_wrong_arguments_to_zip_function(self): self.mod.write( @@ -342,7 +342,7 @@ def test_wrong_arguments_to_zip_function(self): c1_class = pymod['C1'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() # noqa - self.assertEquals(c1_class, a_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) def test_enumerate_builtin_function(self): self.mod.write('class C(object):\n pass\nl = [C()]\n' @@ -350,12 +350,12 @@ def test_enumerate_builtin_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_builtin_class_get_name(self): - self.assertEquals('object', + self.assertEqual('object', builtins.builtins['object'].get_object().get_name()) - self.assertEquals( + self.assertEqual( 'property', builtins.builtins['property'].get_object().get_name()) def test_star_args_and_double_star_args(self): @@ -385,60 +385,60 @@ def test_iter_builtin_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_simple_int_type(self): self.mod.write('l = 1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals(builtins.builtins['int'].get_object(), + self.assertEqual(builtins.builtins['int'].get_object(), pymod['l'].get_object().get_type()) def test_simple_float_type(self): self.mod.write('l = 1.0\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals(builtins.builtins['float'].get_object(), + self.assertEqual(builtins.builtins['float'].get_object(), pymod['l'].get_object().get_type()) def test_simple_float_type2(self): self.mod.write('l = 1e1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals(builtins.builtins['float'].get_object(), + self.assertEqual(builtins.builtins['float'].get_object(), pymod['l'].get_object().get_type()) def test_simple_complex_type(self): self.mod.write('l = 1.0j\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals(builtins.builtins['complex'].get_object(), + self.assertEqual(builtins.builtins['complex'].get_object(), pymod['l'].get_object().get_type()) def test_handling_unaryop_on_ints(self): self.mod.write('l = -(1)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals(builtins.builtins['int'].get_object(), + self.assertEqual(builtins.builtins['int'].get_object(), pymod['l'].get_object().get_type()) def test_handling_binop_on_ints(self): self.mod.write('l = 1 + 1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals(builtins.builtins['int'].get_object(), + self.assertEqual(builtins.builtins['int'].get_object(), pymod['l'].get_object().get_type()) def test_handling_compares(self): self.mod.write('l = 1 == 1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals(builtins.builtins['bool'].get_object(), + self.assertEqual(builtins.builtins['bool'].get_object(), pymod['l'].get_object().get_type()) def test_handling_boolops(self): self.mod.write('l = 1 and 2\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals(builtins.builtins['int'].get_object(), + self.assertEqual(builtins.builtins['int'].get_object(), pymod['l'].get_object().get_type()) def test_binary_or_left_value_unknown(self): code = 'var = (asdsd or 3)\n' pymod = libutils.get_string_module(self.project, code) - self.assertEquals(builtins.builtins['int'].get_object(), + self.assertEqual(builtins.builtins['int'].get_object(), pymod['var'].get_object().get_type()) def test_unknown_return_object(self): diff --git a/ropetest/codeanalyzetest.py b/ropetest/codeanalyzetest.py index 6b6ff0883..3b38c3273 100644 --- a/ropetest/codeanalyzetest.py +++ b/ropetest/codeanalyzetest.py @@ -21,33 +21,33 @@ def tearDown(self): def test_source_lines_simple(self): to_lines = SourceLinesAdapter('line1\nline2\n') - self.assertEquals('line1', to_lines.get_line(1)) - self.assertEquals('line2', to_lines.get_line(2)) - self.assertEquals('', to_lines.get_line(3)) - self.assertEquals(3, to_lines.length()) + self.assertEqual('line1', to_lines.get_line(1)) + self.assertEqual('line2', to_lines.get_line(2)) + self.assertEqual('', to_lines.get_line(3)) + self.assertEqual(3, to_lines.length()) def test_source_lines_get_line_number(self): to_lines = SourceLinesAdapter('line1\nline2\n') - self.assertEquals(1, to_lines.get_line_number(0)) - self.assertEquals(1, to_lines.get_line_number(5)) - self.assertEquals(2, to_lines.get_line_number(7)) - self.assertEquals(3, to_lines.get_line_number(12)) + self.assertEqual(1, to_lines.get_line_number(0)) + self.assertEqual(1, to_lines.get_line_number(5)) + self.assertEqual(2, to_lines.get_line_number(7)) + self.assertEqual(3, to_lines.get_line_number(12)) def test_source_lines_get_line_start(self): to_lines = SourceLinesAdapter('line1\nline2\n') - self.assertEquals(0, to_lines.get_line_start(1)) - self.assertEquals(6, to_lines.get_line_start(2)) - self.assertEquals(12, to_lines.get_line_start(3)) + self.assertEqual(0, to_lines.get_line_start(1)) + self.assertEqual(6, to_lines.get_line_start(2)) + self.assertEqual(12, to_lines.get_line_start(3)) def test_source_lines_get_line_end(self): to_lines = SourceLinesAdapter('line1\nline2\n') - self.assertEquals(5, to_lines.get_line_end(1)) - self.assertEquals(11, to_lines.get_line_end(2)) - self.assertEquals(12, to_lines.get_line_end(3)) + self.assertEqual(5, to_lines.get_line_end(1)) + self.assertEqual(11, to_lines.get_line_end(2)) + self.assertEqual(12, to_lines.get_line_end(3)) def test_source_lines_last_line_with_no_new_line(self): to_lines = SourceLinesAdapter('line1') - self.assertEquals(1, to_lines.get_line_number(5)) + self.assertEqual(1, to_lines.get_line_number(5)) class WordRangeFinderTest(unittest.TestCase): @@ -65,151 +65,151 @@ def _find_primary(self, code, offset): def test_keyword_before_parens(self): code = 'if (a_var).an_attr:\n pass\n' - self.assertEquals('(a_var).an_attr', + self.assertEqual('(a_var).an_attr', self._find_primary(code, code.index(':'))) def test_inside_parans(self): code = 'a_func(a_var)' - self.assertEquals('a_var', self._find_primary(code, 10)) + self.assertEqual('a_var', self._find_primary(code, 10)) def test_simple_names(self): code = 'a_var = 10' - self.assertEquals('a_var', self._find_primary(code, 3)) + self.assertEqual('a_var', self._find_primary(code, 3)) def test_function_calls(self): code = 'sample_function()' - self.assertEquals('sample_function', self._find_primary(code, 10)) + self.assertEqual('sample_function', self._find_primary(code, 10)) def test_attribute_accesses(self): code = 'a_var.an_attr' - self.assertEquals('a_var.an_attr', self._find_primary(code, 10)) + self.assertEqual('a_var.an_attr', self._find_primary(code, 10)) def test_word_finder_on_word_beginning(self): code = 'print(a_var)\n' word_finder = worder.Worder(code) result = word_finder.get_word_at(code.index('a_var')) - self.assertEquals('a_var', result) + self.assertEqual('a_var', result) def test_word_finder_on_primary_beginning(self): code = 'print(a_var)\n' result = self._find_primary(code, code.index('a_var')) - self.assertEquals('a_var', result) + self.assertEqual('a_var', result) def test_word_finder_on_word_ending(self): code = 'print(a_var)\n' word_finder = worder.Worder(code) result = word_finder.get_word_at(code.index('a_var') + 5) - self.assertEquals('a_var', result) + self.assertEqual('a_var', result) def test_word_finder_on_primary_ending(self): code = 'print(a_var)\n' result = self._find_primary(code, code.index('a_var') + 5) - self.assertEquals('a_var', result) + self.assertEqual('a_var', result) def test_word_finder_on_primaries_with_dots_inside_parens(self): code = '(a_var.\nattr)' result = self._find_primary(code, code.index('attr') + 1) - self.assertEquals('a_var.\nattr', result) + self.assertEqual('a_var.\nattr', result) def test_strings(self): code = '"a string".split()' - self.assertEquals('"a string".split', self._find_primary(code, 14)) + self.assertEqual('"a string".split', self._find_primary(code, 14)) def test_function_calls2(self): code = 'file("afile.txt").read()' - self.assertEquals('file("afile.txt").read', + self.assertEqual('file("afile.txt").read', self._find_primary(code, 18)) def test_parens(self): code = '("afile.txt").split()' - self.assertEquals('("afile.txt").split', self._find_primary(code, 18)) + self.assertEqual('("afile.txt").split', self._find_primary(code, 18)) def test_function_with_no_param(self): code = 'AClass().a_func()' - self.assertEquals('AClass().a_func', self._find_primary(code, 12)) + self.assertEqual('AClass().a_func', self._find_primary(code, 12)) def test_function_with_multiple_param(self): code = 'AClass(a_param, another_param, "a string").a_func()' - self.assertEquals('AClass(a_param, another_param, "a string").a_func', + self.assertEqual('AClass(a_param, another_param, "a string").a_func', self._find_primary(code, 44)) def test_param_expressions(self): code = 'AClass(an_object.an_attr).a_func()' - self.assertEquals('an_object.an_attr', self._find_primary(code, 20)) + self.assertEqual('an_object.an_attr', self._find_primary(code, 20)) def test_string_parens(self): code = 'a_func("(").an_attr' - self.assertEquals('a_func("(").an_attr', self._find_primary(code, 16)) + self.assertEqual('a_func("(").an_attr', self._find_primary(code, 16)) def test_extra_spaces(self): code = 'a_func ( "(" ) . an_attr' - self.assertEquals('a_func ( "(" ) . an_attr', + self.assertEqual('a_func ( "(" ) . an_attr', self._find_primary(code, 26)) def test_functions_on_ending_parens(self): code = 'A()' - self.assertEquals('A()', self._find_primary(code, 2)) + self.assertEqual('A()', self._find_primary(code, 2)) def test_splitted_statement(self): word_finder = worder.Worder('an_object.an_attr') - self.assertEquals(('an_object', 'an_at', 10), + self.assertEqual(('an_object', 'an_at', 10), word_finder.get_splitted_primary_before(15)) def test_empty_splitted_statement(self): word_finder = worder.Worder('an_attr') - self.assertEquals(('', 'an_at', 0), + self.assertEqual(('', 'an_at', 0), word_finder.get_splitted_primary_before(5)) def test_empty_splitted_statement2(self): word_finder = worder.Worder('an_object.') - self.assertEquals(('an_object', '', 10), + self.assertEqual(('an_object', '', 10), word_finder.get_splitted_primary_before(10)) def test_empty_splitted_statement3(self): word_finder = worder.Worder('') - self.assertEquals(('', '', 0), + self.assertEqual(('', '', 0), word_finder.get_splitted_primary_before(0)) def test_empty_splitted_statement4(self): word_finder = worder.Worder('a_var = ') - self.assertEquals(('', '', 8), + self.assertEqual(('', '', 8), word_finder.get_splitted_primary_before(8)) def test_empty_splitted_statement5(self): word_finder = worder.Worder('a.') - self.assertEquals(('a', '', 2), + self.assertEqual(('a', '', 2), word_finder.get_splitted_primary_before(2)) def test_operators_inside_parens(self): code = '(a_var + another_var).reverse()' - self.assertEquals('(a_var + another_var).reverse', + self.assertEqual('(a_var + another_var).reverse', self._find_primary(code, 25)) def test_dictionaries(self): code = 'print({1: "one", 2: "two"}.keys())' - self.assertEquals('{1: "one", 2: "two"}.keys', + self.assertEqual('{1: "one", 2: "two"}.keys', self._find_primary(code, 29)) def test_following_parens(self): code = 'a_var = a_func()()' result = self._find_primary(code, code.index(')(') + 3) - self.assertEquals('a_func()()', result) + self.assertEqual('a_func()()', result) def test_comments_for_finding_statements(self): code = '# var2 . \n var3' - self.assertEquals('var3', self._find_primary(code, code.index('3'))) + self.assertEqual('var3', self._find_primary(code, code.index('3'))) def test_str_in_comments_for_finding_statements(self): code = '# "var2" . \n var3' - self.assertEquals('var3', self._find_primary(code, code.index('3'))) + self.assertEqual('var3', self._find_primary(code, code.index('3'))) def test_comments_for_finding_statements2(self): code = 'var1 + "# var2".\n var3' - self.assertEquals('var3', self._find_primary(code, 21)) + self.assertEqual('var3', self._find_primary(code, 21)) def test_comments_for_finding_statements3(self): code = '"" + # var2.\n var3' - self.assertEquals('var3', self._find_primary(code, 21)) + self.assertEqual('var3', self._find_primary(code, 21)) def test_import_statement_finding(self): code = 'import mod\na_var = 10\n' @@ -227,12 +227,12 @@ def test_word_parens_range(self): code = 's = str()\ns.title()\n' word_finder = worder.Worder(code) result = word_finder.get_word_parens_range(code.rindex('()') - 1) - self.assertEquals((len(code) - 3, len(code) - 1), result) + self.assertEqual((len(code) - 3, len(code) - 1), result) def test_getting_primary_before_get_index(self): code = '\na = (b + c).d[0]()\n' result = self._find_primary(code, len(code) - 2) - self.assertEquals('(b + c).d[0]()', result) + self.assertEqual('(b + c).d[0]()', result) def test_getting_primary_and_strings_at_the_end_of_line(self): code = 'f(\'\\\'\')\n' @@ -241,13 +241,13 @@ def test_getting_primary_and_strings_at_the_end_of_line(self): def test_getting_primary_and_not_crossing_newlines(self): code = '\na = (b + c)\n(4 + 1).x\n' result = self._find_primary(code, len(code) - 1) - self.assertEquals('(4 + 1).x', result) + self.assertEqual('(4 + 1).x', result) # XXX: cancatenated string literals def xxx_test_getting_primary_cancatenating_strs(self): code = 's = "a"\n"b" "c"\n' result = self._find_primary(code, len(code) - 2) - self.assertEquals('"b" "c"', result) + self.assertEqual('"b" "c"', result) def test_is_a_function_being_called_with_parens_on_next_line(self): code = 'func\n(1, 2)\n' @@ -258,18 +258,18 @@ def test_is_a_function_being_called_with_parens_on_next_line(self): def xxx_test_triple_quotes(self): code = 's = """string"""\n' result = self._find_primary(code, len(code) - 1) - self.assertEquals('"""string"""', result) + self.assertEqual('"""string"""', result) def test_triple_quotes_spanning_multiple_lines(self): code = 's = """\\\nl1\nl2\n """\n' result = self._find_primary(code, len(code) - 2) - self.assertEquals('"""\\\nl1\nl2\n """', result) + self.assertEqual('"""\\\nl1\nl2\n """', result) def test_get_word_parens_range_and_string_literals(self): code = 'f(1, ")", 2)\n' word_finder = worder.Worder(code) result = word_finder.get_word_parens_range(0) - self.assertEquals((1, len(code) - 1), result) + self.assertEqual((1, len(code) - 1), result) def test_is_assigned_here_for_equality_test(self): code = 'a == 1\n' @@ -306,35 +306,35 @@ def test_one_letter_function_keyword_arguments(self): def test_find_parens_start(self): code = 'f(p)\n' finder = worder.Worder(code) - self.assertEquals(1, finder.find_parens_start_from_inside(2)) + self.assertEqual(1, finder.find_parens_start_from_inside(2)) def test_underlined_find_parens_start(self): code = 'f(p="")\n' finder = worder.Worder(code) - self.assertEquals(1, finder._find_parens_start(len(code) - 2)) + self.assertEqual(1, finder._find_parens_start(len(code) - 2)) def test_find_parens_start_with_multiple_entries(self): code = 'myfunc(p1, p2, p3\n' finder = worder.Worder(code) - self.assertEquals(code.index('('), + self.assertEqual(code.index('('), finder.find_parens_start_from_inside(len(code) - 1)) def test_find_parens_start_with_nested_parens(self): code = 'myfunc(p1, (p2, p3), p4\n' finder = worder.Worder(code) - self.assertEquals(code.index('('), + self.assertEqual(code.index('('), finder.find_parens_start_from_inside(len(code) - 1)) def test_find_parens_start_with_parens_in_strs(self): code = 'myfunc(p1, "(", p4\n' finder = worder.Worder(code) - self.assertEquals(code.index('('), + self.assertEqual(code.index('('), finder.find_parens_start_from_inside(len(code) - 1)) def test_find_parens_start_with_parens_in_strs_in_multiple_lines(self): code = 'myfunc (\np1\n , \n "(" \n, \np4\n' finder = worder.Worder(code) - self.assertEquals(code.index('('), + self.assertEqual(code.index('('), finder.find_parens_start_from_inside(len(code) - 1)) def test_is_on_function_keyword(self): @@ -360,7 +360,7 @@ def xxx_test_global_name_in_class_body(self): scope = libutils.get_string_scope(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) result = name_finder.get_pyname_at(len(code) - 3) - self.assertEquals(scope['a_var'], result) + self.assertEqual(scope['a_var'], result) def test_class_variable_attribute_in_class_body(self): code = 'a_var = 10\nclass C(object):\n a_var = a_var\n' @@ -368,7 +368,7 @@ def test_class_variable_attribute_in_class_body(self): name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_var_pyname = scope['C'].get_object()['a_var'] result = name_finder.get_pyname_at(len(code) - 12) - self.assertEquals(a_var_pyname, result) + self.assertEqual(a_var_pyname, result) def test_class_variable_attribute_in_class_body2(self): code = 'a_var = 10\nclass C(object):\n a_var \\\n= a_var\n' @@ -376,7 +376,7 @@ def test_class_variable_attribute_in_class_body2(self): name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_var_pyname = scope['C'].get_object()['a_var'] result = name_finder.get_pyname_at(len(code) - 12) - self.assertEquals(a_var_pyname, result) + self.assertEqual(a_var_pyname, result) def test_class_method_attribute_in_class_body(self): code = 'class C(object):\n def a_method(self):\n pass\n' @@ -384,7 +384,7 @@ def test_class_method_attribute_in_class_body(self): name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_method_pyname = scope['C'].get_object()['a_method'] result = name_finder.get_pyname_at(code.index('a_method') + 2) - self.assertEquals(a_method_pyname, result) + self.assertEqual(a_method_pyname, result) def test_inner_class_attribute_in_class_body(self): code = 'class C(object):\n class CC(object):\n pass\n' @@ -392,7 +392,7 @@ def test_inner_class_attribute_in_class_body(self): name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_class_pyname = scope['C'].get_object()['CC'] result = name_finder.get_pyname_at(code.index('CC') + 2) - self.assertEquals(a_class_pyname, result) + self.assertEqual(a_class_pyname, result) def test_class_method_in_class_body_but_not_indexed(self): code = 'class C(object):\n def func(self, func):\n pass\n' @@ -400,7 +400,7 @@ def test_class_method_in_class_body_but_not_indexed(self): a_func_pyname = scope.get_scopes()[0].get_scopes()[0]['func'] name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) result = name_finder.get_pyname_at(code.index(', func') + 3) - self.assertEquals(a_func_pyname, result) + self.assertEqual(a_func_pyname, result) def test_function_but_not_indexed(self): code = 'def a_func(a_func):\n pass\n' @@ -408,7 +408,7 @@ def test_function_but_not_indexed(self): a_func_pyname = scope['a_func'] name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) result = name_finder.get_pyname_at(code.index('a_func') + 3) - self.assertEquals(a_func_pyname, result) + self.assertEqual(a_func_pyname, result) def test_modules_after_from_statements(self): root_folder = self.project.root @@ -419,7 +419,7 @@ def test_modules_after_from_statements(self): name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) mod_pyobject = self.project.get_pymodule(mod) found_pyname = name_finder.get_pyname_at(code.index('mod') + 1) - self.assertEquals(mod_pyobject, found_pyname.get_object()) + self.assertEqual(mod_pyobject, found_pyname.get_object()) def test_renaming_functions_with_from_import_and_parens(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -430,7 +430,7 @@ def test_renaming_functions_with_from_import_and_parens(self): mod_pyobject = self.project.get_pymodule(mod1) afunc = mod_pyobject['afunc'] found_pyname = name_finder.get_pyname_at(code.index('afunc') + 1) - self.assertEquals(afunc.get_object(), found_pyname.get_object()) + self.assertEqual(afunc.get_object(), found_pyname.get_object()) @testutils.only_for('2.5') def test_relative_modules_after_from_statements(self): @@ -445,7 +445,7 @@ def test_relative_modules_after_from_statements(self): name_finder = rope.base.evaluate.ScopeNameFinder(mod2_scope.pyobject) mod1_pyobject = self.project.get_pymodule(mod1) found_pyname = name_finder.get_pyname_at(code.index('mod1') + 1) - self.assertEquals(mod1_pyobject, found_pyname.get_object()) + self.assertEqual(mod1_pyobject, found_pyname.get_object()) def test_relative_modules_after_from_statements2(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -458,7 +458,7 @@ def test_relative_modules_after_from_statements2(self): name_finder = rope.base.evaluate.ScopeNameFinder(mod1_scope.pyobject) pkg2_pyobject = self.project.get_pymodule(pkg2) found_pyname = name_finder.get_pyname_at(mod1.read().index('pkg2') + 1) - self.assertEquals(pkg2_pyobject, found_pyname.get_object()) + self.assertEqual(pkg2_pyobject, found_pyname.get_object()) def test_get_pyname_at_on_language_keywords(self): code = 'def a_func(a_func):\n pass\n' @@ -472,21 +472,21 @@ def test_one_liners(self): pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) - self.assertEquals(pymod['var'], pyname) + self.assertEqual(pymod['var'], pyname) def test_one_liners_with_line_breaks(self): code = 'var = 1\ndef f(\n): var = 2\nprint(var)\n' pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) - self.assertEquals(pymod['var'], pyname) + self.assertEqual(pymod['var'], pyname) def test_one_liners_with_line_breaks2(self): code = 'var = 1\ndef f(\np): var = 2\nprint(var)\n' pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) - self.assertEquals(pymod['var'], pyname) + self.assertEqual(pymod['var'], pyname) class LogicalLineFinderTest(unittest.TestCase): @@ -503,106 +503,106 @@ def _logical_finder(self, code): def test_normal_lines(self): code = 'a_var = 10' line_finder = self._logical_finder(code) - self.assertEquals((1, 1), line_finder.logical_line_in(1)) + self.assertEqual((1, 1), line_finder.logical_line_in(1)) def test_normal_lines2(self): code = 'another = 10\na_var = 20\n' line_finder = self._logical_finder(code) - self.assertEquals((1, 1), line_finder.logical_line_in(1)) - self.assertEquals((2, 2), line_finder.logical_line_in(2)) + self.assertEqual((1, 1), line_finder.logical_line_in(1)) + self.assertEqual((2, 2), line_finder.logical_line_in(2)) def test_implicit_continuation(self): code = 'a_var = 3 + \\\n 4 + \\\n 5' line_finder = self._logical_finder(code) - self.assertEquals((1, 3), line_finder.logical_line_in(2)) + self.assertEqual((1, 3), line_finder.logical_line_in(2)) def test_explicit_continuation(self): code = 'print(2)\na_var = (3 + \n 4, \n 5)\n' line_finder = self._logical_finder(code) - self.assertEquals((2, 4), line_finder.logical_line_in(2)) + self.assertEqual((2, 4), line_finder.logical_line_in(2)) def test_explicit_continuation_comments(self): code = '#\na_var = 3\n' line_finder = self._logical_finder(code) - self.assertEquals((2, 2), line_finder.logical_line_in(2)) + self.assertEqual((2, 2), line_finder.logical_line_in(2)) def test_multiple_indented_ifs(self): code = 'if True:\n if True:\n ' \ 'if True:\n pass\n a = 10\n' line_finder = self._logical_finder(code) - self.assertEquals((5, 5), line_finder.logical_line_in(5)) + self.assertEqual((5, 5), line_finder.logical_line_in(5)) def test_list_comprehensions_and_fors(self): code = 'a_list = [i\n for i in range(10)]\n' line_finder = self._logical_finder(code) - self.assertEquals((1, 2), line_finder.logical_line_in(2)) + self.assertEqual((1, 2), line_finder.logical_line_in(2)) def test_generator_expressions_and_fors(self): code = 'a_list = (i\n for i in range(10))\n' line_finder = self._logical_finder(code) - self.assertEquals((1, 2), line_finder.logical_line_in(2)) + self.assertEqual((1, 2), line_finder.logical_line_in(2)) def test_fors_and_block_start(self): code = 'l = range(10)\nfor i in l:\n print(i)\n' - self.assertEquals(2, get_block_start(SourceLinesAdapter(code), 2)) + self.assertEqual(2, get_block_start(SourceLinesAdapter(code), 2)) def test_problems_with_inner_indentations(self): code = 'if True:\n if True:\n if True:\n pass\n' \ ' a = \\\n 1\n' line_finder = self._logical_finder(code) - self.assertEquals((5, 6), line_finder.logical_line_in(6)) + self.assertEqual((5, 6), line_finder.logical_line_in(6)) def test_problems_with_inner_indentations2(self): code = 'if True:\n if True:\n pass\n' \ 'a = 1\n' line_finder = self._logical_finder(code) - self.assertEquals((4, 4), line_finder.logical_line_in(4)) + self.assertEqual((4, 4), line_finder.logical_line_in(4)) def test_logical_lines_for_else(self): code = 'if True:\n pass\nelse:\n pass\n' line_finder = self._logical_finder(code) - self.assertEquals((3, 3), line_finder.logical_line_in(3)) + self.assertEqual((3, 3), line_finder.logical_line_in(3)) def test_logical_lines_for_lines_with_wrong_continues(self): code = 'var = 1 + \\' line_finder = self._logical_finder(code) - self.assertEquals((1, 1), line_finder.logical_line_in(1)) + self.assertEqual((1, 1), line_finder.logical_line_in(1)) def test_logical_lines_for_multiline_string_with_extra_quotes_front(self): code = '""""Docs."""\na = 1\n' line_finder = self._logical_finder(code) - self.assertEquals((2, 2), line_finder.logical_line_in(2)) + self.assertEqual((2, 2), line_finder.logical_line_in(2)) def test_logical_lines_for_multiline_string_with_escaped_quotes(self): code = '"""Quotes \\""" "\\"" \' """\na = 1\n' line_finder = self._logical_finder(code) - self.assertEquals((2, 2), line_finder.logical_line_in(2)) + self.assertEqual((2, 2), line_finder.logical_line_in(2)) def test_generating_line_starts(self): code = 'a = 1\na = 2\n\na = 3\n' line_finder = self._logical_finder(code) - self.assertEquals([1, 2, 4], list(line_finder.generate_starts())) + self.assertEqual([1, 2, 4], list(line_finder.generate_starts())) def test_generating_line_starts2(self): code = 'a = 1\na = 2\n\na = \\ 3\n' line_finder = LogicalLineFinder(SourceLinesAdapter(code)) - self.assertEquals([2, 4], list(line_finder.generate_starts(2))) + self.assertEqual([2, 4], list(line_finder.generate_starts(2))) def test_generating_line_starts3(self): code = 'a = 1\na = 2\n\na = \\ 3\n' line_finder = LogicalLineFinder(SourceLinesAdapter(code)) - self.assertEquals([2], list(line_finder.generate_starts(2, 3))) + self.assertEqual([2], list(line_finder.generate_starts(2, 3))) def test_generating_line_starts_for_multi_line_statements(self): code = '\na = \\\n 1 + \\\n 1\n' line_finder = self._logical_finder(code) - self.assertEquals([2], list(line_finder.generate_starts())) + self.assertEqual([2], list(line_finder.generate_starts())) def test_generating_line_starts_and_unmatched_deindents(self): code = 'if True:\n if True:\n if True:\n' \ ' a = 1\n b = 1\n' line_finder = self._logical_finder(code) - self.assertEquals([4, 5], list(line_finder.generate_starts(4))) + self.assertEqual([4, 5], list(line_finder.generate_starts(4))) class TokenizerLogicalLineFinderTest(LogicalLineFinderTest): diff --git a/ropetest/contrib/autoimporttest.py b/ropetest/contrib/autoimporttest.py index f26de801d..7c6ef303d 100644 --- a/ropetest/contrib/autoimporttest.py +++ b/ropetest/contrib/autoimporttest.py @@ -19,94 +19,94 @@ def tearDown(self): super(AutoImportTest, self).tearDown() def test_simple_case(self): - self.assertEquals([], self.importer.import_assist('A')) + self.assertEqual([], self.importer.import_assist('A')) def test_update_resource(self): self.mod1.write('myvar = None\n') self.importer.update_resource(self.mod1) - self.assertEquals([('myvar', 'mod1')], + self.assertEqual([('myvar', 'mod1')], self.importer.import_assist('myva')) def test_update_module(self): self.mod1.write('myvar = None') self.importer.update_module('mod1') - self.assertEquals([('myvar', 'mod1')], + self.assertEqual([('myvar', 'mod1')], self.importer.import_assist('myva')) def test_update_non_existent_module(self): self.importer.update_module('does_not_exists_this') - self.assertEquals([], self.importer.import_assist('myva')) + self.assertEqual([], self.importer.import_assist('myva')) def test_module_with_syntax_errors(self): self.mod1.write('this is a syntax error\n') self.importer.update_resource(self.mod1) - self.assertEquals([], self.importer.import_assist('myva')) + self.assertEqual([], self.importer.import_assist('myva')) def test_excluding_imported_names(self): self.mod1.write('import pkg\n') self.importer.update_resource(self.mod1) - self.assertEquals([], self.importer.import_assist('pkg')) + self.assertEqual([], self.importer.import_assist('pkg')) def test_get_modules(self): self.mod1.write('myvar = None\n') self.importer.update_resource(self.mod1) - self.assertEquals(['mod1'], self.importer.get_modules('myvar')) + self.assertEqual(['mod1'], self.importer.get_modules('myvar')) def test_get_modules_inside_packages(self): self.mod1.write('myvar = None\n') self.mod2.write('myvar = None\n') self.importer.update_resource(self.mod1) self.importer.update_resource(self.mod2) - self.assertEquals(set(['mod1', 'pkg.mod2']), + self.assertEqual(set(['mod1', 'pkg.mod2']), set(self.importer.get_modules('myvar'))) def test_trivial_insertion_line(self): result = self.importer.find_insertion_line('') - self.assertEquals(1, result) + self.assertEqual(1, result) def test_insertion_line(self): result = self.importer.find_insertion_line('import mod\n') - self.assertEquals(2, result) + self.assertEqual(2, result) def test_insertion_line_with_pydocs(self): result = self.importer.find_insertion_line( '"""docs\n\ndocs"""\nimport mod\n') - self.assertEquals(5, result) + self.assertEqual(5, result) def test_insertion_line_with_multiple_imports(self): result = self.importer.find_insertion_line( 'import mod1\n\nimport mod2\n') - self.assertEquals(4, result) + self.assertEqual(4, result) def test_insertion_line_with_blank_lines(self): result = self.importer.find_insertion_line( 'import mod1\n\n# comment\n') - self.assertEquals(2, result) + self.assertEqual(2, result) def test_empty_cache(self): self.mod1.write('myvar = None\n') self.importer.update_resource(self.mod1) - self.assertEquals(['mod1'], self.importer.get_modules('myvar')) + self.assertEqual(['mod1'], self.importer.get_modules('myvar')) self.importer.clear_cache() - self.assertEquals([], self.importer.get_modules('myvar')) + self.assertEqual([], self.importer.get_modules('myvar')) def test_not_caching_underlined_names(self): self.mod1.write('_myvar = None\n') self.importer.update_resource(self.mod1, underlined=False) - self.assertEquals([], self.importer.get_modules('_myvar')) + self.assertEqual([], self.importer.get_modules('_myvar')) self.importer.update_resource(self.mod1, underlined=True) - self.assertEquals(['mod1'], self.importer.get_modules('_myvar')) + self.assertEqual(['mod1'], self.importer.get_modules('_myvar')) def test_caching_underlined_names_passing_to_the_constructor(self): importer = autoimport.AutoImport(self.project, False, True) self.mod1.write('_myvar = None\n') importer.update_resource(self.mod1) - self.assertEquals(['mod1'], importer.get_modules('_myvar')) + self.assertEqual(['mod1'], importer.get_modules('_myvar')) def test_name_locations(self): self.mod1.write('myvar = None\n') self.importer.update_resource(self.mod1) - self.assertEquals([(self.mod1, 1)], + self.assertEqual([(self.mod1, 1)], self.importer.get_name_locations('myvar')) def test_name_locations_with_multiple_occurrences(self): @@ -114,7 +114,7 @@ def test_name_locations_with_multiple_occurrences(self): self.mod2.write('\nmyvar = None\n') self.importer.update_resource(self.mod1) self.importer.update_resource(self.mod2) - self.assertEquals(set([(self.mod1, 1), (self.mod2, 2)]), + self.assertEqual(set([(self.mod1, 1), (self.mod2, 2)]), set(self.importer.get_name_locations('myvar'))) def test_handling_builtin_modules(self): @@ -122,9 +122,9 @@ def test_handling_builtin_modules(self): self.assertTrue('sys' in self.importer.get_modules('exit')) def test_submodules(self): - self.assertEquals(set([self.mod1]), + self.assertEqual(set([self.mod1]), autoimport.submodules(self.mod1)) - self.assertEquals(set([self.mod2, self.pkg]), + self.assertEqual(set([self.mod2, self.pkg]), autoimport.submodules(self.pkg)) @@ -144,17 +144,17 @@ def tearDown(self): def test_writing_files(self): self.mod1.write('myvar = None\n') - self.assertEquals(['mod1'], self.importer.get_modules('myvar')) + self.assertEqual(['mod1'], self.importer.get_modules('myvar')) def test_moving_files(self): self.mod1.write('myvar = None\n') self.mod1.move('mod3.py') - self.assertEquals(['mod3'], self.importer.get_modules('myvar')) + self.assertEqual(['mod3'], self.importer.get_modules('myvar')) def test_removing_files(self): self.mod1.write('myvar = None\n') self.mod1.remove() - self.assertEquals([], self.importer.get_modules('myvar')) + self.assertEqual([], self.importer.get_modules('myvar')) def suite(): diff --git a/ropetest/contrib/changestacktest.py b/ropetest/contrib/changestacktest.py index ba16c4704..487b77488 100644 --- a/ropetest/contrib/changestacktest.py +++ b/ropetest/contrib/changestacktest.py @@ -21,14 +21,14 @@ def test_change_stack(self): myfile.write('1') stack = rope.contrib.changestack.ChangeStack(self.project) stack.push(rope.base.change.ChangeContents(myfile, '2')) - self.assertEquals('2', myfile.read()) + self.assertEqual('2', myfile.read()) stack.push(rope.base.change.ChangeContents(myfile, '3')) - self.assertEquals('3', myfile.read()) + self.assertEqual('3', myfile.read()) stack.pop_all() - self.assertEquals('1', myfile.read()) + self.assertEqual('1', myfile.read()) changes = stack.merged() self.project.do(changes) - self.assertEquals('3', myfile.read()) + self.assertEqual('3', myfile.read()) if __name__ == '__main__': diff --git a/ropetest/contrib/codeassisttest.py b/ropetest/contrib/codeassisttest.py index 99af16841..c2b1e5338 100644 --- a/ropetest/contrib/codeassisttest.py +++ b/ropetest/contrib/codeassisttest.py @@ -91,7 +91,7 @@ def test_proposing_each_name_at_most_once(self): result = self._assist(code) count = len([x for x in result if x.name == 'variable' and x.scope == 'global']) - self.assertEquals(1, count) + self.assertEqual(1, count) def test_throwing_exception_in_case_of_syntax_errors(self): code = 'sample (sdf+)\n' @@ -115,7 +115,7 @@ def test_not_reporting_variables_in_current_line(self): def test_completion_result(self): code = 'my_global = 10\nt = my' - self.assertEquals(len(code) - 2, starting_offset(code, len(code))) + self.assertEqual(len(code) - 2, starting_offset(code, len(code))) def test_completing_imported_names(self): code = 'import sys\na = sy' @@ -345,12 +345,12 @@ def test_code_assist_with_function_with_two_line_return(self): def test_get_definition_location(self): code = 'def a_func():\n pass\na_func()' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEquals((None, 1), result) + self.assertEqual((None, 1), result) def test_get_definition_location_underlined_names(self): code = 'def a_sample_func():\n pass\na_sample_func()' result = get_definition_location(self.project, code, len(code) - 11) - self.assertEquals((None, 1), result) + self.assertEqual((None, 1), result) def test_get_definition_location_dotted_names(self): code = 'class AClass(object):\n' \ @@ -359,14 +359,14 @@ def test_get_definition_location_dotted_names(self): ' pass\n' \ 'AClass.a_method()' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEquals((None, 2), result) + self.assertEqual((None, 2), result) def test_get_definition_location_dotted_module_names(self): module_resource = testutils.create_module(self.project, 'mod') module_resource.write('def a_func():\n pass\n') code = 'import mod\nmod.a_func()' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEquals((module_resource, 1), result) + self.assertEqual((module_resource, 1), result) def test_get_definition_location_for_nested_packages(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -377,33 +377,33 @@ def test_get_definition_location_for_nested_packages(self): init_dot_py = pkg2.get_child('__init__.py') found_pyname = get_definition_location(self.project, mod1.read(), mod1.read().index('pkg2') + 1) - self.assertEquals(init_dot_py, found_pyname[0]) + self.assertEqual(init_dot_py, found_pyname[0]) def test_get_definition_location_unknown(self): code = 'a_func()\n' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEquals((None, None), result) + self.assertEqual((None, None), result) def test_get_definition_location_dot_spaces(self): code = 'class AClass(object):\n ' \ '@staticmethod\n def a_method():\n' \ ' pass\nAClass.\\\n a_method()' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEquals((None, 2), result) + self.assertEqual((None, 2), result) def test_get_definition_location_dot_line_break_inside_parens(self): code = 'class A(object):\n def a_method(self):\n pass\n' + \ '(A.\na_method)' result = get_definition_location(self.project, code, code.rindex('a_method') + 1) - self.assertEquals((None, 2), result) + self.assertEqual((None, 2), result) def test_if_scopes_in_other_scopes_for_get_definition_location(self): code = 'def f(a_var):\n pass\na_var = 10\n' + \ 'if True:\n' + \ ' print(a_var)\n' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEquals((None, 3), result) + self.assertEqual((None, 3), result) def test_code_assists_in_parens(self): code = 'def a_func(a_var):\n pass\na_var = 10\na_func(a_' @@ -425,8 +425,8 @@ def test_proposals_sorter(self): ' my_sample_var = 20\n' + \ ' my_sample_' proposals = sorted_proposals(self._assist(code)) - self.assertEquals('my_sample_var', proposals[0].name) - self.assertEquals('my_sample_function', proposals[1].name) + self.assertEqual('my_sample_var', proposals[0].name) + self.assertEqual('my_sample_function', proposals[1].name) def test_proposals_sorter_for_methods_and_attributes(self): code = 'class A(object):\n' + \ @@ -439,9 +439,9 @@ def test_proposals_sorter_for_methods_and_attributes(self): 'a_var = A()\n' + \ 'a_var.my_' proposals = sorted_proposals(self._assist(code)) - self.assertEquals('my_b_func', proposals[0].name) - self.assertEquals('my_c_func', proposals[1].name) - self.assertEquals('my_a_var', proposals[2].name) + self.assertEqual('my_b_func', proposals[0].name) + self.assertEqual('my_c_func', proposals[1].name) + self.assertEqual('my_a_var', proposals[2].name) def test_proposals_sorter_for_global_methods_and_funcs(self): code = 'def my_b_func(self):\n' + \ @@ -449,8 +449,8 @@ def test_proposals_sorter_for_global_methods_and_funcs(self): 'my_a_var = 10\n' + \ 'my_' proposals = sorted_proposals(self._assist(code)) - self.assertEquals('my_b_func', proposals[0].name) - self.assertEquals('my_a_var', proposals[1].name) + self.assertEqual('my_b_func', proposals[0].name) + self.assertEqual('my_a_var', proposals[1].name) def test_proposals_sorter_underlined_methods(self): code = 'class A(object):\n' + \ @@ -461,8 +461,8 @@ def test_proposals_sorter_underlined_methods(self): 'a_var = A()\n' + \ 'a_var.' proposals = sorted_proposals(self._assist(code)) - self.assertEquals('my_func', proposals[0].name) - self.assertEquals('_my_func', proposals[1].name) + self.assertEqual('my_func', proposals[0].name) + self.assertEqual('_my_func', proposals[1].name) def test_proposals_sorter_and_scope_prefs(self): code = 'my_global_var = 1\n' \ @@ -471,8 +471,8 @@ def test_proposals_sorter_and_scope_prefs(self): ' my_' result = self._assist(code) proposals = sorted_proposals(result, scopepref=['global', 'local']) - self.assertEquals('my_global_var', proposals[0].name) - self.assertEquals('my_local_var', proposals[1].name) + self.assertEqual('my_global_var', proposals[0].name) + self.assertEqual('my_local_var', proposals[1].name) def test_proposals_sorter_and_type_prefs(self): code = 'my_global_var = 1\n' \ @@ -481,8 +481,8 @@ def test_proposals_sorter_and_type_prefs(self): 'my_' result = self._assist(code) proposals = sorted_proposals(result, typepref=['instance', 'function']) - self.assertEquals('my_global_var', proposals[0].name) - self.assertEquals('my_global_func', proposals[1].name) + self.assertEqual('my_global_var', proposals[0].name) + self.assertEqual('my_global_func', proposals[1].name) def test_proposals_sorter_and_missing_type_in_typepref(self): code = 'my_global_var = 1\n' \ @@ -525,7 +525,7 @@ def test_get_pydoc_for_modules(self): mod = testutils.create_module(self.project, 'mod') mod.write('"""a module"""\n') src = 'import mod\nmod' - self.assertEquals('a module', get_doc(self.project, src, len(src) - 1)) + self.assertEqual('a module', get_doc(self.project, src, len(src) - 1)) def test_get_pydoc_for_builtins(self): src = 'print(object)\n' @@ -685,20 +685,20 @@ def test_codeassist_before_line_indents_in_a_blank_line(self): def test_simple_get_calltips(self): src = 'def f():\n pass\nvar = f()\n' doc = get_calltip(self.project, src, src.rindex('f')) - self.assertEquals('f()', doc) + self.assertEqual('f()', doc) def test_get_calltips_for_classes(self): src = 'class C(object):\n' \ ' def __init__(self):\n pass\nC(' doc = get_calltip(self.project, src, len(src) - 1) - self.assertEquals('C.__init__(self)', doc) + self.assertEqual('C.__init__(self)', doc) def test_get_calltips_for_objects_with_call(self): src = 'class C(object):\n' \ ' def __call__(self, p):\n pass\n' \ 'c = C()\nc(1,' doc = get_calltip(self.project, src, src.rindex('c')) - self.assertEquals('C.__call__(self, p)', doc) + self.assertEqual('C.__call__(self, p)', doc) def test_get_calltips_and_including_module_name(self): src = 'class C(object):\n' \ @@ -707,7 +707,7 @@ def test_get_calltips_and_including_module_name(self): mod = testutils.create_module(self.project, 'mod') mod.write(src) doc = get_calltip(self.project, src, src.rindex('c'), mod) - self.assertEquals('mod.C.__call__(self, p)', doc) + self.assertEqual('mod.C.__call__(self, p)', doc) def test_get_calltips_and_including_module_name_2(self): src = 'range()\n' @@ -720,7 +720,7 @@ def test_removing_self_parameter(self): ' pass\n' \ 'C().f()' doc = get_calltip(self.project, src, src.rindex('f'), remove_self=True) - self.assertEquals('C.f()', doc) + self.assertEqual('C.f()', doc) def test_removing_self_parameter_and_more_than_one_parameter(self): src = 'class C(object):\n' \ @@ -728,7 +728,7 @@ def test_removing_self_parameter_and_more_than_one_parameter(self): ' pass\n' \ 'C().f()' doc = get_calltip(self.project, src, src.rindex('f'), remove_self=True) - self.assertEquals('C.f(p1)', doc) + self.assertEqual('C.f(p1)', doc) def test_lambda_calltip(self): src = 'foo = lambda x, y=1: None\n' \ @@ -859,7 +859,7 @@ def test_object_path_global(self): resource.write(code) result = get_canonical_path(self.project, resource, 1) mod_path = os.path.join(self.project.address, 'mod.py') - self.assertEquals( + self.assertEqual( result, [(mod_path, 'MODULE'), ('GLOBAL_VARIABLE', 'VARIABLE')]) @@ -870,7 +870,7 @@ def test_object_path_attribute(self): resource.write(code) result = get_canonical_path(self.project, resource, 24) mod_path = os.path.join(self.project.address, 'mod.py') - self.assertEquals( + self.assertEqual( result, [(mod_path, 'MODULE'), ('Foo', 'CLASS'), ('attr', 'VARIABLE')]) @@ -882,7 +882,7 @@ def test_object_path_subclass(self): resource.write(code) result = get_canonical_path(self.project, resource, 30) mod_path = os.path.join(self.project.address, 'mod.py') - self.assertEquals( + self.assertEqual( result, [(mod_path, 'MODULE'), ('Foo', 'CLASS'), ('Bar', 'CLASS')]) @@ -894,7 +894,7 @@ def test_object_path_method_parameter(self): resource.write(code) result = get_canonical_path(self.project, resource, 41) mod_path = os.path.join(self.project.address, 'mod.py') - self.assertEquals( + self.assertEqual( result, [(mod_path, 'MODULE'), ('Foo', 'CLASS'), ('bar', 'FUNCTION'), ('b', 'PARAMETER')]) @@ -905,7 +905,7 @@ def test_object_path_variable(self): resource.write(code) result = get_canonical_path(self.project, resource, 17) mod_path = os.path.join(self.project.address, 'mod.py') - self.assertEquals( + self.assertEqual( result, [(mod_path, 'MODULE'), ('bar', 'FUNCTION'), ('x', 'VARIABLE')]) @@ -1027,7 +1027,7 @@ def test_result_start_offset_for_dotted_completions(self): ' def method1(self):\n' \ ' pass\n' \ 'Sample.me' - self.assertEquals(len(code) - 2, starting_offset(code, len(code))) + self.assertEqual(len(code) - 2, starting_offset(code, len(code))) def test_backslash_after_dots(self): code = 'class Sample(object):\n' \ @@ -1062,13 +1062,13 @@ def test_get_location_on_relative_imports(self): code = 'import mod1\nmod1.a_func\n' result = get_definition_location(self.project, code, len(code) - 2, mod2) - self.assertEquals((mod1, 1), result) + self.assertEqual((mod1, 1), result) def test_get_definition_location_for_builtins(self): code = 'import sys\n' result = get_definition_location(self.project, code, len(code) - 2) - self.assertEquals((None, None), result) + self.assertEqual((None, None), result) def test_get_doc_on_relative_imports(self): pkg = testutils.create_package(self.project, 'pkg') @@ -1120,7 +1120,7 @@ def test_completing_names_after_from_import2(self): def test_starting_expression(self): code = 'l = list()\nl.app' - self.assertEquals('l.app', starting_expression(code, len(code))) + self.assertEqual('l.app', starting_expression(code, len(code))) def suite(): diff --git a/ropetest/contrib/finderrorstest.py b/ropetest/contrib/finderrorstest.py index 494a47c91..1116f2b2d 100644 --- a/ropetest/contrib/finderrorstest.py +++ b/ropetest/contrib/finderrorstest.py @@ -18,24 +18,24 @@ def tearDown(self): def test_unresolved_variables(self): self.mod.write('print(var)\n') result = finderrors.find_errors(self.project, self.mod) - self.assertEquals(1, len(result)) - self.assertEquals(1, result[0].lineno) + self.assertEqual(1, len(result)) + self.assertEqual(1, result[0].lineno) def test_defined_later(self): self.mod.write('print(var)\nvar = 1\n') result = finderrors.find_errors(self.project, self.mod) - self.assertEquals(1, len(result)) - self.assertEquals(1, result[0].lineno) + self.assertEqual(1, len(result)) + self.assertEqual(1, result[0].lineno) def test_ignoring_builtins(self): self.mod.write('range(2)\n') result = finderrors.find_errors(self.project, self.mod) - self.assertEquals(0, len(result)) + self.assertEqual(0, len(result)) def test_ignoring_none(self): self.mod.write('var = None\n') result = finderrors.find_errors(self.project, self.mod) - self.assertEquals(0, len(result)) + self.assertEqual(0, len(result)) def test_bad_attributes(self): code = 'class C(object):\n' \ @@ -44,8 +44,8 @@ def test_bad_attributes(self): 'print(c.var)\n' self.mod.write(code) result = finderrors.find_errors(self.project, self.mod) - self.assertEquals(1, len(result)) - self.assertEquals(4, result[0].lineno) + self.assertEqual(1, len(result)) + self.assertEqual(4, result[0].lineno) if __name__ == '__main__': diff --git a/ropetest/contrib/findittest.py b/ropetest/contrib/findittest.py index 9406a36db..1382e06aa 100644 --- a/ropetest/contrib/findittest.py +++ b/ropetest/contrib/findittest.py @@ -23,9 +23,9 @@ def test_finding_occurrences(self): mod = testutils.create_module(self.project, 'mod') mod.write('a_var = 1\n') result = find_occurrences(self.project, mod, 1) - self.assertEquals(mod, result[0].resource) - self.assertEquals(0, result[0].offset) - self.assertEquals(False, result[0].unsure) + self.assertEqual(mod, result[0].resource) + self.assertEqual(0, result[0].offset) + self.assertEqual(False, result[0].unsure) def test_finding_occurrences_in_more_than_one_module(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -33,7 +33,7 @@ def test_finding_occurrences_in_more_than_one_module(self): mod1.write('a_var = 1\n') mod2.write('import mod1\nmy_var = mod1.a_var') result = find_occurrences(self.project, mod1, 1) - self.assertEquals(2, len(result)) + self.assertEqual(2, len(result)) modules = (result[0].resource, result[1].resource) self.assertTrue(mod1 in modules and mod2 in modules) @@ -43,7 +43,7 @@ def test_finding_occurrences_matching_when_unsure(self): 'def f(arg):\n arg.a_func()\n') result = find_occurrences( self.project, mod1, mod1.read().index('a_func'), unsure=True) - self.assertEquals(2, len(result)) + self.assertEqual(2, len(result)) def test_find_occurrences_resources_parameter(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -51,8 +51,8 @@ def test_find_occurrences_resources_parameter(self): mod1.write('a_var = 1\n') mod2.write('import mod1\nmy_var = mod1.a_var') result = find_occurrences(self.project, mod1, 1, resources=[mod1]) - self.assertEquals(1, len(result)) - self.assertEquals((mod1, 0), (result[0].resource, result[0].offset)) + self.assertEqual(1, len(result)) + self.assertEqual((mod1, 0), (result[0].resource, result[0].offset)) def test_find_occurrences_and_class_hierarchies(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -62,15 +62,15 @@ def test_find_occurrences_and_class_hierarchies(self): result1 = find_occurrences(self.project, mod1, offset) result2 = find_occurrences(self.project, mod1, offset, in_hierarchy=True) - self.assertEquals(1, len(result1)) - self.assertEquals(2, len(result2)) + self.assertEqual(1, len(result1)) + self.assertEqual(2, len(result2)) def test_trivial_find_implementations(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write('class A(object):\n def f(self):\n pass\n') offset = mod1.read().rindex('f(') result = find_implementations(self.project, mod1, offset) - self.assertEquals([], result) + self.assertEqual([], result) def test_find_implementations_and_not_returning_parents(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -78,7 +78,7 @@ def test_find_implementations_and_not_returning_parents(self): 'class B(A):\n def f(self):\n pass\n') offset = mod1.read().rindex('f(') result = find_implementations(self.project, mod1, offset) - self.assertEquals([], result) + self.assertEqual([], result) def test_find_implementations_real_implementation(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -86,8 +86,8 @@ def test_find_implementations_real_implementation(self): 'class B(A):\n def f(self):\n pass\n') offset = mod1.read().index('f(') result = find_implementations(self.project, mod1, offset) - self.assertEquals(1, len(result)) - self.assertEquals(mod1.read().rindex('f('), result[0].offset) + self.assertEqual(1, len(result)) + self.assertEqual(mod1.read().rindex('f('), result[0].offset) def test_find_implementations_real_implementation_simple(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -100,18 +100,18 @@ def test_trivial_find_definition(self): code = 'def a_func():\n pass\na_func()' result = find_definition(self.project, code, code.rindex('a_func')) start = code.index('a_func') - self.assertEquals(start, result.offset) - self.assertEquals(None, result.resource) - self.assertEquals(1, result.lineno) - self.assertEquals((start, start + len('a_func')), result.region) + self.assertEqual(start, result.offset) + self.assertEqual(None, result.resource) + self.assertEqual(1, result.lineno) + self.assertEqual((start, start + len('a_func')), result.region) def test_find_definition_in_other_modules(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write('var = 1\n') code = 'import mod1\nprint(mod1.var)\n' result = find_definition(self.project, code, code.index('var')) - self.assertEquals(mod1, result.resource) - self.assertEquals(0, result.offset) + self.assertEqual(mod1, result.resource) + self.assertEqual(0, result.offset) def suite(): diff --git a/ropetest/contrib/fixmodnamestest.py b/ropetest/contrib/fixmodnamestest.py index 9fa364221..fa1ec8a9e 100644 --- a/ropetest/contrib/fixmodnamestest.py +++ b/ropetest/contrib/fixmodnamestest.py @@ -37,8 +37,8 @@ def test_fixing_contents(self): self.project.do(FixModuleNames(self.project).get_changes(_fixer)) newmod1 = self.project.get_resource('_od1.py') newmod2 = self.project.get_resource('_od2.py') - self.assertEquals('import _od2\n', newmod1.read()) - self.assertEquals('import _od1\n', newmod2.read()) + self.assertEqual('import _od2\n', newmod1.read()) + self.assertEqual('import _od1\n', newmod2.read()) def test_handling_nested_modules(self): pkg = create_package(self.project, 'xkg') diff --git a/ropetest/contrib/generatetest.py b/ropetest/contrib/generatetest.py index 48f9f913a..3a6a1817c 100644 --- a/ropetest/contrib/generatetest.py +++ b/ropetest/contrib/generatetest.py @@ -41,28 +41,28 @@ def test_getting_location(self): code = 'a_var = name\n' self.mod.write(code) generator = self._get_generate(code.index('name')) - self.assertEquals((self.mod, 1), generator.get_location()) + self.assertEqual((self.mod, 1), generator.get_location()) def test_generating_variable(self): code = 'a_var = name\n' self.mod.write(code) changes = self._get_generate(code.index('name')).get_changes() self.project.do(changes) - self.assertEquals('name = None\n\n\na_var = name\n', self.mod.read()) + self.assertEqual('name = None\n\n\na_var = name\n', self.mod.read()) def test_generating_variable_inserting_before_statement(self): code = 'c = 1\nc = b\n' self.mod.write(code) changes = self._get_generate(code.index('b')).get_changes() self.project.do(changes) - self.assertEquals('c = 1\nb = None\n\n\nc = b\n', self.mod.read()) + self.assertEqual('c = 1\nb = None\n\n\nc = b\n', self.mod.read()) def test_generating_variable_in_local_scopes(self): code = 'def f():\n c = 1\n c = b\n' self.mod.write(code) changes = self._get_generate(code.index('b')).get_changes() self.project.do(changes) - self.assertEquals('def f():\n c = 1\n b = None\n c = b\n', + self.assertEqual('def f():\n c = 1\n b = None\n c = b\n', self.mod.read()) def test_generating_variable_in_other_modules(self): @@ -70,8 +70,8 @@ def test_generating_variable_in_other_modules(self): self.mod.write(code) generator = self._get_generate(code.index('b')) self.project.do(generator.get_changes()) - self.assertEquals((self.mod2, 1), generator.get_location()) - self.assertEquals('b = None\n', self.mod2.read()) + self.assertEqual((self.mod2, 1), generator.get_location()) + self.assertEqual('b = None\n', self.mod2.read()) def test_generating_variable_in_classes(self): code = 'class C(object):\n def f(self):\n pass\n' \ @@ -79,7 +79,7 @@ def test_generating_variable_in_classes(self): self.mod.write(code) changes = self._get_generate(code.index('attr')).get_changes() self.project.do(changes) - self.assertEquals( + self.assertEqual( 'class C(object):\n def f(self):\n ' 'pass\n\n attr = None\n' 'c = C()\na_var = c.attr', self.mod.read()) @@ -89,7 +89,7 @@ def test_generating_variable_in_classes_removing_pass(self): self.mod.write(code) changes = self._get_generate(code.index('attr')).get_changes() self.project.do(changes) - self.assertEquals('class C(object):\n\n attr = None\n' + self.assertEqual('class C(object):\n\n attr = None\n' 'c = C()\na_var = c.attr', self.mod.read()) def test_generating_variable_in_packages(self): @@ -98,15 +98,15 @@ def test_generating_variable_in_packages(self): generator = self._get_generate(code.rindex('a')) self.project.do(generator.get_changes()) init = self.pkg.get_child('__init__.py') - self.assertEquals((init, 1), generator.get_location()) - self.assertEquals('a = None\n', init.read()) + self.assertEqual((init, 1), generator.get_location()) + self.assertEqual('a = None\n', init.read()) def test_generating_classes(self): code = 'c = C()\n' self.mod.write(code) changes = self._get_generate_class(code.index('C')).get_changes() self.project.do(changes) - self.assertEquals('class C(object):\n pass\n\n\nc = C()\n', + self.assertEqual('class C(object):\n pass\n\n\nc = C()\n', self.mod.read()) def test_generating_modules(self): @@ -115,8 +115,8 @@ def test_generating_modules(self): generator = self._get_generate_module(code.rindex('mod')) self.project.do(generator.get_changes()) mod = self.pkg.get_child('mod.py') - self.assertEquals((mod, 1), generator.get_location()) - self.assertEquals('import pkg.mod\npkg.mod\n', self.mod.read()) + self.assertEqual((mod, 1), generator.get_location()) + self.assertEqual('import pkg.mod\npkg.mod\n', self.mod.read()) def test_generating_packages(self): code = 'import pkg\npkg.pkg2\n' @@ -125,8 +125,8 @@ def test_generating_packages(self): self.project.do(generator.get_changes()) pkg2 = self.pkg.get_child('pkg2') init = pkg2.get_child('__init__.py') - self.assertEquals((init, 1), generator.get_location()) - self.assertEquals('import pkg.pkg2\npkg.pkg2\n', self.mod.read()) + self.assertEqual((init, 1), generator.get_location()) + self.assertEqual('import pkg.pkg2\npkg.pkg2\n', self.mod.read()) def test_generating_function(self): code = 'a_func()\n' @@ -134,7 +134,7 @@ def test_generating_function(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEquals('def a_func():\n pass\n\n\na_func()\n', + self.assertEqual('def a_func():\n pass\n\n\na_func()\n', self.mod.read()) def test_generating_modules_with_empty_primary(self): @@ -143,8 +143,8 @@ def test_generating_modules_with_empty_primary(self): generator = self._get_generate_module(code.rindex('mod')) self.project.do(generator.get_changes()) mod = self.project.root.get_child('mod.py') - self.assertEquals((mod, 1), generator.get_location()) - self.assertEquals('import mod\nmod\n', self.mod.read()) + self.assertEqual((mod, 1), generator.get_location()) + self.assertEqual('import mod\nmod\n', self.mod.read()) def test_generating_variable_already_exists(self): code = 'b = 1\nc = b\n' @@ -171,7 +171,7 @@ def test_generating_static_methods(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEquals( + self.assertEqual( 'class C(object):\n\n @staticmethod' '\n def a_func():\n pass\nC.a_func()\n', self.mod.read()) @@ -182,7 +182,7 @@ def test_generating_methods(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEquals( + self.assertEqual( 'class C(object):\n\n def a_func(self):\n pass\n' 'c = C()\nc.a_func()\n', self.mod.read()) @@ -192,7 +192,7 @@ def test_generating_constructors(self): self.mod.write(code) changes = self._get_generate_function(code.rindex('C')).get_changes() self.project.do(changes) - self.assertEquals( + self.assertEqual( 'class C(object):\n\n def __init__(self):\n pass\n' 'c = C()\n', self.mod.read()) @@ -202,7 +202,7 @@ def test_generating_calls(self): self.mod.write(code) changes = self._get_generate_function(code.rindex('c')).get_changes() self.project.do(changes) - self.assertEquals( + self.assertEqual( 'class C(object):\n\n def __call__(self):\n pass\n' 'c = C()\nc()\n', self.mod.read()) @@ -213,7 +213,7 @@ def test_generating_calls_in_other_modules(self): self.mod.write(code) changes = self._get_generate_function(code.rindex('c')).get_changes() self.project.do(changes) - self.assertEquals( + self.assertEqual( 'class C(object):\n\n def __call__(self):\n pass\n', self.mod2.read()) @@ -223,7 +223,7 @@ def test_generating_function_handling_arguments(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEquals('def a_func(arg0):\n pass\n\n\na_func(1)\n', + self.assertEqual('def a_func(arg0):\n pass\n\n\na_func(1)\n', self.mod.read()) def test_generating_function_handling_keyword_xarguments(self): @@ -232,7 +232,7 @@ def test_generating_function_handling_keyword_xarguments(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEquals('def a_func(p):\n pass\n\n\na_func(p=1)\n', + self.assertEqual('def a_func(p):\n pass\n\n\na_func(p=1)\n', self.mod.read()) def test_generating_function_handling_arguments_better_naming(self): @@ -241,7 +241,7 @@ def test_generating_function_handling_arguments_better_naming(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEquals('a_var = 1\ndef a_func(a_var):' + self.assertEqual('a_var = 1\ndef a_func(a_var):' '\n pass\n\n\na_func(a_var)\n', self.mod.read()) @@ -251,8 +251,8 @@ def test_generating_variable_in_other_modules2(self): self.mod.write(code) generator = self._get_generate(code.index('b')) self.project.do(generator.get_changes()) - self.assertEquals((self.mod2, 5), generator.get_location()) - self.assertEquals('\n\n\nprint(1)\n\n\nb = None\n', self.mod2.read()) + self.assertEqual((self.mod2, 5), generator.get_location()) + self.assertEqual('\n\n\nprint(1)\n\n\nb = None\n', self.mod2.read()) def test_generating_function_in_a_suite(self): code = 'if True:\n a_func()\n' @@ -260,7 +260,7 @@ def test_generating_function_in_a_suite(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEquals('def a_func():\n pass' + self.assertEqual('def a_func():\n pass' '\n\n\nif True:\n a_func()\n', self.mod.read()) @@ -269,7 +269,7 @@ def test_generating_function_in_a_suite_in_a_function(self): self.mod.write(code) changes = self._get_generate_function(code.index('g()')).get_changes() self.project.do(changes) - self.assertEquals( + self.assertEqual( 'def f():\n a = 1\n def g():\n pass\n' ' if 1:\n g()\n', self.mod.read()) diff --git a/ropetest/historytest.py b/ropetest/historytest.py index 2eaa92caf..c278733fb 100644 --- a/ropetest/historytest.py +++ b/ropetest/historytest.py @@ -24,20 +24,20 @@ def test_undoing_writes(self): my_file = self.project.root.create_file('my_file.txt') my_file.write('text1') self.history.undo() - self.assertEquals('', my_file.read()) + self.assertEqual('', my_file.read()) def test_moving_files(self): my_file = self.project.root.create_file('my_file.txt') my_file.move('new_file.txt') self.history.undo() - self.assertEquals('', my_file.read()) + self.assertEqual('', my_file.read()) def test_moving_files_to_folders(self): my_file = self.project.root.create_file('my_file.txt') my_folder = self.project.root.create_folder('my_folder') my_file.move(my_folder.path) self.history.undo() - self.assertEquals('', my_file.read()) + self.assertEqual('', my_file.read()) def test_writing_files_that_does_not_change_contents(self): my_file = self.project.root.create_file('my_file.txt') @@ -62,27 +62,27 @@ def tearDown(self): def test_simple_undo(self): change = rope.base.change.ChangeContents(self.file1, '1') self.history.do(change) - self.assertEquals('1', self.file1.read()) + self.assertEqual('1', self.file1.read()) self.history.undo() - self.assertEquals('', self.file1.read()) + self.assertEqual('', self.file1.read()) def test_tobe_undone(self): change1 = rope.base.change.ChangeContents(self.file1, '1') - self.assertEquals(None, self.history.tobe_undone) + self.assertEqual(None, self.history.tobe_undone) self.history.do(change1) - self.assertEquals(change1, self.history.tobe_undone) + self.assertEqual(change1, self.history.tobe_undone) change2 = rope.base.change.ChangeContents(self.file1, '2') self.history.do(change2) - self.assertEquals(change2, self.history.tobe_undone) + self.assertEqual(change2, self.history.tobe_undone) self.history.undo() - self.assertEquals(change1, self.history.tobe_undone) + self.assertEqual(change1, self.history.tobe_undone) def test_tobe_redone(self): change = rope.base.change.ChangeContents(self.file1, '1') self.history.do(change) - self.assertEquals(None, self.history.tobe_redone) + self.assertEqual(None, self.history.tobe_redone) self.history.undo() - self.assertEquals(change, self.history.tobe_redone) + self.assertEqual(change, self.history.tobe_redone) def test_undo_limit(self): history = rope.base.history.History(self.project, maxundos=1) @@ -93,14 +93,14 @@ def test_undo_limit(self): with self.assertRaises(exceptions.HistoryError): history.undo() finally: - self.assertEquals('1', self.file1.read()) + self.assertEqual('1', self.file1.read()) def test_simple_redo(self): change = rope.base.change.ChangeContents(self.file1, '1') self.history.do(change) self.history.undo() self.history.redo() - self.assertEquals('1', self.file1.read()) + self.assertEqual('1', self.file1.read()) def test_simple_re_undo(self): change = rope.base.change.ChangeContents(self.file1, '1') @@ -108,7 +108,7 @@ def test_simple_re_undo(self): self.history.undo() self.history.redo() self.history.undo() - self.assertEquals('', self.file1.read()) + self.assertEqual('', self.file1.read()) def test_multiple_undos(self): change = rope.base.change.ChangeContents(self.file1, '1') @@ -116,13 +116,13 @@ def test_multiple_undos(self): change = rope.base.change.ChangeContents(self.file1, '2') self.history.do(change) self.history.undo() - self.assertEquals('1', self.file1.read()) + self.assertEqual('1', self.file1.read()) change = rope.base.change.ChangeContents(self.file1, '3') self.history.do(change) self.history.undo() - self.assertEquals('1', self.file1.read()) + self.assertEqual('1', self.file1.read()) self.history.redo() - self.assertEquals('3', self.file1.read()) + self.assertEqual('3', self.file1.read()) def test_undo_list_underflow(self): with self.assertRaises(exceptions.HistoryError): @@ -142,7 +142,7 @@ def test_undoing_choosen_changes(self): change = rope.base.change.ChangeContents(self.file1, '1') self.history.do(change) self.history.undo(change) - self.assertEquals('', self.file1.read()) + self.assertEqual('', self.file1.read()) self.assertFalse(self.history.undo_list) def test_undoing_choosen_changes2(self): @@ -150,7 +150,7 @@ def test_undoing_choosen_changes2(self): self.history.do(change1) self.history.do(rope.base.change.ChangeContents(self.file1, '2')) self.history.undo(change1) - self.assertEquals('', self.file1.read()) + self.assertEqual('', self.file1.read()) self.assertFalse(self.history.undo_list) def test_undoing_choosen_changes_not_undoing_others(self): @@ -158,8 +158,8 @@ def test_undoing_choosen_changes_not_undoing_others(self): self.history.do(change1) self.history.do(rope.base.change.ChangeContents(self.file2, '2')) self.history.undo(change1) - self.assertEquals('', self.file1.read()) - self.assertEquals('2', self.file2.read()) + self.assertEqual('', self.file1.read()) + self.assertEqual('2', self.file2.read()) def test_undoing_writing_after_moving(self): change1 = rope.base.change.ChangeContents(self.file1, '1') @@ -167,7 +167,7 @@ def test_undoing_writing_after_moving(self): self.history.do(rope.base.change.MoveResource(self.file1, 'file3.txt')) file3 = self.project.get_resource('file3.txt') self.history.undo(change1) - self.assertEquals('', self.file1.read()) + self.assertEqual('', self.file1.read()) self.assertFalse(file3.exists()) def test_undoing_folder_movements_for_undoing_writes_inside_it(self): @@ -178,7 +178,7 @@ def test_undoing_folder_movements_for_undoing_writes_inside_it(self): self.history.do(rope.base.change.MoveResource(folder, 'new_folder')) new_folder = self.project.get_resource('new_folder') self.history.undo(change1) - self.assertEquals('', file3.read()) + self.assertEqual('', file3.read()) self.assertFalse(new_folder.exists()) def test_undoing_changes_that_depend_on_a_dependant_change(self): @@ -192,8 +192,8 @@ def test_undoing_changes_that_depend_on_a_dependant_change(self): file3 = self.project.get_resource('file3.txt') self.history.undo(change1) - self.assertEquals('', self.file1.read()) - self.assertEquals('', self.file2.read()) + self.assertEqual('', self.file1.read()) + self.assertEqual('', self.file2.read()) self.assertFalse(file3.exists()) def test_undoing_writes_for_undoing_folder_movements_containing_it(self): @@ -204,7 +204,7 @@ def test_undoing_writes_for_undoing_folder_movements_containing_it(self): new_file = self.project.get_resource('new_folder/file3.txt') self.history.do(rope.base.change.ChangeContents(new_file, '1')) self.history.undo(change1) - self.assertEquals('', old_file.read()) + self.assertEqual('', old_file.read()) self.assertFalse(new_file.exists()) def test_undoing_not_available_change(self): @@ -218,18 +218,18 @@ def test_ignoring_ignored_resources(self): change = rope.base.change.CreateResource(ignored) self.history.do(change) self.assertTrue(ignored.exists()) - self.assertEquals(0, len(self.history.undo_list)) + self.assertEqual(0, len(self.history.undo_list)) def test_get_file_undo_list_simple(self): change = rope.base.change.ChangeContents(self.file1, '1') self.history.do(change) - self.assertEquals(set([change]), + self.assertEqual(set([change]), set(self.history.get_file_undo_list(self.file1))) def test_get_file_undo_list_for_moves(self): change = rope.base.change.MoveResource(self.file1, 'file2.txt') self.history.do(change) - self.assertEquals(set([change]), + self.assertEqual(set([change]), set(self.history.get_file_undo_list(self.file1))) # XXX: What happens for moves before the file is created? @@ -238,7 +238,7 @@ def xxx_test_get_file_undo_list_and_moving_its_contining_folder(self): old_file = folder.create_file('file3.txt') change1 = rope.base.change.MoveResource(folder, 'new_folder') self.history.do(change1) - self.assertEquals(set([change1]), + self.assertEqual(set([change1]), set(self.history.get_file_undo_list(old_file))) def test_clearing_redo_list_after_do(self): @@ -246,7 +246,7 @@ def test_clearing_redo_list_after_do(self): self.history.do(change) self.history.undo() self.history.do(change) - self.assertEquals(0, len(self.history.redo_list)) + self.assertEqual(0, len(self.history.redo_list)) def test_undoing_a_not_yet_performed_change(self): change = rope.base.change.ChangeContents(self.file1, '1') @@ -261,8 +261,8 @@ def test_clearing_up_the_history(self): self.history.do(change2) self.history.undo() self.history.clear() - self.assertEquals(0, len(self.history.undo_list)) - self.assertEquals(0, len(self.history.redo_list)) + self.assertEqual(0, len(self.history.undo_list)) + self.assertEqual(0, len(self.history.redo_list)) def test_redoing_choosen_changes_not_undoing_others(self): change1 = rope.base.change.ChangeContents(self.file1, '1') @@ -272,9 +272,9 @@ def test_redoing_choosen_changes_not_undoing_others(self): self.history.undo() self.history.undo() redone = self.history.redo(change2) - self.assertEquals([change2], redone) - self.assertEquals('', self.file1.read()) - self.assertEquals('2', self.file2.read()) + self.assertEqual([change2], redone) + self.assertEqual('', self.file1.read()) + self.assertEqual('2', self.file2.read()) class SavingHistoryTest(unittest.TestCase): @@ -293,7 +293,7 @@ def tearDown(self): def test_simple_set_saving(self): data = self.to_data(rope.base.change.ChangeSet('testing')) change = self.to_change(data) - self.assertEquals('testing', str(change)) + self.assertEqual('testing', str(change)) def test_simple_change_content_saving(self): myfile = self.project.get_file('myfile.txt') @@ -302,9 +302,9 @@ def test_simple_change_content_saving(self): data = self.to_data(rope.base.change.ChangeContents(myfile, '2')) change = self.to_change(data) self.history.do(change) - self.assertEquals('2', myfile.read()) + self.assertEqual('2', myfile.read()) self.history.undo() - self.assertEquals('1', change.old_contents) + self.assertEqual('1', change.old_contents) def test_move_resource_saving(self): myfile = self.project.root.create_file('myfile.txt') @@ -375,7 +375,7 @@ def test_change_set_saving(self): data = self.to_data(change) change = self.to_change(data) self.history.do(change) - self.assertEquals('1', myfile.read()) + self.assertEqual('1', myfile.read()) self.history.undo() self.assertFalse(myfile.exists()) diff --git a/ropetest/objectdbtest.py b/ropetest/objectdbtest.py index ab59084b2..a104a7786 100644 --- a/ropetest/objectdbtest.py +++ b/ropetest/objectdbtest.py @@ -59,87 +59,87 @@ def test_simple_per_name(self, db): @_do_for_all_dbs def test_simple_per_name_does_not_exist(self, db): - self.assertEquals(None, db.get_pername('file', 'key', 'name')) + self.assertEqual(None, db.get_pername('file', 'key', 'name')) @_do_for_all_dbs def test_simple_per_name_after_syncing(self, db): db.add_pername('file', 'key', 'name', 1) db.write() - self.assertEquals(1, db.get_pername('file', 'key', 'name')) + self.assertEqual(1, db.get_pername('file', 'key', 'name')) @_do_for_all_dbs def test_getting_returned(self, db): db.add_callinfo('file', 'key', (1, 2), 3) - self.assertEquals(3, db.get_returned('file', 'key', (1, 2))) + self.assertEqual(3, db.get_returned('file', 'key', (1, 2))) @_do_for_all_dbs def test_getting_returned_when_does_not_match(self, db): db.add_callinfo('file', 'key', (1, 2), 3) - self.assertEquals(None, db.get_returned('file', 'key', (1, 1))) + self.assertEqual(None, db.get_returned('file', 'key', (1, 1))) @_do_for_all_dbs def test_getting_call_info(self, db): db.add_callinfo('file', 'key', (1, 2), 3) call_infos = list(db.get_callinfos('file', 'key')) - self.assertEquals(1, len(call_infos)) - self.assertEquals((1, 2), call_infos[0].get_parameters()) - self.assertEquals(3, call_infos[0].get_returned()) + self.assertEqual(1, len(call_infos)) + self.assertEqual((1, 2), call_infos[0].get_parameters()) + self.assertEqual(3, call_infos[0].get_returned()) @_do_for_all_dbs def test_invalid_per_name(self, db): db.add_pername('file', 'key', 'name', -1) - self.assertEquals(None, db.get_pername('file', 'key', 'name')) + self.assertEqual(None, db.get_pername('file', 'key', 'name')) @_do_for_all_dbs def test_overwriting_per_name(self, db): db.add_pername('file', 'key', 'name', 1) db.add_pername('file', 'key', 'name', 2) - self.assertEquals(2, db.get_pername('file', 'key', 'name')) + self.assertEqual(2, db.get_pername('file', 'key', 'name')) @_do_for_all_dbs def test_not_overwriting_with_invalid_per_name(self, db): db.add_pername('file', 'key', 'name', 1) db.add_pername('file', 'key', 'name', -1) - self.assertEquals(1, db.get_pername('file', 'key', 'name')) + self.assertEqual(1, db.get_pername('file', 'key', 'name')) @_do_for_all_dbs def test_getting_invalid_returned(self, db): db.add_callinfo('file', 'key', (1, 2), -1) - self.assertEquals(None, db.get_returned('file', 'key', (1, 2))) + self.assertEqual(None, db.get_returned('file', 'key', (1, 2))) @_do_for_all_dbs def test_not_overwriting_with_invalid_returned(self, db): db.add_callinfo('file', 'key', (1, 2), 3) db.add_callinfo('file', 'key', (1, 2), -1) - self.assertEquals(3, db.get_returned('file', 'key', (1, 2))) + self.assertEqual(3, db.get_returned('file', 'key', (1, 2))) @_do_for_all_dbs def test_get_files(self, db): db.add_callinfo('file1', 'key', (1, 2), 3) db.add_callinfo('file2', 'key', (1, 2), 3) - self.assertEquals(set(['file1', 'file2']), set(db.get_files())) + self.assertEqual(set(['file1', 'file2']), set(db.get_files())) @_do_for_all_dbs def test_validating_files(self, db): db.add_callinfo('invalid', 'key', (1, 2), 3) db.validate_files() - self.assertEquals(0, len(db.get_files())) + self.assertEqual(0, len(db.get_files())) @_do_for_all_dbs def test_validating_file_for_scopes(self, db): db.add_callinfo('file', 'invalid', (1, 2), 3) db.validate_file('file') - self.assertEquals(1, len(db.get_files())) - self.assertEquals(0, len(list(db.get_callinfos('file', 'invalid')))) + self.assertEqual(1, len(db.get_files())) + self.assertEqual(0, len(list(db.get_callinfos('file', 'invalid')))) @_do_for_all_dbs def test_validating_file_moved(self, db): db.add_callinfo('file', 'key', (1, 2), 3) db.file_moved('file', 'newfile') - self.assertEquals(1, len(db.get_files())) - self.assertEquals(1, len(list(db.get_callinfos('newfile', 'key')))) + self.assertEqual(1, len(db.get_files())) + self.assertEqual(1, len(list(db.get_callinfos('newfile', 'key')))) @_do_for_all_dbs def test_using_file_list_observer(self, db): @@ -147,7 +147,7 @@ def test_using_file_list_observer(self, db): observer = _MockFileListObserver() db.add_file_list_observer(observer) db.validate_files() - self.assertEquals('removed invalid ', observer.log) + self.assertEqual('removed invalid ', observer.log) def suite(): diff --git a/ropetest/objectinfertest.py b/ropetest/objectinfertest.py index ca8c29a08..e7ae45692 100644 --- a/ropetest/objectinfertest.py +++ b/ropetest/objectinfertest.py @@ -21,7 +21,7 @@ def test_simple_type_inferencing(self): scope = libutils.get_string_scope(self.project, code) sample_class = scope['Sample'].get_object() a_var = scope['a_var'].get_object() - self.assertEquals(sample_class, a_var.get_type()) + self.assertEqual(sample_class, a_var.get_type()) def test_simple_type_inferencing_classes_defined_in_holding_scope(self): code = 'class Sample(object):\n pass\n' \ @@ -30,7 +30,7 @@ def test_simple_type_inferencing_classes_defined_in_holding_scope(self): sample_class = scope['Sample'].get_object() a_var = scope['a_func'].get_object().\ get_scope()['a_var'].get_object() - self.assertEquals(sample_class, a_var.get_type()) + self.assertEqual(sample_class, a_var.get_type()) def test_simple_type_inferencing_classes_in_class_methods(self): code = 'class Sample(object):\n pass\n' \ @@ -41,7 +41,7 @@ def test_simple_type_inferencing_classes_in_class_methods(self): another_class = scope['Another'].get_object() a_var = another_class['a_method'].\ get_object().get_scope()['a_var'].get_object() - self.assertEquals(sample_class, a_var.get_type()) + self.assertEqual(sample_class, a_var.get_type()) def test_simple_type_inferencing_class_attributes(self): code = 'class Sample(object):\n pass\n' \ @@ -51,7 +51,7 @@ def test_simple_type_inferencing_class_attributes(self): sample_class = scope['Sample'].get_object() another_class = scope['Another'].get_object() a_var = another_class['a_var'].get_object() - self.assertEquals(sample_class, a_var.get_type()) + self.assertEqual(sample_class, a_var.get_type()) def test_simple_type_inferencing_for_in_class_assignments(self): code = 'class Sample(object):\n pass\n' \ @@ -60,7 +60,7 @@ def test_simple_type_inferencing_for_in_class_assignments(self): sample_class = scope['Sample'].get_object() another_class = scope['Another'].get_object() an_attr = another_class['an_attr'].get_object() - self.assertEquals(sample_class, an_attr.get_type()) + self.assertEqual(sample_class, an_attr.get_type()) def test_simple_type_inferencing_for_chained_assignments(self): mod = 'class Sample(object):\n pass\n' \ @@ -68,7 +68,7 @@ def test_simple_type_inferencing_for_chained_assignments(self): mod_scope = libutils.get_string_scope(self.project, mod) sample_class = mod_scope['Sample'] copied_sample = mod_scope['copied_sample'] - self.assertEquals(sample_class.get_object(), + self.assertEqual(sample_class.get_object(), copied_sample.get_object()) def test_following_chained_assignments_avoiding_circles(self): @@ -78,7 +78,7 @@ def test_following_chained_assignments_avoiding_circles(self): mod_scope = libutils.get_string_scope(self.project, mod) sample_class = mod_scope['Sample'] sample_class_var = mod_scope['sample_class'] - self.assertEquals(sample_class.get_object(), + self.assertEqual(sample_class.get_object(), sample_class_var.get_object()) def test_function_returned_object_static_type_inference1(self): @@ -88,7 +88,7 @@ def test_function_returned_object_static_type_inference1(self): scope = libutils.get_string_scope(self.project, src) sample_class = scope['Sample'] a_var = scope['a_var'] - self.assertEquals(sample_class.get_object(), a_var.get_object()) + self.assertEqual(sample_class.get_object(), a_var.get_object()) def test_function_returned_object_static_type_inference2(self): src = 'class Sample(object):\n pass\n' \ @@ -97,7 +97,7 @@ def test_function_returned_object_static_type_inference2(self): scope = libutils.get_string_scope(self.project, src) sample_class = scope['Sample'].get_object() a_var = scope['a_var'].get_object() - self.assertEquals(sample_class, a_var.get_type()) + self.assertEqual(sample_class, a_var.get_type()) def test_recursive_function_returned_object_static_type_inference(self): src = 'class Sample(object):\n pass\n' \ @@ -108,7 +108,7 @@ def test_recursive_function_returned_object_static_type_inference(self): scope = libutils.get_string_scope(self.project, src) sample_class = scope['Sample'].get_object() a_var = scope['a_var'].get_object() - self.assertEquals(sample_class, a_var.get_type()) + self.assertEqual(sample_class, a_var.get_type()) def test_func_returned_obj_using_call_spec_func_static_type_infer(self): src = 'class Sample(object):\n' \ @@ -117,7 +117,7 @@ def test_func_returned_obj_using_call_spec_func_static_type_infer(self): scope = libutils.get_string_scope(self.project, src) sample_class = scope['Sample'] a_var = scope['a_var'] - self.assertEquals(sample_class.get_object(), a_var.get_object()) + self.assertEqual(sample_class.get_object(), a_var.get_object()) def test_list_type_inferencing(self): src = 'class Sample(object):\n pass\na_var = [Sample()]\n' @@ -133,7 +133,7 @@ def test_attributed_object_inference(self): scope = libutils.get_string_scope(self.project, src) sample_class = scope['Sample'].get_object() a_var = sample_class['a_var'].get_object() - self.assertEquals(sample_class, a_var.get_type()) + self.assertEqual(sample_class, a_var.get_type()) def test_getting_property_attributes(self): src = 'class A(object):\n pass\n' \ @@ -143,7 +143,7 @@ def test_getting_property_attributes(self): pymod = libutils.get_string_module(self.project, src) a_class = pymod['A'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(a_class, a_var.get_type()) + self.assertEqual(a_class, a_var.get_type()) def test_getting_property_attributes_with_method_getters(self): src = 'class A(object):\n pass\n' \ @@ -153,7 +153,7 @@ def test_getting_property_attributes_with_method_getters(self): pymod = libutils.get_string_module(self.project, src) a_class = pymod['A'].get_object() a_var = pymod['a_var'].get_object() - self.assertEquals(a_class, a_var.get_type()) + self.assertEqual(a_class, a_var.get_type()) def test_lambda_functions(self): code = 'class C(object):\n pass\n' \ @@ -161,7 +161,7 @@ def test_lambda_functions(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_mixing_subscript_with_tuple_assigns(self): code = 'class C(object):\n attr = 0\n' \ @@ -169,7 +169,7 @@ def test_mixing_subscript_with_tuple_assigns(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['b'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_mixing_ass_attr_with_tuple_assignment(self): code = 'class C(object):\n attr = 0\n' \ @@ -177,7 +177,7 @@ def test_mixing_ass_attr_with_tuple_assignment(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['b'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_mixing_slice_with_tuple_assigns(self): mod = libutils.get_string_module( @@ -186,7 +186,7 @@ def test_mixing_slice_with_tuple_assigns(self): 'd = [None] * 3\nd[0:2], b = ((0,), C())\n') c_class = mod['C'].get_object() a_var = mod['b'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_nested_tuple_assignments(self): mod = libutils.get_string_module( @@ -198,9 +198,9 @@ def test_nested_tuple_assignments(self): a_var = mod['a'].get_object() b_var = mod['b'].get_object() c_var = mod['c'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) - self.assertEquals(c1_class, c_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) + self.assertEqual(c1_class, c_var.get_type()) def test_empty_tuples(self): mod = libutils.get_string_module( @@ -214,7 +214,7 @@ def test_handling_generator_functions(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_handling_generator_functions_for_strs(self): mod = testutils.create_module(self.project, 'mod') @@ -230,7 +230,7 @@ def test_considering_nones_to_be_unknowns(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_basic_list_comprehensions(self): code = 'class C(object):\n pass\n' \ @@ -238,7 +238,7 @@ def test_basic_list_comprehensions(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_basic_generator_expressions(self): code = 'class C(object):\n pass\n' \ @@ -246,7 +246,7 @@ def test_basic_generator_expressions(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_list_comprehensions_and_loop_var(self): code = 'class C(object):\n pass\n' \ @@ -255,7 +255,7 @@ def test_list_comprehensions_and_loop_var(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEquals(c_class, a_var.get_type()) + self.assertEqual(c_class, a_var.get_type()) def test_list_comprehensions_and_multiple_loop_var(self): code = 'class C1(object):\n pass\n' \ @@ -267,8 +267,8 @@ def test_list_comprehensions_and_multiple_loop_var(self): c2_class = mod['C2'].get_object() a_var = mod['a'].get_object() b_var = mod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_list_comprehensions_and_multiple_iters(self): mod = libutils.get_string_module( @@ -280,8 +280,8 @@ def test_list_comprehensions_and_multiple_iters(self): c2_class = mod['C2'].get_object() a_var = mod['a'].get_object() b_var = mod['b'].get_object() - self.assertEquals(c1_class, a_var.get_type()) - self.assertEquals(c2_class, b_var.get_type()) + self.assertEqual(c1_class, a_var.get_type()) + self.assertEqual(c2_class, b_var.get_type()) def test_we_know_the_type_of_catched_exceptions(self): code = 'class MyError(Exception):\n pass\n' \ @@ -290,7 +290,7 @@ def test_we_know_the_type_of_catched_exceptions(self): mod = libutils.get_string_module(self.project, code) my_error = mod['MyError'].get_object() e_var = mod['e'].get_object() - self.assertEquals(my_error, e_var.get_type()) + self.assertEqual(my_error, e_var.get_type()) def test_we_know_the_type_of_catched_multiple_excepts(self): code = 'class MyError(Exception):\n pass\n' \ @@ -299,7 +299,7 @@ def test_we_know_the_type_of_catched_multiple_excepts(self): mod = libutils.get_string_module(self.project, code) my_error = mod['MyError'].get_object() e_var = mod['e'].get_object() - self.assertEquals(my_error, e_var.get_type()) + self.assertEqual(my_error, e_var.get_type()) def test_using_property_as_decorators(self): code = 'class A(object):\n pass\n' \ @@ -309,7 +309,7 @@ def test_using_property_as_decorators(self): mod = libutils.get_string_module(self.project, code) var = mod['var'].get_object() a = mod['A'].get_object() - self.assertEquals(a, var.get_type()) + self.assertEqual(a, var.get_type()) def test_using_property_as_decorators_and_passing_parameter(self): code = 'class B(object):\n' \ @@ -318,7 +318,7 @@ def test_using_property_as_decorators_and_passing_parameter(self): mod = libutils.get_string_module(self.project, code) var = mod['var'].get_object() a = mod['B'].get_object() - self.assertEquals(a, var.get_type()) + self.assertEqual(a, var.get_type()) def suite(): diff --git a/ropetest/projecttest.py b/ropetest/projecttest.py index 7c00f95f8..4fa67ed44 100644 --- a/ropetest/projecttest.py +++ b/ropetest/projecttest.py @@ -40,7 +40,7 @@ def tearDown(self): unittest.TestCase.tearDown(self) def test_project_creation(self): - self.assertEquals(_realpath(self.project_root), + self.assertEqual(_realpath(self.project_root), self.project.address) def test_getting_project_file(self): @@ -49,7 +49,7 @@ def test_getting_project_file(self): def test_project_file_reading(self): projectFile = self.project.get_resource(self.sample_file) - self.assertEquals('sample text\n', projectFile.read()) + self.assertEqual('sample text\n', projectFile.read()) def test_getting_not_existing_project_file(self): with self.assertRaises(ResourceNotFoundError): @@ -58,7 +58,7 @@ def test_getting_not_existing_project_file(self): def test_writing_in_project_files(self): project_file = self.project.get_resource(self.sample_file) project_file.write('another text\n') - self.assertEquals('another text\n', project_file.read()) + self.assertEqual('another text\n', project_file.read()) def test_creating_files(self): project_file = 'newfile.txt' @@ -114,8 +114,8 @@ def test_creating_file_inside_folder(self): parent_folder.create_file(file_name) file = self.project.get_resource(file_path) file.write('sample notes') - self.assertEquals(file_path, file.path) - self.assertEquals('sample notes', + self.assertEqual(file_path, file.path) + self.assertEqual('sample notes', open(os.path.join(self.project.address, file_path)).read()) @@ -165,31 +165,31 @@ def test_removing_nested_files(self): def test_file_get_name(self): file = self.project.get_resource(self.sample_file) - self.assertEquals(self.sample_file, file.name) + self.assertEqual(self.sample_file, file.name) file_name = 'nestedFile.txt' parent = self.project.get_resource(self.sample_folder) filePath = self.sample_folder + '/' + file_name parent.create_file(file_name) nestedFile = self.project.get_resource(filePath) - self.assertEquals(file_name, nestedFile.name) + self.assertEqual(file_name, nestedFile.name) def test_folder_get_name(self): folder = self.project.get_resource(self.sample_folder) - self.assertEquals(self.sample_folder, folder.name) + self.assertEqual(self.sample_folder, folder.name) def test_file_get_path(self): file = self.project.get_resource(self.sample_file) - self.assertEquals(self.sample_file, file.path) + self.assertEqual(self.sample_file, file.path) fileName = 'nestedFile.txt' parent = self.project.get_resource(self.sample_folder) filePath = self.sample_folder + '/' + fileName parent.create_file(fileName) nestedFile = self.project.get_resource(filePath) - self.assertEquals(filePath, nestedFile.path) + self.assertEqual(filePath, nestedFile.path) def test_folder_get_path(self): folder = self.project.get_resource(self.sample_folder) - self.assertEquals(self.sample_folder, folder.path) + self.assertEqual(self.sample_folder, folder.path) def test_is_folder(self): self.assertTrue(self.project.get_resource( @@ -199,7 +199,7 @@ def test_is_folder(self): def testget_children(self): children = self.project.get_resource(self.sample_folder).get_children() - self.assertEquals([], children) + self.assertEqual([], children) def test_nonempty_get_children(self): file_name = 'nestedfile.txt' @@ -207,8 +207,8 @@ def test_nonempty_get_children(self): parent = self.project.get_resource(self.sample_folder) parent.create_file(file_name) children = parent.get_children() - self.assertEquals(1, len(children)) - self.assertEquals(filePath, children[0].path) + self.assertEqual(1, len(children)) + self.assertEqual(filePath, children[0].path) def test_nonempty_get_children2(self): file_name = 'nestedfile.txt' @@ -219,7 +219,7 @@ def test_nonempty_get_children2(self): parent.create_file(file_name) parent.create_folder(folder_name) children = parent.get_children() - self.assertEquals(2, len(children)) + self.assertEqual(2, len(children)) self.assertTrue(filePath == children[0].path or filePath == children[1].path) self.assertTrue(folderPath == children[0].path or @@ -240,12 +240,12 @@ def test_does_not_fail_for_permission_denied(self): def test_getting_files(self): files = self.project.root.get_files() - self.assertEquals(1, len(files)) + self.assertEqual(1, len(files)) self.assertTrue(self.project.get_resource(self.sample_file) in files) def test_getting_folders(self): folders = self.project.root.get_folders() - self.assertEquals(1, len(folders)) + self.assertEqual(1, len(folders)) self.assertTrue(self.project.get_resource( self.sample_folder) in folders) @@ -254,45 +254,45 @@ def test_nested_folder_get_files(self): parent.create_file('file1.txt') parent.create_file('file2.txt') files = parent.get_files() - self.assertEquals(2, len(files)) + self.assertEqual(2, len(files)) self.assertTrue(self.project.get_resource('top/file2.txt') in files) - self.assertEquals(0, len(parent.get_folders())) + self.assertEqual(0, len(parent.get_folders())) def test_nested_folder_get_folders(self): parent = self.project.root.create_folder('top') parent.create_folder('dir1') parent.create_folder('dir2') folders = parent.get_folders() - self.assertEquals(2, len(folders)) + self.assertEqual(2, len(folders)) self.assertTrue(self.project.get_resource('top/dir1') in folders) - self.assertEquals(0, len(parent.get_files())) + self.assertEqual(0, len(parent.get_files())) def test_root_folder(self): root_folder = self.project.root - self.assertEquals(2, len(root_folder.get_children())) - self.assertEquals('', root_folder.path) - self.assertEquals('', root_folder.name) + self.assertEqual(2, len(root_folder.get_children())) + self.assertEqual('', root_folder.path) + self.assertEqual('', root_folder.name) def test_get_all_files(self): files = tuple(self.project.get_files()) - self.assertEquals(1, len(files)) - self.assertEquals(self.sample_file, files[0].name) + self.assertEqual(1, len(files)) + self.assertEqual(self.sample_file, files[0].name) def test_get_all_files_after_changing(self): - self.assertEquals(1, len(self.project.get_files())) + self.assertEqual(1, len(self.project.get_files())) myfile = self.project.root.create_file('myfile.txt') - self.assertEquals(2, len(self.project.get_files())) + self.assertEqual(2, len(self.project.get_files())) myfile.move('newfile.txt') - self.assertEquals(2, len(self.project.get_files())) + self.assertEqual(2, len(self.project.get_files())) self.project.get_file('newfile.txt').remove() - self.assertEquals(1, len(self.project.get_files())) + self.assertEqual(1, len(self.project.get_files())) def test_multifile_get_all_files(self): fileName = 'nestedFile.txt' parent = self.project.get_resource(self.sample_folder) parent.create_file(fileName) files = list(self.project.get_files()) - self.assertEquals(2, len(files)) + self.assertEqual(2, len(files)) self.assertTrue(fileName == files[0].name or fileName == files[1].name) def test_ignoring_dot_pyc_files_in_get_files(self): @@ -336,9 +336,9 @@ def test_folder_get_child(self): folder = self.project.root folder.create_file('myfile.txt') folder.create_folder('myfolder') - self.assertEquals(self.project.get_resource('myfile.txt'), + self.assertEqual(self.project.get_resource('myfile.txt'), folder.get_child('myfile.txt')) - self.assertEquals(self.project.get_resource('myfolder'), + self.assertEqual(self.project.get_resource('myfolder'), folder.get_child('myfolder')) def test_folder_get_child_nested(self): @@ -346,13 +346,13 @@ def test_folder_get_child_nested(self): folder = root.create_folder('myfolder') folder.create_file('myfile.txt') folder.create_folder('myfolder') - self.assertEquals(self.project.get_resource('myfolder/myfile.txt'), + self.assertEqual(self.project.get_resource('myfolder/myfile.txt'), folder.get_child('myfile.txt')) - self.assertEquals(self.project.get_resource('myfolder/myfolder'), + self.assertEqual(self.project.get_resource('myfolder/myfolder'), folder.get_child('myfolder')) def test_project_root_is_root_folder(self): - self.assertEquals('', self.project.root.path) + self.assertEqual('', self.project.root.path) def test_moving_files(self): root_folder = self.project.root @@ -384,7 +384,7 @@ def test_moving_files_and_resource_objects(self): my_file = root_folder.create_file('my_file.txt') old_hash = hash(my_file) my_file.move('my_other_file.txt') - self.assertEquals(old_hash, hash(my_file)) + self.assertEqual(old_hash, hash(my_file)) def test_file_encoding_reading(self): sample_file = self.project.root.create_file('my_file.txt') @@ -393,20 +393,20 @@ def test_file_encoding_reading(self): file = open(sample_file.real_path, 'wb') file.write(contents.encode('utf-8')) file.close() - self.assertEquals(contents, sample_file.read()) + self.assertEqual(contents, sample_file.read()) def test_file_encoding_writing(self): sample_file = self.project.root.create_file('my_file.txt') contents = (b'# -*- coding: utf-8 -*-\n' + b'\N{LATIN SMALL LETTER I WITH DIAERESIS}\n').decode('utf8') sample_file.write(contents) - self.assertEquals(contents, sample_file.read()) + self.assertEqual(contents, sample_file.read()) def test_using_utf8_when_writing_in_case_of_errors(self): sample_file = self.project.root.create_file('my_file.txt') contents = b'\n\N{LATIN SMALL LETTER I WITH DIAERESIS}\n'.decode('utf8') sample_file.write(contents) - self.assertEquals(contents, sample_file.read()) + self.assertEqual(contents, sample_file.read()) def test_encoding_declaration_in_the_second_line(self): sample_file = self.project.root.create_file('my_file.txt') @@ -414,7 +414,7 @@ def test_encoding_declaration_in_the_second_line(self): file = open(sample_file.real_path, 'wb') file.write(contents) file.close() - self.assertEquals(contents, sample_file.read().encode('latin-1')) + self.assertEqual(contents, sample_file.read().encode('latin-1')) def test_read_bytes(self): sample_file = self.project.root.create_file('my_file.txt') @@ -422,7 +422,7 @@ def test_read_bytes(self): file = open(sample_file.real_path, 'wb') file.write(contents) file.close() - self.assertEquals(contents, sample_file.read_bytes()) + self.assertEqual(contents, sample_file.read_bytes()) # TODO: Detecting utf-16 encoding def xxx_test_using_utf16(self): @@ -432,7 +432,7 @@ def xxx_test_using_utf16(self): file.write(contents.encode('utf-16')) file.close() sample_file.write(contents) - self.assertEquals(contents, sample_file.read()) + self.assertEqual(contents, sample_file.read()) # XXX: supporting utf_8_sig def xxx_test_file_encoding_reading_for_notepad_styles(self): @@ -442,7 +442,7 @@ def xxx_test_file_encoding_reading_for_notepad_styles(self): # file.write('\xef\xbb\xbf') file.write(contents.encode('utf-8-sig')) file.close() - self.assertEquals(contents, sample_file.read()) + self.assertEqual(contents, sample_file.read()) def test_using_project_get_file(self): myfile = self.project.get_file(self.sample_file) @@ -475,14 +475,14 @@ def test_exception_when_parent_does_not_exist(self): def test_simple_path_to_resource(self): myfile = self.project.root.create_file('myfile.txt') - self.assertEquals(myfile, path_to_resource(self.project, + self.assertEqual(myfile, path_to_resource(self.project, myfile.real_path)) - self.assertEquals(myfile, path_to_resource( + self.assertEqual(myfile, path_to_resource( self.project, myfile.real_path, type='file')) myfolder = self.project.root.create_folder('myfolder') - self.assertEquals(myfolder, path_to_resource(self.project, + self.assertEqual(myfolder, path_to_resource(self.project, myfolder.real_path)) - self.assertEquals(myfolder, path_to_resource( + self.assertEqual(myfolder, path_to_resource( self.project, myfolder.real_path, type='folder')) @testutils.skipNotPOSIX() @@ -493,31 +493,31 @@ def test_ignoring_symlinks_inside_project(self): path = os.path.join(self.project.address, 'linkedfile.txt') os.symlink(mod.real_path, path) files = self.project.root.get_files() - self.assertEquals(1, len(files)) + self.assertEqual(1, len(files)) finally: testutils.remove_project(project2) def test_getting_empty_source_folders(self): - self.assertEquals([], self.project.get_source_folders()) + self.assertEqual([], self.project.get_source_folders()) def test_root_source_folder(self): self.project.root.create_file('sample.py') source_folders = self.project.get_source_folders() - self.assertEquals(1, len(source_folders)) + self.assertEqual(1, len(source_folders)) self.assertTrue(self.project.root in source_folders) def test_root_source_folder2(self): self.project.root.create_file('mod1.py') self.project.root.create_file('mod2.py') source_folders = self.project.get_source_folders() - self.assertEquals(1, len(source_folders)) + self.assertEqual(1, len(source_folders)) self.assertTrue(self.project.root in source_folders) def test_src_source_folder(self): src = self.project.root.create_folder('src') src.create_file('sample.py') source_folders = self.project.get_source_folders() - self.assertEquals(1, len(source_folders)) + self.assertEqual(1, len(source_folders)) self.assertTrue(self.project.get_resource('src') in source_folders) def test_packages(self): @@ -525,7 +525,7 @@ def test_packages(self): pkg = src.create_folder('package') pkg.create_file('__init__.py') source_folders = self.project.get_source_folders() - self.assertEquals(1, len(source_folders)) + self.assertEqual(1, len(source_folders)) self.assertTrue(src in source_folders) def test_multi_source_folders(self): @@ -535,7 +535,7 @@ def test_multi_source_folders(self): test = self.project.root.create_folder('test') test.create_file('alltests.py') source_folders = self.project.get_source_folders() - self.assertEquals(2, len(source_folders)) + self.assertEqual(2, len(source_folders)) self.assertTrue(src in source_folders) self.assertTrue(test in source_folders) @@ -545,7 +545,7 @@ def test_multi_source_folders2(self): package = testutils.create_package(self.project, 'package', src) testutils.create_module(self.project, 'mod2', package) source_folders = self.project.get_source_folders() - self.assertEquals(2, len(source_folders)) + self.assertEqual(2, len(source_folders)) self.assertTrue(self.project.root in source_folders and src in source_folders) @@ -566,8 +566,8 @@ def test_resource_change_observer(self): sample_observer = _SampleObserver() self.project.add_observer(sample_observer) sample_file.write('a sample file version 2') - self.assertEquals(1, sample_observer.change_count) - self.assertEquals(sample_file, sample_observer.last_changed) + self.assertEqual(1, sample_observer.change_count) + self.assertEqual(sample_file, sample_observer.last_changed) def test_resource_change_observer_after_removal(self): sample_file = self.project.root.create_file('my_file.txt') @@ -576,8 +576,8 @@ def test_resource_change_observer_after_removal(self): self.project.add_observer(FilteredResourceObserver(sample_observer, [sample_file])) sample_file.remove() - self.assertEquals(1, sample_observer.change_count) - self.assertEquals(sample_file, sample_observer.last_removed) + self.assertEqual(1, sample_observer.change_count) + self.assertEqual(sample_file, sample_observer.last_removed) def test_resource_change_observer2(self): sample_file = self.project.root.create_file('my_file.txt') @@ -585,7 +585,7 @@ def test_resource_change_observer2(self): self.project.add_observer(sample_observer) self.project.remove_observer(sample_observer) sample_file.write('a sample file version 2') - self.assertEquals(0, sample_observer.change_count) + self.assertEqual(0, sample_observer.change_count) def test_resource_change_observer_for_folders(self): root_folder = self.project.root @@ -597,21 +597,21 @@ def test_resource_change_observer_for_folders(self): self.project.add_observer( FilteredResourceObserver(root_folder_observer, [root_folder])) my_file = my_folder.create_file('my_file.txt') - self.assertEquals(1, my_folder_observer.change_count) + self.assertEqual(1, my_folder_observer.change_count) my_file.move('another_file.txt') - self.assertEquals(2, my_folder_observer.change_count) - self.assertEquals(1, root_folder_observer.change_count) + self.assertEqual(2, my_folder_observer.change_count) + self.assertEqual(1, root_folder_observer.change_count) self.project.get_resource('another_file.txt').remove() - self.assertEquals(2, my_folder_observer.change_count) - self.assertEquals(2, root_folder_observer.change_count) + self.assertEqual(2, my_folder_observer.change_count) + self.assertEqual(2, root_folder_observer.change_count) def test_resource_change_observer_after_moving(self): sample_file = self.project.root.create_file('my_file.txt') sample_observer = _SampleObserver() self.project.add_observer(sample_observer) sample_file.move('new_file.txt') - self.assertEquals(1, sample_observer.change_count) - self.assertEquals((sample_file, + self.assertEqual(1, sample_observer.change_count) + self.assertEqual((sample_file, self.project.get_resource('new_file.txt')), sample_observer.last_moved) @@ -623,8 +623,8 @@ def test_revalidating_files(self): [my_file])) os.remove(my_file.real_path) self.project.validate(root) - self.assertEquals(my_file, sample_observer.last_removed) - self.assertEquals(1, sample_observer.change_count) + self.assertEqual(my_file, sample_observer.last_removed) + self.assertEqual(1, sample_observer.change_count) def test_revalidating_files_and_no_changes2(self): root = self.project.root @@ -633,8 +633,8 @@ def test_revalidating_files_and_no_changes2(self): self.project.add_observer(FilteredResourceObserver(sample_observer, [my_file])) self.project.validate(root) - self.assertEquals(None, sample_observer.last_moved) - self.assertEquals(0, sample_observer.change_count) + self.assertEqual(None, sample_observer.last_moved) + self.assertEqual(0, sample_observer.change_count) def test_revalidating_folders(self): root = self.project.root @@ -645,8 +645,8 @@ def test_revalidating_folders(self): [my_folder])) testutils.remove_recursively(my_folder.real_path) self.project.validate(root) - self.assertEquals(my_folder, sample_observer.last_removed) - self.assertEquals(1, sample_observer.change_count) + self.assertEqual(my_folder, sample_observer.last_removed) + self.assertEqual(1, sample_observer.change_count) def test_removing_and_adding_resources_to_filtered_observer(self): my_file = self.project.root.create_file('my_file.txt') @@ -654,13 +654,13 @@ def test_removing_and_adding_resources_to_filtered_observer(self): filtered_observer = FilteredResourceObserver(sample_observer) self.project.add_observer(filtered_observer) my_file.write('1') - self.assertEquals(0, sample_observer.change_count) + self.assertEqual(0, sample_observer.change_count) filtered_observer.add_resource(my_file) my_file.write('2') - self.assertEquals(1, sample_observer.change_count) + self.assertEqual(1, sample_observer.change_count) filtered_observer.remove_resource(my_file) my_file.write('3') - self.assertEquals(1, sample_observer.change_count) + self.assertEqual(1, sample_observer.change_count) def test_validation_and_changing_files(self): my_file = self.project.root.create_file('my_file.txt') @@ -672,7 +672,7 @@ def test_validation_and_changing_files(self): self._write_file(my_file.real_path) timekeeper.set_indicator(my_file, 1) self.project.validate(self.project.root) - self.assertEquals(1, sample_observer.change_count) + self.assertEqual(1, sample_observer.change_count) def test_validation_and_changing_files2(self): my_file = self.project.root.create_file('my_file.txt') @@ -683,9 +683,9 @@ def test_validation_and_changing_files2(self): timekeeper=timekeeper)) timekeeper.set_indicator(my_file, 1) my_file.write('hey') - self.assertEquals(1, sample_observer.change_count) + self.assertEqual(1, sample_observer.change_count) self.project.validate(self.project.root) - self.assertEquals(1, sample_observer.change_count) + self.assertEqual(1, sample_observer.change_count) def test_not_reporting_multiple_changes_to_folders(self): root = self.project.root @@ -696,9 +696,9 @@ def test_not_reporting_multiple_changes_to_folders(self): sample_observer, [root, file1, file2])) os.remove(file1.real_path) os.remove(file2.real_path) - self.assertEquals(0, sample_observer.change_count) + self.assertEqual(0, sample_observer.change_count) self.project.validate(self.project.root) - self.assertEquals(3, sample_observer.change_count) + self.assertEqual(3, sample_observer.change_count) def _write_file(self, path): my_file = open(path, 'w') @@ -713,7 +713,7 @@ def test_moving_and_being_interested_about_a_folder_and_a_child(self): sample_observer, [my_folder, my_file]) self.project.add_observer(filtered_observer) my_folder.move('new_folder') - self.assertEquals(2, sample_observer.change_count) + self.assertEqual(2, sample_observer.change_count) def test_contains_for_folders(self): folder1 = self.project.root.create_folder('folder') @@ -728,8 +728,8 @@ def test_validating_when_created(self): [my_file])) open(my_file.real_path, 'w').close() self.project.validate(root) - self.assertEquals(my_file, sample_observer.last_created) - self.assertEquals(1, sample_observer.change_count) + self.assertEqual(my_file, sample_observer.last_created) + self.assertEqual(1, sample_observer.change_count) def test_validating_twice_when_created(self): root = self.project.root @@ -740,8 +740,8 @@ def test_validating_twice_when_created(self): open(my_file.real_path, 'w').close() self.project.validate(root) self.project.validate(root) - self.assertEquals(my_file, sample_observer.last_created) - self.assertEquals(1, sample_observer.change_count) + self.assertEqual(my_file, sample_observer.last_created) + self.assertEqual(1, sample_observer.change_count) def test_changes_and_adding_resources(self): root = self.project.root # noqa @@ -752,17 +752,17 @@ def test_changes_and_adding_resources(self): self.project.add_observer(FilteredResourceObserver(sample_observer, [file1, file2])) file1.move(file2.path) - self.assertEquals(2, sample_observer.change_count) - self.assertEquals(file2, sample_observer.last_created) - self.assertEquals((file1, file2), sample_observer.last_moved) + self.assertEqual(2, sample_observer.change_count) + self.assertEqual(file2, sample_observer.last_created) + self.assertEqual((file1, file2), sample_observer.last_moved) def test_validating_get_files_list(self): root = self.project.root # noqa - self.assertEquals(0, len(self.project.get_files())) + self.assertEqual(0, len(self.project.get_files())) file = open(os.path.join(self.project.address, 'myfile.txt'), 'w') file.close() self.project.validate() - self.assertEquals(1, len(self.project.get_files())) + self.assertEqual(1, len(self.project.get_files())) def test_clear_observered_resources_for_filtered_observers(self): sample_file = self.project.root.create_file('myfile.txt') @@ -772,7 +772,7 @@ def test_clear_observered_resources_for_filtered_observers(self): filtered.add_resource(sample_file) filtered.clear_resources() sample_file.write('1') - self.assertEquals(0, sample_observer.change_count) + self.assertEqual(0, sample_observer.change_count) class _MockChangeIndicator(object): @@ -834,18 +834,18 @@ def test_simple_out_of_project_file(self): sample_file.write('sample content\n') sample_file.close() sample_resource = self.no_project.get_resource(sample_file_path) - self.assertEquals('sample content\n', sample_resource.read()) + self.assertEqual('sample content\n', sample_resource.read()) def test_simple_out_of_project_folder(self): sample_folder_path = os.path.join(self.test_directory, 'sample_folder') os.mkdir(sample_folder_path) sample_folder = self.no_project.get_resource(sample_folder_path) - self.assertEquals([], sample_folder.get_children()) + self.assertEqual([], sample_folder.get_children()) sample_file_path = os.path.join(sample_folder_path, 'sample.txt') open(sample_file_path, 'w').close() sample_resource = self.no_project.get_resource(sample_file_path) - self.assertEquals(sample_resource, sample_folder.get_children()[0]) + self.assertEqual(sample_resource, sample_folder.get_children()[0]) def test_using_absolute_path(self): sample_file_path = os.path.join(self.test_directory, 'sample.txt') @@ -853,20 +853,20 @@ def test_using_absolute_path(self): normal_sample_resource = self.no_project.get_resource(sample_file_path) absolute_sample_resource = \ self.no_project.get_resource(os.path.abspath(sample_file_path)) - self.assertEquals(normal_sample_resource, absolute_sample_resource) + self.assertEqual(normal_sample_resource, absolute_sample_resource) def test_folder_get_child(self): sample_folder_path = os.path.join(self.test_directory, 'sample_folder') os.mkdir(sample_folder_path) sample_folder = self.no_project.get_resource(sample_folder_path) - self.assertEquals([], sample_folder.get_children()) + self.assertEqual([], sample_folder.get_children()) sample_file_path = os.path.join(sample_folder_path, 'sample.txt') open(sample_file_path, 'w').close() sample_resource = self.no_project.get_resource(sample_file_path) self.assertTrue(sample_folder.has_child('sample.txt')) self.assertFalse(sample_folder.has_child('doesnothave.txt')) - self.assertEquals(sample_resource, + self.assertEqual(sample_resource, sample_folder.get_child('sample.txt')) def test_out_of_project_files_and_path_to_resource(self): @@ -875,7 +875,7 @@ def test_out_of_project_files_and_path_to_resource(self): sample_file.write('sample content\n') sample_file.close() sample_resource = self.no_project.get_resource(sample_file_path) - self.assertEquals(sample_resource, + self.assertEqual(sample_resource, path_to_resource(self.project, sample_file_path)) @@ -940,15 +940,15 @@ def test_ignored_resources_and_get_files(self): self.project = testutils.sample_project( ignored_resources=['myfile.txt'], ropefolder=None) myfile = self.project.get_file('myfile.txt') - self.assertEquals(0, len(self.project.get_files())) + self.assertEqual(0, len(self.project.get_files())) myfile.create() - self.assertEquals(0, len(self.project.get_files())) + self.assertEqual(0, len(self.project.get_files())) def test_ignored_resources_and_get_files2(self): self.project = testutils.sample_project( ignored_resources=['myfile.txt'], ropefolder=None) myfile = self.project.root.create_file('myfile.txt') # noqa - self.assertEquals(0, len(self.project.get_files())) + self.assertEqual(0, len(self.project.get_files())) def test_setting_ignored_resources_patterns(self): self.project = testutils.sample_project(ignored_resources=['m?file.*']) @@ -979,7 +979,7 @@ def test_fscommands_and_ignored_resources(self): ignored_resources=['myfile.txt'], ropefolder=None) myfile = self.project.get_file('myfile.txt') myfile.create() - self.assertEquals('', fscommands.log) + self.assertEqual('', fscommands.log) def test_ignored_resources_and_prefixes(self): self.project = testutils.sample_project( @@ -1022,7 +1022,7 @@ def test_compressed_objectdb(self): def test_nested_dot_ropeproject_folder(self): self.project = testutils.sample_project(ropefolder='.f1/f2') ropefolder = self.project.ropefolder - self.assertEquals('.f1/f2', ropefolder.path) + self.assertEqual('.f1/f2', ropefolder.path) self.assertTrue(ropefolder.exists()) diff --git a/ropetest/pycoretest.py b/ropetest/pycoretest.py index fc9c1b29d..804330f50 100644 --- a/ropetest/pycoretest.py +++ b/ropetest/pycoretest.py @@ -25,37 +25,37 @@ def tearDown(self): def test_simple_module(self): testutils.create_module(self.project, 'mod') result = self.project.get_module('mod') - self.assertEquals(get_base_type('Module'), result.type) - self.assertEquals(0, len(result.get_attributes())) + self.assertEqual(get_base_type('Module'), result.type) + self.assertEqual(0, len(result.get_attributes())) def test_nested_modules(self): pkg = testutils.create_package(self.project, 'pkg') mod = testutils.create_module(self.project, 'mod', pkg) # noqa package = self.project.get_module('pkg') - self.assertEquals(get_base_type('Module'), package.get_type()) - self.assertEquals(1, len(package.get_attributes())) + self.assertEqual(get_base_type('Module'), package.get_type()) + self.assertEqual(1, len(package.get_attributes())) module = package['mod'].get_object() - self.assertEquals(get_base_type('Module'), module.get_type()) + self.assertEqual(get_base_type('Module'), module.get_type()) def test_package(self): pkg = testutils.create_package(self.project, 'pkg') mod = testutils.create_module(self.project, 'mod', pkg) # noqa result = self.project.get_module('pkg') - self.assertEquals(get_base_type('Module'), result.type) + self.assertEqual(get_base_type('Module'), result.type) def test_simple_class(self): mod = testutils.create_module(self.project, 'mod') mod.write('class SampleClass(object):\n pass\n') mod_element = self.project.get_module('mod') result = mod_element['SampleClass'].get_object() - self.assertEquals(get_base_type('Type'), result.get_type()) + self.assertEqual(get_base_type('Type'), result.get_type()) def test_simple_function(self): mod = testutils.create_module(self.project, 'mod') mod.write('def sample_function():\n pass\n') mod_element = self.project.get_module('mod') result = mod_element['sample_function'].get_object() - self.assertEquals(get_base_type('Function'), result.get_type()) + self.assertEqual(get_base_type('Function'), result.get_type()) def test_class_methods(self): mod = testutils.create_module(self.project, 'mod') @@ -67,7 +67,7 @@ def test_class_methods(self): sample_class = mod_element['SampleClass'].get_object() self.assertTrue('sample_method' in sample_class) method = sample_class['sample_method'].get_object() - self.assertEquals(get_base_type('Function'), method.get_type()) + self.assertEqual(get_base_type('Function'), method.get_type()) def test_global_variables(self): mod = testutils.create_module(self.project, 'mod') @@ -112,7 +112,7 @@ def test_classes_inside_other_classes(self): mod_element = self.project.get_module('mod') sample_class = mod_element['SampleClass'].get_object() var = sample_class['InnerClass'].get_object() - self.assertEquals(get_base_type('Type'), var.get_type()) + self.assertEqual(get_base_type('Type'), var.get_type()) def test_non_existent_module(self): with self.assertRaises(exceptions.ModuleNotFoundError): @@ -124,7 +124,7 @@ def test_imported_names(self): mod.write('import mod1\n') module = self.project.get_module('mod2') imported_sys = module['mod1'].get_object() - self.assertEquals(get_base_type('Module'), imported_sys.get_type()) + self.assertEqual(get_base_type('Module'), imported_sys.get_type()) def test_imported_as_names(self): testutils.create_module(self.project, 'mod1') @@ -132,13 +132,13 @@ def test_imported_as_names(self): mod.write('import mod1 as my_import\n') module = self.project.get_module('mod2') imported_mod = module['my_import'].get_object() - self.assertEquals(get_base_type('Module'), imported_mod.get_type()) + self.assertEqual(get_base_type('Module'), imported_mod.get_type()) def test_get_string_module(self): mod = libutils.get_string_module( self.project, 'class Sample(object):\n pass\n') sample_class = mod['Sample'].get_object() - self.assertEquals(get_base_type('Type'), sample_class.get_type()) + self.assertEqual(get_base_type('Type'), sample_class.get_type()) def test_get_string_module_with_extra_spaces(self): mod = libutils.get_string_module( @@ -148,14 +148,14 @@ def test_parameter_info_for_functions(self): code = 'def func(param1, param2=10, *param3, **param4):\n pass' mod = libutils.get_string_module(self.project, code) sample_function = mod['func'] - self.assertEquals(['param1', 'param2', 'param3', 'param4'], + self.assertEqual(['param1', 'param2', 'param3', 'param4'], sample_function.get_object().get_param_names()) # FIXME: Not found modules def xxx_test_not_found_module_is_module(self): mod = libutils.get_string_module( self.project, 'import doesnotexist\n') - self.assertEquals(get_base_type('Module'), + self.assertEqual(get_base_type('Module'), mod['doesnotexist']. get_object().get_type()) @@ -173,7 +173,7 @@ def test_inheriting_base_class_attributes(self): mod = libutils.get_string_module(self.project, code) derived = mod['Derived'].get_object() self.assertTrue('method' in derived) - self.assertEquals(get_base_type('Function'), + self.assertEqual(get_base_type('Function'), derived['method'].get_object().get_type()) def test_inheriting_multiple_base_class_attributes(self): @@ -192,7 +192,7 @@ def test_inherit_multiple_base_class_attrs_with_the_same_name(self): mod = libutils.get_string_module(self.project, code) base1 = mod['Base1'].get_object() derived = mod['Derived'].get_object() - self.assertEquals(base1['method'].get_object(), + self.assertEqual(base1['method'].get_object(), derived['method'].get_object()) def test_inheriting_unknown_base_class(self): @@ -206,32 +206,32 @@ def test_inheriting_unknown_base_class(self): def test_module_creation(self): new_module = testutils.create_module(self.project, 'module') self.assertFalse(new_module.is_folder()) - self.assertEquals(self.project.get_resource('module.py'), new_module) + self.assertEqual(self.project.get_resource('module.py'), new_module) def test_packaged_module_creation(self): package = self.project.root.create_folder('package') # noqa new_module = testutils.create_module(self.project, 'package.module') - self.assertEquals(self.project.get_resource('package/module.py'), + self.assertEqual(self.project.get_resource('package/module.py'), new_module) def test_packaged_module_creation_with_nested_src(self): src = self.project.root.create_folder('src') src.create_folder('pkg') new_module = testutils.create_module(self.project, 'pkg.mod', src) - self.assertEquals(self.project.get_resource('src/pkg/mod.py'), + self.assertEqual(self.project.get_resource('src/pkg/mod.py'), new_module) def test_package_creation(self): new_package = testutils.create_package(self.project, 'pkg') self.assertTrue(new_package.is_folder()) - self.assertEquals(self.project.get_resource('pkg'), new_package) - self.assertEquals(self.project.get_resource('pkg/__init__.py'), + self.assertEqual(self.project.get_resource('pkg'), new_package) + self.assertEqual(self.project.get_resource('pkg/__init__.py'), new_package.get_child('__init__.py')) def test_nested_package_creation(self): testutils.create_package(self.project, 'pkg1') nested_package = testutils.create_package(self.project, 'pkg1.pkg2') - self.assertEquals(self.project.get_resource('pkg1/pkg2'), + self.assertEqual(self.project.get_resource('pkg1/pkg2'), nested_package) def test_packaged_package_creation_with_nested_src(self): @@ -239,14 +239,14 @@ def test_packaged_package_creation_with_nested_src(self): testutils.create_package(self.project, 'pkg1', src) nested_package = testutils.create_package(self.project, 'pkg1.pkg2', src) - self.assertEquals(self.project.get_resource('src/pkg1/pkg2'), + self.assertEqual(self.project.get_resource('src/pkg1/pkg2'), nested_package) def test_find_module(self): src = self.project.root.create_folder('src') samplemod = testutils.create_module(self.project, 'samplemod', src) found_module = self.project.find_module('samplemod') - self.assertEquals(samplemod, found_module) + self.assertEqual(samplemod, found_module) def test_find_nested_module(self): src = self.project.root.create_folder('src') @@ -254,7 +254,7 @@ def test_find_nested_module(self): samplemod = testutils.create_module(self.project, 'samplemod', samplepkg) found_module = self.project.find_module('samplepkg.samplemod') - self.assertEquals(samplemod, found_module) + self.assertEqual(samplemod, found_module) def test_find_multiple_module(self): src = self.project.root.create_folder('src') @@ -271,14 +271,14 @@ def test_find_module_packages(self): src = self.project.root samplepkg = testutils.create_package(self.project, 'samplepkg', src) found_module = self.project.find_module('samplepkg') - self.assertEquals(samplepkg, found_module) + self.assertEqual(samplepkg, found_module) def test_find_module_when_module_and_package_with_the_same_name(self): src = self.project.root testutils.create_module(self.project, 'sample', src) samplepkg = testutils.create_package(self.project, 'sample', src) found_module = self.project.find_module('sample') - self.assertEquals(samplepkg, found_module) + self.assertEqual(samplepkg, found_module) def test_source_folders_preference(self): testutils.create_package(self.project, 'pkg1') @@ -294,39 +294,39 @@ def test_source_folders_preference(self): def test_get_pyname_definition_location(self): mod = libutils.get_string_module(self.project, 'a_var = 20\n') a_var = mod['a_var'] - self.assertEquals((mod, 1), a_var.get_definition_location()) + self.assertEqual((mod, 1), a_var.get_definition_location()) def test_get_pyname_definition_location_functions(self): mod = libutils.get_string_module( self.project, 'def a_func():\n pass\n') a_func = mod['a_func'] - self.assertEquals((mod, 1), a_func.get_definition_location()) + self.assertEqual((mod, 1), a_func.get_definition_location()) def test_get_pyname_definition_location_class(self): code = 'class AClass(object):\n pass\n\n' mod = libutils.get_string_module(self.project, code) a_class = mod['AClass'] - self.assertEquals((mod, 1), a_class.get_definition_location()) + self.assertEqual((mod, 1), a_class.get_definition_location()) def test_get_pyname_definition_location_local_variables(self): mod = libutils.get_string_module( self.project, 'def a_func():\n a_var = 10\n') a_func_scope = mod.get_scope().get_scopes()[0] a_var = a_func_scope['a_var'] - self.assertEquals((mod, 2), a_var.get_definition_location()) + self.assertEqual((mod, 2), a_var.get_definition_location()) def test_get_pyname_definition_location_reassigning(self): mod = libutils.get_string_module( self.project, 'a_var = 20\na_var=30\n') a_var = mod['a_var'] - self.assertEquals((mod, 1), a_var.get_definition_location()) + self.assertEqual((mod, 1), a_var.get_definition_location()) def test_get_pyname_definition_location_importes(self): testutils.create_module(self.project, 'mod') mod = libutils.get_string_module(self.project, 'import mod\n') imported_module = self.project.get_module('mod') module_pyname = mod['mod'] - self.assertEquals((imported_module, 1), + self.assertEqual((imported_module, 1), module_pyname.get_definition_location()) def test_get_pyname_definition_location_imports(self): @@ -336,7 +336,7 @@ def test_get_pyname_definition_location_imports(self): mod = libutils.get_string_module( self.project, 'from mod import a_func\n') a_func = mod['a_func'] - self.assertEquals((imported_module, 2), + self.assertEqual((imported_module, 2), a_func.get_definition_location()) def test_get_pyname_definition_location_parameters(self): @@ -344,17 +344,17 @@ def test_get_pyname_definition_location_parameters(self): mod = libutils.get_string_module(self.project, code) a_func_scope = mod.get_scope().get_scopes()[0] param1 = a_func_scope['param1'] - self.assertEquals((mod, 1), param1.get_definition_location()) + self.assertEqual((mod, 1), param1.get_definition_location()) param2 = a_func_scope['param2'] - self.assertEquals((mod, 1), param2.get_definition_location()) + self.assertEqual((mod, 1), param2.get_definition_location()) def test_module_get_resource(self): module_resource = testutils.create_module(self.project, 'mod') module = self.project.get_module('mod') - self.assertEquals(module_resource, module.get_resource()) + self.assertEqual(module_resource, module.get_resource()) string_module = libutils.get_string_module( self.project, 'from mod import a_func\n') - self.assertEquals(None, string_module.get_resource()) + self.assertEqual(None, string_module.get_resource()) def test_get_pyname_definition_location_class2(self): code = 'class AClass(object):\n' \ @@ -363,20 +363,20 @@ def test_get_pyname_definition_location_class2(self): mod = libutils.get_string_module(self.project, code) a_class = mod['AClass'].get_object() an_attr = a_class['an_attr'] - self.assertEquals((mod, 3), an_attr.get_definition_location()) + self.assertEqual((mod, 3), an_attr.get_definition_location()) def test_import_not_found_module_get_definition_location(self): mod = libutils.get_string_module( self.project, 'import doesnotexist\n') does_not_exist = mod['doesnotexist'] - self.assertEquals((None, None), + self.assertEqual((None, None), does_not_exist.get_definition_location()) def test_from_not_found_module_get_definition_location(self): mod = libutils.get_string_module( self.project, 'from doesnotexist import Sample\n') sample = mod['Sample'] - self.assertEquals((None, None), sample.get_definition_location()) + self.assertEqual((None, None), sample.get_definition_location()) def test_from_package_import_module_get_definition_location(self): pkg = testutils.create_package(self.project, 'pkg') @@ -385,21 +385,21 @@ def test_from_package_import_module_get_definition_location(self): mod = libutils.get_string_module( self.project, 'from pkg import mod\n') imported_mod = mod['mod'] - self.assertEquals((pkg_mod, 1), + self.assertEqual((pkg_mod, 1), imported_mod.get_definition_location()) def test_get_module_for_defined_pyobjects(self): mod = libutils.get_string_module( self.project, 'class AClass(object):\n pass\n') a_class = mod['AClass'].get_object() - self.assertEquals(mod, a_class.get_module()) + self.assertEqual(mod, a_class.get_module()) def test_get_definition_location_for_packages(self): testutils.create_package(self.project, 'pkg') init_module = self.project.get_module('pkg.__init__') mod = libutils.get_string_module(self.project, 'import pkg\n') pkg_pyname = mod['pkg'] - self.assertEquals((init_module, 1), + self.assertEqual((init_module, 1), pkg_pyname.get_definition_location()) def test_get_definition_location_for_filtered_packages(self): @@ -408,7 +408,7 @@ def test_get_definition_location_for_filtered_packages(self): init_module = self.project.get_module('pkg.__init__') mod = libutils.get_string_module(self.project, 'import pkg.mod') pkg_pyname = mod['pkg'] - self.assertEquals((init_module, 1), + self.assertEqual((init_module, 1), pkg_pyname.get_definition_location()) def test_out_of_project_modules(self): @@ -430,7 +430,7 @@ def test_global_keyword(self): global_var = mod['a_var'] func_scope = mod['a_func'].get_object().get_scope() local_var = func_scope['a_var'] - self.assertEquals(global_var, local_var) + self.assertEqual(global_var, local_var) def test_not_leaking_for_vars_inside_parent_scope(self): mod = testutils.create_module(self.project, 'mod') @@ -516,7 +516,7 @@ def test_with_statement_variable_type(self): pymod = libutils.get_string_module(self.project, code) a_class = pymod['A'].get_object() var = pymod['var'].get_object() - self.assertEquals(a_class, var.get_type()) + self.assertEqual(a_class, var.get_type()) @testutils.only_for('2.5') def test_with_statement_with_no_vars(self): @@ -533,21 +533,21 @@ def test_check_for_else_block(self): ' myvar = 1\n' mod = libutils.get_string_module(self.project, code) a_var = mod['myvar'] - self.assertEquals((mod, 4), a_var.get_definition_location()) + self.assertEqual((mod, 4), a_var.get_definition_location()) def test_check_names_defined_in_whiles(self): mod = libutils.get_string_module( self.project, 'while False:\n myvar = 1\n') a_var = mod['myvar'] - self.assertEquals((mod, 2), a_var.get_definition_location()) + self.assertEqual((mod, 2), a_var.get_definition_location()) def test_get_definition_location_in_tuple_assnames(self): mod = libutils.get_string_module( self.project, 'def f(x):\n x.z, a = range(2)\n') x = mod['f'].get_object().get_scope()['x'] a = mod['f'].get_object().get_scope()['a'] - self.assertEquals((mod, 1), x.get_definition_location()) - self.assertEquals((mod, 2), a.get_definition_location()) + self.assertEqual((mod, 1), x.get_definition_location()) + self.assertEqual((mod, 2), a.get_definition_location()) def test_syntax_errors_in_code(self): with self.assertRaises(exceptions.ModuleSyntaxError): @@ -557,7 +557,7 @@ def test_holding_error_location_information(self): try: libutils.get_string_module(self.project, 'xyx print\n') except exceptions.ModuleSyntaxError as e: - self.assertEquals(1, e.lineno) + self.assertEqual(1, e.lineno) def test_no_exceptions_on_module_encoding_problems(self): mod = testutils.create_module(self.project, 'mod') @@ -620,7 +620,7 @@ def test_pyobject_equality_should_compare_types(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write('var1 = ""\nvar2 = ""\n') pymod1 = self.pycore.resource_to_pyobject(mod1) - self.assertEquals(pymod1['var1'].get_object(), + self.assertEqual(pymod1['var1'].get_object(), pymod1['var2'].get_object()) @@ -651,21 +651,21 @@ def test_simple_import(self): mod = libutils.get_string_module( self.project, 'import samplemod\n') samplemod = mod['samplemod'].get_object() - self.assertEquals(get_base_type('Module'), samplemod.get_type()) + self.assertEqual(get_base_type('Module'), samplemod.get_type()) def test_from_import_class(self): mod = libutils.get_string_module( self.project, 'from samplemod import SampleClass\n') result = mod['SampleClass'].get_object() - self.assertEquals(get_base_type('Type'), result.get_type()) + self.assertEqual(get_base_type('Type'), result.get_type()) self.assertTrue('sample_func' not in mod.get_attributes()) def test_from_import_star(self): mod = libutils.get_string_module( self.project, 'from samplemod import *\n') - self.assertEquals(get_base_type('Type'), + self.assertEqual(get_base_type('Type'), mod['SampleClass'].get_object().get_type()) - self.assertEquals(get_base_type('Function'), + self.assertEqual(get_base_type('Function'), mod['sample_func'].get_object().get_type()) self.assertTrue(mod['sample_var'] is not None) @@ -691,7 +691,7 @@ def test_from_import_star_imports_in_functions(self): def test_from_package_import_mod(self): mod = libutils.get_string_module( self.project, 'from package import nestedmod\n') - self.assertEquals(get_base_type('Module'), + self.assertEqual(get_base_type('Module'), mod['nestedmod'].get_object().get_type()) # XXX: Deciding to import everything on import start from packages @@ -708,7 +708,7 @@ def test_unknown_when_module_cannot_be_found(self): def test_from_import_function(self): code = 'def f():\n from samplemod import SampleClass\n' scope = libutils.get_string_scope(self.project, code) - self.assertEquals(get_base_type('Type'), + self.assertEqual(get_base_type('Type'), scope.get_scopes()[0]['SampleClass']. get_object().get_type()) @@ -744,7 +744,7 @@ def test_multi_dot_imports2(self): mod = libutils.get_string_module( self.project, 'import pkg.mod1\nimport pkg.mod2\n') package = mod['pkg'].get_object() - self.assertEquals(2, len(package.get_attributes())) + self.assertEqual(2, len(package.get_attributes())) self.assertTrue('mod1' in package and 'mod2' in package) @@ -757,7 +757,7 @@ def test_multi_dot_imports3(self): mod = libutils.get_string_module(self.project, code) package1 = mod['pkg1'].get_object() package2 = package1['pkg2'].get_object() - self.assertEquals(2, len(package2.get_attributes())) + self.assertEqual(2, len(package2.get_attributes())) self.assertTrue('mod1' in package2 and 'mod2' in package2) def test_multi_dot_imports_as(self): @@ -777,7 +777,7 @@ def xxx_test_from_package_import_package(self): mod = libutils.get_string_module( self.project, 'from pkg1 import pkg2\n') package = mod['pkg2'] - self.assertEquals(0, len(package.get_attributes())) + self.assertEqual(0, len(package.get_attributes())) def test_invalidating_cache_after_resource_change(self): module = testutils.create_module(self.project, 'mod') @@ -818,7 +818,7 @@ def test_from_import_nonexistent_module(self): code = 'from doesnotexistmod import DoesNotExistClass\n' mod = libutils.get_string_module(self.project, code) self.assertTrue('DoesNotExistClass' in mod) - self.assertEquals(get_base_type('Unknown'), + self.assertEqual(get_base_type('Unknown'), mod['DoesNotExistClass']. get_object().get_type()) @@ -826,19 +826,19 @@ def test_from_import_nonexistent_name(self): code = 'from samplemod import DoesNotExistClass\n' mod = libutils.get_string_module(self.project, code) self.assertTrue('DoesNotExistClass' in mod) - self.assertEquals(get_base_type('Unknown'), + self.assertEqual(get_base_type('Unknown'), mod['DoesNotExistClass']. get_object().get_type()) def test_not_considering_imported_names_as_sub_scopes(self): code = 'from samplemod import SampleClass\n' scope = libutils.get_string_scope(self.project, code) - self.assertEquals(0, len(scope.get_scopes())) + self.assertEqual(0, len(scope.get_scopes())) def test_not_considering_imported_modules_as_sub_scopes(self): scope = libutils.get_string_scope( self.project, 'import samplemod\n') - self.assertEquals(0, len(scope.get_scopes())) + self.assertEqual(0, len(scope.get_scopes())) def test_inheriting_dotted_base_class(self): code = 'import samplemod\n' \ @@ -855,7 +855,7 @@ def test_self_in_methods(self): scope = libutils.get_string_scope(self.project, code) sample_class = scope['Sample'].get_object() func_scope = scope.get_scopes()[0].get_scopes()[0] - self.assertEquals(sample_class, + self.assertEqual(sample_class, func_scope['self'].get_object().get_type()) self.assertTrue('func' in func_scope['self'].get_object()) @@ -886,7 +886,7 @@ def test_location_of_imports_when_importing(self): self.project, 'from mod import SampleClass\n') sample_class = scope['SampleClass'] samplemod = self.project.get_module('samplemod') - self.assertEquals((samplemod, 1), + self.assertEqual((samplemod, 1), sample_class.get_definition_location()) def test_nested_modules(self): @@ -895,7 +895,7 @@ def test_nested_modules(self): imported_module = self.project.get_module('pkg.mod') scope = libutils.get_string_scope(self.project, 'import pkg.mod\n') mod_pyobject = scope['pkg'].get_object()['mod'] - self.assertEquals((imported_module, 1), + self.assertEqual((imported_module, 1), mod_pyobject.get_definition_location()) def test_reading_init_dot_py(self): @@ -912,7 +912,7 @@ def test_relative_imports(self): mod2.write('import mod1\n') mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = self.pycore.resource_to_pyobject(mod2) - self.assertEquals(mod1_object, + self.assertEqual(mod1_object, mod2_object.get_attributes()['mod1'].get_object()) def test_relative_froms(self): @@ -923,7 +923,7 @@ def test_relative_froms(self): mod2.write('from mod1 import a_func\n') mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = self.pycore.resource_to_pyobject(mod2) - self.assertEquals(mod1_object['a_func'].get_object(), + self.assertEqual(mod1_object['a_func'].get_object(), mod2_object['a_func'].get_object()) def test_relative_imports_for_string_modules(self): @@ -934,7 +934,7 @@ def test_relative_imports_for_string_modules(self): mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = libutils.get_string_module( self.project, mod2.read(), mod2) - self.assertEquals(mod1_object, mod2_object['mod1'].get_object()) + self.assertEqual(mod1_object, mod2_object['mod1'].get_object()) def test_relative_imports_for_string_scopes(self): pkg = testutils.create_package(self.project, 'pkg') @@ -944,7 +944,7 @@ def test_relative_imports_for_string_scopes(self): mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_scope = libutils.get_string_scope(self.project, mod2.read(), mod2) - self.assertEquals(mod1_object, mod2_scope['mod1'].get_object()) + self.assertEqual(mod1_object, mod2_scope['mod1'].get_object()) @testutils.only_for('2.5') def test_new_style_relative_imports(self): @@ -954,7 +954,7 @@ def test_new_style_relative_imports(self): mod2.write('from . import mod1\n') mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = self.pycore.resource_to_pyobject(mod2) - self.assertEquals(mod1_object, mod2_object['mod1'].get_object()) + self.assertEqual(mod1_object, mod2_object['mod1'].get_object()) @testutils.only_for('2.5') def test_new_style_relative_imports2(self): @@ -965,7 +965,7 @@ def test_new_style_relative_imports2(self): mod2.write('from ..mod1 import a_func\n') mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = self.pycore.resource_to_pyobject(mod2) - self.assertEquals(mod1_object['a_func'].get_object(), + self.assertEqual(mod1_object['a_func'].get_object(), mod2_object['a_func'].get_object()) def test_invalidating_cache_for_from_imports_after_resource_change(self): @@ -976,11 +976,11 @@ def test_invalidating_cache_for_from_imports_after_resource_change(self): pymod1 = self.project.get_module('mod1') pymod2 = self.project.get_module('mod2') - self.assertEquals(pymod1['a_func'].get_object(), + self.assertEqual(pymod1['a_func'].get_object(), pymod2['a_func'].get_object()) mod2.write(mod2.read() + '\n') pymod2 = self.project.get_module('mod2') - self.assertEquals(pymod1['a_func'].get_object(), + self.assertEqual(pymod1['a_func'].get_object(), pymod2['a_func'].get_object()) def test_invalidating_superclasses_after_change(self): diff --git a/ropetest/pyscopestest.py b/ropetest/pyscopestest.py index 00c5582cc..a3fb2823b 100644 --- a/ropetest/pyscopestest.py +++ b/ropetest/pyscopestest.py @@ -20,24 +20,24 @@ def test_simple_scope(self): scope = libutils.get_string_scope( self.project, 'def sample_func():\n pass\n') sample_func = scope['sample_func'].get_object() - self.assertEquals(get_base_type('Function'), sample_func.get_type()) + self.assertEqual(get_base_type('Function'), sample_func.get_type()) def test_simple_function_scope(self): scope = libutils.get_string_scope( self.project, 'def sample_func():\n a = 10\n') - self.assertEquals(1, len(scope.get_scopes())) + self.assertEqual(1, len(scope.get_scopes())) sample_func_scope = scope.get_scopes()[0] - self.assertEquals(1, len(sample_func_scope.get_names())) - self.assertEquals(0, len(sample_func_scope.get_scopes())) + self.assertEqual(1, len(sample_func_scope.get_names())) + self.assertEqual(0, len(sample_func_scope.get_scopes())) def test_classes_inside_function_scopes(self): scope = libutils.get_string_scope( self.project, 'def sample_func():\n' ' class SampleClass(object):\n pass\n') - self.assertEquals(1, len(scope.get_scopes())) + self.assertEqual(1, len(scope.get_scopes())) sample_func_scope = scope.get_scopes()[0] # noqa - self.assertEquals(get_base_type('Type'), + self.assertEqual(get_base_type('Type'), scope.get_scopes()[0]['SampleClass']. get_object().get_type()) @@ -46,20 +46,20 @@ def test_simple_class_scope(self): self.project, 'class SampleClass(object):\n' ' def f(self):\n var = 10\n') - self.assertEquals(1, len(scope.get_scopes())) + self.assertEqual(1, len(scope.get_scopes())) sample_class_scope = scope.get_scopes()[0] self.assertTrue('f' in sample_class_scope) - self.assertEquals(1, len(sample_class_scope.get_scopes())) + self.assertEqual(1, len(sample_class_scope.get_scopes())) f_in_class = sample_class_scope.get_scopes()[0] self.assertTrue('var' in f_in_class) def test_get_lineno(self): scope = libutils.get_string_scope( self.project, '\ndef sample_func():\n a = 10\n') - self.assertEquals(1, len(scope.get_scopes())) + self.assertEqual(1, len(scope.get_scopes())) sample_func_scope = scope.get_scopes()[0] - self.assertEquals(1, scope.get_start()) - self.assertEquals(2, sample_func_scope.get_start()) + self.assertEqual(1, scope.get_start()) + self.assertEqual(2, sample_func_scope.get_start()) def test_scope_kind(self): scope = libutils.get_string_scope( @@ -68,9 +68,9 @@ def test_scope_kind(self): 'def sample_func():\n pass\n') sample_class_scope = scope.get_scopes()[0] sample_func_scope = scope.get_scopes()[1] - self.assertEquals('Module', scope.get_kind()) - self.assertEquals('Class', sample_class_scope.get_kind()) - self.assertEquals('Function', sample_func_scope.get_kind()) + self.assertEqual('Module', scope.get_kind()) + self.assertEqual('Class', sample_class_scope.get_kind()) + self.assertEqual('Function', sample_func_scope.get_kind()) def test_function_parameters_in_scope_names(self): scope = libutils.get_string_scope( @@ -90,7 +90,7 @@ def test_scope_lookup(self): self.project, 'var1 = 10\ndef sample_func(param):\n var2 = 20\n') self.assertTrue(scope.lookup('var2') is None) - self.assertEquals(get_base_type('Function'), + self.assertEqual(get_base_type('Function'), scope.lookup('sample_func').get_object().get_type()) sample_func_scope = scope.get_scopes()[0] self.assertTrue(sample_func_scope.lookup('var1') is not None) @@ -138,7 +138,7 @@ def test_first_parameter_of_a_method(self): a_class = libutils.get_string_module(self.project, code)['AClass'].\ get_object() function_scope = a_class['a_func'].get_object().get_scope() - self.assertEquals(a_class, + self.assertEqual(a_class, function_scope['self'].get_object().get_type()) self.assertNotEquals(a_class, function_scope['param']. get_object().get_type()) @@ -159,7 +159,7 @@ def test_first_parameter_of_class_methods(self): a_class = libutils.get_string_module(self.project, code)['AClass'].\ get_object() function_scope = a_class['a_func'].get_object().get_scope() - self.assertEquals(a_class, function_scope['cls'].get_object()) + self.assertEqual(a_class, function_scope['cls'].get_object()) def test_first_parameter_with_self_as_name_and_unknown_decorator(self): code = 'def my_decorator(func):\n return func\n'\ @@ -168,7 +168,7 @@ def test_first_parameter_with_self_as_name_and_unknown_decorator(self): a_class = libutils.get_string_module(self.project, code)['AClass'].\ get_object() function_scope = a_class['a_func'].get_object().get_scope() - self.assertEquals(a_class, function_scope['self']. + self.assertEqual(a_class, function_scope['self']. get_object().get_type()) def test_inside_class_scope_attribute_lookup(self): @@ -177,7 +177,7 @@ def test_inside_class_scope_attribute_lookup(self): 'class C(object):\n' ' an_attr = 1\n' ' def a_func(self):\n pass') - self.assertEquals(1, len(scope.get_scopes())) + self.assertEqual(1, len(scope.get_scopes())) c_scope = scope.get_scopes()[0] self.assertTrue('an_attr'in c_scope.get_names()) self.assertTrue(c_scope.lookup('an_attr') is not None) @@ -190,7 +190,7 @@ def test_inside_class_scope_attribute_lookup2(self): 'class C(object):\n' ' def __init__(self):\n self.an_attr = 1\n' ' def a_func(self):\n pass') - self.assertEquals(1, len(scope.get_scopes())) + self.assertEqual(1, len(scope.get_scopes())) c_scope = scope.get_scopes()[0] f_in_c = c_scope.get_scopes()[0] self.assertTrue(f_in_c.lookup('an_attr') is None) @@ -203,12 +203,12 @@ def test_get_inner_scope_for_staticmethods(self): ' def a_func(self):\n pass\n') c_scope = scope.get_scopes()[0] f_in_c = c_scope.get_scopes()[0] - self.assertEquals(f_in_c, scope.get_inner_scope_for_line(4)) + self.assertEqual(f_in_c, scope.get_inner_scope_for_line(4)) def test_getting_overwritten_scopes(self): scope = libutils.get_string_scope( self.project, 'def f():\n pass\ndef f():\n pass\n') - self.assertEquals(2, len(scope.get_scopes())) + self.assertEqual(2, len(scope.get_scopes())) f1_scope = scope.get_scopes()[0] f2_scope = scope.get_scopes()[1] self.assertNotEquals(f1_scope, f2_scope) @@ -216,7 +216,7 @@ def test_getting_overwritten_scopes(self): def test_assigning_builtin_names(self): mod = libutils.get_string_module(self.project, 'range = 1\n') range = mod.get_scope().lookup('range') - self.assertEquals((mod, 1), range.get_definition_location()) + self.assertEqual((mod, 1), range.get_definition_location()) def test_get_inner_scope_and_logical_lines(self): scope = libutils.get_string_scope( @@ -225,7 +225,7 @@ def test_get_inner_scope_and_logical_lines(self): ' def f():\n s = """\n1\n2\n"""\n a = 1\n') c_scope = scope.get_scopes()[0] f_in_c = c_scope.get_scopes()[0] - self.assertEquals(f_in_c, scope.get_inner_scope_for_line(7)) + self.assertEqual(f_in_c, scope.get_inner_scope_for_line(7)) def test_getting_defined_names_for_classes(self): scope = libutils.get_string_scope( diff --git a/ropetest/refactor/__init__.py b/ropetest/refactor/__init__.py index ab9152926..4dacd142e 100644 --- a/ropetest/refactor/__init__.py +++ b/ropetest/refactor/__init__.py @@ -40,7 +40,7 @@ def test_empty_method(self): code = 'def func():\n pass\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEquals( + self.assertEqual( 'class _New(object):\n\n def __call__(self):\n pass\n', replacer.get_new_class('_New')) @@ -48,7 +48,7 @@ def test_trivial_return(self): code = 'def func():\n return 1\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEquals( + self.assertEqual( 'class _New(object):\n\n def __call__(self):' '\n return 1\n', replacer.get_new_class('_New')) @@ -57,7 +57,7 @@ def test_multi_line_header(self): code = 'def func(\n ):\n return 1\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEquals( + self.assertEqual( 'class _New(object):\n\n def __call__(self):' '\n return 1\n', replacer.get_new_class('_New')) @@ -66,7 +66,7 @@ def test_a_single_parameter(self): code = 'def func(param):\n return 1\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEquals( + self.assertEqual( 'class _New(object):\n\n' ' def __init__(self, param):\n self.param = param\n\n' ' def __call__(self):\n return 1\n', @@ -76,7 +76,7 @@ def test_self_parameter(self): code = 'def func(self):\n return 1\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEquals( + self.assertEqual( 'class _New(object):\n\n' ' def __init__(self, host):\n self.self = host\n\n' ' def __call__(self):\n return 1\n', @@ -86,7 +86,7 @@ def test_simple_using_passed_parameters(self): code = 'def func(param):\n return param\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEquals( + self.assertEqual( 'class _New(object):\n\n' ' def __init__(self, param):\n self.param = param\n\n' ' def __call__(self):\n return self.param\n', @@ -107,7 +107,7 @@ def test_self_keywords_and_args_parameters(self): ' result = self.arg + ' \ 'self.args[0] + self.kwds[self.arg]\n' \ ' return result\n' - self.assertEquals(expected, replacer.get_new_class('_New')) + self.assertEqual(expected, replacer.get_new_class('_New')) def test_performing_on_not_a_function(self): code = 'my_var = 10\n' @@ -125,7 +125,7 @@ def test_changing_the_module(self): 'class _New(object):\n\n' \ ' def __call__(self):\n' \ ' return 1\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_changing_the_module_and_class_methods(self): code = 'class C(object):\n\n' \ @@ -146,7 +146,7 @@ def test_changing_the_module_and_class_methods(self): ' self.self = host\n\n' \ ' def __call__(self):\n' \ ' return 1\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) class IntroduceFactoryTest(unittest.TestCase): @@ -176,7 +176,7 @@ def test_adding_the_method(self): ' def create(*args, **kwds):\n' \ ' return AClass(*args, **kwds)\n' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create') - self.assertEquals(expected, mod.read()) + self.assertEqual(expected, mod.read()) def test_changing_occurances_in_the_main_module(self): code = 'class AClass(object):\n' \ @@ -191,7 +191,7 @@ def test_changing_occurances_in_the_main_module(self): ' return AClass(*args, **kwds)\n'\ 'a_var = AClass.create()' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create') - self.assertEquals(expected, mod.read()) + self.assertEqual(expected, mod.read()) def test_changing_occurances_with_arguments(self): code = 'class AClass(object):\n' \ @@ -208,7 +208,7 @@ def test_changing_occurances_with_arguments(self): ' return AClass(*args, **kwds)\n' \ 'a_var = AClass.create(10)\n' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create') - self.assertEquals(expected, mod.read()) + self.assertEqual(expected, mod.read()) def test_changing_occurances_in_other_modules(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -224,8 +224,8 @@ def test_changing_occurances_in_other_modules(self): ' return AClass(*args, **kwds)\n' expected2 = 'import mod1\n' \ 'a_var = mod1.AClass.create()\n' - self.assertEquals(expected1, mod1.read()) - self.assertEquals(expected2, mod2.read()) + self.assertEqual(expected1, mod1.read()) + self.assertEqual(expected2, mod2.read()) def test_raising_exception_for_non_classes(self): mod = testutils.create_module(self.project, 'mod') @@ -244,8 +244,8 @@ def test_undoing_introduce_factory(self): self._introduce_factory(mod1, mod1.read().index('AClass') + 1, 'create') self.project.history.undo() - self.assertEquals(code1, mod1.read()) - self.assertEquals(code2, mod2.read()) + self.assertEqual(code1, mod1.read()) + self.assertEqual(code2, mod2.read()) def test_using_on_an_occurance_outside_the_main_module(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -261,8 +261,8 @@ def test_using_on_an_occurance_outside_the_main_module(self): ' return AClass(*args, **kwds)\n' expected2 = 'import mod1\n' \ 'a_var = mod1.AClass.create()\n' - self.assertEquals(expected1, mod1.read()) - self.assertEquals(expected2, mod2.read()) + self.assertEqual(expected1, mod1.read()) + self.assertEqual(expected2, mod2.read()) def test_introduce_factory_in_nested_scopes(self): code = 'def create_var():\n'\ @@ -279,7 +279,7 @@ def test_introduce_factory_in_nested_scopes(self): ' return AClass(*args, **kwds)\n'\ ' return AClass.create()\n' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create') - self.assertEquals(expected, mod.read()) + self.assertEqual(expected, mod.read()) def test_adding_factory_for_global_factories(self): code = 'class AClass(object):\n an_attr = 10\n' @@ -291,7 +291,7 @@ def test_adding_factory_for_global_factories(self): ' return AClass(*args, **kwds)\n' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create', global_factory=True) - self.assertEquals(expected, mod.read()) + self.assertEqual(expected, mod.read()) def test_get_name_for_factories(self): code = 'class C(object):\n pass\n' @@ -299,7 +299,7 @@ def test_get_name_for_factories(self): mod.write(code) factory = IntroduceFactory(self.project, mod, mod.read().index('C') + 1) - self.assertEquals('C', factory.get_name()) + self.assertEqual('C', factory.get_name()) def test_raising_exception_for_global_factory_for_nested_classes(self): code = 'def create_var():\n'\ @@ -324,7 +324,7 @@ def test_changing_occurances_in_the_main_module_for_global_factories(self): 'a_var = create()' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create', global_factory=True) - self.assertEquals(expected, mod.read()) + self.assertEqual(expected, mod.read()) def test_changing_occurances_in_other_modules_for_global_factories(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -339,8 +339,8 @@ def test_changing_occurances_in_other_modules_for_global_factories(self): ' return AClass(*args, **kwds)\n' expected2 = 'import mod1\n' \ 'a_var = mod1.create()\n' - self.assertEquals(expected1, mod1.read()) - self.assertEquals(expected2, mod2.read()) + self.assertEqual(expected1, mod1.read()) + self.assertEqual(expected2, mod2.read()) def test_import_if_necessary_in_other_mods_for_global_factories(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -355,8 +355,8 @@ def test_import_if_necessary_in_other_mods_for_global_factories(self): ' return AClass(*args, **kwds)\n' expected2 = 'from mod1 import AClass, create\n' \ 'pair = create(), AClass\n' - self.assertEquals(expected1, mod1.read()) - self.assertEquals(expected2, mod2.read()) + self.assertEqual(expected1, mod1.read()) + self.assertEqual(expected2, mod2.read()) def test_changing_occurances_for_renamed_classes(self): code = 'class AClass(object):\n an_attr = 10' \ @@ -371,7 +371,7 @@ def test_changing_occurances_for_renamed_classes(self): 'a_class = AClass\n' \ 'a_var = a_class()' self._introduce_factory(mod, mod.read().index('a_class') + 1, 'create') - self.assertEquals(expected, mod.read()) + self.assertEqual(expected, mod.read()) def test_changing_occurrs_in_the_same_module_with_conflict_ranges(self): mod = testutils.create_module(self.project, 'mod') @@ -398,7 +398,7 @@ def test_transform_module_to_package(self): mod2 = self.project.get_resource('mod2') root_folder = self.project.root self.assertFalse(root_folder.has_child('mod2.py')) - self.assertEquals('class AClass(object):\n pass\n', + self.assertEqual('class AClass(object):\n pass\n', root_folder.get_child('mod2'). get_child('__init__.py').read()) @@ -420,7 +420,7 @@ def test_transform_module_to_package_with_relative_imports(self): mod2.write('class AClass(object):\n pass\n') self._transform_module_to_package(mod1) new_init = self.project.get_resource('pkg/mod1/__init__.py') - self.assertEquals('import pkg.mod2\nfrom pkg.mod2 import AClass\n', + self.assertEqual('import pkg.mod2\nfrom pkg.mod2 import AClass\n', new_init.read()) def test_resources_parameter(self): @@ -437,8 +437,8 @@ def test_resources_parameter(self): ' return A(*args, **kwds)\n' self._introduce_factory(mod, mod.read().index('A') + 1, 'create', resources=[mod]) - self.assertEquals(expected, mod.read()) - self.assertEquals(code1, mod1.read()) + self.assertEqual(expected, mod.read()) + self.assertEqual(code1, mod1.read()) class EncapsulateFieldTest(unittest.TestCase): @@ -472,7 +472,7 @@ def test_adding_getters_and_setters(self): code = self.a_class self.mod.write(code) self._encapsulate(self.mod, code.index('attr') + 1) - self.assertEquals(self.encapsulated, self.mod.read()) + self.assertEqual(self.encapsulated, self.mod.read()) def test_changing_getters_in_other_modules(self): code = 'import mod\n' \ @@ -484,7 +484,7 @@ def test_changing_getters_in_other_modules(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'range(a_var.get_attr())\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_changing_setters_in_other_modules(self): code = 'import mod\n' \ @@ -496,7 +496,7 @@ def test_changing_setters_in_other_modules(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'a_var.set_attr(1)\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_changing_getters_in_setters(self): code = 'import mod\n' \ @@ -508,12 +508,12 @@ def test_changing_getters_in_setters(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'a_var.set_attr(1 + a_var.get_attr())\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_appending_to_class_end(self): self.mod1.write(self.a_class + 'a_var = A()\n') self._encapsulate(self.mod1, self.mod1.read().index('attr') + 1) - self.assertEquals(self.encapsulated + 'a_var = A()\n', + self.assertEqual(self.encapsulated + 'a_var = A()\n', self.mod1.read()) def test_performing_in_other_modules(self): @@ -523,11 +523,11 @@ def test_performing_in_other_modules(self): self.mod1.write(code) self.mod.write(self.a_class) self._encapsulate(self.mod1, self.mod1.read().index('attr') + 1) - self.assertEquals(self.encapsulated, self.mod.read()) + self.assertEqual(self.encapsulated, self.mod.read()) expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'range(a_var.get_attr())\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_changing_main_module_occurances(self): code = self.a_class + \ @@ -538,7 +538,7 @@ def test_changing_main_module_occurances(self): expected = self.encapsulated + \ 'a_var = A()\n' \ 'a_var.set_attr(a_var.get_attr() * 2)\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_raising_exception_when_performed_on_non_attributes(self): self.mod1.write('attr = 10') @@ -579,7 +579,7 @@ def test_tuple_assignments_and_function_calls(self): ' pass\n' \ 'a_var = mod.A()\n' \ 'func(a_var.get_attr(), a2=2)\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_tuple_assignments(self): code = 'import mod\n' \ @@ -591,7 +591,7 @@ def test_tuple_assignments(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'a, b = a_var.get_attr(), 1\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_changing_augmented_assignments(self): code = 'import mod\n' \ @@ -603,7 +603,7 @@ def test_changing_augmented_assignments(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'a_var.set_attr(a_var.get_attr() + 1)\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_changing_augmented_assignments2(self): code = 'import mod\n' \ @@ -615,7 +615,7 @@ def test_changing_augmented_assignments2(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'a_var.set_attr(a_var.get_attr() << 1)\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_changing_occurrences_inside_the_class(self): new_class = self.a_class + '\n' \ @@ -627,7 +627,7 @@ def test_changing_occurrences_inside_the_class(self): ' def a_func(self):\n' \ ' self.set_attr(1)\n' + \ self.added_methods - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_getter_and_setter_parameters(self): self.mod.write(self.a_class) @@ -636,17 +636,17 @@ def test_getter_and_setter_parameters(self): new_methods = self.added_methods.replace('get_attr', 'getAttr').\ replace('set_attr', 'setAttr') expected = self.a_class + new_methods - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_using_resources_parameter(self): self.mod1.write('import mod\na = mod.A()\nvar = a.attr\n') self.mod.write(self.a_class) self._encapsulate(self.mod, self.mod.read().index('attr') + 1, resources=[self.mod]) - self.assertEquals('import mod\na = mod.A()\nvar = a.attr\n', + self.assertEqual('import mod\na = mod.A()\nvar = a.attr\n', self.mod1.read()) expected = self.a_class + self.added_methods - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) class LocalToFieldTest(unittest.TestCase): @@ -676,7 +676,7 @@ def test_simple_local_to_field(self): expected = 'class A(object):\n' \ ' def a_func(self):\n' \ ' self.var = 10\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_raising_exception_when_performed_on_a_global_var(self): self.mod.write('var = 10\n') @@ -723,7 +723,7 @@ def test_local_to_field_with_self_renamed(self): expected = 'class A(object):\n' \ ' def a_func(myself):\n' \ ' myself.var = 10\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) class IntroduceParameterTest(unittest.TestCase): @@ -752,7 +752,7 @@ def test_simple_case(self): expected = 'var = 1\n' \ 'def f(var=var):\n' \ ' b = var\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_changing_function_body(self): code = 'var = 1\n' \ @@ -764,14 +764,14 @@ def test_changing_function_body(self): expected = 'var = 1\n' \ 'def f(p1=var):\n' \ ' b = p1\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_unknown_variables(self): self.mod.write('def f():\n b = var + c\n') offset = self.mod.read().rindex('var') with self.assertRaises(RefactoringError): self._introduce_parameter(offset, 'p1') - self.assertEquals('def f(p1=var):\n b = p1 + c\n', + self.assertEqual('def f(p1=var):\n b = p1 + c\n', self.mod.read()) def test_failing_when_not_inside(self): @@ -793,7 +793,7 @@ def test_attribute_accesses(self): 'c = C()\n' \ 'def f(p1=c.a):\n' \ ' b = p1\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_introducing_parameters_for_methods(self): code = 'var = 1\n' \ @@ -807,7 +807,7 @@ def test_introducing_parameters_for_methods(self): 'class C(object):\n' \ ' def f(self, p1=var):\n' \ ' b = p1\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) class _MockTaskObserver(object): @@ -833,7 +833,7 @@ def test_stopping(self): def test_job_sets(self): handle = rope.base.taskhandle.TaskHandle() jobs = handle.create_jobset() - self.assertEquals([jobs], handle.get_jobsets()) + self.assertEqual([jobs], handle.get_jobsets()) def test_starting_and_finishing_jobs(self): handle = rope.base.taskhandle.TaskHandle() @@ -860,14 +860,14 @@ def test_calling_the_observer_after_stopping(self): observer = _MockTaskObserver() handle.add_observer(observer) handle.stop() - self.assertEquals(1, observer.called) + self.assertEqual(1, observer.called) def test_calling_the_observer_after_creating_job_sets(self): handle = rope.base.taskhandle.TaskHandle() observer = _MockTaskObserver() handle.add_observer(observer) jobs = handle.create_jobset() # noqa - self.assertEquals(1, observer.called) + self.assertEqual(1, observer.called) def test_calling_the_observer_when_starting_and_finishing_jobs(self): handle = rope.base.taskhandle.TaskHandle() @@ -876,26 +876,26 @@ def test_calling_the_observer_when_starting_and_finishing_jobs(self): jobs = handle.create_jobset(name='test job set', count=1) jobs.started_job('job1') jobs.finished_job() - self.assertEquals(3, observer.called) + self.assertEqual(3, observer.called) def test_job_set_get_percent_done(self): handle = rope.base.taskhandle.TaskHandle() jobs = handle.create_jobset(name='test job set', count=2) - self.assertEquals(0, jobs.get_percent_done()) + self.assertEqual(0, jobs.get_percent_done()) jobs.started_job('job1') jobs.finished_job() - self.assertEquals(50, jobs.get_percent_done()) + self.assertEqual(50, jobs.get_percent_done()) jobs.started_job('job2') jobs.finished_job() - self.assertEquals(100, jobs.get_percent_done()) + self.assertEqual(100, jobs.get_percent_done()) def test_getting_job_name(self): handle = rope.base.taskhandle.TaskHandle() jobs = handle.create_jobset(name='test job set', count=1) - self.assertEquals('test job set', jobs.get_name()) - self.assertEquals(None, jobs.get_active_job_name()) + self.assertEqual('test job set', jobs.get_name()) + self.assertEqual(None, jobs.get_active_job_name()) jobs.started_job('job1') - self.assertEquals('job1', jobs.get_active_job_name()) + self.assertEqual('job1', jobs.get_active_job_name()) def suite(): diff --git a/ropetest/refactor/change_signature_test.py b/ropetest/refactor/change_signature_test.py index 944ffb548..dd29955c8 100644 --- a/ropetest/refactor/change_signature_test.py +++ b/ropetest/refactor/change_signature_test.py @@ -27,7 +27,7 @@ def test_normalizing_parameters_for_trivial_case(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEquals(code, self.mod.read()) + self.assertEqual(code, self.mod.read()) def test_normalizing_parameters_for_trivial_case2(self): code = 'def a_func(param):\n pass\na_func(2)' @@ -36,7 +36,7 @@ def test_normalizing_parameters_for_trivial_case2(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEquals(code, self.mod.read()) + self.assertEqual(code, self.mod.read()) def test_normalizing_parameters_for_unneeded_keyword(self): self.mod.write('def a_func(param):\n pass\na_func(param=1)') @@ -44,7 +44,7 @@ def test_normalizing_parameters_for_unneeded_keyword(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEquals('def a_func(param):\n pass\na_func(1)', + self.assertEqual('def a_func(param):\n pass\na_func(1)', self.mod.read()) def test_normalizing_parameters_for_unneeded_keyword_for_methods(self): @@ -63,7 +63,7 @@ def test_normalizing_parameters_for_unneeded_keyword_for_methods(self): ' pass\n' \ 'a_var = A()\n' \ 'a_var.a_func(1)\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_normalizing_parameters_for_unsorted_keyword(self): self.mod.write('def a_func(p1, p2):\n pass\na_func(p2=2, p1=1)') @@ -71,7 +71,7 @@ def test_normalizing_parameters_for_unsorted_keyword(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEquals('def a_func(p1, p2):\n pass\na_func(1, 2)', + self.assertEqual('def a_func(p1, p2):\n pass\na_func(1, 2)', self.mod.read()) def test_raising_exceptions_for_non_functions(self): @@ -86,7 +86,7 @@ def test_normalizing_parameters_for_args_parameter(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEquals('def a_func(*arg):\n pass\na_func(1, 2)\n', + self.assertEqual('def a_func(*arg):\n pass\na_func(1, 2)\n', self.mod.read()) def test_normalizing_parameters_for_args_parameter_and_keywords(self): @@ -96,7 +96,7 @@ def test_normalizing_parameters_for_args_parameter_and_keywords(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEquals('def a_func(param, *args):\n pass\n' + self.assertEqual('def a_func(param, *args):\n pass\n' 'a_func(*[1, 2, 3])\n', self.mod.read()) def test_normalizing_functions_from_other_modules(self): @@ -107,7 +107,7 @@ def test_normalizing_functions_from_other_modules(self): self.project, mod1, mod1.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEquals('import mod1\nmod1.a_func(1)\n', self.mod.read()) + self.assertEqual('import mod1\nmod1.a_func(1)\n', self.mod.read()) def test_normalizing_parameters_for_keyword_parameters(self): self.mod.write('def a_func(p1, **kwds):\n pass\n' @@ -116,7 +116,7 @@ def test_normalizing_parameters_for_keyword_parameters(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEquals('def a_func(p1, **kwds):\n pass\n' + self.assertEqual('def a_func(p1, **kwds):\n pass\n' 'a_func(1, p2=2)\n', self.mod.read()) def test_removing_arguments(self): @@ -125,7 +125,7 @@ def test_removing_arguments(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(0)])) - self.assertEquals('def a_func():\n pass\na_func()\n', + self.assertEqual('def a_func():\n pass\na_func()\n', self.mod.read()) def test_removing_arguments_with_multiple_args(self): @@ -134,7 +134,7 @@ def test_removing_arguments_with_multiple_args(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(0)])) - self.assertEquals('def a_func(p2):\n pass\na_func(2)\n', + self.assertEqual('def a_func(p2):\n pass\na_func(2)\n', self.mod.read()) def test_removing_arguments_passed_as_keywords(self): @@ -143,7 +143,7 @@ def test_removing_arguments_passed_as_keywords(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(0)])) - self.assertEquals('def a_func():\n pass\na_func()\n', + self.assertEqual('def a_func():\n pass\na_func()\n', self.mod.read()) def test_removing_arguments_with_defaults(self): @@ -152,7 +152,7 @@ def test_removing_arguments_with_defaults(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(0)])) - self.assertEquals('def a_func():\n pass\na_func()\n', + self.assertEqual('def a_func():\n pass\na_func()\n', self.mod.read()) def test_removing_arguments_star_args(self): @@ -161,7 +161,7 @@ def test_removing_arguments_star_args(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(1)])) - self.assertEquals('def a_func(p1):\n pass\na_func(1)\n', + self.assertEqual('def a_func(p1):\n pass\na_func(1)\n', self.mod.read()) def test_removing_keyword_arg(self): @@ -170,7 +170,7 @@ def test_removing_keyword_arg(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(1)])) - self.assertEquals('def a_func(p1):\n pass\na_func(1)\n', + self.assertEqual('def a_func(p1):\n pass\na_func(1)\n', self.mod.read()) def test_removing_keyword_arg2(self): @@ -179,7 +179,7 @@ def test_removing_keyword_arg2(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(2)])) - self.assertEquals('def a_func(p1, *args):\n pass\na_func(1)\n', + self.assertEqual('def a_func(p1, *args):\n pass\na_func(1)\n', self.mod.read()) # XXX: What to do here for star args? @@ -191,7 +191,7 @@ def xxx_test_removing_arguments_star_args2(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(1)])) - self.assertEquals('def a_func(p1):\n pass\na_func(p1=1)\n', + self.assertEqual('def a_func(p1):\n pass\na_func(p1=1)\n', self.mod.read()) # XXX: What to do here for star args? @@ -202,7 +202,7 @@ def xxx_test_removing_arguments_star_args3(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(1)])) - self.assertEquals('def a_func(p1):\n pass\na_func(*[1, 2, 3])\n', + self.assertEqual('def a_func(p1):\n pass\na_func(*[1, 2, 3])\n', self.mod.read()) def test_adding_arguments_for_normal_args_changing_definition(self): @@ -211,7 +211,7 @@ def test_adding_arguments_for_normal_args_changing_definition(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentAdder(0, 'p1')])) - self.assertEquals('def a_func(p1):\n pass\n', self.mod.read()) + self.assertEqual('def a_func(p1):\n pass\n', self.mod.read()) def test_adding_arguments_for_normal_args_with_defaults(self): self.mod.write('def a_func():\n pass\na_func()\n') @@ -219,7 +219,7 @@ def test_adding_arguments_for_normal_args_with_defaults(self): self.project, self.mod, self.mod.read().index('a_func') + 1) adder = change_signature.ArgumentAdder(0, 'p1', 'None') self.project.do(signature.get_changes([adder])) - self.assertEquals('def a_func(p1=None):\n pass\na_func()\n', + self.assertEqual('def a_func(p1=None):\n pass\na_func()\n', self.mod.read()) def test_adding_arguments_for_normal_args_changing_calls(self): @@ -228,7 +228,7 @@ def test_adding_arguments_for_normal_args_changing_calls(self): self.project, self.mod, self.mod.read().index('a_func') + 1) adder = change_signature.ArgumentAdder(0, 'p1', 'None', '1') self.project.do(signature.get_changes([adder])) - self.assertEquals('def a_func(p1=None):\n pass\na_func(1)\n', + self.assertEqual('def a_func(p1=None):\n pass\na_func(1)\n', self.mod.read()) def test_adding_arguments_for_norm_args_chang_calls_with_kwords(self): @@ -237,7 +237,7 @@ def test_adding_arguments_for_norm_args_chang_calls_with_kwords(self): self.project, self.mod, self.mod.read().index('a_func') + 1) adder = change_signature.ArgumentAdder(1, 'p2', '0', '1') self.project.do(signature.get_changes([adder])) - self.assertEquals('def a_func(p1=0, p2=0):\n pass\na_func(p2=1)\n', + self.assertEqual('def a_func(p1=0, p2=0):\n pass\na_func(p2=1)\n', self.mod.read()) def test_adding_arguments_for_norm_args_chang_calls_with_no_value(self): @@ -246,7 +246,7 @@ def test_adding_arguments_for_norm_args_chang_calls_with_no_value(self): self.project, self.mod, self.mod.read().index('a_func') + 1) adder = change_signature.ArgumentAdder(0, 'p1', '0', None) self.project.do(signature.get_changes([adder])) - self.assertEquals('def a_func(p1=0, p2=0):\n pass\na_func(p2=1)\n', + self.assertEqual('def a_func(p1=0, p2=0):\n pass\na_func(p2=1)\n', self.mod.read()) def test_adding_duplicate_parameter_and_raising_exceptions(self): @@ -263,7 +263,7 @@ def test_inlining_default_arguments(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentDefaultInliner(0)])) - self.assertEquals('def a_func(p1=0):\n pass\n' + self.assertEqual('def a_func(p1=0):\n pass\n' 'a_func(0)\n', self.mod.read()) def test_inlining_default_arguments2(self): @@ -272,7 +272,7 @@ def test_inlining_default_arguments2(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentDefaultInliner(0)])) - self.assertEquals('def a_func(p1=0):\n pass\n' + self.assertEqual('def a_func(p1=0):\n pass\n' 'a_func(1)\n', self.mod.read()) def test_preserving_args_and_keywords_order(self): @@ -282,7 +282,7 @@ def test_preserving_args_and_keywords_order(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEquals('def a_func(*args, **kwds):\n pass\n' + self.assertEqual('def a_func(*args, **kwds):\n pass\n' 'a_func(3, 1, 2, a=1, c=3, b=2)\n', self.mod.read()) def test_change_order_for_only_one_parameter(self): @@ -291,7 +291,7 @@ def test_change_order_for_only_one_parameter(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentReorderer([0])])) - self.assertEquals('def a_func(p1):\n pass\na_func(1)\n', + self.assertEqual('def a_func(p1):\n pass\na_func(1)\n', self.mod.read()) def test_change_order_for_two_parameter(self): @@ -300,7 +300,7 @@ def test_change_order_for_two_parameter(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentReorderer([1, 0])])) - self.assertEquals('def a_func(p2, p1):\n pass\na_func(2, 1)\n', + self.assertEqual('def a_func(p2, p1):\n pass\na_func(2, 1)\n', self.mod.read()) def test_reordering_multi_line_function_headers(self): @@ -309,7 +309,7 @@ def test_reordering_multi_line_function_headers(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentReorderer([1, 0])])) - self.assertEquals('def a_func(p2, p1):\n pass\na_func(2, 1)\n', + self.assertEqual('def a_func(p2, p1):\n pass\na_func(2, 1)\n', self.mod.read()) def test_changing_order_with_static_params(self): @@ -318,7 +318,7 @@ def test_changing_order_with_static_params(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentReorderer([0, 2, 1])])) - self.assertEquals('def a_func(p1, p3=0, p2=0):\n pass\n' + self.assertEqual('def a_func(p1, p3=0, p2=0):\n pass\n' 'a_func(1, p2=2)\n', self.mod.read()) def test_doing_multiple_changes(self): @@ -329,7 +329,7 @@ def test_doing_multiple_changes(self): signature = change_signature.ChangeSignature( self.project, self.mod, self.mod.read().index('a_func') + 1) signature.get_changes(changers).do() - self.assertEquals('def a_func(p2):\n pass\na_func()\n', + self.assertEqual('def a_func(p2):\n pass\na_func()\n', self.mod.read()) def test_doing_multiple_changes2(self): @@ -341,7 +341,7 @@ def test_doing_multiple_changes2(self): signature = change_signature.ChangeSignature( self.project, self.mod, self.mod.read().index('a_func') + 1) signature.get_changes(changers).do() - self.assertEquals('def a_func(p2, p3):\n pass\na_func(2, 3)\n', + self.assertEqual('def a_func(p2, p3):\n pass\na_func(2, 3)\n', self.mod.read()) def test_changing_signature_in_subclasses(self): @@ -352,7 +352,7 @@ def test_changing_signature_in_subclasses(self): self.project, self.mod, self.mod.read().index('a_method') + 1) signature.get_changes([change_signature.ArgumentAdder(1, 'p1')], in_hierarchy=True).do() - self.assertEquals( + self.assertEqual( 'class A(object):\n def a_method(self, p1):\n pass\n' 'class B(A):\n def a_method(self, p1):\n pass\n', self.mod.read()) @@ -365,7 +365,7 @@ def test_differentiating_class_accesses_from_instance_accesses(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(1)])) - self.assertEquals( + self.assertEqual( 'class A(object):\n def a_func(self):\n pass\n' 'a_var = A()\nA.a_func(a_var)', self.mod.read()) @@ -376,7 +376,7 @@ def test_changing_signature_for_constructors(self): signature = change_signature.ChangeSignature( self.project, self.mod, self.mod.read().index('C') + 1) signature.get_changes([change_signature.ArgumentRemover(1)]).do() - self.assertEquals( + self.assertEqual( 'class C(object):\n def __init__(self):\n pass\n' 'c = C()\n', self.mod.read()) @@ -388,7 +388,7 @@ def test_changing_signature_for_constructors2(self): signature = change_signature.ChangeSignature( self.project, self.mod, self.mod.read().index('__init__') + 1) signature.get_changes([change_signature.ArgumentRemover(1)]).do() - self.assertEquals( + self.assertEqual( 'class C(object):\n def __init__(self):\n pass\n' 'c = C()\n', self.mod.read()) @@ -401,7 +401,7 @@ def test_changing_signature_for_constructors_when_using_super(self): signature = change_signature.ChangeSignature( self.project, self.mod, self.mod.read().index('__init__') + 1) signature.get_changes([change_signature.ArgumentRemover(1)]).do() - self.assertEquals( + self.assertEqual( 'class A(object):\n def __init__(self):\n pass\n' 'class B(A):\n ' 'def __init__(self, p):\n super(B, self).__init__()\n', @@ -413,7 +413,7 @@ def test_redordering_arguments_reported_by_mft(self): self.project, self.mod, self.mod.read().rindex('f')) signature.get_changes( [change_signature.ArgumentReorderer([1, 2, 0])]).do() - self.assertEquals('def f(b, c, a):\n pass\nf(2, 3, 1)\n', + self.assertEqual('def f(b, c, a):\n pass\nf(2, 3, 1)\n', self.mod.read()) def test_resources_parameter(self): @@ -424,8 +424,8 @@ def test_resources_parameter(self): self.project, mod1, mod1.read().index('a_func') + 1) signature.get_changes([change_signature.ArgumentRemover(0)], resources=[mod1]).do() - self.assertEquals('import mod1\nmod1.a_func(1)\n', self.mod.read()) - self.assertEquals('def a_func():\n pass\n', mod1.read()) + self.assertEqual('import mod1\nmod1.a_func(1)\n', self.mod.read()) + self.assertEqual('def a_func():\n pass\n', mod1.read()) def test_reordering_and_automatic_defaults(self): code = 'def f(p1, p2=2):\n' \ @@ -439,7 +439,7 @@ def test_reordering_and_automatic_defaults(self): expected = 'def f(p2=2, p1=1):\n' \ ' pass\n' \ 'f(2, 1)\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) if __name__ == '__main__': diff --git a/ropetest/refactor/extracttest.py b/ropetest/refactor/extracttest.py index de48b3895..104cad66a 100644 --- a/ropetest/refactor/extracttest.py +++ b/ropetest/refactor/extracttest.py @@ -45,7 +45,7 @@ def test_simple_extract_function(self): refactored = self.do_extract_method(code, start, end, 'extracted') expected = "def a_func():\n extracted()\n print('two')\n\n" \ "def extracted():\n print('one')\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_function_at_the_end_of_file(self): code = "def a_func():\n print('one')" @@ -53,7 +53,7 @@ def test_extract_function_at_the_end_of_file(self): refactored = self.do_extract_method(code, start, end, 'extracted') expected = "def a_func():\n extracted()\n" \ "def extracted():\n print('one')\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_function_after_scope(self): code = "def a_func():\n print('one')\n print('two')" \ @@ -62,7 +62,7 @@ def test_extract_function_after_scope(self): refactored = self.do_extract_method(code, start, end, 'extracted') expected = "def a_func():\n extracted()\n print('two')\n\n" \ "def extracted():\n print('one')\n\nprint('hey')\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_simple_extract_function_with_parameter(self): code = "def a_func():\n a_var = 10\n print(a_var)\n" @@ -70,7 +70,7 @@ def test_simple_extract_function_with_parameter(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = "def a_func():\n a_var = 10\n new_func(a_var)\n\n" \ "def new_func(a_var):\n print(a_var)\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_not_unread_variables_as_parameter(self): code = "def a_func():\n a_var = 10\n print('hey')\n" @@ -78,7 +78,7 @@ def test_not_unread_variables_as_parameter(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = "def a_func():\n a_var = 10\n new_func()\n\n" \ "def new_func():\n print('hey')\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_simple_extract_function_with_two_parameter(self): code = 'def a_func():\n a_var = 10\n another_var = 20\n' \ @@ -89,7 +89,7 @@ def test_simple_extract_function_with_two_parameter(self): ' new_func(a_var, another_var)\n\n' \ 'def new_func(a_var, another_var):\n' \ ' third_var = a_var + another_var\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_simple_extract_function_with_return_value(self): code = 'def a_func():\n a_var = 10\n print(a_var)\n' @@ -98,7 +98,7 @@ def test_simple_extract_function_with_return_value(self): expected = 'def a_func():\n a_var = new_func()' \ '\n print(a_var)\n\n' \ 'def new_func():\n a_var = 10\n return a_var\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_function_with_multiple_return_values(self): code = 'def a_func():\n a_var = 10\n another_var = 20\n' \ @@ -109,7 +109,7 @@ def test_extract_function_with_multiple_return_values(self): ' third_var = a_var + another_var\n\n' \ 'def new_func():\n a_var = 10\n another_var = 20\n' \ ' return a_var, another_var\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_simple_extract_method(self): code = 'class AClass(object):\n\n' \ @@ -121,7 +121,7 @@ def test_simple_extract_method(self): ' self.new_func()\n' \ ' print(2)\n\n' \ ' def new_func(self):\n print(1)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_with_args_and_returns(self): code = 'class AClass(object):\n' \ @@ -139,7 +139,7 @@ def test_extract_method_with_args_and_returns(self): ' def new_func(self, a_var):\n' \ ' another_var = a_var * 3\n' \ ' return another_var\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_with_self_as_argument(self): code = 'class AClass(object):\n' \ @@ -152,7 +152,7 @@ def test_extract_method_with_self_as_argument(self): ' self.new_func()\n\n' \ ' def new_func(self):\n' \ ' print(self)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_with_no_self_as_argument(self): code = 'class AClass(object):\n' \ @@ -177,7 +177,7 @@ def test_extract_method_with_multiple_methods(self): ' print(self)\n\n' \ ' def another_func(self):\n' \ ' pass\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_function_with_function_returns(self): code = 'def a_func():\n def inner_func():\n pass\n' \ @@ -189,7 +189,7 @@ def test_extract_function_with_function_returns(self): 'def new_func():\n' \ ' def inner_func():\n pass\n' \ ' return inner_func\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_simple_extract_global_function(self): code = "print('one')\nprint('two')\nprint('three')\n" @@ -197,7 +197,7 @@ def test_simple_extract_global_function(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = "print('one')\n\ndef new_func():\n print('two')\n" \ "\nnew_func()\nprint('three')\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_global_function_inside_ifs(self): code = 'if True:\n a = 10\n' @@ -205,7 +205,7 @@ def test_extract_global_function_inside_ifs(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = '\ndef new_func():\n a = 10\n\nif True:\n' \ ' new_func()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_function_while_inner_function_reads(self): code = 'def a_func():\n a_var = 10\n' \ @@ -219,7 +219,7 @@ def test_extract_function_while_inner_function_reads(self): 'def new_func(a_var):\n' \ ' def inner_func():\n print(a_var)\n' \ ' return inner_func\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_bad_range(self): code = "def a_func():\n pass\na_var = 10\n" @@ -266,7 +266,7 @@ def test_extract_function_and_argument_as_paramenter(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = 'def a_func(arg):\n new_func(arg)\n\n' \ 'def new_func(arg):\n print(arg)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_function_and_end_as_the_start_of_a_line(self): code = 'print("hey")\nif True:\n pass\n' @@ -275,7 +275,7 @@ def test_extract_function_and_end_as_the_start_of_a_line(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = '\ndef new_func():\n print("hey")\n\n' \ 'new_func()\nif True:\n pass\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_function_and_indented_blocks(self): code = 'def a_func(arg):\n if True:\n' \ @@ -285,7 +285,7 @@ def test_extract_function_and_indented_blocks(self): expected = 'def a_func(arg):\n ' \ 'if True:\n new_func(arg)\n\n' \ 'def new_func(arg):\n if True:\n print(arg)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_and_multi_line_headers(self): code = 'def a_func(\n arg):\n print(arg)\n' @@ -293,7 +293,7 @@ def test_extract_method_and_multi_line_headers(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = 'def a_func(\n arg):\n new_func(arg)\n\n' \ 'def new_func(arg):\n print(arg)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_single_line_extract_function(self): code = 'a_var = 10 + 20\n' @@ -302,7 +302,7 @@ def test_single_line_extract_function(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = "\ndef new_func():\n " \ "return 10 + 20\n\na_var = new_func()\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_single_line_extract_function2(self): code = 'def a_func():\n a = 10\n b = a * 20\n' @@ -311,7 +311,7 @@ def test_single_line_extract_function2(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = 'def a_func():\n a = 10\n b = new_func(a)\n' \ '\ndef new_func(a):\n return a * 20\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_single_line_extract_method_and_logical_lines(self): code = 'a_var = 10 +\\\n 20\n' @@ -320,7 +320,7 @@ def test_single_line_extract_method_and_logical_lines(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = '\ndef new_func():\n ' \ 'return 10 + 20\n\na_var = new_func()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_single_line_extract_method_and_logical_lines2(self): code = 'a_var = (10,\\\n 20)\n' @@ -329,7 +329,7 @@ def test_single_line_extract_method_and_logical_lines2(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = '\ndef new_func():\n' \ ' return (10, 20)\n\na_var = new_func()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_single_line_extract_method(self): code = "class AClass(object):\n\n" \ @@ -341,7 +341,7 @@ def test_single_line_extract_method(self): ' def a_func(self):\n' \ ' a = 10\n b = self.new_func(a)\n\n' \ ' def new_func(self, a):\n return a * a\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_single_line_extract_function_if_condition(self): code = 'if True:\n pass\n' @@ -350,7 +350,7 @@ def test_single_line_extract_function_if_condition(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = "\ndef new_func():\n return True\n\nif new_func():" \ "\n pass\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_unneeded_params(self): code = 'class A(object):\n ' \ @@ -362,7 +362,7 @@ def test_unneeded_params(self): ' def a_func(self):\n a_var = 10\n' \ ' a_var += self.new_func()\n\n' \ ' def new_func(self):\n return 2\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_breaks_and_continues_inside_loops(self): code = 'def a_func():\n for i in range(10):\n continue\n' @@ -372,7 +372,7 @@ def test_breaks_and_continues_inside_loops(self): expected = 'def a_func():\n new_func()\n\n' \ 'def new_func():\n' \ ' for i in range(10):\n continue\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_breaks_and_continues_outside_loops(self): code = 'def a_func():\n' \ @@ -389,7 +389,7 @@ def test_variable_writes_followed_by_variable_reads_after_extraction(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = 'def a_func():\n new_func()\n a = 2\n b = a\n\n' \ 'def new_func():\n a = 1\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_var_writes_followed_by_var_reads_inside_extraction(self): code = 'def a_func():\n a = 1\n a = 2\n b = a\n' @@ -398,7 +398,7 @@ def test_var_writes_followed_by_var_reads_inside_extraction(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = 'def a_func():\n a = 1\n new_func()\n\n' \ 'def new_func():\n a = 2\n b = a\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable(self): code = 'a_var = 10 + 20\n' @@ -406,7 +406,7 @@ def test_extract_variable(self): end = code.index('20') + 2 refactored = self.do_extract_variable(code, start, end, 'new_var') expected = 'new_var = 10 + 20\na_var = new_var\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_multiple_lines(self): code = 'a = 1\nb = 2\n' @@ -414,7 +414,7 @@ def test_extract_variable_multiple_lines(self): end = code.index('1') + 1 refactored = self.do_extract_variable(code, start, end, 'c') expected = 'c = 1\na = c\nb = 2\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_in_the_middle_of_statements(self): code = 'a = 1 + 2\n' @@ -422,7 +422,7 @@ def test_extract_variable_in_the_middle_of_statements(self): end = code.index('1') + 1 refactored = self.do_extract_variable(code, start, end, 'c') expected = 'c = 1\na = c + 2\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_for_a_tuple(self): code = 'a = 1, 2\n' @@ -430,7 +430,7 @@ def test_extract_variable_for_a_tuple(self): end = code.index('2') + 1 refactored = self.do_extract_variable(code, start, end, 'c') expected = 'c = 1, 2\na = c\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_for_a_string(self): code = 'def a_func():\n a = "hey!"\n' @@ -438,7 +438,7 @@ def test_extract_variable_for_a_string(self): end = code.rindex('"') + 1 refactored = self.do_extract_variable(code, start, end, 'c') expected = 'def a_func():\n c = "hey!"\n a = c\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_inside_ifs(self): code = 'if True:\n a = 1 + 2\n' @@ -446,7 +446,7 @@ def test_extract_variable_inside_ifs(self): end = code.rindex('2') + 1 refactored = self.do_extract_variable(code, start, end, 'b') expected = 'if True:\n b = 1 + 2\n a = b\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_inside_ifs_and_logical_lines(self): code = 'if True:\n a = (3 + \n(1 + 2))\n' @@ -454,7 +454,7 @@ def test_extract_variable_inside_ifs_and_logical_lines(self): end = code.index('2') + 1 refactored = self.do_extract_variable(code, start, end, 'b') expected = 'if True:\n b = 1 + 2\n a = (3 + \n(b))\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) # TODO: Handle when extracting a subexpression def xxx_test_extract_variable_for_a_subexpression(self): @@ -463,7 +463,7 @@ def xxx_test_extract_variable_for_a_subexpression(self): end = code.index('2') + 1 refactored = self.do_extract_variable(code, start, end, 'b') expected = 'b = 1 + 2\na = 3 + b\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_starting_from_the_start_of_the_line(self): code = 'a_dict = {1: 1}\na_dict.values().count(1)\n' @@ -472,7 +472,7 @@ def test_extract_variable_starting_from_the_start_of_the_line(self): refactored = self.do_extract_variable(code, start, end, 'values') expected = 'a_dict = {1: 1}\n' \ 'values = a_dict.values()\nvalues.count(1)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_on_the_last_line_of_a_function(self): code = 'def f():\n a_var = {}\n a_var.keys()\n' @@ -481,7 +481,7 @@ def test_extract_variable_on_the_last_line_of_a_function(self): refactored = self.do_extract_variable(code, start, end, 'new_var') expected = 'def f():\n a_var = {}\n ' \ 'new_var = a_var\n new_var.keys()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_on_the_indented_function_statement(self): code = 'def f():\n if True:\n a_var = 1 + 2\n' @@ -490,7 +490,7 @@ def test_extract_variable_on_the_indented_function_statement(self): refactored = self.do_extract_variable(code, start, end, 'new_var') expected = 'def f():\n if True:\n' \ ' new_var = 1 + 2\n a_var = new_var\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_on_the_last_line_of_a_function(self): code = 'def f():\n a_var = {}\n a_var.keys()\n' @@ -499,7 +499,7 @@ def test_extract_method_on_the_last_line_of_a_function(self): refactored = self.do_extract_method(code, start, end, 'new_f') expected = 'def f():\n a_var = {}\n new_f(a_var).keys()\n\n' \ 'def new_f(a_var):\n return a_var\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_raising_exception_when_on_incomplete_variables(self): code = 'a_var = 10 + 20\n' @@ -541,7 +541,7 @@ def test_extract_method_and_extra_blank_lines(self): code = '\nprint(1)\n' refactored = self.do_extract_method(code, 0, len(code), 'new_f') expected = '\n\ndef new_f():\n print(1)\n\nnew_f()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_variable_writes_in_the_same_line_as_variable_read(self): code = 'a = 1\na = 1 + a\n' @@ -550,7 +550,7 @@ def test_variable_writes_in_the_same_line_as_variable_read(self): refactored = self.do_extract_method(code, start, end, 'new_f', global_=True) expected = 'a = 1\n\ndef new_f(a):\n a = 1 + a\n\nnew_f(a)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_variable_writes_in_the_same_line_as_variable_read2(self): code = 'a = 1\na += 1\n' @@ -559,7 +559,7 @@ def test_variable_writes_in_the_same_line_as_variable_read2(self): refactored = self.do_extract_method(code, start, end, 'new_f', global_=True) expected = 'a = 1\n\ndef new_f():\n a += 1\n\nnew_f()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_variable_and_similar_expressions(self): code = 'a = 1\nb = 1\n' @@ -568,7 +568,7 @@ def test_variable_and_similar_expressions(self): refactored = self.do_extract_variable(code, start, end, 'one', similar=True) expected = 'one = 1\na = one\nb = one\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_definition_should_appear_before_the_first_use(self): code = 'a = 1\nb = 1\n' @@ -577,7 +577,7 @@ def test_definition_should_appear_before_the_first_use(self): refactored = self.do_extract_variable(code, start, end, 'one', similar=True) expected = 'one = 1\na = one\nb = one\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_and_similar_expressions(self): code = 'a = 1\nb = 1\n' @@ -586,7 +586,7 @@ def test_extract_method_and_similar_expressions(self): refactored = self.do_extract_method(code, start, end, 'one', similar=True) expected = '\ndef one():\n return 1\n\na = one()\nb = one()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_simple_extract_method_and_similar_statements(self): code = 'class AClass(object):\n\n' \ @@ -602,7 +602,7 @@ def test_simple_extract_method_and_similar_statements(self): ' a = 1 + 2\n return a\n' \ ' def func2(self):\n' \ ' a = self.new_func()\n b = a\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_and_similar_statements2(self): code = 'class AClass(object):\n\n' \ @@ -617,7 +617,7 @@ def test_extract_method_and_similar_statements2(self): 'a = self.new_func(p1)\n\n' \ ' def new_func(self, p1):\n return p1 + 2\n' \ ' def func2(self, p2):\n a = self.new_func(p2)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_and_similar_sttemnts_return_is_different(self): code = 'class AClass(object):\n\n' \ @@ -633,7 +633,7 @@ def test_extract_method_and_similar_sttemnts_return_is_different(self): ' def new_func(self, p1):\n return p1 + 2\n' \ ' def func2(self, p2):\n' \ ' self.attr = self.new_func(p2)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_definition_should_appear_where_it_is_visible(self): code = 'if True:\n a = 1\nelse:\n b = 1\n' @@ -642,7 +642,7 @@ def test_definition_should_appear_where_it_is_visible(self): refactored = self.do_extract_variable(code, start, end, 'one', similar=True) expected = 'one = 1\nif True:\n a = one\nelse:\n b = one\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_and_similar_statements_in_classes(self): code = 'class AClass(object):\n\n' \ @@ -654,7 +654,7 @@ def test_extract_variable_and_similar_statements_in_classes(self): expected = 'class AClass(object):\n\n' \ ' def func1(self):\n one = 1\n a = one\n' \ ' def func2(self):\n b = 1\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_in_staticmethods(self): code = 'class AClass(object):\n\n' \ @@ -667,7 +667,7 @@ def test_extract_method_in_staticmethods(self): ' b = AClass.one()\n\n' \ ' @staticmethod\n def one():\n' \ ' return 1\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_normal_method_with_staticmethods(self): code = 'class AClass(object):\n\n' \ @@ -680,7 +680,7 @@ def test_extract_normal_method_with_staticmethods(self): ' @staticmethod\n def func1():\n b = 1\n' \ ' def func2(self):\n b = self.one()\n\n' \ ' def one(self):\n return 1\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_variable_with_no_new_lines_at_the_end(self): code = 'a_var = 10' @@ -688,7 +688,7 @@ def test_extract_variable_with_no_new_lines_at_the_end(self): end = start + 2 refactored = self.do_extract_variable(code, start, end, 'new_var') expected = 'new_var = 10\na_var = new_var' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_containing_return_in_functions(self): code = 'def f(arg):\n return arg\nprint(f(1))\n' @@ -696,7 +696,7 @@ def test_extract_method_containing_return_in_functions(self): refactored = self.do_extract_method(code, start, end, 'a_func') expected = '\ndef a_func():\n def f(arg):\n return arg\n' \ ' print(f(1))\n\na_func()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_and_varying_first_parameter(self): code = 'class C(object):\n' \ @@ -710,7 +710,7 @@ def test_extract_method_and_varying_first_parameter(self): ' def f1(self):\n print(self.to_str())\n\n' \ ' def to_str(self):\n return str(self)\n' \ ' def f2(self):\n print(str(1))\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_when_an_attribute_exists_in_function_scope(self): code = 'class A(object):\n def func(self):\n pass\n' \ @@ -724,7 +724,7 @@ def test_extract_method_when_an_attribute_exists_in_function_scope(self): refactored = refactored[refactored.index('A()') + 4:] expected = 'def f():\n func = g()\n print(func)\n\n' \ 'def g():\n func = a.func()\n return func\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_global_option_for_extract_method(self): code = 'def a_func():\n print(1)\n' @@ -733,7 +733,7 @@ def test_global_option_for_extract_method(self): 'extracted', global_=True) expected = 'def a_func():\n extracted()\n\n' \ 'def extracted():\n print(1)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_global_extract_method(self): code = 'class AClass(object):\n\n' \ @@ -744,7 +744,7 @@ def test_global_extract_method(self): expected = 'class AClass(object):\n\n' \ ' def a_func(self):\n new_func()\n\n' \ 'def new_func():\n print(1)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_with_multiple_methods(self): # noqa code = 'class AClass(object):\n' \ @@ -762,7 +762,7 @@ def test_extract_method_with_multiple_methods(self): # noqa ' pass\n\n' \ 'def new_func():\n' \ ' print(1)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_where_to_seach_when_extracting_global_names(self): code = 'def a():\n return 1\ndef b():\n return 1\nb = 1\n' @@ -772,7 +772,7 @@ def test_where_to_seach_when_extracting_global_names(self): similar=True, global_=True) expected = 'def a():\n return one\none = 1\n' \ 'def b():\n return one\nb = one\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extracting_pieces_with_distinct_temp_names(self): code = 'a = 1\nprint(a)\nb = 1\nprint(b)\n' @@ -781,7 +781,7 @@ def test_extracting_pieces_with_distinct_temp_names(self): refactored = self.do_extract_method(code, start, end, 'f', similar=True, global_=True) expected = '\ndef f():\n a = 1\n print(a)\n\nf()\nf()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_methods_in_glob_funcs_should_be_glob(self): code = 'def f():\n a = 1\ndef g():\n b = 1\n' @@ -790,7 +790,7 @@ def test_extract_methods_in_glob_funcs_should_be_glob(self): similar=True, global_=False) expected = 'def f():\n a = one()\ndef g():\n b = one()\n\n' \ 'def one():\n return 1\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_methods_in_glob_funcs_should_be_glob_2(self): code = 'if 1:\n var = 2\n' @@ -798,7 +798,7 @@ def test_extract_methods_in_glob_funcs_should_be_glob_2(self): refactored = self.do_extract_method(code, start, start + 1, 'two', similar=True, global_=False) expected = '\ndef two():\n return 2\n\nif 1:\n var = two()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_and_try_blocks(self): code = 'def f():\n try:\n pass\n' \ @@ -807,7 +807,7 @@ def test_extract_method_and_try_blocks(self): refactored = self.do_extract_method(code, start, end, 'g') expected = 'def f():\n g()\n\ndef g():\n try:\n pass\n' \ ' except Exception:\n pass\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_and_not_passing_global_functions(self): code = 'def next(p):\n return p + 1\nvar = next(1)\n' @@ -815,7 +815,7 @@ def test_extract_and_not_passing_global_functions(self): refactored = self.do_extract_method(code, start, len(code) - 1, 'two') expected = 'def next(p):\n return p + 1\n' \ '\ndef two():\n return next(1)\n\nvar = two()\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extracting_with_only_one_return(self): code = 'def f():\n var = 1\n return var\n' @@ -823,7 +823,7 @@ def test_extracting_with_only_one_return(self): refactored = self.do_extract_method(code, start, end, 'g') expected = 'def f():\n return g()\n\n' \ 'def g():\n var = 1\n return var\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extracting_variable_and_implicit_continuations(self): code = 's = ("1"\n "2")\n' @@ -831,7 +831,7 @@ def test_extracting_variable_and_implicit_continuations(self): end = code.rindex('"') + 1 refactored = self.do_extract_variable(code, start, end, 's2') expected = 's2 = "1" "2"\ns = (s2)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extracting_method_and_implicit_continuations(self): code = 's = ("1"\n "2")\n' @@ -839,7 +839,7 @@ def test_extracting_method_and_implicit_continuations(self): end = code.rindex('"') + 1 refactored = self.do_extract_method(code, start, end, 'f') expected = '\ndef f():\n return "1" "2"\n\ns = (f())\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_passing_conditional_updated_vars_in_extracted(self): code = 'def f(a):\n' \ @@ -854,7 +854,7 @@ def test_passing_conditional_updated_vars_in_extracted(self): ' if 0:\n' \ ' a = 1\n' \ ' print(a)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_returning_conditional_updated_vars_in_extracted(self): code = 'def f(a):\n' \ @@ -870,7 +870,7 @@ def test_returning_conditional_updated_vars_in_extracted(self): ' if 0:\n' \ ' a = 1\n' \ ' return a\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_with_variables_possibly_written_to(self): code = "def a_func(b):\n" \ @@ -886,7 +886,7 @@ def test_extract_method_with_variables_possibly_written_to(self): " if b > 0:\n" \ " a = 2\n" \ " return a\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_with_list_comprehension(self): code = "def foo():\n" \ @@ -908,7 +908,7 @@ def test_extract_method_with_list_comprehension(self): " for e, f in []:\n" \ " def bar():\n" \ " e[42] = 1\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_with_list_comprehension_and_iter(self): code = "def foo():\n" \ @@ -930,7 +930,7 @@ def test_extract_method_with_list_comprehension_and_iter(self): " for x, f in x:\n" \ " def bar():\n" \ " x[42] = 1\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_extract_method_with_list_comprehension_and_orelse(self): code = "def foo():\n" \ @@ -952,7 +952,7 @@ def test_extract_method_with_list_comprehension_and_orelse(self): " for e, f in []:\n" \ " def bar():\n" \ " e[42] = 1\n" - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) if __name__ == '__main__': unittest.main() diff --git a/ropetest/refactor/importutilstest.py b/ropetest/refactor/importutilstest.py index 73f52b822..5363f0c7b 100644 --- a/ropetest/refactor/importutilstest.py +++ b/ropetest/refactor/importutilstest.py @@ -30,38 +30,38 @@ def tearDown(self): def test_get_import_for_module(self): mod = self.project.find_module('mod') import_statement = self.import_tools.get_import(mod) - self.assertEquals('import mod', + self.assertEqual('import mod', import_statement.get_import_statement()) def test_get_import_for_module_in_nested_modules(self): mod = self.project.find_module('pkg1.mod1') import_statement = self.import_tools.get_import(mod) - self.assertEquals('import pkg1.mod1', + self.assertEqual('import pkg1.mod1', import_statement.get_import_statement()) def test_get_import_for_module_in_init_dot_py(self): init_dot_py = self.pkg1.get_child('__init__.py') import_statement = self.import_tools.get_import(init_dot_py) - self.assertEquals('import pkg1', + self.assertEqual('import pkg1', import_statement.get_import_statement()) def test_get_from_import_for_module(self): mod = self.project.find_module('mod') import_statement = self.import_tools.get_from_import(mod, 'a_func') - self.assertEquals('from mod import a_func', + self.assertEqual('from mod import a_func', import_statement.get_import_statement()) def test_get_from_import_for_module_in_nested_modules(self): mod = self.project.find_module('pkg1.mod1') import_statement = self.import_tools.get_from_import(mod, 'a_func') - self.assertEquals('from pkg1.mod1 import a_func', + self.assertEqual('from pkg1.mod1 import a_func', import_statement.get_import_statement()) def test_get_from_import_for_module_in_init_dot_py(self): init_dot_py = self.pkg1.get_child('__init__.py') import_statement = self.import_tools.\ get_from_import(init_dot_py, 'a_func') - self.assertEquals('from pkg1 import a_func', + self.assertEqual('from pkg1 import a_func', import_statement.get_import_statement()) def test_get_import_statements(self): @@ -69,7 +69,7 @@ def test_get_import_statements(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEquals('import pkg1', + self.assertEqual('import pkg1', imports[0].import_info.get_import_statement()) def test_get_import_statements_with_alias(self): @@ -77,7 +77,7 @@ def test_get_import_statements_with_alias(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEquals('import pkg1.mod1 as mod1', + self.assertEqual('import pkg1.mod1 as mod1', imports[0].import_info.get_import_statement()) def test_get_import_statements_for_froms(self): @@ -85,7 +85,7 @@ def test_get_import_statements_for_froms(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEquals('from pkg1 import mod1', + self.assertEqual('from pkg1 import mod1', imports[0].import_info.get_import_statement()) def test_get_multi_line_import_statements_for_froms(self): @@ -93,7 +93,7 @@ def test_get_multi_line_import_statements_for_froms(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEquals('from pkg1 import mod1', + self.assertEqual('from pkg1 import mod1', imports[0].import_info.get_import_statement()) def test_get_import_statements_for_from_star(self): @@ -101,7 +101,7 @@ def test_get_import_statements_for_from_star(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEquals('from pkg1 import *', + self.assertEqual('from pkg1 import *', imports[0].import_info.get_import_statement()) @testutils.only_for('2.5') @@ -110,7 +110,7 @@ def test_get_import_statements_for_new_relatives(self): pymod = self.project.get_module('pkg2.mod2') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEquals('from .mod3 import x', + self.assertEqual('from .mod3 import x', imports[0].import_info.get_import_statement()) def test_ignoring_indented_imports(self): @@ -118,7 +118,7 @@ def test_ignoring_indented_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEquals(0, len(imports)) + self.assertEqual(0, len(imports)) def test_import_get_names(self): self.mod.write('import pkg1 as pkg\n') @@ -126,7 +126,7 @@ def test_import_get_names(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports context = importinfo.ImportContext(self.project, self.project.root) - self.assertEquals(['pkg'], + self.assertEqual(['pkg'], imports[0].import_info.get_imported_names(context)) def test_import_get_names_with_alias(self): @@ -135,7 +135,7 @@ def test_import_get_names_with_alias(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports context = importinfo.ImportContext(self.project, self.project.root) - self.assertEquals(['pkg1'], + self.assertEqual(['pkg1'], imports[0].import_info.get_imported_names(context)) def test_import_get_names_with_alias2(self): @@ -145,7 +145,7 @@ def test_import_get_names_with_alias2(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports context = importinfo.ImportContext(self.project, self.project.root) - self.assertEquals(['a_func'], + self.assertEqual(['a_func'], imports[0].import_info.get_imported_names(context)) def test_empty_getting_used_imports(self): @@ -153,30 +153,30 @@ def test_empty_getting_used_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports(pymod) - self.assertEquals(0, len(imports)) + self.assertEqual(0, len(imports)) def test_empty_getting_used_imports2(self): self.mod.write('import pkg\n') pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports(pymod) - self.assertEquals(0, len(imports)) + self.assertEqual(0, len(imports)) def test_simple_getting_used_imports(self): self.mod.write('import pkg\nprint(pkg)\n') pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports(pymod) - self.assertEquals(1, len(imports)) - self.assertEquals('import pkg', imports[0].get_import_statement()) + self.assertEqual(1, len(imports)) + self.assertEqual('import pkg', imports[0].get_import_statement()) def test_simple_getting_used_imports2(self): self.mod.write('import pkg\ndef a_func():\n print(pkg)\n') pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports(pymod) - self.assertEquals(1, len(imports)) - self.assertEquals('import pkg', imports[0].get_import_statement()) + self.assertEqual(1, len(imports)) + self.assertEqual('import pkg', imports[0].get_import_statement()) def test_getting_used_imports_for_nested_scopes(self): self.mod.write('import pkg1\nprint(pkg1)\n' @@ -185,7 +185,7 @@ def test_getting_used_imports_for_nested_scopes(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports( pymod['a_func'].get_object()) - self.assertEquals(0, len(imports)) + self.assertEqual(0, len(imports)) def test_getting_used_imports_for_nested_scopes2(self): self.mod.write('from pkg1 import mod1\ndef a_func():' @@ -194,8 +194,8 @@ def test_getting_used_imports_for_nested_scopes2(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports( pymod['a_func'].get_object()) - self.assertEquals(1, len(imports)) - self.assertEquals('from pkg1 import mod1', + self.assertEqual(1, len(imports)) + self.assertEqual('from pkg1 import mod1', imports[0].get_import_statement()) def test_empty_removing_unused_imports(self): @@ -203,7 +203,7 @@ def test_empty_removing_unused_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('import pkg1\nprint(pkg1)\n', + self.assertEqual('import pkg1\nprint(pkg1)\n', module_with_imports.get_changed_source()) def test_simple_removing_unused_imports(self): @@ -211,7 +211,7 @@ def test_simple_removing_unused_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('', module_with_imports.get_changed_source()) + self.assertEqual('', module_with_imports.get_changed_source()) def test_simple_removing_unused_imports_for_froms(self): self.mod1.write('def a_func():\n pass' @@ -221,7 +221,7 @@ def test_simple_removing_unused_imports_for_froms(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('from pkg1.mod1 import a_func\n\na_func()\n', + self.assertEqual('from pkg1.mod1 import a_func\n\na_func()\n', module_with_imports.get_changed_source()) def test_simple_removing_unused_imports_for_from_stars(self): @@ -229,7 +229,7 @@ def test_simple_removing_unused_imports_for_from_stars(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('', module_with_imports.get_changed_source()) + self.assertEqual('', module_with_imports.get_changed_source()) def test_simple_removing_unused_imports_for_nested_modules(self): self.mod1.write('def a_func():\n pass\n') @@ -237,7 +237,7 @@ def test_simple_removing_unused_imports_for_nested_modules(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()', + self.assertEqual('import pkg1.mod1\npkg1.mod1.a_func()', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_functions_of_the_same_name(self): @@ -245,7 +245,7 @@ def test_removing_unused_imports_and_functions_of_the_same_name(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('def a_func():\n pass\ndef a_func():\n pass\n', + self.assertEqual('def a_func():\n pass\ndef a_func():\n pass\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_for_from_import_with_as(self): @@ -254,7 +254,7 @@ def test_removing_unused_imports_for_from_import_with_as(self): pymod = self.project.get_pymodule(self.mod1) module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('from mod import a_var as myvar\na_var = myvar\n', + self.assertEqual('from mod import a_var as myvar\na_var = myvar\n', module_with_imports.get_changed_source()) def test_not_removing_imports_that_conflict_with_class_names(self): @@ -264,7 +264,7 @@ def test_not_removing_imports_that_conflict_with_class_names(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals(code, module_with_imports.get_changed_source()) + self.assertEqual(code, module_with_imports.get_changed_source()) def test_adding_imports(self): self.mod.write('\n') @@ -272,7 +272,7 @@ def test_adding_imports(self): module_with_imports = self.import_tools.module_imports(pymod) new_import = self.import_tools.get_import(self.mod1) module_with_imports.add_import(new_import) - self.assertEquals('import pkg1.mod1\n', + self.assertEqual('import pkg1.mod1\n', module_with_imports.get_changed_source()) def test_adding_from_imports(self): @@ -284,7 +284,7 @@ def test_adding_from_imports(self): new_import = self.import_tools.get_from_import( self.mod1, 'another_func') module_with_imports.add_import(new_import) - self.assertEquals('from pkg1.mod1 import a_func, another_func\n', + self.assertEqual('from pkg1.mod1 import a_func, another_func\n', module_with_imports.get_changed_source()) def test_adding_to_star_imports(self): @@ -296,7 +296,7 @@ def test_adding_to_star_imports(self): new_import = self.import_tools.get_from_import( self.mod1, 'another_func') module_with_imports.add_import(new_import) - self.assertEquals('from pkg1.mod1 import *\n', + self.assertEqual('from pkg1.mod1 import *\n', module_with_imports.get_changed_source()) def test_adding_star_imports(self): @@ -307,7 +307,7 @@ def test_adding_star_imports(self): module_with_imports = self.import_tools.module_imports(pymod) new_import = self.import_tools.get_from_import(self.mod1, '*') module_with_imports.add_import(new_import) - self.assertEquals('from pkg1.mod1 import *\n', + self.assertEqual('from pkg1.mod1 import *\n', module_with_imports.get_changed_source()) def test_adding_imports_and_preserving_spaces_after_imports(self): @@ -316,7 +316,7 @@ def test_adding_imports_and_preserving_spaces_after_imports(self): module_with_imports = self.import_tools.module_imports(pymod) new_import = self.import_tools.get_import(self.pkg2) module_with_imports.add_import(new_import) - self.assertEquals('import pkg1\nimport pkg2\n\n\nprint(pkg1)\n', + self.assertEqual('import pkg1\nimport pkg2\n\n\nprint(pkg1)\n', module_with_imports.get_changed_source()) def test_not_changing_the_format_of_unchanged_imports(self): @@ -325,7 +325,7 @@ def test_not_changing_the_format_of_unchanged_imports(self): self.mod.write('from pkg1.mod1 import (a_func,\n another_func)\n') pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) - self.assertEquals( + self.assertEqual( 'from pkg1.mod1 import (a_func,\n another_func)\n', module_with_imports.get_changed_source()) @@ -336,7 +336,7 @@ def test_not_changing_the_format_of_unchanged_imports2(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('from pkg1.mod1 import (a_func)\na_func()\n', + self.assertEqual('from pkg1.mod1 import (a_func)\na_func()\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_reoccuring_names(self): @@ -347,7 +347,7 @@ def test_removing_unused_imports_and_reoccuring_names(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('from pkg1.mod1 import *\na_func()\n', + self.assertEqual('from pkg1.mod1 import *\na_func()\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_reoccuring_names2(self): @@ -356,7 +356,7 @@ def test_removing_unused_imports_and_reoccuring_names2(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals( + self.assertEqual( 'import pkg2.mod2\nimport pkg2.mod3\nprint(pkg2.mod2, pkg2.mod3)', module_with_imports.get_changed_source()) @@ -366,7 +366,7 @@ def test_removing_unused_imports_and_common_packages(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('import pkg1.mod1\nprint(pkg1, pkg1.mod1)\n', + self.assertEqual('import pkg1.mod1\nprint(pkg1, pkg1.mod1)\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_common_packages_reversed(self): @@ -375,7 +375,7 @@ def test_removing_unused_imports_and_common_packages_reversed(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_duplicates() - self.assertEquals('import pkg1.mod1\nprint(pkg1, pkg1.mod1)\n', + self.assertEqual('import pkg1.mod1\nprint(pkg1, pkg1.mod1)\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_common_packages2(self): @@ -383,7 +383,7 @@ def test_removing_unused_imports_and_common_packages2(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('import pkg1.mod1\nprint(pkg1)\n', + self.assertEqual('import pkg1.mod1\nprint(pkg1)\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_froms(self): @@ -392,7 +392,7 @@ def test_removing_unused_imports_and_froms(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('', module_with_imports.get_changed_source()) + self.assertEqual('', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_froms2(self): self.mod1.write('def func1():\n pass\n') @@ -400,7 +400,7 @@ def test_removing_unused_imports_and_froms2(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('from pkg1.mod1 import func1\nfunc1()', + self.assertEqual('from pkg1.mod1 import func1\nfunc1()', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_froms3(self): @@ -410,7 +410,7 @@ def test_removing_unused_imports_and_froms3(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals( + self.assertEqual( 'from pkg1.mod1 import func1\ndef a_func():\n func1()\n', module_with_imports.get_changed_source()) @@ -421,7 +421,7 @@ def test_removing_unused_imports_and_froms4(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('from pkg1.mod1 import func1\nclass A(object):\n' + self.assertEqual('from pkg1.mod1 import func1\nclass A(object):\n' ' def a_func(self):\n func1()\n', module_with_imports.get_changed_source()) @@ -431,7 +431,7 @@ def test_removing_unused_imports_and_getting_attributes(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('from pkg1.mod1 import A\nvar = A().f()', + self.assertEqual('from pkg1.mod1 import A\nvar = A().f()', module_with_imports.get_changed_source()) def test_removing_unused_imports_function_parameters(self): @@ -440,7 +440,7 @@ def test_removing_unused_imports_function_parameters(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('def a_func(pkg1):\n my_var = pkg1\n', + self.assertEqual('def a_func(pkg1):\n my_var = pkg1\n', module_with_imports.get_changed_source()) def test_trivial_expanding_star_imports(self): @@ -450,7 +450,7 @@ def test_trivial_expanding_star_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.expand_stars() - self.assertEquals('', module_with_imports.get_changed_source()) + self.assertEqual('', module_with_imports.get_changed_source()) def test_expanding_star_imports(self): self.mod1.write('def a_func():\n pass\n' @@ -459,7 +459,7 @@ def test_expanding_star_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.expand_stars() - self.assertEquals('from pkg1.mod1 import a_func\na_func()\n', + self.assertEqual('from pkg1.mod1 import a_func\na_func()\n', module_with_imports.get_changed_source()) def test_removing_duplicate_imports(self): @@ -467,7 +467,7 @@ def test_removing_duplicate_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_duplicates() - self.assertEquals('import pkg1\n', + self.assertEqual('import pkg1\n', module_with_imports.get_changed_source()) def test_removing_duplicates_and_reoccuring_names(self): @@ -475,7 +475,7 @@ def test_removing_duplicates_and_reoccuring_names(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_duplicates() - self.assertEquals('import pkg2.mod2\nimport pkg2.mod3\n', + self.assertEqual('import pkg2.mod2\nimport pkg2.mod3\n', module_with_imports.get_changed_source()) def test_removing_duplicate_imports_for_froms(self): @@ -486,7 +486,7 @@ def test_removing_duplicate_imports_for_froms(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_duplicates() - self.assertEquals('from pkg1 import a_func, another_func\n', + self.assertEqual('from pkg1 import a_func, another_func\n', module_with_imports.get_changed_source()) def test_transforming_froms_to_normal_changing_imports(self): @@ -494,7 +494,7 @@ def test_transforming_froms_to_normal_changing_imports(self): self.mod.write('from pkg1.mod1 import a_func\nprint(a_func)\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEquals('import pkg1.mod1\nprint(pkg1.mod1.a_func)\n', + self.assertEqual('import pkg1.mod1\nprint(pkg1.mod1.a_func)\n', changed_module) def test_transforming_froms_to_normal_changing_occurances(self): @@ -502,7 +502,7 @@ def test_transforming_froms_to_normal_changing_occurances(self): self.mod.write('from pkg1.mod1 import a_func\na_func()') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()', + self.assertEqual('import pkg1.mod1\npkg1.mod1.a_func()', changed_module) def test_transforming_froms_to_normal_for_multi_imports(self): @@ -511,7 +511,7 @@ def test_transforming_froms_to_normal_for_multi_imports(self): self.mod.write('from pkg1.mod1 import *\na_func()\nanother_func()\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEquals( + self.assertEqual( 'import pkg1.mod1\npkg1.mod1.a_func()\npkg1.mod1.another_func()\n', changed_module) @@ -522,7 +522,7 @@ def test_transform_froms_to_norm_for_multi_imports_inside_parens(self): '\na_func()\nanother_func()\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEquals( + self.assertEqual( 'import pkg1.mod1\npkg1.mod1.a_func()\npkg1.mod1.another_func()\n', changed_module) @@ -531,7 +531,7 @@ def test_transforming_froms_to_normal_from_stars(self): self.mod.write('from pkg1.mod1 import *\na_func()\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()\n', + self.assertEqual('import pkg1.mod1\npkg1.mod1.a_func()\n', changed_module) def test_transforming_froms_to_normal_from_stars2(self): @@ -540,7 +540,7 @@ def test_transforming_froms_to_normal_from_stars2(self): 'def a_func():\n print(pkg1.mod1, a_var)\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEquals('import pkg1.mod1\n' + self.assertEqual('import pkg1.mod1\n' 'def a_func():\n ' 'print(pkg1.mod1, pkg1.mod1.a_var)\n', changed_module) @@ -551,7 +551,7 @@ def test_transforming_froms_to_normal_from_with_alias(self): 'from pkg1.mod1 import a_func as another_func\nanother_func()\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()\n', + self.assertEqual('import pkg1.mod1\npkg1.mod1.a_func()\n', changed_module) def test_transforming_froms_to_normal_for_relatives(self): @@ -559,32 +559,32 @@ def test_transforming_froms_to_normal_for_relatives(self): self.mod3.write('from mod2 import *\na_func()\n') pymod = self.project.get_pymodule(self.mod3) changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEquals('import pkg2.mod2\npkg2.mod2.a_func()\n', + self.assertEqual('import pkg2.mod2\npkg2.mod2.a_func()\n', changed_module) def test_transforming_froms_to_normal_for_os_path(self): self.mod.write('from os import path\npath.exists(\'.\')\n') pymod = self.project.get_pymodule(self.mod) changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEquals('import os\nos.path.exists(\'.\')\n', changed_module) + self.assertEqual('import os\nos.path.exists(\'.\')\n', changed_module) def test_transform_relatives_imports_to_abs_imports_doing_nothing(self): self.mod2.write('from pkg1 import mod1\nimport mod1\n') pymod = self.project.get_pymodule(self.mod2) - self.assertEquals('from pkg1 import mod1\nimport mod1\n', + self.assertEqual('from pkg1 import mod1\nimport mod1\n', self.import_tools.relatives_to_absolutes(pymod)) def test_transform_relatives_to_absolute_imports_for_normal_imports(self): self.mod2.write('import mod3\n') pymod = self.project.get_pymodule(self.mod2) - self.assertEquals('import pkg2.mod3\n', + self.assertEqual('import pkg2.mod3\n', self.import_tools.relatives_to_absolutes(pymod)) def test_transform_relatives_imports_to_absolute_imports_for_froms(self): self.mod3.write('def a_func():\n pass\n') self.mod2.write('from mod3 import a_func\n') pymod = self.project.get_pymodule(self.mod2) - self.assertEquals('from pkg2.mod3 import a_func\n', + self.assertEqual('from pkg2.mod3 import a_func\n', self.import_tools.relatives_to_absolutes(pymod)) @testutils.only_for('2.5') @@ -592,32 +592,32 @@ def test_transform_rel_imports_to_abs_imports_for_new_relatives(self): self.mod3.write('def a_func():\n pass\n') self.mod2.write('from .mod3 import a_func\n') pymod = self.project.get_pymodule(self.mod2) - self.assertEquals('from pkg2.mod3 import a_func\n', + self.assertEqual('from pkg2.mod3 import a_func\n', self.import_tools.relatives_to_absolutes(pymod)) def test_transform_relatives_to_absolute_imports_for_normal_imports2(self): self.mod2.write('import mod3\nprint(mod3)') pymod = self.project.get_pymodule(self.mod2) - self.assertEquals('import pkg2.mod3\nprint(pkg2.mod3)', + self.assertEqual('import pkg2.mod3\nprint(pkg2.mod3)', self.import_tools.relatives_to_absolutes(pymod)) def test_transform_relatives_to_absolute_imports_for_aliases(self): self.mod2.write('import mod3 as mod3\nprint(mod3)') pymod = self.project.get_pymodule(self.mod2) - self.assertEquals('import pkg2.mod3 as mod3\nprint(mod3)', + self.assertEqual('import pkg2.mod3 as mod3\nprint(mod3)', self.import_tools.relatives_to_absolutes(pymod)) def test_organizing_imports(self): self.mod1.write('import mod1\n') pymod = self.project.get_pymodule(self.mod1) - self.assertEquals('', self.import_tools.organize_imports(pymod)) + self.assertEqual('', self.import_tools.organize_imports(pymod)) def test_organizing_imports_without_deduplication(self): contents = 'from pkg2 import mod2\nfrom pkg2 import mod3\n' self.mod.write(contents) pymod = self.project.get_pymodule(self.mod) self.project.prefs['split_imports'] = True - self.assertEquals(contents, + self.assertEqual(contents, self.import_tools.organize_imports(pymod, unused=False)) @@ -625,7 +625,7 @@ def test_splitting_imports(self): self.mod.write('from pkg1 import mod1\nfrom pkg2 import mod2, mod3\n') pymod = self.project.get_pymodule(self.mod) self.project.prefs['split_imports'] = True - self.assertEquals('from pkg1 import mod1\nfrom pkg2 import mod2\n' + self.assertEqual('from pkg1 import mod1\nfrom pkg2 import mod2\n' 'from pkg2 import mod3\n', self.import_tools.organize_imports(pymod, unused=False)) @@ -634,7 +634,7 @@ def test_splitting_duplicate_imports(self): self.mod.write('from pkg2 import mod1\nfrom pkg2 import mod1, mod2\n') pymod = self.project.get_pymodule(self.mod) self.project.prefs['split_imports'] = True - self.assertEquals('from pkg2 import mod1\nfrom pkg2 import mod2\n', + self.assertEqual('from pkg2 import mod1\nfrom pkg2 import mod2\n', self.import_tools.organize_imports(pymod, unused=False)) @@ -644,7 +644,7 @@ def test_splitting_duplicate_imports2(self): 'from pkg2 import mod2, mod3\n') pymod = self.project.get_pymodule(self.mod) self.project.prefs['split_imports'] = True - self.assertEquals('from pkg2 import mod1\nfrom pkg2 import mod2\n' + self.assertEqual('from pkg2 import mod1\nfrom pkg2 import mod2\n' 'from pkg2 import mod3\n', self.import_tools.organize_imports(pymod, unused=False)) @@ -652,96 +652,96 @@ def test_splitting_duplicate_imports2(self): def test_removing_self_imports(self): self.mod.write('import mod\nmod.a_var = 1\nprint(mod.a_var)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('a_var = 1\nprint(a_var)\n', + self.assertEqual('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports2(self): self.mod1.write('import pkg1.mod1\npkg1.mod1.a_var = 1\n' 'print(pkg1.mod1.a_var)\n') pymod = self.project.get_pymodule(self.mod1) - self.assertEquals('a_var = 1\nprint(a_var)\n', + self.assertEqual('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_with_as(self): self.mod.write('import mod as mymod\n' 'mymod.a_var = 1\nprint(mymod.a_var)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('a_var = 1\nprint(a_var)\n', + self.assertEqual('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_froms(self): self.mod1.write('from pkg1 import mod1\n' 'mod1.a_var = 1\nprint(mod1.a_var)\n') pymod = self.project.get_pymodule(self.mod1) - self.assertEquals('a_var = 1\nprint(a_var)\n', + self.assertEqual('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_froms_with_as(self): self.mod1.write('from pkg1 import mod1 as mymod\n' 'mymod.a_var = 1\nprint(mymod.a_var)\n') pymod = self.project.get_pymodule(self.mod1) - self.assertEquals('a_var = 1\nprint(a_var)\n', + self.assertEqual('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_froms2(self): self.mod.write('from mod import a_var\na_var = 1\nprint(a_var)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('a_var = 1\nprint(a_var)\n', + self.assertEqual('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_froms3(self): self.mod.write('from mod import a_var\na_var = 1\nprint(a_var)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('a_var = 1\nprint(a_var)\n', + self.assertEqual('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_froms4(self): self.mod.write('from mod import a_var as myvar\n' 'a_var = 1\nprint(myvar)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('a_var = 1\nprint(a_var)\n', + self.assertEqual('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_with_no_dot_after_mod(self): self.mod.write('import mod\nprint(mod)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('import mod\n\n\nprint(mod)\n', + self.assertEqual('import mod\n\n\nprint(mod)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_with_no_dot_after_mod2(self): self.mod.write('import mod\na_var = 1\n' 'print(mod\\\n \\\n .var)\n\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('a_var = 1\nprint(var)\n\n', + self.assertEqual('a_var = 1\nprint(var)\n\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_from_import_star(self): self.mod.write('from mod import *\na_var = 1\nprint(myvar)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('a_var = 1\nprint(myvar)\n', + self.assertEqual('a_var = 1\nprint(myvar)\n', self.import_tools.organize_imports(pymod)) def test_not_removing_future_imports(self): self.mod.write('from __future__ import division\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('from __future__ import division\n', + self.assertEqual('from __future__ import division\n', self.import_tools.organize_imports(pymod)) def test_sorting_empty_imports(self): self.mod.write('') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('', self.import_tools.sort_imports(pymod)) + self.assertEqual('', self.import_tools.sort_imports(pymod)) def test_sorting_one_import(self): self.mod.write('import pkg1.mod1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('import pkg1.mod1\n', + self.assertEqual('import pkg1.mod1\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_alphabetically(self): self.mod.write('import pkg2.mod2\nimport pkg1.mod1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('import pkg1.mod1\nimport pkg2.mod2\n', + self.assertEqual('import pkg1.mod1\nimport pkg2.mod2\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_purely_alphabetically(self): @@ -749,64 +749,64 @@ def test_sorting_imports_purely_alphabetically(self): 'import pkg2.mod2\nimport pkg1.mod1\n') pymod = self.project.get_pymodule(self.mod) self.project.prefs['sort_imports_alphabetically'] = True - self.assertEquals('import pkg1.mod1\nimport pkg2.mod2\n' + self.assertEqual('import pkg1.mod1\nimport pkg2.mod2\n' 'from pkg2 import mod3 as mod0\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_and_froms(self): self.mod.write('import pkg2.mod2\nfrom pkg1 import mod1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('import pkg2.mod2\nfrom pkg1 import mod1\n', + self.assertEqual('import pkg2.mod2\nfrom pkg1 import mod1\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_and_standard_modules(self): self.mod.write('import pkg1\nimport sys\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('import sys\n\nimport pkg1\n', + self.assertEqual('import sys\n\nimport pkg1\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_and_standard_modules2(self): self.mod.write('import sys\n\nimport time\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('import sys\nimport time\n', + self.assertEqual('import sys\nimport time\n', self.import_tools.sort_imports(pymod)) def test_sorting_only_standard_modules(self): self.mod.write('import sys\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('import sys\n', + self.assertEqual('import sys\n', self.import_tools.sort_imports(pymod)) def test_sorting_third_party(self): self.mod.write('import pkg1\nimport a_third_party\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('import a_third_party\n\nimport pkg1\n', + self.assertEqual('import a_third_party\n\nimport pkg1\n', self.import_tools.sort_imports(pymod)) def test_sorting_only_third_parties(self): self.mod.write('import a_third_party\na_var = 1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals('import a_third_party\n\n\na_var = 1\n', + self.assertEqual('import a_third_party\n\n\na_var = 1\n', self.import_tools.sort_imports(pymod)) def test_simple_handling_long_imports(self): self.mod.write('import pkg1.mod1\n\n\nm = pkg1.mod1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'import pkg1.mod1\n\n\nm = pkg1.mod1\n', self.import_tools.handle_long_imports(pymod, maxdots=2)) def test_handling_long_imports_for_many_dots(self): self.mod.write('import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'from p1.p2.p3 import m1\n\n\nm = m1\n', self.import_tools.handle_long_imports(pymod, maxdots=2)) def test_handling_long_imports_for_their_length(self): self.mod.write('import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n', self.import_tools.handle_long_imports(pymod, maxdots=3, maxlength=20)) @@ -814,7 +814,7 @@ def test_handling_long_imports_for_their_length(self): def test_handling_long_imports_for_many_dots2(self): self.mod.write('import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'from p1.p2.p3 import m1\n\n\nm = m1\n', self.import_tools.handle_long_imports(pymod, maxdots=3, maxlength=10)) @@ -822,7 +822,7 @@ def test_handling_long_imports_for_many_dots2(self): def test_handling_long_imports_with_one_letter_last(self): self.mod.write('import p1.p2.p3.l\n\n\nm = p1.p2.p3.l\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'from p1.p2.p3 import l\n\n\nm = l\n', self.import_tools.handle_long_imports(pymod, maxdots=2)) @@ -831,28 +831,28 @@ def test_empty_removing_unused_imports_and_eating_blank_lines(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEquals('import pkg1\n\n\nprint(pkg1)\n', + self.assertEqual('import pkg1\n\n\nprint(pkg1)\n', module_with_imports.get_changed_source()) def test_sorting_imports_moving_to_top(self): self.mod.write('import mod\ndef f():\n print(mod, pkg1, pkg2)\n' 'import pkg1\nimport pkg2\n') pymod = self.project.get_module('mod') - self.assertEquals('import mod\nimport pkg1\nimport pkg2\n\n\n' + self.assertEqual('import mod\nimport pkg1\nimport pkg2\n\n\n' 'def f():\n print(mod, pkg1, pkg2)\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_moving_to_top2(self): self.mod.write('def f():\n print(mod)\nimport mod\n') pymod = self.project.get_module('mod') - self.assertEquals('import mod\n\n\ndef f():\n print(mod)\n', + self.assertEqual('import mod\n\n\ndef f():\n print(mod)\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_moving_to_top_and_module_docs(self): self.mod.write('"""\ndocs\n"""\ndef f():' '\n print(mod)\nimport mod\n') pymod = self.project.get_module('mod') - self.assertEquals( + self.assertEqual( '"""\ndocs\n"""\nimport mod\n\n\ndef f():\n print(mod)\n', self.import_tools.sort_imports(pymod)) @@ -860,7 +860,7 @@ def test_sorting_imports_moving_to_top_and_module_docs2(self): self.mod.write('"""\ndocs\n"""\n\n\nimport bbb\nimport aaa\n' 'def f():\n print(mod)\nimport mod\n') pymod = self.project.get_module('mod') - self.assertEquals( + self.assertEqual( '"""\ndocs\n"""\n\n\nimport aaa\nimport bbb\n\n' 'import mod\n\n\ndef f():\n print(mod)\n', self.import_tools.sort_imports(pymod)) @@ -868,28 +868,28 @@ def test_sorting_imports_moving_to_top_and_module_docs2(self): def test_sorting_future_imports(self): self.mod.write('import os\nfrom __future__ import devision\n') pymod = self.project.get_module('mod') - self.assertEquals( + self.assertEqual( 'from __future__ import devision\n\nimport os\n', self.import_tools.sort_imports(pymod)) def test_customized_import_organization(self): self.mod.write('import sys\nimport sys\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'import sys\n', self.import_tools.organize_imports(pymod, unused=False)) def test_customized_import_organization2(self): self.mod.write('import sys\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'import sys\n', self.import_tools.organize_imports(pymod, unused=False)) def test_customized_import_organization3(self): self.mod.write('import sys\nimport mod\n\n\nvar = 1\nprint(mod.var)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'import sys\n\n\nvar = 1\nprint(var)\n', self.import_tools.organize_imports(pymod, unused=False)) @@ -899,7 +899,7 @@ def test_trivial_filtered_expand_stars(self): self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' 'print(var1, var2)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'from pkg1 import *\nfrom pkg2 import *\n\nprint(var1, var2)\n', self.import_tools.expand_stars(pymod, lambda stmt: False)) @@ -914,7 +914,7 @@ def test_filtered_expand_stars(self): self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' 'print(var1, var2)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'from pkg1 import *\nfrom pkg2 import var2\n\nprint(var1, var2)\n', self.import_tools.expand_stars(pymod, self._line_filter(2))) @@ -922,11 +922,11 @@ def test_filtered_relative_to_absolute(self): self.mod3.write('var = 1') self.mod2.write('import mod3\n\nprint(mod3.var)\n') pymod = self.project.get_pymodule(self.mod2) - self.assertEquals( + self.assertEqual( 'import mod3\n\nprint(mod3.var)\n', self.import_tools.relatives_to_absolutes( pymod, lambda stmt: False)) - self.assertEquals( + self.assertEqual( 'import pkg2.mod3\n\nprint(pkg2.mod3.var)\n', self.import_tools.relatives_to_absolutes( pymod, self._line_filter(1))) @@ -937,11 +937,11 @@ def test_filtered_froms_to_normals(self): self.mod.write('from pkg1 import var1\nfrom pkg2 import var2\n\n' 'print(var1, var2)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'from pkg1 import var1\nfrom pkg2 ' 'import var2\n\nprint(var1, var2)\n', self.import_tools.expand_stars(pymod, lambda stmt: False)) - self.assertEquals( + self.assertEqual( 'from pkg1 import var1\nimport pkg2\n\nprint(var1, pkg2.var2)\n', self.import_tools.froms_to_imports(pymod, self._line_filter(2))) @@ -951,7 +951,7 @@ def test_filtered_froms_to_normals2(self): self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' 'print(var1, var2)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'from pkg1 import *\nimport pkg2\n\nprint(var1, pkg2.var2)\n', self.import_tools.froms_to_imports(pymod, self._line_filter(2))) @@ -959,7 +959,7 @@ def test_filtered_handle_long_imports(self): self.mod.write('import p1.p2.p3.m1\nimport pkg1.mod1\n\n\n' 'm = p1.p2.p3.m1, pkg1.mod1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'import p1.p2.p3.m1\nfrom pkg1 import mod1\n\n\n' 'm = p1.p2.p3.m1, mod1\n', self.import_tools.handle_long_imports( @@ -972,7 +972,7 @@ def test_filtering_and_import_actions_with_more_than_one_phase(self): self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' 'print(var2)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEquals( + self.assertEqual( 'from pkg2 import *\n\nprint(var2)\n', self.import_tools.expand_stars(pymod, self._line_filter(1))) @@ -983,7 +983,7 @@ def test_non_existent_module_and_used_imports(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports(pymod) - self.assertEquals(1, len(imports)) + self.assertEqual(1, len(imports)) class AddImportTest(unittest.TestCase): @@ -1006,24 +1006,24 @@ def test_normal_imports(self): self.mod1.write('\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'mod2', 'myvar') - self.assertEquals('import mod2\n', result) - self.assertEquals('mod2.myvar', name) + self.assertEqual('import mod2\n', result) + self.assertEqual('mod2.myvar', name) def test_not_reimporting_a_name(self): self.mod2.write('myvar = None\n') self.mod1.write('from mod2 import myvar\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'mod2', 'myvar') - self.assertEquals('from mod2 import myvar\n', result) - self.assertEquals('myvar', name) + self.assertEqual('from mod2 import myvar\n', result) + self.assertEqual('myvar', name) def test_adding_import_when_siblings_are_imported(self): self.mod2.write('var1 = None\nvar2 = None\n') self.mod1.write('from mod2 import var1\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'mod2', 'var2') - self.assertEquals('from mod2 import var1, var2\n', result) - self.assertEquals('var2', name) + self.assertEqual('from mod2 import var1, var2\n', result) + self.assertEqual('var2', name) def test_adding_import_when_the_package_is_imported(self): self.pkg.get_child('__init__.py').write('var1 = None\n') @@ -1031,8 +1031,8 @@ def test_adding_import_when_the_package_is_imported(self): self.mod1.write('from pkg import var1\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'pkg.mod3', 'var2') - self.assertEquals('from pkg import var1, mod3\n', result) - self.assertEquals('mod3.var2', name) + self.assertEqual('from pkg import var1, mod3\n', result) + self.assertEqual('mod3.var2', name) def test_adding_import_for_modules_instead_of_names(self): self.pkg.get_child('__init__.py').write('var1 = None\n') @@ -1040,8 +1040,8 @@ def test_adding_import_for_modules_instead_of_names(self): self.mod1.write('from pkg import var1\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'pkg.mod3', None) - self.assertEquals('from pkg import var1, mod3\n', result) - self.assertEquals('mod3', name) + self.assertEqual('from pkg import var1, mod3\n', result) + self.assertEqual('mod3', name) def test_adding_import_for_modules_with_normal_duplicate_imports(self): self.pkg.get_child('__init__.py').write('var1 = None\n') @@ -1049,8 +1049,8 @@ def test_adding_import_for_modules_with_normal_duplicate_imports(self): self.mod1.write('import pkg.mod3\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'pkg.mod3', None) - self.assertEquals('import pkg.mod3\n', result) - self.assertEquals('pkg.mod3', name) + self.assertEqual('import pkg.mod3\n', result) + self.assertEqual('pkg.mod3', name) def suite(): diff --git a/ropetest/refactor/inlinetest.py b/ropetest/refactor/inlinetest.py index 3dfd13457..bbc66ffb9 100644 --- a/ropetest/refactor/inlinetest.py +++ b/ropetest/refactor/inlinetest.py @@ -35,32 +35,32 @@ def _inline2(self, resource, offset, **kwds): def test_simple_case(self): code = 'a_var = 10\nanother_var = a_var\n' refactored = self._inline(code, code.index('a_var') + 1) - self.assertEquals('another_var = 10\n', refactored) + self.assertEqual('another_var = 10\n', refactored) def test_empty_case(self): code = 'a_var = 10\n' refactored = self._inline(code, code.index('a_var') + 1) - self.assertEquals('', refactored) + self.assertEqual('', refactored) def test_long_definition(self): code = 'a_var = 10 + (10 + 10)\nanother_var = a_var\n' refactored = self._inline(code, code.index('a_var') + 1) - self.assertEquals('another_var = 10 + (10 + 10)\n', refactored) + self.assertEqual('another_var = 10 + (10 + 10)\n', refactored) def test_explicit_continuation(self): code = 'a_var = (10 +\n 10)\nanother_var = a_var\n' refactored = self._inline(code, code.index('a_var') + 1) - self.assertEquals('another_var = (10 + 10)\n', refactored) + self.assertEqual('another_var = (10 + 10)\n', refactored) def test_implicit_continuation(self): code = 'a_var = 10 +\\\n 10\nanother_var = a_var\n' refactored = self._inline(code, code.index('a_var') + 1) - self.assertEquals('another_var = 10 + 10\n', refactored) + self.assertEqual('another_var = 10 + 10\n', refactored) def test_inlining_at_the_end_of_input(self): code = 'a = 1\nb = a' refactored = self._inline(code, code.index('a') + 1) - self.assertEquals('b = 1', refactored) + self.assertEqual('b = 1', refactored) def test_on_classes(self): code = 'class AClass(object):\n pass\n' @@ -88,7 +88,7 @@ def test_attribute_inlining(self): refactored = self._inline(code, code.index('an_attr') + 1) expected = 'class A(object):\n def __init__(self):\n' \ ' range(3)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_attribute_inlining2(self): code = 'class A(object):\n def __init__(self):\n' \ @@ -98,31 +98,31 @@ def test_attribute_inlining2(self): expected = 'class A(object):\n def __init__(self):\n' \ ' range(3)\n' \ 'a = A()\nrange(3)' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_a_function_with_no_occurance(self): self.mod.write('def a_func():\n pass\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('', self.mod.read()) + self.assertEqual('', self.mod.read()) def test_a_function_with_no_occurance2(self): self.mod.write('a_var = 10\ndef a_func():\n pass\nprint(a_var)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('a_var = 10\nprint(a_var)\n', self.mod.read()) + self.assertEqual('a_var = 10\nprint(a_var)\n', self.mod.read()) def test_replacing_calls_with_function_definition_in_other_modules(self): self.mod.write('def a_func():\n print(1)\n') mod1 = testutils.create_module(self.project, 'mod1') mod1.write('import mod\nmod.a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('import mod\nprint(1)\n', mod1.read()) + self.assertEqual('import mod\nprint(1)\n', mod1.read()) def test_replacing_calls_with_function_definition_in_other_modules2(self): self.mod.write('def a_func():\n print(1)\n') mod1 = testutils.create_module(self.project, 'mod1') mod1.write('import mod\nif True:\n mod.a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('import mod\nif True:\n print(1)\n', mod1.read()) + self.assertEqual('import mod\nif True:\n print(1)\n', mod1.read()) def test_replacing_calls_with_method_definition_in_other_modules(self): self.mod.write('class A(object):\n var = 10\n' @@ -130,63 +130,63 @@ def test_replacing_calls_with_method_definition_in_other_modules(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write('import mod\nmod.A().a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('import mod\nprint(1)\n', mod1.read()) - self.assertEquals('class A(object):\n var = 10\n', self.mod.read()) + self.assertEqual('import mod\nprint(1)\n', mod1.read()) + self.assertEqual('class A(object):\n var = 10\n', self.mod.read()) def test_replacing_calls_with_function_definition_in_defining_module(self): self.mod.write('def a_func():\n print(1)\na_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('print(1)\n', self.mod.read()) + self.assertEqual('print(1)\n', self.mod.read()) def test_replac_calls_with_function_definition_in_defining_module2(self): self.mod.write('def a_func():\n ' 'for i in range(10):\n print(1)\na_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('for i in range(10):\n print(1)\n', + self.assertEqual('for i in range(10):\n print(1)\n', self.mod.read()) def test_replacing_calls_with_method_definition_in_defining_modules(self): self.mod.write('class A(object):\n var = 10\n' ' def a_func(self):\n print(1)\nA().a_func()') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('class A(object):\n var = 10\nprint(1)\n', + self.assertEqual('class A(object):\n var = 10\nprint(1)\n', self.mod.read()) def test_parameters_with_the_same_name_as_passed(self): self.mod.write('def a_func(var):\n ' 'print(var)\nvar = 1\na_func(var)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('var = 1\nprint(var)\n', self.mod.read()) + self.assertEqual('var = 1\nprint(var)\n', self.mod.read()) def test_parameters_with_the_same_name_as_passed2(self): self.mod.write('def a_func(var):\n ' 'print(var)\nvar = 1\na_func(var=var)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('var = 1\nprint(var)\n', self.mod.read()) + self.assertEqual('var = 1\nprint(var)\n', self.mod.read()) def test_simple_parameters_renaming(self): self.mod.write('def a_func(param):\n ' 'print(param)\nvar = 1\na_func(var)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('var = 1\nprint(var)\n', self.mod.read()) + self.assertEqual('var = 1\nprint(var)\n', self.mod.read()) def test_simple_parameters_renaming_for_multiple_params(self): self.mod.write('def a_func(param1, param2):\n p = param1 + param2\n' 'var1 = 1\nvar2 = 1\na_func(var1, var2)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('var1 = 1\nvar2 = 1\np = var1 + var2\n', + self.assertEqual('var1 = 1\nvar2 = 1\np = var1 + var2\n', self.mod.read()) def test_parameters_renaming_for_passed_constants(self): self.mod.write('def a_func(param):\n print(param)\na_func(1)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('print(1)\n', self.mod.read()) + self.assertEqual('print(1)\n', self.mod.read()) def test_parameters_renaming_for_passed_statements(self): self.mod.write('def a_func(param):\n ' 'print(param)\na_func((1 + 2) / 3)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('print((1 + 2) / 3)\n', self.mod.read()) + self.assertEqual('print((1 + 2) / 3)\n', self.mod.read()) def test_simple_parameters_renam_for_multiple_params_using_keywords(self): self.mod.write('def a_func(param1, param2):\n ' @@ -194,35 +194,35 @@ def test_simple_parameters_renam_for_multiple_params_using_keywords(self): 'var1 = 1\nvar2 = 1\n' 'a_func(param2=var1, param1=var2)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('var1 = 1\nvar2 = 1\np = var2 + var1\n', + self.assertEqual('var1 = 1\nvar2 = 1\np = var2 + var1\n', self.mod.read()) def test_simple_params_renam_for_multi_params_using_mixed_keywords(self): self.mod.write('def a_func(param1, param2):\n p = param1 + param2\n' 'var1 = 1\nvar2 = 1\na_func(var2, param2=var1)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('var1 = 1\nvar2 = 1\np = var2 + var1\n', + self.assertEqual('var1 = 1\nvar2 = 1\np = var2 + var1\n', self.mod.read()) def test_simple_putting_in_default_arguments(self): self.mod.write('def a_func(param=None):\n print(param)\n' 'a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('print(None)\n', self.mod.read()) + self.assertEqual('print(None)\n', self.mod.read()) def test_overriding_default_arguments(self): self.mod.write('def a_func(param1=1, param2=2):' '\n print(param1, param2)\n' 'a_func(param2=3)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('print(1, 3)\n', self.mod.read()) + self.assertEqual('print(1, 3)\n', self.mod.read()) def test_badly_formatted_text(self): self.mod.write('def a_func ( param1 = 1 ,param2 = 2 ) :' '\n print(param1, param2)\n' 'a_func ( param2 \n = 3 ) \n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('print(1, 3)\n', self.mod.read()) + self.assertEqual('print(1, 3)\n', self.mod.read()) def test_passing_first_arguments_for_methods(self): a_class = 'class A(object):\n' \ @@ -237,7 +237,7 @@ def test_passing_first_arguments_for_methods(self): ' def __init__(self):\n' \ ' self.var = 1\n' \ ' print(self.var)\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_passing_first_arguments_for_methods2(self): a_class = 'class A(object):\n' \ @@ -254,7 +254,7 @@ def test_passing_first_arguments_for_methods2(self): ' self.var = 1\n' \ 'an_a = A()\n' \ 'print(1, an_a.var)\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_passing_first_arguments_for_methods3(self): a_class = 'class A(object):\n' \ @@ -271,7 +271,7 @@ def test_passing_first_arguments_for_methods3(self): ' self.var = 1\n' \ 'an_a = A()\n' \ 'print(1, an_a.var)\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_inlining_staticmethods(self): a_class = 'class A(object):\n' \ @@ -284,7 +284,7 @@ def test_inlining_staticmethods(self): expected = 'class A(object):\n' \ ' pass\n' \ 'print(1)\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_static_methods2(self): a_class = 'class A(object):\n' \ @@ -302,7 +302,7 @@ def test_static_methods2(self): 'an_a = A()\n' \ 'print(1)\n' \ 'print(2)\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_inlining_classmethods(self): a_class = 'class A(object):\n' \ @@ -315,7 +315,7 @@ def test_inlining_classmethods(self): expected = 'class A(object):\n' \ ' pass\n' \ 'print(1)\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_inlining_classmethods2(self): a_class = 'class A(object):\n' \ @@ -328,24 +328,24 @@ def test_inlining_classmethods2(self): expected = 'class A(object):\n' \ ' pass\n' \ 'print(A)\n' - self.assertEquals(expected, self.mod.read()) + self.assertEqual(expected, self.mod.read()) def test_simple_return_values_and_inlining_functions(self): self.mod.write('def a_func():\n return 1\na = a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('a = 1\n', + self.assertEqual('a = 1\n', self.mod.read()) def test_simple_return_values_and_inlining_lonely_functions(self): self.mod.write('def a_func():\n return 1\na_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('1\n', self.mod.read()) + self.assertEqual('1\n', self.mod.read()) def test_empty_returns_and_inlining_lonely_functions(self): self.mod.write('def a_func():\n ' 'if True:\n return\na_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('if True:\n pass\n', self.mod.read()) + self.assertEqual('if True:\n pass\n', self.mod.read()) def test_multiple_returns(self): self.mod.write('def less_than_five(var):\n if var < 5:\n' @@ -359,7 +359,7 @@ def test_multiple_returns_and_not_using_the_value(self): ' return True\n ' 'return False\nless_than_five(2)\n') self._inline2(self.mod, self.mod.read().index('less') + 1) - self.assertEquals('if 2 < 5:\n True\nFalse\n', self.mod.read()) + self.assertEqual('if 2 < 5:\n True\nFalse\n', self.mod.read()) def test_raising_exception_for_list_arguments(self): self.mod.write('def a_func(*args):\n print(args)\na_func(1)\n') @@ -377,7 +377,7 @@ def test_function_parameters_and_returns_in_other_functions(self): 'range(a_func(20, param2=abs(10)))\n' self.mod.write(code) self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('range(20 + abs(10))\n', self.mod.read()) + self.assertEqual('range(20 + abs(10))\n', self.mod.read()) def test_function_references_other_than_call(self): self.mod.write('def a_func(param):\n print(param)\nf = a_func\n') @@ -398,60 +398,60 @@ def test_recursive_functions(self): def xxx_test_inlining_function_default_parameters(self): self.mod.write('def a_func(p1=1):\n pass\na_func()\n') self._inline2(self.mod, self.mod.read().index('p1') + 1) - self.assertEquals('def a_func(p1=1):\n pass\na_func()\n', + self.assertEqual('def a_func(p1=1):\n pass\na_func()\n', self.mod.read()) def test_simple_inlining_after_extra_indented_lines(self): self.mod.write('def a_func():\n for i in range(10):\n pass\n' 'if True:\n pass\na_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('if True:\n pass\nfor i in range(10):' + self.assertEqual('if True:\n pass\nfor i in range(10):' '\n pass\n', self.mod.read()) def test_inlining_a_function_with_pydoc(self): self.mod.write('def a_func():\n """docs"""\n a = 1\na_func()') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('a = 1\n', self.mod.read()) + self.assertEqual('a = 1\n', self.mod.read()) def test_inlining_methods(self): self.mod.write("class A(object):\n name = 'hey'\n" " def get_name(self):\n return self.name\n" "a = A()\nname = a.get_name()\n") self._inline2(self.mod, self.mod.read().rindex('get_name') + 1) - self.assertEquals("class A(object):\n name = 'hey'\n" + self.assertEqual("class A(object):\n name = 'hey'\n" "a = A()\nname = a.name\n", self.mod.read()) def test_simple_returns_with_backslashes(self): self.mod.write('def a_func():\n return 1' '\\\n + 2\na = a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('a = 1 + 2\n', self.mod.read()) + self.assertEqual('a = 1 + 2\n', self.mod.read()) def test_a_function_with_pass_body(self): self.mod.write('def a_func():\n print(1)\na = a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEquals('print(1)\na = None\n', self.mod.read()) + self.assertEqual('print(1)\na = None\n', self.mod.read()) def test_inlining_the_last_method_of_a_class(self): self.mod.write('class A(object):\n' ' def a_func(self):\n pass\n') self._inline2(self.mod, self.mod.read().rindex('a_func') + 1) - self.assertEquals('class A(object):\n pass\n', + self.assertEqual('class A(object):\n pass\n', self.mod.read()) def test_adding_needed_imports_in_the_dest_module(self): self.mod.write('import sys\n\ndef ver():\n print(sys.version)\n') self.mod2.write('import mod\n\nmod.ver()') self._inline2(self.mod, self.mod.read().index('ver') + 1) - self.assertEquals('import mod\nimport sys\n\nprint(sys.version)\n', + self.assertEqual('import mod\nimport sys\n\nprint(sys.version)\n', self.mod2.read()) def test_adding_needed_imports_in_the_dest_module_removing_selfs(self): self.mod.write('import mod2\n\ndef f():\n print(mod2.var)\n') self.mod2.write('import mod\n\nvar = 1\nmod.f()\n') self._inline2(self.mod, self.mod.read().index('f(') + 1) - self.assertEquals('import mod\n\nvar = 1\nprint(var)\n', + self.assertEqual('import mod\n\nvar = 1\nprint(var)\n', self.mod2.read()) def test_handling_relative_imports_when_inlining(self): @@ -469,7 +469,7 @@ def test_adding_needed_imports_for_elements_in_source(self): self.mod.write('def f1():\n return f2()\ndef f2():\n return 1\n') self.mod2.write('import mod\n\nprint(mod.f1())\n') self._inline2(self.mod, self.mod.read().index('f1') + 1) - self.assertEquals('import mod\nfrom mod import f2\n\nprint(f2())\n', + self.assertEqual('import mod\nfrom mod import f2\n\nprint(f2())\n', self.mod2.read()) def test_relative_imports_and_changing_inlining_body(self): @@ -480,7 +480,7 @@ def test_relative_imports_and_changing_inlining_body(self): mod3.write('import mod4\n\ndef f():\n print(mod4.var)\n') self.mod.write('import pkg.mod3\n\npkg.mod3.f()\n') self._inline2(self.mod, self.mod.read().index('f(') + 1) - self.assertEquals( + self.assertEqual( 'import pkg.mod3\nimport pkg.mod4\n\nprint(pkg.mod4.var)\n', self.mod.read()) @@ -488,49 +488,49 @@ def test_inlining_with_different_returns(self): self.mod.write('def f(p):\n return p\n' 'print(f(1))\nprint(f(2))\nprint(f(1))\n') self._inline2(self.mod, self.mod.read().index('f(') + 1) - self.assertEquals('print(1)\nprint(2)\nprint(1)\n', + self.assertEqual('print(1)\nprint(2)\nprint(1)\n', self.mod.read()) def test_not_removing_definition_for_variables(self): code = 'a_var = 10\nanother_var = a_var\n' refactored = self._inline(code, code.index('a_var') + 1, remove=False) - self.assertEquals('a_var = 10\nanother_var = 10\n', refactored) + self.assertEqual('a_var = 10\nanother_var = 10\n', refactored) def test_not_removing_definition_for_methods(self): code = 'def func():\n print(1)\n\nfunc()\n' refactored = self._inline(code, code.index('func') + 1, remove=False) - self.assertEquals('def func():\n print(1)\n\nprint(1)\n', + self.assertEqual('def func():\n print(1)\n\nprint(1)\n', refactored) def test_only_current_for_methods(self): code = 'def func():\n print(1)\n\nfunc()\nfunc()\n' refactored = self._inline(code, code.rindex('func') + 1, remove=False, only_current=True) - self.assertEquals('def func():\n print(1)\n\nfunc()\nprint(1)\n', + self.assertEqual('def func():\n print(1)\n\nfunc()\nprint(1)\n', refactored) def test_only_current_for_variables(self): code = 'one = 1\n\na = one\nb = one\n' refactored = self._inline(code, code.rindex('one') + 1, remove=False, only_current=True) - self.assertEquals('one = 1\n\na = one\nb = 1\n', refactored) + self.assertEqual('one = 1\n\na = one\nb = 1\n', refactored) def test_inlining_one_line_functions(self): code = 'def f(): return 1\nvar = f()\n' refactored = self._inline(code, code.rindex('f')) - self.assertEquals('var = 1\n', refactored) + self.assertEqual('var = 1\n', refactored) def test_inlining_one_line_functions_with_breaks(self): code = 'def f(\np): return p\nvar = f(1)\n' refactored = self._inline(code, code.rindex('f')) - self.assertEquals('var = 1\n', refactored) + self.assertEqual('var = 1\n', refactored) def test_inlining_one_line_functions_with_breaks2(self): code = 'def f(\n): return 1\nvar = f()\n' refactored = self._inline(code, code.rindex('f')) - self.assertEquals('var = 1\n', refactored) + self.assertEqual('var = 1\n', refactored) def test_resources_parameter(self): self.mod.write('def a_func():\n print(1)\n') @@ -538,29 +538,29 @@ def test_resources_parameter(self): mod1.write('import mod\nmod.a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func'), resources=[self.mod]) - self.assertEquals('', self.mod.read()) - self.assertEquals('import mod\nmod.a_func()\n', mod1.read()) + self.assertEqual('', self.mod.read()) + self.assertEqual('import mod\nmod.a_func()\n', mod1.read()) def test_inlining_parameters(self): code = 'def f(p=1):\n pass\nf()\n' result = self._inline(code, code.index('p')) - self.assertEquals('def f(p=1):\n pass\nf(1)\n', result) + self.assertEqual('def f(p=1):\n pass\nf(1)\n', result) def test_inlining_function_with_line_breaks_in_args(self): code = 'def f(p): return p\nvar = f(1 +\n1)\n' refactored = self._inline(code, code.rindex('f')) - self.assertEquals('var = 1 + 1\n', refactored) + self.assertEqual('var = 1 + 1\n', refactored) def test_inlining_variables_before_comparison(self): code = 'start = 1\nprint(start <= 2)\n' refactored = self._inline(code, code.index('start')) - self.assertEquals('print(1 <= 2)\n', refactored) + self.assertEqual('print(1 <= 2)\n', refactored) def test_inlining_variables_in_other_modules(self): self.mod.write('myvar = 1\n') self.mod2.write('import mod\nprint(mod.myvar)\n') self._inline2(self.mod, 2) - self.assertEquals('import mod\nprint(1)\n', self.mod2.read()) + self.assertEqual('import mod\nprint(1)\n', self.mod2.read()) def test_inlining_variables_and_back_importing(self): self.mod.write('mainvar = 1\nmyvar = mainvar\n') @@ -569,7 +569,7 @@ def test_inlining_variables_and_back_importing(self): expected = 'import mod\n' \ 'from mod import mainvar\n' \ 'print(mainvar)\n' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) def test_inlining_variables_and_importing_used_imports(self): self.mod.write('import sys\nmyvar = sys.argv\n') @@ -578,19 +578,19 @@ def test_inlining_variables_and_importing_used_imports(self): expected = 'import mod\n' \ 'import sys\n' \ 'print(sys.argv)\n' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) def test_inlining_variables_and_removing_old_froms(self): self.mod.write('var = 1\n') self.mod2.write('from mod import var\nprint(var)\n') self._inline2(self.mod2, self.mod2.read().rindex('var')) - self.assertEquals('print(1)\n', self.mod2.read()) + self.assertEqual('print(1)\n', self.mod2.read()) def test_inlining_method_and_removing_old_froms(self): self.mod.write('def f(): return 1\n') self.mod2.write('from mod import f\nprint(f())\n') self._inline2(self.mod2, self.mod2.read().rindex('f')) - self.assertEquals('print(1)\n', self.mod2.read()) + self.assertEqual('print(1)\n', self.mod2.read()) def test_inlining_functions_in_other_modules_and_only_current(self): code1 = 'def f():\n' \ @@ -606,8 +606,8 @@ def test_inlining_functions_in_other_modules_and_only_current(self): expected2 = 'import mod\n' \ 'print(mod.f())\n' \ 'print(1)\n' - self.assertEquals(code1, self.mod.read()) - self.assertEquals(expected2, self.mod2.read()) + self.assertEqual(code1, self.mod.read()) + self.assertEqual(expected2, self.mod2.read()) def test_inlining_variables_in_other_modules_and_only_current(self): code1 = 'var = 1\n' \ @@ -622,8 +622,8 @@ def test_inlining_variables_in_other_modules_and_only_current(self): expected2 = 'import mod\n' \ 'print(mod.var)\n' \ 'print(1)\n' - self.assertEquals(code1, self.mod.read()) - self.assertEquals(expected2, self.mod2.read()) + self.assertEqual(code1, self.mod.read()) + self.assertEqual(expected2, self.mod2.read()) def test_inlining_does_not_change_string_constants(self): code = 'var = 1\n' \ @@ -634,7 +634,7 @@ def test_inlining_does_not_change_string_constants(self): '")\n' refactored = self._inline(code, code.rindex('var'), remove=False, only_current=True, docs=False) - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_inlining_does_change_string_constants_if_docs_is_set(self): code = 'var = 1\n' \ @@ -645,7 +645,7 @@ def test_inlining_does_change_string_constants_if_docs_is_set(self): '")\n' refactored = self._inline(code, code.rindex('var'), remove=False, only_current=True, docs=True) - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def suite(): diff --git a/ropetest/refactor/movetest.py b/ropetest/refactor/movetest.py index ad667cc77..078c8ac2d 100644 --- a/ropetest/refactor/movetest.py +++ b/ropetest/refactor/movetest.py @@ -33,8 +33,8 @@ def test_simple_moving(self): self.mod1.write('class AClass(object):\n pass\n') self._move(self.mod1, self.mod1.read().index('AClass') + 1, self.mod2) - self.assertEquals('', self.mod1.read()) - self.assertEquals('class AClass(object):\n pass\n', + self.assertEqual('', self.mod1.read()) + self.assertEqual('class AClass(object):\n pass\n', self.mod2.read()) def test_changing_other_modules_adding_normal_imports(self): @@ -42,7 +42,7 @@ def test_changing_other_modules_adding_normal_imports(self): self.mod3.write('import mod1\na_var = mod1.AClass()\n') self._move(self.mod1, self.mod1.read().index('AClass') + 1, self.mod2) - self.assertEquals('import mod1\nimport mod2\na_var = mod2.AClass()\n', + self.assertEqual('import mod1\nimport mod2\na_var = mod2.AClass()\n', self.mod3.read()) def test_changing_other_modules_removing_from_imports(self): @@ -50,14 +50,14 @@ def test_changing_other_modules_removing_from_imports(self): self.mod3.write('from mod1 import AClass\na_var = AClass()\n') self._move(self.mod1, self.mod1.read().index('AClass') + 1, self.mod2) - self.assertEquals('import mod2\na_var = mod2.AClass()\n', + self.assertEqual('import mod2\na_var = mod2.AClass()\n', self.mod3.read()) def test_changing_source_module(self): self.mod1.write('class AClass(object):\n pass\na_var = AClass()\n') self._move(self.mod1, self.mod1.read().index('AClass') + 1, self.mod2) - self.assertEquals('import mod2\na_var = mod2.AClass()\n', + self.assertEqual('import mod2\na_var = mod2.AClass()\n', self.mod1.read()) def test_changing_destination_module(self): @@ -65,7 +65,7 @@ def test_changing_destination_module(self): self.mod2.write('from mod1 import AClass\na_var = AClass()\n') self._move(self.mod1, self.mod1.read().index('AClass') + 1, self.mod2) - self.assertEquals('class AClass(object):\n ' + self.assertEqual('class AClass(object):\n ' 'pass\na_var = AClass()\n', self.mod2.read()) @@ -98,7 +98,7 @@ def test_moving_used_imports_to_destination_module(self): expected = 'import mod3\n' \ 'from mod3 import a_var\n\n\n' \ 'def a_func():\n print(mod3, a_var)\n' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) def test_moving_used_names_to_destination_module2(self): code = 'a_var = 10\n' \ @@ -106,11 +106,11 @@ def test_moving_used_names_to_destination_module2(self): ' print(a_var)\n' self.mod1.write(code) self._move(self.mod1, code.index('a_func') + 1, self.mod2) - self.assertEquals('a_var = 10\n', self.mod1.read()) + self.assertEqual('a_var = 10\n', self.mod1.read()) expected = 'from mod1 import a_var\n\n\n' \ 'def a_func():\n' \ ' print(a_var)\n' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) def test_moving_used_underlined_names_to_destination_module(self): code = '_var = 10\n' \ @@ -121,7 +121,7 @@ def test_moving_used_underlined_names_to_destination_module(self): expected = 'from mod1 import _var\n\n\n' \ 'def a_func():\n' \ ' print(_var)\n' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) def test_moving_and_used_relative_imports(self): code = 'import mod5\n' \ @@ -132,14 +132,14 @@ def test_moving_and_used_relative_imports(self): expected = 'import pkg.mod5\n\n\n' \ 'def a_func():\n' \ ' print(pkg.mod5)\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_modules(self): code = 'import mod1\nprint(mod1)' self.mod2.write(code) self._move(self.mod2, code.index('mod1') + 1, self.pkg) expected = 'import pkg.mod1\nprint(pkg.mod1)' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) self.assertTrue(not self.mod1.exists() and self.project.find_module('pkg.mod1') is not None) @@ -148,14 +148,14 @@ def test_moving_modules_and_removing_out_of_date_imports(self): self.mod2.write(code) self._move(self.mod2, code.index('mod4') + 1, self.project.root) expected = 'import mod4\nprint(mod4)' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) self.assertTrue(self.project.find_module('mod4') is not None) def test_moving_modules_and_removing_out_of_date_froms(self): code = 'from pkg import mod4\nprint(mod4)' self.mod2.write(code) self._move(self.mod2, code.index('mod4') + 1, self.project.root) - self.assertEquals('import mod4\nprint(mod4)', self.mod2.read()) + self.assertEqual('import mod4\nprint(mod4)', self.mod2.read()) def test_moving_modules_and_removing_out_of_date_froms2(self): self.mod4.write('a_var = 10') @@ -163,7 +163,7 @@ def test_moving_modules_and_removing_out_of_date_froms2(self): self.mod2.write(code) self._move(self.mod2, code.index('mod4') + 1, self.project.root) expected = 'from mod4 import a_var\nprint(a_var)\n' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) def test_moving_modules_and_relative_import(self): self.mod4.write('import mod5\nprint(mod5)\n') @@ -172,7 +172,7 @@ def test_moving_modules_and_relative_import(self): self._move(self.mod2, code.index('mod4') + 1, self.project.root) moved = self.project.find_module('mod4') expected = 'import pkg.mod5\nprint(pkg.mod5)\n' - self.assertEquals(expected, moved.read()) + self.assertEqual(expected, moved.read()) def test_moving_packages(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -184,14 +184,14 @@ def test_moving_packages(self): self.assertTrue(self.project.find_module('pkg2.pkg.mod4') is not None) self.assertTrue(self.project.find_module('pkg2.pkg.mod5') is not None) expected = 'import pkg2.pkg.mod4\nprint(pkg2.pkg.mod4)' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_modules_with_self_imports(self): self.mod1.write('import mod1\nprint(mod1)\n') self.mod2.write('import mod1\n') self._move(self.mod2, self.mod2.read().index('mod1') + 1, self.pkg) moved = self.project.find_module('pkg.mod1') - self.assertEquals('import pkg.mod1\nprint(pkg.mod1)\n', moved.read()) + self.assertEqual('import pkg.mod1\nprint(pkg.mod1)\n', moved.read()) def test_moving_modules_with_from_imports(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -204,7 +204,7 @@ def test_moving_modules_with_from_imports(self): self.assertTrue(self.project.find_module('pkg2.pkg.mod5') is not None) expected = ('from pkg2.pkg import mod4\n' 'print(mod4)') - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_modules_with_from_import(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -218,7 +218,7 @@ def test_moving_modules_with_from_import(self): self.project.find_module('pkg2.pkg3.pkg4.mod4') is not None) expected = ('from pkg2.pkg3.pkg4 import mod4\n' 'print(mod4)') - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_modules_with_multi_from_imports(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -233,7 +233,7 @@ def test_moving_modules_with_multi_from_imports(self): expected = ('from pkg import mod5\n' 'from pkg2.pkg3.pkg4 import mod4\n' 'print(mod4)') - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_modules_with_from_and_normal_imports(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -251,7 +251,7 @@ def test_moving_modules_with_from_and_normal_imports(self): 'from pkg2.pkg3.pkg4 import mod4\n' 'print(mod4)\n' 'print(pkg2.pkg3.pkg4.mod4)') - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_modules_with_normal_and_from_imports(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -269,7 +269,7 @@ def test_moving_modules_with_normal_and_from_imports(self): 'from pkg2.pkg3.pkg4 import mod4\n' 'print(mod4)\n' 'print(pkg2.pkg3.pkg4.mod4)') - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_modules_from_import_variable(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -283,7 +283,7 @@ def test_moving_modules_from_import_variable(self): self.project.find_module('pkg2.pkg3.pkg4.mod4') is not None) expected = ('from pkg2.pkg3.pkg4.mod4 import foo\n' 'print(foo)') - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_modules_normal_import(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -297,7 +297,7 @@ def test_moving_modules_normal_import(self): self.project.find_module('pkg2.pkg3.pkg4.mod4') is not None) expected = ('import pkg2.pkg3.pkg4.mod4\n' 'print(pkg2.pkg3.pkg4.mod4)') - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_package_with_from_and_normal_imports(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -314,7 +314,7 @@ def test_moving_package_with_from_and_normal_imports(self): 'import pkg2.pkg.mod4\n' 'print(pkg2.pkg.mod4)\n' 'print(mod4)') - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_package_with_from_and_normal_imports2(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -331,7 +331,7 @@ def test_moving_package_with_from_and_normal_imports2(self): 'from pkg2.pkg import mod4\n' 'print(pkg2.pkg.mod4)\n' 'print(mod4)') - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_package_and_retaining_blank_lines(self): pkg2 = testutils.create_package(self.project, 'pkg2', self.pkg) @@ -355,7 +355,7 @@ def test_moving_package_and_retaining_blank_lines(self): 'from pkg.pkg2 import mod4\n' 'print(pkg.pkg2.mod4)\n' 'print(mod4)') - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_funtions_to_imported_module(self): code = 'import mod1\n' \ @@ -367,7 +367,7 @@ def test_moving_funtions_to_imported_module(self): expected = 'def a_func():\n' \ ' var = a_var\n' \ 'a_var = 1\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_resources_using_move_module_refactoring(self): self.mod1.write('a_var = 1') @@ -375,7 +375,7 @@ def test_moving_resources_using_move_module_refactoring(self): mover = move.create_move(self.project, self.mod1) mover.get_changes(self.pkg).do() expected = 'import pkg.mod1\nmy_var = pkg.mod1.a_var\n' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) self.assertTrue(self.pkg.get_child('mod1.py') is not None) def test_moving_resources_using_move_module_for_packages(self): @@ -384,7 +384,7 @@ def test_moving_resources_using_move_module_for_packages(self): mover = move.create_move(self.project, self.pkg) mover.get_changes(pkg2).do() expected = 'import pkg2.pkg\nmy_pkg = pkg2.pkg' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) self.assertTrue(pkg2.get_child('pkg') is not None) def test_moving_resources_using_move_module_for_init_dot_py(self): @@ -393,7 +393,7 @@ def test_moving_resources_using_move_module_for_init_dot_py(self): init = self.pkg.get_child('__init__.py') mover = move.create_move(self.project, init) mover.get_changes(pkg2).do() - self.assertEquals('import pkg2.pkg\nmy_pkg = pkg2.pkg', + self.assertEqual('import pkg2.pkg\nmy_pkg = pkg2.pkg', self.mod1.read()) self.assertTrue(pkg2.get_child('pkg') is not None) @@ -402,7 +402,7 @@ def test_moving_module_and_star_imports(self): self.mod2.write('from mod1 import *\na = a_var\n') mover = move.create_move(self.project, self.mod1) mover.get_changes(self.pkg).do() - self.assertEquals('from pkg.mod1 import *\na = a_var\n', + self.assertEqual('from pkg.mod1 import *\na = a_var\n', self.mod2.read()) def test_moving_module_and_not_removing_blanks_after_imports(self): @@ -411,7 +411,7 @@ def test_moving_module_and_not_removing_blanks_after_imports(self): 'import os\n\n\nprint(mod4.a_var)\n') mover = move.create_move(self.project, self.mod4) mover.get_changes(self.project.root).do() - self.assertEquals('import os\nimport mod4\n\n\n' + self.assertEqual('import os\nimport mod4\n\n\n' 'print(mod4.a_var)\n', self.mod2.read()) def test_moving_module_refactoring_and_nonexistent_destinations(self): @@ -434,7 +434,7 @@ def test_moving_methods_getting_new_method_for_empty_methods(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEquals('def new_method(self):\n pass\n', + self.assertEqual('def new_method(self):\n pass\n', mover.get_new_method('new_method')) def test_moving_methods_getting_new_method_for_constant_methods(self): @@ -442,7 +442,7 @@ def test_moving_methods_getting_new_method_for_constant_methods(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEquals('def new_method(self):\n return 1\n', + self.assertEqual('def new_method(self):\n return 1\n', mover.get_new_method('new_method')) def test_moving_methods_getting_new_method_passing_simple_paremters(self): @@ -451,7 +451,7 @@ def test_moving_methods_getting_new_method_passing_simple_paremters(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEquals('def new_method(self, p):\n return p\n', + self.assertEqual('def new_method(self, p):\n return p\n', mover.get_new_method('new_method')) def test_moving_methods_getting_new_method_using_main_object(self): @@ -460,7 +460,7 @@ def test_moving_methods_getting_new_method_using_main_object(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEquals('def new_method(self, host):' + self.assertEqual('def new_method(self, host):' '\n return host.attr\n', mover.get_new_method('new_method')) @@ -470,7 +470,7 @@ def test_moving_methods_getting_new_method_renaming_main_object(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEquals('def new_method(self, host):' + self.assertEqual('def new_method(self, host):' '\n return host.attr\n', mover.get_new_method('new_method')) @@ -480,7 +480,7 @@ def test_moving_methods_gettin_new_method_with_keyword_arguments(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEquals('def new_method(self, p=None):\n return p\n', + self.assertEqual('def new_method(self, p=None):\n return p\n', mover.get_new_method('new_method')) def test_moving_methods_gettin_new_method_with_many_kinds_arguments(self): @@ -492,7 +492,7 @@ def test_moving_methods_gettin_new_method_with_many_kinds_arguments(self): code.index('a_method')) expected = 'def new_method(self, host, p1, *args, **kwds):\n' \ ' return host.attr\n' - self.assertEquals(expected, mover.get_new_method('new_method')) + self.assertEqual(expected, mover.get_new_method('new_method')) def test_moving_methods_getting_new_method_for_multi_line_methods(self): code = 'class A(object):\n' \ @@ -502,7 +502,7 @@ def test_moving_methods_getting_new_method_for_multi_line_methods(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEquals( + self.assertEqual( 'def new_method(self):\n a = 2\n return a\n', mover.get_new_method('new_method')) @@ -522,7 +522,7 @@ def test_moving_methods_getting_old_method_for_constant_methods(self): ' attr = mod2.B()\n' \ ' def a_method(self):\n' \ ' return self.attr.new_method()\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_moving_methods_getting_getting_changes_for_goal_class(self): self.mod2.write('class B(object):\n var = 1\n') @@ -539,7 +539,7 @@ def test_moving_methods_getting_getting_changes_for_goal_class(self): ' var = 1\n\n\n' \ ' def new_method(self):\n' \ ' return 1\n' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) def test_moving_methods_getting_getting_changes_for_goal_class2(self): code = 'class B(object):\n var = 1\n\n' \ @@ -549,7 +549,7 @@ def test_moving_methods_getting_getting_changes_for_goal_class2(self): mover = move.create_move(self.project, self.mod1, code.index('a_method')) mover.get_changes('attr', 'new_method').do() - self.assertEquals( + self.assertEqual( 'class B(object):\n var = 1\n\n\n' ' def new_method(self):\n' ' return 1\n\n' @@ -592,7 +592,7 @@ def test_moving_methods_and_moving_used_imports(self): ' var = 1\n\n\n' \ ' def new_method(self):\n' \ ' return sys.version\n' - self.assertEquals(code, self.mod2.read()) + self.assertEqual(code, self.mod2.read()) def test_moving_methods_getting_getting_changes_for_goal_class3(self): self.mod2.write('class B(object):\n pass\n') @@ -608,7 +608,7 @@ def test_moving_methods_getting_getting_changes_for_goal_class3(self): expected = 'class B(object):\n\n' \ ' def new_method(self):\n' \ ' return 1\n' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) def test_moving_methods_and_source_class_with_parameters(self): self.mod2.write('class B(object):\n pass\n') @@ -625,11 +625,11 @@ def test_moving_methods_and_source_class_with_parameters(self): ' attr = mod2.B()\n' \ ' def a_method(self, p):\n' \ ' return self.attr.new_method(p)\n' - self.assertEquals(expected1, self.mod1.read()) + self.assertEqual(expected1, self.mod1.read()) expected2 = 'class B(object):\n\n' \ ' def new_method(self, p):\n' \ ' return p\n' - self.assertEquals(expected2, self.mod2.read()) + self.assertEqual(expected2, self.mod2.read()) def test_moving_globals_to_a_module_with_only_docstrings(self): self.mod1.write('import sys\n\n\ndef f():\n print(sys.version)\n') @@ -637,7 +637,7 @@ def test_moving_globals_to_a_module_with_only_docstrings(self): mover = move.create_move(self.project, self.mod1, self.mod1.read().index('f()') + 1) self.project.do(mover.get_changes(self.mod2)) - self.assertEquals( + self.assertEqual( '"""doc\n\nMore docs ...\n\n"""\n' 'import sys\n\n\ndef f():\n print(sys.version)\n', self.mod2.read()) @@ -657,7 +657,7 @@ def test_moving_globals_to_a_module_with_only_docstrings2(self): 'import sys\n\n\n' \ 'def f():\n' \ ' print(sys.version, os.path)\n' - self.assertEquals(expected, self.mod2.read()) + self.assertEqual(expected, self.mod2.read()) def test_moving_a_global_when_it_is_used_after_a_multiline_str(self): code = 'def f():\n pass\ns = """\\\n"""\nr = f()\n' @@ -666,7 +666,7 @@ def test_moving_a_global_when_it_is_used_after_a_multiline_str(self): code.index('f()') + 1) self.project.do(mover.get_changes(self.mod2)) expected = 'import mod2\ns = """\\\n"""\nr = mod2.f()\n' - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) def test_raising_an_exception_when_moving_non_package_folders(self): dir = self.project.root.create_folder('dir') @@ -682,7 +682,7 @@ def test_moving_to_a_module_with_encoding_cookie(self): code2.index('f()') + 1) self.project.do(mover.get_changes(self.mod1)) expected = '%s\n%s' % (code1, code2) - self.assertEquals(expected, self.mod1.read()) + self.assertEqual(expected, self.mod1.read()) if __name__ == '__main__': diff --git a/ropetest/refactor/multiprojecttest.py b/ropetest/refactor/multiprojecttest.py index 1801f3281..cdc3e564a 100644 --- a/ropetest/refactor/multiprojecttest.py +++ b/ropetest/refactor/multiprojecttest.py @@ -25,7 +25,7 @@ def test_trivial_rename(self): rename.Rename, []) renamer = refactoring(self.project1, self.mod1, 1) multiproject.perform(renamer.get_all_changes('newvar')) - self.assertEquals('newvar = 1\n', self.mod1.read()) + self.assertEqual('newvar = 1\n', self.mod1.read()) def test_rename(self): self.mod1.write('var = 1\n') @@ -34,8 +34,8 @@ def test_rename(self): rename.Rename, [self.project2]) renamer = refactoring(self.project1, self.mod1, 1) multiproject.perform(renamer.get_all_changes('newvar')) - self.assertEquals('newvar = 1\n', self.mod1.read()) - self.assertEquals('import mod1\nmyvar = mod1.newvar\n', + self.assertEqual('newvar = 1\n', self.mod1.read()) + self.assertEqual('import mod1\nmyvar = mod1.newvar\n', self.mod2.read()) def test_move(self): @@ -46,9 +46,9 @@ def test_move(self): renamer = refactoring(self.project1, self.mod1, self.mod1.read().index('_func')) multiproject.perform(renamer.get_all_changes(self.other)) - self.assertEquals('', self.mod1.read()) - self.assertEquals('def a_func():\n pass\n', self.other.read()) - self.assertEquals( + self.assertEqual('', self.mod1.read()) + self.assertEqual('def a_func():\n pass\n', self.other.read()) + self.assertEqual( 'import mod1\nimport other\nmyvar = other.a_func()\n', self.mod2.read()) @@ -61,8 +61,8 @@ def test_rename_from_the_project_not_containing_the_change(self): renamer = refactoring(self.project2, self.mod2, self.mod2.read().rindex('var')) multiproject.perform(renamer.get_all_changes('newvar')) - self.assertEquals('newvar = 1\n', self.mod1.read()) - self.assertEquals('import mod1\nmyvar = mod1.newvar\n', + self.assertEqual('newvar = 1\n', self.mod1.read()) + self.assertEqual('import mod1\nmyvar = mod1.newvar\n', self.mod2.read()) diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index 75441b69c..4850c1a68 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -33,62 +33,62 @@ def _rename(self, resource, offset, new_name, **kwds): def test_simple_global_variable_renaming(self): refactored = self._local_rename('a_var = 20\n', 2, 'new_var') - self.assertEquals('new_var = 20\n', refactored) + self.assertEqual('new_var = 20\n', refactored) def test_variable_renaming_only_in_its_scope(self): refactored = self._local_rename( 'a_var = 20\ndef a_func():\n a_var = 10\n', 32, 'new_var') - self.assertEquals('a_var = 20\ndef a_func():\n new_var = 10\n', + self.assertEqual('a_var = 20\ndef a_func():\n new_var = 10\n', refactored) def test_not_renaming_dot_name(self): refactored = self._local_rename( "replace = True\n'aaa'.replace('a', 'b')\n", 1, 'new_var') - self.assertEquals("new_var = True\n'aaa'.replace('a', 'b')\n", + self.assertEqual("new_var = True\n'aaa'.replace('a', 'b')\n", refactored) def test_renaming_multiple_names_in_the_same_line(self): refactored = self._local_rename( 'a_var = 10\na_var = 10 + a_var / 2\n', 2, 'new_var') - self.assertEquals('new_var = 10\nnew_var = 10 + new_var / 2\n', + self.assertEqual('new_var = 10\nnew_var = 10 + new_var / 2\n', refactored) def test_renaming_names_when_getting_some_attribute(self): refactored = self._local_rename( "a_var = 'a b c'\na_var.split('\\n')\n", 2, 'new_var') - self.assertEquals("new_var = 'a b c'\nnew_var.split('\\n')\n", + self.assertEqual("new_var = 'a b c'\nnew_var.split('\\n')\n", refactored) def test_renaming_names_when_getting_some_attribute2(self): refactored = self._local_rename( "a_var = 'a b c'\na_var.split('\\n')\n", 20, 'new_var') - self.assertEquals("new_var = 'a b c'\nnew_var.split('\\n')\n", + self.assertEqual("new_var = 'a b c'\nnew_var.split('\\n')\n", refactored) def test_renaming_function_parameters1(self): refactored = self._local_rename( "def f(a_param):\n print(a_param)\n", 8, 'new_param') - self.assertEquals("def f(new_param):\n print(new_param)\n", + self.assertEqual("def f(new_param):\n print(new_param)\n", refactored) def test_renaming_function_parameters2(self): refactored = self._local_rename( "def f(a_param):\n print(a_param)\n", 30, 'new_param') - self.assertEquals("def f(new_param):\n print(new_param)\n", + self.assertEqual("def f(new_param):\n print(new_param)\n", refactored) def test_renaming_occurrences_inside_functions(self): code = 'def a_func(p1):\n a = p1\na_func(1)\n' refactored = self._local_rename(code, code.index('p1') + 1, 'new_param') - self.assertEquals( + self.assertEqual( 'def a_func(new_param):\n a = new_param\na_func(1)\n', refactored) def test_renaming_arguments_for_normal_args_changing_calls(self): code = 'def a_func(p1=None, p2=None):\n pass\na_func(p2=1)\n' refactored = self._local_rename(code, code.index('p2') + 1, 'p3') - self.assertEquals( + self.assertEqual( 'def a_func(p1=None, p3=None):\n pass\na_func(p3=1)\n', refactored) @@ -101,7 +101,7 @@ def test_renaming_function_parameters_of_class_init(self): expected = 'class A(object):\n ' \ 'def __init__(self, new_param):\n pass\n' \ 'a_var = A(new_param=1)\n' - self.assertEquals(expected, refactored) + self.assertEqual(expected, refactored) def test_renam_functions_parameters_and_occurances_in_other_modules(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -109,57 +109,57 @@ def test_renam_functions_parameters_and_occurances_in_other_modules(self): mod1.write('def a_func(a_param):\n print(a_param)\n') mod2.write('from mod1 import a_func\na_func(a_param=10)\n') self._rename(mod1, mod1.read().index('a_param') + 1, 'new_param') - self.assertEquals('def a_func(new_param):\n print(new_param)\n', + self.assertEqual('def a_func(new_param):\n print(new_param)\n', mod1.read()) - self.assertEquals('from mod1 import a_func\na_func(new_param=10)\n', + self.assertEqual('from mod1 import a_func\na_func(new_param=10)\n', mod2.read()) def test_renaming_with_backslash_continued_names(self): refactored = self._local_rename( "replace = True\n'ali'.\\\nreplace\n", 2, 'is_replace') - self.assertEquals("is_replace = True\n'ali'.\\\nreplace\n", + self.assertEqual("is_replace = True\n'ali'.\\\nreplace\n", refactored) def test_not_renaming_string_contents(self): refactored = self._local_rename("a_var = 20\na_string='a_var'\n", 2, 'new_var') - self.assertEquals("new_var = 20\na_string='a_var'\n", + self.assertEqual("new_var = 20\na_string='a_var'\n", refactored) def test_not_renaming_comment_contents(self): refactored = self._local_rename("a_var = 20\n# a_var\n", 2, 'new_var') - self.assertEquals("new_var = 20\n# a_var\n", refactored) + self.assertEqual("new_var = 20\n# a_var\n", refactored) def test_renaming_all_occurances_in_containing_scope(self): code = 'if True:\n a_var = 1\nelse:\n a_var = 20\n' refactored = self._local_rename(code, 16, 'new_var') - self.assertEquals( + self.assertEqual( 'if True:\n new_var = 1\nelse:\n new_var = 20\n', refactored) def test_renaming_a_variable_with_arguement_name(self): code = 'a_var = 10\ndef a_func(a_var):\n print(a_var)\n' refactored = self._local_rename(code, 1, 'new_var') - self.assertEquals( + self.assertEqual( 'new_var = 10\ndef a_func(a_var):\n print(a_var)\n', refactored) def test_renaming_an_arguement_with_variable_name(self): code = 'a_var = 10\ndef a_func(a_var):\n print(a_var)\n' refactored = self._local_rename(code, len(code) - 3, 'new_var') - self.assertEquals( + self.assertEqual( 'a_var = 10\ndef a_func(new_var):\n print(new_var)\n', refactored) def test_renaming_function_with_local_variable_name(self): code = 'def a_func():\n a_func=20\na_func()' refactored = self._local_rename(code, len(code) - 3, 'new_func') - self.assertEquals('def new_func():\n a_func=20\nnew_func()', + self.assertEqual('def new_func():\n a_func=20\nnew_func()', refactored) def test_renaming_functions(self): code = 'def a_func():\n pass\na_func()\n' refactored = self._local_rename(code, len(code) - 5, 'new_func') - self.assertEquals('def new_func():\n pass\nnew_func()\n', + self.assertEqual('def new_func():\n pass\nnew_func()\n', refactored) def test_renaming_functions_across_modules(self): @@ -168,9 +168,9 @@ def test_renaming_functions_across_modules(self): mod2 = testutils.create_module(self.project, 'mod2') mod2.write('import mod1\nmod1.a_func()\n') self._rename(mod1, len(mod1.read()) - 5, 'new_func') - self.assertEquals('def new_func():\n pass\nnew_func()\n', + self.assertEqual('def new_func():\n pass\nnew_func()\n', mod1.read()) - self.assertEquals('import mod1\nmod1.new_func()\n', mod2.read()) + self.assertEqual('import mod1\nmod1.new_func()\n', mod2.read()) def test_renaming_functions_across_modules_from_import(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -178,9 +178,9 @@ def test_renaming_functions_across_modules_from_import(self): mod2 = testutils.create_module(self.project, 'mod2') mod2.write('from mod1 import a_func\na_func()\n') self._rename(mod1, len(mod1.read()) - 5, 'new_func') - self.assertEquals('def new_func():\n pass\nnew_func()\n', + self.assertEqual('def new_func():\n pass\nnew_func()\n', mod1.read()) - self.assertEquals('from mod1 import new_func\nnew_func()\n', + self.assertEqual('from mod1 import new_func\nnew_func()\n', mod2.read()) def test_renaming_functions_from_another_module(self): @@ -189,9 +189,9 @@ def test_renaming_functions_from_another_module(self): mod2 = testutils.create_module(self.project, 'mod2') mod2.write('import mod1\nmod1.a_func()\n') self._rename(mod2, len(mod2.read()) - 5, 'new_func') - self.assertEquals('def new_func():\n pass\nnew_func()\n', + self.assertEqual('def new_func():\n pass\nnew_func()\n', mod1.read()) - self.assertEquals('import mod1\nmod1.new_func()\n', mod2.read()) + self.assertEqual('import mod1\nmod1.new_func()\n', mod2.read()) def test_applying_all_changes_together(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -199,8 +199,8 @@ def test_applying_all_changes_together(self): mod2 = testutils.create_module(self.project, 'mod2') mod2.write('def a_func():\n pass\na_func()\n') self._rename(mod2, len(mod2.read()) - 5, 'new_func') - self.assertEquals('import mod2\nmod2.new_func()\n', mod1.read()) - self.assertEquals('def new_func():\n pass\nnew_func()\n', + self.assertEqual('import mod2\nmod2.new_func()\n', mod1.read()) + self.assertEqual('def new_func():\n pass\nnew_func()\n', mod2.read()) def test_renaming_modules(self): @@ -211,7 +211,7 @@ def test_renaming_modules(self): self._rename(mod2, mod2.read().index('mod1') + 1, 'newmod') self.assertTrue(not mod1.exists() and self.project.find_module('newmod') is not None) - self.assertEquals('from newmod import a_func\n', mod2.read()) + self.assertEqual('from newmod import a_func\n', mod2.read()) def test_renaming_packages(self): pkg = testutils.create_package(self.project, 'pkg') @@ -222,7 +222,7 @@ def test_renaming_packages(self): self._rename(mod2, 6, 'newpkg') self.assertTrue(self.project.find_module('newpkg.mod1') is not None) new_mod2 = self.project.find_module('newpkg.mod2') - self.assertEquals('from newpkg.mod1 import a_func\n', new_mod2.read()) + self.assertEqual('from newpkg.mod1 import a_func\n', new_mod2.read()) def test_module_dependencies(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -233,8 +233,8 @@ def test_module_dependencies(self): mod1.write('def AClass():\n return 0\n') self._rename(mod2, len(mod2.read()) - 3, 'a_func') - self.assertEquals('def a_func():\n return 0\n', mod1.read()) - self.assertEquals('import mod1\na_var = mod1.a_func()\n', mod2.read()) + self.assertEqual('def a_func():\n return 0\n', mod1.read()) + self.assertEqual('import mod1\na_var = mod1.a_func()\n', mod2.read()) def test_renaming_class_attributes(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -245,9 +245,9 @@ def test_renaming_class_attributes(self): 'another_var = a_var.an_attr') self._rename(mod1, mod1.read().index('an_attr'), 'attr') - self.assertEquals('class AClass(object):\n def __init__(self):\n' + self.assertEqual('class AClass(object):\n def __init__(self):\n' ' self.attr = 10\n', mod1.read()) - self.assertEquals( + self.assertEqual( 'import mod1\na_var = mod1.AClass()\nanother_var = a_var.attr', mod2.read()) @@ -260,10 +260,10 @@ def test_renaming_class_attributes2(self): 'another_var = a_var.an_attr') self._rename(mod1, mod1.read().rindex('an_attr'), 'attr') - self.assertEquals( + self.assertEqual( 'class AClass(object):\n def __init__(self):\n' ' an_attr = 10\n self.attr = 10\n', mod1.read()) - self.assertEquals( + self.assertEqual( 'import mod1\na_var = mod1.AClass()\nanother_var = a_var.attr', mod2.read()) @@ -274,7 +274,7 @@ def test_renaming_methods_in_subclasses(self): self._rename(mod, mod.read().rindex('a_method') + 1, 'new_method', in_hierarchy=True) - self.assertEquals( + self.assertEqual( 'class A(object):\n def new_method(self):\n pass\n' 'class B(A):\n def new_method(self):\n pass\n', mod.read()) @@ -287,7 +287,7 @@ def test_renaming_methods_in_sibling_classes(self): self._rename(mod, mod.read().rindex('a_method') + 1, 'new_method', in_hierarchy=True) - self.assertEquals( + self.assertEqual( 'class A(object):\n def new_method(self):\n pass\n' 'class B(A):\n def new_method(self):\n pass\n' 'class C(A):\n def new_method(self):\n pass\n', @@ -300,7 +300,7 @@ def test_not_renaming_methods_in_hierarchies(self): self._rename(mod, mod.read().rindex('a_method') + 1, 'new_method', in_hierarchy=False) - self.assertEquals( + self.assertEqual( 'class A(object):\n def a_method(self):\n pass\n' 'class B(A):\n def new_method(self):\n pass\n', mod.read()) @@ -310,7 +310,7 @@ def test_undoing_refactorings(self): mod1.write('def a_func():\n pass\na_func()\n') self._rename(mod1, len(mod1.read()) - 5, 'new_func') self.project.history.undo() - self.assertEquals('def a_func():\n pass\na_func()\n', mod1.read()) + self.assertEqual('def a_func():\n pass\na_func()\n', mod1.read()) def test_undoing_renaming_modules(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -319,8 +319,8 @@ def test_undoing_renaming_modules(self): mod2.write('from mod1 import a_func\n') self._rename(mod2, 6, 'newmod') self.project.history.undo() - self.assertEquals('mod1.py', mod1.path) - self.assertEquals('from mod1 import a_func\n', mod2.read()) + self.assertEqual('mod1.py', mod1.path) + self.assertEqual('from mod1 import a_func\n', mod2.read()) def test_rename_in_module_renaming_one_letter_names_for_expressions(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -331,25 +331,25 @@ def test_rename_in_module_renaming_one_letter_names_for_expressions(self): self.project, 'a', old_pyname) refactored = rename.rename_in_module( finder, 'new_var', pymodule=pymod, replace_primary=True) - self.assertEquals('new_var = 10\nprint(1+new_var)\n', refactored) + self.assertEqual('new_var = 10\nprint(1+new_var)\n', refactored) def test_renaming_for_loop_variable(self): code = 'for var in range(10):\n print(var)\n' refactored = self._local_rename(code, code.find('var') + 1, 'new_var') - self.assertEquals('for new_var in range(10):\n print(new_var)\n', + self.assertEqual('for new_var in range(10):\n print(new_var)\n', refactored) def test_renaming_parameters(self): code = 'def a_func(param):\n print(param)\na_func(param=hey)\n' refactored = self._local_rename(code, code.find('param') + 1, 'new_param') - self.assertEquals('def a_func(new_param):\n print(new_param)\n' + self.assertEqual('def a_func(new_param):\n print(new_param)\n' 'a_func(new_param=hey)\n', refactored) def test_renaming_assigned_parameters(self): code = 'def f(p):\n p = p + 1\n return p\nf(p=1)\n' refactored = self._local_rename(code, code.find('p'), 'arg') - self.assertEquals('def f(arg):\n arg = arg + 1\n' + self.assertEqual('def f(arg):\n arg = arg + 1\n' ' return arg\nf(arg=1)\n', refactored) def test_renaming_parameters_not_renaming_others(self): @@ -357,7 +357,7 @@ def test_renaming_parameters_not_renaming_others(self): '\n print(param)\nparam=10\na_func(param)\n' refactored = self._local_rename(code, code.find('param') + 1, 'new_param') - self.assertEquals('def a_func(new_param):\n print(new_param)\n' + self.assertEqual('def a_func(new_param):\n print(new_param)\n' 'param=10\na_func(param)\n', refactored) def test_renaming_parameters_not_renaming_others2(self): @@ -365,7 +365,7 @@ def test_renaming_parameters_not_renaming_others2(self): 'param=10\na_func(param=param)' refactored = self._local_rename(code, code.find('param') + 1, 'new_param') - self.assertEquals('def a_func(new_param):\n print(new_param)\n' + self.assertEqual('def a_func(new_param):\n print(new_param)\n' 'param=10\na_func(new_param=param)', refactored) def test_renaming_parameters_with_multiple_params(self): @@ -373,7 +373,7 @@ def test_renaming_parameters_with_multiple_params(self): 'a_func(param1=1, param2=2)\n' refactored = self._local_rename(code, code.find('param1') + 1, 'new_param') - self.assertEquals( + self.assertEqual( 'def a_func(new_param, param2):\n print(new_param)\n' 'a_func(new_param=1, param2=2)\n', refactored) @@ -382,28 +382,28 @@ def test_renaming_parameters_with_multiple_params2(self): 'a_func(param1=1, param2=2)\n' refactored = self._local_rename(code, code.rfind('param2') + 1, 'new_param') - self.assertEquals('def a_func(param1, new_param):\n print(param1)\n' + self.assertEqual('def a_func(param1, new_param):\n print(param1)\n' 'a_func(param1=1, new_param=2)\n', refactored) def test_renaming_parameters_on_calls(self): code = 'def a_func(param):\n print(param)\na_func(param = hey)\n' refactored = self._local_rename(code, code.rfind('param') + 1, 'new_param') - self.assertEquals('def a_func(new_param):\n print(new_param)\n' + self.assertEqual('def a_func(new_param):\n print(new_param)\n' 'a_func(new_param = hey)\n', refactored) def test_renaming_parameters_spaces_before_call(self): code = 'def a_func(param):\n print(param)\na_func (param=hey)\n' refactored = self._local_rename(code, code.rfind('param') + 1, 'new_param') - self.assertEquals('def a_func(new_param):\n print(new_param)\n' + self.assertEqual('def a_func(new_param):\n print(new_param)\n' 'a_func (new_param=hey)\n', refactored) def test_renaming_parameter_like_objects_after_keywords(self): code = 'def a_func(param):\n print(param)\ndict(param=hey)\n' refactored = self._local_rename(code, code.find('param') + 1, 'new_param') - self.assertEquals('def a_func(new_param):\n print(new_param)\n' + self.assertEqual('def a_func(new_param):\n print(new_param)\n' 'dict(param=hey)\n', refactored) def test_renaming_variables_in_init_dot_pys(self): @@ -413,8 +413,8 @@ def test_renaming_variables_in_init_dot_pys(self): mod = testutils.create_module(self.project, 'mod') mod.write('import pkg\nprint(pkg.a_var)\n') self._rename(mod, mod.read().index('a_var') + 1, 'new_var') - self.assertEquals('new_var = 10\n', init_dot_py.read()) - self.assertEquals('import pkg\nprint(pkg.new_var)\n', mod.read()) + self.assertEqual('new_var = 10\n', init_dot_py.read()) + self.assertEqual('import pkg\nprint(pkg.new_var)\n', mod.read()) def test_renaming_variables_in_init_dot_pys2(self): pkg = testutils.create_package(self.project, 'pkg') @@ -424,8 +424,8 @@ def test_renaming_variables_in_init_dot_pys2(self): mod.write('import pkg\nprint(pkg.a_var)\n') self._rename(init_dot_py, init_dot_py.read().index('a_var') + 1, 'new_var') - self.assertEquals('new_var = 10\n', init_dot_py.read()) - self.assertEquals('import pkg\nprint(pkg.new_var)\n', mod.read()) + self.assertEqual('new_var = 10\n', init_dot_py.read()) + self.assertEqual('import pkg\nprint(pkg.new_var)\n', mod.read()) def test_renaming_variables_in_init_dot_pys3(self): pkg = testutils.create_package(self.project, 'pkg') @@ -434,8 +434,8 @@ def test_renaming_variables_in_init_dot_pys3(self): mod = testutils.create_module(self.project, 'mod') mod.write('import pkg\nprint(pkg.a_var)\n') self._rename(mod, mod.read().index('a_var') + 1, 'new_var') - self.assertEquals('new_var = 10\n', init_dot_py.read()) - self.assertEquals('import pkg\nprint(pkg.new_var)\n', mod.read()) + self.assertEqual('new_var = 10\n', init_dot_py.read()) + self.assertEqual('import pkg\nprint(pkg.new_var)\n', mod.read()) def test_renaming_resources_using_rename_module_refactoring(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -444,7 +444,7 @@ def test_renaming_resources_using_rename_module_refactoring(self): mod2.write('import mod1\nmy_var = mod1.a_var\n') renamer = rename.Rename(self.project, mod1) renamer.get_changes('newmod').do() - self.assertEquals('import newmod\nmy_var = newmod.a_var\n', + self.assertEqual('import newmod\nmy_var = newmod.a_var\n', mod2.read()) def test_renam_resources_using_rename_module_refactor_for_packages(self): @@ -453,7 +453,7 @@ def test_renam_resources_using_rename_module_refactor_for_packages(self): mod1.write('import pkg\nmy_pkg = pkg') renamer = rename.Rename(self.project, pkg) renamer.get_changes('newpkg').do() - self.assertEquals('import newpkg\nmy_pkg = newpkg', mod1.read()) + self.assertEqual('import newpkg\nmy_pkg = newpkg', mod1.read()) def test_renam_resources_use_rename_module_refactor_for_init_dot_py(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -461,12 +461,12 @@ def test_renam_resources_use_rename_module_refactor_for_init_dot_py(self): mod1.write('import pkg\nmy_pkg = pkg') renamer = rename.Rename(self.project, pkg.get_child('__init__.py')) renamer.get_changes('newpkg').do() - self.assertEquals('import newpkg\nmy_pkg = newpkg', mod1.read()) + self.assertEqual('import newpkg\nmy_pkg = newpkg', mod1.read()) def test_renaming_global_variables(self): code = 'a_var = 1\ndef a_func():\n global a_var\n var = a_var\n' refactored = self._local_rename(code, code.index('a_var'), 'new_var') - self.assertEquals( + self.assertEqual( 'new_var = 1\ndef a_func():\n ' 'global new_var\n var = new_var\n', refactored) @@ -474,7 +474,7 @@ def test_renaming_global_variables(self): def test_renaming_global_variables2(self): code = 'a_var = 1\ndef a_func():\n global a_var\n var = a_var\n' refactored = self._local_rename(code, code.rindex('a_var'), 'new_var') - self.assertEquals( + self.assertEqual( 'new_var = 1\ndef a_func():\n ' 'global new_var\n var = new_var\n', refactored) @@ -486,7 +486,7 @@ def test_renaming_when_unsure(self): mod1.write(code) self._rename(mod1, code.index('a_func'), 'new_func', unsure=self._true) - self.assertEquals( + self.assertEqual( 'class C(object):\n def new_func(self):\n pass\n' 'def f(arg):\n arg.new_func()\n', mod1.read()) @@ -502,7 +502,7 @@ def confirm(occurrence): mod1 = testutils.create_module(self.project, 'mod1') mod1.write(code) self._rename(mod1, code.index('a_func'), 'new_func', unsure=confirm) - self.assertEquals( + self.assertEqual( 'class C(object):\n def new_func(self):\n pass\n' 'def f(arg):\n arg.a_func()\n', mod1.read()) @@ -513,7 +513,7 @@ def test_renaming_when_unsure_not_renaming_knowns(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write(code) self._rename(mod1, code.index('a_func'), 'new_func', unsure=self._true) - self.assertEquals( + self.assertEqual( 'class C1(object):\n def new_func(self):\n pass\n' 'class C2(object):\n def a_func(self):\n pass\n' 'c1 = C1()\nc1.new_func()\nc2 = C2()\nc2.a_func()\n', @@ -524,27 +524,27 @@ def test_renaming_in_strings_and_comments(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write(code) self._rename(mod1, code.index('a_var'), 'new_var', docs=True) - self.assertEquals('new_var = 1\n# new_var\n', mod1.read()) + self.assertEqual('new_var = 1\n# new_var\n', mod1.read()) def test_not_renaming_in_strings_and_comments_where_not_visible(self): code = 'def f():\n a_var = 1\n# a_var\n' mod1 = testutils.create_module(self.project, 'mod1') mod1.write(code) self._rename(mod1, code.index('a_var'), 'new_var', docs=True) - self.assertEquals('def f():\n new_var = 1\n# a_var\n', mod1.read()) + self.assertEqual('def f():\n new_var = 1\n# a_var\n', mod1.read()) def test_not_renaming_all_text_occurrences_in_strings_and_comments(self): code = 'a_var = 1\n# a_vard _a_var\n' mod1 = testutils.create_module(self.project, 'mod1') mod1.write(code) self._rename(mod1, code.index('a_var'), 'new_var', docs=True) - self.assertEquals('new_var = 1\n# a_vard _a_var\n', mod1.read()) + self.assertEqual('new_var = 1\n# a_vard _a_var\n', mod1.read()) def test_renaming_occurrences_in_overwritten_scopes(self): refactored = self._local_rename( 'a_var = 20\ndef f():\n print(a_var)\n' 'def f():\n print(a_var)\n', 2, 'new_var') - self.assertEquals('new_var = 20\ndef f():\n print(new_var)\n' + self.assertEqual('new_var = 20\ndef f():\n print(new_var)\n' 'def f():\n print(new_var)\n', refactored) def test_renaming_occurrences_in_overwritten_scopes2(self): @@ -552,13 +552,13 @@ def test_renaming_occurrences_in_overwritten_scopes2(self): 'def f():\n a_var = 1\n print(a_var)\n' refactored = self._local_rename(code, code.index('a_var') + 1, 'new_var') - self.assertEquals(code.replace('a_var', 'new_var', 2), refactored) + self.assertEqual(code.replace('a_var', 'new_var', 2), refactored) def test_dos_line_ending_and_renaming(self): code = '\r\na = 1\r\n\r\nprint(2 + a + 2)\r\n' offset = code.replace('\r\n', '\n').rindex('a') refactored = self._local_rename(code, offset, 'b') - self.assertEquals('\nb = 1\n\nprint(2 + b + 2)\n', + self.assertEqual('\nb = 1\n\nprint(2 + b + 2)\n', refactored.replace('\r\n', '\n')) def test_multi_byte_strs_and_renaming(self): @@ -566,7 +566,7 @@ def test_multi_byte_strs_and_renaming(self): code = u'# -*- coding: utf-8 -*-\n# ' + s + \ '\na = 1\nprint(2 + a + 2)\n' refactored = self._local_rename(code, code.rindex('a'), 'b') - self.assertEquals(u'# -*- coding: utf-8 -*-\n# ' + s + + self.assertEqual(u'# -*- coding: utf-8 -*-\n# ' + s + '\nb = 1\nprint(2 + b + 2)\n', refactored) def test_resources_parameter(self): @@ -576,8 +576,8 @@ def test_resources_parameter(self): mod2.write('import mod1\nmod1.f()\n') self._rename(mod1, mod1.read().rindex('f'), 'g', resources=[mod1]) - self.assertEquals('def g():\n pass\n', mod1.read()) - self.assertEquals('import mod1\nmod1.f()\n', mod2.read()) + self.assertEqual('def g():\n pass\n', mod1.read()) + self.assertEqual('import mod1\nmod1.f()\n', mod2.read()) def test_resources_parameter_not_changing_defining_module(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -586,8 +586,8 @@ def test_resources_parameter_not_changing_defining_module(self): mod2.write('import mod1\nmod1.f()\n') self._rename(mod1, mod1.read().rindex('f'), 'g', resources=[mod2]) - self.assertEquals('def f():\n pass\n', mod1.read()) - self.assertEquals('import mod1\nmod1.g()\n', mod2.read()) + self.assertEqual('def f():\n pass\n', mod1.read()) + self.assertEqual('import mod1\nmod1.g()\n', mod2.read()) # XXX: with variables should not leak @testutils.only_for('2.5') @@ -599,7 +599,7 @@ def xxx_test_with_statement_variables_should_not_leak(self): mod1.write(code) self._rename(mod1, code.rindex('f'), 'file') expected = 'f = 1\nwith open("1.txt") as file:\n print(file)\n' - self.assertEquals(expected, mod1.read()) + self.assertEqual(expected, mod1.read()) class ChangeOccurrencesTest(unittest.TestCase): @@ -617,14 +617,14 @@ def test_simple_case(self): changer = rename.ChangeOccurrences(self.project, self.mod, self.mod.read().index('a_var')) changer.get_changes('new_var').do() - self.assertEquals('new_var = 1\nprint(new_var)\n', self.mod.read()) + self.assertEqual('new_var = 1\nprint(new_var)\n', self.mod.read()) def test_only_performing_inside_scopes(self): self.mod.write('a_var = 1\nnew_var = 2\ndef f():\n print(a_var)\n') changer = rename.ChangeOccurrences(self.project, self.mod, self.mod.read().rindex('a_var')) changer.get_changes('new_var').do() - self.assertEquals( + self.assertEqual( 'a_var = 1\nnew_var = 2\ndef f():\n print(new_var)\n', self.mod.read()) @@ -634,7 +634,7 @@ def test_only_performing_on_calls(self): changer = rename.ChangeOccurrences(self.project, self.mod, self.mod.read().rindex('f1')) changer.get_changes('f2', only_calls=True).do() - self.assertEquals( + self.assertEqual( 'def f1():\n pass\ndef f2():\n pass\ng = f1\na = f2()\n', self.mod.read()) @@ -643,7 +643,7 @@ def test_only_performing_on_reads(self): changer = rename.ChangeOccurrences(self.project, self.mod, self.mod.read().rindex('a')) changer.get_changes('b', writes=False).do() - self.assertEquals('a = 1\nb = 2\nprint(b)\n', self.mod.read()) + self.assertEqual('a = 1\nb = 2\nprint(b)\n', self.mod.read()) class ImplicitInterfacesTest(unittest.TestCase): @@ -672,8 +672,8 @@ def test_performing_rename_on_parameters(self): 'mod1.f(A())\nmod1.f(B())\n') self.pycore.analyze_module(self.mod2) self._rename(self.mod1, self.mod1.read().index('run'), 'newrun') - self.assertEquals('def f(arg):\n arg.newrun()\n', self.mod1.read()) - self.assertEquals( + self.assertEqual('def f(arg):\n arg.newrun()\n', self.mod1.read()) + self.assertEqual( 'import mod1\n\n\n' 'class A(object):\n def newrun(self):\n pass\n' 'class B(object):\n def newrun(self):\n pass\n' diff --git a/ropetest/refactor/restructuretest.py b/ropetest/refactor/restructuretest.py index b721e3085..650b64ac0 100644 --- a/ropetest/refactor/restructuretest.py +++ b/ropetest/refactor/restructuretest.py @@ -21,42 +21,42 @@ def test_trivial_case(self): 'a = 1', 'a = 0') self.mod.write('b = 1\n') self.project.do(refactoring.get_changes()) - self.assertEquals('b = 1\n', self.mod.read()) + self.assertEqual('b = 1\n', self.mod.read()) def test_replacing_simple_patterns(self): refactoring = restructure.Restructure(self.project, 'a = 1', 'a = int(1)') self.mod.write('a = 1\nb = 1\n') self.project.do(refactoring.get_changes()) - self.assertEquals('a = int(1)\nb = 1\n', self.mod.read()) + self.assertEqual('a = int(1)\nb = 1\n', self.mod.read()) def test_replacing_patterns_with_normal_names(self): refactoring = restructure.Restructure( self.project, '${a} = 1', '${a} = int(1)', args={'a': 'exact'}) self.mod.write('a = 1\nb = 1\n') self.project.do(refactoring.get_changes()) - self.assertEquals('a = int(1)\nb = 1\n', self.mod.read()) + self.assertEqual('a = int(1)\nb = 1\n', self.mod.read()) def test_replacing_patterns_with_any_names(self): refactoring = restructure.Restructure(self.project, '${a} = 1', '${a} = int(1)') self.mod.write('a = 1\nb = 1\n') self.project.do(refactoring.get_changes()) - self.assertEquals('a = int(1)\nb = int(1)\n', self.mod.read()) + self.assertEqual('a = int(1)\nb = int(1)\n', self.mod.read()) def test_replacing_patterns_with_any_names2(self): refactoring = restructure.Restructure( self.project, '${x} + ${x}', '${x} * 2') self.mod.write('a = 1 + 1\n') self.project.do(refactoring.get_changes()) - self.assertEquals('a = 1 * 2\n', self.mod.read()) + self.assertEqual('a = 1 * 2\n', self.mod.read()) def test_replacing_patterns_with_checks(self): self.mod.write('def f(p=1):\n return p\ng = f\ng()\n') refactoring = restructure.Restructure( self.project, '${f}()', '${f}(2)', args={'f': 'object=mod.f'}) self.project.do(refactoring.get_changes()) - self.assertEquals('def f(p=1):\n return p\ng = f\ng(2)\n', + self.assertEqual('def f(p=1):\n return p\ng = f\ng(2)\n', self.mod.read()) def test_replacing_assignments_with_sets(self): @@ -64,21 +64,21 @@ def test_replacing_assignments_with_sets(self): self.project, '${a} = ${b}', '${a}.set(${b})') self.mod.write('a = 1\nb = 1\n') self.project.do(refactoring.get_changes()) - self.assertEquals('a.set(1)\nb.set(1)\n', self.mod.read()) + self.assertEqual('a.set(1)\nb.set(1)\n', self.mod.read()) def test_replacing_sets_with_assignments(self): refactoring = restructure.Restructure( self.project, '${a}.set(${b})', '${a} = ${b}') self.mod.write('a.set(1)\nb.set(1)\n') self.project.do(refactoring.get_changes()) - self.assertEquals('a = 1\nb = 1\n', self.mod.read()) + self.assertEqual('a = 1\nb = 1\n', self.mod.read()) def test_using_make_checks(self): self.mod.write('def f(p=1):\n return p\ng = f\ng()\n') refactoring = restructure.Restructure( self.project, '${f}()', '${f}(2)', args={'f': 'object=mod.f'}) self.project.do(refactoring.get_changes()) - self.assertEquals('def f(p=1):\n return p\ng = f\ng(2)\n', + self.assertEqual('def f(p=1):\n return p\ng = f\ng(2)\n', self.mod.read()) def test_using_make_checking_builtin_types(self): @@ -87,28 +87,28 @@ def test_using_make_checking_builtin_types(self): self.project, '${i} + ${i}', '${i} * 2', args={'i': 'type=__builtin__.int'}) self.project.do(refactoring.get_changes()) - self.assertEquals('a = 1 * 2\n', self.mod.read()) + self.assertEqual('a = 1 * 2\n', self.mod.read()) def test_auto_indentation_when_no_indentation(self): self.mod.write('a = 2\n') refactoring = restructure.Restructure( self.project, '${a} = 2', '${a} = 1\n${a} += 1') self.project.do(refactoring.get_changes()) - self.assertEquals('a = 1\na += 1\n', self.mod.read()) + self.assertEqual('a = 1\na += 1\n', self.mod.read()) def test_auto_indentation(self): self.mod.write('def f():\n a = 2\n') refactoring = restructure.Restructure( self.project, '${a} = 2', '${a} = 1\n${a} += 1') self.project.do(refactoring.get_changes()) - self.assertEquals('def f():\n a = 1\n a += 1\n', self.mod.read()) + self.assertEqual('def f():\n a = 1\n a += 1\n', self.mod.read()) def test_auto_indentation_and_not_indenting_blanks(self): self.mod.write('def f():\n a = 2\n') refactoring = restructure.Restructure( self.project, '${a} = 2', '${a} = 1\n\n${a} += 1') self.project.do(refactoring.get_changes()) - self.assertEquals('def f():\n a = 1\n\n a += 1\n', + self.assertEqual('def f():\n a = 1\n\n a += 1\n', self.mod.read()) def test_importing_names(self): @@ -117,7 +117,7 @@ def test_importing_names(self): self.project, '${a} = 2', '${a} = myconsts.two', imports=['import myconsts']) self.project.do(refactoring.get_changes()) - self.assertEquals('import myconsts\na = myconsts.two\n', + self.assertEqual('import myconsts\na = myconsts.two\n', self.mod.read()) def test_not_importing_names_when_there_are_no_changes(self): @@ -126,27 +126,27 @@ def test_not_importing_names_when_there_are_no_changes(self): self.project, '${a} = 2', '${a} = myconsts.two', imports=['import myconsts']) self.project.do(refactoring.get_changes()) - self.assertEquals('a = True\n', self.mod.read()) + self.assertEqual('a = True\n', self.mod.read()) def test_handling_containing_matches(self): self.mod.write('a = 1 / 2 / 3\n') refactoring = restructure.Restructure( self.project, '${a} / ${b}', '${a} // ${b}') self.project.do(refactoring.get_changes()) - self.assertEquals('a = 1 // 2 // 3\n', self.mod.read()) + self.assertEqual('a = 1 // 2 // 3\n', self.mod.read()) def test_handling_overlapping_matches(self): self.mod.write('a = 1\na = 1\na = 1\n') refactoring = restructure.Restructure( self.project, 'a = 1\na = 1\n', 'b = 1') self.project.do(refactoring.get_changes()) - self.assertEquals('b = 1\na = 1\n', self.mod.read()) + self.assertEqual('b = 1\na = 1\n', self.mod.read()) def test_preventing_stack_overflow_when_matching(self): self.mod.write('1\n') refactoring = restructure.Restructure(self.project, '${a}', '${a}') self.project.do(refactoring.get_changes()) - self.assertEquals('1\n', self.mod.read()) + self.assertEqual('1\n', self.mod.read()) def test_performing_a_restructuring_to_all_modules(self): mod2 = testutils.create_module(self.project, 'mod2') @@ -154,8 +154,8 @@ def test_performing_a_restructuring_to_all_modules(self): mod2.write('b = 1\n') refactoring = restructure.Restructure(self.project, '1', '2 / 1') self.project.do(refactoring.get_changes()) - self.assertEquals('a = 2 / 1\n', self.mod.read()) - self.assertEquals('b = 2 / 1\n', mod2.read()) + self.assertEqual('a = 2 / 1\n', self.mod.read()) + self.assertEqual('b = 2 / 1\n', mod2.read()) def test_performing_a_restructuring_to_selected_modules(self): mod2 = testutils.create_module(self.project, 'mod2') @@ -163,8 +163,8 @@ def test_performing_a_restructuring_to_selected_modules(self): mod2.write('b = 1\n') refactoring = restructure.Restructure(self.project, '1', '2 / 1') self.project.do(refactoring.get_changes(resources=[mod2])) - self.assertEquals('a = 1\n', self.mod.read()) - self.assertEquals('b = 2 / 1\n', mod2.read()) + self.assertEqual('a = 1\n', self.mod.read()) + self.assertEqual('b = 2 / 1\n', mod2.read()) def test_unsure_argument_of_default_wildcard(self): self.mod.write('def f(p):\n return p * 2\nx = "" * 2\ni = 1 * 2\n') @@ -172,7 +172,7 @@ def test_unsure_argument_of_default_wildcard(self): self.project, '${s} * 2', 'dup(${s})', args={'s': {'type': '__builtins__.str', 'unsure': True}}) self.project.do(refactoring.get_changes()) - self.assertEquals('def f(p):\n return dup(p)\nx = dup("")\n' + self.assertEqual('def f(p):\n return dup(p)\nx = dup("")\n' 'i = 1 * 2\n', self.mod.read()) def test_statement_after_string_and_column(self): @@ -180,7 +180,7 @@ def test_statement_after_string_and_column(self): self.mod.write(mod_text) refactoring = restructure.Restructure(self.project, '${a}', '${a}') self.project.do(refactoring.get_changes()) - self.assertEquals(mod_text, self.mod.read()) + self.assertEqual(mod_text, self.mod.read()) if __name__ == '__main__': diff --git a/ropetest/refactor/similarfindertest.py b/ropetest/refactor/similarfindertest.py index c8e6c1ff3..693e0de80 100644 --- a/ropetest/refactor/similarfindertest.py +++ b/ropetest/refactor/similarfindertest.py @@ -22,52 +22,52 @@ def _create_finder(self, source, **kwds): def test_trivial_case(self): finder = self._create_finder('') - self.assertEquals([], list(finder.get_match_regions('10'))) + self.assertEqual([], list(finder.get_match_regions('10'))) def test_constant_integer(self): source = 'a = 10\n' finder = self._create_finder(source) result = [(source.index('10'), source.index('10') + 2)] - self.assertEquals(result, list(finder.get_match_regions('10'))) + self.assertEqual(result, list(finder.get_match_regions('10'))) def test_simple_addition(self): source = 'a = 1 + 2\n' finder = self._create_finder(source) result = [(source.index('1'), source.index('2') + 1)] - self.assertEquals(result, list(finder.get_match_regions('1 + 2'))) + self.assertEqual(result, list(finder.get_match_regions('1 + 2'))) def test_simple_addition2(self): source = 'a = 1 +2\n' finder = self._create_finder(source) result = [(source.index('1'), source.index('2') + 1)] - self.assertEquals(result, list(finder.get_match_regions('1 + 2'))) + self.assertEqual(result, list(finder.get_match_regions('1 + 2'))) def test_simple_assign_statements(self): source = 'a = 1 + 2\n' finder = self._create_finder(source) - self.assertEquals([(0, len(source) - 1)], + self.assertEqual([(0, len(source) - 1)], list(finder.get_match_regions('a = 1 + 2'))) def test_simple_multiline_statements(self): source = 'a = 1\nb = 2\n' finder = self._create_finder(source) - self.assertEquals([(0, len(source) - 1)], + self.assertEqual([(0, len(source) - 1)], list(finder.get_match_regions('a = 1\nb = 2'))) def test_multiple_matches(self): source = 'a = 1 + 1\n' finder = self._create_finder(source) result = list(finder.get_match_regions('1')) - self.assertEquals(2, len(result)) + self.assertEqual(2, len(result)) start1 = source.index('1') - self.assertEquals((start1, start1 + 1), result[0]) + self.assertEqual((start1, start1 + 1), result[0]) start2 = source.rindex('1') - self.assertEquals((start2, start2 + 1), result[1]) + self.assertEqual((start2, start2 + 1), result[1]) def test_multiple_matches2(self): source = 'a = 1\nb = 2\n\na = 1\nb = 2\n' finder = self._create_finder(source) - self.assertEquals( + self.assertEqual( 2, len(list(finder.get_match_regions('a = 1\nb = 2')))) def test_restricting_the_region_to_search(self): @@ -75,86 +75,86 @@ def test_restricting_the_region_to_search(self): finder = self._create_finder(source) result = list(finder.get_match_regions('1', start=2)) start = source.rfind('1') - self.assertEquals([(start, start + 1)], result) + self.assertEqual([(start, start + 1)], result) def test_matching_basic_patterns(self): source = 'b = a\n' finder = self._create_finder(source) result = list(finder.get_match_regions('${a}', args={'a': 'exact'})) start = source.rfind('a') - self.assertEquals([(start, start + 1)], result) + self.assertEqual([(start, start + 1)], result) def test_match_get_ast(self): source = 'b = a\n' finder = self._create_finder(source) result = list(finder.get_matches('${a}', args={'a': 'exact'})) - self.assertEquals('a', result[0].get_ast('a').id) + self.assertEqual('a', result[0].get_ast('a').id) def test_match_get_ast_for_statements(self): source = 'b = a\n' finder = self._create_finder(source) result = list(finder.get_matches('b = ${a}')) - self.assertEquals('a', result[0].get_ast('a').id) + self.assertEqual('a', result[0].get_ast('a').id) def test_matching_multiple_patterns(self): source = 'c = a + b\n' finder = self._create_finder(source) result = list(finder.get_matches('${a} + ${b}')) - self.assertEquals('a', result[0].get_ast('a').id) - self.assertEquals('b', result[0].get_ast('b').id) + self.assertEqual('a', result[0].get_ast('a').id) + self.assertEqual('b', result[0].get_ast('b').id) def test_matching_any_patterns(self): source = 'b = a\n' finder = self._create_finder(source) result = list(finder.get_matches('b = ${x}')) - self.assertEquals('a', result[0].get_ast('x').id) + self.assertEqual('a', result[0].get_ast('x').id) def test_matching_any_patterns_repeating(self): source = 'b = 1 + 1\n' finder = self._create_finder(source) result = list(finder.get_matches('b = ${x} + ${x}')) - self.assertEquals(1, result[0].get_ast('x').n) + self.assertEqual(1, result[0].get_ast('x').n) def test_matching_any_patterns_not_matching_different_nodes(self): source = 'b = 1 + 2\n' finder = self._create_finder(source) result = list(finder.get_matches('b = ${x} + ${x}')) - self.assertEquals(0, len(result)) + self.assertEqual(0, len(result)) def test_matching_normal_names_and_assname(self): source = 'a = 1\n' finder = self._create_finder(source) result = list(finder.get_matches('${a} = 1')) - self.assertEquals('a', result[0].get_ast('a').id) + self.assertEqual('a', result[0].get_ast('a').id) def test_matching_normal_names_and_assname2(self): source = 'a = 1\n' finder = self._create_finder(source) result = list(finder.get_matches('${a}', args={'a': 'exact'})) - self.assertEquals(1, len(result)) + self.assertEqual(1, len(result)) def test_matching_normal_names_and_attributes(self): source = 'x.a = 1\n' finder = self._create_finder(source) result = list(finder.get_matches('${a} = 1', args={'a': 'exact'})) - self.assertEquals(0, len(result)) + self.assertEqual(0, len(result)) def test_functions_not_matching_when_only_first_parameters(self): source = 'f(1, 2)\n' finder = self._create_finder(source) - self.assertEquals(0, len(list(finder.get_matches('f(1)')))) + self.assertEqual(0, len(list(finder.get_matches('f(1)')))) def test_matching_nested_try_finally(self): source = 'if 1:\n try:\n pass\n except:\n pass\n' pattern = 'try:\n pass\nexcept:\n pass\n' finder = self._create_finder(source) - self.assertEquals(1, len(list(finder.get_matches(pattern)))) + self.assertEqual(1, len(list(finder.get_matches(pattern)))) def test_matching_dicts_inside_functions(self): source = 'def f(p):\n d = {1: p.x}\n' pattern = '{1: ${a}.x}' finder = self._create_finder(source) - self.assertEquals(1, len(list(finder.get_matches(pattern)))) + self.assertEqual(1, len(list(finder.get_matches(pattern)))) class CheckingFinderTest(unittest.TestCase): @@ -172,14 +172,14 @@ def test_trivial_case(self): self.mod1.write('') pymodule = self.project.get_pymodule(self.mod1) finder = similarfinder.SimilarFinder(pymodule) - self.assertEquals([], list(finder.get_matches('10', {}))) + self.assertEqual([], list(finder.get_matches('10', {}))) def test_simple_finding(self): self.mod1.write('class A(object):\n pass\na = A()\n') pymodule = self.project.get_pymodule(self.mod1) finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${anything} = ${A}()', {})) - self.assertEquals(1, len(result)) + self.assertEqual(1, len(result)) def test_not_matching_when_the_name_does_not_match(self): self.mod1.write('class A(object):\n pass\na = list()\n') @@ -187,7 +187,7 @@ def test_not_matching_when_the_name_does_not_match(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${anything} = ${C}()', {'C': 'name=mod1.A'})) - self.assertEquals(0, len(result)) + self.assertEqual(0, len(result)) def test_not_matching_unknowns_finding(self): self.mod1.write('class A(object):\n pass\na = unknown()\n') @@ -195,7 +195,7 @@ def test_not_matching_unknowns_finding(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${anything} = ${C}()', {'C': 'name=mod1.A'})) - self.assertEquals(0, len(result)) + self.assertEqual(0, len(result)) def test_finding_and_matching_pyobjects(self): source = 'class A(object):\n pass\nNewA = A\na = NewA()\n' @@ -204,9 +204,9 @@ def test_finding_and_matching_pyobjects(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${anything} = ${A}()', {'A': 'object=mod1.A'})) - self.assertEquals(1, len(result)) + self.assertEqual(1, len(result)) start = source.rindex('a =') - self.assertEquals((start, len(source) - 1), result[0].get_region()) + self.assertEqual((start, len(source) - 1), result[0].get_region()) def test_finding_and_matching_types(self): source = 'class A(object):\n def f(self):\n pass\n' \ @@ -216,9 +216,9 @@ def test_finding_and_matching_types(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${anything} = ${inst}.f()', {'inst': 'type=mod1.A'})) - self.assertEquals(1, len(result)) + self.assertEqual(1, len(result)) start = source.rindex('b') - self.assertEquals((start, len(source) - 1), result[0].get_region()) + self.assertEqual((start, len(source) - 1), result[0].get_region()) def test_checking_the_type_of_an_ass_name_node(self): self.mod1.write('class A(object):\n pass\nan_a = A()\n') @@ -226,7 +226,7 @@ def test_checking_the_type_of_an_ass_name_node(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${a} = ${assigned}', {'a': 'type=mod1.A'})) - self.assertEquals(1, len(result)) + self.assertEqual(1, len(result)) def test_checking_instance_of_an_ass_name_node(self): self.mod1.write('class A(object):\n pass\n' @@ -235,7 +235,7 @@ def test_checking_instance_of_an_ass_name_node(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${a} = ${assigned}', {'a': 'instance=mod1.A'})) - self.assertEquals(1, len(result)) + self.assertEqual(1, len(result)) def test_checking_equality_of_imported_pynames(self): mod2 = testutils.create_module(self.project, 'mod2') @@ -245,30 +245,30 @@ def test_checking_equality_of_imported_pynames(self): finder = similarfinder.SimilarFinder(pymod1) result = list(finder.get_matches('${a_class}()', {'a_class': 'name=mod2.A'})) - self.assertEquals(1, len(result)) + self.assertEqual(1, len(result)) class TemplateTest(unittest.TestCase): def test_simple_templates(self): template = similarfinder.CodeTemplate('${a}\n') - self.assertEquals(set(['a']), set(template.get_names())) + self.assertEqual(set(['a']), set(template.get_names())) def test_ignoring_matches_in_comments(self): template = similarfinder.CodeTemplate('#${a}\n') - self.assertEquals({}.keys(), template.get_names()) + self.assertEqual({}.keys(), template.get_names()) def test_ignoring_matches_in_strings(self): template = similarfinder.CodeTemplate("'${a}'\n") - self.assertEquals({}.keys(), template.get_names()) + self.assertEqual({}.keys(), template.get_names()) def test_simple_substitution(self): template = similarfinder.CodeTemplate('${a}\n') - self.assertEquals('b\n', template.substitute({'a': 'b'})) + self.assertEqual('b\n', template.substitute({'a': 'b'})) def test_substituting_multiple_names(self): template = similarfinder.CodeTemplate('${a}, ${b}\n') - self.assertEquals('1, 2\n', template.substitute({'a': '1', 'b': '2'})) + self.assertEqual('1, 2\n', template.substitute({'a': '1', 'b': '2'})) def suite(): diff --git a/ropetest/refactor/suitestest.py b/ropetest/refactor/suitestest.py index d9b8b972e..4798fecb9 100644 --- a/ropetest/refactor/suitestest.py +++ b/ropetest/refactor/suitestest.py @@ -14,121 +14,121 @@ def tearDown(self): def test_trivial_case(self): root = source_suite_tree('') - self.assertEquals(1, root.get_start()) - self.assertEquals(0, len(root.get_children())) + self.assertEqual(1, root.get_start()) + self.assertEqual(0, len(root.get_children())) def test_simple_ifs(self): root = source_suite_tree('if True:\n pass') - self.assertEquals(1, len(root.get_children())) + self.assertEqual(1, len(root.get_children())) def test_simple_else(self): root = source_suite_tree( 'if True:\n pass\nelse:\n pass\n') - self.assertEquals(2, len(root.get_children())) - self.assertEquals(1, root.get_children()[1].get_start()) + self.assertEqual(2, len(root.get_children())) + self.assertEqual(1, root.get_children()[1].get_start()) def test_for(self): root = source_suite_tree( '\nfor i in range(10):\n pass\nelse:\n pass\n') - self.assertEquals(2, len(root.get_children())) - self.assertEquals(2, root.get_children()[1].get_start()) + self.assertEqual(2, len(root.get_children())) + self.assertEqual(2, root.get_children()[1].get_start()) def test_while(self): root = source_suite_tree( 'while True:\n pass\n') - self.assertEquals(1, len(root.get_children())) - self.assertEquals(1, root.get_children()[0].get_start()) + self.assertEqual(1, len(root.get_children())) + self.assertEqual(1, root.get_children()[0].get_start()) def test_with(self): root = source_suite_tree( 'from __future__ import with_statement\nwith file(x): pass\n') - self.assertEquals(1, len(root.get_children())) - self.assertEquals(2, root.get_children()[0].get_start()) + self.assertEqual(1, len(root.get_children())) + self.assertEqual(2, root.get_children()[0].get_start()) def test_try_finally(self): root = source_suite_tree( 'try:\n pass\nfinally:\n pass\n') - self.assertEquals(2, len(root.get_children())) - self.assertEquals(1, root.get_children()[0].get_start()) + self.assertEqual(2, len(root.get_children())) + self.assertEqual(1, root.get_children()[0].get_start()) def test_try_except(self): root = source_suite_tree( 'try:\n pass\nexcept:\n pass\nelse:\n pass\n') - self.assertEquals(3, len(root.get_children())) - self.assertEquals(1, root.get_children()[2].get_start()) + self.assertEqual(3, len(root.get_children())) + self.assertEqual(1, root.get_children()[2].get_start()) def test_try_except_finally(self): root = source_suite_tree( 'try:\n pass\nexcept:\n pass\nfinally:\n pass\n') - self.assertEquals(3, len(root.get_children())) - self.assertEquals(1, root.get_children()[2].get_start()) + self.assertEqual(3, len(root.get_children())) + self.assertEqual(1, root.get_children()[2].get_start()) def test_local_start_and_end(self): root = source_suite_tree('if True:\n pass\nelse:\n pass\n') - self.assertEquals(1, root.local_start()) - self.assertEquals(4, root.local_end()) + self.assertEqual(1, root.local_start()) + self.assertEqual(4, root.local_end()) if_suite = root.get_children()[0] - self.assertEquals(2, if_suite.local_start()) - self.assertEquals(2, if_suite.local_end()) + self.assertEqual(2, if_suite.local_start()) + self.assertEqual(2, if_suite.local_end()) else_suite = root.get_children()[1] - self.assertEquals(4, else_suite.local_start()) - self.assertEquals(4, else_suite.local_end()) + self.assertEqual(4, else_suite.local_start()) + self.assertEqual(4, else_suite.local_end()) def test_find_suite(self): root = source_suite_tree('\n') - self.assertEquals(root, root.find_suite(1)) + self.assertEqual(root, root.find_suite(1)) def test_find_suite_for_ifs(self): root = source_suite_tree('if True:\n pass\n') if_suite = root.get_children()[0] - self.assertEquals(if_suite, root.find_suite(2)) + self.assertEqual(if_suite, root.find_suite(2)) def test_find_suite_for_between_suites(self): root = source_suite_tree( 'if True:\n pass\nprint(1)\nif True:\n pass\n') if_suite1 = root.get_children()[0] if_suite2 = root.get_children()[1] - self.assertEquals(if_suite1, root.find_suite(2)) - self.assertEquals(if_suite2, root.find_suite(5)) - self.assertEquals(root, root.find_suite(3)) + self.assertEqual(if_suite1, root.find_suite(2)) + self.assertEqual(if_suite2, root.find_suite(5)) + self.assertEqual(root, root.find_suite(3)) def test_simple_find_visible(self): root = source_suite_tree('a = 1\n') - self.assertEquals(1, suites.find_visible_for_suite(root, [1])) + self.assertEqual(1, suites.find_visible_for_suite(root, [1])) def test_simple_find_visible_ifs(self): root = source_suite_tree('\nif True:\n a = 1\n b = 2\n') - self.assertEquals(root.find_suite(3), root.find_suite(4)) - self.assertEquals(3, suites.find_visible_for_suite(root, [3, 4])) + self.assertEqual(root.find_suite(3), root.find_suite(4)) + self.assertEqual(3, suites.find_visible_for_suite(root, [3, 4])) def test_simple_find_visible_for_else(self): root = source_suite_tree('\nif True:\n pass\nelse: pass\n') - self.assertEquals(2, suites.find_visible_for_suite(root, [2, 4])) + self.assertEqual(2, suites.find_visible_for_suite(root, [2, 4])) def test_simple_find_visible_for_different_suites(self): root = source_suite_tree('if True:\n pass\na = 1\n' 'if False:\n pass\n') - self.assertEquals(1, suites.find_visible_for_suite(root, [2, 3])) - self.assertEquals(5, suites.find_visible_for_suite(root, [5])) - self.assertEquals(1, suites.find_visible_for_suite(root, [2, 5])) + self.assertEqual(1, suites.find_visible_for_suite(root, [2, 3])) + self.assertEqual(5, suites.find_visible_for_suite(root, [5])) + self.assertEqual(1, suites.find_visible_for_suite(root, [2, 5])) def test_not_always_selecting_scope_start(self): root = source_suite_tree( 'if True:\n a = 1\n if True:\n pass\n' ' else:\n pass\n') - self.assertEquals(3, suites.find_visible_for_suite(root, [4, 6])) - self.assertEquals(3, suites.find_visible_for_suite(root, [3, 5])) - self.assertEquals(3, suites.find_visible_for_suite(root, [4, 5])) + self.assertEqual(3, suites.find_visible_for_suite(root, [4, 6])) + self.assertEqual(3, suites.find_visible_for_suite(root, [3, 5])) + self.assertEqual(3, suites.find_visible_for_suite(root, [4, 5])) def test_ignoring_functions(self): root = source_suite_tree( 'def f():\n pass\na = 1\n') - self.assertEquals(3, suites.find_visible_for_suite(root, [2, 3])) + self.assertEqual(3, suites.find_visible_for_suite(root, [2, 3])) def test_ignoring_classes(self): root = source_suite_tree( 'a = 1\nclass C():\n pass\n') - self.assertEquals(1, suites.find_visible_for_suite(root, [1, 3])) + self.assertEqual(1, suites.find_visible_for_suite(root, [1, 3])) def source_suite_tree(source): diff --git a/ropetest/refactor/usefunctiontest.py b/ropetest/refactor/usefunctiontest.py index a6eada009..1bc5c0dce 100644 --- a/ropetest/refactor/usefunctiontest.py +++ b/ropetest/refactor/usefunctiontest.py @@ -25,14 +25,14 @@ def test_simple_case(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEquals(code, self.mod1.read()) + self.assertEqual(code, self.mod1.read()) def test_simple_function(self): code = 'def f(p):\n print(p)\nprint(1)\n' self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEquals('def f(p):\n print(p)\nf(1)\n', + self.assertEqual('def f(p):\n print(p)\nf(1)\n', self.mod1.read()) def test_simple_function2(self): @@ -40,7 +40,7 @@ def test_simple_function2(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEquals('def f(p):\n print(p + 1)\nf(1)\n', + self.assertEqual('def f(p):\n print(p + 1)\nf(1)\n', self.mod1.read()) def test_functions_with_multiple_statements(self): @@ -48,7 +48,7 @@ def test_functions_with_multiple_statements(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEquals('def f(p):\n r = p + 1\n print(r)\nf(2)\n', + self.assertEqual('def f(p):\n r = p + 1\n print(r)\nf(2)\n', self.mod1.read()) def test_returning(self): @@ -56,7 +56,7 @@ def test_returning(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEquals( + self.assertEqual( 'def f(p):\n return p + 1\nr = f(2)\nprint(r)\n', self.mod1.read()) @@ -65,7 +65,7 @@ def test_returning_a_single_expression(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEquals( + self.assertEqual( 'def f(p):\n return p + 1\nprint(f(2))\n', self.mod1.read()) @@ -75,7 +75,7 @@ def test_occurrences_in_other_modules(self): user = UseFunction(self.project, self.mod1, code.rindex('f')) self.mod2.write('print(2 + 1)\n') self.project.do(user.get_changes()) - self.assertEquals('import mod1\nprint(mod1.f(2))\n', + self.assertEqual('import mod1\nprint(mod1.f(2))\n', self.mod2.read()) def test_when_performing_on_non_functions(self): @@ -89,7 +89,7 @@ def test_differing_in_the_inner_temp_names(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEquals('def f(p):\n a = p + 1\n print(a)\nf(2)\n', + self.assertEqual('def f(p):\n a = p + 1\n print(a)\nf(2)\n', self.mod1.read()) # TODO: probably new options should be added to restructure @@ -99,7 +99,7 @@ def xxx_test_being_a_bit_more_intelligent_when_returning_assigneds(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEquals('def f(p):\n a = p + 1\n return a\n' + self.assertEqual('def f(p):\n a = p + 1\n return a\n' 'var = f(p)\nprint(var)\n', self.mod1.read()) def test_exception_when_performing_a_function_with_yield(self): diff --git a/ropetest/runmodtest.py b/ropetest/runmodtest.py index 932088e36..1b799b6c9 100644 --- a/ropetest/runmodtest.py +++ b/ropetest/runmodtest.py @@ -44,7 +44,7 @@ def test_making_runner(self): file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.wait_process() - self.assertEquals('run', self.get_output_file_content(file_path)) + self.assertEqual('run', self.get_output_file_content(file_path)) def test_passing_arguments(self): file_path = 'sample.py' @@ -78,7 +78,7 @@ def test_killing_runner(self): file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.kill_process() - self.assertEquals('', self.get_output_file_content(file_path)) + self.assertEqual('', self.get_output_file_content(file_path)) def test_running_nested_files(self): self.project.root.create_folder('src') @@ -87,7 +87,7 @@ def test_running_nested_files(self): file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.wait_process() - self.assertEquals('run', self.get_output_file_content(file_path)) + self.assertEqual('run', self.get_output_file_content(file_path)) def test_setting_process_input(self): file_path = 'sample.py' @@ -105,7 +105,7 @@ def test_setting_process_input(self): runner = self.pycore.run_module(file_resource, stdin=stdin) runner.wait_process() stdin.close() - self.assertEquals('input text\n', + self.assertEqual('input text\n', self.get_output_file_content(file_path)) finally: os.remove(temp_file_name) @@ -124,7 +124,7 @@ def test_setting_process_output(self): runner.wait_process() stdout.close() temp_file = open(temp_file_name, 'r') - self.assertEquals('output text\n', temp_file.read()) + self.assertEqual('output text\n', temp_file.read()) temp_file.close() finally: os.remove(temp_file_name) @@ -142,7 +142,7 @@ def test_setting_pythonpath(self): file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.wait_process() - self.assertEquals('run', self.get_output_file_content(file_path)) + self.assertEqual('run', self.get_output_file_content(file_path)) def test_making_runner_when_doi_is_disabled(self): self.project.set('enable_doi', False) @@ -151,7 +151,7 @@ def test_making_runner_when_doi_is_disabled(self): file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.wait_process() - self.assertEquals('run', self.get_output_file_content(file_path)) + self.assertEqual('run', self.get_output_file_content(file_path)) def suite(): diff --git a/ropetest/simplifytest.py b/ropetest/simplifytest.py index 05969e36d..de6583ef2 100644 --- a/ropetest/simplifytest.py +++ b/ropetest/simplifytest.py @@ -12,51 +12,51 @@ def tearDown(self): super(SimplifyTest, self).tearDown() def test_trivial_case(self): - self.assertEquals('', simplify.real_code('')) + self.assertEqual('', simplify.real_code('')) def test_empty_strs(self): code = 's = ""\n' - self.assertEquals(code, simplify.real_code(code)) + self.assertEqual(code, simplify.real_code(code)) def test_blanking_strs(self): code = 's = "..."\n' - self.assertEquals('s = " "\n', simplify.real_code(code)) + self.assertEqual('s = " "\n', simplify.real_code(code)) def test_changing_to_double_quotes(self): code = 's = \'\'\n' - self.assertEquals('s = ""\n', simplify.real_code(code)) + self.assertEqual('s = ""\n', simplify.real_code(code)) def test_changing_to_double_quotes2(self): code = 's = """\n"""\n' - self.assertEquals('s = " "\n', simplify.real_code(code)) + self.assertEqual('s = " "\n', simplify.real_code(code)) def test_removing_comments(self): code = '# c\n' - self.assertEquals(' \n', simplify.real_code(code)) + self.assertEqual(' \n', simplify.real_code(code)) def test_removing_comments_that_contain_strings(self): code = '# "c"\n' - self.assertEquals(' \n', simplify.real_code(code)) + self.assertEqual(' \n', simplify.real_code(code)) def test_removing_strings_containing_comments(self): code = '"#c"\n' - self.assertEquals('" "\n', simplify.real_code(code)) + self.assertEqual('" "\n', simplify.real_code(code)) def test_joining_implicit_continuations(self): code = '(\n)\n' - self.assertEquals('( )\n', simplify.real_code(code)) + self.assertEqual('( )\n', simplify.real_code(code)) def test_joining_explicit_continuations(self): code = '1 + \\\n 2\n' - self.assertEquals('1 + 2\n', simplify.real_code(code)) + self.assertEqual('1 + 2\n', simplify.real_code(code)) def test_replacing_tabs(self): code = '1\t+\t2\n' - self.assertEquals('1 + 2\n', simplify.real_code(code)) + self.assertEqual('1 + 2\n', simplify.real_code(code)) def test_replacing_semicolons(self): code = 'a = 1;b = 2\n' - self.assertEquals('a = 1\nb = 2\n', simplify.real_code(code)) + self.assertEqual('a = 1\nb = 2\n', simplify.real_code(code)) def suite(): From e85797c741add3f74e441ad889f67d6443474b88 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sun, 14 Feb 2016 01:23:22 +0200 Subject: [PATCH 70/92] Fixed Py3k for nested with statement --- rope/base/pyobjectsdef.py | 8 ++++---- rope/base/utils/pycompat.py | 12 +++++------- rope/refactor/patchedast.py | 9 +++++---- ropetest/pycoretest.py | 25 +++++++++++++++++++++++++ ropetest/refactor/patchedasttest.py | 5 +++-- 5 files changed, 42 insertions(+), 17 deletions(-) diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index 1d40ac6b7..b1e3dd952 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -393,10 +393,10 @@ def _update_evaluated(self, targets, assigned, return result def _With(self, node): - withitem = pycompat.get_ast_with(node) - if withitem.optional_vars: - self._update_evaluated(withitem.optional_vars, - withitem.context_expr, '.__enter__()') + for item in pycompat.get_ast_with_items(node): + if item.optional_vars: + self._update_evaluated(item.optional_vars, + item.context_expr, '.__enter__()') for child in node.body: ast.walk(child, self) diff --git a/rope/base/utils/pycompat.py b/rope/base/utils/pycompat.py index de271d431..7c5f421c4 100644 --- a/rope/base/utils/pycompat.py +++ b/rope/base/utils/pycompat.py @@ -23,10 +23,12 @@ def execfile(fn, global_vars=None, local_vars=None): exec(code, global_vars or {}, local_vars) def get_ast_arg_arg(node): - if isinstance(node, string_types): + if isinstance(node, string_types): # TODO: G21: Understand the Algorithm (Where it's used?) return node return node.arg + def get_ast_with_items(node): + return node.items else: # PY2 @@ -41,9 +43,5 @@ def get_ast_arg_arg(node): return node return node.id - -def get_ast_with(node): - # @todo fixmee - handle all withitems - if PY2: - return node - return node.items[0] + def get_ast_with_items(node): + return [node] diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 84e1870a3..38a4ae5c6 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -686,10 +686,11 @@ def _While(self, node): self._handle(node, children) def _With(self, node): - withitem = pycompat.get_ast_with(node) - children = ['with', withitem.context_expr] - if withitem.optional_vars: - children.extend(['as', withitem.optional_vars]) + children = [] + for item in pycompat.get_ast_with_items(node): + children.extend(['with', item.context_expr]) + if item.optional_vars: + children.extend(['as', item.optional_vars]) children.append(':') children.extend(node.body) self._handle(node, children) diff --git a/ropetest/pycoretest.py b/ropetest/pycoretest.py index 804330f50..b1969c7b6 100644 --- a/ropetest/pycoretest.py +++ b/ropetest/pycoretest.py @@ -518,6 +518,31 @@ def test_with_statement_variable_type(self): var = pymod['var'].get_object() self.assertEqual(a_class, var.get_type()) + @testutils.only_for('2.5') + def test_nested_with_statement_variable_type(self): + code = 'class A(object):\n' \ + ' def __enter__(self):\n' \ + ' return self\n'\ + ' def __exit__(self, type, value, tb):\n' \ + ' pass\n' \ + 'class B(object):\n' \ + ' def __enter__(self):\n' \ + ' return self\n'\ + ' def __exit__(self, type, value, tb):\n' \ + ' pass\n' \ + 'with A() as var_a, B() as var_b:\n' \ + ' pass\n' + if sys.version_info < (2, 6, 0): + code = 'from __future__ import with_statement\n' + code + pymod = libutils.get_string_module(self.project, code) + a_class = pymod['A'].get_object() + var_a = pymod['var_a'].get_object() + self.assertEqual(a_class, var_a.get_type()) + + b_class = pymod['B'].get_object() + var_b = pymod['var_b'].get_object() + self.assertEqual(b_class, var_b.get_type()) + @testutils.only_for('2.5') def test_with_statement_with_no_vars(self): code = 'with open("file"): pass\n' diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index 9f9097d7d..728bd336d 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -781,8 +781,9 @@ def test_while_node(self): @testutils.only_for('2.5') def test_with_node(self): - source = 'from __future__ import with_statement\nwith a as ' \ - 'b:\n pass\n' + source = 'from __future__ import with_statement\n' +\ + 'with a as b:\n' +\ + ' pass\n' ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) checker.check_children( From 70480f9db5e92823b732ad868167135d9cf91f92 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 01:47:18 +0100 Subject: [PATCH 71/92] changed url to repo --- README.rst | 12 +++++++----- docs/contributing.rst | 6 +++--- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/README.rst b/README.rst index 062458c1b..1c1625357 100644 --- a/README.rst +++ b/README.rst @@ -1,5 +1,5 @@ -.. _GitHub python-rope / rope: https://github.com/python-rope/rope +.. _GitHub python-rope / rope: https://github.com/sergeyglazyrindev/rope ======================================== @@ -11,8 +11,11 @@ Overview ======== `Rope`_ is a python refactoring library. +`Rope Offical`_ originally it was written by @aligrudi and a long time was supported by @mcepl. +We hope to give this library fresh breath and new life. -.. _`rope`: https://github.com/python-rope/rope +.. _`rope`: https://github.com/sergeyglazyrindev/rope +.. _`rope official`: https://github.com/python-rope/rope New Features @@ -40,10 +43,9 @@ you open a project). Bug Reports =========== -Send your bug reports and feature requests to `rope-dev (at) -googlegroups.com`_. +Please create issues or enhancements on github `Issues`_ page. -.. _`rope-dev (at) googlegroups.com`: http://groups.google.com/group/rope-dev +.. _`Issues`: https://github.com/sergeyglazyrindev/rope/issues License diff --git a/docs/contributing.rst b/docs/contributing.rst index c6cb8a8f2..970e40caa 100644 --- a/docs/contributing.rst +++ b/docs/contributing.rst @@ -79,7 +79,7 @@ Source Repository ================= Rope uses GitHub_. The repository exists at -`https://github.com/python-rope/rope`_. +`https://github.com/sergeyglazyrindev/rope`_. Submitting patches @@ -99,9 +99,9 @@ Sending Patches --------------- Follow the instructions on GitHub_ on how to setup Git and fork the -`python-rope/rope`_ repository. Once your changes are ready, send a +`sergeyglazyrindev/rope`_ repository. Once your changes are ready, send a `pull request`_ for review. .. _GitHub: http://github.com/ -.. _`python-rope/rope`: https://github.com/python-rope/rope +.. _`sergeyglazyrindev/rope`: https://github.com/sergeyglazyrindev/rope .. _`pull request`: https://help.github.com/articles/using-pull-requests From 4551d62eb360d9cf9489abf434247e70f0fddcf5 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 01:48:46 +0100 Subject: [PATCH 72/92] changed url to repo --- README.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.rst b/README.rst index 1c1625357..2604e710a 100644 --- a/README.rst +++ b/README.rst @@ -11,11 +11,11 @@ Overview ======== `Rope`_ is a python refactoring library. -`Rope Offical`_ originally it was written by @aligrudi and a long time was supported by @mcepl. +`RopeOffical`_ originally it was written by @aligrudi and a long time was supported by @mcepl. We hope to give this library fresh breath and new life. .. _`rope`: https://github.com/sergeyglazyrindev/rope -.. _`rope official`: https://github.com/python-rope/rope +.. _`ropeofficial`: https://github.com/python-rope/rope New Features From 689c001a5014b5b23dfc9aea621b17514471b4b4 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 01:55:33 +0100 Subject: [PATCH 73/92] fixed rst doc --- README.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.rst b/README.rst index 2604e710a..74b504448 100644 --- a/README.rst +++ b/README.rst @@ -11,11 +11,11 @@ Overview ======== `Rope`_ is a python refactoring library. -`RopeOffical`_ originally it was written by @aligrudi and a long time was supported by @mcepl. +`Official Rope`_ originally was written by @aligrudi and a long time was supported by @mcepl. We hope to give this library fresh breath and new life. .. _`rope`: https://github.com/sergeyglazyrindev/rope -.. _`ropeofficial`: https://github.com/python-rope/rope +.. _`Official Rope`: https://github.com/python-rope/rope New Features From c26b9ffba6a7216a403eda6903cdef667436199e Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 02:05:11 +0100 Subject: [PATCH 74/92] removed mailing lists - later we add another way how to discuss ideas --- CONTRIBUTORS | 2 -- docs/contributing.rst | 24 +++++------------------- docs/overview.rst | 3 +-- 3 files changed, 6 insertions(+), 23 deletions(-) diff --git a/CONTRIBUTORS b/CONTRIBUTORS index fe41ebc10..35b564fc2 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -2,8 +2,6 @@ Rope Contributors =================== -See Mercurial logs and the mailing list for details. - * Alexander Solovyov * Sebastjan Trepca * MATSUI Tetsushi diff --git a/docs/contributing.rst b/docs/contributing.rst index 970e40caa..6f1981e4f 100644 --- a/docs/contributing.rst +++ b/docs/contributing.rst @@ -14,22 +14,15 @@ welcome to! How to Help Rope? ================= -Rope's mailing list is `rope-dev (at) googlegroups.com`_. Click the -"Join group to post" button to subscribe. Then: +Look into `Issues`_ page and check if you can fix/help/suggest how to fix any issue/enhancement. -* Use rope -* Send bug reports and request features -* Submit patches for bugs or new features -* Discuss your ideas - -.. _`rope-dev (at) googlegroups.com`: http://groups.google.com/group/rope-dev +.. _`Issues`: https://github.com/sergeyglazyrindev/rope/issues Wish List ========= -You are welcome to send your patches to the `rope-dev (at) -googlegroups.com`_ mailing list. Here is a list of suggestions. +You are welcome to send your patches to this repository Issues page. Issues ------ @@ -38,16 +31,10 @@ The `dev/issues.rst`_ file is actually the main rope todo file. There is a section called "unresolved issues"; it contains almost every kind of task. Most of them need some thought or discussion. Pickup whichever you are most interested in. If you have ideas or questions -about them, don't hesitate to discuss it in the mailing list. +about them, please create corresponding issue and we can discuss enhancements, etc .. _`dev/issues.rst`: dev/issues.rst -Getting Ready For Python 3.0 ----------------------------- - -Checkout http://bitbucket.org/agr/rope_py3k Mercurial_ repository. -Contributions are welcome. - Write Plugins For Other IDEs ---------------------------- @@ -78,8 +65,7 @@ more information. Source Repository ================= -Rope uses GitHub_. The repository exists at -`https://github.com/sergeyglazyrindev/rope`_. +Rope uses GitHub_. The repository exists at https://github.com/sergeyglazyrindev/rope. Submitting patches diff --git a/docs/overview.rst b/docs/overview.rst index d290f5e6d..25e5c8b6c 100644 --- a/docs/overview.rst +++ b/docs/overview.rst @@ -737,8 +737,7 @@ examples. After this example you might like to have a look at: default wildcard supports. Finally, restructurings can be improved in many ways (for instance -adding new wildcards). You might like to discuss your ideas in the -mailing list. +adding new wildcards). Example 1 From 888e09996f3f56e07343d496609cc0cb9213a548 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sun, 14 Feb 2016 04:01:49 +0200 Subject: [PATCH 75/92] List supports slice now --- rope/base/builtins.py | 14 +++++++------- rope/base/evaluate.py | 6 +++++- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/rope/base/builtins.py b/rope/base/builtins.py index 63e19b15f..60ac1a2f0 100644 --- a/rope/base/builtins.py +++ b/rope/base/builtins.py @@ -272,10 +272,10 @@ def __init__(self, holding=None): argnames=['self', 'iterable']) # Getting methods - collector('__getitem__', function=self._self_get if pycompat.PY3 else self._list_get) + collector('__getitem__', function=self._list_get) collector('pop', function=self._list_get) try: - collector('__getslice__', function=self._self_get) + collector('__getslice__', function=self._list_get) except AttributeError: pass @@ -301,6 +301,10 @@ def _self_set(self, context): def _list_get(self, context): if self.holding is not None: + args = context.get_arguments(['self', 'key']) + if (len(args) > 1 and args[1] is not None and + args[1].get_type() == builtins['slice'].get_object()): + return get_list(self.holding) return self.holding return context.get_per_name() @@ -308,11 +312,7 @@ def _iterator_get(self, context): return get_iterator(self._list_get(context)) def _self_get(self, context): - # @todo - refactor, not sure how to implement it properly - if context.get_arguments_number() > 1: - return self._list_get(context) - else: - return get_list(self._list_get(context)) + return get_list(self._list_get(context)) get_list = _create_builtin_getter(List) diff --git a/rope/base/evaluate.py b/rope/base/evaluate.py index 1032d9d68..f43239237 100644 --- a/rope/base/evaluate.py +++ b/rope/base/evaluate.py @@ -291,7 +291,11 @@ def _Subscript(self, node): self._call_function(node.value, '__getitem__', [node.slice.value]) elif isinstance(node.slice, ast.Slice): - self._call_function(node.value, '__getitem__' if pycompat.PY3 else '__getslice__') + self._call_function(node.value, '__getitem__', + [node.slice]) + + def _Slice(self, node): + self.result = self._get_builtin_name('slice') def _call_function(self, node, function_name, other_args=None): pyname = eval_node(self.scope, node) From 1c37e327a0010795d774079053eb4e6b888d703f Mon Sep 17 00:00:00 2001 From: emacsway Date: Sun, 14 Feb 2016 04:12:30 +0200 Subject: [PATCH 76/92] TODO: add slice support in Tuple --- rope/base/builtins.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rope/base/builtins.py b/rope/base/builtins.py index 60ac1a2f0..1ab9b0481 100644 --- a/rope/base/builtins.py +++ b/rope/base/builtins.py @@ -422,7 +422,7 @@ def __init__(self, *objects): if objects: first = objects[0] attributes = { - '__getitem__': BuiltinName(BuiltinFunction(first)), + '__getitem__': BuiltinName(BuiltinFunction(first)), # TODO: add slice support '__getslice__': BuiltinName(BuiltinFunction(pyobjects.PyObject(self))), '__new__': BuiltinName(BuiltinFunction(function=self._new_tuple)), From 1898a6474b23785a766dfca573a951fc754d9b64 Mon Sep 17 00:00:00 2001 From: emacsway Date: Sun, 14 Feb 2016 04:46:01 +0200 Subject: [PATCH 77/92] Temporary revert "self.assertEquals() -> self.assertEqual()" for review This reverts commit 969da2d83d7eab45a6ceefcf79cf8fcfd1448352. --- ropetest/advanced_oi_test.py | 132 +++++----- ropetest/builtinstest.py | 104 ++++---- ropetest/codeanalyzetest.py | 190 +++++++-------- ropetest/contrib/autoimporttest.py | 50 ++-- ropetest/contrib/changestacktest.py | 8 +- ropetest/contrib/codeassisttest.py | 80 +++--- ropetest/contrib/finderrorstest.py | 16 +- ropetest/contrib/findittest.py | 38 +-- ropetest/contrib/fixmodnamestest.py | 4 +- ropetest/contrib/generatetest.py | 60 ++--- ropetest/historytest.py | 80 +++--- ropetest/objectdbtest.py | 38 +-- ropetest/objectinfertest.py | 68 +++--- ropetest/projecttest.py | 210 ++++++++-------- ropetest/pycoretest.py | 156 ++++++------ ropetest/pyscopestest.py | 48 ++-- ropetest/refactor/__init__.py | 128 +++++----- ropetest/refactor/change_signature_test.py | 82 +++---- ropetest/refactor/extracttest.py | 154 ++++++------ ropetest/refactor/importutilstest.py | 268 ++++++++++----------- ropetest/refactor/inlinetest.py | 150 ++++++------ ropetest/refactor/movetest.py | 106 ++++---- ropetest/refactor/multiprojecttest.py | 16 +- ropetest/refactor/renametest.py | 172 ++++++------- ropetest/refactor/restructuretest.py | 48 ++-- ropetest/refactor/similarfindertest.py | 82 +++---- ropetest/refactor/suitestest.py | 80 +++--- ropetest/refactor/usefunctiontest.py | 18 +- ropetest/runmodtest.py | 14 +- ropetest/simplifytest.py | 24 +- 30 files changed, 1312 insertions(+), 1312 deletions(-) diff --git a/ropetest/advanced_oi_test.py b/ropetest/advanced_oi_test.py index 838e6988c..9003eed84 100644 --- a/ropetest/advanced_oi_test.py +++ b/ropetest/advanced_oi_test.py @@ -27,7 +27,7 @@ def test_simple_dti(self): mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) - self.assertEqual(pymod['a_func'].get_object(), + self.assertEquals(pymod['a_func'].get_object(), pymod['a_var'].get_object()) def test_module_dti(self): @@ -38,7 +38,7 @@ def test_module_dti(self): mod2.write(code) self.pycore.run_module(mod2).wait_process() pymod2 = self.project.get_pymodule(mod2) - self.assertEqual(self.project.get_pymodule(mod1), + self.assertEquals(self.project.get_pymodule(mod1), pymod2['a_var'].get_object()) def test_class_from_another_module_dti(self): @@ -53,7 +53,7 @@ def test_class_from_another_module_dti(self): self.pycore.run_module(mod2).wait_process() #pymod1 = self.project.get_pymodule(mod1) pymod2 = self.project.get_pymodule(mod2) - self.assertEqual(pymod2['AClass'].get_object(), + self.assertEquals(pymod2['AClass'].get_object(), pymod2['a_var'].get_object()) def test_class_dti(self): @@ -64,7 +64,7 @@ def test_class_dti(self): mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) - self.assertEqual(pymod['AClass'].get_object(), + self.assertEquals(pymod['AClass'].get_object(), pymod['a_var'].get_object()) def test_instance_dti(self): @@ -75,7 +75,7 @@ def test_instance_dti(self): mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) - self.assertEqual(pymod['AClass'].get_object(), + self.assertEquals(pymod['AClass'].get_object(), pymod['a_var'].get_object().get_type()) def test_method_dti(self): @@ -87,7 +87,7 @@ def test_method_dti(self): mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) - self.assertEqual(pymod['AClass'].get_object(), + self.assertEquals(pymod['AClass'].get_object(), pymod['a_var'].get_object().get_type()) def test_function_argument_dti(self): @@ -97,7 +97,7 @@ def test_function_argument_dti(self): mod.write(code) self.pycore.run_module(mod).wait_process() pyscope = self.project.get_pymodule(mod).get_scope() - self.assertEqual(pyscope['a_func'].get_object(), + self.assertEquals(pyscope['a_func'].get_object(), pyscope.get_scopes()[0]['arg'].get_object()) def test_classes_with_the_same_name(self): @@ -109,7 +109,7 @@ def test_classes_with_the_same_name(self): mod.write(code) self.pycore.run_module(mod).wait_process() pymod = self.project.get_pymodule(mod) - self.assertEqual(pymod['AClass'].get_object(), + self.assertEquals(pymod['AClass'].get_object(), pymod['a_var'].get_object()) def test_nested_classes(self): @@ -121,7 +121,7 @@ def test_nested_classes(self): mod.write(code) self.pycore.run_module(mod).wait_process() pyscope = self.project.get_pymodule(mod).get_scope() - self.assertEqual(pyscope.get_scopes()[0]['AClass'].get_object(), + self.assertEquals(pyscope.get_scopes()[0]['AClass'].get_object(), pyscope['a_var'].get_object()) def test_function_argument_dti2(self): @@ -131,7 +131,7 @@ def test_function_argument_dti2(self): mod.write(code) self.pycore.run_module(mod).wait_process() pyscope = self.project.get_pymodule(mod).get_scope() - self.assertEqual(pyscope['a_func'].get_object(), + self.assertEquals(pyscope['a_func'].get_object(), pyscope.get_scopes()[0]['arg'].get_object()) def test_dti_and_concluded_data_invalidation(self): @@ -142,7 +142,7 @@ def test_dti_and_concluded_data_invalidation(self): pymod = self.project.get_pymodule(mod) pymod['a_var'].get_object() self.pycore.run_module(mod).wait_process() - self.assertEqual(pymod['a_func'].get_object(), + self.assertEquals(pymod['a_func'].get_object(), pymod['a_var'].get_object()) def test_list_objects_and_dynamicoi(self): @@ -155,7 +155,7 @@ def test_list_objects_and_dynamicoi(self): pymod = self.project.get_pymodule(mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_for_loops_and_dynamicoi(self): mod = testutils.create_module(self.project, 'mod') @@ -167,7 +167,7 @@ def test_for_loops_and_dynamicoi(self): pymod = self.project.get_pymodule(mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_dict_objects_and_dynamicoi(self): mod = testutils.create_module(self.project, 'mod') @@ -179,7 +179,7 @@ def test_dict_objects_and_dynamicoi(self): pymod = self.project.get_pymodule(mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_dict_keys_and_dynamicoi(self): mod = testutils.create_module(self.project, 'mod') @@ -196,7 +196,7 @@ def test_dict_keys_and_dynamicoi(self): pymod = self.project.get_pymodule(mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_dict_keys_and_dynamicoi2(self): mod = testutils.create_module(self.project, 'mod') @@ -210,8 +210,8 @@ def test_dict_keys_and_dynamicoi2(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_strs_and_dynamicoi(self): mod = testutils.create_module(self.project, 'mod') @@ -238,12 +238,12 @@ def complex_to_textual(pyobject): to_pyobject.transform(to_textual.transform(pyobject))) for name in ('C', 'f', 'a_var', 'a_list', 'a_str', 'a_file'): var = pymod[name].get_object() - self.assertEqual(to_textual.transform(var), + self.assertEquals(to_textual.transform(var), complex_to_textual(var)) - self.assertEqual(to_textual.transform(pymod), + self.assertEquals(to_textual.transform(pymod), complex_to_textual(pymod)) enumerate_func = rope.base.builtins.builtins['enumerate'].get_object() - self.assertEqual(to_textual.transform(enumerate_func), + self.assertEquals(to_textual.transform(enumerate_func), complex_to_textual(enumerate_func)) def test_arguments_with_keywords(self): @@ -258,8 +258,8 @@ def test_arguments_with_keywords(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_a_function_with_different_returns(self): mod = testutils.create_module(self.project, 'mod') @@ -273,8 +273,8 @@ def test_a_function_with_different_returns(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_a_function_with_different_returns2(self): mod = testutils.create_module(self.project, 'mod') @@ -289,8 +289,8 @@ def test_a_function_with_different_returns2(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_ignoring_star_args(self): mod = testutils.create_module(self.project, 'mod') @@ -306,8 +306,8 @@ def test_ignoring_star_args(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_ignoring_double_star_args(self): mod = testutils.create_module(self.project, 'mod') @@ -323,8 +323,8 @@ def test_ignoring_double_star_args(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_invalidating_data_after_changing(self): mod = testutils.create_module(self.project, 'mod') @@ -349,7 +349,7 @@ def test_invalidating_data_after_moving(self): mod.move('newmod.py') pymod = self.project.get_module('newmod') pymod2 = self.project.get_pymodule(mod2) - self.assertEqual(pymod2['C'].get_object(), + self.assertEquals(pymod2['C'].get_object(), pymod['a_var'].get_object()) @@ -373,7 +373,7 @@ def test_static_oi_for_simple_function_calls(self): c_class = pymod['C'].get_object() f_scope = pymod['f'].get_object().get_scope() p_type = f_scope['p'].get_object().get_type() - self.assertEqual(c_class, p_type) + self.assertEquals(c_class, p_type) def test_static_oi_not_failing_when_callin_callables(self): code = 'class C(object):\n pass\nC()\n' @@ -389,7 +389,7 @@ def test_static_oi_for_nested_calls(self): c_class = pymod['C'].get_object() f_scope = pymod['f'].get_object().get_scope() p_type = f_scope['p'].get_object().get_type() - self.assertEqual(c_class, p_type) + self.assertEquals(c_class, p_type) def test_static_oi_class_methods(self): code = 'class C(object):\n def f(self, p):\n pass\n' \ @@ -400,7 +400,7 @@ def test_static_oi_class_methods(self): c_class = pymod['C'].get_object() f_scope = c_class['f'].get_object().get_scope() p_type = f_scope['p'].get_object().get_type() - self.assertEqual(c_class, p_type) + self.assertEquals(c_class, p_type) def test_static_oi_preventing_soi_maximum_recursion_exceptions(self): code = 'item = {}\nfor item in item.keys():\n pass\n' @@ -417,7 +417,7 @@ def test_static_oi_for_infer_return_typs_from_funcs_based_on_params(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_a_function_with_different_returns(self): code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ @@ -429,8 +429,8 @@ def test_a_function_with_different_returns(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_not_reporting_out_of_date_information(self): code = 'class C1(object):\n pass\n' \ @@ -439,13 +439,13 @@ def test_not_reporting_out_of_date_information(self): pymod = self.project.get_pymodule(self.mod) c1_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c1_class, a_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) self.mod.write(code.replace('C1', 'C2')) pymod = self.project.get_pymodule(self.mod) c2_class = pymod['C2'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c2_class, a_var.get_type()) + self.assertEquals(c2_class, a_var.get_type()) def test_invalidating_concluded_data_in_a_function(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -458,13 +458,13 @@ def test_invalidating_concluded_data_in_a_function(self): pymod2 = self.project.get_pymodule(mod2) c1_class = pymod2['C1'].get_object() a_var = pymod2['a_var'].get_object() - self.assertEqual(c1_class, a_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) mod2.write(mod2.read()[:mod2.read().rfind('C1()')] + 'C2())\n') pymod2 = self.project.get_pymodule(mod2) c2_class = pymod2['C2'].get_object() a_var = pymod2['a_var'].get_object() - self.assertEqual(c2_class, a_var.get_type()) + self.assertEquals(c2_class, a_var.get_type()) def test_handling_generator_functions_for_strs(self): self.mod.write('class C(object):\n pass\ndef f(p):\n yield p()\n' @@ -472,7 +472,7 @@ def test_handling_generator_functions_for_strs(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) # TODO: Returning a generator for functions that yield unknowns @unittest.skip("Returning a generator that yields unknowns") @@ -493,7 +493,7 @@ def test_static_oi_for_lists_depending_on_append_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_get_item(self): code = 'class C(object):\n pass\nl = list()\n' \ @@ -503,7 +503,7 @@ def test_static_oi_for_lists_per_object_for_get_item(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_fields(self): code = 'class C(object):\n pass\n' \ @@ -516,7 +516,7 @@ def test_static_oi_for_lists_per_object_for_fields(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_set_item(self): code = 'class C(object):\n pass\nl = [None]\n' \ @@ -526,7 +526,7 @@ def test_static_oi_for_lists_per_object_for_set_item(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_extending_lists(self): code = 'class C(object):\n pass\nl = []\n' \ @@ -536,7 +536,7 @@ def test_static_oi_for_lists_per_object_for_extending_lists(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_static_oi_for_lists_per_object_for_iters(self): code = 'class C(object):\n pass\n' \ @@ -547,7 +547,7 @@ def test_static_oi_for_lists_per_object_for_iters(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_static_oi_for_dicts_depending_on_append_function(self): code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ @@ -559,8 +559,8 @@ def test_static_oi_for_dicts_depending_on_append_function(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_static_oi_for_dicts_depending_on_for_loops(self): code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ @@ -573,8 +573,8 @@ def test_static_oi_for_dicts_depending_on_for_loops(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_static_oi_for_dicts_depending_on_update(self): code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ @@ -587,8 +587,8 @@ def test_static_oi_for_dicts_depending_on_update(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_static_oi_for_dicts_depending_on_update_on_seqs(self): code = 'class C1(object):\n pass\nclass C2(object):\n pass\n' \ @@ -600,8 +600,8 @@ def test_static_oi_for_dicts_depending_on_update_on_seqs(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_static_oi_for_sets_per_object_for_set_item(self): code = 'class C(object):\n pass\ns = set()\n' \ @@ -611,7 +611,7 @@ def test_static_oi_for_sets_per_object_for_set_item(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_properties_and_calling_get_property(self): code = 'class C1(object):\n pass\n' \ @@ -622,7 +622,7 @@ def test_properties_and_calling_get_property(self): pymod = self.project.get_pymodule(self.mod) c1_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c1_class, a_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) def test_soi_on_constructors(self): code = 'class C1(object):\n pass\n' \ @@ -634,7 +634,7 @@ def test_soi_on_constructors(self): pymod = self.project.get_pymodule(self.mod) c1_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c1_class, a_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) def test_not_saving_unknown_function_returns(self): mod2 = testutils.create_module(self.project, 'mod2') @@ -650,7 +650,7 @@ def test_not_saving_unknown_function_returns(self): self.assertNotEquals(c_class, a_var.get_object().get_type()) self.pycore.analyze_module(self.mod) - self.assertEqual(c_class, a_var.get_object().get_type()) + self.assertEquals(c_class, a_var.get_object().get_type()) def test_using_the_best_callinfo(self): code = 'class C1(object):\n pass\n' \ @@ -662,7 +662,7 @@ def test_using_the_best_callinfo(self): c1_class = pymod['C1'].get_object() f_scope = pymod['f'].get_object().get_scope() arg2 = f_scope['arg2'].get_object() - self.assertEqual(c1_class, arg2.get_type()) + self.assertEquals(c1_class, arg2.get_type()) def test_call_function_and_parameters(self): code = 'class A(object):\n def __call__(self, p):\n pass\n' \ @@ -685,7 +685,7 @@ def test_report_change_in_libutils(self): c_class = pymod['C'].get_object() f_scope = pymod['f'].get_object().get_scope() p_type = f_scope['p'].get_object().get_type() - self.assertEqual(c_class, p_type) + self.assertEquals(c_class, p_type) def test_report_libutils_and_analyze_all_modules(self): code = 'class C(object):\n pass\ndef f(p):\n pass\nf(C())\n' @@ -695,7 +695,7 @@ def test_report_libutils_and_analyze_all_modules(self): c_class = pymod['C'].get_object() f_scope = pymod['f'].get_object().get_scope() p_type = f_scope['p'].get_object().get_type() - self.assertEqual(c_class, p_type) + self.assertEquals(c_class, p_type) def test_validation_problems_for_objectdb_retrievals(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -709,7 +709,7 @@ def test_validation_problems_for_objectdb_retrievals(self): c_class = pymod2['C'].get_object() pymod1 = self.project.get_pymodule(mod1) var_pyname = pymod1['var'] - self.assertEqual(c_class, var_pyname.get_object().get_type()) + self.assertEquals(c_class, var_pyname.get_object().get_type()) mod2.write('import mod1\n\nmod1.l.append("")\n') self.assertNotEquals(c_class, var_pyname.get_object().get_type(), 'Class `C` no more exists') @@ -732,7 +732,7 @@ def test_always_returning_containing_class_for_selfs(self): a_class = pymod['A'].get_object() f_scope = a_class.get_scope().get_scopes()[0] p_type = f_scope['p'].get_object().get_type() - self.assertEqual(a_class, p_type) + self.assertEquals(a_class, p_type) def test_following_function_calls_when_asked_to(self): code = 'class A(object):\n pass\n' \ @@ -746,7 +746,7 @@ def test_following_function_calls_when_asked_to(self): pymod = self.project.get_pymodule(self.mod) a_class = pymod['A'].get_object() x_var = pymod['x'].get_object().get_type() - self.assertEqual(a_class, x_var) + self.assertEquals(a_class, x_var) def suite(): diff --git a/ropetest/builtinstest.py b/ropetest/builtinstest.py index 5fe370916..df365449d 100644 --- a/ropetest/builtinstest.py +++ b/ropetest/builtinstest.py @@ -28,7 +28,7 @@ def test_holding_type_information(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_get_items(self): self.mod.write('class C(object):' @@ -37,14 +37,14 @@ def test_get_items(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_get_items_for_lists(self): self.mod.write('class C(object):\n pass\nl = [C()]\na_var = l[0]\n') pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_get_items_from_slices(self): self.mod.write('class C(object):\n pass' @@ -52,7 +52,7 @@ def test_get_items_from_slices(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_simple_for_loops(self): self.mod.write('class C(object):\n pass\nl = [C()]\n' @@ -60,14 +60,14 @@ def test_simple_for_loops(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_definition_location_for_loop_variables(self): self.mod.write('class C(object):\n pass\nl = [C()]\n' 'for c in l:\n pass\n') pymod = self.project.get_pymodule(self.mod) c_var = pymod['c'] - self.assertEqual((pymod, 4), c_var.get_definition_location()) + self.assertEquals((pymod, 4), c_var.get_definition_location()) def test_simple_case_for_dicts(self): self.mod.write('d = {}\n') @@ -80,7 +80,7 @@ def test_get_item_for_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_popping_dicts(self): self.mod.write('class C(object):\n pass\n' @@ -88,7 +88,7 @@ def test_popping_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_getting_keys_from_dicts(self): self.mod.write('class C1(object):\n pass\n' @@ -97,7 +97,7 @@ def test_getting_keys_from_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_getting_values_from_dicts(self): self.mod.write('class C1(object):\n pass\n' @@ -107,7 +107,7 @@ def test_getting_values_from_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C2'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_getting_iterkeys_from_dicts(self): self.mod.write('class C1(object):\n pass' @@ -116,7 +116,7 @@ def test_getting_iterkeys_from_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_getting_itervalues_from_dicts(self): self.mod.write('class C1(object):\n pass' @@ -126,7 +126,7 @@ def test_getting_itervalues_from_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C2'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_using_copy_for_dicts(self): self.mod.write('class C1(object):\n pass' @@ -135,7 +135,7 @@ def test_using_copy_for_dicts(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C1'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_tuple_assignments_for_items(self): self.mod.write('class C1(object):\n pass' @@ -146,8 +146,8 @@ def test_tuple_assignments_for_items(self): c2_class = pymod['C2'].get_object() key = pymod['key'].get_object() value = pymod['value'].get_object() - self.assertEqual(c1_class, key.get_type()) - self.assertEqual(c2_class, value.get_type()) + self.assertEquals(c1_class, key.get_type()) + self.assertEquals(c2_class, value.get_type()) def test_tuple_assignment_for_lists(self): self.mod.write('class C(object):\n pass\n' @@ -156,8 +156,8 @@ def test_tuple_assignment_for_lists(self): c_class = pymod['C'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c_class, a_var.get_type()) - self.assertEqual(c_class, b_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) + self.assertEquals(c_class, b_var.get_type()) def test_tuple_assignments_for_iteritems_in_fors(self): self.mod.write('class C1(object):\n pass\n' @@ -169,8 +169,8 @@ def test_tuple_assignments_for_iteritems_in_fors(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_simple_tuple_assignments(self): self.mod.write('class C1(object):' @@ -181,15 +181,15 @@ def test_simple_tuple_assignments(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_overriding_builtin_names(self): self.mod.write('class C(object):\n pass\nlist = C\n') pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() list_var = pymod['list'].get_object() - self.assertEqual(c_class, list_var) + self.assertEquals(c_class, list_var) def test_simple_builtin_scope_test(self): self.mod.write('l = list()\n') @@ -207,7 +207,7 @@ def test_making_lists_using_the_passed_argument_to_init(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_making_tuples_using_the_passed_argument_to_init(self): self.mod.write('class C(object):\n pass\nl1 = [C()]\n' @@ -215,7 +215,7 @@ def test_making_tuples_using_the_passed_argument_to_init(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_making_sets_using_the_passed_argument_to_init(self): self.mod.write('class C(object):\n pass\nl1 = [C()]\n' @@ -223,7 +223,7 @@ def test_making_sets_using_the_passed_argument_to_init(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_making_dicts_using_the_passed_argument_to_init(self): self.mod.write('class C1(object):\n pass\n' @@ -235,8 +235,8 @@ def test_making_dicts_using_the_passed_argument_to_init(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_range_builtin_function(self): self.mod.write('l = range(1)\n') @@ -250,7 +250,7 @@ def test_reversed_builtin_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_sorted_builtin_function(self): self.mod.write('class C(object):\n pass\nl = [C()]\n' @@ -258,7 +258,7 @@ def test_sorted_builtin_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_super_builtin_function(self): self.mod.write( @@ -270,7 +270,7 @@ def test_super_builtin_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_file_builtin_type(self): self.mod.write('for line in open("file.txt"):\n a_var = line\n') @@ -288,7 +288,7 @@ def test_lambda_functions(self): self.mod.write('l = lambda: 1\n') pymod = self.project.get_pymodule(self.mod) l_var = pymod['l'].get_object() - self.assertEqual(pyobjects.get_base_type('Function'), + self.assertEquals(pyobjects.get_base_type('Function'), l_var.get_type()) def test_lambda_function_definition(self): @@ -296,8 +296,8 @@ def test_lambda_function_definition(self): pymod = self.project.get_pymodule(self.mod) l_var = pymod['l'].get_object() self.assertTrue(l_var.get_name() is not None) - self.assertEqual(len(l_var.get_param_names()), 4) - self.assertEqual((pymod, 1), + self.assertEquals(len(l_var.get_param_names()), 4) + self.assertEquals((pymod, 1), pymod['l'].get_definition_location()) def test_lambdas_that_return_unknown(self): @@ -316,8 +316,8 @@ def test_builtin_zip_function(self): c2_class = pymod['C2'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_builtin_zip_function_with_more_than_two_args(self): self.mod.write( @@ -330,9 +330,9 @@ def test_builtin_zip_function_with_more_than_two_args(self): a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() c_var = pymod['c'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) - self.assertEqual(c1_class, c_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) + self.assertEquals(c1_class, c_var.get_type()) def test_wrong_arguments_to_zip_function(self): self.mod.write( @@ -342,7 +342,7 @@ def test_wrong_arguments_to_zip_function(self): c1_class = pymod['C1'].get_object() a_var = pymod['a'].get_object() b_var = pymod['b'].get_object() # noqa - self.assertEqual(c1_class, a_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) def test_enumerate_builtin_function(self): self.mod.write('class C(object):\n pass\nl = [C()]\n' @@ -350,12 +350,12 @@ def test_enumerate_builtin_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_builtin_class_get_name(self): - self.assertEqual('object', + self.assertEquals('object', builtins.builtins['object'].get_object().get_name()) - self.assertEqual( + self.assertEquals( 'property', builtins.builtins['property'].get_object().get_name()) def test_star_args_and_double_star_args(self): @@ -385,60 +385,60 @@ def test_iter_builtin_function(self): pymod = self.project.get_pymodule(self.mod) c_class = pymod['C'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_simple_int_type(self): self.mod.write('l = 1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual(builtins.builtins['int'].get_object(), + self.assertEquals(builtins.builtins['int'].get_object(), pymod['l'].get_object().get_type()) def test_simple_float_type(self): self.mod.write('l = 1.0\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual(builtins.builtins['float'].get_object(), + self.assertEquals(builtins.builtins['float'].get_object(), pymod['l'].get_object().get_type()) def test_simple_float_type2(self): self.mod.write('l = 1e1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual(builtins.builtins['float'].get_object(), + self.assertEquals(builtins.builtins['float'].get_object(), pymod['l'].get_object().get_type()) def test_simple_complex_type(self): self.mod.write('l = 1.0j\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual(builtins.builtins['complex'].get_object(), + self.assertEquals(builtins.builtins['complex'].get_object(), pymod['l'].get_object().get_type()) def test_handling_unaryop_on_ints(self): self.mod.write('l = -(1)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual(builtins.builtins['int'].get_object(), + self.assertEquals(builtins.builtins['int'].get_object(), pymod['l'].get_object().get_type()) def test_handling_binop_on_ints(self): self.mod.write('l = 1 + 1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual(builtins.builtins['int'].get_object(), + self.assertEquals(builtins.builtins['int'].get_object(), pymod['l'].get_object().get_type()) def test_handling_compares(self): self.mod.write('l = 1 == 1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual(builtins.builtins['bool'].get_object(), + self.assertEquals(builtins.builtins['bool'].get_object(), pymod['l'].get_object().get_type()) def test_handling_boolops(self): self.mod.write('l = 1 and 2\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual(builtins.builtins['int'].get_object(), + self.assertEquals(builtins.builtins['int'].get_object(), pymod['l'].get_object().get_type()) def test_binary_or_left_value_unknown(self): code = 'var = (asdsd or 3)\n' pymod = libutils.get_string_module(self.project, code) - self.assertEqual(builtins.builtins['int'].get_object(), + self.assertEquals(builtins.builtins['int'].get_object(), pymod['var'].get_object().get_type()) def test_unknown_return_object(self): diff --git a/ropetest/codeanalyzetest.py b/ropetest/codeanalyzetest.py index 3b38c3273..6b6ff0883 100644 --- a/ropetest/codeanalyzetest.py +++ b/ropetest/codeanalyzetest.py @@ -21,33 +21,33 @@ def tearDown(self): def test_source_lines_simple(self): to_lines = SourceLinesAdapter('line1\nline2\n') - self.assertEqual('line1', to_lines.get_line(1)) - self.assertEqual('line2', to_lines.get_line(2)) - self.assertEqual('', to_lines.get_line(3)) - self.assertEqual(3, to_lines.length()) + self.assertEquals('line1', to_lines.get_line(1)) + self.assertEquals('line2', to_lines.get_line(2)) + self.assertEquals('', to_lines.get_line(3)) + self.assertEquals(3, to_lines.length()) def test_source_lines_get_line_number(self): to_lines = SourceLinesAdapter('line1\nline2\n') - self.assertEqual(1, to_lines.get_line_number(0)) - self.assertEqual(1, to_lines.get_line_number(5)) - self.assertEqual(2, to_lines.get_line_number(7)) - self.assertEqual(3, to_lines.get_line_number(12)) + self.assertEquals(1, to_lines.get_line_number(0)) + self.assertEquals(1, to_lines.get_line_number(5)) + self.assertEquals(2, to_lines.get_line_number(7)) + self.assertEquals(3, to_lines.get_line_number(12)) def test_source_lines_get_line_start(self): to_lines = SourceLinesAdapter('line1\nline2\n') - self.assertEqual(0, to_lines.get_line_start(1)) - self.assertEqual(6, to_lines.get_line_start(2)) - self.assertEqual(12, to_lines.get_line_start(3)) + self.assertEquals(0, to_lines.get_line_start(1)) + self.assertEquals(6, to_lines.get_line_start(2)) + self.assertEquals(12, to_lines.get_line_start(3)) def test_source_lines_get_line_end(self): to_lines = SourceLinesAdapter('line1\nline2\n') - self.assertEqual(5, to_lines.get_line_end(1)) - self.assertEqual(11, to_lines.get_line_end(2)) - self.assertEqual(12, to_lines.get_line_end(3)) + self.assertEquals(5, to_lines.get_line_end(1)) + self.assertEquals(11, to_lines.get_line_end(2)) + self.assertEquals(12, to_lines.get_line_end(3)) def test_source_lines_last_line_with_no_new_line(self): to_lines = SourceLinesAdapter('line1') - self.assertEqual(1, to_lines.get_line_number(5)) + self.assertEquals(1, to_lines.get_line_number(5)) class WordRangeFinderTest(unittest.TestCase): @@ -65,151 +65,151 @@ def _find_primary(self, code, offset): def test_keyword_before_parens(self): code = 'if (a_var).an_attr:\n pass\n' - self.assertEqual('(a_var).an_attr', + self.assertEquals('(a_var).an_attr', self._find_primary(code, code.index(':'))) def test_inside_parans(self): code = 'a_func(a_var)' - self.assertEqual('a_var', self._find_primary(code, 10)) + self.assertEquals('a_var', self._find_primary(code, 10)) def test_simple_names(self): code = 'a_var = 10' - self.assertEqual('a_var', self._find_primary(code, 3)) + self.assertEquals('a_var', self._find_primary(code, 3)) def test_function_calls(self): code = 'sample_function()' - self.assertEqual('sample_function', self._find_primary(code, 10)) + self.assertEquals('sample_function', self._find_primary(code, 10)) def test_attribute_accesses(self): code = 'a_var.an_attr' - self.assertEqual('a_var.an_attr', self._find_primary(code, 10)) + self.assertEquals('a_var.an_attr', self._find_primary(code, 10)) def test_word_finder_on_word_beginning(self): code = 'print(a_var)\n' word_finder = worder.Worder(code) result = word_finder.get_word_at(code.index('a_var')) - self.assertEqual('a_var', result) + self.assertEquals('a_var', result) def test_word_finder_on_primary_beginning(self): code = 'print(a_var)\n' result = self._find_primary(code, code.index('a_var')) - self.assertEqual('a_var', result) + self.assertEquals('a_var', result) def test_word_finder_on_word_ending(self): code = 'print(a_var)\n' word_finder = worder.Worder(code) result = word_finder.get_word_at(code.index('a_var') + 5) - self.assertEqual('a_var', result) + self.assertEquals('a_var', result) def test_word_finder_on_primary_ending(self): code = 'print(a_var)\n' result = self._find_primary(code, code.index('a_var') + 5) - self.assertEqual('a_var', result) + self.assertEquals('a_var', result) def test_word_finder_on_primaries_with_dots_inside_parens(self): code = '(a_var.\nattr)' result = self._find_primary(code, code.index('attr') + 1) - self.assertEqual('a_var.\nattr', result) + self.assertEquals('a_var.\nattr', result) def test_strings(self): code = '"a string".split()' - self.assertEqual('"a string".split', self._find_primary(code, 14)) + self.assertEquals('"a string".split', self._find_primary(code, 14)) def test_function_calls2(self): code = 'file("afile.txt").read()' - self.assertEqual('file("afile.txt").read', + self.assertEquals('file("afile.txt").read', self._find_primary(code, 18)) def test_parens(self): code = '("afile.txt").split()' - self.assertEqual('("afile.txt").split', self._find_primary(code, 18)) + self.assertEquals('("afile.txt").split', self._find_primary(code, 18)) def test_function_with_no_param(self): code = 'AClass().a_func()' - self.assertEqual('AClass().a_func', self._find_primary(code, 12)) + self.assertEquals('AClass().a_func', self._find_primary(code, 12)) def test_function_with_multiple_param(self): code = 'AClass(a_param, another_param, "a string").a_func()' - self.assertEqual('AClass(a_param, another_param, "a string").a_func', + self.assertEquals('AClass(a_param, another_param, "a string").a_func', self._find_primary(code, 44)) def test_param_expressions(self): code = 'AClass(an_object.an_attr).a_func()' - self.assertEqual('an_object.an_attr', self._find_primary(code, 20)) + self.assertEquals('an_object.an_attr', self._find_primary(code, 20)) def test_string_parens(self): code = 'a_func("(").an_attr' - self.assertEqual('a_func("(").an_attr', self._find_primary(code, 16)) + self.assertEquals('a_func("(").an_attr', self._find_primary(code, 16)) def test_extra_spaces(self): code = 'a_func ( "(" ) . an_attr' - self.assertEqual('a_func ( "(" ) . an_attr', + self.assertEquals('a_func ( "(" ) . an_attr', self._find_primary(code, 26)) def test_functions_on_ending_parens(self): code = 'A()' - self.assertEqual('A()', self._find_primary(code, 2)) + self.assertEquals('A()', self._find_primary(code, 2)) def test_splitted_statement(self): word_finder = worder.Worder('an_object.an_attr') - self.assertEqual(('an_object', 'an_at', 10), + self.assertEquals(('an_object', 'an_at', 10), word_finder.get_splitted_primary_before(15)) def test_empty_splitted_statement(self): word_finder = worder.Worder('an_attr') - self.assertEqual(('', 'an_at', 0), + self.assertEquals(('', 'an_at', 0), word_finder.get_splitted_primary_before(5)) def test_empty_splitted_statement2(self): word_finder = worder.Worder('an_object.') - self.assertEqual(('an_object', '', 10), + self.assertEquals(('an_object', '', 10), word_finder.get_splitted_primary_before(10)) def test_empty_splitted_statement3(self): word_finder = worder.Worder('') - self.assertEqual(('', '', 0), + self.assertEquals(('', '', 0), word_finder.get_splitted_primary_before(0)) def test_empty_splitted_statement4(self): word_finder = worder.Worder('a_var = ') - self.assertEqual(('', '', 8), + self.assertEquals(('', '', 8), word_finder.get_splitted_primary_before(8)) def test_empty_splitted_statement5(self): word_finder = worder.Worder('a.') - self.assertEqual(('a', '', 2), + self.assertEquals(('a', '', 2), word_finder.get_splitted_primary_before(2)) def test_operators_inside_parens(self): code = '(a_var + another_var).reverse()' - self.assertEqual('(a_var + another_var).reverse', + self.assertEquals('(a_var + another_var).reverse', self._find_primary(code, 25)) def test_dictionaries(self): code = 'print({1: "one", 2: "two"}.keys())' - self.assertEqual('{1: "one", 2: "two"}.keys', + self.assertEquals('{1: "one", 2: "two"}.keys', self._find_primary(code, 29)) def test_following_parens(self): code = 'a_var = a_func()()' result = self._find_primary(code, code.index(')(') + 3) - self.assertEqual('a_func()()', result) + self.assertEquals('a_func()()', result) def test_comments_for_finding_statements(self): code = '# var2 . \n var3' - self.assertEqual('var3', self._find_primary(code, code.index('3'))) + self.assertEquals('var3', self._find_primary(code, code.index('3'))) def test_str_in_comments_for_finding_statements(self): code = '# "var2" . \n var3' - self.assertEqual('var3', self._find_primary(code, code.index('3'))) + self.assertEquals('var3', self._find_primary(code, code.index('3'))) def test_comments_for_finding_statements2(self): code = 'var1 + "# var2".\n var3' - self.assertEqual('var3', self._find_primary(code, 21)) + self.assertEquals('var3', self._find_primary(code, 21)) def test_comments_for_finding_statements3(self): code = '"" + # var2.\n var3' - self.assertEqual('var3', self._find_primary(code, 21)) + self.assertEquals('var3', self._find_primary(code, 21)) def test_import_statement_finding(self): code = 'import mod\na_var = 10\n' @@ -227,12 +227,12 @@ def test_word_parens_range(self): code = 's = str()\ns.title()\n' word_finder = worder.Worder(code) result = word_finder.get_word_parens_range(code.rindex('()') - 1) - self.assertEqual((len(code) - 3, len(code) - 1), result) + self.assertEquals((len(code) - 3, len(code) - 1), result) def test_getting_primary_before_get_index(self): code = '\na = (b + c).d[0]()\n' result = self._find_primary(code, len(code) - 2) - self.assertEqual('(b + c).d[0]()', result) + self.assertEquals('(b + c).d[0]()', result) def test_getting_primary_and_strings_at_the_end_of_line(self): code = 'f(\'\\\'\')\n' @@ -241,13 +241,13 @@ def test_getting_primary_and_strings_at_the_end_of_line(self): def test_getting_primary_and_not_crossing_newlines(self): code = '\na = (b + c)\n(4 + 1).x\n' result = self._find_primary(code, len(code) - 1) - self.assertEqual('(4 + 1).x', result) + self.assertEquals('(4 + 1).x', result) # XXX: cancatenated string literals def xxx_test_getting_primary_cancatenating_strs(self): code = 's = "a"\n"b" "c"\n' result = self._find_primary(code, len(code) - 2) - self.assertEqual('"b" "c"', result) + self.assertEquals('"b" "c"', result) def test_is_a_function_being_called_with_parens_on_next_line(self): code = 'func\n(1, 2)\n' @@ -258,18 +258,18 @@ def test_is_a_function_being_called_with_parens_on_next_line(self): def xxx_test_triple_quotes(self): code = 's = """string"""\n' result = self._find_primary(code, len(code) - 1) - self.assertEqual('"""string"""', result) + self.assertEquals('"""string"""', result) def test_triple_quotes_spanning_multiple_lines(self): code = 's = """\\\nl1\nl2\n """\n' result = self._find_primary(code, len(code) - 2) - self.assertEqual('"""\\\nl1\nl2\n """', result) + self.assertEquals('"""\\\nl1\nl2\n """', result) def test_get_word_parens_range_and_string_literals(self): code = 'f(1, ")", 2)\n' word_finder = worder.Worder(code) result = word_finder.get_word_parens_range(0) - self.assertEqual((1, len(code) - 1), result) + self.assertEquals((1, len(code) - 1), result) def test_is_assigned_here_for_equality_test(self): code = 'a == 1\n' @@ -306,35 +306,35 @@ def test_one_letter_function_keyword_arguments(self): def test_find_parens_start(self): code = 'f(p)\n' finder = worder.Worder(code) - self.assertEqual(1, finder.find_parens_start_from_inside(2)) + self.assertEquals(1, finder.find_parens_start_from_inside(2)) def test_underlined_find_parens_start(self): code = 'f(p="")\n' finder = worder.Worder(code) - self.assertEqual(1, finder._find_parens_start(len(code) - 2)) + self.assertEquals(1, finder._find_parens_start(len(code) - 2)) def test_find_parens_start_with_multiple_entries(self): code = 'myfunc(p1, p2, p3\n' finder = worder.Worder(code) - self.assertEqual(code.index('('), + self.assertEquals(code.index('('), finder.find_parens_start_from_inside(len(code) - 1)) def test_find_parens_start_with_nested_parens(self): code = 'myfunc(p1, (p2, p3), p4\n' finder = worder.Worder(code) - self.assertEqual(code.index('('), + self.assertEquals(code.index('('), finder.find_parens_start_from_inside(len(code) - 1)) def test_find_parens_start_with_parens_in_strs(self): code = 'myfunc(p1, "(", p4\n' finder = worder.Worder(code) - self.assertEqual(code.index('('), + self.assertEquals(code.index('('), finder.find_parens_start_from_inside(len(code) - 1)) def test_find_parens_start_with_parens_in_strs_in_multiple_lines(self): code = 'myfunc (\np1\n , \n "(" \n, \np4\n' finder = worder.Worder(code) - self.assertEqual(code.index('('), + self.assertEquals(code.index('('), finder.find_parens_start_from_inside(len(code) - 1)) def test_is_on_function_keyword(self): @@ -360,7 +360,7 @@ def xxx_test_global_name_in_class_body(self): scope = libutils.get_string_scope(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) result = name_finder.get_pyname_at(len(code) - 3) - self.assertEqual(scope['a_var'], result) + self.assertEquals(scope['a_var'], result) def test_class_variable_attribute_in_class_body(self): code = 'a_var = 10\nclass C(object):\n a_var = a_var\n' @@ -368,7 +368,7 @@ def test_class_variable_attribute_in_class_body(self): name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_var_pyname = scope['C'].get_object()['a_var'] result = name_finder.get_pyname_at(len(code) - 12) - self.assertEqual(a_var_pyname, result) + self.assertEquals(a_var_pyname, result) def test_class_variable_attribute_in_class_body2(self): code = 'a_var = 10\nclass C(object):\n a_var \\\n= a_var\n' @@ -376,7 +376,7 @@ def test_class_variable_attribute_in_class_body2(self): name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_var_pyname = scope['C'].get_object()['a_var'] result = name_finder.get_pyname_at(len(code) - 12) - self.assertEqual(a_var_pyname, result) + self.assertEquals(a_var_pyname, result) def test_class_method_attribute_in_class_body(self): code = 'class C(object):\n def a_method(self):\n pass\n' @@ -384,7 +384,7 @@ def test_class_method_attribute_in_class_body(self): name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_method_pyname = scope['C'].get_object()['a_method'] result = name_finder.get_pyname_at(code.index('a_method') + 2) - self.assertEqual(a_method_pyname, result) + self.assertEquals(a_method_pyname, result) def test_inner_class_attribute_in_class_body(self): code = 'class C(object):\n class CC(object):\n pass\n' @@ -392,7 +392,7 @@ def test_inner_class_attribute_in_class_body(self): name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) a_class_pyname = scope['C'].get_object()['CC'] result = name_finder.get_pyname_at(code.index('CC') + 2) - self.assertEqual(a_class_pyname, result) + self.assertEquals(a_class_pyname, result) def test_class_method_in_class_body_but_not_indexed(self): code = 'class C(object):\n def func(self, func):\n pass\n' @@ -400,7 +400,7 @@ def test_class_method_in_class_body_but_not_indexed(self): a_func_pyname = scope.get_scopes()[0].get_scopes()[0]['func'] name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) result = name_finder.get_pyname_at(code.index(', func') + 3) - self.assertEqual(a_func_pyname, result) + self.assertEquals(a_func_pyname, result) def test_function_but_not_indexed(self): code = 'def a_func(a_func):\n pass\n' @@ -408,7 +408,7 @@ def test_function_but_not_indexed(self): a_func_pyname = scope['a_func'] name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) result = name_finder.get_pyname_at(code.index('a_func') + 3) - self.assertEqual(a_func_pyname, result) + self.assertEquals(a_func_pyname, result) def test_modules_after_from_statements(self): root_folder = self.project.root @@ -419,7 +419,7 @@ def test_modules_after_from_statements(self): name_finder = rope.base.evaluate.ScopeNameFinder(scope.pyobject) mod_pyobject = self.project.get_pymodule(mod) found_pyname = name_finder.get_pyname_at(code.index('mod') + 1) - self.assertEqual(mod_pyobject, found_pyname.get_object()) + self.assertEquals(mod_pyobject, found_pyname.get_object()) def test_renaming_functions_with_from_import_and_parens(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -430,7 +430,7 @@ def test_renaming_functions_with_from_import_and_parens(self): mod_pyobject = self.project.get_pymodule(mod1) afunc = mod_pyobject['afunc'] found_pyname = name_finder.get_pyname_at(code.index('afunc') + 1) - self.assertEqual(afunc.get_object(), found_pyname.get_object()) + self.assertEquals(afunc.get_object(), found_pyname.get_object()) @testutils.only_for('2.5') def test_relative_modules_after_from_statements(self): @@ -445,7 +445,7 @@ def test_relative_modules_after_from_statements(self): name_finder = rope.base.evaluate.ScopeNameFinder(mod2_scope.pyobject) mod1_pyobject = self.project.get_pymodule(mod1) found_pyname = name_finder.get_pyname_at(code.index('mod1') + 1) - self.assertEqual(mod1_pyobject, found_pyname.get_object()) + self.assertEquals(mod1_pyobject, found_pyname.get_object()) def test_relative_modules_after_from_statements2(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -458,7 +458,7 @@ def test_relative_modules_after_from_statements2(self): name_finder = rope.base.evaluate.ScopeNameFinder(mod1_scope.pyobject) pkg2_pyobject = self.project.get_pymodule(pkg2) found_pyname = name_finder.get_pyname_at(mod1.read().index('pkg2') + 1) - self.assertEqual(pkg2_pyobject, found_pyname.get_object()) + self.assertEquals(pkg2_pyobject, found_pyname.get_object()) def test_get_pyname_at_on_language_keywords(self): code = 'def a_func(a_func):\n pass\n' @@ -472,21 +472,21 @@ def test_one_liners(self): pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) - self.assertEqual(pymod['var'], pyname) + self.assertEquals(pymod['var'], pyname) def test_one_liners_with_line_breaks(self): code = 'var = 1\ndef f(\n): var = 2\nprint(var)\n' pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) - self.assertEqual(pymod['var'], pyname) + self.assertEquals(pymod['var'], pyname) def test_one_liners_with_line_breaks2(self): code = 'var = 1\ndef f(\np): var = 2\nprint(var)\n' pymod = libutils.get_string_module(self.project, code) name_finder = rope.base.evaluate.ScopeNameFinder(pymod) pyname = name_finder.get_pyname_at(code.rindex('var')) - self.assertEqual(pymod['var'], pyname) + self.assertEquals(pymod['var'], pyname) class LogicalLineFinderTest(unittest.TestCase): @@ -503,106 +503,106 @@ def _logical_finder(self, code): def test_normal_lines(self): code = 'a_var = 10' line_finder = self._logical_finder(code) - self.assertEqual((1, 1), line_finder.logical_line_in(1)) + self.assertEquals((1, 1), line_finder.logical_line_in(1)) def test_normal_lines2(self): code = 'another = 10\na_var = 20\n' line_finder = self._logical_finder(code) - self.assertEqual((1, 1), line_finder.logical_line_in(1)) - self.assertEqual((2, 2), line_finder.logical_line_in(2)) + self.assertEquals((1, 1), line_finder.logical_line_in(1)) + self.assertEquals((2, 2), line_finder.logical_line_in(2)) def test_implicit_continuation(self): code = 'a_var = 3 + \\\n 4 + \\\n 5' line_finder = self._logical_finder(code) - self.assertEqual((1, 3), line_finder.logical_line_in(2)) + self.assertEquals((1, 3), line_finder.logical_line_in(2)) def test_explicit_continuation(self): code = 'print(2)\na_var = (3 + \n 4, \n 5)\n' line_finder = self._logical_finder(code) - self.assertEqual((2, 4), line_finder.logical_line_in(2)) + self.assertEquals((2, 4), line_finder.logical_line_in(2)) def test_explicit_continuation_comments(self): code = '#\na_var = 3\n' line_finder = self._logical_finder(code) - self.assertEqual((2, 2), line_finder.logical_line_in(2)) + self.assertEquals((2, 2), line_finder.logical_line_in(2)) def test_multiple_indented_ifs(self): code = 'if True:\n if True:\n ' \ 'if True:\n pass\n a = 10\n' line_finder = self._logical_finder(code) - self.assertEqual((5, 5), line_finder.logical_line_in(5)) + self.assertEquals((5, 5), line_finder.logical_line_in(5)) def test_list_comprehensions_and_fors(self): code = 'a_list = [i\n for i in range(10)]\n' line_finder = self._logical_finder(code) - self.assertEqual((1, 2), line_finder.logical_line_in(2)) + self.assertEquals((1, 2), line_finder.logical_line_in(2)) def test_generator_expressions_and_fors(self): code = 'a_list = (i\n for i in range(10))\n' line_finder = self._logical_finder(code) - self.assertEqual((1, 2), line_finder.logical_line_in(2)) + self.assertEquals((1, 2), line_finder.logical_line_in(2)) def test_fors_and_block_start(self): code = 'l = range(10)\nfor i in l:\n print(i)\n' - self.assertEqual(2, get_block_start(SourceLinesAdapter(code), 2)) + self.assertEquals(2, get_block_start(SourceLinesAdapter(code), 2)) def test_problems_with_inner_indentations(self): code = 'if True:\n if True:\n if True:\n pass\n' \ ' a = \\\n 1\n' line_finder = self._logical_finder(code) - self.assertEqual((5, 6), line_finder.logical_line_in(6)) + self.assertEquals((5, 6), line_finder.logical_line_in(6)) def test_problems_with_inner_indentations2(self): code = 'if True:\n if True:\n pass\n' \ 'a = 1\n' line_finder = self._logical_finder(code) - self.assertEqual((4, 4), line_finder.logical_line_in(4)) + self.assertEquals((4, 4), line_finder.logical_line_in(4)) def test_logical_lines_for_else(self): code = 'if True:\n pass\nelse:\n pass\n' line_finder = self._logical_finder(code) - self.assertEqual((3, 3), line_finder.logical_line_in(3)) + self.assertEquals((3, 3), line_finder.logical_line_in(3)) def test_logical_lines_for_lines_with_wrong_continues(self): code = 'var = 1 + \\' line_finder = self._logical_finder(code) - self.assertEqual((1, 1), line_finder.logical_line_in(1)) + self.assertEquals((1, 1), line_finder.logical_line_in(1)) def test_logical_lines_for_multiline_string_with_extra_quotes_front(self): code = '""""Docs."""\na = 1\n' line_finder = self._logical_finder(code) - self.assertEqual((2, 2), line_finder.logical_line_in(2)) + self.assertEquals((2, 2), line_finder.logical_line_in(2)) def test_logical_lines_for_multiline_string_with_escaped_quotes(self): code = '"""Quotes \\""" "\\"" \' """\na = 1\n' line_finder = self._logical_finder(code) - self.assertEqual((2, 2), line_finder.logical_line_in(2)) + self.assertEquals((2, 2), line_finder.logical_line_in(2)) def test_generating_line_starts(self): code = 'a = 1\na = 2\n\na = 3\n' line_finder = self._logical_finder(code) - self.assertEqual([1, 2, 4], list(line_finder.generate_starts())) + self.assertEquals([1, 2, 4], list(line_finder.generate_starts())) def test_generating_line_starts2(self): code = 'a = 1\na = 2\n\na = \\ 3\n' line_finder = LogicalLineFinder(SourceLinesAdapter(code)) - self.assertEqual([2, 4], list(line_finder.generate_starts(2))) + self.assertEquals([2, 4], list(line_finder.generate_starts(2))) def test_generating_line_starts3(self): code = 'a = 1\na = 2\n\na = \\ 3\n' line_finder = LogicalLineFinder(SourceLinesAdapter(code)) - self.assertEqual([2], list(line_finder.generate_starts(2, 3))) + self.assertEquals([2], list(line_finder.generate_starts(2, 3))) def test_generating_line_starts_for_multi_line_statements(self): code = '\na = \\\n 1 + \\\n 1\n' line_finder = self._logical_finder(code) - self.assertEqual([2], list(line_finder.generate_starts())) + self.assertEquals([2], list(line_finder.generate_starts())) def test_generating_line_starts_and_unmatched_deindents(self): code = 'if True:\n if True:\n if True:\n' \ ' a = 1\n b = 1\n' line_finder = self._logical_finder(code) - self.assertEqual([4, 5], list(line_finder.generate_starts(4))) + self.assertEquals([4, 5], list(line_finder.generate_starts(4))) class TokenizerLogicalLineFinderTest(LogicalLineFinderTest): diff --git a/ropetest/contrib/autoimporttest.py b/ropetest/contrib/autoimporttest.py index 7c6ef303d..f26de801d 100644 --- a/ropetest/contrib/autoimporttest.py +++ b/ropetest/contrib/autoimporttest.py @@ -19,94 +19,94 @@ def tearDown(self): super(AutoImportTest, self).tearDown() def test_simple_case(self): - self.assertEqual([], self.importer.import_assist('A')) + self.assertEquals([], self.importer.import_assist('A')) def test_update_resource(self): self.mod1.write('myvar = None\n') self.importer.update_resource(self.mod1) - self.assertEqual([('myvar', 'mod1')], + self.assertEquals([('myvar', 'mod1')], self.importer.import_assist('myva')) def test_update_module(self): self.mod1.write('myvar = None') self.importer.update_module('mod1') - self.assertEqual([('myvar', 'mod1')], + self.assertEquals([('myvar', 'mod1')], self.importer.import_assist('myva')) def test_update_non_existent_module(self): self.importer.update_module('does_not_exists_this') - self.assertEqual([], self.importer.import_assist('myva')) + self.assertEquals([], self.importer.import_assist('myva')) def test_module_with_syntax_errors(self): self.mod1.write('this is a syntax error\n') self.importer.update_resource(self.mod1) - self.assertEqual([], self.importer.import_assist('myva')) + self.assertEquals([], self.importer.import_assist('myva')) def test_excluding_imported_names(self): self.mod1.write('import pkg\n') self.importer.update_resource(self.mod1) - self.assertEqual([], self.importer.import_assist('pkg')) + self.assertEquals([], self.importer.import_assist('pkg')) def test_get_modules(self): self.mod1.write('myvar = None\n') self.importer.update_resource(self.mod1) - self.assertEqual(['mod1'], self.importer.get_modules('myvar')) + self.assertEquals(['mod1'], self.importer.get_modules('myvar')) def test_get_modules_inside_packages(self): self.mod1.write('myvar = None\n') self.mod2.write('myvar = None\n') self.importer.update_resource(self.mod1) self.importer.update_resource(self.mod2) - self.assertEqual(set(['mod1', 'pkg.mod2']), + self.assertEquals(set(['mod1', 'pkg.mod2']), set(self.importer.get_modules('myvar'))) def test_trivial_insertion_line(self): result = self.importer.find_insertion_line('') - self.assertEqual(1, result) + self.assertEquals(1, result) def test_insertion_line(self): result = self.importer.find_insertion_line('import mod\n') - self.assertEqual(2, result) + self.assertEquals(2, result) def test_insertion_line_with_pydocs(self): result = self.importer.find_insertion_line( '"""docs\n\ndocs"""\nimport mod\n') - self.assertEqual(5, result) + self.assertEquals(5, result) def test_insertion_line_with_multiple_imports(self): result = self.importer.find_insertion_line( 'import mod1\n\nimport mod2\n') - self.assertEqual(4, result) + self.assertEquals(4, result) def test_insertion_line_with_blank_lines(self): result = self.importer.find_insertion_line( 'import mod1\n\n# comment\n') - self.assertEqual(2, result) + self.assertEquals(2, result) def test_empty_cache(self): self.mod1.write('myvar = None\n') self.importer.update_resource(self.mod1) - self.assertEqual(['mod1'], self.importer.get_modules('myvar')) + self.assertEquals(['mod1'], self.importer.get_modules('myvar')) self.importer.clear_cache() - self.assertEqual([], self.importer.get_modules('myvar')) + self.assertEquals([], self.importer.get_modules('myvar')) def test_not_caching_underlined_names(self): self.mod1.write('_myvar = None\n') self.importer.update_resource(self.mod1, underlined=False) - self.assertEqual([], self.importer.get_modules('_myvar')) + self.assertEquals([], self.importer.get_modules('_myvar')) self.importer.update_resource(self.mod1, underlined=True) - self.assertEqual(['mod1'], self.importer.get_modules('_myvar')) + self.assertEquals(['mod1'], self.importer.get_modules('_myvar')) def test_caching_underlined_names_passing_to_the_constructor(self): importer = autoimport.AutoImport(self.project, False, True) self.mod1.write('_myvar = None\n') importer.update_resource(self.mod1) - self.assertEqual(['mod1'], importer.get_modules('_myvar')) + self.assertEquals(['mod1'], importer.get_modules('_myvar')) def test_name_locations(self): self.mod1.write('myvar = None\n') self.importer.update_resource(self.mod1) - self.assertEqual([(self.mod1, 1)], + self.assertEquals([(self.mod1, 1)], self.importer.get_name_locations('myvar')) def test_name_locations_with_multiple_occurrences(self): @@ -114,7 +114,7 @@ def test_name_locations_with_multiple_occurrences(self): self.mod2.write('\nmyvar = None\n') self.importer.update_resource(self.mod1) self.importer.update_resource(self.mod2) - self.assertEqual(set([(self.mod1, 1), (self.mod2, 2)]), + self.assertEquals(set([(self.mod1, 1), (self.mod2, 2)]), set(self.importer.get_name_locations('myvar'))) def test_handling_builtin_modules(self): @@ -122,9 +122,9 @@ def test_handling_builtin_modules(self): self.assertTrue('sys' in self.importer.get_modules('exit')) def test_submodules(self): - self.assertEqual(set([self.mod1]), + self.assertEquals(set([self.mod1]), autoimport.submodules(self.mod1)) - self.assertEqual(set([self.mod2, self.pkg]), + self.assertEquals(set([self.mod2, self.pkg]), autoimport.submodules(self.pkg)) @@ -144,17 +144,17 @@ def tearDown(self): def test_writing_files(self): self.mod1.write('myvar = None\n') - self.assertEqual(['mod1'], self.importer.get_modules('myvar')) + self.assertEquals(['mod1'], self.importer.get_modules('myvar')) def test_moving_files(self): self.mod1.write('myvar = None\n') self.mod1.move('mod3.py') - self.assertEqual(['mod3'], self.importer.get_modules('myvar')) + self.assertEquals(['mod3'], self.importer.get_modules('myvar')) def test_removing_files(self): self.mod1.write('myvar = None\n') self.mod1.remove() - self.assertEqual([], self.importer.get_modules('myvar')) + self.assertEquals([], self.importer.get_modules('myvar')) def suite(): diff --git a/ropetest/contrib/changestacktest.py b/ropetest/contrib/changestacktest.py index 487b77488..ba16c4704 100644 --- a/ropetest/contrib/changestacktest.py +++ b/ropetest/contrib/changestacktest.py @@ -21,14 +21,14 @@ def test_change_stack(self): myfile.write('1') stack = rope.contrib.changestack.ChangeStack(self.project) stack.push(rope.base.change.ChangeContents(myfile, '2')) - self.assertEqual('2', myfile.read()) + self.assertEquals('2', myfile.read()) stack.push(rope.base.change.ChangeContents(myfile, '3')) - self.assertEqual('3', myfile.read()) + self.assertEquals('3', myfile.read()) stack.pop_all() - self.assertEqual('1', myfile.read()) + self.assertEquals('1', myfile.read()) changes = stack.merged() self.project.do(changes) - self.assertEqual('3', myfile.read()) + self.assertEquals('3', myfile.read()) if __name__ == '__main__': diff --git a/ropetest/contrib/codeassisttest.py b/ropetest/contrib/codeassisttest.py index c2b1e5338..99af16841 100644 --- a/ropetest/contrib/codeassisttest.py +++ b/ropetest/contrib/codeassisttest.py @@ -91,7 +91,7 @@ def test_proposing_each_name_at_most_once(self): result = self._assist(code) count = len([x for x in result if x.name == 'variable' and x.scope == 'global']) - self.assertEqual(1, count) + self.assertEquals(1, count) def test_throwing_exception_in_case_of_syntax_errors(self): code = 'sample (sdf+)\n' @@ -115,7 +115,7 @@ def test_not_reporting_variables_in_current_line(self): def test_completion_result(self): code = 'my_global = 10\nt = my' - self.assertEqual(len(code) - 2, starting_offset(code, len(code))) + self.assertEquals(len(code) - 2, starting_offset(code, len(code))) def test_completing_imported_names(self): code = 'import sys\na = sy' @@ -345,12 +345,12 @@ def test_code_assist_with_function_with_two_line_return(self): def test_get_definition_location(self): code = 'def a_func():\n pass\na_func()' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEqual((None, 1), result) + self.assertEquals((None, 1), result) def test_get_definition_location_underlined_names(self): code = 'def a_sample_func():\n pass\na_sample_func()' result = get_definition_location(self.project, code, len(code) - 11) - self.assertEqual((None, 1), result) + self.assertEquals((None, 1), result) def test_get_definition_location_dotted_names(self): code = 'class AClass(object):\n' \ @@ -359,14 +359,14 @@ def test_get_definition_location_dotted_names(self): ' pass\n' \ 'AClass.a_method()' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEqual((None, 2), result) + self.assertEquals((None, 2), result) def test_get_definition_location_dotted_module_names(self): module_resource = testutils.create_module(self.project, 'mod') module_resource.write('def a_func():\n pass\n') code = 'import mod\nmod.a_func()' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEqual((module_resource, 1), result) + self.assertEquals((module_resource, 1), result) def test_get_definition_location_for_nested_packages(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -377,33 +377,33 @@ def test_get_definition_location_for_nested_packages(self): init_dot_py = pkg2.get_child('__init__.py') found_pyname = get_definition_location(self.project, mod1.read(), mod1.read().index('pkg2') + 1) - self.assertEqual(init_dot_py, found_pyname[0]) + self.assertEquals(init_dot_py, found_pyname[0]) def test_get_definition_location_unknown(self): code = 'a_func()\n' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEqual((None, None), result) + self.assertEquals((None, None), result) def test_get_definition_location_dot_spaces(self): code = 'class AClass(object):\n ' \ '@staticmethod\n def a_method():\n' \ ' pass\nAClass.\\\n a_method()' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEqual((None, 2), result) + self.assertEquals((None, 2), result) def test_get_definition_location_dot_line_break_inside_parens(self): code = 'class A(object):\n def a_method(self):\n pass\n' + \ '(A.\na_method)' result = get_definition_location(self.project, code, code.rindex('a_method') + 1) - self.assertEqual((None, 2), result) + self.assertEquals((None, 2), result) def test_if_scopes_in_other_scopes_for_get_definition_location(self): code = 'def f(a_var):\n pass\na_var = 10\n' + \ 'if True:\n' + \ ' print(a_var)\n' result = get_definition_location(self.project, code, len(code) - 3) - self.assertEqual((None, 3), result) + self.assertEquals((None, 3), result) def test_code_assists_in_parens(self): code = 'def a_func(a_var):\n pass\na_var = 10\na_func(a_' @@ -425,8 +425,8 @@ def test_proposals_sorter(self): ' my_sample_var = 20\n' + \ ' my_sample_' proposals = sorted_proposals(self._assist(code)) - self.assertEqual('my_sample_var', proposals[0].name) - self.assertEqual('my_sample_function', proposals[1].name) + self.assertEquals('my_sample_var', proposals[0].name) + self.assertEquals('my_sample_function', proposals[1].name) def test_proposals_sorter_for_methods_and_attributes(self): code = 'class A(object):\n' + \ @@ -439,9 +439,9 @@ def test_proposals_sorter_for_methods_and_attributes(self): 'a_var = A()\n' + \ 'a_var.my_' proposals = sorted_proposals(self._assist(code)) - self.assertEqual('my_b_func', proposals[0].name) - self.assertEqual('my_c_func', proposals[1].name) - self.assertEqual('my_a_var', proposals[2].name) + self.assertEquals('my_b_func', proposals[0].name) + self.assertEquals('my_c_func', proposals[1].name) + self.assertEquals('my_a_var', proposals[2].name) def test_proposals_sorter_for_global_methods_and_funcs(self): code = 'def my_b_func(self):\n' + \ @@ -449,8 +449,8 @@ def test_proposals_sorter_for_global_methods_and_funcs(self): 'my_a_var = 10\n' + \ 'my_' proposals = sorted_proposals(self._assist(code)) - self.assertEqual('my_b_func', proposals[0].name) - self.assertEqual('my_a_var', proposals[1].name) + self.assertEquals('my_b_func', proposals[0].name) + self.assertEquals('my_a_var', proposals[1].name) def test_proposals_sorter_underlined_methods(self): code = 'class A(object):\n' + \ @@ -461,8 +461,8 @@ def test_proposals_sorter_underlined_methods(self): 'a_var = A()\n' + \ 'a_var.' proposals = sorted_proposals(self._assist(code)) - self.assertEqual('my_func', proposals[0].name) - self.assertEqual('_my_func', proposals[1].name) + self.assertEquals('my_func', proposals[0].name) + self.assertEquals('_my_func', proposals[1].name) def test_proposals_sorter_and_scope_prefs(self): code = 'my_global_var = 1\n' \ @@ -471,8 +471,8 @@ def test_proposals_sorter_and_scope_prefs(self): ' my_' result = self._assist(code) proposals = sorted_proposals(result, scopepref=['global', 'local']) - self.assertEqual('my_global_var', proposals[0].name) - self.assertEqual('my_local_var', proposals[1].name) + self.assertEquals('my_global_var', proposals[0].name) + self.assertEquals('my_local_var', proposals[1].name) def test_proposals_sorter_and_type_prefs(self): code = 'my_global_var = 1\n' \ @@ -481,8 +481,8 @@ def test_proposals_sorter_and_type_prefs(self): 'my_' result = self._assist(code) proposals = sorted_proposals(result, typepref=['instance', 'function']) - self.assertEqual('my_global_var', proposals[0].name) - self.assertEqual('my_global_func', proposals[1].name) + self.assertEquals('my_global_var', proposals[0].name) + self.assertEquals('my_global_func', proposals[1].name) def test_proposals_sorter_and_missing_type_in_typepref(self): code = 'my_global_var = 1\n' \ @@ -525,7 +525,7 @@ def test_get_pydoc_for_modules(self): mod = testutils.create_module(self.project, 'mod') mod.write('"""a module"""\n') src = 'import mod\nmod' - self.assertEqual('a module', get_doc(self.project, src, len(src) - 1)) + self.assertEquals('a module', get_doc(self.project, src, len(src) - 1)) def test_get_pydoc_for_builtins(self): src = 'print(object)\n' @@ -685,20 +685,20 @@ def test_codeassist_before_line_indents_in_a_blank_line(self): def test_simple_get_calltips(self): src = 'def f():\n pass\nvar = f()\n' doc = get_calltip(self.project, src, src.rindex('f')) - self.assertEqual('f()', doc) + self.assertEquals('f()', doc) def test_get_calltips_for_classes(self): src = 'class C(object):\n' \ ' def __init__(self):\n pass\nC(' doc = get_calltip(self.project, src, len(src) - 1) - self.assertEqual('C.__init__(self)', doc) + self.assertEquals('C.__init__(self)', doc) def test_get_calltips_for_objects_with_call(self): src = 'class C(object):\n' \ ' def __call__(self, p):\n pass\n' \ 'c = C()\nc(1,' doc = get_calltip(self.project, src, src.rindex('c')) - self.assertEqual('C.__call__(self, p)', doc) + self.assertEquals('C.__call__(self, p)', doc) def test_get_calltips_and_including_module_name(self): src = 'class C(object):\n' \ @@ -707,7 +707,7 @@ def test_get_calltips_and_including_module_name(self): mod = testutils.create_module(self.project, 'mod') mod.write(src) doc = get_calltip(self.project, src, src.rindex('c'), mod) - self.assertEqual('mod.C.__call__(self, p)', doc) + self.assertEquals('mod.C.__call__(self, p)', doc) def test_get_calltips_and_including_module_name_2(self): src = 'range()\n' @@ -720,7 +720,7 @@ def test_removing_self_parameter(self): ' pass\n' \ 'C().f()' doc = get_calltip(self.project, src, src.rindex('f'), remove_self=True) - self.assertEqual('C.f()', doc) + self.assertEquals('C.f()', doc) def test_removing_self_parameter_and_more_than_one_parameter(self): src = 'class C(object):\n' \ @@ -728,7 +728,7 @@ def test_removing_self_parameter_and_more_than_one_parameter(self): ' pass\n' \ 'C().f()' doc = get_calltip(self.project, src, src.rindex('f'), remove_self=True) - self.assertEqual('C.f(p1)', doc) + self.assertEquals('C.f(p1)', doc) def test_lambda_calltip(self): src = 'foo = lambda x, y=1: None\n' \ @@ -859,7 +859,7 @@ def test_object_path_global(self): resource.write(code) result = get_canonical_path(self.project, resource, 1) mod_path = os.path.join(self.project.address, 'mod.py') - self.assertEqual( + self.assertEquals( result, [(mod_path, 'MODULE'), ('GLOBAL_VARIABLE', 'VARIABLE')]) @@ -870,7 +870,7 @@ def test_object_path_attribute(self): resource.write(code) result = get_canonical_path(self.project, resource, 24) mod_path = os.path.join(self.project.address, 'mod.py') - self.assertEqual( + self.assertEquals( result, [(mod_path, 'MODULE'), ('Foo', 'CLASS'), ('attr', 'VARIABLE')]) @@ -882,7 +882,7 @@ def test_object_path_subclass(self): resource.write(code) result = get_canonical_path(self.project, resource, 30) mod_path = os.path.join(self.project.address, 'mod.py') - self.assertEqual( + self.assertEquals( result, [(mod_path, 'MODULE'), ('Foo', 'CLASS'), ('Bar', 'CLASS')]) @@ -894,7 +894,7 @@ def test_object_path_method_parameter(self): resource.write(code) result = get_canonical_path(self.project, resource, 41) mod_path = os.path.join(self.project.address, 'mod.py') - self.assertEqual( + self.assertEquals( result, [(mod_path, 'MODULE'), ('Foo', 'CLASS'), ('bar', 'FUNCTION'), ('b', 'PARAMETER')]) @@ -905,7 +905,7 @@ def test_object_path_variable(self): resource.write(code) result = get_canonical_path(self.project, resource, 17) mod_path = os.path.join(self.project.address, 'mod.py') - self.assertEqual( + self.assertEquals( result, [(mod_path, 'MODULE'), ('bar', 'FUNCTION'), ('x', 'VARIABLE')]) @@ -1027,7 +1027,7 @@ def test_result_start_offset_for_dotted_completions(self): ' def method1(self):\n' \ ' pass\n' \ 'Sample.me' - self.assertEqual(len(code) - 2, starting_offset(code, len(code))) + self.assertEquals(len(code) - 2, starting_offset(code, len(code))) def test_backslash_after_dots(self): code = 'class Sample(object):\n' \ @@ -1062,13 +1062,13 @@ def test_get_location_on_relative_imports(self): code = 'import mod1\nmod1.a_func\n' result = get_definition_location(self.project, code, len(code) - 2, mod2) - self.assertEqual((mod1, 1), result) + self.assertEquals((mod1, 1), result) def test_get_definition_location_for_builtins(self): code = 'import sys\n' result = get_definition_location(self.project, code, len(code) - 2) - self.assertEqual((None, None), result) + self.assertEquals((None, None), result) def test_get_doc_on_relative_imports(self): pkg = testutils.create_package(self.project, 'pkg') @@ -1120,7 +1120,7 @@ def test_completing_names_after_from_import2(self): def test_starting_expression(self): code = 'l = list()\nl.app' - self.assertEqual('l.app', starting_expression(code, len(code))) + self.assertEquals('l.app', starting_expression(code, len(code))) def suite(): diff --git a/ropetest/contrib/finderrorstest.py b/ropetest/contrib/finderrorstest.py index 1116f2b2d..494a47c91 100644 --- a/ropetest/contrib/finderrorstest.py +++ b/ropetest/contrib/finderrorstest.py @@ -18,24 +18,24 @@ def tearDown(self): def test_unresolved_variables(self): self.mod.write('print(var)\n') result = finderrors.find_errors(self.project, self.mod) - self.assertEqual(1, len(result)) - self.assertEqual(1, result[0].lineno) + self.assertEquals(1, len(result)) + self.assertEquals(1, result[0].lineno) def test_defined_later(self): self.mod.write('print(var)\nvar = 1\n') result = finderrors.find_errors(self.project, self.mod) - self.assertEqual(1, len(result)) - self.assertEqual(1, result[0].lineno) + self.assertEquals(1, len(result)) + self.assertEquals(1, result[0].lineno) def test_ignoring_builtins(self): self.mod.write('range(2)\n') result = finderrors.find_errors(self.project, self.mod) - self.assertEqual(0, len(result)) + self.assertEquals(0, len(result)) def test_ignoring_none(self): self.mod.write('var = None\n') result = finderrors.find_errors(self.project, self.mod) - self.assertEqual(0, len(result)) + self.assertEquals(0, len(result)) def test_bad_attributes(self): code = 'class C(object):\n' \ @@ -44,8 +44,8 @@ def test_bad_attributes(self): 'print(c.var)\n' self.mod.write(code) result = finderrors.find_errors(self.project, self.mod) - self.assertEqual(1, len(result)) - self.assertEqual(4, result[0].lineno) + self.assertEquals(1, len(result)) + self.assertEquals(4, result[0].lineno) if __name__ == '__main__': diff --git a/ropetest/contrib/findittest.py b/ropetest/contrib/findittest.py index 1382e06aa..9406a36db 100644 --- a/ropetest/contrib/findittest.py +++ b/ropetest/contrib/findittest.py @@ -23,9 +23,9 @@ def test_finding_occurrences(self): mod = testutils.create_module(self.project, 'mod') mod.write('a_var = 1\n') result = find_occurrences(self.project, mod, 1) - self.assertEqual(mod, result[0].resource) - self.assertEqual(0, result[0].offset) - self.assertEqual(False, result[0].unsure) + self.assertEquals(mod, result[0].resource) + self.assertEquals(0, result[0].offset) + self.assertEquals(False, result[0].unsure) def test_finding_occurrences_in_more_than_one_module(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -33,7 +33,7 @@ def test_finding_occurrences_in_more_than_one_module(self): mod1.write('a_var = 1\n') mod2.write('import mod1\nmy_var = mod1.a_var') result = find_occurrences(self.project, mod1, 1) - self.assertEqual(2, len(result)) + self.assertEquals(2, len(result)) modules = (result[0].resource, result[1].resource) self.assertTrue(mod1 in modules and mod2 in modules) @@ -43,7 +43,7 @@ def test_finding_occurrences_matching_when_unsure(self): 'def f(arg):\n arg.a_func()\n') result = find_occurrences( self.project, mod1, mod1.read().index('a_func'), unsure=True) - self.assertEqual(2, len(result)) + self.assertEquals(2, len(result)) def test_find_occurrences_resources_parameter(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -51,8 +51,8 @@ def test_find_occurrences_resources_parameter(self): mod1.write('a_var = 1\n') mod2.write('import mod1\nmy_var = mod1.a_var') result = find_occurrences(self.project, mod1, 1, resources=[mod1]) - self.assertEqual(1, len(result)) - self.assertEqual((mod1, 0), (result[0].resource, result[0].offset)) + self.assertEquals(1, len(result)) + self.assertEquals((mod1, 0), (result[0].resource, result[0].offset)) def test_find_occurrences_and_class_hierarchies(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -62,15 +62,15 @@ def test_find_occurrences_and_class_hierarchies(self): result1 = find_occurrences(self.project, mod1, offset) result2 = find_occurrences(self.project, mod1, offset, in_hierarchy=True) - self.assertEqual(1, len(result1)) - self.assertEqual(2, len(result2)) + self.assertEquals(1, len(result1)) + self.assertEquals(2, len(result2)) def test_trivial_find_implementations(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write('class A(object):\n def f(self):\n pass\n') offset = mod1.read().rindex('f(') result = find_implementations(self.project, mod1, offset) - self.assertEqual([], result) + self.assertEquals([], result) def test_find_implementations_and_not_returning_parents(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -78,7 +78,7 @@ def test_find_implementations_and_not_returning_parents(self): 'class B(A):\n def f(self):\n pass\n') offset = mod1.read().rindex('f(') result = find_implementations(self.project, mod1, offset) - self.assertEqual([], result) + self.assertEquals([], result) def test_find_implementations_real_implementation(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -86,8 +86,8 @@ def test_find_implementations_real_implementation(self): 'class B(A):\n def f(self):\n pass\n') offset = mod1.read().index('f(') result = find_implementations(self.project, mod1, offset) - self.assertEqual(1, len(result)) - self.assertEqual(mod1.read().rindex('f('), result[0].offset) + self.assertEquals(1, len(result)) + self.assertEquals(mod1.read().rindex('f('), result[0].offset) def test_find_implementations_real_implementation_simple(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -100,18 +100,18 @@ def test_trivial_find_definition(self): code = 'def a_func():\n pass\na_func()' result = find_definition(self.project, code, code.rindex('a_func')) start = code.index('a_func') - self.assertEqual(start, result.offset) - self.assertEqual(None, result.resource) - self.assertEqual(1, result.lineno) - self.assertEqual((start, start + len('a_func')), result.region) + self.assertEquals(start, result.offset) + self.assertEquals(None, result.resource) + self.assertEquals(1, result.lineno) + self.assertEquals((start, start + len('a_func')), result.region) def test_find_definition_in_other_modules(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write('var = 1\n') code = 'import mod1\nprint(mod1.var)\n' result = find_definition(self.project, code, code.index('var')) - self.assertEqual(mod1, result.resource) - self.assertEqual(0, result.offset) + self.assertEquals(mod1, result.resource) + self.assertEquals(0, result.offset) def suite(): diff --git a/ropetest/contrib/fixmodnamestest.py b/ropetest/contrib/fixmodnamestest.py index fa1ec8a9e..9fa364221 100644 --- a/ropetest/contrib/fixmodnamestest.py +++ b/ropetest/contrib/fixmodnamestest.py @@ -37,8 +37,8 @@ def test_fixing_contents(self): self.project.do(FixModuleNames(self.project).get_changes(_fixer)) newmod1 = self.project.get_resource('_od1.py') newmod2 = self.project.get_resource('_od2.py') - self.assertEqual('import _od2\n', newmod1.read()) - self.assertEqual('import _od1\n', newmod2.read()) + self.assertEquals('import _od2\n', newmod1.read()) + self.assertEquals('import _od1\n', newmod2.read()) def test_handling_nested_modules(self): pkg = create_package(self.project, 'xkg') diff --git a/ropetest/contrib/generatetest.py b/ropetest/contrib/generatetest.py index 3a6a1817c..48f9f913a 100644 --- a/ropetest/contrib/generatetest.py +++ b/ropetest/contrib/generatetest.py @@ -41,28 +41,28 @@ def test_getting_location(self): code = 'a_var = name\n' self.mod.write(code) generator = self._get_generate(code.index('name')) - self.assertEqual((self.mod, 1), generator.get_location()) + self.assertEquals((self.mod, 1), generator.get_location()) def test_generating_variable(self): code = 'a_var = name\n' self.mod.write(code) changes = self._get_generate(code.index('name')).get_changes() self.project.do(changes) - self.assertEqual('name = None\n\n\na_var = name\n', self.mod.read()) + self.assertEquals('name = None\n\n\na_var = name\n', self.mod.read()) def test_generating_variable_inserting_before_statement(self): code = 'c = 1\nc = b\n' self.mod.write(code) changes = self._get_generate(code.index('b')).get_changes() self.project.do(changes) - self.assertEqual('c = 1\nb = None\n\n\nc = b\n', self.mod.read()) + self.assertEquals('c = 1\nb = None\n\n\nc = b\n', self.mod.read()) def test_generating_variable_in_local_scopes(self): code = 'def f():\n c = 1\n c = b\n' self.mod.write(code) changes = self._get_generate(code.index('b')).get_changes() self.project.do(changes) - self.assertEqual('def f():\n c = 1\n b = None\n c = b\n', + self.assertEquals('def f():\n c = 1\n b = None\n c = b\n', self.mod.read()) def test_generating_variable_in_other_modules(self): @@ -70,8 +70,8 @@ def test_generating_variable_in_other_modules(self): self.mod.write(code) generator = self._get_generate(code.index('b')) self.project.do(generator.get_changes()) - self.assertEqual((self.mod2, 1), generator.get_location()) - self.assertEqual('b = None\n', self.mod2.read()) + self.assertEquals((self.mod2, 1), generator.get_location()) + self.assertEquals('b = None\n', self.mod2.read()) def test_generating_variable_in_classes(self): code = 'class C(object):\n def f(self):\n pass\n' \ @@ -79,7 +79,7 @@ def test_generating_variable_in_classes(self): self.mod.write(code) changes = self._get_generate(code.index('attr')).get_changes() self.project.do(changes) - self.assertEqual( + self.assertEquals( 'class C(object):\n def f(self):\n ' 'pass\n\n attr = None\n' 'c = C()\na_var = c.attr', self.mod.read()) @@ -89,7 +89,7 @@ def test_generating_variable_in_classes_removing_pass(self): self.mod.write(code) changes = self._get_generate(code.index('attr')).get_changes() self.project.do(changes) - self.assertEqual('class C(object):\n\n attr = None\n' + self.assertEquals('class C(object):\n\n attr = None\n' 'c = C()\na_var = c.attr', self.mod.read()) def test_generating_variable_in_packages(self): @@ -98,15 +98,15 @@ def test_generating_variable_in_packages(self): generator = self._get_generate(code.rindex('a')) self.project.do(generator.get_changes()) init = self.pkg.get_child('__init__.py') - self.assertEqual((init, 1), generator.get_location()) - self.assertEqual('a = None\n', init.read()) + self.assertEquals((init, 1), generator.get_location()) + self.assertEquals('a = None\n', init.read()) def test_generating_classes(self): code = 'c = C()\n' self.mod.write(code) changes = self._get_generate_class(code.index('C')).get_changes() self.project.do(changes) - self.assertEqual('class C(object):\n pass\n\n\nc = C()\n', + self.assertEquals('class C(object):\n pass\n\n\nc = C()\n', self.mod.read()) def test_generating_modules(self): @@ -115,8 +115,8 @@ def test_generating_modules(self): generator = self._get_generate_module(code.rindex('mod')) self.project.do(generator.get_changes()) mod = self.pkg.get_child('mod.py') - self.assertEqual((mod, 1), generator.get_location()) - self.assertEqual('import pkg.mod\npkg.mod\n', self.mod.read()) + self.assertEquals((mod, 1), generator.get_location()) + self.assertEquals('import pkg.mod\npkg.mod\n', self.mod.read()) def test_generating_packages(self): code = 'import pkg\npkg.pkg2\n' @@ -125,8 +125,8 @@ def test_generating_packages(self): self.project.do(generator.get_changes()) pkg2 = self.pkg.get_child('pkg2') init = pkg2.get_child('__init__.py') - self.assertEqual((init, 1), generator.get_location()) - self.assertEqual('import pkg.pkg2\npkg.pkg2\n', self.mod.read()) + self.assertEquals((init, 1), generator.get_location()) + self.assertEquals('import pkg.pkg2\npkg.pkg2\n', self.mod.read()) def test_generating_function(self): code = 'a_func()\n' @@ -134,7 +134,7 @@ def test_generating_function(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEqual('def a_func():\n pass\n\n\na_func()\n', + self.assertEquals('def a_func():\n pass\n\n\na_func()\n', self.mod.read()) def test_generating_modules_with_empty_primary(self): @@ -143,8 +143,8 @@ def test_generating_modules_with_empty_primary(self): generator = self._get_generate_module(code.rindex('mod')) self.project.do(generator.get_changes()) mod = self.project.root.get_child('mod.py') - self.assertEqual((mod, 1), generator.get_location()) - self.assertEqual('import mod\nmod\n', self.mod.read()) + self.assertEquals((mod, 1), generator.get_location()) + self.assertEquals('import mod\nmod\n', self.mod.read()) def test_generating_variable_already_exists(self): code = 'b = 1\nc = b\n' @@ -171,7 +171,7 @@ def test_generating_static_methods(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEqual( + self.assertEquals( 'class C(object):\n\n @staticmethod' '\n def a_func():\n pass\nC.a_func()\n', self.mod.read()) @@ -182,7 +182,7 @@ def test_generating_methods(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEqual( + self.assertEquals( 'class C(object):\n\n def a_func(self):\n pass\n' 'c = C()\nc.a_func()\n', self.mod.read()) @@ -192,7 +192,7 @@ def test_generating_constructors(self): self.mod.write(code) changes = self._get_generate_function(code.rindex('C')).get_changes() self.project.do(changes) - self.assertEqual( + self.assertEquals( 'class C(object):\n\n def __init__(self):\n pass\n' 'c = C()\n', self.mod.read()) @@ -202,7 +202,7 @@ def test_generating_calls(self): self.mod.write(code) changes = self._get_generate_function(code.rindex('c')).get_changes() self.project.do(changes) - self.assertEqual( + self.assertEquals( 'class C(object):\n\n def __call__(self):\n pass\n' 'c = C()\nc()\n', self.mod.read()) @@ -213,7 +213,7 @@ def test_generating_calls_in_other_modules(self): self.mod.write(code) changes = self._get_generate_function(code.rindex('c')).get_changes() self.project.do(changes) - self.assertEqual( + self.assertEquals( 'class C(object):\n\n def __call__(self):\n pass\n', self.mod2.read()) @@ -223,7 +223,7 @@ def test_generating_function_handling_arguments(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEqual('def a_func(arg0):\n pass\n\n\na_func(1)\n', + self.assertEquals('def a_func(arg0):\n pass\n\n\na_func(1)\n', self.mod.read()) def test_generating_function_handling_keyword_xarguments(self): @@ -232,7 +232,7 @@ def test_generating_function_handling_keyword_xarguments(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEqual('def a_func(p):\n pass\n\n\na_func(p=1)\n', + self.assertEquals('def a_func(p):\n pass\n\n\na_func(p=1)\n', self.mod.read()) def test_generating_function_handling_arguments_better_naming(self): @@ -241,7 +241,7 @@ def test_generating_function_handling_arguments_better_naming(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEqual('a_var = 1\ndef a_func(a_var):' + self.assertEquals('a_var = 1\ndef a_func(a_var):' '\n pass\n\n\na_func(a_var)\n', self.mod.read()) @@ -251,8 +251,8 @@ def test_generating_variable_in_other_modules2(self): self.mod.write(code) generator = self._get_generate(code.index('b')) self.project.do(generator.get_changes()) - self.assertEqual((self.mod2, 5), generator.get_location()) - self.assertEqual('\n\n\nprint(1)\n\n\nb = None\n', self.mod2.read()) + self.assertEquals((self.mod2, 5), generator.get_location()) + self.assertEquals('\n\n\nprint(1)\n\n\nb = None\n', self.mod2.read()) def test_generating_function_in_a_suite(self): code = 'if True:\n a_func()\n' @@ -260,7 +260,7 @@ def test_generating_function_in_a_suite(self): changes = self._get_generate_function( code.index('a_func')).get_changes() self.project.do(changes) - self.assertEqual('def a_func():\n pass' + self.assertEquals('def a_func():\n pass' '\n\n\nif True:\n a_func()\n', self.mod.read()) @@ -269,7 +269,7 @@ def test_generating_function_in_a_suite_in_a_function(self): self.mod.write(code) changes = self._get_generate_function(code.index('g()')).get_changes() self.project.do(changes) - self.assertEqual( + self.assertEquals( 'def f():\n a = 1\n def g():\n pass\n' ' if 1:\n g()\n', self.mod.read()) diff --git a/ropetest/historytest.py b/ropetest/historytest.py index c278733fb..2eaa92caf 100644 --- a/ropetest/historytest.py +++ b/ropetest/historytest.py @@ -24,20 +24,20 @@ def test_undoing_writes(self): my_file = self.project.root.create_file('my_file.txt') my_file.write('text1') self.history.undo() - self.assertEqual('', my_file.read()) + self.assertEquals('', my_file.read()) def test_moving_files(self): my_file = self.project.root.create_file('my_file.txt') my_file.move('new_file.txt') self.history.undo() - self.assertEqual('', my_file.read()) + self.assertEquals('', my_file.read()) def test_moving_files_to_folders(self): my_file = self.project.root.create_file('my_file.txt') my_folder = self.project.root.create_folder('my_folder') my_file.move(my_folder.path) self.history.undo() - self.assertEqual('', my_file.read()) + self.assertEquals('', my_file.read()) def test_writing_files_that_does_not_change_contents(self): my_file = self.project.root.create_file('my_file.txt') @@ -62,27 +62,27 @@ def tearDown(self): def test_simple_undo(self): change = rope.base.change.ChangeContents(self.file1, '1') self.history.do(change) - self.assertEqual('1', self.file1.read()) + self.assertEquals('1', self.file1.read()) self.history.undo() - self.assertEqual('', self.file1.read()) + self.assertEquals('', self.file1.read()) def test_tobe_undone(self): change1 = rope.base.change.ChangeContents(self.file1, '1') - self.assertEqual(None, self.history.tobe_undone) + self.assertEquals(None, self.history.tobe_undone) self.history.do(change1) - self.assertEqual(change1, self.history.tobe_undone) + self.assertEquals(change1, self.history.tobe_undone) change2 = rope.base.change.ChangeContents(self.file1, '2') self.history.do(change2) - self.assertEqual(change2, self.history.tobe_undone) + self.assertEquals(change2, self.history.tobe_undone) self.history.undo() - self.assertEqual(change1, self.history.tobe_undone) + self.assertEquals(change1, self.history.tobe_undone) def test_tobe_redone(self): change = rope.base.change.ChangeContents(self.file1, '1') self.history.do(change) - self.assertEqual(None, self.history.tobe_redone) + self.assertEquals(None, self.history.tobe_redone) self.history.undo() - self.assertEqual(change, self.history.tobe_redone) + self.assertEquals(change, self.history.tobe_redone) def test_undo_limit(self): history = rope.base.history.History(self.project, maxundos=1) @@ -93,14 +93,14 @@ def test_undo_limit(self): with self.assertRaises(exceptions.HistoryError): history.undo() finally: - self.assertEqual('1', self.file1.read()) + self.assertEquals('1', self.file1.read()) def test_simple_redo(self): change = rope.base.change.ChangeContents(self.file1, '1') self.history.do(change) self.history.undo() self.history.redo() - self.assertEqual('1', self.file1.read()) + self.assertEquals('1', self.file1.read()) def test_simple_re_undo(self): change = rope.base.change.ChangeContents(self.file1, '1') @@ -108,7 +108,7 @@ def test_simple_re_undo(self): self.history.undo() self.history.redo() self.history.undo() - self.assertEqual('', self.file1.read()) + self.assertEquals('', self.file1.read()) def test_multiple_undos(self): change = rope.base.change.ChangeContents(self.file1, '1') @@ -116,13 +116,13 @@ def test_multiple_undos(self): change = rope.base.change.ChangeContents(self.file1, '2') self.history.do(change) self.history.undo() - self.assertEqual('1', self.file1.read()) + self.assertEquals('1', self.file1.read()) change = rope.base.change.ChangeContents(self.file1, '3') self.history.do(change) self.history.undo() - self.assertEqual('1', self.file1.read()) + self.assertEquals('1', self.file1.read()) self.history.redo() - self.assertEqual('3', self.file1.read()) + self.assertEquals('3', self.file1.read()) def test_undo_list_underflow(self): with self.assertRaises(exceptions.HistoryError): @@ -142,7 +142,7 @@ def test_undoing_choosen_changes(self): change = rope.base.change.ChangeContents(self.file1, '1') self.history.do(change) self.history.undo(change) - self.assertEqual('', self.file1.read()) + self.assertEquals('', self.file1.read()) self.assertFalse(self.history.undo_list) def test_undoing_choosen_changes2(self): @@ -150,7 +150,7 @@ def test_undoing_choosen_changes2(self): self.history.do(change1) self.history.do(rope.base.change.ChangeContents(self.file1, '2')) self.history.undo(change1) - self.assertEqual('', self.file1.read()) + self.assertEquals('', self.file1.read()) self.assertFalse(self.history.undo_list) def test_undoing_choosen_changes_not_undoing_others(self): @@ -158,8 +158,8 @@ def test_undoing_choosen_changes_not_undoing_others(self): self.history.do(change1) self.history.do(rope.base.change.ChangeContents(self.file2, '2')) self.history.undo(change1) - self.assertEqual('', self.file1.read()) - self.assertEqual('2', self.file2.read()) + self.assertEquals('', self.file1.read()) + self.assertEquals('2', self.file2.read()) def test_undoing_writing_after_moving(self): change1 = rope.base.change.ChangeContents(self.file1, '1') @@ -167,7 +167,7 @@ def test_undoing_writing_after_moving(self): self.history.do(rope.base.change.MoveResource(self.file1, 'file3.txt')) file3 = self.project.get_resource('file3.txt') self.history.undo(change1) - self.assertEqual('', self.file1.read()) + self.assertEquals('', self.file1.read()) self.assertFalse(file3.exists()) def test_undoing_folder_movements_for_undoing_writes_inside_it(self): @@ -178,7 +178,7 @@ def test_undoing_folder_movements_for_undoing_writes_inside_it(self): self.history.do(rope.base.change.MoveResource(folder, 'new_folder')) new_folder = self.project.get_resource('new_folder') self.history.undo(change1) - self.assertEqual('', file3.read()) + self.assertEquals('', file3.read()) self.assertFalse(new_folder.exists()) def test_undoing_changes_that_depend_on_a_dependant_change(self): @@ -192,8 +192,8 @@ def test_undoing_changes_that_depend_on_a_dependant_change(self): file3 = self.project.get_resource('file3.txt') self.history.undo(change1) - self.assertEqual('', self.file1.read()) - self.assertEqual('', self.file2.read()) + self.assertEquals('', self.file1.read()) + self.assertEquals('', self.file2.read()) self.assertFalse(file3.exists()) def test_undoing_writes_for_undoing_folder_movements_containing_it(self): @@ -204,7 +204,7 @@ def test_undoing_writes_for_undoing_folder_movements_containing_it(self): new_file = self.project.get_resource('new_folder/file3.txt') self.history.do(rope.base.change.ChangeContents(new_file, '1')) self.history.undo(change1) - self.assertEqual('', old_file.read()) + self.assertEquals('', old_file.read()) self.assertFalse(new_file.exists()) def test_undoing_not_available_change(self): @@ -218,18 +218,18 @@ def test_ignoring_ignored_resources(self): change = rope.base.change.CreateResource(ignored) self.history.do(change) self.assertTrue(ignored.exists()) - self.assertEqual(0, len(self.history.undo_list)) + self.assertEquals(0, len(self.history.undo_list)) def test_get_file_undo_list_simple(self): change = rope.base.change.ChangeContents(self.file1, '1') self.history.do(change) - self.assertEqual(set([change]), + self.assertEquals(set([change]), set(self.history.get_file_undo_list(self.file1))) def test_get_file_undo_list_for_moves(self): change = rope.base.change.MoveResource(self.file1, 'file2.txt') self.history.do(change) - self.assertEqual(set([change]), + self.assertEquals(set([change]), set(self.history.get_file_undo_list(self.file1))) # XXX: What happens for moves before the file is created? @@ -238,7 +238,7 @@ def xxx_test_get_file_undo_list_and_moving_its_contining_folder(self): old_file = folder.create_file('file3.txt') change1 = rope.base.change.MoveResource(folder, 'new_folder') self.history.do(change1) - self.assertEqual(set([change1]), + self.assertEquals(set([change1]), set(self.history.get_file_undo_list(old_file))) def test_clearing_redo_list_after_do(self): @@ -246,7 +246,7 @@ def test_clearing_redo_list_after_do(self): self.history.do(change) self.history.undo() self.history.do(change) - self.assertEqual(0, len(self.history.redo_list)) + self.assertEquals(0, len(self.history.redo_list)) def test_undoing_a_not_yet_performed_change(self): change = rope.base.change.ChangeContents(self.file1, '1') @@ -261,8 +261,8 @@ def test_clearing_up_the_history(self): self.history.do(change2) self.history.undo() self.history.clear() - self.assertEqual(0, len(self.history.undo_list)) - self.assertEqual(0, len(self.history.redo_list)) + self.assertEquals(0, len(self.history.undo_list)) + self.assertEquals(0, len(self.history.redo_list)) def test_redoing_choosen_changes_not_undoing_others(self): change1 = rope.base.change.ChangeContents(self.file1, '1') @@ -272,9 +272,9 @@ def test_redoing_choosen_changes_not_undoing_others(self): self.history.undo() self.history.undo() redone = self.history.redo(change2) - self.assertEqual([change2], redone) - self.assertEqual('', self.file1.read()) - self.assertEqual('2', self.file2.read()) + self.assertEquals([change2], redone) + self.assertEquals('', self.file1.read()) + self.assertEquals('2', self.file2.read()) class SavingHistoryTest(unittest.TestCase): @@ -293,7 +293,7 @@ def tearDown(self): def test_simple_set_saving(self): data = self.to_data(rope.base.change.ChangeSet('testing')) change = self.to_change(data) - self.assertEqual('testing', str(change)) + self.assertEquals('testing', str(change)) def test_simple_change_content_saving(self): myfile = self.project.get_file('myfile.txt') @@ -302,9 +302,9 @@ def test_simple_change_content_saving(self): data = self.to_data(rope.base.change.ChangeContents(myfile, '2')) change = self.to_change(data) self.history.do(change) - self.assertEqual('2', myfile.read()) + self.assertEquals('2', myfile.read()) self.history.undo() - self.assertEqual('1', change.old_contents) + self.assertEquals('1', change.old_contents) def test_move_resource_saving(self): myfile = self.project.root.create_file('myfile.txt') @@ -375,7 +375,7 @@ def test_change_set_saving(self): data = self.to_data(change) change = self.to_change(data) self.history.do(change) - self.assertEqual('1', myfile.read()) + self.assertEquals('1', myfile.read()) self.history.undo() self.assertFalse(myfile.exists()) diff --git a/ropetest/objectdbtest.py b/ropetest/objectdbtest.py index a104a7786..ab59084b2 100644 --- a/ropetest/objectdbtest.py +++ b/ropetest/objectdbtest.py @@ -59,87 +59,87 @@ def test_simple_per_name(self, db): @_do_for_all_dbs def test_simple_per_name_does_not_exist(self, db): - self.assertEqual(None, db.get_pername('file', 'key', 'name')) + self.assertEquals(None, db.get_pername('file', 'key', 'name')) @_do_for_all_dbs def test_simple_per_name_after_syncing(self, db): db.add_pername('file', 'key', 'name', 1) db.write() - self.assertEqual(1, db.get_pername('file', 'key', 'name')) + self.assertEquals(1, db.get_pername('file', 'key', 'name')) @_do_for_all_dbs def test_getting_returned(self, db): db.add_callinfo('file', 'key', (1, 2), 3) - self.assertEqual(3, db.get_returned('file', 'key', (1, 2))) + self.assertEquals(3, db.get_returned('file', 'key', (1, 2))) @_do_for_all_dbs def test_getting_returned_when_does_not_match(self, db): db.add_callinfo('file', 'key', (1, 2), 3) - self.assertEqual(None, db.get_returned('file', 'key', (1, 1))) + self.assertEquals(None, db.get_returned('file', 'key', (1, 1))) @_do_for_all_dbs def test_getting_call_info(self, db): db.add_callinfo('file', 'key', (1, 2), 3) call_infos = list(db.get_callinfos('file', 'key')) - self.assertEqual(1, len(call_infos)) - self.assertEqual((1, 2), call_infos[0].get_parameters()) - self.assertEqual(3, call_infos[0].get_returned()) + self.assertEquals(1, len(call_infos)) + self.assertEquals((1, 2), call_infos[0].get_parameters()) + self.assertEquals(3, call_infos[0].get_returned()) @_do_for_all_dbs def test_invalid_per_name(self, db): db.add_pername('file', 'key', 'name', -1) - self.assertEqual(None, db.get_pername('file', 'key', 'name')) + self.assertEquals(None, db.get_pername('file', 'key', 'name')) @_do_for_all_dbs def test_overwriting_per_name(self, db): db.add_pername('file', 'key', 'name', 1) db.add_pername('file', 'key', 'name', 2) - self.assertEqual(2, db.get_pername('file', 'key', 'name')) + self.assertEquals(2, db.get_pername('file', 'key', 'name')) @_do_for_all_dbs def test_not_overwriting_with_invalid_per_name(self, db): db.add_pername('file', 'key', 'name', 1) db.add_pername('file', 'key', 'name', -1) - self.assertEqual(1, db.get_pername('file', 'key', 'name')) + self.assertEquals(1, db.get_pername('file', 'key', 'name')) @_do_for_all_dbs def test_getting_invalid_returned(self, db): db.add_callinfo('file', 'key', (1, 2), -1) - self.assertEqual(None, db.get_returned('file', 'key', (1, 2))) + self.assertEquals(None, db.get_returned('file', 'key', (1, 2))) @_do_for_all_dbs def test_not_overwriting_with_invalid_returned(self, db): db.add_callinfo('file', 'key', (1, 2), 3) db.add_callinfo('file', 'key', (1, 2), -1) - self.assertEqual(3, db.get_returned('file', 'key', (1, 2))) + self.assertEquals(3, db.get_returned('file', 'key', (1, 2))) @_do_for_all_dbs def test_get_files(self, db): db.add_callinfo('file1', 'key', (1, 2), 3) db.add_callinfo('file2', 'key', (1, 2), 3) - self.assertEqual(set(['file1', 'file2']), set(db.get_files())) + self.assertEquals(set(['file1', 'file2']), set(db.get_files())) @_do_for_all_dbs def test_validating_files(self, db): db.add_callinfo('invalid', 'key', (1, 2), 3) db.validate_files() - self.assertEqual(0, len(db.get_files())) + self.assertEquals(0, len(db.get_files())) @_do_for_all_dbs def test_validating_file_for_scopes(self, db): db.add_callinfo('file', 'invalid', (1, 2), 3) db.validate_file('file') - self.assertEqual(1, len(db.get_files())) - self.assertEqual(0, len(list(db.get_callinfos('file', 'invalid')))) + self.assertEquals(1, len(db.get_files())) + self.assertEquals(0, len(list(db.get_callinfos('file', 'invalid')))) @_do_for_all_dbs def test_validating_file_moved(self, db): db.add_callinfo('file', 'key', (1, 2), 3) db.file_moved('file', 'newfile') - self.assertEqual(1, len(db.get_files())) - self.assertEqual(1, len(list(db.get_callinfos('newfile', 'key')))) + self.assertEquals(1, len(db.get_files())) + self.assertEquals(1, len(list(db.get_callinfos('newfile', 'key')))) @_do_for_all_dbs def test_using_file_list_observer(self, db): @@ -147,7 +147,7 @@ def test_using_file_list_observer(self, db): observer = _MockFileListObserver() db.add_file_list_observer(observer) db.validate_files() - self.assertEqual('removed invalid ', observer.log) + self.assertEquals('removed invalid ', observer.log) def suite(): diff --git a/ropetest/objectinfertest.py b/ropetest/objectinfertest.py index e7ae45692..ca8c29a08 100644 --- a/ropetest/objectinfertest.py +++ b/ropetest/objectinfertest.py @@ -21,7 +21,7 @@ def test_simple_type_inferencing(self): scope = libutils.get_string_scope(self.project, code) sample_class = scope['Sample'].get_object() a_var = scope['a_var'].get_object() - self.assertEqual(sample_class, a_var.get_type()) + self.assertEquals(sample_class, a_var.get_type()) def test_simple_type_inferencing_classes_defined_in_holding_scope(self): code = 'class Sample(object):\n pass\n' \ @@ -30,7 +30,7 @@ def test_simple_type_inferencing_classes_defined_in_holding_scope(self): sample_class = scope['Sample'].get_object() a_var = scope['a_func'].get_object().\ get_scope()['a_var'].get_object() - self.assertEqual(sample_class, a_var.get_type()) + self.assertEquals(sample_class, a_var.get_type()) def test_simple_type_inferencing_classes_in_class_methods(self): code = 'class Sample(object):\n pass\n' \ @@ -41,7 +41,7 @@ def test_simple_type_inferencing_classes_in_class_methods(self): another_class = scope['Another'].get_object() a_var = another_class['a_method'].\ get_object().get_scope()['a_var'].get_object() - self.assertEqual(sample_class, a_var.get_type()) + self.assertEquals(sample_class, a_var.get_type()) def test_simple_type_inferencing_class_attributes(self): code = 'class Sample(object):\n pass\n' \ @@ -51,7 +51,7 @@ def test_simple_type_inferencing_class_attributes(self): sample_class = scope['Sample'].get_object() another_class = scope['Another'].get_object() a_var = another_class['a_var'].get_object() - self.assertEqual(sample_class, a_var.get_type()) + self.assertEquals(sample_class, a_var.get_type()) def test_simple_type_inferencing_for_in_class_assignments(self): code = 'class Sample(object):\n pass\n' \ @@ -60,7 +60,7 @@ def test_simple_type_inferencing_for_in_class_assignments(self): sample_class = scope['Sample'].get_object() another_class = scope['Another'].get_object() an_attr = another_class['an_attr'].get_object() - self.assertEqual(sample_class, an_attr.get_type()) + self.assertEquals(sample_class, an_attr.get_type()) def test_simple_type_inferencing_for_chained_assignments(self): mod = 'class Sample(object):\n pass\n' \ @@ -68,7 +68,7 @@ def test_simple_type_inferencing_for_chained_assignments(self): mod_scope = libutils.get_string_scope(self.project, mod) sample_class = mod_scope['Sample'] copied_sample = mod_scope['copied_sample'] - self.assertEqual(sample_class.get_object(), + self.assertEquals(sample_class.get_object(), copied_sample.get_object()) def test_following_chained_assignments_avoiding_circles(self): @@ -78,7 +78,7 @@ def test_following_chained_assignments_avoiding_circles(self): mod_scope = libutils.get_string_scope(self.project, mod) sample_class = mod_scope['Sample'] sample_class_var = mod_scope['sample_class'] - self.assertEqual(sample_class.get_object(), + self.assertEquals(sample_class.get_object(), sample_class_var.get_object()) def test_function_returned_object_static_type_inference1(self): @@ -88,7 +88,7 @@ def test_function_returned_object_static_type_inference1(self): scope = libutils.get_string_scope(self.project, src) sample_class = scope['Sample'] a_var = scope['a_var'] - self.assertEqual(sample_class.get_object(), a_var.get_object()) + self.assertEquals(sample_class.get_object(), a_var.get_object()) def test_function_returned_object_static_type_inference2(self): src = 'class Sample(object):\n pass\n' \ @@ -97,7 +97,7 @@ def test_function_returned_object_static_type_inference2(self): scope = libutils.get_string_scope(self.project, src) sample_class = scope['Sample'].get_object() a_var = scope['a_var'].get_object() - self.assertEqual(sample_class, a_var.get_type()) + self.assertEquals(sample_class, a_var.get_type()) def test_recursive_function_returned_object_static_type_inference(self): src = 'class Sample(object):\n pass\n' \ @@ -108,7 +108,7 @@ def test_recursive_function_returned_object_static_type_inference(self): scope = libutils.get_string_scope(self.project, src) sample_class = scope['Sample'].get_object() a_var = scope['a_var'].get_object() - self.assertEqual(sample_class, a_var.get_type()) + self.assertEquals(sample_class, a_var.get_type()) def test_func_returned_obj_using_call_spec_func_static_type_infer(self): src = 'class Sample(object):\n' \ @@ -117,7 +117,7 @@ def test_func_returned_obj_using_call_spec_func_static_type_infer(self): scope = libutils.get_string_scope(self.project, src) sample_class = scope['Sample'] a_var = scope['a_var'] - self.assertEqual(sample_class.get_object(), a_var.get_object()) + self.assertEquals(sample_class.get_object(), a_var.get_object()) def test_list_type_inferencing(self): src = 'class Sample(object):\n pass\na_var = [Sample()]\n' @@ -133,7 +133,7 @@ def test_attributed_object_inference(self): scope = libutils.get_string_scope(self.project, src) sample_class = scope['Sample'].get_object() a_var = sample_class['a_var'].get_object() - self.assertEqual(sample_class, a_var.get_type()) + self.assertEquals(sample_class, a_var.get_type()) def test_getting_property_attributes(self): src = 'class A(object):\n pass\n' \ @@ -143,7 +143,7 @@ def test_getting_property_attributes(self): pymod = libutils.get_string_module(self.project, src) a_class = pymod['A'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(a_class, a_var.get_type()) + self.assertEquals(a_class, a_var.get_type()) def test_getting_property_attributes_with_method_getters(self): src = 'class A(object):\n pass\n' \ @@ -153,7 +153,7 @@ def test_getting_property_attributes_with_method_getters(self): pymod = libutils.get_string_module(self.project, src) a_class = pymod['A'].get_object() a_var = pymod['a_var'].get_object() - self.assertEqual(a_class, a_var.get_type()) + self.assertEquals(a_class, a_var.get_type()) def test_lambda_functions(self): code = 'class C(object):\n pass\n' \ @@ -161,7 +161,7 @@ def test_lambda_functions(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_mixing_subscript_with_tuple_assigns(self): code = 'class C(object):\n attr = 0\n' \ @@ -169,7 +169,7 @@ def test_mixing_subscript_with_tuple_assigns(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['b'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_mixing_ass_attr_with_tuple_assignment(self): code = 'class C(object):\n attr = 0\n' \ @@ -177,7 +177,7 @@ def test_mixing_ass_attr_with_tuple_assignment(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['b'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_mixing_slice_with_tuple_assigns(self): mod = libutils.get_string_module( @@ -186,7 +186,7 @@ def test_mixing_slice_with_tuple_assigns(self): 'd = [None] * 3\nd[0:2], b = ((0,), C())\n') c_class = mod['C'].get_object() a_var = mod['b'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_nested_tuple_assignments(self): mod = libutils.get_string_module( @@ -198,9 +198,9 @@ def test_nested_tuple_assignments(self): a_var = mod['a'].get_object() b_var = mod['b'].get_object() c_var = mod['c'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) - self.assertEqual(c1_class, c_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) + self.assertEquals(c1_class, c_var.get_type()) def test_empty_tuples(self): mod = libutils.get_string_module( @@ -214,7 +214,7 @@ def test_handling_generator_functions(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_handling_generator_functions_for_strs(self): mod = testutils.create_module(self.project, 'mod') @@ -230,7 +230,7 @@ def test_considering_nones_to_be_unknowns(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_basic_list_comprehensions(self): code = 'class C(object):\n pass\n' \ @@ -238,7 +238,7 @@ def test_basic_list_comprehensions(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_basic_generator_expressions(self): code = 'class C(object):\n pass\n' \ @@ -246,7 +246,7 @@ def test_basic_generator_expressions(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_list_comprehensions_and_loop_var(self): code = 'class C(object):\n pass\n' \ @@ -255,7 +255,7 @@ def test_list_comprehensions_and_loop_var(self): mod = libutils.get_string_module(self.project, code) c_class = mod['C'].get_object() a_var = mod['a_var'].get_object() - self.assertEqual(c_class, a_var.get_type()) + self.assertEquals(c_class, a_var.get_type()) def test_list_comprehensions_and_multiple_loop_var(self): code = 'class C1(object):\n pass\n' \ @@ -267,8 +267,8 @@ def test_list_comprehensions_and_multiple_loop_var(self): c2_class = mod['C2'].get_object() a_var = mod['a'].get_object() b_var = mod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_list_comprehensions_and_multiple_iters(self): mod = libutils.get_string_module( @@ -280,8 +280,8 @@ def test_list_comprehensions_and_multiple_iters(self): c2_class = mod['C2'].get_object() a_var = mod['a'].get_object() b_var = mod['b'].get_object() - self.assertEqual(c1_class, a_var.get_type()) - self.assertEqual(c2_class, b_var.get_type()) + self.assertEquals(c1_class, a_var.get_type()) + self.assertEquals(c2_class, b_var.get_type()) def test_we_know_the_type_of_catched_exceptions(self): code = 'class MyError(Exception):\n pass\n' \ @@ -290,7 +290,7 @@ def test_we_know_the_type_of_catched_exceptions(self): mod = libutils.get_string_module(self.project, code) my_error = mod['MyError'].get_object() e_var = mod['e'].get_object() - self.assertEqual(my_error, e_var.get_type()) + self.assertEquals(my_error, e_var.get_type()) def test_we_know_the_type_of_catched_multiple_excepts(self): code = 'class MyError(Exception):\n pass\n' \ @@ -299,7 +299,7 @@ def test_we_know_the_type_of_catched_multiple_excepts(self): mod = libutils.get_string_module(self.project, code) my_error = mod['MyError'].get_object() e_var = mod['e'].get_object() - self.assertEqual(my_error, e_var.get_type()) + self.assertEquals(my_error, e_var.get_type()) def test_using_property_as_decorators(self): code = 'class A(object):\n pass\n' \ @@ -309,7 +309,7 @@ def test_using_property_as_decorators(self): mod = libutils.get_string_module(self.project, code) var = mod['var'].get_object() a = mod['A'].get_object() - self.assertEqual(a, var.get_type()) + self.assertEquals(a, var.get_type()) def test_using_property_as_decorators_and_passing_parameter(self): code = 'class B(object):\n' \ @@ -318,7 +318,7 @@ def test_using_property_as_decorators_and_passing_parameter(self): mod = libutils.get_string_module(self.project, code) var = mod['var'].get_object() a = mod['B'].get_object() - self.assertEqual(a, var.get_type()) + self.assertEquals(a, var.get_type()) def suite(): diff --git a/ropetest/projecttest.py b/ropetest/projecttest.py index 4fa67ed44..7c00f95f8 100644 --- a/ropetest/projecttest.py +++ b/ropetest/projecttest.py @@ -40,7 +40,7 @@ def tearDown(self): unittest.TestCase.tearDown(self) def test_project_creation(self): - self.assertEqual(_realpath(self.project_root), + self.assertEquals(_realpath(self.project_root), self.project.address) def test_getting_project_file(self): @@ -49,7 +49,7 @@ def test_getting_project_file(self): def test_project_file_reading(self): projectFile = self.project.get_resource(self.sample_file) - self.assertEqual('sample text\n', projectFile.read()) + self.assertEquals('sample text\n', projectFile.read()) def test_getting_not_existing_project_file(self): with self.assertRaises(ResourceNotFoundError): @@ -58,7 +58,7 @@ def test_getting_not_existing_project_file(self): def test_writing_in_project_files(self): project_file = self.project.get_resource(self.sample_file) project_file.write('another text\n') - self.assertEqual('another text\n', project_file.read()) + self.assertEquals('another text\n', project_file.read()) def test_creating_files(self): project_file = 'newfile.txt' @@ -114,8 +114,8 @@ def test_creating_file_inside_folder(self): parent_folder.create_file(file_name) file = self.project.get_resource(file_path) file.write('sample notes') - self.assertEqual(file_path, file.path) - self.assertEqual('sample notes', + self.assertEquals(file_path, file.path) + self.assertEquals('sample notes', open(os.path.join(self.project.address, file_path)).read()) @@ -165,31 +165,31 @@ def test_removing_nested_files(self): def test_file_get_name(self): file = self.project.get_resource(self.sample_file) - self.assertEqual(self.sample_file, file.name) + self.assertEquals(self.sample_file, file.name) file_name = 'nestedFile.txt' parent = self.project.get_resource(self.sample_folder) filePath = self.sample_folder + '/' + file_name parent.create_file(file_name) nestedFile = self.project.get_resource(filePath) - self.assertEqual(file_name, nestedFile.name) + self.assertEquals(file_name, nestedFile.name) def test_folder_get_name(self): folder = self.project.get_resource(self.sample_folder) - self.assertEqual(self.sample_folder, folder.name) + self.assertEquals(self.sample_folder, folder.name) def test_file_get_path(self): file = self.project.get_resource(self.sample_file) - self.assertEqual(self.sample_file, file.path) + self.assertEquals(self.sample_file, file.path) fileName = 'nestedFile.txt' parent = self.project.get_resource(self.sample_folder) filePath = self.sample_folder + '/' + fileName parent.create_file(fileName) nestedFile = self.project.get_resource(filePath) - self.assertEqual(filePath, nestedFile.path) + self.assertEquals(filePath, nestedFile.path) def test_folder_get_path(self): folder = self.project.get_resource(self.sample_folder) - self.assertEqual(self.sample_folder, folder.path) + self.assertEquals(self.sample_folder, folder.path) def test_is_folder(self): self.assertTrue(self.project.get_resource( @@ -199,7 +199,7 @@ def test_is_folder(self): def testget_children(self): children = self.project.get_resource(self.sample_folder).get_children() - self.assertEqual([], children) + self.assertEquals([], children) def test_nonempty_get_children(self): file_name = 'nestedfile.txt' @@ -207,8 +207,8 @@ def test_nonempty_get_children(self): parent = self.project.get_resource(self.sample_folder) parent.create_file(file_name) children = parent.get_children() - self.assertEqual(1, len(children)) - self.assertEqual(filePath, children[0].path) + self.assertEquals(1, len(children)) + self.assertEquals(filePath, children[0].path) def test_nonempty_get_children2(self): file_name = 'nestedfile.txt' @@ -219,7 +219,7 @@ def test_nonempty_get_children2(self): parent.create_file(file_name) parent.create_folder(folder_name) children = parent.get_children() - self.assertEqual(2, len(children)) + self.assertEquals(2, len(children)) self.assertTrue(filePath == children[0].path or filePath == children[1].path) self.assertTrue(folderPath == children[0].path or @@ -240,12 +240,12 @@ def test_does_not_fail_for_permission_denied(self): def test_getting_files(self): files = self.project.root.get_files() - self.assertEqual(1, len(files)) + self.assertEquals(1, len(files)) self.assertTrue(self.project.get_resource(self.sample_file) in files) def test_getting_folders(self): folders = self.project.root.get_folders() - self.assertEqual(1, len(folders)) + self.assertEquals(1, len(folders)) self.assertTrue(self.project.get_resource( self.sample_folder) in folders) @@ -254,45 +254,45 @@ def test_nested_folder_get_files(self): parent.create_file('file1.txt') parent.create_file('file2.txt') files = parent.get_files() - self.assertEqual(2, len(files)) + self.assertEquals(2, len(files)) self.assertTrue(self.project.get_resource('top/file2.txt') in files) - self.assertEqual(0, len(parent.get_folders())) + self.assertEquals(0, len(parent.get_folders())) def test_nested_folder_get_folders(self): parent = self.project.root.create_folder('top') parent.create_folder('dir1') parent.create_folder('dir2') folders = parent.get_folders() - self.assertEqual(2, len(folders)) + self.assertEquals(2, len(folders)) self.assertTrue(self.project.get_resource('top/dir1') in folders) - self.assertEqual(0, len(parent.get_files())) + self.assertEquals(0, len(parent.get_files())) def test_root_folder(self): root_folder = self.project.root - self.assertEqual(2, len(root_folder.get_children())) - self.assertEqual('', root_folder.path) - self.assertEqual('', root_folder.name) + self.assertEquals(2, len(root_folder.get_children())) + self.assertEquals('', root_folder.path) + self.assertEquals('', root_folder.name) def test_get_all_files(self): files = tuple(self.project.get_files()) - self.assertEqual(1, len(files)) - self.assertEqual(self.sample_file, files[0].name) + self.assertEquals(1, len(files)) + self.assertEquals(self.sample_file, files[0].name) def test_get_all_files_after_changing(self): - self.assertEqual(1, len(self.project.get_files())) + self.assertEquals(1, len(self.project.get_files())) myfile = self.project.root.create_file('myfile.txt') - self.assertEqual(2, len(self.project.get_files())) + self.assertEquals(2, len(self.project.get_files())) myfile.move('newfile.txt') - self.assertEqual(2, len(self.project.get_files())) + self.assertEquals(2, len(self.project.get_files())) self.project.get_file('newfile.txt').remove() - self.assertEqual(1, len(self.project.get_files())) + self.assertEquals(1, len(self.project.get_files())) def test_multifile_get_all_files(self): fileName = 'nestedFile.txt' parent = self.project.get_resource(self.sample_folder) parent.create_file(fileName) files = list(self.project.get_files()) - self.assertEqual(2, len(files)) + self.assertEquals(2, len(files)) self.assertTrue(fileName == files[0].name or fileName == files[1].name) def test_ignoring_dot_pyc_files_in_get_files(self): @@ -336,9 +336,9 @@ def test_folder_get_child(self): folder = self.project.root folder.create_file('myfile.txt') folder.create_folder('myfolder') - self.assertEqual(self.project.get_resource('myfile.txt'), + self.assertEquals(self.project.get_resource('myfile.txt'), folder.get_child('myfile.txt')) - self.assertEqual(self.project.get_resource('myfolder'), + self.assertEquals(self.project.get_resource('myfolder'), folder.get_child('myfolder')) def test_folder_get_child_nested(self): @@ -346,13 +346,13 @@ def test_folder_get_child_nested(self): folder = root.create_folder('myfolder') folder.create_file('myfile.txt') folder.create_folder('myfolder') - self.assertEqual(self.project.get_resource('myfolder/myfile.txt'), + self.assertEquals(self.project.get_resource('myfolder/myfile.txt'), folder.get_child('myfile.txt')) - self.assertEqual(self.project.get_resource('myfolder/myfolder'), + self.assertEquals(self.project.get_resource('myfolder/myfolder'), folder.get_child('myfolder')) def test_project_root_is_root_folder(self): - self.assertEqual('', self.project.root.path) + self.assertEquals('', self.project.root.path) def test_moving_files(self): root_folder = self.project.root @@ -384,7 +384,7 @@ def test_moving_files_and_resource_objects(self): my_file = root_folder.create_file('my_file.txt') old_hash = hash(my_file) my_file.move('my_other_file.txt') - self.assertEqual(old_hash, hash(my_file)) + self.assertEquals(old_hash, hash(my_file)) def test_file_encoding_reading(self): sample_file = self.project.root.create_file('my_file.txt') @@ -393,20 +393,20 @@ def test_file_encoding_reading(self): file = open(sample_file.real_path, 'wb') file.write(contents.encode('utf-8')) file.close() - self.assertEqual(contents, sample_file.read()) + self.assertEquals(contents, sample_file.read()) def test_file_encoding_writing(self): sample_file = self.project.root.create_file('my_file.txt') contents = (b'# -*- coding: utf-8 -*-\n' + b'\N{LATIN SMALL LETTER I WITH DIAERESIS}\n').decode('utf8') sample_file.write(contents) - self.assertEqual(contents, sample_file.read()) + self.assertEquals(contents, sample_file.read()) def test_using_utf8_when_writing_in_case_of_errors(self): sample_file = self.project.root.create_file('my_file.txt') contents = b'\n\N{LATIN SMALL LETTER I WITH DIAERESIS}\n'.decode('utf8') sample_file.write(contents) - self.assertEqual(contents, sample_file.read()) + self.assertEquals(contents, sample_file.read()) def test_encoding_declaration_in_the_second_line(self): sample_file = self.project.root.create_file('my_file.txt') @@ -414,7 +414,7 @@ def test_encoding_declaration_in_the_second_line(self): file = open(sample_file.real_path, 'wb') file.write(contents) file.close() - self.assertEqual(contents, sample_file.read().encode('latin-1')) + self.assertEquals(contents, sample_file.read().encode('latin-1')) def test_read_bytes(self): sample_file = self.project.root.create_file('my_file.txt') @@ -422,7 +422,7 @@ def test_read_bytes(self): file = open(sample_file.real_path, 'wb') file.write(contents) file.close() - self.assertEqual(contents, sample_file.read_bytes()) + self.assertEquals(contents, sample_file.read_bytes()) # TODO: Detecting utf-16 encoding def xxx_test_using_utf16(self): @@ -432,7 +432,7 @@ def xxx_test_using_utf16(self): file.write(contents.encode('utf-16')) file.close() sample_file.write(contents) - self.assertEqual(contents, sample_file.read()) + self.assertEquals(contents, sample_file.read()) # XXX: supporting utf_8_sig def xxx_test_file_encoding_reading_for_notepad_styles(self): @@ -442,7 +442,7 @@ def xxx_test_file_encoding_reading_for_notepad_styles(self): # file.write('\xef\xbb\xbf') file.write(contents.encode('utf-8-sig')) file.close() - self.assertEqual(contents, sample_file.read()) + self.assertEquals(contents, sample_file.read()) def test_using_project_get_file(self): myfile = self.project.get_file(self.sample_file) @@ -475,14 +475,14 @@ def test_exception_when_parent_does_not_exist(self): def test_simple_path_to_resource(self): myfile = self.project.root.create_file('myfile.txt') - self.assertEqual(myfile, path_to_resource(self.project, + self.assertEquals(myfile, path_to_resource(self.project, myfile.real_path)) - self.assertEqual(myfile, path_to_resource( + self.assertEquals(myfile, path_to_resource( self.project, myfile.real_path, type='file')) myfolder = self.project.root.create_folder('myfolder') - self.assertEqual(myfolder, path_to_resource(self.project, + self.assertEquals(myfolder, path_to_resource(self.project, myfolder.real_path)) - self.assertEqual(myfolder, path_to_resource( + self.assertEquals(myfolder, path_to_resource( self.project, myfolder.real_path, type='folder')) @testutils.skipNotPOSIX() @@ -493,31 +493,31 @@ def test_ignoring_symlinks_inside_project(self): path = os.path.join(self.project.address, 'linkedfile.txt') os.symlink(mod.real_path, path) files = self.project.root.get_files() - self.assertEqual(1, len(files)) + self.assertEquals(1, len(files)) finally: testutils.remove_project(project2) def test_getting_empty_source_folders(self): - self.assertEqual([], self.project.get_source_folders()) + self.assertEquals([], self.project.get_source_folders()) def test_root_source_folder(self): self.project.root.create_file('sample.py') source_folders = self.project.get_source_folders() - self.assertEqual(1, len(source_folders)) + self.assertEquals(1, len(source_folders)) self.assertTrue(self.project.root in source_folders) def test_root_source_folder2(self): self.project.root.create_file('mod1.py') self.project.root.create_file('mod2.py') source_folders = self.project.get_source_folders() - self.assertEqual(1, len(source_folders)) + self.assertEquals(1, len(source_folders)) self.assertTrue(self.project.root in source_folders) def test_src_source_folder(self): src = self.project.root.create_folder('src') src.create_file('sample.py') source_folders = self.project.get_source_folders() - self.assertEqual(1, len(source_folders)) + self.assertEquals(1, len(source_folders)) self.assertTrue(self.project.get_resource('src') in source_folders) def test_packages(self): @@ -525,7 +525,7 @@ def test_packages(self): pkg = src.create_folder('package') pkg.create_file('__init__.py') source_folders = self.project.get_source_folders() - self.assertEqual(1, len(source_folders)) + self.assertEquals(1, len(source_folders)) self.assertTrue(src in source_folders) def test_multi_source_folders(self): @@ -535,7 +535,7 @@ def test_multi_source_folders(self): test = self.project.root.create_folder('test') test.create_file('alltests.py') source_folders = self.project.get_source_folders() - self.assertEqual(2, len(source_folders)) + self.assertEquals(2, len(source_folders)) self.assertTrue(src in source_folders) self.assertTrue(test in source_folders) @@ -545,7 +545,7 @@ def test_multi_source_folders2(self): package = testutils.create_package(self.project, 'package', src) testutils.create_module(self.project, 'mod2', package) source_folders = self.project.get_source_folders() - self.assertEqual(2, len(source_folders)) + self.assertEquals(2, len(source_folders)) self.assertTrue(self.project.root in source_folders and src in source_folders) @@ -566,8 +566,8 @@ def test_resource_change_observer(self): sample_observer = _SampleObserver() self.project.add_observer(sample_observer) sample_file.write('a sample file version 2') - self.assertEqual(1, sample_observer.change_count) - self.assertEqual(sample_file, sample_observer.last_changed) + self.assertEquals(1, sample_observer.change_count) + self.assertEquals(sample_file, sample_observer.last_changed) def test_resource_change_observer_after_removal(self): sample_file = self.project.root.create_file('my_file.txt') @@ -576,8 +576,8 @@ def test_resource_change_observer_after_removal(self): self.project.add_observer(FilteredResourceObserver(sample_observer, [sample_file])) sample_file.remove() - self.assertEqual(1, sample_observer.change_count) - self.assertEqual(sample_file, sample_observer.last_removed) + self.assertEquals(1, sample_observer.change_count) + self.assertEquals(sample_file, sample_observer.last_removed) def test_resource_change_observer2(self): sample_file = self.project.root.create_file('my_file.txt') @@ -585,7 +585,7 @@ def test_resource_change_observer2(self): self.project.add_observer(sample_observer) self.project.remove_observer(sample_observer) sample_file.write('a sample file version 2') - self.assertEqual(0, sample_observer.change_count) + self.assertEquals(0, sample_observer.change_count) def test_resource_change_observer_for_folders(self): root_folder = self.project.root @@ -597,21 +597,21 @@ def test_resource_change_observer_for_folders(self): self.project.add_observer( FilteredResourceObserver(root_folder_observer, [root_folder])) my_file = my_folder.create_file('my_file.txt') - self.assertEqual(1, my_folder_observer.change_count) + self.assertEquals(1, my_folder_observer.change_count) my_file.move('another_file.txt') - self.assertEqual(2, my_folder_observer.change_count) - self.assertEqual(1, root_folder_observer.change_count) + self.assertEquals(2, my_folder_observer.change_count) + self.assertEquals(1, root_folder_observer.change_count) self.project.get_resource('another_file.txt').remove() - self.assertEqual(2, my_folder_observer.change_count) - self.assertEqual(2, root_folder_observer.change_count) + self.assertEquals(2, my_folder_observer.change_count) + self.assertEquals(2, root_folder_observer.change_count) def test_resource_change_observer_after_moving(self): sample_file = self.project.root.create_file('my_file.txt') sample_observer = _SampleObserver() self.project.add_observer(sample_observer) sample_file.move('new_file.txt') - self.assertEqual(1, sample_observer.change_count) - self.assertEqual((sample_file, + self.assertEquals(1, sample_observer.change_count) + self.assertEquals((sample_file, self.project.get_resource('new_file.txt')), sample_observer.last_moved) @@ -623,8 +623,8 @@ def test_revalidating_files(self): [my_file])) os.remove(my_file.real_path) self.project.validate(root) - self.assertEqual(my_file, sample_observer.last_removed) - self.assertEqual(1, sample_observer.change_count) + self.assertEquals(my_file, sample_observer.last_removed) + self.assertEquals(1, sample_observer.change_count) def test_revalidating_files_and_no_changes2(self): root = self.project.root @@ -633,8 +633,8 @@ def test_revalidating_files_and_no_changes2(self): self.project.add_observer(FilteredResourceObserver(sample_observer, [my_file])) self.project.validate(root) - self.assertEqual(None, sample_observer.last_moved) - self.assertEqual(0, sample_observer.change_count) + self.assertEquals(None, sample_observer.last_moved) + self.assertEquals(0, sample_observer.change_count) def test_revalidating_folders(self): root = self.project.root @@ -645,8 +645,8 @@ def test_revalidating_folders(self): [my_folder])) testutils.remove_recursively(my_folder.real_path) self.project.validate(root) - self.assertEqual(my_folder, sample_observer.last_removed) - self.assertEqual(1, sample_observer.change_count) + self.assertEquals(my_folder, sample_observer.last_removed) + self.assertEquals(1, sample_observer.change_count) def test_removing_and_adding_resources_to_filtered_observer(self): my_file = self.project.root.create_file('my_file.txt') @@ -654,13 +654,13 @@ def test_removing_and_adding_resources_to_filtered_observer(self): filtered_observer = FilteredResourceObserver(sample_observer) self.project.add_observer(filtered_observer) my_file.write('1') - self.assertEqual(0, sample_observer.change_count) + self.assertEquals(0, sample_observer.change_count) filtered_observer.add_resource(my_file) my_file.write('2') - self.assertEqual(1, sample_observer.change_count) + self.assertEquals(1, sample_observer.change_count) filtered_observer.remove_resource(my_file) my_file.write('3') - self.assertEqual(1, sample_observer.change_count) + self.assertEquals(1, sample_observer.change_count) def test_validation_and_changing_files(self): my_file = self.project.root.create_file('my_file.txt') @@ -672,7 +672,7 @@ def test_validation_and_changing_files(self): self._write_file(my_file.real_path) timekeeper.set_indicator(my_file, 1) self.project.validate(self.project.root) - self.assertEqual(1, sample_observer.change_count) + self.assertEquals(1, sample_observer.change_count) def test_validation_and_changing_files2(self): my_file = self.project.root.create_file('my_file.txt') @@ -683,9 +683,9 @@ def test_validation_and_changing_files2(self): timekeeper=timekeeper)) timekeeper.set_indicator(my_file, 1) my_file.write('hey') - self.assertEqual(1, sample_observer.change_count) + self.assertEquals(1, sample_observer.change_count) self.project.validate(self.project.root) - self.assertEqual(1, sample_observer.change_count) + self.assertEquals(1, sample_observer.change_count) def test_not_reporting_multiple_changes_to_folders(self): root = self.project.root @@ -696,9 +696,9 @@ def test_not_reporting_multiple_changes_to_folders(self): sample_observer, [root, file1, file2])) os.remove(file1.real_path) os.remove(file2.real_path) - self.assertEqual(0, sample_observer.change_count) + self.assertEquals(0, sample_observer.change_count) self.project.validate(self.project.root) - self.assertEqual(3, sample_observer.change_count) + self.assertEquals(3, sample_observer.change_count) def _write_file(self, path): my_file = open(path, 'w') @@ -713,7 +713,7 @@ def test_moving_and_being_interested_about_a_folder_and_a_child(self): sample_observer, [my_folder, my_file]) self.project.add_observer(filtered_observer) my_folder.move('new_folder') - self.assertEqual(2, sample_observer.change_count) + self.assertEquals(2, sample_observer.change_count) def test_contains_for_folders(self): folder1 = self.project.root.create_folder('folder') @@ -728,8 +728,8 @@ def test_validating_when_created(self): [my_file])) open(my_file.real_path, 'w').close() self.project.validate(root) - self.assertEqual(my_file, sample_observer.last_created) - self.assertEqual(1, sample_observer.change_count) + self.assertEquals(my_file, sample_observer.last_created) + self.assertEquals(1, sample_observer.change_count) def test_validating_twice_when_created(self): root = self.project.root @@ -740,8 +740,8 @@ def test_validating_twice_when_created(self): open(my_file.real_path, 'w').close() self.project.validate(root) self.project.validate(root) - self.assertEqual(my_file, sample_observer.last_created) - self.assertEqual(1, sample_observer.change_count) + self.assertEquals(my_file, sample_observer.last_created) + self.assertEquals(1, sample_observer.change_count) def test_changes_and_adding_resources(self): root = self.project.root # noqa @@ -752,17 +752,17 @@ def test_changes_and_adding_resources(self): self.project.add_observer(FilteredResourceObserver(sample_observer, [file1, file2])) file1.move(file2.path) - self.assertEqual(2, sample_observer.change_count) - self.assertEqual(file2, sample_observer.last_created) - self.assertEqual((file1, file2), sample_observer.last_moved) + self.assertEquals(2, sample_observer.change_count) + self.assertEquals(file2, sample_observer.last_created) + self.assertEquals((file1, file2), sample_observer.last_moved) def test_validating_get_files_list(self): root = self.project.root # noqa - self.assertEqual(0, len(self.project.get_files())) + self.assertEquals(0, len(self.project.get_files())) file = open(os.path.join(self.project.address, 'myfile.txt'), 'w') file.close() self.project.validate() - self.assertEqual(1, len(self.project.get_files())) + self.assertEquals(1, len(self.project.get_files())) def test_clear_observered_resources_for_filtered_observers(self): sample_file = self.project.root.create_file('myfile.txt') @@ -772,7 +772,7 @@ def test_clear_observered_resources_for_filtered_observers(self): filtered.add_resource(sample_file) filtered.clear_resources() sample_file.write('1') - self.assertEqual(0, sample_observer.change_count) + self.assertEquals(0, sample_observer.change_count) class _MockChangeIndicator(object): @@ -834,18 +834,18 @@ def test_simple_out_of_project_file(self): sample_file.write('sample content\n') sample_file.close() sample_resource = self.no_project.get_resource(sample_file_path) - self.assertEqual('sample content\n', sample_resource.read()) + self.assertEquals('sample content\n', sample_resource.read()) def test_simple_out_of_project_folder(self): sample_folder_path = os.path.join(self.test_directory, 'sample_folder') os.mkdir(sample_folder_path) sample_folder = self.no_project.get_resource(sample_folder_path) - self.assertEqual([], sample_folder.get_children()) + self.assertEquals([], sample_folder.get_children()) sample_file_path = os.path.join(sample_folder_path, 'sample.txt') open(sample_file_path, 'w').close() sample_resource = self.no_project.get_resource(sample_file_path) - self.assertEqual(sample_resource, sample_folder.get_children()[0]) + self.assertEquals(sample_resource, sample_folder.get_children()[0]) def test_using_absolute_path(self): sample_file_path = os.path.join(self.test_directory, 'sample.txt') @@ -853,20 +853,20 @@ def test_using_absolute_path(self): normal_sample_resource = self.no_project.get_resource(sample_file_path) absolute_sample_resource = \ self.no_project.get_resource(os.path.abspath(sample_file_path)) - self.assertEqual(normal_sample_resource, absolute_sample_resource) + self.assertEquals(normal_sample_resource, absolute_sample_resource) def test_folder_get_child(self): sample_folder_path = os.path.join(self.test_directory, 'sample_folder') os.mkdir(sample_folder_path) sample_folder = self.no_project.get_resource(sample_folder_path) - self.assertEqual([], sample_folder.get_children()) + self.assertEquals([], sample_folder.get_children()) sample_file_path = os.path.join(sample_folder_path, 'sample.txt') open(sample_file_path, 'w').close() sample_resource = self.no_project.get_resource(sample_file_path) self.assertTrue(sample_folder.has_child('sample.txt')) self.assertFalse(sample_folder.has_child('doesnothave.txt')) - self.assertEqual(sample_resource, + self.assertEquals(sample_resource, sample_folder.get_child('sample.txt')) def test_out_of_project_files_and_path_to_resource(self): @@ -875,7 +875,7 @@ def test_out_of_project_files_and_path_to_resource(self): sample_file.write('sample content\n') sample_file.close() sample_resource = self.no_project.get_resource(sample_file_path) - self.assertEqual(sample_resource, + self.assertEquals(sample_resource, path_to_resource(self.project, sample_file_path)) @@ -940,15 +940,15 @@ def test_ignored_resources_and_get_files(self): self.project = testutils.sample_project( ignored_resources=['myfile.txt'], ropefolder=None) myfile = self.project.get_file('myfile.txt') - self.assertEqual(0, len(self.project.get_files())) + self.assertEquals(0, len(self.project.get_files())) myfile.create() - self.assertEqual(0, len(self.project.get_files())) + self.assertEquals(0, len(self.project.get_files())) def test_ignored_resources_and_get_files2(self): self.project = testutils.sample_project( ignored_resources=['myfile.txt'], ropefolder=None) myfile = self.project.root.create_file('myfile.txt') # noqa - self.assertEqual(0, len(self.project.get_files())) + self.assertEquals(0, len(self.project.get_files())) def test_setting_ignored_resources_patterns(self): self.project = testutils.sample_project(ignored_resources=['m?file.*']) @@ -979,7 +979,7 @@ def test_fscommands_and_ignored_resources(self): ignored_resources=['myfile.txt'], ropefolder=None) myfile = self.project.get_file('myfile.txt') myfile.create() - self.assertEqual('', fscommands.log) + self.assertEquals('', fscommands.log) def test_ignored_resources_and_prefixes(self): self.project = testutils.sample_project( @@ -1022,7 +1022,7 @@ def test_compressed_objectdb(self): def test_nested_dot_ropeproject_folder(self): self.project = testutils.sample_project(ropefolder='.f1/f2') ropefolder = self.project.ropefolder - self.assertEqual('.f1/f2', ropefolder.path) + self.assertEquals('.f1/f2', ropefolder.path) self.assertTrue(ropefolder.exists()) diff --git a/ropetest/pycoretest.py b/ropetest/pycoretest.py index b1969c7b6..b5284a711 100644 --- a/ropetest/pycoretest.py +++ b/ropetest/pycoretest.py @@ -25,37 +25,37 @@ def tearDown(self): def test_simple_module(self): testutils.create_module(self.project, 'mod') result = self.project.get_module('mod') - self.assertEqual(get_base_type('Module'), result.type) - self.assertEqual(0, len(result.get_attributes())) + self.assertEquals(get_base_type('Module'), result.type) + self.assertEquals(0, len(result.get_attributes())) def test_nested_modules(self): pkg = testutils.create_package(self.project, 'pkg') mod = testutils.create_module(self.project, 'mod', pkg) # noqa package = self.project.get_module('pkg') - self.assertEqual(get_base_type('Module'), package.get_type()) - self.assertEqual(1, len(package.get_attributes())) + self.assertEquals(get_base_type('Module'), package.get_type()) + self.assertEquals(1, len(package.get_attributes())) module = package['mod'].get_object() - self.assertEqual(get_base_type('Module'), module.get_type()) + self.assertEquals(get_base_type('Module'), module.get_type()) def test_package(self): pkg = testutils.create_package(self.project, 'pkg') mod = testutils.create_module(self.project, 'mod', pkg) # noqa result = self.project.get_module('pkg') - self.assertEqual(get_base_type('Module'), result.type) + self.assertEquals(get_base_type('Module'), result.type) def test_simple_class(self): mod = testutils.create_module(self.project, 'mod') mod.write('class SampleClass(object):\n pass\n') mod_element = self.project.get_module('mod') result = mod_element['SampleClass'].get_object() - self.assertEqual(get_base_type('Type'), result.get_type()) + self.assertEquals(get_base_type('Type'), result.get_type()) def test_simple_function(self): mod = testutils.create_module(self.project, 'mod') mod.write('def sample_function():\n pass\n') mod_element = self.project.get_module('mod') result = mod_element['sample_function'].get_object() - self.assertEqual(get_base_type('Function'), result.get_type()) + self.assertEquals(get_base_type('Function'), result.get_type()) def test_class_methods(self): mod = testutils.create_module(self.project, 'mod') @@ -67,7 +67,7 @@ def test_class_methods(self): sample_class = mod_element['SampleClass'].get_object() self.assertTrue('sample_method' in sample_class) method = sample_class['sample_method'].get_object() - self.assertEqual(get_base_type('Function'), method.get_type()) + self.assertEquals(get_base_type('Function'), method.get_type()) def test_global_variables(self): mod = testutils.create_module(self.project, 'mod') @@ -112,7 +112,7 @@ def test_classes_inside_other_classes(self): mod_element = self.project.get_module('mod') sample_class = mod_element['SampleClass'].get_object() var = sample_class['InnerClass'].get_object() - self.assertEqual(get_base_type('Type'), var.get_type()) + self.assertEquals(get_base_type('Type'), var.get_type()) def test_non_existent_module(self): with self.assertRaises(exceptions.ModuleNotFoundError): @@ -124,7 +124,7 @@ def test_imported_names(self): mod.write('import mod1\n') module = self.project.get_module('mod2') imported_sys = module['mod1'].get_object() - self.assertEqual(get_base_type('Module'), imported_sys.get_type()) + self.assertEquals(get_base_type('Module'), imported_sys.get_type()) def test_imported_as_names(self): testutils.create_module(self.project, 'mod1') @@ -132,13 +132,13 @@ def test_imported_as_names(self): mod.write('import mod1 as my_import\n') module = self.project.get_module('mod2') imported_mod = module['my_import'].get_object() - self.assertEqual(get_base_type('Module'), imported_mod.get_type()) + self.assertEquals(get_base_type('Module'), imported_mod.get_type()) def test_get_string_module(self): mod = libutils.get_string_module( self.project, 'class Sample(object):\n pass\n') sample_class = mod['Sample'].get_object() - self.assertEqual(get_base_type('Type'), sample_class.get_type()) + self.assertEquals(get_base_type('Type'), sample_class.get_type()) def test_get_string_module_with_extra_spaces(self): mod = libutils.get_string_module( @@ -148,14 +148,14 @@ def test_parameter_info_for_functions(self): code = 'def func(param1, param2=10, *param3, **param4):\n pass' mod = libutils.get_string_module(self.project, code) sample_function = mod['func'] - self.assertEqual(['param1', 'param2', 'param3', 'param4'], + self.assertEquals(['param1', 'param2', 'param3', 'param4'], sample_function.get_object().get_param_names()) # FIXME: Not found modules def xxx_test_not_found_module_is_module(self): mod = libutils.get_string_module( self.project, 'import doesnotexist\n') - self.assertEqual(get_base_type('Module'), + self.assertEquals(get_base_type('Module'), mod['doesnotexist']. get_object().get_type()) @@ -173,7 +173,7 @@ def test_inheriting_base_class_attributes(self): mod = libutils.get_string_module(self.project, code) derived = mod['Derived'].get_object() self.assertTrue('method' in derived) - self.assertEqual(get_base_type('Function'), + self.assertEquals(get_base_type('Function'), derived['method'].get_object().get_type()) def test_inheriting_multiple_base_class_attributes(self): @@ -192,7 +192,7 @@ def test_inherit_multiple_base_class_attrs_with_the_same_name(self): mod = libutils.get_string_module(self.project, code) base1 = mod['Base1'].get_object() derived = mod['Derived'].get_object() - self.assertEqual(base1['method'].get_object(), + self.assertEquals(base1['method'].get_object(), derived['method'].get_object()) def test_inheriting_unknown_base_class(self): @@ -206,32 +206,32 @@ def test_inheriting_unknown_base_class(self): def test_module_creation(self): new_module = testutils.create_module(self.project, 'module') self.assertFalse(new_module.is_folder()) - self.assertEqual(self.project.get_resource('module.py'), new_module) + self.assertEquals(self.project.get_resource('module.py'), new_module) def test_packaged_module_creation(self): package = self.project.root.create_folder('package') # noqa new_module = testutils.create_module(self.project, 'package.module') - self.assertEqual(self.project.get_resource('package/module.py'), + self.assertEquals(self.project.get_resource('package/module.py'), new_module) def test_packaged_module_creation_with_nested_src(self): src = self.project.root.create_folder('src') src.create_folder('pkg') new_module = testutils.create_module(self.project, 'pkg.mod', src) - self.assertEqual(self.project.get_resource('src/pkg/mod.py'), + self.assertEquals(self.project.get_resource('src/pkg/mod.py'), new_module) def test_package_creation(self): new_package = testutils.create_package(self.project, 'pkg') self.assertTrue(new_package.is_folder()) - self.assertEqual(self.project.get_resource('pkg'), new_package) - self.assertEqual(self.project.get_resource('pkg/__init__.py'), + self.assertEquals(self.project.get_resource('pkg'), new_package) + self.assertEquals(self.project.get_resource('pkg/__init__.py'), new_package.get_child('__init__.py')) def test_nested_package_creation(self): testutils.create_package(self.project, 'pkg1') nested_package = testutils.create_package(self.project, 'pkg1.pkg2') - self.assertEqual(self.project.get_resource('pkg1/pkg2'), + self.assertEquals(self.project.get_resource('pkg1/pkg2'), nested_package) def test_packaged_package_creation_with_nested_src(self): @@ -239,14 +239,14 @@ def test_packaged_package_creation_with_nested_src(self): testutils.create_package(self.project, 'pkg1', src) nested_package = testutils.create_package(self.project, 'pkg1.pkg2', src) - self.assertEqual(self.project.get_resource('src/pkg1/pkg2'), + self.assertEquals(self.project.get_resource('src/pkg1/pkg2'), nested_package) def test_find_module(self): src = self.project.root.create_folder('src') samplemod = testutils.create_module(self.project, 'samplemod', src) found_module = self.project.find_module('samplemod') - self.assertEqual(samplemod, found_module) + self.assertEquals(samplemod, found_module) def test_find_nested_module(self): src = self.project.root.create_folder('src') @@ -254,7 +254,7 @@ def test_find_nested_module(self): samplemod = testutils.create_module(self.project, 'samplemod', samplepkg) found_module = self.project.find_module('samplepkg.samplemod') - self.assertEqual(samplemod, found_module) + self.assertEquals(samplemod, found_module) def test_find_multiple_module(self): src = self.project.root.create_folder('src') @@ -271,14 +271,14 @@ def test_find_module_packages(self): src = self.project.root samplepkg = testutils.create_package(self.project, 'samplepkg', src) found_module = self.project.find_module('samplepkg') - self.assertEqual(samplepkg, found_module) + self.assertEquals(samplepkg, found_module) def test_find_module_when_module_and_package_with_the_same_name(self): src = self.project.root testutils.create_module(self.project, 'sample', src) samplepkg = testutils.create_package(self.project, 'sample', src) found_module = self.project.find_module('sample') - self.assertEqual(samplepkg, found_module) + self.assertEquals(samplepkg, found_module) def test_source_folders_preference(self): testutils.create_package(self.project, 'pkg1') @@ -294,39 +294,39 @@ def test_source_folders_preference(self): def test_get_pyname_definition_location(self): mod = libutils.get_string_module(self.project, 'a_var = 20\n') a_var = mod['a_var'] - self.assertEqual((mod, 1), a_var.get_definition_location()) + self.assertEquals((mod, 1), a_var.get_definition_location()) def test_get_pyname_definition_location_functions(self): mod = libutils.get_string_module( self.project, 'def a_func():\n pass\n') a_func = mod['a_func'] - self.assertEqual((mod, 1), a_func.get_definition_location()) + self.assertEquals((mod, 1), a_func.get_definition_location()) def test_get_pyname_definition_location_class(self): code = 'class AClass(object):\n pass\n\n' mod = libutils.get_string_module(self.project, code) a_class = mod['AClass'] - self.assertEqual((mod, 1), a_class.get_definition_location()) + self.assertEquals((mod, 1), a_class.get_definition_location()) def test_get_pyname_definition_location_local_variables(self): mod = libutils.get_string_module( self.project, 'def a_func():\n a_var = 10\n') a_func_scope = mod.get_scope().get_scopes()[0] a_var = a_func_scope['a_var'] - self.assertEqual((mod, 2), a_var.get_definition_location()) + self.assertEquals((mod, 2), a_var.get_definition_location()) def test_get_pyname_definition_location_reassigning(self): mod = libutils.get_string_module( self.project, 'a_var = 20\na_var=30\n') a_var = mod['a_var'] - self.assertEqual((mod, 1), a_var.get_definition_location()) + self.assertEquals((mod, 1), a_var.get_definition_location()) def test_get_pyname_definition_location_importes(self): testutils.create_module(self.project, 'mod') mod = libutils.get_string_module(self.project, 'import mod\n') imported_module = self.project.get_module('mod') module_pyname = mod['mod'] - self.assertEqual((imported_module, 1), + self.assertEquals((imported_module, 1), module_pyname.get_definition_location()) def test_get_pyname_definition_location_imports(self): @@ -336,7 +336,7 @@ def test_get_pyname_definition_location_imports(self): mod = libutils.get_string_module( self.project, 'from mod import a_func\n') a_func = mod['a_func'] - self.assertEqual((imported_module, 2), + self.assertEquals((imported_module, 2), a_func.get_definition_location()) def test_get_pyname_definition_location_parameters(self): @@ -344,17 +344,17 @@ def test_get_pyname_definition_location_parameters(self): mod = libutils.get_string_module(self.project, code) a_func_scope = mod.get_scope().get_scopes()[0] param1 = a_func_scope['param1'] - self.assertEqual((mod, 1), param1.get_definition_location()) + self.assertEquals((mod, 1), param1.get_definition_location()) param2 = a_func_scope['param2'] - self.assertEqual((mod, 1), param2.get_definition_location()) + self.assertEquals((mod, 1), param2.get_definition_location()) def test_module_get_resource(self): module_resource = testutils.create_module(self.project, 'mod') module = self.project.get_module('mod') - self.assertEqual(module_resource, module.get_resource()) + self.assertEquals(module_resource, module.get_resource()) string_module = libutils.get_string_module( self.project, 'from mod import a_func\n') - self.assertEqual(None, string_module.get_resource()) + self.assertEquals(None, string_module.get_resource()) def test_get_pyname_definition_location_class2(self): code = 'class AClass(object):\n' \ @@ -363,20 +363,20 @@ def test_get_pyname_definition_location_class2(self): mod = libutils.get_string_module(self.project, code) a_class = mod['AClass'].get_object() an_attr = a_class['an_attr'] - self.assertEqual((mod, 3), an_attr.get_definition_location()) + self.assertEquals((mod, 3), an_attr.get_definition_location()) def test_import_not_found_module_get_definition_location(self): mod = libutils.get_string_module( self.project, 'import doesnotexist\n') does_not_exist = mod['doesnotexist'] - self.assertEqual((None, None), + self.assertEquals((None, None), does_not_exist.get_definition_location()) def test_from_not_found_module_get_definition_location(self): mod = libutils.get_string_module( self.project, 'from doesnotexist import Sample\n') sample = mod['Sample'] - self.assertEqual((None, None), sample.get_definition_location()) + self.assertEquals((None, None), sample.get_definition_location()) def test_from_package_import_module_get_definition_location(self): pkg = testutils.create_package(self.project, 'pkg') @@ -385,21 +385,21 @@ def test_from_package_import_module_get_definition_location(self): mod = libutils.get_string_module( self.project, 'from pkg import mod\n') imported_mod = mod['mod'] - self.assertEqual((pkg_mod, 1), + self.assertEquals((pkg_mod, 1), imported_mod.get_definition_location()) def test_get_module_for_defined_pyobjects(self): mod = libutils.get_string_module( self.project, 'class AClass(object):\n pass\n') a_class = mod['AClass'].get_object() - self.assertEqual(mod, a_class.get_module()) + self.assertEquals(mod, a_class.get_module()) def test_get_definition_location_for_packages(self): testutils.create_package(self.project, 'pkg') init_module = self.project.get_module('pkg.__init__') mod = libutils.get_string_module(self.project, 'import pkg\n') pkg_pyname = mod['pkg'] - self.assertEqual((init_module, 1), + self.assertEquals((init_module, 1), pkg_pyname.get_definition_location()) def test_get_definition_location_for_filtered_packages(self): @@ -408,7 +408,7 @@ def test_get_definition_location_for_filtered_packages(self): init_module = self.project.get_module('pkg.__init__') mod = libutils.get_string_module(self.project, 'import pkg.mod') pkg_pyname = mod['pkg'] - self.assertEqual((init_module, 1), + self.assertEquals((init_module, 1), pkg_pyname.get_definition_location()) def test_out_of_project_modules(self): @@ -430,7 +430,7 @@ def test_global_keyword(self): global_var = mod['a_var'] func_scope = mod['a_func'].get_object().get_scope() local_var = func_scope['a_var'] - self.assertEqual(global_var, local_var) + self.assertEquals(global_var, local_var) def test_not_leaking_for_vars_inside_parent_scope(self): mod = testutils.create_module(self.project, 'mod') @@ -516,7 +516,7 @@ def test_with_statement_variable_type(self): pymod = libutils.get_string_module(self.project, code) a_class = pymod['A'].get_object() var = pymod['var'].get_object() - self.assertEqual(a_class, var.get_type()) + self.assertEquals(a_class, var.get_type()) @testutils.only_for('2.5') def test_nested_with_statement_variable_type(self): @@ -558,21 +558,21 @@ def test_check_for_else_block(self): ' myvar = 1\n' mod = libutils.get_string_module(self.project, code) a_var = mod['myvar'] - self.assertEqual((mod, 4), a_var.get_definition_location()) + self.assertEquals((mod, 4), a_var.get_definition_location()) def test_check_names_defined_in_whiles(self): mod = libutils.get_string_module( self.project, 'while False:\n myvar = 1\n') a_var = mod['myvar'] - self.assertEqual((mod, 2), a_var.get_definition_location()) + self.assertEquals((mod, 2), a_var.get_definition_location()) def test_get_definition_location_in_tuple_assnames(self): mod = libutils.get_string_module( self.project, 'def f(x):\n x.z, a = range(2)\n') x = mod['f'].get_object().get_scope()['x'] a = mod['f'].get_object().get_scope()['a'] - self.assertEqual((mod, 1), x.get_definition_location()) - self.assertEqual((mod, 2), a.get_definition_location()) + self.assertEquals((mod, 1), x.get_definition_location()) + self.assertEquals((mod, 2), a.get_definition_location()) def test_syntax_errors_in_code(self): with self.assertRaises(exceptions.ModuleSyntaxError): @@ -582,7 +582,7 @@ def test_holding_error_location_information(self): try: libutils.get_string_module(self.project, 'xyx print\n') except exceptions.ModuleSyntaxError as e: - self.assertEqual(1, e.lineno) + self.assertEquals(1, e.lineno) def test_no_exceptions_on_module_encoding_problems(self): mod = testutils.create_module(self.project, 'mod') @@ -645,7 +645,7 @@ def test_pyobject_equality_should_compare_types(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write('var1 = ""\nvar2 = ""\n') pymod1 = self.pycore.resource_to_pyobject(mod1) - self.assertEqual(pymod1['var1'].get_object(), + self.assertEquals(pymod1['var1'].get_object(), pymod1['var2'].get_object()) @@ -676,21 +676,21 @@ def test_simple_import(self): mod = libutils.get_string_module( self.project, 'import samplemod\n') samplemod = mod['samplemod'].get_object() - self.assertEqual(get_base_type('Module'), samplemod.get_type()) + self.assertEquals(get_base_type('Module'), samplemod.get_type()) def test_from_import_class(self): mod = libutils.get_string_module( self.project, 'from samplemod import SampleClass\n') result = mod['SampleClass'].get_object() - self.assertEqual(get_base_type('Type'), result.get_type()) + self.assertEquals(get_base_type('Type'), result.get_type()) self.assertTrue('sample_func' not in mod.get_attributes()) def test_from_import_star(self): mod = libutils.get_string_module( self.project, 'from samplemod import *\n') - self.assertEqual(get_base_type('Type'), + self.assertEquals(get_base_type('Type'), mod['SampleClass'].get_object().get_type()) - self.assertEqual(get_base_type('Function'), + self.assertEquals(get_base_type('Function'), mod['sample_func'].get_object().get_type()) self.assertTrue(mod['sample_var'] is not None) @@ -716,7 +716,7 @@ def test_from_import_star_imports_in_functions(self): def test_from_package_import_mod(self): mod = libutils.get_string_module( self.project, 'from package import nestedmod\n') - self.assertEqual(get_base_type('Module'), + self.assertEquals(get_base_type('Module'), mod['nestedmod'].get_object().get_type()) # XXX: Deciding to import everything on import start from packages @@ -733,7 +733,7 @@ def test_unknown_when_module_cannot_be_found(self): def test_from_import_function(self): code = 'def f():\n from samplemod import SampleClass\n' scope = libutils.get_string_scope(self.project, code) - self.assertEqual(get_base_type('Type'), + self.assertEquals(get_base_type('Type'), scope.get_scopes()[0]['SampleClass']. get_object().get_type()) @@ -769,7 +769,7 @@ def test_multi_dot_imports2(self): mod = libutils.get_string_module( self.project, 'import pkg.mod1\nimport pkg.mod2\n') package = mod['pkg'].get_object() - self.assertEqual(2, len(package.get_attributes())) + self.assertEquals(2, len(package.get_attributes())) self.assertTrue('mod1' in package and 'mod2' in package) @@ -782,7 +782,7 @@ def test_multi_dot_imports3(self): mod = libutils.get_string_module(self.project, code) package1 = mod['pkg1'].get_object() package2 = package1['pkg2'].get_object() - self.assertEqual(2, len(package2.get_attributes())) + self.assertEquals(2, len(package2.get_attributes())) self.assertTrue('mod1' in package2 and 'mod2' in package2) def test_multi_dot_imports_as(self): @@ -802,7 +802,7 @@ def xxx_test_from_package_import_package(self): mod = libutils.get_string_module( self.project, 'from pkg1 import pkg2\n') package = mod['pkg2'] - self.assertEqual(0, len(package.get_attributes())) + self.assertEquals(0, len(package.get_attributes())) def test_invalidating_cache_after_resource_change(self): module = testutils.create_module(self.project, 'mod') @@ -843,7 +843,7 @@ def test_from_import_nonexistent_module(self): code = 'from doesnotexistmod import DoesNotExistClass\n' mod = libutils.get_string_module(self.project, code) self.assertTrue('DoesNotExistClass' in mod) - self.assertEqual(get_base_type('Unknown'), + self.assertEquals(get_base_type('Unknown'), mod['DoesNotExistClass']. get_object().get_type()) @@ -851,19 +851,19 @@ def test_from_import_nonexistent_name(self): code = 'from samplemod import DoesNotExistClass\n' mod = libutils.get_string_module(self.project, code) self.assertTrue('DoesNotExistClass' in mod) - self.assertEqual(get_base_type('Unknown'), + self.assertEquals(get_base_type('Unknown'), mod['DoesNotExistClass']. get_object().get_type()) def test_not_considering_imported_names_as_sub_scopes(self): code = 'from samplemod import SampleClass\n' scope = libutils.get_string_scope(self.project, code) - self.assertEqual(0, len(scope.get_scopes())) + self.assertEquals(0, len(scope.get_scopes())) def test_not_considering_imported_modules_as_sub_scopes(self): scope = libutils.get_string_scope( self.project, 'import samplemod\n') - self.assertEqual(0, len(scope.get_scopes())) + self.assertEquals(0, len(scope.get_scopes())) def test_inheriting_dotted_base_class(self): code = 'import samplemod\n' \ @@ -880,7 +880,7 @@ def test_self_in_methods(self): scope = libutils.get_string_scope(self.project, code) sample_class = scope['Sample'].get_object() func_scope = scope.get_scopes()[0].get_scopes()[0] - self.assertEqual(sample_class, + self.assertEquals(sample_class, func_scope['self'].get_object().get_type()) self.assertTrue('func' in func_scope['self'].get_object()) @@ -911,7 +911,7 @@ def test_location_of_imports_when_importing(self): self.project, 'from mod import SampleClass\n') sample_class = scope['SampleClass'] samplemod = self.project.get_module('samplemod') - self.assertEqual((samplemod, 1), + self.assertEquals((samplemod, 1), sample_class.get_definition_location()) def test_nested_modules(self): @@ -920,7 +920,7 @@ def test_nested_modules(self): imported_module = self.project.get_module('pkg.mod') scope = libutils.get_string_scope(self.project, 'import pkg.mod\n') mod_pyobject = scope['pkg'].get_object()['mod'] - self.assertEqual((imported_module, 1), + self.assertEquals((imported_module, 1), mod_pyobject.get_definition_location()) def test_reading_init_dot_py(self): @@ -937,7 +937,7 @@ def test_relative_imports(self): mod2.write('import mod1\n') mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = self.pycore.resource_to_pyobject(mod2) - self.assertEqual(mod1_object, + self.assertEquals(mod1_object, mod2_object.get_attributes()['mod1'].get_object()) def test_relative_froms(self): @@ -948,7 +948,7 @@ def test_relative_froms(self): mod2.write('from mod1 import a_func\n') mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = self.pycore.resource_to_pyobject(mod2) - self.assertEqual(mod1_object['a_func'].get_object(), + self.assertEquals(mod1_object['a_func'].get_object(), mod2_object['a_func'].get_object()) def test_relative_imports_for_string_modules(self): @@ -959,7 +959,7 @@ def test_relative_imports_for_string_modules(self): mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = libutils.get_string_module( self.project, mod2.read(), mod2) - self.assertEqual(mod1_object, mod2_object['mod1'].get_object()) + self.assertEquals(mod1_object, mod2_object['mod1'].get_object()) def test_relative_imports_for_string_scopes(self): pkg = testutils.create_package(self.project, 'pkg') @@ -969,7 +969,7 @@ def test_relative_imports_for_string_scopes(self): mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_scope = libutils.get_string_scope(self.project, mod2.read(), mod2) - self.assertEqual(mod1_object, mod2_scope['mod1'].get_object()) + self.assertEquals(mod1_object, mod2_scope['mod1'].get_object()) @testutils.only_for('2.5') def test_new_style_relative_imports(self): @@ -979,7 +979,7 @@ def test_new_style_relative_imports(self): mod2.write('from . import mod1\n') mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = self.pycore.resource_to_pyobject(mod2) - self.assertEqual(mod1_object, mod2_object['mod1'].get_object()) + self.assertEquals(mod1_object, mod2_object['mod1'].get_object()) @testutils.only_for('2.5') def test_new_style_relative_imports2(self): @@ -990,7 +990,7 @@ def test_new_style_relative_imports2(self): mod2.write('from ..mod1 import a_func\n') mod1_object = self.pycore.resource_to_pyobject(mod1) mod2_object = self.pycore.resource_to_pyobject(mod2) - self.assertEqual(mod1_object['a_func'].get_object(), + self.assertEquals(mod1_object['a_func'].get_object(), mod2_object['a_func'].get_object()) def test_invalidating_cache_for_from_imports_after_resource_change(self): @@ -1001,11 +1001,11 @@ def test_invalidating_cache_for_from_imports_after_resource_change(self): pymod1 = self.project.get_module('mod1') pymod2 = self.project.get_module('mod2') - self.assertEqual(pymod1['a_func'].get_object(), + self.assertEquals(pymod1['a_func'].get_object(), pymod2['a_func'].get_object()) mod2.write(mod2.read() + '\n') pymod2 = self.project.get_module('mod2') - self.assertEqual(pymod1['a_func'].get_object(), + self.assertEquals(pymod1['a_func'].get_object(), pymod2['a_func'].get_object()) def test_invalidating_superclasses_after_change(self): diff --git a/ropetest/pyscopestest.py b/ropetest/pyscopestest.py index a3fb2823b..00c5582cc 100644 --- a/ropetest/pyscopestest.py +++ b/ropetest/pyscopestest.py @@ -20,24 +20,24 @@ def test_simple_scope(self): scope = libutils.get_string_scope( self.project, 'def sample_func():\n pass\n') sample_func = scope['sample_func'].get_object() - self.assertEqual(get_base_type('Function'), sample_func.get_type()) + self.assertEquals(get_base_type('Function'), sample_func.get_type()) def test_simple_function_scope(self): scope = libutils.get_string_scope( self.project, 'def sample_func():\n a = 10\n') - self.assertEqual(1, len(scope.get_scopes())) + self.assertEquals(1, len(scope.get_scopes())) sample_func_scope = scope.get_scopes()[0] - self.assertEqual(1, len(sample_func_scope.get_names())) - self.assertEqual(0, len(sample_func_scope.get_scopes())) + self.assertEquals(1, len(sample_func_scope.get_names())) + self.assertEquals(0, len(sample_func_scope.get_scopes())) def test_classes_inside_function_scopes(self): scope = libutils.get_string_scope( self.project, 'def sample_func():\n' ' class SampleClass(object):\n pass\n') - self.assertEqual(1, len(scope.get_scopes())) + self.assertEquals(1, len(scope.get_scopes())) sample_func_scope = scope.get_scopes()[0] # noqa - self.assertEqual(get_base_type('Type'), + self.assertEquals(get_base_type('Type'), scope.get_scopes()[0]['SampleClass']. get_object().get_type()) @@ -46,20 +46,20 @@ def test_simple_class_scope(self): self.project, 'class SampleClass(object):\n' ' def f(self):\n var = 10\n') - self.assertEqual(1, len(scope.get_scopes())) + self.assertEquals(1, len(scope.get_scopes())) sample_class_scope = scope.get_scopes()[0] self.assertTrue('f' in sample_class_scope) - self.assertEqual(1, len(sample_class_scope.get_scopes())) + self.assertEquals(1, len(sample_class_scope.get_scopes())) f_in_class = sample_class_scope.get_scopes()[0] self.assertTrue('var' in f_in_class) def test_get_lineno(self): scope = libutils.get_string_scope( self.project, '\ndef sample_func():\n a = 10\n') - self.assertEqual(1, len(scope.get_scopes())) + self.assertEquals(1, len(scope.get_scopes())) sample_func_scope = scope.get_scopes()[0] - self.assertEqual(1, scope.get_start()) - self.assertEqual(2, sample_func_scope.get_start()) + self.assertEquals(1, scope.get_start()) + self.assertEquals(2, sample_func_scope.get_start()) def test_scope_kind(self): scope = libutils.get_string_scope( @@ -68,9 +68,9 @@ def test_scope_kind(self): 'def sample_func():\n pass\n') sample_class_scope = scope.get_scopes()[0] sample_func_scope = scope.get_scopes()[1] - self.assertEqual('Module', scope.get_kind()) - self.assertEqual('Class', sample_class_scope.get_kind()) - self.assertEqual('Function', sample_func_scope.get_kind()) + self.assertEquals('Module', scope.get_kind()) + self.assertEquals('Class', sample_class_scope.get_kind()) + self.assertEquals('Function', sample_func_scope.get_kind()) def test_function_parameters_in_scope_names(self): scope = libutils.get_string_scope( @@ -90,7 +90,7 @@ def test_scope_lookup(self): self.project, 'var1 = 10\ndef sample_func(param):\n var2 = 20\n') self.assertTrue(scope.lookup('var2') is None) - self.assertEqual(get_base_type('Function'), + self.assertEquals(get_base_type('Function'), scope.lookup('sample_func').get_object().get_type()) sample_func_scope = scope.get_scopes()[0] self.assertTrue(sample_func_scope.lookup('var1') is not None) @@ -138,7 +138,7 @@ def test_first_parameter_of_a_method(self): a_class = libutils.get_string_module(self.project, code)['AClass'].\ get_object() function_scope = a_class['a_func'].get_object().get_scope() - self.assertEqual(a_class, + self.assertEquals(a_class, function_scope['self'].get_object().get_type()) self.assertNotEquals(a_class, function_scope['param']. get_object().get_type()) @@ -159,7 +159,7 @@ def test_first_parameter_of_class_methods(self): a_class = libutils.get_string_module(self.project, code)['AClass'].\ get_object() function_scope = a_class['a_func'].get_object().get_scope() - self.assertEqual(a_class, function_scope['cls'].get_object()) + self.assertEquals(a_class, function_scope['cls'].get_object()) def test_first_parameter_with_self_as_name_and_unknown_decorator(self): code = 'def my_decorator(func):\n return func\n'\ @@ -168,7 +168,7 @@ def test_first_parameter_with_self_as_name_and_unknown_decorator(self): a_class = libutils.get_string_module(self.project, code)['AClass'].\ get_object() function_scope = a_class['a_func'].get_object().get_scope() - self.assertEqual(a_class, function_scope['self']. + self.assertEquals(a_class, function_scope['self']. get_object().get_type()) def test_inside_class_scope_attribute_lookup(self): @@ -177,7 +177,7 @@ def test_inside_class_scope_attribute_lookup(self): 'class C(object):\n' ' an_attr = 1\n' ' def a_func(self):\n pass') - self.assertEqual(1, len(scope.get_scopes())) + self.assertEquals(1, len(scope.get_scopes())) c_scope = scope.get_scopes()[0] self.assertTrue('an_attr'in c_scope.get_names()) self.assertTrue(c_scope.lookup('an_attr') is not None) @@ -190,7 +190,7 @@ def test_inside_class_scope_attribute_lookup2(self): 'class C(object):\n' ' def __init__(self):\n self.an_attr = 1\n' ' def a_func(self):\n pass') - self.assertEqual(1, len(scope.get_scopes())) + self.assertEquals(1, len(scope.get_scopes())) c_scope = scope.get_scopes()[0] f_in_c = c_scope.get_scopes()[0] self.assertTrue(f_in_c.lookup('an_attr') is None) @@ -203,12 +203,12 @@ def test_get_inner_scope_for_staticmethods(self): ' def a_func(self):\n pass\n') c_scope = scope.get_scopes()[0] f_in_c = c_scope.get_scopes()[0] - self.assertEqual(f_in_c, scope.get_inner_scope_for_line(4)) + self.assertEquals(f_in_c, scope.get_inner_scope_for_line(4)) def test_getting_overwritten_scopes(self): scope = libutils.get_string_scope( self.project, 'def f():\n pass\ndef f():\n pass\n') - self.assertEqual(2, len(scope.get_scopes())) + self.assertEquals(2, len(scope.get_scopes())) f1_scope = scope.get_scopes()[0] f2_scope = scope.get_scopes()[1] self.assertNotEquals(f1_scope, f2_scope) @@ -216,7 +216,7 @@ def test_getting_overwritten_scopes(self): def test_assigning_builtin_names(self): mod = libutils.get_string_module(self.project, 'range = 1\n') range = mod.get_scope().lookup('range') - self.assertEqual((mod, 1), range.get_definition_location()) + self.assertEquals((mod, 1), range.get_definition_location()) def test_get_inner_scope_and_logical_lines(self): scope = libutils.get_string_scope( @@ -225,7 +225,7 @@ def test_get_inner_scope_and_logical_lines(self): ' def f():\n s = """\n1\n2\n"""\n a = 1\n') c_scope = scope.get_scopes()[0] f_in_c = c_scope.get_scopes()[0] - self.assertEqual(f_in_c, scope.get_inner_scope_for_line(7)) + self.assertEquals(f_in_c, scope.get_inner_scope_for_line(7)) def test_getting_defined_names_for_classes(self): scope = libutils.get_string_scope( diff --git a/ropetest/refactor/__init__.py b/ropetest/refactor/__init__.py index 4dacd142e..ab9152926 100644 --- a/ropetest/refactor/__init__.py +++ b/ropetest/refactor/__init__.py @@ -40,7 +40,7 @@ def test_empty_method(self): code = 'def func():\n pass\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEqual( + self.assertEquals( 'class _New(object):\n\n def __call__(self):\n pass\n', replacer.get_new_class('_New')) @@ -48,7 +48,7 @@ def test_trivial_return(self): code = 'def func():\n return 1\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEqual( + self.assertEquals( 'class _New(object):\n\n def __call__(self):' '\n return 1\n', replacer.get_new_class('_New')) @@ -57,7 +57,7 @@ def test_multi_line_header(self): code = 'def func(\n ):\n return 1\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEqual( + self.assertEquals( 'class _New(object):\n\n def __call__(self):' '\n return 1\n', replacer.get_new_class('_New')) @@ -66,7 +66,7 @@ def test_a_single_parameter(self): code = 'def func(param):\n return 1\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEqual( + self.assertEquals( 'class _New(object):\n\n' ' def __init__(self, param):\n self.param = param\n\n' ' def __call__(self):\n return 1\n', @@ -76,7 +76,7 @@ def test_self_parameter(self): code = 'def func(self):\n return 1\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEqual( + self.assertEquals( 'class _New(object):\n\n' ' def __init__(self, host):\n self.self = host\n\n' ' def __call__(self):\n return 1\n', @@ -86,7 +86,7 @@ def test_simple_using_passed_parameters(self): code = 'def func(param):\n return param\n' self.mod.write(code) replacer = MethodObject(self.project, self.mod, code.index('func')) - self.assertEqual( + self.assertEquals( 'class _New(object):\n\n' ' def __init__(self, param):\n self.param = param\n\n' ' def __call__(self):\n return self.param\n', @@ -107,7 +107,7 @@ def test_self_keywords_and_args_parameters(self): ' result = self.arg + ' \ 'self.args[0] + self.kwds[self.arg]\n' \ ' return result\n' - self.assertEqual(expected, replacer.get_new_class('_New')) + self.assertEquals(expected, replacer.get_new_class('_New')) def test_performing_on_not_a_function(self): code = 'my_var = 10\n' @@ -125,7 +125,7 @@ def test_changing_the_module(self): 'class _New(object):\n\n' \ ' def __call__(self):\n' \ ' return 1\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_changing_the_module_and_class_methods(self): code = 'class C(object):\n\n' \ @@ -146,7 +146,7 @@ def test_changing_the_module_and_class_methods(self): ' self.self = host\n\n' \ ' def __call__(self):\n' \ ' return 1\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) class IntroduceFactoryTest(unittest.TestCase): @@ -176,7 +176,7 @@ def test_adding_the_method(self): ' def create(*args, **kwds):\n' \ ' return AClass(*args, **kwds)\n' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create') - self.assertEqual(expected, mod.read()) + self.assertEquals(expected, mod.read()) def test_changing_occurances_in_the_main_module(self): code = 'class AClass(object):\n' \ @@ -191,7 +191,7 @@ def test_changing_occurances_in_the_main_module(self): ' return AClass(*args, **kwds)\n'\ 'a_var = AClass.create()' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create') - self.assertEqual(expected, mod.read()) + self.assertEquals(expected, mod.read()) def test_changing_occurances_with_arguments(self): code = 'class AClass(object):\n' \ @@ -208,7 +208,7 @@ def test_changing_occurances_with_arguments(self): ' return AClass(*args, **kwds)\n' \ 'a_var = AClass.create(10)\n' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create') - self.assertEqual(expected, mod.read()) + self.assertEquals(expected, mod.read()) def test_changing_occurances_in_other_modules(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -224,8 +224,8 @@ def test_changing_occurances_in_other_modules(self): ' return AClass(*args, **kwds)\n' expected2 = 'import mod1\n' \ 'a_var = mod1.AClass.create()\n' - self.assertEqual(expected1, mod1.read()) - self.assertEqual(expected2, mod2.read()) + self.assertEquals(expected1, mod1.read()) + self.assertEquals(expected2, mod2.read()) def test_raising_exception_for_non_classes(self): mod = testutils.create_module(self.project, 'mod') @@ -244,8 +244,8 @@ def test_undoing_introduce_factory(self): self._introduce_factory(mod1, mod1.read().index('AClass') + 1, 'create') self.project.history.undo() - self.assertEqual(code1, mod1.read()) - self.assertEqual(code2, mod2.read()) + self.assertEquals(code1, mod1.read()) + self.assertEquals(code2, mod2.read()) def test_using_on_an_occurance_outside_the_main_module(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -261,8 +261,8 @@ def test_using_on_an_occurance_outside_the_main_module(self): ' return AClass(*args, **kwds)\n' expected2 = 'import mod1\n' \ 'a_var = mod1.AClass.create()\n' - self.assertEqual(expected1, mod1.read()) - self.assertEqual(expected2, mod2.read()) + self.assertEquals(expected1, mod1.read()) + self.assertEquals(expected2, mod2.read()) def test_introduce_factory_in_nested_scopes(self): code = 'def create_var():\n'\ @@ -279,7 +279,7 @@ def test_introduce_factory_in_nested_scopes(self): ' return AClass(*args, **kwds)\n'\ ' return AClass.create()\n' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create') - self.assertEqual(expected, mod.read()) + self.assertEquals(expected, mod.read()) def test_adding_factory_for_global_factories(self): code = 'class AClass(object):\n an_attr = 10\n' @@ -291,7 +291,7 @@ def test_adding_factory_for_global_factories(self): ' return AClass(*args, **kwds)\n' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create', global_factory=True) - self.assertEqual(expected, mod.read()) + self.assertEquals(expected, mod.read()) def test_get_name_for_factories(self): code = 'class C(object):\n pass\n' @@ -299,7 +299,7 @@ def test_get_name_for_factories(self): mod.write(code) factory = IntroduceFactory(self.project, mod, mod.read().index('C') + 1) - self.assertEqual('C', factory.get_name()) + self.assertEquals('C', factory.get_name()) def test_raising_exception_for_global_factory_for_nested_classes(self): code = 'def create_var():\n'\ @@ -324,7 +324,7 @@ def test_changing_occurances_in_the_main_module_for_global_factories(self): 'a_var = create()' self._introduce_factory(mod, mod.read().index('AClass') + 1, 'create', global_factory=True) - self.assertEqual(expected, mod.read()) + self.assertEquals(expected, mod.read()) def test_changing_occurances_in_other_modules_for_global_factories(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -339,8 +339,8 @@ def test_changing_occurances_in_other_modules_for_global_factories(self): ' return AClass(*args, **kwds)\n' expected2 = 'import mod1\n' \ 'a_var = mod1.create()\n' - self.assertEqual(expected1, mod1.read()) - self.assertEqual(expected2, mod2.read()) + self.assertEquals(expected1, mod1.read()) + self.assertEquals(expected2, mod2.read()) def test_import_if_necessary_in_other_mods_for_global_factories(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -355,8 +355,8 @@ def test_import_if_necessary_in_other_mods_for_global_factories(self): ' return AClass(*args, **kwds)\n' expected2 = 'from mod1 import AClass, create\n' \ 'pair = create(), AClass\n' - self.assertEqual(expected1, mod1.read()) - self.assertEqual(expected2, mod2.read()) + self.assertEquals(expected1, mod1.read()) + self.assertEquals(expected2, mod2.read()) def test_changing_occurances_for_renamed_classes(self): code = 'class AClass(object):\n an_attr = 10' \ @@ -371,7 +371,7 @@ def test_changing_occurances_for_renamed_classes(self): 'a_class = AClass\n' \ 'a_var = a_class()' self._introduce_factory(mod, mod.read().index('a_class') + 1, 'create') - self.assertEqual(expected, mod.read()) + self.assertEquals(expected, mod.read()) def test_changing_occurrs_in_the_same_module_with_conflict_ranges(self): mod = testutils.create_module(self.project, 'mod') @@ -398,7 +398,7 @@ def test_transform_module_to_package(self): mod2 = self.project.get_resource('mod2') root_folder = self.project.root self.assertFalse(root_folder.has_child('mod2.py')) - self.assertEqual('class AClass(object):\n pass\n', + self.assertEquals('class AClass(object):\n pass\n', root_folder.get_child('mod2'). get_child('__init__.py').read()) @@ -420,7 +420,7 @@ def test_transform_module_to_package_with_relative_imports(self): mod2.write('class AClass(object):\n pass\n') self._transform_module_to_package(mod1) new_init = self.project.get_resource('pkg/mod1/__init__.py') - self.assertEqual('import pkg.mod2\nfrom pkg.mod2 import AClass\n', + self.assertEquals('import pkg.mod2\nfrom pkg.mod2 import AClass\n', new_init.read()) def test_resources_parameter(self): @@ -437,8 +437,8 @@ def test_resources_parameter(self): ' return A(*args, **kwds)\n' self._introduce_factory(mod, mod.read().index('A') + 1, 'create', resources=[mod]) - self.assertEqual(expected, mod.read()) - self.assertEqual(code1, mod1.read()) + self.assertEquals(expected, mod.read()) + self.assertEquals(code1, mod1.read()) class EncapsulateFieldTest(unittest.TestCase): @@ -472,7 +472,7 @@ def test_adding_getters_and_setters(self): code = self.a_class self.mod.write(code) self._encapsulate(self.mod, code.index('attr') + 1) - self.assertEqual(self.encapsulated, self.mod.read()) + self.assertEquals(self.encapsulated, self.mod.read()) def test_changing_getters_in_other_modules(self): code = 'import mod\n' \ @@ -484,7 +484,7 @@ def test_changing_getters_in_other_modules(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'range(a_var.get_attr())\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_changing_setters_in_other_modules(self): code = 'import mod\n' \ @@ -496,7 +496,7 @@ def test_changing_setters_in_other_modules(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'a_var.set_attr(1)\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_changing_getters_in_setters(self): code = 'import mod\n' \ @@ -508,12 +508,12 @@ def test_changing_getters_in_setters(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'a_var.set_attr(1 + a_var.get_attr())\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_appending_to_class_end(self): self.mod1.write(self.a_class + 'a_var = A()\n') self._encapsulate(self.mod1, self.mod1.read().index('attr') + 1) - self.assertEqual(self.encapsulated + 'a_var = A()\n', + self.assertEquals(self.encapsulated + 'a_var = A()\n', self.mod1.read()) def test_performing_in_other_modules(self): @@ -523,11 +523,11 @@ def test_performing_in_other_modules(self): self.mod1.write(code) self.mod.write(self.a_class) self._encapsulate(self.mod1, self.mod1.read().index('attr') + 1) - self.assertEqual(self.encapsulated, self.mod.read()) + self.assertEquals(self.encapsulated, self.mod.read()) expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'range(a_var.get_attr())\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_changing_main_module_occurances(self): code = self.a_class + \ @@ -538,7 +538,7 @@ def test_changing_main_module_occurances(self): expected = self.encapsulated + \ 'a_var = A()\n' \ 'a_var.set_attr(a_var.get_attr() * 2)\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_raising_exception_when_performed_on_non_attributes(self): self.mod1.write('attr = 10') @@ -579,7 +579,7 @@ def test_tuple_assignments_and_function_calls(self): ' pass\n' \ 'a_var = mod.A()\n' \ 'func(a_var.get_attr(), a2=2)\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_tuple_assignments(self): code = 'import mod\n' \ @@ -591,7 +591,7 @@ def test_tuple_assignments(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'a, b = a_var.get_attr(), 1\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_changing_augmented_assignments(self): code = 'import mod\n' \ @@ -603,7 +603,7 @@ def test_changing_augmented_assignments(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'a_var.set_attr(a_var.get_attr() + 1)\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_changing_augmented_assignments2(self): code = 'import mod\n' \ @@ -615,7 +615,7 @@ def test_changing_augmented_assignments2(self): expected = 'import mod\n' \ 'a_var = mod.A()\n' \ 'a_var.set_attr(a_var.get_attr() << 1)\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_changing_occurrences_inside_the_class(self): new_class = self.a_class + '\n' \ @@ -627,7 +627,7 @@ def test_changing_occurrences_inside_the_class(self): ' def a_func(self):\n' \ ' self.set_attr(1)\n' + \ self.added_methods - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_getter_and_setter_parameters(self): self.mod.write(self.a_class) @@ -636,17 +636,17 @@ def test_getter_and_setter_parameters(self): new_methods = self.added_methods.replace('get_attr', 'getAttr').\ replace('set_attr', 'setAttr') expected = self.a_class + new_methods - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_using_resources_parameter(self): self.mod1.write('import mod\na = mod.A()\nvar = a.attr\n') self.mod.write(self.a_class) self._encapsulate(self.mod, self.mod.read().index('attr') + 1, resources=[self.mod]) - self.assertEqual('import mod\na = mod.A()\nvar = a.attr\n', + self.assertEquals('import mod\na = mod.A()\nvar = a.attr\n', self.mod1.read()) expected = self.a_class + self.added_methods - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) class LocalToFieldTest(unittest.TestCase): @@ -676,7 +676,7 @@ def test_simple_local_to_field(self): expected = 'class A(object):\n' \ ' def a_func(self):\n' \ ' self.var = 10\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_raising_exception_when_performed_on_a_global_var(self): self.mod.write('var = 10\n') @@ -723,7 +723,7 @@ def test_local_to_field_with_self_renamed(self): expected = 'class A(object):\n' \ ' def a_func(myself):\n' \ ' myself.var = 10\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) class IntroduceParameterTest(unittest.TestCase): @@ -752,7 +752,7 @@ def test_simple_case(self): expected = 'var = 1\n' \ 'def f(var=var):\n' \ ' b = var\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_changing_function_body(self): code = 'var = 1\n' \ @@ -764,14 +764,14 @@ def test_changing_function_body(self): expected = 'var = 1\n' \ 'def f(p1=var):\n' \ ' b = p1\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_unknown_variables(self): self.mod.write('def f():\n b = var + c\n') offset = self.mod.read().rindex('var') with self.assertRaises(RefactoringError): self._introduce_parameter(offset, 'p1') - self.assertEqual('def f(p1=var):\n b = p1 + c\n', + self.assertEquals('def f(p1=var):\n b = p1 + c\n', self.mod.read()) def test_failing_when_not_inside(self): @@ -793,7 +793,7 @@ def test_attribute_accesses(self): 'c = C()\n' \ 'def f(p1=c.a):\n' \ ' b = p1\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_introducing_parameters_for_methods(self): code = 'var = 1\n' \ @@ -807,7 +807,7 @@ def test_introducing_parameters_for_methods(self): 'class C(object):\n' \ ' def f(self, p1=var):\n' \ ' b = p1\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) class _MockTaskObserver(object): @@ -833,7 +833,7 @@ def test_stopping(self): def test_job_sets(self): handle = rope.base.taskhandle.TaskHandle() jobs = handle.create_jobset() - self.assertEqual([jobs], handle.get_jobsets()) + self.assertEquals([jobs], handle.get_jobsets()) def test_starting_and_finishing_jobs(self): handle = rope.base.taskhandle.TaskHandle() @@ -860,14 +860,14 @@ def test_calling_the_observer_after_stopping(self): observer = _MockTaskObserver() handle.add_observer(observer) handle.stop() - self.assertEqual(1, observer.called) + self.assertEquals(1, observer.called) def test_calling_the_observer_after_creating_job_sets(self): handle = rope.base.taskhandle.TaskHandle() observer = _MockTaskObserver() handle.add_observer(observer) jobs = handle.create_jobset() # noqa - self.assertEqual(1, observer.called) + self.assertEquals(1, observer.called) def test_calling_the_observer_when_starting_and_finishing_jobs(self): handle = rope.base.taskhandle.TaskHandle() @@ -876,26 +876,26 @@ def test_calling_the_observer_when_starting_and_finishing_jobs(self): jobs = handle.create_jobset(name='test job set', count=1) jobs.started_job('job1') jobs.finished_job() - self.assertEqual(3, observer.called) + self.assertEquals(3, observer.called) def test_job_set_get_percent_done(self): handle = rope.base.taskhandle.TaskHandle() jobs = handle.create_jobset(name='test job set', count=2) - self.assertEqual(0, jobs.get_percent_done()) + self.assertEquals(0, jobs.get_percent_done()) jobs.started_job('job1') jobs.finished_job() - self.assertEqual(50, jobs.get_percent_done()) + self.assertEquals(50, jobs.get_percent_done()) jobs.started_job('job2') jobs.finished_job() - self.assertEqual(100, jobs.get_percent_done()) + self.assertEquals(100, jobs.get_percent_done()) def test_getting_job_name(self): handle = rope.base.taskhandle.TaskHandle() jobs = handle.create_jobset(name='test job set', count=1) - self.assertEqual('test job set', jobs.get_name()) - self.assertEqual(None, jobs.get_active_job_name()) + self.assertEquals('test job set', jobs.get_name()) + self.assertEquals(None, jobs.get_active_job_name()) jobs.started_job('job1') - self.assertEqual('job1', jobs.get_active_job_name()) + self.assertEquals('job1', jobs.get_active_job_name()) def suite(): diff --git a/ropetest/refactor/change_signature_test.py b/ropetest/refactor/change_signature_test.py index dd29955c8..944ffb548 100644 --- a/ropetest/refactor/change_signature_test.py +++ b/ropetest/refactor/change_signature_test.py @@ -27,7 +27,7 @@ def test_normalizing_parameters_for_trivial_case(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEqual(code, self.mod.read()) + self.assertEquals(code, self.mod.read()) def test_normalizing_parameters_for_trivial_case2(self): code = 'def a_func(param):\n pass\na_func(2)' @@ -36,7 +36,7 @@ def test_normalizing_parameters_for_trivial_case2(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEqual(code, self.mod.read()) + self.assertEquals(code, self.mod.read()) def test_normalizing_parameters_for_unneeded_keyword(self): self.mod.write('def a_func(param):\n pass\na_func(param=1)') @@ -44,7 +44,7 @@ def test_normalizing_parameters_for_unneeded_keyword(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEqual('def a_func(param):\n pass\na_func(1)', + self.assertEquals('def a_func(param):\n pass\na_func(1)', self.mod.read()) def test_normalizing_parameters_for_unneeded_keyword_for_methods(self): @@ -63,7 +63,7 @@ def test_normalizing_parameters_for_unneeded_keyword_for_methods(self): ' pass\n' \ 'a_var = A()\n' \ 'a_var.a_func(1)\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_normalizing_parameters_for_unsorted_keyword(self): self.mod.write('def a_func(p1, p2):\n pass\na_func(p2=2, p1=1)') @@ -71,7 +71,7 @@ def test_normalizing_parameters_for_unsorted_keyword(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEqual('def a_func(p1, p2):\n pass\na_func(1, 2)', + self.assertEquals('def a_func(p1, p2):\n pass\na_func(1, 2)', self.mod.read()) def test_raising_exceptions_for_non_functions(self): @@ -86,7 +86,7 @@ def test_normalizing_parameters_for_args_parameter(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEqual('def a_func(*arg):\n pass\na_func(1, 2)\n', + self.assertEquals('def a_func(*arg):\n pass\na_func(1, 2)\n', self.mod.read()) def test_normalizing_parameters_for_args_parameter_and_keywords(self): @@ -96,7 +96,7 @@ def test_normalizing_parameters_for_args_parameter_and_keywords(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEqual('def a_func(param, *args):\n pass\n' + self.assertEquals('def a_func(param, *args):\n pass\n' 'a_func(*[1, 2, 3])\n', self.mod.read()) def test_normalizing_functions_from_other_modules(self): @@ -107,7 +107,7 @@ def test_normalizing_functions_from_other_modules(self): self.project, mod1, mod1.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEqual('import mod1\nmod1.a_func(1)\n', self.mod.read()) + self.assertEquals('import mod1\nmod1.a_func(1)\n', self.mod.read()) def test_normalizing_parameters_for_keyword_parameters(self): self.mod.write('def a_func(p1, **kwds):\n pass\n' @@ -116,7 +116,7 @@ def test_normalizing_parameters_for_keyword_parameters(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEqual('def a_func(p1, **kwds):\n pass\n' + self.assertEquals('def a_func(p1, **kwds):\n pass\n' 'a_func(1, p2=2)\n', self.mod.read()) def test_removing_arguments(self): @@ -125,7 +125,7 @@ def test_removing_arguments(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(0)])) - self.assertEqual('def a_func():\n pass\na_func()\n', + self.assertEquals('def a_func():\n pass\na_func()\n', self.mod.read()) def test_removing_arguments_with_multiple_args(self): @@ -134,7 +134,7 @@ def test_removing_arguments_with_multiple_args(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(0)])) - self.assertEqual('def a_func(p2):\n pass\na_func(2)\n', + self.assertEquals('def a_func(p2):\n pass\na_func(2)\n', self.mod.read()) def test_removing_arguments_passed_as_keywords(self): @@ -143,7 +143,7 @@ def test_removing_arguments_passed_as_keywords(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(0)])) - self.assertEqual('def a_func():\n pass\na_func()\n', + self.assertEquals('def a_func():\n pass\na_func()\n', self.mod.read()) def test_removing_arguments_with_defaults(self): @@ -152,7 +152,7 @@ def test_removing_arguments_with_defaults(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(0)])) - self.assertEqual('def a_func():\n pass\na_func()\n', + self.assertEquals('def a_func():\n pass\na_func()\n', self.mod.read()) def test_removing_arguments_star_args(self): @@ -161,7 +161,7 @@ def test_removing_arguments_star_args(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(1)])) - self.assertEqual('def a_func(p1):\n pass\na_func(1)\n', + self.assertEquals('def a_func(p1):\n pass\na_func(1)\n', self.mod.read()) def test_removing_keyword_arg(self): @@ -170,7 +170,7 @@ def test_removing_keyword_arg(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(1)])) - self.assertEqual('def a_func(p1):\n pass\na_func(1)\n', + self.assertEquals('def a_func(p1):\n pass\na_func(1)\n', self.mod.read()) def test_removing_keyword_arg2(self): @@ -179,7 +179,7 @@ def test_removing_keyword_arg2(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(2)])) - self.assertEqual('def a_func(p1, *args):\n pass\na_func(1)\n', + self.assertEquals('def a_func(p1, *args):\n pass\na_func(1)\n', self.mod.read()) # XXX: What to do here for star args? @@ -191,7 +191,7 @@ def xxx_test_removing_arguments_star_args2(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(1)])) - self.assertEqual('def a_func(p1):\n pass\na_func(p1=1)\n', + self.assertEquals('def a_func(p1):\n pass\na_func(p1=1)\n', self.mod.read()) # XXX: What to do here for star args? @@ -202,7 +202,7 @@ def xxx_test_removing_arguments_star_args3(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(1)])) - self.assertEqual('def a_func(p1):\n pass\na_func(*[1, 2, 3])\n', + self.assertEquals('def a_func(p1):\n pass\na_func(*[1, 2, 3])\n', self.mod.read()) def test_adding_arguments_for_normal_args_changing_definition(self): @@ -211,7 +211,7 @@ def test_adding_arguments_for_normal_args_changing_definition(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentAdder(0, 'p1')])) - self.assertEqual('def a_func(p1):\n pass\n', self.mod.read()) + self.assertEquals('def a_func(p1):\n pass\n', self.mod.read()) def test_adding_arguments_for_normal_args_with_defaults(self): self.mod.write('def a_func():\n pass\na_func()\n') @@ -219,7 +219,7 @@ def test_adding_arguments_for_normal_args_with_defaults(self): self.project, self.mod, self.mod.read().index('a_func') + 1) adder = change_signature.ArgumentAdder(0, 'p1', 'None') self.project.do(signature.get_changes([adder])) - self.assertEqual('def a_func(p1=None):\n pass\na_func()\n', + self.assertEquals('def a_func(p1=None):\n pass\na_func()\n', self.mod.read()) def test_adding_arguments_for_normal_args_changing_calls(self): @@ -228,7 +228,7 @@ def test_adding_arguments_for_normal_args_changing_calls(self): self.project, self.mod, self.mod.read().index('a_func') + 1) adder = change_signature.ArgumentAdder(0, 'p1', 'None', '1') self.project.do(signature.get_changes([adder])) - self.assertEqual('def a_func(p1=None):\n pass\na_func(1)\n', + self.assertEquals('def a_func(p1=None):\n pass\na_func(1)\n', self.mod.read()) def test_adding_arguments_for_norm_args_chang_calls_with_kwords(self): @@ -237,7 +237,7 @@ def test_adding_arguments_for_norm_args_chang_calls_with_kwords(self): self.project, self.mod, self.mod.read().index('a_func') + 1) adder = change_signature.ArgumentAdder(1, 'p2', '0', '1') self.project.do(signature.get_changes([adder])) - self.assertEqual('def a_func(p1=0, p2=0):\n pass\na_func(p2=1)\n', + self.assertEquals('def a_func(p1=0, p2=0):\n pass\na_func(p2=1)\n', self.mod.read()) def test_adding_arguments_for_norm_args_chang_calls_with_no_value(self): @@ -246,7 +246,7 @@ def test_adding_arguments_for_norm_args_chang_calls_with_no_value(self): self.project, self.mod, self.mod.read().index('a_func') + 1) adder = change_signature.ArgumentAdder(0, 'p1', '0', None) self.project.do(signature.get_changes([adder])) - self.assertEqual('def a_func(p1=0, p2=0):\n pass\na_func(p2=1)\n', + self.assertEquals('def a_func(p1=0, p2=0):\n pass\na_func(p2=1)\n', self.mod.read()) def test_adding_duplicate_parameter_and_raising_exceptions(self): @@ -263,7 +263,7 @@ def test_inlining_default_arguments(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentDefaultInliner(0)])) - self.assertEqual('def a_func(p1=0):\n pass\n' + self.assertEquals('def a_func(p1=0):\n pass\n' 'a_func(0)\n', self.mod.read()) def test_inlining_default_arguments2(self): @@ -272,7 +272,7 @@ def test_inlining_default_arguments2(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentDefaultInliner(0)])) - self.assertEqual('def a_func(p1=0):\n pass\n' + self.assertEquals('def a_func(p1=0):\n pass\n' 'a_func(1)\n', self.mod.read()) def test_preserving_args_and_keywords_order(self): @@ -282,7 +282,7 @@ def test_preserving_args_and_keywords_order(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentNormalizer()])) - self.assertEqual('def a_func(*args, **kwds):\n pass\n' + self.assertEquals('def a_func(*args, **kwds):\n pass\n' 'a_func(3, 1, 2, a=1, c=3, b=2)\n', self.mod.read()) def test_change_order_for_only_one_parameter(self): @@ -291,7 +291,7 @@ def test_change_order_for_only_one_parameter(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentReorderer([0])])) - self.assertEqual('def a_func(p1):\n pass\na_func(1)\n', + self.assertEquals('def a_func(p1):\n pass\na_func(1)\n', self.mod.read()) def test_change_order_for_two_parameter(self): @@ -300,7 +300,7 @@ def test_change_order_for_two_parameter(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentReorderer([1, 0])])) - self.assertEqual('def a_func(p2, p1):\n pass\na_func(2, 1)\n', + self.assertEquals('def a_func(p2, p1):\n pass\na_func(2, 1)\n', self.mod.read()) def test_reordering_multi_line_function_headers(self): @@ -309,7 +309,7 @@ def test_reordering_multi_line_function_headers(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentReorderer([1, 0])])) - self.assertEqual('def a_func(p2, p1):\n pass\na_func(2, 1)\n', + self.assertEquals('def a_func(p2, p1):\n pass\na_func(2, 1)\n', self.mod.read()) def test_changing_order_with_static_params(self): @@ -318,7 +318,7 @@ def test_changing_order_with_static_params(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentReorderer([0, 2, 1])])) - self.assertEqual('def a_func(p1, p3=0, p2=0):\n pass\n' + self.assertEquals('def a_func(p1, p3=0, p2=0):\n pass\n' 'a_func(1, p2=2)\n', self.mod.read()) def test_doing_multiple_changes(self): @@ -329,7 +329,7 @@ def test_doing_multiple_changes(self): signature = change_signature.ChangeSignature( self.project, self.mod, self.mod.read().index('a_func') + 1) signature.get_changes(changers).do() - self.assertEqual('def a_func(p2):\n pass\na_func()\n', + self.assertEquals('def a_func(p2):\n pass\na_func()\n', self.mod.read()) def test_doing_multiple_changes2(self): @@ -341,7 +341,7 @@ def test_doing_multiple_changes2(self): signature = change_signature.ChangeSignature( self.project, self.mod, self.mod.read().index('a_func') + 1) signature.get_changes(changers).do() - self.assertEqual('def a_func(p2, p3):\n pass\na_func(2, 3)\n', + self.assertEquals('def a_func(p2, p3):\n pass\na_func(2, 3)\n', self.mod.read()) def test_changing_signature_in_subclasses(self): @@ -352,7 +352,7 @@ def test_changing_signature_in_subclasses(self): self.project, self.mod, self.mod.read().index('a_method') + 1) signature.get_changes([change_signature.ArgumentAdder(1, 'p1')], in_hierarchy=True).do() - self.assertEqual( + self.assertEquals( 'class A(object):\n def a_method(self, p1):\n pass\n' 'class B(A):\n def a_method(self, p1):\n pass\n', self.mod.read()) @@ -365,7 +365,7 @@ def test_differentiating_class_accesses_from_instance_accesses(self): self.project, self.mod, self.mod.read().index('a_func') + 1) self.project.do(signature.get_changes( [change_signature.ArgumentRemover(1)])) - self.assertEqual( + self.assertEquals( 'class A(object):\n def a_func(self):\n pass\n' 'a_var = A()\nA.a_func(a_var)', self.mod.read()) @@ -376,7 +376,7 @@ def test_changing_signature_for_constructors(self): signature = change_signature.ChangeSignature( self.project, self.mod, self.mod.read().index('C') + 1) signature.get_changes([change_signature.ArgumentRemover(1)]).do() - self.assertEqual( + self.assertEquals( 'class C(object):\n def __init__(self):\n pass\n' 'c = C()\n', self.mod.read()) @@ -388,7 +388,7 @@ def test_changing_signature_for_constructors2(self): signature = change_signature.ChangeSignature( self.project, self.mod, self.mod.read().index('__init__') + 1) signature.get_changes([change_signature.ArgumentRemover(1)]).do() - self.assertEqual( + self.assertEquals( 'class C(object):\n def __init__(self):\n pass\n' 'c = C()\n', self.mod.read()) @@ -401,7 +401,7 @@ def test_changing_signature_for_constructors_when_using_super(self): signature = change_signature.ChangeSignature( self.project, self.mod, self.mod.read().index('__init__') + 1) signature.get_changes([change_signature.ArgumentRemover(1)]).do() - self.assertEqual( + self.assertEquals( 'class A(object):\n def __init__(self):\n pass\n' 'class B(A):\n ' 'def __init__(self, p):\n super(B, self).__init__()\n', @@ -413,7 +413,7 @@ def test_redordering_arguments_reported_by_mft(self): self.project, self.mod, self.mod.read().rindex('f')) signature.get_changes( [change_signature.ArgumentReorderer([1, 2, 0])]).do() - self.assertEqual('def f(b, c, a):\n pass\nf(2, 3, 1)\n', + self.assertEquals('def f(b, c, a):\n pass\nf(2, 3, 1)\n', self.mod.read()) def test_resources_parameter(self): @@ -424,8 +424,8 @@ def test_resources_parameter(self): self.project, mod1, mod1.read().index('a_func') + 1) signature.get_changes([change_signature.ArgumentRemover(0)], resources=[mod1]).do() - self.assertEqual('import mod1\nmod1.a_func(1)\n', self.mod.read()) - self.assertEqual('def a_func():\n pass\n', mod1.read()) + self.assertEquals('import mod1\nmod1.a_func(1)\n', self.mod.read()) + self.assertEquals('def a_func():\n pass\n', mod1.read()) def test_reordering_and_automatic_defaults(self): code = 'def f(p1, p2=2):\n' \ @@ -439,7 +439,7 @@ def test_reordering_and_automatic_defaults(self): expected = 'def f(p2=2, p1=1):\n' \ ' pass\n' \ 'f(2, 1)\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) if __name__ == '__main__': diff --git a/ropetest/refactor/extracttest.py b/ropetest/refactor/extracttest.py index 104cad66a..de48b3895 100644 --- a/ropetest/refactor/extracttest.py +++ b/ropetest/refactor/extracttest.py @@ -45,7 +45,7 @@ def test_simple_extract_function(self): refactored = self.do_extract_method(code, start, end, 'extracted') expected = "def a_func():\n extracted()\n print('two')\n\n" \ "def extracted():\n print('one')\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_function_at_the_end_of_file(self): code = "def a_func():\n print('one')" @@ -53,7 +53,7 @@ def test_extract_function_at_the_end_of_file(self): refactored = self.do_extract_method(code, start, end, 'extracted') expected = "def a_func():\n extracted()\n" \ "def extracted():\n print('one')\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_function_after_scope(self): code = "def a_func():\n print('one')\n print('two')" \ @@ -62,7 +62,7 @@ def test_extract_function_after_scope(self): refactored = self.do_extract_method(code, start, end, 'extracted') expected = "def a_func():\n extracted()\n print('two')\n\n" \ "def extracted():\n print('one')\n\nprint('hey')\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_simple_extract_function_with_parameter(self): code = "def a_func():\n a_var = 10\n print(a_var)\n" @@ -70,7 +70,7 @@ def test_simple_extract_function_with_parameter(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = "def a_func():\n a_var = 10\n new_func(a_var)\n\n" \ "def new_func(a_var):\n print(a_var)\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_not_unread_variables_as_parameter(self): code = "def a_func():\n a_var = 10\n print('hey')\n" @@ -78,7 +78,7 @@ def test_not_unread_variables_as_parameter(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = "def a_func():\n a_var = 10\n new_func()\n\n" \ "def new_func():\n print('hey')\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_simple_extract_function_with_two_parameter(self): code = 'def a_func():\n a_var = 10\n another_var = 20\n' \ @@ -89,7 +89,7 @@ def test_simple_extract_function_with_two_parameter(self): ' new_func(a_var, another_var)\n\n' \ 'def new_func(a_var, another_var):\n' \ ' third_var = a_var + another_var\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_simple_extract_function_with_return_value(self): code = 'def a_func():\n a_var = 10\n print(a_var)\n' @@ -98,7 +98,7 @@ def test_simple_extract_function_with_return_value(self): expected = 'def a_func():\n a_var = new_func()' \ '\n print(a_var)\n\n' \ 'def new_func():\n a_var = 10\n return a_var\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_function_with_multiple_return_values(self): code = 'def a_func():\n a_var = 10\n another_var = 20\n' \ @@ -109,7 +109,7 @@ def test_extract_function_with_multiple_return_values(self): ' third_var = a_var + another_var\n\n' \ 'def new_func():\n a_var = 10\n another_var = 20\n' \ ' return a_var, another_var\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_simple_extract_method(self): code = 'class AClass(object):\n\n' \ @@ -121,7 +121,7 @@ def test_simple_extract_method(self): ' self.new_func()\n' \ ' print(2)\n\n' \ ' def new_func(self):\n print(1)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_with_args_and_returns(self): code = 'class AClass(object):\n' \ @@ -139,7 +139,7 @@ def test_extract_method_with_args_and_returns(self): ' def new_func(self, a_var):\n' \ ' another_var = a_var * 3\n' \ ' return another_var\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_with_self_as_argument(self): code = 'class AClass(object):\n' \ @@ -152,7 +152,7 @@ def test_extract_method_with_self_as_argument(self): ' self.new_func()\n\n' \ ' def new_func(self):\n' \ ' print(self)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_with_no_self_as_argument(self): code = 'class AClass(object):\n' \ @@ -177,7 +177,7 @@ def test_extract_method_with_multiple_methods(self): ' print(self)\n\n' \ ' def another_func(self):\n' \ ' pass\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_function_with_function_returns(self): code = 'def a_func():\n def inner_func():\n pass\n' \ @@ -189,7 +189,7 @@ def test_extract_function_with_function_returns(self): 'def new_func():\n' \ ' def inner_func():\n pass\n' \ ' return inner_func\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_simple_extract_global_function(self): code = "print('one')\nprint('two')\nprint('three')\n" @@ -197,7 +197,7 @@ def test_simple_extract_global_function(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = "print('one')\n\ndef new_func():\n print('two')\n" \ "\nnew_func()\nprint('three')\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_global_function_inside_ifs(self): code = 'if True:\n a = 10\n' @@ -205,7 +205,7 @@ def test_extract_global_function_inside_ifs(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = '\ndef new_func():\n a = 10\n\nif True:\n' \ ' new_func()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_function_while_inner_function_reads(self): code = 'def a_func():\n a_var = 10\n' \ @@ -219,7 +219,7 @@ def test_extract_function_while_inner_function_reads(self): 'def new_func(a_var):\n' \ ' def inner_func():\n print(a_var)\n' \ ' return inner_func\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_bad_range(self): code = "def a_func():\n pass\na_var = 10\n" @@ -266,7 +266,7 @@ def test_extract_function_and_argument_as_paramenter(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = 'def a_func(arg):\n new_func(arg)\n\n' \ 'def new_func(arg):\n print(arg)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_function_and_end_as_the_start_of_a_line(self): code = 'print("hey")\nif True:\n pass\n' @@ -275,7 +275,7 @@ def test_extract_function_and_end_as_the_start_of_a_line(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = '\ndef new_func():\n print("hey")\n\n' \ 'new_func()\nif True:\n pass\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_function_and_indented_blocks(self): code = 'def a_func(arg):\n if True:\n' \ @@ -285,7 +285,7 @@ def test_extract_function_and_indented_blocks(self): expected = 'def a_func(arg):\n ' \ 'if True:\n new_func(arg)\n\n' \ 'def new_func(arg):\n if True:\n print(arg)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_and_multi_line_headers(self): code = 'def a_func(\n arg):\n print(arg)\n' @@ -293,7 +293,7 @@ def test_extract_method_and_multi_line_headers(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = 'def a_func(\n arg):\n new_func(arg)\n\n' \ 'def new_func(arg):\n print(arg)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_single_line_extract_function(self): code = 'a_var = 10 + 20\n' @@ -302,7 +302,7 @@ def test_single_line_extract_function(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = "\ndef new_func():\n " \ "return 10 + 20\n\na_var = new_func()\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_single_line_extract_function2(self): code = 'def a_func():\n a = 10\n b = a * 20\n' @@ -311,7 +311,7 @@ def test_single_line_extract_function2(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = 'def a_func():\n a = 10\n b = new_func(a)\n' \ '\ndef new_func(a):\n return a * 20\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_single_line_extract_method_and_logical_lines(self): code = 'a_var = 10 +\\\n 20\n' @@ -320,7 +320,7 @@ def test_single_line_extract_method_and_logical_lines(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = '\ndef new_func():\n ' \ 'return 10 + 20\n\na_var = new_func()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_single_line_extract_method_and_logical_lines2(self): code = 'a_var = (10,\\\n 20)\n' @@ -329,7 +329,7 @@ def test_single_line_extract_method_and_logical_lines2(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = '\ndef new_func():\n' \ ' return (10, 20)\n\na_var = new_func()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_single_line_extract_method(self): code = "class AClass(object):\n\n" \ @@ -341,7 +341,7 @@ def test_single_line_extract_method(self): ' def a_func(self):\n' \ ' a = 10\n b = self.new_func(a)\n\n' \ ' def new_func(self, a):\n return a * a\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_single_line_extract_function_if_condition(self): code = 'if True:\n pass\n' @@ -350,7 +350,7 @@ def test_single_line_extract_function_if_condition(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = "\ndef new_func():\n return True\n\nif new_func():" \ "\n pass\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_unneeded_params(self): code = 'class A(object):\n ' \ @@ -362,7 +362,7 @@ def test_unneeded_params(self): ' def a_func(self):\n a_var = 10\n' \ ' a_var += self.new_func()\n\n' \ ' def new_func(self):\n return 2\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_breaks_and_continues_inside_loops(self): code = 'def a_func():\n for i in range(10):\n continue\n' @@ -372,7 +372,7 @@ def test_breaks_and_continues_inside_loops(self): expected = 'def a_func():\n new_func()\n\n' \ 'def new_func():\n' \ ' for i in range(10):\n continue\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_breaks_and_continues_outside_loops(self): code = 'def a_func():\n' \ @@ -389,7 +389,7 @@ def test_variable_writes_followed_by_variable_reads_after_extraction(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = 'def a_func():\n new_func()\n a = 2\n b = a\n\n' \ 'def new_func():\n a = 1\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_var_writes_followed_by_var_reads_inside_extraction(self): code = 'def a_func():\n a = 1\n a = 2\n b = a\n' @@ -398,7 +398,7 @@ def test_var_writes_followed_by_var_reads_inside_extraction(self): refactored = self.do_extract_method(code, start, end, 'new_func') expected = 'def a_func():\n a = 1\n new_func()\n\n' \ 'def new_func():\n a = 2\n b = a\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable(self): code = 'a_var = 10 + 20\n' @@ -406,7 +406,7 @@ def test_extract_variable(self): end = code.index('20') + 2 refactored = self.do_extract_variable(code, start, end, 'new_var') expected = 'new_var = 10 + 20\na_var = new_var\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_multiple_lines(self): code = 'a = 1\nb = 2\n' @@ -414,7 +414,7 @@ def test_extract_variable_multiple_lines(self): end = code.index('1') + 1 refactored = self.do_extract_variable(code, start, end, 'c') expected = 'c = 1\na = c\nb = 2\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_in_the_middle_of_statements(self): code = 'a = 1 + 2\n' @@ -422,7 +422,7 @@ def test_extract_variable_in_the_middle_of_statements(self): end = code.index('1') + 1 refactored = self.do_extract_variable(code, start, end, 'c') expected = 'c = 1\na = c + 2\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_for_a_tuple(self): code = 'a = 1, 2\n' @@ -430,7 +430,7 @@ def test_extract_variable_for_a_tuple(self): end = code.index('2') + 1 refactored = self.do_extract_variable(code, start, end, 'c') expected = 'c = 1, 2\na = c\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_for_a_string(self): code = 'def a_func():\n a = "hey!"\n' @@ -438,7 +438,7 @@ def test_extract_variable_for_a_string(self): end = code.rindex('"') + 1 refactored = self.do_extract_variable(code, start, end, 'c') expected = 'def a_func():\n c = "hey!"\n a = c\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_inside_ifs(self): code = 'if True:\n a = 1 + 2\n' @@ -446,7 +446,7 @@ def test_extract_variable_inside_ifs(self): end = code.rindex('2') + 1 refactored = self.do_extract_variable(code, start, end, 'b') expected = 'if True:\n b = 1 + 2\n a = b\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_inside_ifs_and_logical_lines(self): code = 'if True:\n a = (3 + \n(1 + 2))\n' @@ -454,7 +454,7 @@ def test_extract_variable_inside_ifs_and_logical_lines(self): end = code.index('2') + 1 refactored = self.do_extract_variable(code, start, end, 'b') expected = 'if True:\n b = 1 + 2\n a = (3 + \n(b))\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) # TODO: Handle when extracting a subexpression def xxx_test_extract_variable_for_a_subexpression(self): @@ -463,7 +463,7 @@ def xxx_test_extract_variable_for_a_subexpression(self): end = code.index('2') + 1 refactored = self.do_extract_variable(code, start, end, 'b') expected = 'b = 1 + 2\na = 3 + b\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_starting_from_the_start_of_the_line(self): code = 'a_dict = {1: 1}\na_dict.values().count(1)\n' @@ -472,7 +472,7 @@ def test_extract_variable_starting_from_the_start_of_the_line(self): refactored = self.do_extract_variable(code, start, end, 'values') expected = 'a_dict = {1: 1}\n' \ 'values = a_dict.values()\nvalues.count(1)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_on_the_last_line_of_a_function(self): code = 'def f():\n a_var = {}\n a_var.keys()\n' @@ -481,7 +481,7 @@ def test_extract_variable_on_the_last_line_of_a_function(self): refactored = self.do_extract_variable(code, start, end, 'new_var') expected = 'def f():\n a_var = {}\n ' \ 'new_var = a_var\n new_var.keys()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_on_the_indented_function_statement(self): code = 'def f():\n if True:\n a_var = 1 + 2\n' @@ -490,7 +490,7 @@ def test_extract_variable_on_the_indented_function_statement(self): refactored = self.do_extract_variable(code, start, end, 'new_var') expected = 'def f():\n if True:\n' \ ' new_var = 1 + 2\n a_var = new_var\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_on_the_last_line_of_a_function(self): code = 'def f():\n a_var = {}\n a_var.keys()\n' @@ -499,7 +499,7 @@ def test_extract_method_on_the_last_line_of_a_function(self): refactored = self.do_extract_method(code, start, end, 'new_f') expected = 'def f():\n a_var = {}\n new_f(a_var).keys()\n\n' \ 'def new_f(a_var):\n return a_var\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_raising_exception_when_on_incomplete_variables(self): code = 'a_var = 10 + 20\n' @@ -541,7 +541,7 @@ def test_extract_method_and_extra_blank_lines(self): code = '\nprint(1)\n' refactored = self.do_extract_method(code, 0, len(code), 'new_f') expected = '\n\ndef new_f():\n print(1)\n\nnew_f()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_variable_writes_in_the_same_line_as_variable_read(self): code = 'a = 1\na = 1 + a\n' @@ -550,7 +550,7 @@ def test_variable_writes_in_the_same_line_as_variable_read(self): refactored = self.do_extract_method(code, start, end, 'new_f', global_=True) expected = 'a = 1\n\ndef new_f(a):\n a = 1 + a\n\nnew_f(a)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_variable_writes_in_the_same_line_as_variable_read2(self): code = 'a = 1\na += 1\n' @@ -559,7 +559,7 @@ def test_variable_writes_in_the_same_line_as_variable_read2(self): refactored = self.do_extract_method(code, start, end, 'new_f', global_=True) expected = 'a = 1\n\ndef new_f():\n a += 1\n\nnew_f()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_variable_and_similar_expressions(self): code = 'a = 1\nb = 1\n' @@ -568,7 +568,7 @@ def test_variable_and_similar_expressions(self): refactored = self.do_extract_variable(code, start, end, 'one', similar=True) expected = 'one = 1\na = one\nb = one\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_definition_should_appear_before_the_first_use(self): code = 'a = 1\nb = 1\n' @@ -577,7 +577,7 @@ def test_definition_should_appear_before_the_first_use(self): refactored = self.do_extract_variable(code, start, end, 'one', similar=True) expected = 'one = 1\na = one\nb = one\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_and_similar_expressions(self): code = 'a = 1\nb = 1\n' @@ -586,7 +586,7 @@ def test_extract_method_and_similar_expressions(self): refactored = self.do_extract_method(code, start, end, 'one', similar=True) expected = '\ndef one():\n return 1\n\na = one()\nb = one()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_simple_extract_method_and_similar_statements(self): code = 'class AClass(object):\n\n' \ @@ -602,7 +602,7 @@ def test_simple_extract_method_and_similar_statements(self): ' a = 1 + 2\n return a\n' \ ' def func2(self):\n' \ ' a = self.new_func()\n b = a\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_and_similar_statements2(self): code = 'class AClass(object):\n\n' \ @@ -617,7 +617,7 @@ def test_extract_method_and_similar_statements2(self): 'a = self.new_func(p1)\n\n' \ ' def new_func(self, p1):\n return p1 + 2\n' \ ' def func2(self, p2):\n a = self.new_func(p2)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_and_similar_sttemnts_return_is_different(self): code = 'class AClass(object):\n\n' \ @@ -633,7 +633,7 @@ def test_extract_method_and_similar_sttemnts_return_is_different(self): ' def new_func(self, p1):\n return p1 + 2\n' \ ' def func2(self, p2):\n' \ ' self.attr = self.new_func(p2)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_definition_should_appear_where_it_is_visible(self): code = 'if True:\n a = 1\nelse:\n b = 1\n' @@ -642,7 +642,7 @@ def test_definition_should_appear_where_it_is_visible(self): refactored = self.do_extract_variable(code, start, end, 'one', similar=True) expected = 'one = 1\nif True:\n a = one\nelse:\n b = one\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_and_similar_statements_in_classes(self): code = 'class AClass(object):\n\n' \ @@ -654,7 +654,7 @@ def test_extract_variable_and_similar_statements_in_classes(self): expected = 'class AClass(object):\n\n' \ ' def func1(self):\n one = 1\n a = one\n' \ ' def func2(self):\n b = 1\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_in_staticmethods(self): code = 'class AClass(object):\n\n' \ @@ -667,7 +667,7 @@ def test_extract_method_in_staticmethods(self): ' b = AClass.one()\n\n' \ ' @staticmethod\n def one():\n' \ ' return 1\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_normal_method_with_staticmethods(self): code = 'class AClass(object):\n\n' \ @@ -680,7 +680,7 @@ def test_extract_normal_method_with_staticmethods(self): ' @staticmethod\n def func1():\n b = 1\n' \ ' def func2(self):\n b = self.one()\n\n' \ ' def one(self):\n return 1\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_variable_with_no_new_lines_at_the_end(self): code = 'a_var = 10' @@ -688,7 +688,7 @@ def test_extract_variable_with_no_new_lines_at_the_end(self): end = start + 2 refactored = self.do_extract_variable(code, start, end, 'new_var') expected = 'new_var = 10\na_var = new_var' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_containing_return_in_functions(self): code = 'def f(arg):\n return arg\nprint(f(1))\n' @@ -696,7 +696,7 @@ def test_extract_method_containing_return_in_functions(self): refactored = self.do_extract_method(code, start, end, 'a_func') expected = '\ndef a_func():\n def f(arg):\n return arg\n' \ ' print(f(1))\n\na_func()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_and_varying_first_parameter(self): code = 'class C(object):\n' \ @@ -710,7 +710,7 @@ def test_extract_method_and_varying_first_parameter(self): ' def f1(self):\n print(self.to_str())\n\n' \ ' def to_str(self):\n return str(self)\n' \ ' def f2(self):\n print(str(1))\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_when_an_attribute_exists_in_function_scope(self): code = 'class A(object):\n def func(self):\n pass\n' \ @@ -724,7 +724,7 @@ def test_extract_method_when_an_attribute_exists_in_function_scope(self): refactored = refactored[refactored.index('A()') + 4:] expected = 'def f():\n func = g()\n print(func)\n\n' \ 'def g():\n func = a.func()\n return func\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_global_option_for_extract_method(self): code = 'def a_func():\n print(1)\n' @@ -733,7 +733,7 @@ def test_global_option_for_extract_method(self): 'extracted', global_=True) expected = 'def a_func():\n extracted()\n\n' \ 'def extracted():\n print(1)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_global_extract_method(self): code = 'class AClass(object):\n\n' \ @@ -744,7 +744,7 @@ def test_global_extract_method(self): expected = 'class AClass(object):\n\n' \ ' def a_func(self):\n new_func()\n\n' \ 'def new_func():\n print(1)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_with_multiple_methods(self): # noqa code = 'class AClass(object):\n' \ @@ -762,7 +762,7 @@ def test_extract_method_with_multiple_methods(self): # noqa ' pass\n\n' \ 'def new_func():\n' \ ' print(1)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_where_to_seach_when_extracting_global_names(self): code = 'def a():\n return 1\ndef b():\n return 1\nb = 1\n' @@ -772,7 +772,7 @@ def test_where_to_seach_when_extracting_global_names(self): similar=True, global_=True) expected = 'def a():\n return one\none = 1\n' \ 'def b():\n return one\nb = one\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extracting_pieces_with_distinct_temp_names(self): code = 'a = 1\nprint(a)\nb = 1\nprint(b)\n' @@ -781,7 +781,7 @@ def test_extracting_pieces_with_distinct_temp_names(self): refactored = self.do_extract_method(code, start, end, 'f', similar=True, global_=True) expected = '\ndef f():\n a = 1\n print(a)\n\nf()\nf()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_methods_in_glob_funcs_should_be_glob(self): code = 'def f():\n a = 1\ndef g():\n b = 1\n' @@ -790,7 +790,7 @@ def test_extract_methods_in_glob_funcs_should_be_glob(self): similar=True, global_=False) expected = 'def f():\n a = one()\ndef g():\n b = one()\n\n' \ 'def one():\n return 1\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_methods_in_glob_funcs_should_be_glob_2(self): code = 'if 1:\n var = 2\n' @@ -798,7 +798,7 @@ def test_extract_methods_in_glob_funcs_should_be_glob_2(self): refactored = self.do_extract_method(code, start, start + 1, 'two', similar=True, global_=False) expected = '\ndef two():\n return 2\n\nif 1:\n var = two()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_and_try_blocks(self): code = 'def f():\n try:\n pass\n' \ @@ -807,7 +807,7 @@ def test_extract_method_and_try_blocks(self): refactored = self.do_extract_method(code, start, end, 'g') expected = 'def f():\n g()\n\ndef g():\n try:\n pass\n' \ ' except Exception:\n pass\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_and_not_passing_global_functions(self): code = 'def next(p):\n return p + 1\nvar = next(1)\n' @@ -815,7 +815,7 @@ def test_extract_and_not_passing_global_functions(self): refactored = self.do_extract_method(code, start, len(code) - 1, 'two') expected = 'def next(p):\n return p + 1\n' \ '\ndef two():\n return next(1)\n\nvar = two()\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extracting_with_only_one_return(self): code = 'def f():\n var = 1\n return var\n' @@ -823,7 +823,7 @@ def test_extracting_with_only_one_return(self): refactored = self.do_extract_method(code, start, end, 'g') expected = 'def f():\n return g()\n\n' \ 'def g():\n var = 1\n return var\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extracting_variable_and_implicit_continuations(self): code = 's = ("1"\n "2")\n' @@ -831,7 +831,7 @@ def test_extracting_variable_and_implicit_continuations(self): end = code.rindex('"') + 1 refactored = self.do_extract_variable(code, start, end, 's2') expected = 's2 = "1" "2"\ns = (s2)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extracting_method_and_implicit_continuations(self): code = 's = ("1"\n "2")\n' @@ -839,7 +839,7 @@ def test_extracting_method_and_implicit_continuations(self): end = code.rindex('"') + 1 refactored = self.do_extract_method(code, start, end, 'f') expected = '\ndef f():\n return "1" "2"\n\ns = (f())\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_passing_conditional_updated_vars_in_extracted(self): code = 'def f(a):\n' \ @@ -854,7 +854,7 @@ def test_passing_conditional_updated_vars_in_extracted(self): ' if 0:\n' \ ' a = 1\n' \ ' print(a)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_returning_conditional_updated_vars_in_extracted(self): code = 'def f(a):\n' \ @@ -870,7 +870,7 @@ def test_returning_conditional_updated_vars_in_extracted(self): ' if 0:\n' \ ' a = 1\n' \ ' return a\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_with_variables_possibly_written_to(self): code = "def a_func(b):\n" \ @@ -886,7 +886,7 @@ def test_extract_method_with_variables_possibly_written_to(self): " if b > 0:\n" \ " a = 2\n" \ " return a\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_with_list_comprehension(self): code = "def foo():\n" \ @@ -908,7 +908,7 @@ def test_extract_method_with_list_comprehension(self): " for e, f in []:\n" \ " def bar():\n" \ " e[42] = 1\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_with_list_comprehension_and_iter(self): code = "def foo():\n" \ @@ -930,7 +930,7 @@ def test_extract_method_with_list_comprehension_and_iter(self): " for x, f in x:\n" \ " def bar():\n" \ " x[42] = 1\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_extract_method_with_list_comprehension_and_orelse(self): code = "def foo():\n" \ @@ -952,7 +952,7 @@ def test_extract_method_with_list_comprehension_and_orelse(self): " for e, f in []:\n" \ " def bar():\n" \ " e[42] = 1\n" - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) if __name__ == '__main__': unittest.main() diff --git a/ropetest/refactor/importutilstest.py b/ropetest/refactor/importutilstest.py index 5363f0c7b..73f52b822 100644 --- a/ropetest/refactor/importutilstest.py +++ b/ropetest/refactor/importutilstest.py @@ -30,38 +30,38 @@ def tearDown(self): def test_get_import_for_module(self): mod = self.project.find_module('mod') import_statement = self.import_tools.get_import(mod) - self.assertEqual('import mod', + self.assertEquals('import mod', import_statement.get_import_statement()) def test_get_import_for_module_in_nested_modules(self): mod = self.project.find_module('pkg1.mod1') import_statement = self.import_tools.get_import(mod) - self.assertEqual('import pkg1.mod1', + self.assertEquals('import pkg1.mod1', import_statement.get_import_statement()) def test_get_import_for_module_in_init_dot_py(self): init_dot_py = self.pkg1.get_child('__init__.py') import_statement = self.import_tools.get_import(init_dot_py) - self.assertEqual('import pkg1', + self.assertEquals('import pkg1', import_statement.get_import_statement()) def test_get_from_import_for_module(self): mod = self.project.find_module('mod') import_statement = self.import_tools.get_from_import(mod, 'a_func') - self.assertEqual('from mod import a_func', + self.assertEquals('from mod import a_func', import_statement.get_import_statement()) def test_get_from_import_for_module_in_nested_modules(self): mod = self.project.find_module('pkg1.mod1') import_statement = self.import_tools.get_from_import(mod, 'a_func') - self.assertEqual('from pkg1.mod1 import a_func', + self.assertEquals('from pkg1.mod1 import a_func', import_statement.get_import_statement()) def test_get_from_import_for_module_in_init_dot_py(self): init_dot_py = self.pkg1.get_child('__init__.py') import_statement = self.import_tools.\ get_from_import(init_dot_py, 'a_func') - self.assertEqual('from pkg1 import a_func', + self.assertEquals('from pkg1 import a_func', import_statement.get_import_statement()) def test_get_import_statements(self): @@ -69,7 +69,7 @@ def test_get_import_statements(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEqual('import pkg1', + self.assertEquals('import pkg1', imports[0].import_info.get_import_statement()) def test_get_import_statements_with_alias(self): @@ -77,7 +77,7 @@ def test_get_import_statements_with_alias(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEqual('import pkg1.mod1 as mod1', + self.assertEquals('import pkg1.mod1 as mod1', imports[0].import_info.get_import_statement()) def test_get_import_statements_for_froms(self): @@ -85,7 +85,7 @@ def test_get_import_statements_for_froms(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEqual('from pkg1 import mod1', + self.assertEquals('from pkg1 import mod1', imports[0].import_info.get_import_statement()) def test_get_multi_line_import_statements_for_froms(self): @@ -93,7 +93,7 @@ def test_get_multi_line_import_statements_for_froms(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEqual('from pkg1 import mod1', + self.assertEquals('from pkg1 import mod1', imports[0].import_info.get_import_statement()) def test_get_import_statements_for_from_star(self): @@ -101,7 +101,7 @@ def test_get_import_statements_for_from_star(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEqual('from pkg1 import *', + self.assertEquals('from pkg1 import *', imports[0].import_info.get_import_statement()) @testutils.only_for('2.5') @@ -110,7 +110,7 @@ def test_get_import_statements_for_new_relatives(self): pymod = self.project.get_module('pkg2.mod2') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEqual('from .mod3 import x', + self.assertEquals('from .mod3 import x', imports[0].import_info.get_import_statement()) def test_ignoring_indented_imports(self): @@ -118,7 +118,7 @@ def test_ignoring_indented_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports - self.assertEqual(0, len(imports)) + self.assertEquals(0, len(imports)) def test_import_get_names(self): self.mod.write('import pkg1 as pkg\n') @@ -126,7 +126,7 @@ def test_import_get_names(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports context = importinfo.ImportContext(self.project, self.project.root) - self.assertEqual(['pkg'], + self.assertEquals(['pkg'], imports[0].import_info.get_imported_names(context)) def test_import_get_names_with_alias(self): @@ -135,7 +135,7 @@ def test_import_get_names_with_alias(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports context = importinfo.ImportContext(self.project, self.project.root) - self.assertEqual(['pkg1'], + self.assertEquals(['pkg1'], imports[0].import_info.get_imported_names(context)) def test_import_get_names_with_alias2(self): @@ -145,7 +145,7 @@ def test_import_get_names_with_alias2(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.imports context = importinfo.ImportContext(self.project, self.project.root) - self.assertEqual(['a_func'], + self.assertEquals(['a_func'], imports[0].import_info.get_imported_names(context)) def test_empty_getting_used_imports(self): @@ -153,30 +153,30 @@ def test_empty_getting_used_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports(pymod) - self.assertEqual(0, len(imports)) + self.assertEquals(0, len(imports)) def test_empty_getting_used_imports2(self): self.mod.write('import pkg\n') pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports(pymod) - self.assertEqual(0, len(imports)) + self.assertEquals(0, len(imports)) def test_simple_getting_used_imports(self): self.mod.write('import pkg\nprint(pkg)\n') pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports(pymod) - self.assertEqual(1, len(imports)) - self.assertEqual('import pkg', imports[0].get_import_statement()) + self.assertEquals(1, len(imports)) + self.assertEquals('import pkg', imports[0].get_import_statement()) def test_simple_getting_used_imports2(self): self.mod.write('import pkg\ndef a_func():\n print(pkg)\n') pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports(pymod) - self.assertEqual(1, len(imports)) - self.assertEqual('import pkg', imports[0].get_import_statement()) + self.assertEquals(1, len(imports)) + self.assertEquals('import pkg', imports[0].get_import_statement()) def test_getting_used_imports_for_nested_scopes(self): self.mod.write('import pkg1\nprint(pkg1)\n' @@ -185,7 +185,7 @@ def test_getting_used_imports_for_nested_scopes(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports( pymod['a_func'].get_object()) - self.assertEqual(0, len(imports)) + self.assertEquals(0, len(imports)) def test_getting_used_imports_for_nested_scopes2(self): self.mod.write('from pkg1 import mod1\ndef a_func():' @@ -194,8 +194,8 @@ def test_getting_used_imports_for_nested_scopes2(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports( pymod['a_func'].get_object()) - self.assertEqual(1, len(imports)) - self.assertEqual('from pkg1 import mod1', + self.assertEquals(1, len(imports)) + self.assertEquals('from pkg1 import mod1', imports[0].get_import_statement()) def test_empty_removing_unused_imports(self): @@ -203,7 +203,7 @@ def test_empty_removing_unused_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('import pkg1\nprint(pkg1)\n', + self.assertEquals('import pkg1\nprint(pkg1)\n', module_with_imports.get_changed_source()) def test_simple_removing_unused_imports(self): @@ -211,7 +211,7 @@ def test_simple_removing_unused_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('', module_with_imports.get_changed_source()) + self.assertEquals('', module_with_imports.get_changed_source()) def test_simple_removing_unused_imports_for_froms(self): self.mod1.write('def a_func():\n pass' @@ -221,7 +221,7 @@ def test_simple_removing_unused_imports_for_froms(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('from pkg1.mod1 import a_func\n\na_func()\n', + self.assertEquals('from pkg1.mod1 import a_func\n\na_func()\n', module_with_imports.get_changed_source()) def test_simple_removing_unused_imports_for_from_stars(self): @@ -229,7 +229,7 @@ def test_simple_removing_unused_imports_for_from_stars(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('', module_with_imports.get_changed_source()) + self.assertEquals('', module_with_imports.get_changed_source()) def test_simple_removing_unused_imports_for_nested_modules(self): self.mod1.write('def a_func():\n pass\n') @@ -237,7 +237,7 @@ def test_simple_removing_unused_imports_for_nested_modules(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('import pkg1.mod1\npkg1.mod1.a_func()', + self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_functions_of_the_same_name(self): @@ -245,7 +245,7 @@ def test_removing_unused_imports_and_functions_of_the_same_name(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('def a_func():\n pass\ndef a_func():\n pass\n', + self.assertEquals('def a_func():\n pass\ndef a_func():\n pass\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_for_from_import_with_as(self): @@ -254,7 +254,7 @@ def test_removing_unused_imports_for_from_import_with_as(self): pymod = self.project.get_pymodule(self.mod1) module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('from mod import a_var as myvar\na_var = myvar\n', + self.assertEquals('from mod import a_var as myvar\na_var = myvar\n', module_with_imports.get_changed_source()) def test_not_removing_imports_that_conflict_with_class_names(self): @@ -264,7 +264,7 @@ def test_not_removing_imports_that_conflict_with_class_names(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual(code, module_with_imports.get_changed_source()) + self.assertEquals(code, module_with_imports.get_changed_source()) def test_adding_imports(self): self.mod.write('\n') @@ -272,7 +272,7 @@ def test_adding_imports(self): module_with_imports = self.import_tools.module_imports(pymod) new_import = self.import_tools.get_import(self.mod1) module_with_imports.add_import(new_import) - self.assertEqual('import pkg1.mod1\n', + self.assertEquals('import pkg1.mod1\n', module_with_imports.get_changed_source()) def test_adding_from_imports(self): @@ -284,7 +284,7 @@ def test_adding_from_imports(self): new_import = self.import_tools.get_from_import( self.mod1, 'another_func') module_with_imports.add_import(new_import) - self.assertEqual('from pkg1.mod1 import a_func, another_func\n', + self.assertEquals('from pkg1.mod1 import a_func, another_func\n', module_with_imports.get_changed_source()) def test_adding_to_star_imports(self): @@ -296,7 +296,7 @@ def test_adding_to_star_imports(self): new_import = self.import_tools.get_from_import( self.mod1, 'another_func') module_with_imports.add_import(new_import) - self.assertEqual('from pkg1.mod1 import *\n', + self.assertEquals('from pkg1.mod1 import *\n', module_with_imports.get_changed_source()) def test_adding_star_imports(self): @@ -307,7 +307,7 @@ def test_adding_star_imports(self): module_with_imports = self.import_tools.module_imports(pymod) new_import = self.import_tools.get_from_import(self.mod1, '*') module_with_imports.add_import(new_import) - self.assertEqual('from pkg1.mod1 import *\n', + self.assertEquals('from pkg1.mod1 import *\n', module_with_imports.get_changed_source()) def test_adding_imports_and_preserving_spaces_after_imports(self): @@ -316,7 +316,7 @@ def test_adding_imports_and_preserving_spaces_after_imports(self): module_with_imports = self.import_tools.module_imports(pymod) new_import = self.import_tools.get_import(self.pkg2) module_with_imports.add_import(new_import) - self.assertEqual('import pkg1\nimport pkg2\n\n\nprint(pkg1)\n', + self.assertEquals('import pkg1\nimport pkg2\n\n\nprint(pkg1)\n', module_with_imports.get_changed_source()) def test_not_changing_the_format_of_unchanged_imports(self): @@ -325,7 +325,7 @@ def test_not_changing_the_format_of_unchanged_imports(self): self.mod.write('from pkg1.mod1 import (a_func,\n another_func)\n') pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) - self.assertEqual( + self.assertEquals( 'from pkg1.mod1 import (a_func,\n another_func)\n', module_with_imports.get_changed_source()) @@ -336,7 +336,7 @@ def test_not_changing_the_format_of_unchanged_imports2(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('from pkg1.mod1 import (a_func)\na_func()\n', + self.assertEquals('from pkg1.mod1 import (a_func)\na_func()\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_reoccuring_names(self): @@ -347,7 +347,7 @@ def test_removing_unused_imports_and_reoccuring_names(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('from pkg1.mod1 import *\na_func()\n', + self.assertEquals('from pkg1.mod1 import *\na_func()\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_reoccuring_names2(self): @@ -356,7 +356,7 @@ def test_removing_unused_imports_and_reoccuring_names2(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual( + self.assertEquals( 'import pkg2.mod2\nimport pkg2.mod3\nprint(pkg2.mod2, pkg2.mod3)', module_with_imports.get_changed_source()) @@ -366,7 +366,7 @@ def test_removing_unused_imports_and_common_packages(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('import pkg1.mod1\nprint(pkg1, pkg1.mod1)\n', + self.assertEquals('import pkg1.mod1\nprint(pkg1, pkg1.mod1)\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_common_packages_reversed(self): @@ -375,7 +375,7 @@ def test_removing_unused_imports_and_common_packages_reversed(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_duplicates() - self.assertEqual('import pkg1.mod1\nprint(pkg1, pkg1.mod1)\n', + self.assertEquals('import pkg1.mod1\nprint(pkg1, pkg1.mod1)\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_common_packages2(self): @@ -383,7 +383,7 @@ def test_removing_unused_imports_and_common_packages2(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('import pkg1.mod1\nprint(pkg1)\n', + self.assertEquals('import pkg1.mod1\nprint(pkg1)\n', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_froms(self): @@ -392,7 +392,7 @@ def test_removing_unused_imports_and_froms(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('', module_with_imports.get_changed_source()) + self.assertEquals('', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_froms2(self): self.mod1.write('def func1():\n pass\n') @@ -400,7 +400,7 @@ def test_removing_unused_imports_and_froms2(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('from pkg1.mod1 import func1\nfunc1()', + self.assertEquals('from pkg1.mod1 import func1\nfunc1()', module_with_imports.get_changed_source()) def test_removing_unused_imports_and_froms3(self): @@ -410,7 +410,7 @@ def test_removing_unused_imports_and_froms3(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual( + self.assertEquals( 'from pkg1.mod1 import func1\ndef a_func():\n func1()\n', module_with_imports.get_changed_source()) @@ -421,7 +421,7 @@ def test_removing_unused_imports_and_froms4(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('from pkg1.mod1 import func1\nclass A(object):\n' + self.assertEquals('from pkg1.mod1 import func1\nclass A(object):\n' ' def a_func(self):\n func1()\n', module_with_imports.get_changed_source()) @@ -431,7 +431,7 @@ def test_removing_unused_imports_and_getting_attributes(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('from pkg1.mod1 import A\nvar = A().f()', + self.assertEquals('from pkg1.mod1 import A\nvar = A().f()', module_with_imports.get_changed_source()) def test_removing_unused_imports_function_parameters(self): @@ -440,7 +440,7 @@ def test_removing_unused_imports_function_parameters(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('def a_func(pkg1):\n my_var = pkg1\n', + self.assertEquals('def a_func(pkg1):\n my_var = pkg1\n', module_with_imports.get_changed_source()) def test_trivial_expanding_star_imports(self): @@ -450,7 +450,7 @@ def test_trivial_expanding_star_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.expand_stars() - self.assertEqual('', module_with_imports.get_changed_source()) + self.assertEquals('', module_with_imports.get_changed_source()) def test_expanding_star_imports(self): self.mod1.write('def a_func():\n pass\n' @@ -459,7 +459,7 @@ def test_expanding_star_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.expand_stars() - self.assertEqual('from pkg1.mod1 import a_func\na_func()\n', + self.assertEquals('from pkg1.mod1 import a_func\na_func()\n', module_with_imports.get_changed_source()) def test_removing_duplicate_imports(self): @@ -467,7 +467,7 @@ def test_removing_duplicate_imports(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_duplicates() - self.assertEqual('import pkg1\n', + self.assertEquals('import pkg1\n', module_with_imports.get_changed_source()) def test_removing_duplicates_and_reoccuring_names(self): @@ -475,7 +475,7 @@ def test_removing_duplicates_and_reoccuring_names(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_duplicates() - self.assertEqual('import pkg2.mod2\nimport pkg2.mod3\n', + self.assertEquals('import pkg2.mod2\nimport pkg2.mod3\n', module_with_imports.get_changed_source()) def test_removing_duplicate_imports_for_froms(self): @@ -486,7 +486,7 @@ def test_removing_duplicate_imports_for_froms(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_duplicates() - self.assertEqual('from pkg1 import a_func, another_func\n', + self.assertEquals('from pkg1 import a_func, another_func\n', module_with_imports.get_changed_source()) def test_transforming_froms_to_normal_changing_imports(self): @@ -494,7 +494,7 @@ def test_transforming_froms_to_normal_changing_imports(self): self.mod.write('from pkg1.mod1 import a_func\nprint(a_func)\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEqual('import pkg1.mod1\nprint(pkg1.mod1.a_func)\n', + self.assertEquals('import pkg1.mod1\nprint(pkg1.mod1.a_func)\n', changed_module) def test_transforming_froms_to_normal_changing_occurances(self): @@ -502,7 +502,7 @@ def test_transforming_froms_to_normal_changing_occurances(self): self.mod.write('from pkg1.mod1 import a_func\na_func()') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEqual('import pkg1.mod1\npkg1.mod1.a_func()', + self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()', changed_module) def test_transforming_froms_to_normal_for_multi_imports(self): @@ -511,7 +511,7 @@ def test_transforming_froms_to_normal_for_multi_imports(self): self.mod.write('from pkg1.mod1 import *\na_func()\nanother_func()\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEqual( + self.assertEquals( 'import pkg1.mod1\npkg1.mod1.a_func()\npkg1.mod1.another_func()\n', changed_module) @@ -522,7 +522,7 @@ def test_transform_froms_to_norm_for_multi_imports_inside_parens(self): '\na_func()\nanother_func()\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEqual( + self.assertEquals( 'import pkg1.mod1\npkg1.mod1.a_func()\npkg1.mod1.another_func()\n', changed_module) @@ -531,7 +531,7 @@ def test_transforming_froms_to_normal_from_stars(self): self.mod.write('from pkg1.mod1 import *\na_func()\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEqual('import pkg1.mod1\npkg1.mod1.a_func()\n', + self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()\n', changed_module) def test_transforming_froms_to_normal_from_stars2(self): @@ -540,7 +540,7 @@ def test_transforming_froms_to_normal_from_stars2(self): 'def a_func():\n print(pkg1.mod1, a_var)\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEqual('import pkg1.mod1\n' + self.assertEquals('import pkg1.mod1\n' 'def a_func():\n ' 'print(pkg1.mod1, pkg1.mod1.a_var)\n', changed_module) @@ -551,7 +551,7 @@ def test_transforming_froms_to_normal_from_with_alias(self): 'from pkg1.mod1 import a_func as another_func\nanother_func()\n') pymod = self.project.get_module('mod') changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEqual('import pkg1.mod1\npkg1.mod1.a_func()\n', + self.assertEquals('import pkg1.mod1\npkg1.mod1.a_func()\n', changed_module) def test_transforming_froms_to_normal_for_relatives(self): @@ -559,32 +559,32 @@ def test_transforming_froms_to_normal_for_relatives(self): self.mod3.write('from mod2 import *\na_func()\n') pymod = self.project.get_pymodule(self.mod3) changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEqual('import pkg2.mod2\npkg2.mod2.a_func()\n', + self.assertEquals('import pkg2.mod2\npkg2.mod2.a_func()\n', changed_module) def test_transforming_froms_to_normal_for_os_path(self): self.mod.write('from os import path\npath.exists(\'.\')\n') pymod = self.project.get_pymodule(self.mod) changed_module = self.import_tools.froms_to_imports(pymod) - self.assertEqual('import os\nos.path.exists(\'.\')\n', changed_module) + self.assertEquals('import os\nos.path.exists(\'.\')\n', changed_module) def test_transform_relatives_imports_to_abs_imports_doing_nothing(self): self.mod2.write('from pkg1 import mod1\nimport mod1\n') pymod = self.project.get_pymodule(self.mod2) - self.assertEqual('from pkg1 import mod1\nimport mod1\n', + self.assertEquals('from pkg1 import mod1\nimport mod1\n', self.import_tools.relatives_to_absolutes(pymod)) def test_transform_relatives_to_absolute_imports_for_normal_imports(self): self.mod2.write('import mod3\n') pymod = self.project.get_pymodule(self.mod2) - self.assertEqual('import pkg2.mod3\n', + self.assertEquals('import pkg2.mod3\n', self.import_tools.relatives_to_absolutes(pymod)) def test_transform_relatives_imports_to_absolute_imports_for_froms(self): self.mod3.write('def a_func():\n pass\n') self.mod2.write('from mod3 import a_func\n') pymod = self.project.get_pymodule(self.mod2) - self.assertEqual('from pkg2.mod3 import a_func\n', + self.assertEquals('from pkg2.mod3 import a_func\n', self.import_tools.relatives_to_absolutes(pymod)) @testutils.only_for('2.5') @@ -592,32 +592,32 @@ def test_transform_rel_imports_to_abs_imports_for_new_relatives(self): self.mod3.write('def a_func():\n pass\n') self.mod2.write('from .mod3 import a_func\n') pymod = self.project.get_pymodule(self.mod2) - self.assertEqual('from pkg2.mod3 import a_func\n', + self.assertEquals('from pkg2.mod3 import a_func\n', self.import_tools.relatives_to_absolutes(pymod)) def test_transform_relatives_to_absolute_imports_for_normal_imports2(self): self.mod2.write('import mod3\nprint(mod3)') pymod = self.project.get_pymodule(self.mod2) - self.assertEqual('import pkg2.mod3\nprint(pkg2.mod3)', + self.assertEquals('import pkg2.mod3\nprint(pkg2.mod3)', self.import_tools.relatives_to_absolutes(pymod)) def test_transform_relatives_to_absolute_imports_for_aliases(self): self.mod2.write('import mod3 as mod3\nprint(mod3)') pymod = self.project.get_pymodule(self.mod2) - self.assertEqual('import pkg2.mod3 as mod3\nprint(mod3)', + self.assertEquals('import pkg2.mod3 as mod3\nprint(mod3)', self.import_tools.relatives_to_absolutes(pymod)) def test_organizing_imports(self): self.mod1.write('import mod1\n') pymod = self.project.get_pymodule(self.mod1) - self.assertEqual('', self.import_tools.organize_imports(pymod)) + self.assertEquals('', self.import_tools.organize_imports(pymod)) def test_organizing_imports_without_deduplication(self): contents = 'from pkg2 import mod2\nfrom pkg2 import mod3\n' self.mod.write(contents) pymod = self.project.get_pymodule(self.mod) self.project.prefs['split_imports'] = True - self.assertEqual(contents, + self.assertEquals(contents, self.import_tools.organize_imports(pymod, unused=False)) @@ -625,7 +625,7 @@ def test_splitting_imports(self): self.mod.write('from pkg1 import mod1\nfrom pkg2 import mod2, mod3\n') pymod = self.project.get_pymodule(self.mod) self.project.prefs['split_imports'] = True - self.assertEqual('from pkg1 import mod1\nfrom pkg2 import mod2\n' + self.assertEquals('from pkg1 import mod1\nfrom pkg2 import mod2\n' 'from pkg2 import mod3\n', self.import_tools.organize_imports(pymod, unused=False)) @@ -634,7 +634,7 @@ def test_splitting_duplicate_imports(self): self.mod.write('from pkg2 import mod1\nfrom pkg2 import mod1, mod2\n') pymod = self.project.get_pymodule(self.mod) self.project.prefs['split_imports'] = True - self.assertEqual('from pkg2 import mod1\nfrom pkg2 import mod2\n', + self.assertEquals('from pkg2 import mod1\nfrom pkg2 import mod2\n', self.import_tools.organize_imports(pymod, unused=False)) @@ -644,7 +644,7 @@ def test_splitting_duplicate_imports2(self): 'from pkg2 import mod2, mod3\n') pymod = self.project.get_pymodule(self.mod) self.project.prefs['split_imports'] = True - self.assertEqual('from pkg2 import mod1\nfrom pkg2 import mod2\n' + self.assertEquals('from pkg2 import mod1\nfrom pkg2 import mod2\n' 'from pkg2 import mod3\n', self.import_tools.organize_imports(pymod, unused=False)) @@ -652,96 +652,96 @@ def test_splitting_duplicate_imports2(self): def test_removing_self_imports(self): self.mod.write('import mod\nmod.a_var = 1\nprint(mod.a_var)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('a_var = 1\nprint(a_var)\n', + self.assertEquals('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports2(self): self.mod1.write('import pkg1.mod1\npkg1.mod1.a_var = 1\n' 'print(pkg1.mod1.a_var)\n') pymod = self.project.get_pymodule(self.mod1) - self.assertEqual('a_var = 1\nprint(a_var)\n', + self.assertEquals('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_with_as(self): self.mod.write('import mod as mymod\n' 'mymod.a_var = 1\nprint(mymod.a_var)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('a_var = 1\nprint(a_var)\n', + self.assertEquals('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_froms(self): self.mod1.write('from pkg1 import mod1\n' 'mod1.a_var = 1\nprint(mod1.a_var)\n') pymod = self.project.get_pymodule(self.mod1) - self.assertEqual('a_var = 1\nprint(a_var)\n', + self.assertEquals('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_froms_with_as(self): self.mod1.write('from pkg1 import mod1 as mymod\n' 'mymod.a_var = 1\nprint(mymod.a_var)\n') pymod = self.project.get_pymodule(self.mod1) - self.assertEqual('a_var = 1\nprint(a_var)\n', + self.assertEquals('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_froms2(self): self.mod.write('from mod import a_var\na_var = 1\nprint(a_var)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('a_var = 1\nprint(a_var)\n', + self.assertEquals('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_froms3(self): self.mod.write('from mod import a_var\na_var = 1\nprint(a_var)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('a_var = 1\nprint(a_var)\n', + self.assertEquals('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_froms4(self): self.mod.write('from mod import a_var as myvar\n' 'a_var = 1\nprint(myvar)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('a_var = 1\nprint(a_var)\n', + self.assertEquals('a_var = 1\nprint(a_var)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_with_no_dot_after_mod(self): self.mod.write('import mod\nprint(mod)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('import mod\n\n\nprint(mod)\n', + self.assertEquals('import mod\n\n\nprint(mod)\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_with_no_dot_after_mod2(self): self.mod.write('import mod\na_var = 1\n' 'print(mod\\\n \\\n .var)\n\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('a_var = 1\nprint(var)\n\n', + self.assertEquals('a_var = 1\nprint(var)\n\n', self.import_tools.organize_imports(pymod)) def test_removing_self_imports_for_from_import_star(self): self.mod.write('from mod import *\na_var = 1\nprint(myvar)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('a_var = 1\nprint(myvar)\n', + self.assertEquals('a_var = 1\nprint(myvar)\n', self.import_tools.organize_imports(pymod)) def test_not_removing_future_imports(self): self.mod.write('from __future__ import division\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('from __future__ import division\n', + self.assertEquals('from __future__ import division\n', self.import_tools.organize_imports(pymod)) def test_sorting_empty_imports(self): self.mod.write('') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('', self.import_tools.sort_imports(pymod)) + self.assertEquals('', self.import_tools.sort_imports(pymod)) def test_sorting_one_import(self): self.mod.write('import pkg1.mod1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('import pkg1.mod1\n', + self.assertEquals('import pkg1.mod1\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_alphabetically(self): self.mod.write('import pkg2.mod2\nimport pkg1.mod1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('import pkg1.mod1\nimport pkg2.mod2\n', + self.assertEquals('import pkg1.mod1\nimport pkg2.mod2\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_purely_alphabetically(self): @@ -749,64 +749,64 @@ def test_sorting_imports_purely_alphabetically(self): 'import pkg2.mod2\nimport pkg1.mod1\n') pymod = self.project.get_pymodule(self.mod) self.project.prefs['sort_imports_alphabetically'] = True - self.assertEqual('import pkg1.mod1\nimport pkg2.mod2\n' + self.assertEquals('import pkg1.mod1\nimport pkg2.mod2\n' 'from pkg2 import mod3 as mod0\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_and_froms(self): self.mod.write('import pkg2.mod2\nfrom pkg1 import mod1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('import pkg2.mod2\nfrom pkg1 import mod1\n', + self.assertEquals('import pkg2.mod2\nfrom pkg1 import mod1\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_and_standard_modules(self): self.mod.write('import pkg1\nimport sys\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('import sys\n\nimport pkg1\n', + self.assertEquals('import sys\n\nimport pkg1\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_and_standard_modules2(self): self.mod.write('import sys\n\nimport time\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('import sys\nimport time\n', + self.assertEquals('import sys\nimport time\n', self.import_tools.sort_imports(pymod)) def test_sorting_only_standard_modules(self): self.mod.write('import sys\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('import sys\n', + self.assertEquals('import sys\n', self.import_tools.sort_imports(pymod)) def test_sorting_third_party(self): self.mod.write('import pkg1\nimport a_third_party\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('import a_third_party\n\nimport pkg1\n', + self.assertEquals('import a_third_party\n\nimport pkg1\n', self.import_tools.sort_imports(pymod)) def test_sorting_only_third_parties(self): self.mod.write('import a_third_party\na_var = 1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual('import a_third_party\n\n\na_var = 1\n', + self.assertEquals('import a_third_party\n\n\na_var = 1\n', self.import_tools.sort_imports(pymod)) def test_simple_handling_long_imports(self): self.mod.write('import pkg1.mod1\n\n\nm = pkg1.mod1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'import pkg1.mod1\n\n\nm = pkg1.mod1\n', self.import_tools.handle_long_imports(pymod, maxdots=2)) def test_handling_long_imports_for_many_dots(self): self.mod.write('import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'from p1.p2.p3 import m1\n\n\nm = m1\n', self.import_tools.handle_long_imports(pymod, maxdots=2)) def test_handling_long_imports_for_their_length(self): self.mod.write('import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n', self.import_tools.handle_long_imports(pymod, maxdots=3, maxlength=20)) @@ -814,7 +814,7 @@ def test_handling_long_imports_for_their_length(self): def test_handling_long_imports_for_many_dots2(self): self.mod.write('import p1.p2.p3.m1\n\n\nm = p1.p2.p3.m1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'from p1.p2.p3 import m1\n\n\nm = m1\n', self.import_tools.handle_long_imports(pymod, maxdots=3, maxlength=10)) @@ -822,7 +822,7 @@ def test_handling_long_imports_for_many_dots2(self): def test_handling_long_imports_with_one_letter_last(self): self.mod.write('import p1.p2.p3.l\n\n\nm = p1.p2.p3.l\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'from p1.p2.p3 import l\n\n\nm = l\n', self.import_tools.handle_long_imports(pymod, maxdots=2)) @@ -831,28 +831,28 @@ def test_empty_removing_unused_imports_and_eating_blank_lines(self): pymod = self.project.get_module('mod') module_with_imports = self.import_tools.module_imports(pymod) module_with_imports.remove_unused_imports() - self.assertEqual('import pkg1\n\n\nprint(pkg1)\n', + self.assertEquals('import pkg1\n\n\nprint(pkg1)\n', module_with_imports.get_changed_source()) def test_sorting_imports_moving_to_top(self): self.mod.write('import mod\ndef f():\n print(mod, pkg1, pkg2)\n' 'import pkg1\nimport pkg2\n') pymod = self.project.get_module('mod') - self.assertEqual('import mod\nimport pkg1\nimport pkg2\n\n\n' + self.assertEquals('import mod\nimport pkg1\nimport pkg2\n\n\n' 'def f():\n print(mod, pkg1, pkg2)\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_moving_to_top2(self): self.mod.write('def f():\n print(mod)\nimport mod\n') pymod = self.project.get_module('mod') - self.assertEqual('import mod\n\n\ndef f():\n print(mod)\n', + self.assertEquals('import mod\n\n\ndef f():\n print(mod)\n', self.import_tools.sort_imports(pymod)) def test_sorting_imports_moving_to_top_and_module_docs(self): self.mod.write('"""\ndocs\n"""\ndef f():' '\n print(mod)\nimport mod\n') pymod = self.project.get_module('mod') - self.assertEqual( + self.assertEquals( '"""\ndocs\n"""\nimport mod\n\n\ndef f():\n print(mod)\n', self.import_tools.sort_imports(pymod)) @@ -860,7 +860,7 @@ def test_sorting_imports_moving_to_top_and_module_docs2(self): self.mod.write('"""\ndocs\n"""\n\n\nimport bbb\nimport aaa\n' 'def f():\n print(mod)\nimport mod\n') pymod = self.project.get_module('mod') - self.assertEqual( + self.assertEquals( '"""\ndocs\n"""\n\n\nimport aaa\nimport bbb\n\n' 'import mod\n\n\ndef f():\n print(mod)\n', self.import_tools.sort_imports(pymod)) @@ -868,28 +868,28 @@ def test_sorting_imports_moving_to_top_and_module_docs2(self): def test_sorting_future_imports(self): self.mod.write('import os\nfrom __future__ import devision\n') pymod = self.project.get_module('mod') - self.assertEqual( + self.assertEquals( 'from __future__ import devision\n\nimport os\n', self.import_tools.sort_imports(pymod)) def test_customized_import_organization(self): self.mod.write('import sys\nimport sys\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'import sys\n', self.import_tools.organize_imports(pymod, unused=False)) def test_customized_import_organization2(self): self.mod.write('import sys\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'import sys\n', self.import_tools.organize_imports(pymod, unused=False)) def test_customized_import_organization3(self): self.mod.write('import sys\nimport mod\n\n\nvar = 1\nprint(mod.var)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'import sys\n\n\nvar = 1\nprint(var)\n', self.import_tools.organize_imports(pymod, unused=False)) @@ -899,7 +899,7 @@ def test_trivial_filtered_expand_stars(self): self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' 'print(var1, var2)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'from pkg1 import *\nfrom pkg2 import *\n\nprint(var1, var2)\n', self.import_tools.expand_stars(pymod, lambda stmt: False)) @@ -914,7 +914,7 @@ def test_filtered_expand_stars(self): self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' 'print(var1, var2)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'from pkg1 import *\nfrom pkg2 import var2\n\nprint(var1, var2)\n', self.import_tools.expand_stars(pymod, self._line_filter(2))) @@ -922,11 +922,11 @@ def test_filtered_relative_to_absolute(self): self.mod3.write('var = 1') self.mod2.write('import mod3\n\nprint(mod3.var)\n') pymod = self.project.get_pymodule(self.mod2) - self.assertEqual( + self.assertEquals( 'import mod3\n\nprint(mod3.var)\n', self.import_tools.relatives_to_absolutes( pymod, lambda stmt: False)) - self.assertEqual( + self.assertEquals( 'import pkg2.mod3\n\nprint(pkg2.mod3.var)\n', self.import_tools.relatives_to_absolutes( pymod, self._line_filter(1))) @@ -937,11 +937,11 @@ def test_filtered_froms_to_normals(self): self.mod.write('from pkg1 import var1\nfrom pkg2 import var2\n\n' 'print(var1, var2)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'from pkg1 import var1\nfrom pkg2 ' 'import var2\n\nprint(var1, var2)\n', self.import_tools.expand_stars(pymod, lambda stmt: False)) - self.assertEqual( + self.assertEquals( 'from pkg1 import var1\nimport pkg2\n\nprint(var1, pkg2.var2)\n', self.import_tools.froms_to_imports(pymod, self._line_filter(2))) @@ -951,7 +951,7 @@ def test_filtered_froms_to_normals2(self): self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' 'print(var1, var2)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'from pkg1 import *\nimport pkg2\n\nprint(var1, pkg2.var2)\n', self.import_tools.froms_to_imports(pymod, self._line_filter(2))) @@ -959,7 +959,7 @@ def test_filtered_handle_long_imports(self): self.mod.write('import p1.p2.p3.m1\nimport pkg1.mod1\n\n\n' 'm = p1.p2.p3.m1, pkg1.mod1\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'import p1.p2.p3.m1\nfrom pkg1 import mod1\n\n\n' 'm = p1.p2.p3.m1, mod1\n', self.import_tools.handle_long_imports( @@ -972,7 +972,7 @@ def test_filtering_and_import_actions_with_more_than_one_phase(self): self.mod.write('from pkg1 import *\nfrom pkg2 import *\n\n' 'print(var2)\n') pymod = self.project.get_pymodule(self.mod) - self.assertEqual( + self.assertEquals( 'from pkg2 import *\n\nprint(var2)\n', self.import_tools.expand_stars(pymod, self._line_filter(1))) @@ -983,7 +983,7 @@ def test_non_existent_module_and_used_imports(self): module_with_imports = self.import_tools.module_imports(pymod) imports = module_with_imports.get_used_imports(pymod) - self.assertEqual(1, len(imports)) + self.assertEquals(1, len(imports)) class AddImportTest(unittest.TestCase): @@ -1006,24 +1006,24 @@ def test_normal_imports(self): self.mod1.write('\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'mod2', 'myvar') - self.assertEqual('import mod2\n', result) - self.assertEqual('mod2.myvar', name) + self.assertEquals('import mod2\n', result) + self.assertEquals('mod2.myvar', name) def test_not_reimporting_a_name(self): self.mod2.write('myvar = None\n') self.mod1.write('from mod2 import myvar\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'mod2', 'myvar') - self.assertEqual('from mod2 import myvar\n', result) - self.assertEqual('myvar', name) + self.assertEquals('from mod2 import myvar\n', result) + self.assertEquals('myvar', name) def test_adding_import_when_siblings_are_imported(self): self.mod2.write('var1 = None\nvar2 = None\n') self.mod1.write('from mod2 import var1\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'mod2', 'var2') - self.assertEqual('from mod2 import var1, var2\n', result) - self.assertEqual('var2', name) + self.assertEquals('from mod2 import var1, var2\n', result) + self.assertEquals('var2', name) def test_adding_import_when_the_package_is_imported(self): self.pkg.get_child('__init__.py').write('var1 = None\n') @@ -1031,8 +1031,8 @@ def test_adding_import_when_the_package_is_imported(self): self.mod1.write('from pkg import var1\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'pkg.mod3', 'var2') - self.assertEqual('from pkg import var1, mod3\n', result) - self.assertEqual('mod3.var2', name) + self.assertEquals('from pkg import var1, mod3\n', result) + self.assertEquals('mod3.var2', name) def test_adding_import_for_modules_instead_of_names(self): self.pkg.get_child('__init__.py').write('var1 = None\n') @@ -1040,8 +1040,8 @@ def test_adding_import_for_modules_instead_of_names(self): self.mod1.write('from pkg import var1\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'pkg.mod3', None) - self.assertEqual('from pkg import var1, mod3\n', result) - self.assertEqual('mod3', name) + self.assertEquals('from pkg import var1, mod3\n', result) + self.assertEquals('mod3', name) def test_adding_import_for_modules_with_normal_duplicate_imports(self): self.pkg.get_child('__init__.py').write('var1 = None\n') @@ -1049,8 +1049,8 @@ def test_adding_import_for_modules_with_normal_duplicate_imports(self): self.mod1.write('import pkg.mod3\n') pymod = self.project.get_module('mod1') result, name = add_import(self.project, pymod, 'pkg.mod3', None) - self.assertEqual('import pkg.mod3\n', result) - self.assertEqual('pkg.mod3', name) + self.assertEquals('import pkg.mod3\n', result) + self.assertEquals('pkg.mod3', name) def suite(): diff --git a/ropetest/refactor/inlinetest.py b/ropetest/refactor/inlinetest.py index bbc66ffb9..3dfd13457 100644 --- a/ropetest/refactor/inlinetest.py +++ b/ropetest/refactor/inlinetest.py @@ -35,32 +35,32 @@ def _inline2(self, resource, offset, **kwds): def test_simple_case(self): code = 'a_var = 10\nanother_var = a_var\n' refactored = self._inline(code, code.index('a_var') + 1) - self.assertEqual('another_var = 10\n', refactored) + self.assertEquals('another_var = 10\n', refactored) def test_empty_case(self): code = 'a_var = 10\n' refactored = self._inline(code, code.index('a_var') + 1) - self.assertEqual('', refactored) + self.assertEquals('', refactored) def test_long_definition(self): code = 'a_var = 10 + (10 + 10)\nanother_var = a_var\n' refactored = self._inline(code, code.index('a_var') + 1) - self.assertEqual('another_var = 10 + (10 + 10)\n', refactored) + self.assertEquals('another_var = 10 + (10 + 10)\n', refactored) def test_explicit_continuation(self): code = 'a_var = (10 +\n 10)\nanother_var = a_var\n' refactored = self._inline(code, code.index('a_var') + 1) - self.assertEqual('another_var = (10 + 10)\n', refactored) + self.assertEquals('another_var = (10 + 10)\n', refactored) def test_implicit_continuation(self): code = 'a_var = 10 +\\\n 10\nanother_var = a_var\n' refactored = self._inline(code, code.index('a_var') + 1) - self.assertEqual('another_var = 10 + 10\n', refactored) + self.assertEquals('another_var = 10 + 10\n', refactored) def test_inlining_at_the_end_of_input(self): code = 'a = 1\nb = a' refactored = self._inline(code, code.index('a') + 1) - self.assertEqual('b = 1', refactored) + self.assertEquals('b = 1', refactored) def test_on_classes(self): code = 'class AClass(object):\n pass\n' @@ -88,7 +88,7 @@ def test_attribute_inlining(self): refactored = self._inline(code, code.index('an_attr') + 1) expected = 'class A(object):\n def __init__(self):\n' \ ' range(3)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_attribute_inlining2(self): code = 'class A(object):\n def __init__(self):\n' \ @@ -98,31 +98,31 @@ def test_attribute_inlining2(self): expected = 'class A(object):\n def __init__(self):\n' \ ' range(3)\n' \ 'a = A()\nrange(3)' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_a_function_with_no_occurance(self): self.mod.write('def a_func():\n pass\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('', self.mod.read()) + self.assertEquals('', self.mod.read()) def test_a_function_with_no_occurance2(self): self.mod.write('a_var = 10\ndef a_func():\n pass\nprint(a_var)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('a_var = 10\nprint(a_var)\n', self.mod.read()) + self.assertEquals('a_var = 10\nprint(a_var)\n', self.mod.read()) def test_replacing_calls_with_function_definition_in_other_modules(self): self.mod.write('def a_func():\n print(1)\n') mod1 = testutils.create_module(self.project, 'mod1') mod1.write('import mod\nmod.a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('import mod\nprint(1)\n', mod1.read()) + self.assertEquals('import mod\nprint(1)\n', mod1.read()) def test_replacing_calls_with_function_definition_in_other_modules2(self): self.mod.write('def a_func():\n print(1)\n') mod1 = testutils.create_module(self.project, 'mod1') mod1.write('import mod\nif True:\n mod.a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('import mod\nif True:\n print(1)\n', mod1.read()) + self.assertEquals('import mod\nif True:\n print(1)\n', mod1.read()) def test_replacing_calls_with_method_definition_in_other_modules(self): self.mod.write('class A(object):\n var = 10\n' @@ -130,63 +130,63 @@ def test_replacing_calls_with_method_definition_in_other_modules(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write('import mod\nmod.A().a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('import mod\nprint(1)\n', mod1.read()) - self.assertEqual('class A(object):\n var = 10\n', self.mod.read()) + self.assertEquals('import mod\nprint(1)\n', mod1.read()) + self.assertEquals('class A(object):\n var = 10\n', self.mod.read()) def test_replacing_calls_with_function_definition_in_defining_module(self): self.mod.write('def a_func():\n print(1)\na_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('print(1)\n', self.mod.read()) + self.assertEquals('print(1)\n', self.mod.read()) def test_replac_calls_with_function_definition_in_defining_module2(self): self.mod.write('def a_func():\n ' 'for i in range(10):\n print(1)\na_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('for i in range(10):\n print(1)\n', + self.assertEquals('for i in range(10):\n print(1)\n', self.mod.read()) def test_replacing_calls_with_method_definition_in_defining_modules(self): self.mod.write('class A(object):\n var = 10\n' ' def a_func(self):\n print(1)\nA().a_func()') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('class A(object):\n var = 10\nprint(1)\n', + self.assertEquals('class A(object):\n var = 10\nprint(1)\n', self.mod.read()) def test_parameters_with_the_same_name_as_passed(self): self.mod.write('def a_func(var):\n ' 'print(var)\nvar = 1\na_func(var)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('var = 1\nprint(var)\n', self.mod.read()) + self.assertEquals('var = 1\nprint(var)\n', self.mod.read()) def test_parameters_with_the_same_name_as_passed2(self): self.mod.write('def a_func(var):\n ' 'print(var)\nvar = 1\na_func(var=var)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('var = 1\nprint(var)\n', self.mod.read()) + self.assertEquals('var = 1\nprint(var)\n', self.mod.read()) def test_simple_parameters_renaming(self): self.mod.write('def a_func(param):\n ' 'print(param)\nvar = 1\na_func(var)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('var = 1\nprint(var)\n', self.mod.read()) + self.assertEquals('var = 1\nprint(var)\n', self.mod.read()) def test_simple_parameters_renaming_for_multiple_params(self): self.mod.write('def a_func(param1, param2):\n p = param1 + param2\n' 'var1 = 1\nvar2 = 1\na_func(var1, var2)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('var1 = 1\nvar2 = 1\np = var1 + var2\n', + self.assertEquals('var1 = 1\nvar2 = 1\np = var1 + var2\n', self.mod.read()) def test_parameters_renaming_for_passed_constants(self): self.mod.write('def a_func(param):\n print(param)\na_func(1)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('print(1)\n', self.mod.read()) + self.assertEquals('print(1)\n', self.mod.read()) def test_parameters_renaming_for_passed_statements(self): self.mod.write('def a_func(param):\n ' 'print(param)\na_func((1 + 2) / 3)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('print((1 + 2) / 3)\n', self.mod.read()) + self.assertEquals('print((1 + 2) / 3)\n', self.mod.read()) def test_simple_parameters_renam_for_multiple_params_using_keywords(self): self.mod.write('def a_func(param1, param2):\n ' @@ -194,35 +194,35 @@ def test_simple_parameters_renam_for_multiple_params_using_keywords(self): 'var1 = 1\nvar2 = 1\n' 'a_func(param2=var1, param1=var2)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('var1 = 1\nvar2 = 1\np = var2 + var1\n', + self.assertEquals('var1 = 1\nvar2 = 1\np = var2 + var1\n', self.mod.read()) def test_simple_params_renam_for_multi_params_using_mixed_keywords(self): self.mod.write('def a_func(param1, param2):\n p = param1 + param2\n' 'var1 = 1\nvar2 = 1\na_func(var2, param2=var1)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('var1 = 1\nvar2 = 1\np = var2 + var1\n', + self.assertEquals('var1 = 1\nvar2 = 1\np = var2 + var1\n', self.mod.read()) def test_simple_putting_in_default_arguments(self): self.mod.write('def a_func(param=None):\n print(param)\n' 'a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('print(None)\n', self.mod.read()) + self.assertEquals('print(None)\n', self.mod.read()) def test_overriding_default_arguments(self): self.mod.write('def a_func(param1=1, param2=2):' '\n print(param1, param2)\n' 'a_func(param2=3)\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('print(1, 3)\n', self.mod.read()) + self.assertEquals('print(1, 3)\n', self.mod.read()) def test_badly_formatted_text(self): self.mod.write('def a_func ( param1 = 1 ,param2 = 2 ) :' '\n print(param1, param2)\n' 'a_func ( param2 \n = 3 ) \n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('print(1, 3)\n', self.mod.read()) + self.assertEquals('print(1, 3)\n', self.mod.read()) def test_passing_first_arguments_for_methods(self): a_class = 'class A(object):\n' \ @@ -237,7 +237,7 @@ def test_passing_first_arguments_for_methods(self): ' def __init__(self):\n' \ ' self.var = 1\n' \ ' print(self.var)\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_passing_first_arguments_for_methods2(self): a_class = 'class A(object):\n' \ @@ -254,7 +254,7 @@ def test_passing_first_arguments_for_methods2(self): ' self.var = 1\n' \ 'an_a = A()\n' \ 'print(1, an_a.var)\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_passing_first_arguments_for_methods3(self): a_class = 'class A(object):\n' \ @@ -271,7 +271,7 @@ def test_passing_first_arguments_for_methods3(self): ' self.var = 1\n' \ 'an_a = A()\n' \ 'print(1, an_a.var)\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_inlining_staticmethods(self): a_class = 'class A(object):\n' \ @@ -284,7 +284,7 @@ def test_inlining_staticmethods(self): expected = 'class A(object):\n' \ ' pass\n' \ 'print(1)\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_static_methods2(self): a_class = 'class A(object):\n' \ @@ -302,7 +302,7 @@ def test_static_methods2(self): 'an_a = A()\n' \ 'print(1)\n' \ 'print(2)\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_inlining_classmethods(self): a_class = 'class A(object):\n' \ @@ -315,7 +315,7 @@ def test_inlining_classmethods(self): expected = 'class A(object):\n' \ ' pass\n' \ 'print(1)\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_inlining_classmethods2(self): a_class = 'class A(object):\n' \ @@ -328,24 +328,24 @@ def test_inlining_classmethods2(self): expected = 'class A(object):\n' \ ' pass\n' \ 'print(A)\n' - self.assertEqual(expected, self.mod.read()) + self.assertEquals(expected, self.mod.read()) def test_simple_return_values_and_inlining_functions(self): self.mod.write('def a_func():\n return 1\na = a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('a = 1\n', + self.assertEquals('a = 1\n', self.mod.read()) def test_simple_return_values_and_inlining_lonely_functions(self): self.mod.write('def a_func():\n return 1\na_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('1\n', self.mod.read()) + self.assertEquals('1\n', self.mod.read()) def test_empty_returns_and_inlining_lonely_functions(self): self.mod.write('def a_func():\n ' 'if True:\n return\na_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('if True:\n pass\n', self.mod.read()) + self.assertEquals('if True:\n pass\n', self.mod.read()) def test_multiple_returns(self): self.mod.write('def less_than_five(var):\n if var < 5:\n' @@ -359,7 +359,7 @@ def test_multiple_returns_and_not_using_the_value(self): ' return True\n ' 'return False\nless_than_five(2)\n') self._inline2(self.mod, self.mod.read().index('less') + 1) - self.assertEqual('if 2 < 5:\n True\nFalse\n', self.mod.read()) + self.assertEquals('if 2 < 5:\n True\nFalse\n', self.mod.read()) def test_raising_exception_for_list_arguments(self): self.mod.write('def a_func(*args):\n print(args)\na_func(1)\n') @@ -377,7 +377,7 @@ def test_function_parameters_and_returns_in_other_functions(self): 'range(a_func(20, param2=abs(10)))\n' self.mod.write(code) self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('range(20 + abs(10))\n', self.mod.read()) + self.assertEquals('range(20 + abs(10))\n', self.mod.read()) def test_function_references_other_than_call(self): self.mod.write('def a_func(param):\n print(param)\nf = a_func\n') @@ -398,60 +398,60 @@ def test_recursive_functions(self): def xxx_test_inlining_function_default_parameters(self): self.mod.write('def a_func(p1=1):\n pass\na_func()\n') self._inline2(self.mod, self.mod.read().index('p1') + 1) - self.assertEqual('def a_func(p1=1):\n pass\na_func()\n', + self.assertEquals('def a_func(p1=1):\n pass\na_func()\n', self.mod.read()) def test_simple_inlining_after_extra_indented_lines(self): self.mod.write('def a_func():\n for i in range(10):\n pass\n' 'if True:\n pass\na_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('if True:\n pass\nfor i in range(10):' + self.assertEquals('if True:\n pass\nfor i in range(10):' '\n pass\n', self.mod.read()) def test_inlining_a_function_with_pydoc(self): self.mod.write('def a_func():\n """docs"""\n a = 1\na_func()') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('a = 1\n', self.mod.read()) + self.assertEquals('a = 1\n', self.mod.read()) def test_inlining_methods(self): self.mod.write("class A(object):\n name = 'hey'\n" " def get_name(self):\n return self.name\n" "a = A()\nname = a.get_name()\n") self._inline2(self.mod, self.mod.read().rindex('get_name') + 1) - self.assertEqual("class A(object):\n name = 'hey'\n" + self.assertEquals("class A(object):\n name = 'hey'\n" "a = A()\nname = a.name\n", self.mod.read()) def test_simple_returns_with_backslashes(self): self.mod.write('def a_func():\n return 1' '\\\n + 2\na = a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('a = 1 + 2\n', self.mod.read()) + self.assertEquals('a = 1 + 2\n', self.mod.read()) def test_a_function_with_pass_body(self): self.mod.write('def a_func():\n print(1)\na = a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func') + 1) - self.assertEqual('print(1)\na = None\n', self.mod.read()) + self.assertEquals('print(1)\na = None\n', self.mod.read()) def test_inlining_the_last_method_of_a_class(self): self.mod.write('class A(object):\n' ' def a_func(self):\n pass\n') self._inline2(self.mod, self.mod.read().rindex('a_func') + 1) - self.assertEqual('class A(object):\n pass\n', + self.assertEquals('class A(object):\n pass\n', self.mod.read()) def test_adding_needed_imports_in_the_dest_module(self): self.mod.write('import sys\n\ndef ver():\n print(sys.version)\n') self.mod2.write('import mod\n\nmod.ver()') self._inline2(self.mod, self.mod.read().index('ver') + 1) - self.assertEqual('import mod\nimport sys\n\nprint(sys.version)\n', + self.assertEquals('import mod\nimport sys\n\nprint(sys.version)\n', self.mod2.read()) def test_adding_needed_imports_in_the_dest_module_removing_selfs(self): self.mod.write('import mod2\n\ndef f():\n print(mod2.var)\n') self.mod2.write('import mod\n\nvar = 1\nmod.f()\n') self._inline2(self.mod, self.mod.read().index('f(') + 1) - self.assertEqual('import mod\n\nvar = 1\nprint(var)\n', + self.assertEquals('import mod\n\nvar = 1\nprint(var)\n', self.mod2.read()) def test_handling_relative_imports_when_inlining(self): @@ -469,7 +469,7 @@ def test_adding_needed_imports_for_elements_in_source(self): self.mod.write('def f1():\n return f2()\ndef f2():\n return 1\n') self.mod2.write('import mod\n\nprint(mod.f1())\n') self._inline2(self.mod, self.mod.read().index('f1') + 1) - self.assertEqual('import mod\nfrom mod import f2\n\nprint(f2())\n', + self.assertEquals('import mod\nfrom mod import f2\n\nprint(f2())\n', self.mod2.read()) def test_relative_imports_and_changing_inlining_body(self): @@ -480,7 +480,7 @@ def test_relative_imports_and_changing_inlining_body(self): mod3.write('import mod4\n\ndef f():\n print(mod4.var)\n') self.mod.write('import pkg.mod3\n\npkg.mod3.f()\n') self._inline2(self.mod, self.mod.read().index('f(') + 1) - self.assertEqual( + self.assertEquals( 'import pkg.mod3\nimport pkg.mod4\n\nprint(pkg.mod4.var)\n', self.mod.read()) @@ -488,49 +488,49 @@ def test_inlining_with_different_returns(self): self.mod.write('def f(p):\n return p\n' 'print(f(1))\nprint(f(2))\nprint(f(1))\n') self._inline2(self.mod, self.mod.read().index('f(') + 1) - self.assertEqual('print(1)\nprint(2)\nprint(1)\n', + self.assertEquals('print(1)\nprint(2)\nprint(1)\n', self.mod.read()) def test_not_removing_definition_for_variables(self): code = 'a_var = 10\nanother_var = a_var\n' refactored = self._inline(code, code.index('a_var') + 1, remove=False) - self.assertEqual('a_var = 10\nanother_var = 10\n', refactored) + self.assertEquals('a_var = 10\nanother_var = 10\n', refactored) def test_not_removing_definition_for_methods(self): code = 'def func():\n print(1)\n\nfunc()\n' refactored = self._inline(code, code.index('func') + 1, remove=False) - self.assertEqual('def func():\n print(1)\n\nprint(1)\n', + self.assertEquals('def func():\n print(1)\n\nprint(1)\n', refactored) def test_only_current_for_methods(self): code = 'def func():\n print(1)\n\nfunc()\nfunc()\n' refactored = self._inline(code, code.rindex('func') + 1, remove=False, only_current=True) - self.assertEqual('def func():\n print(1)\n\nfunc()\nprint(1)\n', + self.assertEquals('def func():\n print(1)\n\nfunc()\nprint(1)\n', refactored) def test_only_current_for_variables(self): code = 'one = 1\n\na = one\nb = one\n' refactored = self._inline(code, code.rindex('one') + 1, remove=False, only_current=True) - self.assertEqual('one = 1\n\na = one\nb = 1\n', refactored) + self.assertEquals('one = 1\n\na = one\nb = 1\n', refactored) def test_inlining_one_line_functions(self): code = 'def f(): return 1\nvar = f()\n' refactored = self._inline(code, code.rindex('f')) - self.assertEqual('var = 1\n', refactored) + self.assertEquals('var = 1\n', refactored) def test_inlining_one_line_functions_with_breaks(self): code = 'def f(\np): return p\nvar = f(1)\n' refactored = self._inline(code, code.rindex('f')) - self.assertEqual('var = 1\n', refactored) + self.assertEquals('var = 1\n', refactored) def test_inlining_one_line_functions_with_breaks2(self): code = 'def f(\n): return 1\nvar = f()\n' refactored = self._inline(code, code.rindex('f')) - self.assertEqual('var = 1\n', refactored) + self.assertEquals('var = 1\n', refactored) def test_resources_parameter(self): self.mod.write('def a_func():\n print(1)\n') @@ -538,29 +538,29 @@ def test_resources_parameter(self): mod1.write('import mod\nmod.a_func()\n') self._inline2(self.mod, self.mod.read().index('a_func'), resources=[self.mod]) - self.assertEqual('', self.mod.read()) - self.assertEqual('import mod\nmod.a_func()\n', mod1.read()) + self.assertEquals('', self.mod.read()) + self.assertEquals('import mod\nmod.a_func()\n', mod1.read()) def test_inlining_parameters(self): code = 'def f(p=1):\n pass\nf()\n' result = self._inline(code, code.index('p')) - self.assertEqual('def f(p=1):\n pass\nf(1)\n', result) + self.assertEquals('def f(p=1):\n pass\nf(1)\n', result) def test_inlining_function_with_line_breaks_in_args(self): code = 'def f(p): return p\nvar = f(1 +\n1)\n' refactored = self._inline(code, code.rindex('f')) - self.assertEqual('var = 1 + 1\n', refactored) + self.assertEquals('var = 1 + 1\n', refactored) def test_inlining_variables_before_comparison(self): code = 'start = 1\nprint(start <= 2)\n' refactored = self._inline(code, code.index('start')) - self.assertEqual('print(1 <= 2)\n', refactored) + self.assertEquals('print(1 <= 2)\n', refactored) def test_inlining_variables_in_other_modules(self): self.mod.write('myvar = 1\n') self.mod2.write('import mod\nprint(mod.myvar)\n') self._inline2(self.mod, 2) - self.assertEqual('import mod\nprint(1)\n', self.mod2.read()) + self.assertEquals('import mod\nprint(1)\n', self.mod2.read()) def test_inlining_variables_and_back_importing(self): self.mod.write('mainvar = 1\nmyvar = mainvar\n') @@ -569,7 +569,7 @@ def test_inlining_variables_and_back_importing(self): expected = 'import mod\n' \ 'from mod import mainvar\n' \ 'print(mainvar)\n' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) def test_inlining_variables_and_importing_used_imports(self): self.mod.write('import sys\nmyvar = sys.argv\n') @@ -578,19 +578,19 @@ def test_inlining_variables_and_importing_used_imports(self): expected = 'import mod\n' \ 'import sys\n' \ 'print(sys.argv)\n' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) def test_inlining_variables_and_removing_old_froms(self): self.mod.write('var = 1\n') self.mod2.write('from mod import var\nprint(var)\n') self._inline2(self.mod2, self.mod2.read().rindex('var')) - self.assertEqual('print(1)\n', self.mod2.read()) + self.assertEquals('print(1)\n', self.mod2.read()) def test_inlining_method_and_removing_old_froms(self): self.mod.write('def f(): return 1\n') self.mod2.write('from mod import f\nprint(f())\n') self._inline2(self.mod2, self.mod2.read().rindex('f')) - self.assertEqual('print(1)\n', self.mod2.read()) + self.assertEquals('print(1)\n', self.mod2.read()) def test_inlining_functions_in_other_modules_and_only_current(self): code1 = 'def f():\n' \ @@ -606,8 +606,8 @@ def test_inlining_functions_in_other_modules_and_only_current(self): expected2 = 'import mod\n' \ 'print(mod.f())\n' \ 'print(1)\n' - self.assertEqual(code1, self.mod.read()) - self.assertEqual(expected2, self.mod2.read()) + self.assertEquals(code1, self.mod.read()) + self.assertEquals(expected2, self.mod2.read()) def test_inlining_variables_in_other_modules_and_only_current(self): code1 = 'var = 1\n' \ @@ -622,8 +622,8 @@ def test_inlining_variables_in_other_modules_and_only_current(self): expected2 = 'import mod\n' \ 'print(mod.var)\n' \ 'print(1)\n' - self.assertEqual(code1, self.mod.read()) - self.assertEqual(expected2, self.mod2.read()) + self.assertEquals(code1, self.mod.read()) + self.assertEquals(expected2, self.mod2.read()) def test_inlining_does_not_change_string_constants(self): code = 'var = 1\n' \ @@ -634,7 +634,7 @@ def test_inlining_does_not_change_string_constants(self): '")\n' refactored = self._inline(code, code.rindex('var'), remove=False, only_current=True, docs=False) - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_inlining_does_change_string_constants_if_docs_is_set(self): code = 'var = 1\n' \ @@ -645,7 +645,7 @@ def test_inlining_does_change_string_constants_if_docs_is_set(self): '")\n' refactored = self._inline(code, code.rindex('var'), remove=False, only_current=True, docs=True) - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def suite(): diff --git a/ropetest/refactor/movetest.py b/ropetest/refactor/movetest.py index 078c8ac2d..ad667cc77 100644 --- a/ropetest/refactor/movetest.py +++ b/ropetest/refactor/movetest.py @@ -33,8 +33,8 @@ def test_simple_moving(self): self.mod1.write('class AClass(object):\n pass\n') self._move(self.mod1, self.mod1.read().index('AClass') + 1, self.mod2) - self.assertEqual('', self.mod1.read()) - self.assertEqual('class AClass(object):\n pass\n', + self.assertEquals('', self.mod1.read()) + self.assertEquals('class AClass(object):\n pass\n', self.mod2.read()) def test_changing_other_modules_adding_normal_imports(self): @@ -42,7 +42,7 @@ def test_changing_other_modules_adding_normal_imports(self): self.mod3.write('import mod1\na_var = mod1.AClass()\n') self._move(self.mod1, self.mod1.read().index('AClass') + 1, self.mod2) - self.assertEqual('import mod1\nimport mod2\na_var = mod2.AClass()\n', + self.assertEquals('import mod1\nimport mod2\na_var = mod2.AClass()\n', self.mod3.read()) def test_changing_other_modules_removing_from_imports(self): @@ -50,14 +50,14 @@ def test_changing_other_modules_removing_from_imports(self): self.mod3.write('from mod1 import AClass\na_var = AClass()\n') self._move(self.mod1, self.mod1.read().index('AClass') + 1, self.mod2) - self.assertEqual('import mod2\na_var = mod2.AClass()\n', + self.assertEquals('import mod2\na_var = mod2.AClass()\n', self.mod3.read()) def test_changing_source_module(self): self.mod1.write('class AClass(object):\n pass\na_var = AClass()\n') self._move(self.mod1, self.mod1.read().index('AClass') + 1, self.mod2) - self.assertEqual('import mod2\na_var = mod2.AClass()\n', + self.assertEquals('import mod2\na_var = mod2.AClass()\n', self.mod1.read()) def test_changing_destination_module(self): @@ -65,7 +65,7 @@ def test_changing_destination_module(self): self.mod2.write('from mod1 import AClass\na_var = AClass()\n') self._move(self.mod1, self.mod1.read().index('AClass') + 1, self.mod2) - self.assertEqual('class AClass(object):\n ' + self.assertEquals('class AClass(object):\n ' 'pass\na_var = AClass()\n', self.mod2.read()) @@ -98,7 +98,7 @@ def test_moving_used_imports_to_destination_module(self): expected = 'import mod3\n' \ 'from mod3 import a_var\n\n\n' \ 'def a_func():\n print(mod3, a_var)\n' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) def test_moving_used_names_to_destination_module2(self): code = 'a_var = 10\n' \ @@ -106,11 +106,11 @@ def test_moving_used_names_to_destination_module2(self): ' print(a_var)\n' self.mod1.write(code) self._move(self.mod1, code.index('a_func') + 1, self.mod2) - self.assertEqual('a_var = 10\n', self.mod1.read()) + self.assertEquals('a_var = 10\n', self.mod1.read()) expected = 'from mod1 import a_var\n\n\n' \ 'def a_func():\n' \ ' print(a_var)\n' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) def test_moving_used_underlined_names_to_destination_module(self): code = '_var = 10\n' \ @@ -121,7 +121,7 @@ def test_moving_used_underlined_names_to_destination_module(self): expected = 'from mod1 import _var\n\n\n' \ 'def a_func():\n' \ ' print(_var)\n' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) def test_moving_and_used_relative_imports(self): code = 'import mod5\n' \ @@ -132,14 +132,14 @@ def test_moving_and_used_relative_imports(self): expected = 'import pkg.mod5\n\n\n' \ 'def a_func():\n' \ ' print(pkg.mod5)\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_modules(self): code = 'import mod1\nprint(mod1)' self.mod2.write(code) self._move(self.mod2, code.index('mod1') + 1, self.pkg) expected = 'import pkg.mod1\nprint(pkg.mod1)' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) self.assertTrue(not self.mod1.exists() and self.project.find_module('pkg.mod1') is not None) @@ -148,14 +148,14 @@ def test_moving_modules_and_removing_out_of_date_imports(self): self.mod2.write(code) self._move(self.mod2, code.index('mod4') + 1, self.project.root) expected = 'import mod4\nprint(mod4)' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) self.assertTrue(self.project.find_module('mod4') is not None) def test_moving_modules_and_removing_out_of_date_froms(self): code = 'from pkg import mod4\nprint(mod4)' self.mod2.write(code) self._move(self.mod2, code.index('mod4') + 1, self.project.root) - self.assertEqual('import mod4\nprint(mod4)', self.mod2.read()) + self.assertEquals('import mod4\nprint(mod4)', self.mod2.read()) def test_moving_modules_and_removing_out_of_date_froms2(self): self.mod4.write('a_var = 10') @@ -163,7 +163,7 @@ def test_moving_modules_and_removing_out_of_date_froms2(self): self.mod2.write(code) self._move(self.mod2, code.index('mod4') + 1, self.project.root) expected = 'from mod4 import a_var\nprint(a_var)\n' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) def test_moving_modules_and_relative_import(self): self.mod4.write('import mod5\nprint(mod5)\n') @@ -172,7 +172,7 @@ def test_moving_modules_and_relative_import(self): self._move(self.mod2, code.index('mod4') + 1, self.project.root) moved = self.project.find_module('mod4') expected = 'import pkg.mod5\nprint(pkg.mod5)\n' - self.assertEqual(expected, moved.read()) + self.assertEquals(expected, moved.read()) def test_moving_packages(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -184,14 +184,14 @@ def test_moving_packages(self): self.assertTrue(self.project.find_module('pkg2.pkg.mod4') is not None) self.assertTrue(self.project.find_module('pkg2.pkg.mod5') is not None) expected = 'import pkg2.pkg.mod4\nprint(pkg2.pkg.mod4)' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_modules_with_self_imports(self): self.mod1.write('import mod1\nprint(mod1)\n') self.mod2.write('import mod1\n') self._move(self.mod2, self.mod2.read().index('mod1') + 1, self.pkg) moved = self.project.find_module('pkg.mod1') - self.assertEqual('import pkg.mod1\nprint(pkg.mod1)\n', moved.read()) + self.assertEquals('import pkg.mod1\nprint(pkg.mod1)\n', moved.read()) def test_moving_modules_with_from_imports(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -204,7 +204,7 @@ def test_moving_modules_with_from_imports(self): self.assertTrue(self.project.find_module('pkg2.pkg.mod5') is not None) expected = ('from pkg2.pkg import mod4\n' 'print(mod4)') - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_modules_with_from_import(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -218,7 +218,7 @@ def test_moving_modules_with_from_import(self): self.project.find_module('pkg2.pkg3.pkg4.mod4') is not None) expected = ('from pkg2.pkg3.pkg4 import mod4\n' 'print(mod4)') - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_modules_with_multi_from_imports(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -233,7 +233,7 @@ def test_moving_modules_with_multi_from_imports(self): expected = ('from pkg import mod5\n' 'from pkg2.pkg3.pkg4 import mod4\n' 'print(mod4)') - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_modules_with_from_and_normal_imports(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -251,7 +251,7 @@ def test_moving_modules_with_from_and_normal_imports(self): 'from pkg2.pkg3.pkg4 import mod4\n' 'print(mod4)\n' 'print(pkg2.pkg3.pkg4.mod4)') - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_modules_with_normal_and_from_imports(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -269,7 +269,7 @@ def test_moving_modules_with_normal_and_from_imports(self): 'from pkg2.pkg3.pkg4 import mod4\n' 'print(mod4)\n' 'print(pkg2.pkg3.pkg4.mod4)') - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_modules_from_import_variable(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -283,7 +283,7 @@ def test_moving_modules_from_import_variable(self): self.project.find_module('pkg2.pkg3.pkg4.mod4') is not None) expected = ('from pkg2.pkg3.pkg4.mod4 import foo\n' 'print(foo)') - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_modules_normal_import(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -297,7 +297,7 @@ def test_moving_modules_normal_import(self): self.project.find_module('pkg2.pkg3.pkg4.mod4') is not None) expected = ('import pkg2.pkg3.pkg4.mod4\n' 'print(pkg2.pkg3.pkg4.mod4)') - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_package_with_from_and_normal_imports(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -314,7 +314,7 @@ def test_moving_package_with_from_and_normal_imports(self): 'import pkg2.pkg.mod4\n' 'print(pkg2.pkg.mod4)\n' 'print(mod4)') - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_package_with_from_and_normal_imports2(self): pkg2 = testutils.create_package(self.project, 'pkg2') @@ -331,7 +331,7 @@ def test_moving_package_with_from_and_normal_imports2(self): 'from pkg2.pkg import mod4\n' 'print(pkg2.pkg.mod4)\n' 'print(mod4)') - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_package_and_retaining_blank_lines(self): pkg2 = testutils.create_package(self.project, 'pkg2', self.pkg) @@ -355,7 +355,7 @@ def test_moving_package_and_retaining_blank_lines(self): 'from pkg.pkg2 import mod4\n' 'print(pkg.pkg2.mod4)\n' 'print(mod4)') - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_funtions_to_imported_module(self): code = 'import mod1\n' \ @@ -367,7 +367,7 @@ def test_moving_funtions_to_imported_module(self): expected = 'def a_func():\n' \ ' var = a_var\n' \ 'a_var = 1\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_resources_using_move_module_refactoring(self): self.mod1.write('a_var = 1') @@ -375,7 +375,7 @@ def test_moving_resources_using_move_module_refactoring(self): mover = move.create_move(self.project, self.mod1) mover.get_changes(self.pkg).do() expected = 'import pkg.mod1\nmy_var = pkg.mod1.a_var\n' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) self.assertTrue(self.pkg.get_child('mod1.py') is not None) def test_moving_resources_using_move_module_for_packages(self): @@ -384,7 +384,7 @@ def test_moving_resources_using_move_module_for_packages(self): mover = move.create_move(self.project, self.pkg) mover.get_changes(pkg2).do() expected = 'import pkg2.pkg\nmy_pkg = pkg2.pkg' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) self.assertTrue(pkg2.get_child('pkg') is not None) def test_moving_resources_using_move_module_for_init_dot_py(self): @@ -393,7 +393,7 @@ def test_moving_resources_using_move_module_for_init_dot_py(self): init = self.pkg.get_child('__init__.py') mover = move.create_move(self.project, init) mover.get_changes(pkg2).do() - self.assertEqual('import pkg2.pkg\nmy_pkg = pkg2.pkg', + self.assertEquals('import pkg2.pkg\nmy_pkg = pkg2.pkg', self.mod1.read()) self.assertTrue(pkg2.get_child('pkg') is not None) @@ -402,7 +402,7 @@ def test_moving_module_and_star_imports(self): self.mod2.write('from mod1 import *\na = a_var\n') mover = move.create_move(self.project, self.mod1) mover.get_changes(self.pkg).do() - self.assertEqual('from pkg.mod1 import *\na = a_var\n', + self.assertEquals('from pkg.mod1 import *\na = a_var\n', self.mod2.read()) def test_moving_module_and_not_removing_blanks_after_imports(self): @@ -411,7 +411,7 @@ def test_moving_module_and_not_removing_blanks_after_imports(self): 'import os\n\n\nprint(mod4.a_var)\n') mover = move.create_move(self.project, self.mod4) mover.get_changes(self.project.root).do() - self.assertEqual('import os\nimport mod4\n\n\n' + self.assertEquals('import os\nimport mod4\n\n\n' 'print(mod4.a_var)\n', self.mod2.read()) def test_moving_module_refactoring_and_nonexistent_destinations(self): @@ -434,7 +434,7 @@ def test_moving_methods_getting_new_method_for_empty_methods(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEqual('def new_method(self):\n pass\n', + self.assertEquals('def new_method(self):\n pass\n', mover.get_new_method('new_method')) def test_moving_methods_getting_new_method_for_constant_methods(self): @@ -442,7 +442,7 @@ def test_moving_methods_getting_new_method_for_constant_methods(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEqual('def new_method(self):\n return 1\n', + self.assertEquals('def new_method(self):\n return 1\n', mover.get_new_method('new_method')) def test_moving_methods_getting_new_method_passing_simple_paremters(self): @@ -451,7 +451,7 @@ def test_moving_methods_getting_new_method_passing_simple_paremters(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEqual('def new_method(self, p):\n return p\n', + self.assertEquals('def new_method(self, p):\n return p\n', mover.get_new_method('new_method')) def test_moving_methods_getting_new_method_using_main_object(self): @@ -460,7 +460,7 @@ def test_moving_methods_getting_new_method_using_main_object(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEqual('def new_method(self, host):' + self.assertEquals('def new_method(self, host):' '\n return host.attr\n', mover.get_new_method('new_method')) @@ -470,7 +470,7 @@ def test_moving_methods_getting_new_method_renaming_main_object(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEqual('def new_method(self, host):' + self.assertEquals('def new_method(self, host):' '\n return host.attr\n', mover.get_new_method('new_method')) @@ -480,7 +480,7 @@ def test_moving_methods_gettin_new_method_with_keyword_arguments(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEqual('def new_method(self, p=None):\n return p\n', + self.assertEquals('def new_method(self, p=None):\n return p\n', mover.get_new_method('new_method')) def test_moving_methods_gettin_new_method_with_many_kinds_arguments(self): @@ -492,7 +492,7 @@ def test_moving_methods_gettin_new_method_with_many_kinds_arguments(self): code.index('a_method')) expected = 'def new_method(self, host, p1, *args, **kwds):\n' \ ' return host.attr\n' - self.assertEqual(expected, mover.get_new_method('new_method')) + self.assertEquals(expected, mover.get_new_method('new_method')) def test_moving_methods_getting_new_method_for_multi_line_methods(self): code = 'class A(object):\n' \ @@ -502,7 +502,7 @@ def test_moving_methods_getting_new_method_for_multi_line_methods(self): self.mod1.write(code) mover = move.create_move(self.project, self.mod1, code.index('a_method')) - self.assertEqual( + self.assertEquals( 'def new_method(self):\n a = 2\n return a\n', mover.get_new_method('new_method')) @@ -522,7 +522,7 @@ def test_moving_methods_getting_old_method_for_constant_methods(self): ' attr = mod2.B()\n' \ ' def a_method(self):\n' \ ' return self.attr.new_method()\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_moving_methods_getting_getting_changes_for_goal_class(self): self.mod2.write('class B(object):\n var = 1\n') @@ -539,7 +539,7 @@ def test_moving_methods_getting_getting_changes_for_goal_class(self): ' var = 1\n\n\n' \ ' def new_method(self):\n' \ ' return 1\n' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) def test_moving_methods_getting_getting_changes_for_goal_class2(self): code = 'class B(object):\n var = 1\n\n' \ @@ -549,7 +549,7 @@ def test_moving_methods_getting_getting_changes_for_goal_class2(self): mover = move.create_move(self.project, self.mod1, code.index('a_method')) mover.get_changes('attr', 'new_method').do() - self.assertEqual( + self.assertEquals( 'class B(object):\n var = 1\n\n\n' ' def new_method(self):\n' ' return 1\n\n' @@ -592,7 +592,7 @@ def test_moving_methods_and_moving_used_imports(self): ' var = 1\n\n\n' \ ' def new_method(self):\n' \ ' return sys.version\n' - self.assertEqual(code, self.mod2.read()) + self.assertEquals(code, self.mod2.read()) def test_moving_methods_getting_getting_changes_for_goal_class3(self): self.mod2.write('class B(object):\n pass\n') @@ -608,7 +608,7 @@ def test_moving_methods_getting_getting_changes_for_goal_class3(self): expected = 'class B(object):\n\n' \ ' def new_method(self):\n' \ ' return 1\n' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) def test_moving_methods_and_source_class_with_parameters(self): self.mod2.write('class B(object):\n pass\n') @@ -625,11 +625,11 @@ def test_moving_methods_and_source_class_with_parameters(self): ' attr = mod2.B()\n' \ ' def a_method(self, p):\n' \ ' return self.attr.new_method(p)\n' - self.assertEqual(expected1, self.mod1.read()) + self.assertEquals(expected1, self.mod1.read()) expected2 = 'class B(object):\n\n' \ ' def new_method(self, p):\n' \ ' return p\n' - self.assertEqual(expected2, self.mod2.read()) + self.assertEquals(expected2, self.mod2.read()) def test_moving_globals_to_a_module_with_only_docstrings(self): self.mod1.write('import sys\n\n\ndef f():\n print(sys.version)\n') @@ -637,7 +637,7 @@ def test_moving_globals_to_a_module_with_only_docstrings(self): mover = move.create_move(self.project, self.mod1, self.mod1.read().index('f()') + 1) self.project.do(mover.get_changes(self.mod2)) - self.assertEqual( + self.assertEquals( '"""doc\n\nMore docs ...\n\n"""\n' 'import sys\n\n\ndef f():\n print(sys.version)\n', self.mod2.read()) @@ -657,7 +657,7 @@ def test_moving_globals_to_a_module_with_only_docstrings2(self): 'import sys\n\n\n' \ 'def f():\n' \ ' print(sys.version, os.path)\n' - self.assertEqual(expected, self.mod2.read()) + self.assertEquals(expected, self.mod2.read()) def test_moving_a_global_when_it_is_used_after_a_multiline_str(self): code = 'def f():\n pass\ns = """\\\n"""\nr = f()\n' @@ -666,7 +666,7 @@ def test_moving_a_global_when_it_is_used_after_a_multiline_str(self): code.index('f()') + 1) self.project.do(mover.get_changes(self.mod2)) expected = 'import mod2\ns = """\\\n"""\nr = mod2.f()\n' - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) def test_raising_an_exception_when_moving_non_package_folders(self): dir = self.project.root.create_folder('dir') @@ -682,7 +682,7 @@ def test_moving_to_a_module_with_encoding_cookie(self): code2.index('f()') + 1) self.project.do(mover.get_changes(self.mod1)) expected = '%s\n%s' % (code1, code2) - self.assertEqual(expected, self.mod1.read()) + self.assertEquals(expected, self.mod1.read()) if __name__ == '__main__': diff --git a/ropetest/refactor/multiprojecttest.py b/ropetest/refactor/multiprojecttest.py index cdc3e564a..1801f3281 100644 --- a/ropetest/refactor/multiprojecttest.py +++ b/ropetest/refactor/multiprojecttest.py @@ -25,7 +25,7 @@ def test_trivial_rename(self): rename.Rename, []) renamer = refactoring(self.project1, self.mod1, 1) multiproject.perform(renamer.get_all_changes('newvar')) - self.assertEqual('newvar = 1\n', self.mod1.read()) + self.assertEquals('newvar = 1\n', self.mod1.read()) def test_rename(self): self.mod1.write('var = 1\n') @@ -34,8 +34,8 @@ def test_rename(self): rename.Rename, [self.project2]) renamer = refactoring(self.project1, self.mod1, 1) multiproject.perform(renamer.get_all_changes('newvar')) - self.assertEqual('newvar = 1\n', self.mod1.read()) - self.assertEqual('import mod1\nmyvar = mod1.newvar\n', + self.assertEquals('newvar = 1\n', self.mod1.read()) + self.assertEquals('import mod1\nmyvar = mod1.newvar\n', self.mod2.read()) def test_move(self): @@ -46,9 +46,9 @@ def test_move(self): renamer = refactoring(self.project1, self.mod1, self.mod1.read().index('_func')) multiproject.perform(renamer.get_all_changes(self.other)) - self.assertEqual('', self.mod1.read()) - self.assertEqual('def a_func():\n pass\n', self.other.read()) - self.assertEqual( + self.assertEquals('', self.mod1.read()) + self.assertEquals('def a_func():\n pass\n', self.other.read()) + self.assertEquals( 'import mod1\nimport other\nmyvar = other.a_func()\n', self.mod2.read()) @@ -61,8 +61,8 @@ def test_rename_from_the_project_not_containing_the_change(self): renamer = refactoring(self.project2, self.mod2, self.mod2.read().rindex('var')) multiproject.perform(renamer.get_all_changes('newvar')) - self.assertEqual('newvar = 1\n', self.mod1.read()) - self.assertEqual('import mod1\nmyvar = mod1.newvar\n', + self.assertEquals('newvar = 1\n', self.mod1.read()) + self.assertEquals('import mod1\nmyvar = mod1.newvar\n', self.mod2.read()) diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index 4850c1a68..75441b69c 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -33,62 +33,62 @@ def _rename(self, resource, offset, new_name, **kwds): def test_simple_global_variable_renaming(self): refactored = self._local_rename('a_var = 20\n', 2, 'new_var') - self.assertEqual('new_var = 20\n', refactored) + self.assertEquals('new_var = 20\n', refactored) def test_variable_renaming_only_in_its_scope(self): refactored = self._local_rename( 'a_var = 20\ndef a_func():\n a_var = 10\n', 32, 'new_var') - self.assertEqual('a_var = 20\ndef a_func():\n new_var = 10\n', + self.assertEquals('a_var = 20\ndef a_func():\n new_var = 10\n', refactored) def test_not_renaming_dot_name(self): refactored = self._local_rename( "replace = True\n'aaa'.replace('a', 'b')\n", 1, 'new_var') - self.assertEqual("new_var = True\n'aaa'.replace('a', 'b')\n", + self.assertEquals("new_var = True\n'aaa'.replace('a', 'b')\n", refactored) def test_renaming_multiple_names_in_the_same_line(self): refactored = self._local_rename( 'a_var = 10\na_var = 10 + a_var / 2\n', 2, 'new_var') - self.assertEqual('new_var = 10\nnew_var = 10 + new_var / 2\n', + self.assertEquals('new_var = 10\nnew_var = 10 + new_var / 2\n', refactored) def test_renaming_names_when_getting_some_attribute(self): refactored = self._local_rename( "a_var = 'a b c'\na_var.split('\\n')\n", 2, 'new_var') - self.assertEqual("new_var = 'a b c'\nnew_var.split('\\n')\n", + self.assertEquals("new_var = 'a b c'\nnew_var.split('\\n')\n", refactored) def test_renaming_names_when_getting_some_attribute2(self): refactored = self._local_rename( "a_var = 'a b c'\na_var.split('\\n')\n", 20, 'new_var') - self.assertEqual("new_var = 'a b c'\nnew_var.split('\\n')\n", + self.assertEquals("new_var = 'a b c'\nnew_var.split('\\n')\n", refactored) def test_renaming_function_parameters1(self): refactored = self._local_rename( "def f(a_param):\n print(a_param)\n", 8, 'new_param') - self.assertEqual("def f(new_param):\n print(new_param)\n", + self.assertEquals("def f(new_param):\n print(new_param)\n", refactored) def test_renaming_function_parameters2(self): refactored = self._local_rename( "def f(a_param):\n print(a_param)\n", 30, 'new_param') - self.assertEqual("def f(new_param):\n print(new_param)\n", + self.assertEquals("def f(new_param):\n print(new_param)\n", refactored) def test_renaming_occurrences_inside_functions(self): code = 'def a_func(p1):\n a = p1\na_func(1)\n' refactored = self._local_rename(code, code.index('p1') + 1, 'new_param') - self.assertEqual( + self.assertEquals( 'def a_func(new_param):\n a = new_param\na_func(1)\n', refactored) def test_renaming_arguments_for_normal_args_changing_calls(self): code = 'def a_func(p1=None, p2=None):\n pass\na_func(p2=1)\n' refactored = self._local_rename(code, code.index('p2') + 1, 'p3') - self.assertEqual( + self.assertEquals( 'def a_func(p1=None, p3=None):\n pass\na_func(p3=1)\n', refactored) @@ -101,7 +101,7 @@ def test_renaming_function_parameters_of_class_init(self): expected = 'class A(object):\n ' \ 'def __init__(self, new_param):\n pass\n' \ 'a_var = A(new_param=1)\n' - self.assertEqual(expected, refactored) + self.assertEquals(expected, refactored) def test_renam_functions_parameters_and_occurances_in_other_modules(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -109,57 +109,57 @@ def test_renam_functions_parameters_and_occurances_in_other_modules(self): mod1.write('def a_func(a_param):\n print(a_param)\n') mod2.write('from mod1 import a_func\na_func(a_param=10)\n') self._rename(mod1, mod1.read().index('a_param') + 1, 'new_param') - self.assertEqual('def a_func(new_param):\n print(new_param)\n', + self.assertEquals('def a_func(new_param):\n print(new_param)\n', mod1.read()) - self.assertEqual('from mod1 import a_func\na_func(new_param=10)\n', + self.assertEquals('from mod1 import a_func\na_func(new_param=10)\n', mod2.read()) def test_renaming_with_backslash_continued_names(self): refactored = self._local_rename( "replace = True\n'ali'.\\\nreplace\n", 2, 'is_replace') - self.assertEqual("is_replace = True\n'ali'.\\\nreplace\n", + self.assertEquals("is_replace = True\n'ali'.\\\nreplace\n", refactored) def test_not_renaming_string_contents(self): refactored = self._local_rename("a_var = 20\na_string='a_var'\n", 2, 'new_var') - self.assertEqual("new_var = 20\na_string='a_var'\n", + self.assertEquals("new_var = 20\na_string='a_var'\n", refactored) def test_not_renaming_comment_contents(self): refactored = self._local_rename("a_var = 20\n# a_var\n", 2, 'new_var') - self.assertEqual("new_var = 20\n# a_var\n", refactored) + self.assertEquals("new_var = 20\n# a_var\n", refactored) def test_renaming_all_occurances_in_containing_scope(self): code = 'if True:\n a_var = 1\nelse:\n a_var = 20\n' refactored = self._local_rename(code, 16, 'new_var') - self.assertEqual( + self.assertEquals( 'if True:\n new_var = 1\nelse:\n new_var = 20\n', refactored) def test_renaming_a_variable_with_arguement_name(self): code = 'a_var = 10\ndef a_func(a_var):\n print(a_var)\n' refactored = self._local_rename(code, 1, 'new_var') - self.assertEqual( + self.assertEquals( 'new_var = 10\ndef a_func(a_var):\n print(a_var)\n', refactored) def test_renaming_an_arguement_with_variable_name(self): code = 'a_var = 10\ndef a_func(a_var):\n print(a_var)\n' refactored = self._local_rename(code, len(code) - 3, 'new_var') - self.assertEqual( + self.assertEquals( 'a_var = 10\ndef a_func(new_var):\n print(new_var)\n', refactored) def test_renaming_function_with_local_variable_name(self): code = 'def a_func():\n a_func=20\na_func()' refactored = self._local_rename(code, len(code) - 3, 'new_func') - self.assertEqual('def new_func():\n a_func=20\nnew_func()', + self.assertEquals('def new_func():\n a_func=20\nnew_func()', refactored) def test_renaming_functions(self): code = 'def a_func():\n pass\na_func()\n' refactored = self._local_rename(code, len(code) - 5, 'new_func') - self.assertEqual('def new_func():\n pass\nnew_func()\n', + self.assertEquals('def new_func():\n pass\nnew_func()\n', refactored) def test_renaming_functions_across_modules(self): @@ -168,9 +168,9 @@ def test_renaming_functions_across_modules(self): mod2 = testutils.create_module(self.project, 'mod2') mod2.write('import mod1\nmod1.a_func()\n') self._rename(mod1, len(mod1.read()) - 5, 'new_func') - self.assertEqual('def new_func():\n pass\nnew_func()\n', + self.assertEquals('def new_func():\n pass\nnew_func()\n', mod1.read()) - self.assertEqual('import mod1\nmod1.new_func()\n', mod2.read()) + self.assertEquals('import mod1\nmod1.new_func()\n', mod2.read()) def test_renaming_functions_across_modules_from_import(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -178,9 +178,9 @@ def test_renaming_functions_across_modules_from_import(self): mod2 = testutils.create_module(self.project, 'mod2') mod2.write('from mod1 import a_func\na_func()\n') self._rename(mod1, len(mod1.read()) - 5, 'new_func') - self.assertEqual('def new_func():\n pass\nnew_func()\n', + self.assertEquals('def new_func():\n pass\nnew_func()\n', mod1.read()) - self.assertEqual('from mod1 import new_func\nnew_func()\n', + self.assertEquals('from mod1 import new_func\nnew_func()\n', mod2.read()) def test_renaming_functions_from_another_module(self): @@ -189,9 +189,9 @@ def test_renaming_functions_from_another_module(self): mod2 = testutils.create_module(self.project, 'mod2') mod2.write('import mod1\nmod1.a_func()\n') self._rename(mod2, len(mod2.read()) - 5, 'new_func') - self.assertEqual('def new_func():\n pass\nnew_func()\n', + self.assertEquals('def new_func():\n pass\nnew_func()\n', mod1.read()) - self.assertEqual('import mod1\nmod1.new_func()\n', mod2.read()) + self.assertEquals('import mod1\nmod1.new_func()\n', mod2.read()) def test_applying_all_changes_together(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -199,8 +199,8 @@ def test_applying_all_changes_together(self): mod2 = testutils.create_module(self.project, 'mod2') mod2.write('def a_func():\n pass\na_func()\n') self._rename(mod2, len(mod2.read()) - 5, 'new_func') - self.assertEqual('import mod2\nmod2.new_func()\n', mod1.read()) - self.assertEqual('def new_func():\n pass\nnew_func()\n', + self.assertEquals('import mod2\nmod2.new_func()\n', mod1.read()) + self.assertEquals('def new_func():\n pass\nnew_func()\n', mod2.read()) def test_renaming_modules(self): @@ -211,7 +211,7 @@ def test_renaming_modules(self): self._rename(mod2, mod2.read().index('mod1') + 1, 'newmod') self.assertTrue(not mod1.exists() and self.project.find_module('newmod') is not None) - self.assertEqual('from newmod import a_func\n', mod2.read()) + self.assertEquals('from newmod import a_func\n', mod2.read()) def test_renaming_packages(self): pkg = testutils.create_package(self.project, 'pkg') @@ -222,7 +222,7 @@ def test_renaming_packages(self): self._rename(mod2, 6, 'newpkg') self.assertTrue(self.project.find_module('newpkg.mod1') is not None) new_mod2 = self.project.find_module('newpkg.mod2') - self.assertEqual('from newpkg.mod1 import a_func\n', new_mod2.read()) + self.assertEquals('from newpkg.mod1 import a_func\n', new_mod2.read()) def test_module_dependencies(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -233,8 +233,8 @@ def test_module_dependencies(self): mod1.write('def AClass():\n return 0\n') self._rename(mod2, len(mod2.read()) - 3, 'a_func') - self.assertEqual('def a_func():\n return 0\n', mod1.read()) - self.assertEqual('import mod1\na_var = mod1.a_func()\n', mod2.read()) + self.assertEquals('def a_func():\n return 0\n', mod1.read()) + self.assertEquals('import mod1\na_var = mod1.a_func()\n', mod2.read()) def test_renaming_class_attributes(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -245,9 +245,9 @@ def test_renaming_class_attributes(self): 'another_var = a_var.an_attr') self._rename(mod1, mod1.read().index('an_attr'), 'attr') - self.assertEqual('class AClass(object):\n def __init__(self):\n' + self.assertEquals('class AClass(object):\n def __init__(self):\n' ' self.attr = 10\n', mod1.read()) - self.assertEqual( + self.assertEquals( 'import mod1\na_var = mod1.AClass()\nanother_var = a_var.attr', mod2.read()) @@ -260,10 +260,10 @@ def test_renaming_class_attributes2(self): 'another_var = a_var.an_attr') self._rename(mod1, mod1.read().rindex('an_attr'), 'attr') - self.assertEqual( + self.assertEquals( 'class AClass(object):\n def __init__(self):\n' ' an_attr = 10\n self.attr = 10\n', mod1.read()) - self.assertEqual( + self.assertEquals( 'import mod1\na_var = mod1.AClass()\nanother_var = a_var.attr', mod2.read()) @@ -274,7 +274,7 @@ def test_renaming_methods_in_subclasses(self): self._rename(mod, mod.read().rindex('a_method') + 1, 'new_method', in_hierarchy=True) - self.assertEqual( + self.assertEquals( 'class A(object):\n def new_method(self):\n pass\n' 'class B(A):\n def new_method(self):\n pass\n', mod.read()) @@ -287,7 +287,7 @@ def test_renaming_methods_in_sibling_classes(self): self._rename(mod, mod.read().rindex('a_method') + 1, 'new_method', in_hierarchy=True) - self.assertEqual( + self.assertEquals( 'class A(object):\n def new_method(self):\n pass\n' 'class B(A):\n def new_method(self):\n pass\n' 'class C(A):\n def new_method(self):\n pass\n', @@ -300,7 +300,7 @@ def test_not_renaming_methods_in_hierarchies(self): self._rename(mod, mod.read().rindex('a_method') + 1, 'new_method', in_hierarchy=False) - self.assertEqual( + self.assertEquals( 'class A(object):\n def a_method(self):\n pass\n' 'class B(A):\n def new_method(self):\n pass\n', mod.read()) @@ -310,7 +310,7 @@ def test_undoing_refactorings(self): mod1.write('def a_func():\n pass\na_func()\n') self._rename(mod1, len(mod1.read()) - 5, 'new_func') self.project.history.undo() - self.assertEqual('def a_func():\n pass\na_func()\n', mod1.read()) + self.assertEquals('def a_func():\n pass\na_func()\n', mod1.read()) def test_undoing_renaming_modules(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -319,8 +319,8 @@ def test_undoing_renaming_modules(self): mod2.write('from mod1 import a_func\n') self._rename(mod2, 6, 'newmod') self.project.history.undo() - self.assertEqual('mod1.py', mod1.path) - self.assertEqual('from mod1 import a_func\n', mod2.read()) + self.assertEquals('mod1.py', mod1.path) + self.assertEquals('from mod1 import a_func\n', mod2.read()) def test_rename_in_module_renaming_one_letter_names_for_expressions(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -331,25 +331,25 @@ def test_rename_in_module_renaming_one_letter_names_for_expressions(self): self.project, 'a', old_pyname) refactored = rename.rename_in_module( finder, 'new_var', pymodule=pymod, replace_primary=True) - self.assertEqual('new_var = 10\nprint(1+new_var)\n', refactored) + self.assertEquals('new_var = 10\nprint(1+new_var)\n', refactored) def test_renaming_for_loop_variable(self): code = 'for var in range(10):\n print(var)\n' refactored = self._local_rename(code, code.find('var') + 1, 'new_var') - self.assertEqual('for new_var in range(10):\n print(new_var)\n', + self.assertEquals('for new_var in range(10):\n print(new_var)\n', refactored) def test_renaming_parameters(self): code = 'def a_func(param):\n print(param)\na_func(param=hey)\n' refactored = self._local_rename(code, code.find('param') + 1, 'new_param') - self.assertEqual('def a_func(new_param):\n print(new_param)\n' + self.assertEquals('def a_func(new_param):\n print(new_param)\n' 'a_func(new_param=hey)\n', refactored) def test_renaming_assigned_parameters(self): code = 'def f(p):\n p = p + 1\n return p\nf(p=1)\n' refactored = self._local_rename(code, code.find('p'), 'arg') - self.assertEqual('def f(arg):\n arg = arg + 1\n' + self.assertEquals('def f(arg):\n arg = arg + 1\n' ' return arg\nf(arg=1)\n', refactored) def test_renaming_parameters_not_renaming_others(self): @@ -357,7 +357,7 @@ def test_renaming_parameters_not_renaming_others(self): '\n print(param)\nparam=10\na_func(param)\n' refactored = self._local_rename(code, code.find('param') + 1, 'new_param') - self.assertEqual('def a_func(new_param):\n print(new_param)\n' + self.assertEquals('def a_func(new_param):\n print(new_param)\n' 'param=10\na_func(param)\n', refactored) def test_renaming_parameters_not_renaming_others2(self): @@ -365,7 +365,7 @@ def test_renaming_parameters_not_renaming_others2(self): 'param=10\na_func(param=param)' refactored = self._local_rename(code, code.find('param') + 1, 'new_param') - self.assertEqual('def a_func(new_param):\n print(new_param)\n' + self.assertEquals('def a_func(new_param):\n print(new_param)\n' 'param=10\na_func(new_param=param)', refactored) def test_renaming_parameters_with_multiple_params(self): @@ -373,7 +373,7 @@ def test_renaming_parameters_with_multiple_params(self): 'a_func(param1=1, param2=2)\n' refactored = self._local_rename(code, code.find('param1') + 1, 'new_param') - self.assertEqual( + self.assertEquals( 'def a_func(new_param, param2):\n print(new_param)\n' 'a_func(new_param=1, param2=2)\n', refactored) @@ -382,28 +382,28 @@ def test_renaming_parameters_with_multiple_params2(self): 'a_func(param1=1, param2=2)\n' refactored = self._local_rename(code, code.rfind('param2') + 1, 'new_param') - self.assertEqual('def a_func(param1, new_param):\n print(param1)\n' + self.assertEquals('def a_func(param1, new_param):\n print(param1)\n' 'a_func(param1=1, new_param=2)\n', refactored) def test_renaming_parameters_on_calls(self): code = 'def a_func(param):\n print(param)\na_func(param = hey)\n' refactored = self._local_rename(code, code.rfind('param') + 1, 'new_param') - self.assertEqual('def a_func(new_param):\n print(new_param)\n' + self.assertEquals('def a_func(new_param):\n print(new_param)\n' 'a_func(new_param = hey)\n', refactored) def test_renaming_parameters_spaces_before_call(self): code = 'def a_func(param):\n print(param)\na_func (param=hey)\n' refactored = self._local_rename(code, code.rfind('param') + 1, 'new_param') - self.assertEqual('def a_func(new_param):\n print(new_param)\n' + self.assertEquals('def a_func(new_param):\n print(new_param)\n' 'a_func (new_param=hey)\n', refactored) def test_renaming_parameter_like_objects_after_keywords(self): code = 'def a_func(param):\n print(param)\ndict(param=hey)\n' refactored = self._local_rename(code, code.find('param') + 1, 'new_param') - self.assertEqual('def a_func(new_param):\n print(new_param)\n' + self.assertEquals('def a_func(new_param):\n print(new_param)\n' 'dict(param=hey)\n', refactored) def test_renaming_variables_in_init_dot_pys(self): @@ -413,8 +413,8 @@ def test_renaming_variables_in_init_dot_pys(self): mod = testutils.create_module(self.project, 'mod') mod.write('import pkg\nprint(pkg.a_var)\n') self._rename(mod, mod.read().index('a_var') + 1, 'new_var') - self.assertEqual('new_var = 10\n', init_dot_py.read()) - self.assertEqual('import pkg\nprint(pkg.new_var)\n', mod.read()) + self.assertEquals('new_var = 10\n', init_dot_py.read()) + self.assertEquals('import pkg\nprint(pkg.new_var)\n', mod.read()) def test_renaming_variables_in_init_dot_pys2(self): pkg = testutils.create_package(self.project, 'pkg') @@ -424,8 +424,8 @@ def test_renaming_variables_in_init_dot_pys2(self): mod.write('import pkg\nprint(pkg.a_var)\n') self._rename(init_dot_py, init_dot_py.read().index('a_var') + 1, 'new_var') - self.assertEqual('new_var = 10\n', init_dot_py.read()) - self.assertEqual('import pkg\nprint(pkg.new_var)\n', mod.read()) + self.assertEquals('new_var = 10\n', init_dot_py.read()) + self.assertEquals('import pkg\nprint(pkg.new_var)\n', mod.read()) def test_renaming_variables_in_init_dot_pys3(self): pkg = testutils.create_package(self.project, 'pkg') @@ -434,8 +434,8 @@ def test_renaming_variables_in_init_dot_pys3(self): mod = testutils.create_module(self.project, 'mod') mod.write('import pkg\nprint(pkg.a_var)\n') self._rename(mod, mod.read().index('a_var') + 1, 'new_var') - self.assertEqual('new_var = 10\n', init_dot_py.read()) - self.assertEqual('import pkg\nprint(pkg.new_var)\n', mod.read()) + self.assertEquals('new_var = 10\n', init_dot_py.read()) + self.assertEquals('import pkg\nprint(pkg.new_var)\n', mod.read()) def test_renaming_resources_using_rename_module_refactoring(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -444,7 +444,7 @@ def test_renaming_resources_using_rename_module_refactoring(self): mod2.write('import mod1\nmy_var = mod1.a_var\n') renamer = rename.Rename(self.project, mod1) renamer.get_changes('newmod').do() - self.assertEqual('import newmod\nmy_var = newmod.a_var\n', + self.assertEquals('import newmod\nmy_var = newmod.a_var\n', mod2.read()) def test_renam_resources_using_rename_module_refactor_for_packages(self): @@ -453,7 +453,7 @@ def test_renam_resources_using_rename_module_refactor_for_packages(self): mod1.write('import pkg\nmy_pkg = pkg') renamer = rename.Rename(self.project, pkg) renamer.get_changes('newpkg').do() - self.assertEqual('import newpkg\nmy_pkg = newpkg', mod1.read()) + self.assertEquals('import newpkg\nmy_pkg = newpkg', mod1.read()) def test_renam_resources_use_rename_module_refactor_for_init_dot_py(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -461,12 +461,12 @@ def test_renam_resources_use_rename_module_refactor_for_init_dot_py(self): mod1.write('import pkg\nmy_pkg = pkg') renamer = rename.Rename(self.project, pkg.get_child('__init__.py')) renamer.get_changes('newpkg').do() - self.assertEqual('import newpkg\nmy_pkg = newpkg', mod1.read()) + self.assertEquals('import newpkg\nmy_pkg = newpkg', mod1.read()) def test_renaming_global_variables(self): code = 'a_var = 1\ndef a_func():\n global a_var\n var = a_var\n' refactored = self._local_rename(code, code.index('a_var'), 'new_var') - self.assertEqual( + self.assertEquals( 'new_var = 1\ndef a_func():\n ' 'global new_var\n var = new_var\n', refactored) @@ -474,7 +474,7 @@ def test_renaming_global_variables(self): def test_renaming_global_variables2(self): code = 'a_var = 1\ndef a_func():\n global a_var\n var = a_var\n' refactored = self._local_rename(code, code.rindex('a_var'), 'new_var') - self.assertEqual( + self.assertEquals( 'new_var = 1\ndef a_func():\n ' 'global new_var\n var = new_var\n', refactored) @@ -486,7 +486,7 @@ def test_renaming_when_unsure(self): mod1.write(code) self._rename(mod1, code.index('a_func'), 'new_func', unsure=self._true) - self.assertEqual( + self.assertEquals( 'class C(object):\n def new_func(self):\n pass\n' 'def f(arg):\n arg.new_func()\n', mod1.read()) @@ -502,7 +502,7 @@ def confirm(occurrence): mod1 = testutils.create_module(self.project, 'mod1') mod1.write(code) self._rename(mod1, code.index('a_func'), 'new_func', unsure=confirm) - self.assertEqual( + self.assertEquals( 'class C(object):\n def new_func(self):\n pass\n' 'def f(arg):\n arg.a_func()\n', mod1.read()) @@ -513,7 +513,7 @@ def test_renaming_when_unsure_not_renaming_knowns(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write(code) self._rename(mod1, code.index('a_func'), 'new_func', unsure=self._true) - self.assertEqual( + self.assertEquals( 'class C1(object):\n def new_func(self):\n pass\n' 'class C2(object):\n def a_func(self):\n pass\n' 'c1 = C1()\nc1.new_func()\nc2 = C2()\nc2.a_func()\n', @@ -524,27 +524,27 @@ def test_renaming_in_strings_and_comments(self): mod1 = testutils.create_module(self.project, 'mod1') mod1.write(code) self._rename(mod1, code.index('a_var'), 'new_var', docs=True) - self.assertEqual('new_var = 1\n# new_var\n', mod1.read()) + self.assertEquals('new_var = 1\n# new_var\n', mod1.read()) def test_not_renaming_in_strings_and_comments_where_not_visible(self): code = 'def f():\n a_var = 1\n# a_var\n' mod1 = testutils.create_module(self.project, 'mod1') mod1.write(code) self._rename(mod1, code.index('a_var'), 'new_var', docs=True) - self.assertEqual('def f():\n new_var = 1\n# a_var\n', mod1.read()) + self.assertEquals('def f():\n new_var = 1\n# a_var\n', mod1.read()) def test_not_renaming_all_text_occurrences_in_strings_and_comments(self): code = 'a_var = 1\n# a_vard _a_var\n' mod1 = testutils.create_module(self.project, 'mod1') mod1.write(code) self._rename(mod1, code.index('a_var'), 'new_var', docs=True) - self.assertEqual('new_var = 1\n# a_vard _a_var\n', mod1.read()) + self.assertEquals('new_var = 1\n# a_vard _a_var\n', mod1.read()) def test_renaming_occurrences_in_overwritten_scopes(self): refactored = self._local_rename( 'a_var = 20\ndef f():\n print(a_var)\n' 'def f():\n print(a_var)\n', 2, 'new_var') - self.assertEqual('new_var = 20\ndef f():\n print(new_var)\n' + self.assertEquals('new_var = 20\ndef f():\n print(new_var)\n' 'def f():\n print(new_var)\n', refactored) def test_renaming_occurrences_in_overwritten_scopes2(self): @@ -552,13 +552,13 @@ def test_renaming_occurrences_in_overwritten_scopes2(self): 'def f():\n a_var = 1\n print(a_var)\n' refactored = self._local_rename(code, code.index('a_var') + 1, 'new_var') - self.assertEqual(code.replace('a_var', 'new_var', 2), refactored) + self.assertEquals(code.replace('a_var', 'new_var', 2), refactored) def test_dos_line_ending_and_renaming(self): code = '\r\na = 1\r\n\r\nprint(2 + a + 2)\r\n' offset = code.replace('\r\n', '\n').rindex('a') refactored = self._local_rename(code, offset, 'b') - self.assertEqual('\nb = 1\n\nprint(2 + b + 2)\n', + self.assertEquals('\nb = 1\n\nprint(2 + b + 2)\n', refactored.replace('\r\n', '\n')) def test_multi_byte_strs_and_renaming(self): @@ -566,7 +566,7 @@ def test_multi_byte_strs_and_renaming(self): code = u'# -*- coding: utf-8 -*-\n# ' + s + \ '\na = 1\nprint(2 + a + 2)\n' refactored = self._local_rename(code, code.rindex('a'), 'b') - self.assertEqual(u'# -*- coding: utf-8 -*-\n# ' + s + + self.assertEquals(u'# -*- coding: utf-8 -*-\n# ' + s + '\nb = 1\nprint(2 + b + 2)\n', refactored) def test_resources_parameter(self): @@ -576,8 +576,8 @@ def test_resources_parameter(self): mod2.write('import mod1\nmod1.f()\n') self._rename(mod1, mod1.read().rindex('f'), 'g', resources=[mod1]) - self.assertEqual('def g():\n pass\n', mod1.read()) - self.assertEqual('import mod1\nmod1.f()\n', mod2.read()) + self.assertEquals('def g():\n pass\n', mod1.read()) + self.assertEquals('import mod1\nmod1.f()\n', mod2.read()) def test_resources_parameter_not_changing_defining_module(self): mod1 = testutils.create_module(self.project, 'mod1') @@ -586,8 +586,8 @@ def test_resources_parameter_not_changing_defining_module(self): mod2.write('import mod1\nmod1.f()\n') self._rename(mod1, mod1.read().rindex('f'), 'g', resources=[mod2]) - self.assertEqual('def f():\n pass\n', mod1.read()) - self.assertEqual('import mod1\nmod1.g()\n', mod2.read()) + self.assertEquals('def f():\n pass\n', mod1.read()) + self.assertEquals('import mod1\nmod1.g()\n', mod2.read()) # XXX: with variables should not leak @testutils.only_for('2.5') @@ -599,7 +599,7 @@ def xxx_test_with_statement_variables_should_not_leak(self): mod1.write(code) self._rename(mod1, code.rindex('f'), 'file') expected = 'f = 1\nwith open("1.txt") as file:\n print(file)\n' - self.assertEqual(expected, mod1.read()) + self.assertEquals(expected, mod1.read()) class ChangeOccurrencesTest(unittest.TestCase): @@ -617,14 +617,14 @@ def test_simple_case(self): changer = rename.ChangeOccurrences(self.project, self.mod, self.mod.read().index('a_var')) changer.get_changes('new_var').do() - self.assertEqual('new_var = 1\nprint(new_var)\n', self.mod.read()) + self.assertEquals('new_var = 1\nprint(new_var)\n', self.mod.read()) def test_only_performing_inside_scopes(self): self.mod.write('a_var = 1\nnew_var = 2\ndef f():\n print(a_var)\n') changer = rename.ChangeOccurrences(self.project, self.mod, self.mod.read().rindex('a_var')) changer.get_changes('new_var').do() - self.assertEqual( + self.assertEquals( 'a_var = 1\nnew_var = 2\ndef f():\n print(new_var)\n', self.mod.read()) @@ -634,7 +634,7 @@ def test_only_performing_on_calls(self): changer = rename.ChangeOccurrences(self.project, self.mod, self.mod.read().rindex('f1')) changer.get_changes('f2', only_calls=True).do() - self.assertEqual( + self.assertEquals( 'def f1():\n pass\ndef f2():\n pass\ng = f1\na = f2()\n', self.mod.read()) @@ -643,7 +643,7 @@ def test_only_performing_on_reads(self): changer = rename.ChangeOccurrences(self.project, self.mod, self.mod.read().rindex('a')) changer.get_changes('b', writes=False).do() - self.assertEqual('a = 1\nb = 2\nprint(b)\n', self.mod.read()) + self.assertEquals('a = 1\nb = 2\nprint(b)\n', self.mod.read()) class ImplicitInterfacesTest(unittest.TestCase): @@ -672,8 +672,8 @@ def test_performing_rename_on_parameters(self): 'mod1.f(A())\nmod1.f(B())\n') self.pycore.analyze_module(self.mod2) self._rename(self.mod1, self.mod1.read().index('run'), 'newrun') - self.assertEqual('def f(arg):\n arg.newrun()\n', self.mod1.read()) - self.assertEqual( + self.assertEquals('def f(arg):\n arg.newrun()\n', self.mod1.read()) + self.assertEquals( 'import mod1\n\n\n' 'class A(object):\n def newrun(self):\n pass\n' 'class B(object):\n def newrun(self):\n pass\n' diff --git a/ropetest/refactor/restructuretest.py b/ropetest/refactor/restructuretest.py index 650b64ac0..b721e3085 100644 --- a/ropetest/refactor/restructuretest.py +++ b/ropetest/refactor/restructuretest.py @@ -21,42 +21,42 @@ def test_trivial_case(self): 'a = 1', 'a = 0') self.mod.write('b = 1\n') self.project.do(refactoring.get_changes()) - self.assertEqual('b = 1\n', self.mod.read()) + self.assertEquals('b = 1\n', self.mod.read()) def test_replacing_simple_patterns(self): refactoring = restructure.Restructure(self.project, 'a = 1', 'a = int(1)') self.mod.write('a = 1\nb = 1\n') self.project.do(refactoring.get_changes()) - self.assertEqual('a = int(1)\nb = 1\n', self.mod.read()) + self.assertEquals('a = int(1)\nb = 1\n', self.mod.read()) def test_replacing_patterns_with_normal_names(self): refactoring = restructure.Restructure( self.project, '${a} = 1', '${a} = int(1)', args={'a': 'exact'}) self.mod.write('a = 1\nb = 1\n') self.project.do(refactoring.get_changes()) - self.assertEqual('a = int(1)\nb = 1\n', self.mod.read()) + self.assertEquals('a = int(1)\nb = 1\n', self.mod.read()) def test_replacing_patterns_with_any_names(self): refactoring = restructure.Restructure(self.project, '${a} = 1', '${a} = int(1)') self.mod.write('a = 1\nb = 1\n') self.project.do(refactoring.get_changes()) - self.assertEqual('a = int(1)\nb = int(1)\n', self.mod.read()) + self.assertEquals('a = int(1)\nb = int(1)\n', self.mod.read()) def test_replacing_patterns_with_any_names2(self): refactoring = restructure.Restructure( self.project, '${x} + ${x}', '${x} * 2') self.mod.write('a = 1 + 1\n') self.project.do(refactoring.get_changes()) - self.assertEqual('a = 1 * 2\n', self.mod.read()) + self.assertEquals('a = 1 * 2\n', self.mod.read()) def test_replacing_patterns_with_checks(self): self.mod.write('def f(p=1):\n return p\ng = f\ng()\n') refactoring = restructure.Restructure( self.project, '${f}()', '${f}(2)', args={'f': 'object=mod.f'}) self.project.do(refactoring.get_changes()) - self.assertEqual('def f(p=1):\n return p\ng = f\ng(2)\n', + self.assertEquals('def f(p=1):\n return p\ng = f\ng(2)\n', self.mod.read()) def test_replacing_assignments_with_sets(self): @@ -64,21 +64,21 @@ def test_replacing_assignments_with_sets(self): self.project, '${a} = ${b}', '${a}.set(${b})') self.mod.write('a = 1\nb = 1\n') self.project.do(refactoring.get_changes()) - self.assertEqual('a.set(1)\nb.set(1)\n', self.mod.read()) + self.assertEquals('a.set(1)\nb.set(1)\n', self.mod.read()) def test_replacing_sets_with_assignments(self): refactoring = restructure.Restructure( self.project, '${a}.set(${b})', '${a} = ${b}') self.mod.write('a.set(1)\nb.set(1)\n') self.project.do(refactoring.get_changes()) - self.assertEqual('a = 1\nb = 1\n', self.mod.read()) + self.assertEquals('a = 1\nb = 1\n', self.mod.read()) def test_using_make_checks(self): self.mod.write('def f(p=1):\n return p\ng = f\ng()\n') refactoring = restructure.Restructure( self.project, '${f}()', '${f}(2)', args={'f': 'object=mod.f'}) self.project.do(refactoring.get_changes()) - self.assertEqual('def f(p=1):\n return p\ng = f\ng(2)\n', + self.assertEquals('def f(p=1):\n return p\ng = f\ng(2)\n', self.mod.read()) def test_using_make_checking_builtin_types(self): @@ -87,28 +87,28 @@ def test_using_make_checking_builtin_types(self): self.project, '${i} + ${i}', '${i} * 2', args={'i': 'type=__builtin__.int'}) self.project.do(refactoring.get_changes()) - self.assertEqual('a = 1 * 2\n', self.mod.read()) + self.assertEquals('a = 1 * 2\n', self.mod.read()) def test_auto_indentation_when_no_indentation(self): self.mod.write('a = 2\n') refactoring = restructure.Restructure( self.project, '${a} = 2', '${a} = 1\n${a} += 1') self.project.do(refactoring.get_changes()) - self.assertEqual('a = 1\na += 1\n', self.mod.read()) + self.assertEquals('a = 1\na += 1\n', self.mod.read()) def test_auto_indentation(self): self.mod.write('def f():\n a = 2\n') refactoring = restructure.Restructure( self.project, '${a} = 2', '${a} = 1\n${a} += 1') self.project.do(refactoring.get_changes()) - self.assertEqual('def f():\n a = 1\n a += 1\n', self.mod.read()) + self.assertEquals('def f():\n a = 1\n a += 1\n', self.mod.read()) def test_auto_indentation_and_not_indenting_blanks(self): self.mod.write('def f():\n a = 2\n') refactoring = restructure.Restructure( self.project, '${a} = 2', '${a} = 1\n\n${a} += 1') self.project.do(refactoring.get_changes()) - self.assertEqual('def f():\n a = 1\n\n a += 1\n', + self.assertEquals('def f():\n a = 1\n\n a += 1\n', self.mod.read()) def test_importing_names(self): @@ -117,7 +117,7 @@ def test_importing_names(self): self.project, '${a} = 2', '${a} = myconsts.two', imports=['import myconsts']) self.project.do(refactoring.get_changes()) - self.assertEqual('import myconsts\na = myconsts.two\n', + self.assertEquals('import myconsts\na = myconsts.two\n', self.mod.read()) def test_not_importing_names_when_there_are_no_changes(self): @@ -126,27 +126,27 @@ def test_not_importing_names_when_there_are_no_changes(self): self.project, '${a} = 2', '${a} = myconsts.two', imports=['import myconsts']) self.project.do(refactoring.get_changes()) - self.assertEqual('a = True\n', self.mod.read()) + self.assertEquals('a = True\n', self.mod.read()) def test_handling_containing_matches(self): self.mod.write('a = 1 / 2 / 3\n') refactoring = restructure.Restructure( self.project, '${a} / ${b}', '${a} // ${b}') self.project.do(refactoring.get_changes()) - self.assertEqual('a = 1 // 2 // 3\n', self.mod.read()) + self.assertEquals('a = 1 // 2 // 3\n', self.mod.read()) def test_handling_overlapping_matches(self): self.mod.write('a = 1\na = 1\na = 1\n') refactoring = restructure.Restructure( self.project, 'a = 1\na = 1\n', 'b = 1') self.project.do(refactoring.get_changes()) - self.assertEqual('b = 1\na = 1\n', self.mod.read()) + self.assertEquals('b = 1\na = 1\n', self.mod.read()) def test_preventing_stack_overflow_when_matching(self): self.mod.write('1\n') refactoring = restructure.Restructure(self.project, '${a}', '${a}') self.project.do(refactoring.get_changes()) - self.assertEqual('1\n', self.mod.read()) + self.assertEquals('1\n', self.mod.read()) def test_performing_a_restructuring_to_all_modules(self): mod2 = testutils.create_module(self.project, 'mod2') @@ -154,8 +154,8 @@ def test_performing_a_restructuring_to_all_modules(self): mod2.write('b = 1\n') refactoring = restructure.Restructure(self.project, '1', '2 / 1') self.project.do(refactoring.get_changes()) - self.assertEqual('a = 2 / 1\n', self.mod.read()) - self.assertEqual('b = 2 / 1\n', mod2.read()) + self.assertEquals('a = 2 / 1\n', self.mod.read()) + self.assertEquals('b = 2 / 1\n', mod2.read()) def test_performing_a_restructuring_to_selected_modules(self): mod2 = testutils.create_module(self.project, 'mod2') @@ -163,8 +163,8 @@ def test_performing_a_restructuring_to_selected_modules(self): mod2.write('b = 1\n') refactoring = restructure.Restructure(self.project, '1', '2 / 1') self.project.do(refactoring.get_changes(resources=[mod2])) - self.assertEqual('a = 1\n', self.mod.read()) - self.assertEqual('b = 2 / 1\n', mod2.read()) + self.assertEquals('a = 1\n', self.mod.read()) + self.assertEquals('b = 2 / 1\n', mod2.read()) def test_unsure_argument_of_default_wildcard(self): self.mod.write('def f(p):\n return p * 2\nx = "" * 2\ni = 1 * 2\n') @@ -172,7 +172,7 @@ def test_unsure_argument_of_default_wildcard(self): self.project, '${s} * 2', 'dup(${s})', args={'s': {'type': '__builtins__.str', 'unsure': True}}) self.project.do(refactoring.get_changes()) - self.assertEqual('def f(p):\n return dup(p)\nx = dup("")\n' + self.assertEquals('def f(p):\n return dup(p)\nx = dup("")\n' 'i = 1 * 2\n', self.mod.read()) def test_statement_after_string_and_column(self): @@ -180,7 +180,7 @@ def test_statement_after_string_and_column(self): self.mod.write(mod_text) refactoring = restructure.Restructure(self.project, '${a}', '${a}') self.project.do(refactoring.get_changes()) - self.assertEqual(mod_text, self.mod.read()) + self.assertEquals(mod_text, self.mod.read()) if __name__ == '__main__': diff --git a/ropetest/refactor/similarfindertest.py b/ropetest/refactor/similarfindertest.py index 693e0de80..c8e6c1ff3 100644 --- a/ropetest/refactor/similarfindertest.py +++ b/ropetest/refactor/similarfindertest.py @@ -22,52 +22,52 @@ def _create_finder(self, source, **kwds): def test_trivial_case(self): finder = self._create_finder('') - self.assertEqual([], list(finder.get_match_regions('10'))) + self.assertEquals([], list(finder.get_match_regions('10'))) def test_constant_integer(self): source = 'a = 10\n' finder = self._create_finder(source) result = [(source.index('10'), source.index('10') + 2)] - self.assertEqual(result, list(finder.get_match_regions('10'))) + self.assertEquals(result, list(finder.get_match_regions('10'))) def test_simple_addition(self): source = 'a = 1 + 2\n' finder = self._create_finder(source) result = [(source.index('1'), source.index('2') + 1)] - self.assertEqual(result, list(finder.get_match_regions('1 + 2'))) + self.assertEquals(result, list(finder.get_match_regions('1 + 2'))) def test_simple_addition2(self): source = 'a = 1 +2\n' finder = self._create_finder(source) result = [(source.index('1'), source.index('2') + 1)] - self.assertEqual(result, list(finder.get_match_regions('1 + 2'))) + self.assertEquals(result, list(finder.get_match_regions('1 + 2'))) def test_simple_assign_statements(self): source = 'a = 1 + 2\n' finder = self._create_finder(source) - self.assertEqual([(0, len(source) - 1)], + self.assertEquals([(0, len(source) - 1)], list(finder.get_match_regions('a = 1 + 2'))) def test_simple_multiline_statements(self): source = 'a = 1\nb = 2\n' finder = self._create_finder(source) - self.assertEqual([(0, len(source) - 1)], + self.assertEquals([(0, len(source) - 1)], list(finder.get_match_regions('a = 1\nb = 2'))) def test_multiple_matches(self): source = 'a = 1 + 1\n' finder = self._create_finder(source) result = list(finder.get_match_regions('1')) - self.assertEqual(2, len(result)) + self.assertEquals(2, len(result)) start1 = source.index('1') - self.assertEqual((start1, start1 + 1), result[0]) + self.assertEquals((start1, start1 + 1), result[0]) start2 = source.rindex('1') - self.assertEqual((start2, start2 + 1), result[1]) + self.assertEquals((start2, start2 + 1), result[1]) def test_multiple_matches2(self): source = 'a = 1\nb = 2\n\na = 1\nb = 2\n' finder = self._create_finder(source) - self.assertEqual( + self.assertEquals( 2, len(list(finder.get_match_regions('a = 1\nb = 2')))) def test_restricting_the_region_to_search(self): @@ -75,86 +75,86 @@ def test_restricting_the_region_to_search(self): finder = self._create_finder(source) result = list(finder.get_match_regions('1', start=2)) start = source.rfind('1') - self.assertEqual([(start, start + 1)], result) + self.assertEquals([(start, start + 1)], result) def test_matching_basic_patterns(self): source = 'b = a\n' finder = self._create_finder(source) result = list(finder.get_match_regions('${a}', args={'a': 'exact'})) start = source.rfind('a') - self.assertEqual([(start, start + 1)], result) + self.assertEquals([(start, start + 1)], result) def test_match_get_ast(self): source = 'b = a\n' finder = self._create_finder(source) result = list(finder.get_matches('${a}', args={'a': 'exact'})) - self.assertEqual('a', result[0].get_ast('a').id) + self.assertEquals('a', result[0].get_ast('a').id) def test_match_get_ast_for_statements(self): source = 'b = a\n' finder = self._create_finder(source) result = list(finder.get_matches('b = ${a}')) - self.assertEqual('a', result[0].get_ast('a').id) + self.assertEquals('a', result[0].get_ast('a').id) def test_matching_multiple_patterns(self): source = 'c = a + b\n' finder = self._create_finder(source) result = list(finder.get_matches('${a} + ${b}')) - self.assertEqual('a', result[0].get_ast('a').id) - self.assertEqual('b', result[0].get_ast('b').id) + self.assertEquals('a', result[0].get_ast('a').id) + self.assertEquals('b', result[0].get_ast('b').id) def test_matching_any_patterns(self): source = 'b = a\n' finder = self._create_finder(source) result = list(finder.get_matches('b = ${x}')) - self.assertEqual('a', result[0].get_ast('x').id) + self.assertEquals('a', result[0].get_ast('x').id) def test_matching_any_patterns_repeating(self): source = 'b = 1 + 1\n' finder = self._create_finder(source) result = list(finder.get_matches('b = ${x} + ${x}')) - self.assertEqual(1, result[0].get_ast('x').n) + self.assertEquals(1, result[0].get_ast('x').n) def test_matching_any_patterns_not_matching_different_nodes(self): source = 'b = 1 + 2\n' finder = self._create_finder(source) result = list(finder.get_matches('b = ${x} + ${x}')) - self.assertEqual(0, len(result)) + self.assertEquals(0, len(result)) def test_matching_normal_names_and_assname(self): source = 'a = 1\n' finder = self._create_finder(source) result = list(finder.get_matches('${a} = 1')) - self.assertEqual('a', result[0].get_ast('a').id) + self.assertEquals('a', result[0].get_ast('a').id) def test_matching_normal_names_and_assname2(self): source = 'a = 1\n' finder = self._create_finder(source) result = list(finder.get_matches('${a}', args={'a': 'exact'})) - self.assertEqual(1, len(result)) + self.assertEquals(1, len(result)) def test_matching_normal_names_and_attributes(self): source = 'x.a = 1\n' finder = self._create_finder(source) result = list(finder.get_matches('${a} = 1', args={'a': 'exact'})) - self.assertEqual(0, len(result)) + self.assertEquals(0, len(result)) def test_functions_not_matching_when_only_first_parameters(self): source = 'f(1, 2)\n' finder = self._create_finder(source) - self.assertEqual(0, len(list(finder.get_matches('f(1)')))) + self.assertEquals(0, len(list(finder.get_matches('f(1)')))) def test_matching_nested_try_finally(self): source = 'if 1:\n try:\n pass\n except:\n pass\n' pattern = 'try:\n pass\nexcept:\n pass\n' finder = self._create_finder(source) - self.assertEqual(1, len(list(finder.get_matches(pattern)))) + self.assertEquals(1, len(list(finder.get_matches(pattern)))) def test_matching_dicts_inside_functions(self): source = 'def f(p):\n d = {1: p.x}\n' pattern = '{1: ${a}.x}' finder = self._create_finder(source) - self.assertEqual(1, len(list(finder.get_matches(pattern)))) + self.assertEquals(1, len(list(finder.get_matches(pattern)))) class CheckingFinderTest(unittest.TestCase): @@ -172,14 +172,14 @@ def test_trivial_case(self): self.mod1.write('') pymodule = self.project.get_pymodule(self.mod1) finder = similarfinder.SimilarFinder(pymodule) - self.assertEqual([], list(finder.get_matches('10', {}))) + self.assertEquals([], list(finder.get_matches('10', {}))) def test_simple_finding(self): self.mod1.write('class A(object):\n pass\na = A()\n') pymodule = self.project.get_pymodule(self.mod1) finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${anything} = ${A}()', {})) - self.assertEqual(1, len(result)) + self.assertEquals(1, len(result)) def test_not_matching_when_the_name_does_not_match(self): self.mod1.write('class A(object):\n pass\na = list()\n') @@ -187,7 +187,7 @@ def test_not_matching_when_the_name_does_not_match(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${anything} = ${C}()', {'C': 'name=mod1.A'})) - self.assertEqual(0, len(result)) + self.assertEquals(0, len(result)) def test_not_matching_unknowns_finding(self): self.mod1.write('class A(object):\n pass\na = unknown()\n') @@ -195,7 +195,7 @@ def test_not_matching_unknowns_finding(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${anything} = ${C}()', {'C': 'name=mod1.A'})) - self.assertEqual(0, len(result)) + self.assertEquals(0, len(result)) def test_finding_and_matching_pyobjects(self): source = 'class A(object):\n pass\nNewA = A\na = NewA()\n' @@ -204,9 +204,9 @@ def test_finding_and_matching_pyobjects(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${anything} = ${A}()', {'A': 'object=mod1.A'})) - self.assertEqual(1, len(result)) + self.assertEquals(1, len(result)) start = source.rindex('a =') - self.assertEqual((start, len(source) - 1), result[0].get_region()) + self.assertEquals((start, len(source) - 1), result[0].get_region()) def test_finding_and_matching_types(self): source = 'class A(object):\n def f(self):\n pass\n' \ @@ -216,9 +216,9 @@ def test_finding_and_matching_types(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${anything} = ${inst}.f()', {'inst': 'type=mod1.A'})) - self.assertEqual(1, len(result)) + self.assertEquals(1, len(result)) start = source.rindex('b') - self.assertEqual((start, len(source) - 1), result[0].get_region()) + self.assertEquals((start, len(source) - 1), result[0].get_region()) def test_checking_the_type_of_an_ass_name_node(self): self.mod1.write('class A(object):\n pass\nan_a = A()\n') @@ -226,7 +226,7 @@ def test_checking_the_type_of_an_ass_name_node(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${a} = ${assigned}', {'a': 'type=mod1.A'})) - self.assertEqual(1, len(result)) + self.assertEquals(1, len(result)) def test_checking_instance_of_an_ass_name_node(self): self.mod1.write('class A(object):\n pass\n' @@ -235,7 +235,7 @@ def test_checking_instance_of_an_ass_name_node(self): finder = similarfinder.SimilarFinder(pymodule) result = list(finder.get_matches('${a} = ${assigned}', {'a': 'instance=mod1.A'})) - self.assertEqual(1, len(result)) + self.assertEquals(1, len(result)) def test_checking_equality_of_imported_pynames(self): mod2 = testutils.create_module(self.project, 'mod2') @@ -245,30 +245,30 @@ def test_checking_equality_of_imported_pynames(self): finder = similarfinder.SimilarFinder(pymod1) result = list(finder.get_matches('${a_class}()', {'a_class': 'name=mod2.A'})) - self.assertEqual(1, len(result)) + self.assertEquals(1, len(result)) class TemplateTest(unittest.TestCase): def test_simple_templates(self): template = similarfinder.CodeTemplate('${a}\n') - self.assertEqual(set(['a']), set(template.get_names())) + self.assertEquals(set(['a']), set(template.get_names())) def test_ignoring_matches_in_comments(self): template = similarfinder.CodeTemplate('#${a}\n') - self.assertEqual({}.keys(), template.get_names()) + self.assertEquals({}.keys(), template.get_names()) def test_ignoring_matches_in_strings(self): template = similarfinder.CodeTemplate("'${a}'\n") - self.assertEqual({}.keys(), template.get_names()) + self.assertEquals({}.keys(), template.get_names()) def test_simple_substitution(self): template = similarfinder.CodeTemplate('${a}\n') - self.assertEqual('b\n', template.substitute({'a': 'b'})) + self.assertEquals('b\n', template.substitute({'a': 'b'})) def test_substituting_multiple_names(self): template = similarfinder.CodeTemplate('${a}, ${b}\n') - self.assertEqual('1, 2\n', template.substitute({'a': '1', 'b': '2'})) + self.assertEquals('1, 2\n', template.substitute({'a': '1', 'b': '2'})) def suite(): diff --git a/ropetest/refactor/suitestest.py b/ropetest/refactor/suitestest.py index 4798fecb9..d9b8b972e 100644 --- a/ropetest/refactor/suitestest.py +++ b/ropetest/refactor/suitestest.py @@ -14,121 +14,121 @@ def tearDown(self): def test_trivial_case(self): root = source_suite_tree('') - self.assertEqual(1, root.get_start()) - self.assertEqual(0, len(root.get_children())) + self.assertEquals(1, root.get_start()) + self.assertEquals(0, len(root.get_children())) def test_simple_ifs(self): root = source_suite_tree('if True:\n pass') - self.assertEqual(1, len(root.get_children())) + self.assertEquals(1, len(root.get_children())) def test_simple_else(self): root = source_suite_tree( 'if True:\n pass\nelse:\n pass\n') - self.assertEqual(2, len(root.get_children())) - self.assertEqual(1, root.get_children()[1].get_start()) + self.assertEquals(2, len(root.get_children())) + self.assertEquals(1, root.get_children()[1].get_start()) def test_for(self): root = source_suite_tree( '\nfor i in range(10):\n pass\nelse:\n pass\n') - self.assertEqual(2, len(root.get_children())) - self.assertEqual(2, root.get_children()[1].get_start()) + self.assertEquals(2, len(root.get_children())) + self.assertEquals(2, root.get_children()[1].get_start()) def test_while(self): root = source_suite_tree( 'while True:\n pass\n') - self.assertEqual(1, len(root.get_children())) - self.assertEqual(1, root.get_children()[0].get_start()) + self.assertEquals(1, len(root.get_children())) + self.assertEquals(1, root.get_children()[0].get_start()) def test_with(self): root = source_suite_tree( 'from __future__ import with_statement\nwith file(x): pass\n') - self.assertEqual(1, len(root.get_children())) - self.assertEqual(2, root.get_children()[0].get_start()) + self.assertEquals(1, len(root.get_children())) + self.assertEquals(2, root.get_children()[0].get_start()) def test_try_finally(self): root = source_suite_tree( 'try:\n pass\nfinally:\n pass\n') - self.assertEqual(2, len(root.get_children())) - self.assertEqual(1, root.get_children()[0].get_start()) + self.assertEquals(2, len(root.get_children())) + self.assertEquals(1, root.get_children()[0].get_start()) def test_try_except(self): root = source_suite_tree( 'try:\n pass\nexcept:\n pass\nelse:\n pass\n') - self.assertEqual(3, len(root.get_children())) - self.assertEqual(1, root.get_children()[2].get_start()) + self.assertEquals(3, len(root.get_children())) + self.assertEquals(1, root.get_children()[2].get_start()) def test_try_except_finally(self): root = source_suite_tree( 'try:\n pass\nexcept:\n pass\nfinally:\n pass\n') - self.assertEqual(3, len(root.get_children())) - self.assertEqual(1, root.get_children()[2].get_start()) + self.assertEquals(3, len(root.get_children())) + self.assertEquals(1, root.get_children()[2].get_start()) def test_local_start_and_end(self): root = source_suite_tree('if True:\n pass\nelse:\n pass\n') - self.assertEqual(1, root.local_start()) - self.assertEqual(4, root.local_end()) + self.assertEquals(1, root.local_start()) + self.assertEquals(4, root.local_end()) if_suite = root.get_children()[0] - self.assertEqual(2, if_suite.local_start()) - self.assertEqual(2, if_suite.local_end()) + self.assertEquals(2, if_suite.local_start()) + self.assertEquals(2, if_suite.local_end()) else_suite = root.get_children()[1] - self.assertEqual(4, else_suite.local_start()) - self.assertEqual(4, else_suite.local_end()) + self.assertEquals(4, else_suite.local_start()) + self.assertEquals(4, else_suite.local_end()) def test_find_suite(self): root = source_suite_tree('\n') - self.assertEqual(root, root.find_suite(1)) + self.assertEquals(root, root.find_suite(1)) def test_find_suite_for_ifs(self): root = source_suite_tree('if True:\n pass\n') if_suite = root.get_children()[0] - self.assertEqual(if_suite, root.find_suite(2)) + self.assertEquals(if_suite, root.find_suite(2)) def test_find_suite_for_between_suites(self): root = source_suite_tree( 'if True:\n pass\nprint(1)\nif True:\n pass\n') if_suite1 = root.get_children()[0] if_suite2 = root.get_children()[1] - self.assertEqual(if_suite1, root.find_suite(2)) - self.assertEqual(if_suite2, root.find_suite(5)) - self.assertEqual(root, root.find_suite(3)) + self.assertEquals(if_suite1, root.find_suite(2)) + self.assertEquals(if_suite2, root.find_suite(5)) + self.assertEquals(root, root.find_suite(3)) def test_simple_find_visible(self): root = source_suite_tree('a = 1\n') - self.assertEqual(1, suites.find_visible_for_suite(root, [1])) + self.assertEquals(1, suites.find_visible_for_suite(root, [1])) def test_simple_find_visible_ifs(self): root = source_suite_tree('\nif True:\n a = 1\n b = 2\n') - self.assertEqual(root.find_suite(3), root.find_suite(4)) - self.assertEqual(3, suites.find_visible_for_suite(root, [3, 4])) + self.assertEquals(root.find_suite(3), root.find_suite(4)) + self.assertEquals(3, suites.find_visible_for_suite(root, [3, 4])) def test_simple_find_visible_for_else(self): root = source_suite_tree('\nif True:\n pass\nelse: pass\n') - self.assertEqual(2, suites.find_visible_for_suite(root, [2, 4])) + self.assertEquals(2, suites.find_visible_for_suite(root, [2, 4])) def test_simple_find_visible_for_different_suites(self): root = source_suite_tree('if True:\n pass\na = 1\n' 'if False:\n pass\n') - self.assertEqual(1, suites.find_visible_for_suite(root, [2, 3])) - self.assertEqual(5, suites.find_visible_for_suite(root, [5])) - self.assertEqual(1, suites.find_visible_for_suite(root, [2, 5])) + self.assertEquals(1, suites.find_visible_for_suite(root, [2, 3])) + self.assertEquals(5, suites.find_visible_for_suite(root, [5])) + self.assertEquals(1, suites.find_visible_for_suite(root, [2, 5])) def test_not_always_selecting_scope_start(self): root = source_suite_tree( 'if True:\n a = 1\n if True:\n pass\n' ' else:\n pass\n') - self.assertEqual(3, suites.find_visible_for_suite(root, [4, 6])) - self.assertEqual(3, suites.find_visible_for_suite(root, [3, 5])) - self.assertEqual(3, suites.find_visible_for_suite(root, [4, 5])) + self.assertEquals(3, suites.find_visible_for_suite(root, [4, 6])) + self.assertEquals(3, suites.find_visible_for_suite(root, [3, 5])) + self.assertEquals(3, suites.find_visible_for_suite(root, [4, 5])) def test_ignoring_functions(self): root = source_suite_tree( 'def f():\n pass\na = 1\n') - self.assertEqual(3, suites.find_visible_for_suite(root, [2, 3])) + self.assertEquals(3, suites.find_visible_for_suite(root, [2, 3])) def test_ignoring_classes(self): root = source_suite_tree( 'a = 1\nclass C():\n pass\n') - self.assertEqual(1, suites.find_visible_for_suite(root, [1, 3])) + self.assertEquals(1, suites.find_visible_for_suite(root, [1, 3])) def source_suite_tree(source): diff --git a/ropetest/refactor/usefunctiontest.py b/ropetest/refactor/usefunctiontest.py index 1bc5c0dce..a6eada009 100644 --- a/ropetest/refactor/usefunctiontest.py +++ b/ropetest/refactor/usefunctiontest.py @@ -25,14 +25,14 @@ def test_simple_case(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEqual(code, self.mod1.read()) + self.assertEquals(code, self.mod1.read()) def test_simple_function(self): code = 'def f(p):\n print(p)\nprint(1)\n' self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEqual('def f(p):\n print(p)\nf(1)\n', + self.assertEquals('def f(p):\n print(p)\nf(1)\n', self.mod1.read()) def test_simple_function2(self): @@ -40,7 +40,7 @@ def test_simple_function2(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEqual('def f(p):\n print(p + 1)\nf(1)\n', + self.assertEquals('def f(p):\n print(p + 1)\nf(1)\n', self.mod1.read()) def test_functions_with_multiple_statements(self): @@ -48,7 +48,7 @@ def test_functions_with_multiple_statements(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEqual('def f(p):\n r = p + 1\n print(r)\nf(2)\n', + self.assertEquals('def f(p):\n r = p + 1\n print(r)\nf(2)\n', self.mod1.read()) def test_returning(self): @@ -56,7 +56,7 @@ def test_returning(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEqual( + self.assertEquals( 'def f(p):\n return p + 1\nr = f(2)\nprint(r)\n', self.mod1.read()) @@ -65,7 +65,7 @@ def test_returning_a_single_expression(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEqual( + self.assertEquals( 'def f(p):\n return p + 1\nprint(f(2))\n', self.mod1.read()) @@ -75,7 +75,7 @@ def test_occurrences_in_other_modules(self): user = UseFunction(self.project, self.mod1, code.rindex('f')) self.mod2.write('print(2 + 1)\n') self.project.do(user.get_changes()) - self.assertEqual('import mod1\nprint(mod1.f(2))\n', + self.assertEquals('import mod1\nprint(mod1.f(2))\n', self.mod2.read()) def test_when_performing_on_non_functions(self): @@ -89,7 +89,7 @@ def test_differing_in_the_inner_temp_names(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEqual('def f(p):\n a = p + 1\n print(a)\nf(2)\n', + self.assertEquals('def f(p):\n a = p + 1\n print(a)\nf(2)\n', self.mod1.read()) # TODO: probably new options should be added to restructure @@ -99,7 +99,7 @@ def xxx_test_being_a_bit_more_intelligent_when_returning_assigneds(self): self.mod1.write(code) user = UseFunction(self.project, self.mod1, code.rindex('f')) self.project.do(user.get_changes()) - self.assertEqual('def f(p):\n a = p + 1\n return a\n' + self.assertEquals('def f(p):\n a = p + 1\n return a\n' 'var = f(p)\nprint(var)\n', self.mod1.read()) def test_exception_when_performing_a_function_with_yield(self): diff --git a/ropetest/runmodtest.py b/ropetest/runmodtest.py index 1b799b6c9..932088e36 100644 --- a/ropetest/runmodtest.py +++ b/ropetest/runmodtest.py @@ -44,7 +44,7 @@ def test_making_runner(self): file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.wait_process() - self.assertEqual('run', self.get_output_file_content(file_path)) + self.assertEquals('run', self.get_output_file_content(file_path)) def test_passing_arguments(self): file_path = 'sample.py' @@ -78,7 +78,7 @@ def test_killing_runner(self): file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.kill_process() - self.assertEqual('', self.get_output_file_content(file_path)) + self.assertEquals('', self.get_output_file_content(file_path)) def test_running_nested_files(self): self.project.root.create_folder('src') @@ -87,7 +87,7 @@ def test_running_nested_files(self): file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.wait_process() - self.assertEqual('run', self.get_output_file_content(file_path)) + self.assertEquals('run', self.get_output_file_content(file_path)) def test_setting_process_input(self): file_path = 'sample.py' @@ -105,7 +105,7 @@ def test_setting_process_input(self): runner = self.pycore.run_module(file_resource, stdin=stdin) runner.wait_process() stdin.close() - self.assertEqual('input text\n', + self.assertEquals('input text\n', self.get_output_file_content(file_path)) finally: os.remove(temp_file_name) @@ -124,7 +124,7 @@ def test_setting_process_output(self): runner.wait_process() stdout.close() temp_file = open(temp_file_name, 'r') - self.assertEqual('output text\n', temp_file.read()) + self.assertEquals('output text\n', temp_file.read()) temp_file.close() finally: os.remove(temp_file_name) @@ -142,7 +142,7 @@ def test_setting_pythonpath(self): file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.wait_process() - self.assertEqual('run', self.get_output_file_content(file_path)) + self.assertEquals('run', self.get_output_file_content(file_path)) def test_making_runner_when_doi_is_disabled(self): self.project.set('enable_doi', False) @@ -151,7 +151,7 @@ def test_making_runner_when_doi_is_disabled(self): file_resource = self.project.get_resource(file_path) runner = self.pycore.run_module(file_resource) runner.wait_process() - self.assertEqual('run', self.get_output_file_content(file_path)) + self.assertEquals('run', self.get_output_file_content(file_path)) def suite(): diff --git a/ropetest/simplifytest.py b/ropetest/simplifytest.py index de6583ef2..05969e36d 100644 --- a/ropetest/simplifytest.py +++ b/ropetest/simplifytest.py @@ -12,51 +12,51 @@ def tearDown(self): super(SimplifyTest, self).tearDown() def test_trivial_case(self): - self.assertEqual('', simplify.real_code('')) + self.assertEquals('', simplify.real_code('')) def test_empty_strs(self): code = 's = ""\n' - self.assertEqual(code, simplify.real_code(code)) + self.assertEquals(code, simplify.real_code(code)) def test_blanking_strs(self): code = 's = "..."\n' - self.assertEqual('s = " "\n', simplify.real_code(code)) + self.assertEquals('s = " "\n', simplify.real_code(code)) def test_changing_to_double_quotes(self): code = 's = \'\'\n' - self.assertEqual('s = ""\n', simplify.real_code(code)) + self.assertEquals('s = ""\n', simplify.real_code(code)) def test_changing_to_double_quotes2(self): code = 's = """\n"""\n' - self.assertEqual('s = " "\n', simplify.real_code(code)) + self.assertEquals('s = " "\n', simplify.real_code(code)) def test_removing_comments(self): code = '# c\n' - self.assertEqual(' \n', simplify.real_code(code)) + self.assertEquals(' \n', simplify.real_code(code)) def test_removing_comments_that_contain_strings(self): code = '# "c"\n' - self.assertEqual(' \n', simplify.real_code(code)) + self.assertEquals(' \n', simplify.real_code(code)) def test_removing_strings_containing_comments(self): code = '"#c"\n' - self.assertEqual('" "\n', simplify.real_code(code)) + self.assertEquals('" "\n', simplify.real_code(code)) def test_joining_implicit_continuations(self): code = '(\n)\n' - self.assertEqual('( )\n', simplify.real_code(code)) + self.assertEquals('( )\n', simplify.real_code(code)) def test_joining_explicit_continuations(self): code = '1 + \\\n 2\n' - self.assertEqual('1 + 2\n', simplify.real_code(code)) + self.assertEquals('1 + 2\n', simplify.real_code(code)) def test_replacing_tabs(self): code = '1\t+\t2\n' - self.assertEqual('1 + 2\n', simplify.real_code(code)) + self.assertEquals('1 + 2\n', simplify.real_code(code)) def test_replacing_semicolons(self): code = 'a = 1;b = 2\n' - self.assertEqual('a = 1\nb = 2\n', simplify.real_code(code)) + self.assertEquals('a = 1\nb = 2\n', simplify.real_code(code)) def suite(): From a1db15e19797b15b59ab3d3b7b602150fca48eef Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 12:43:51 +0100 Subject: [PATCH 78/92] code cleanup -added @todo --- rope/base/builtins.py | 3 --- rope/base/oi/runmod.py | 2 ++ rope/base/pyobjectsdef.py | 16 ++++------------ rope/base/utils/pycompat.py | 3 ++- 4 files changed, 8 insertions(+), 16 deletions(-) diff --git a/rope/base/builtins.py b/rope/base/builtins.py index 1ab9b0481..bc42f7200 100644 --- a/rope/base/builtins.py +++ b/rope/base/builtins.py @@ -226,9 +226,6 @@ def save_per_name(self, value): pymodule = pyname.get_definition_location()[0] pymodule.pycore.object_info.save_per_name(scope, name, value) - def get_arguments_number(self): - return len(self.args.args) - class _AttributeCollector(object): diff --git a/rope/base/oi/runmod.py b/rope/base/oi/runmod.py index 1daa5e2fa..c2ab9f545 100644 --- a/rope/base/oi/runmod.py +++ b/rope/base/oi/runmod.py @@ -142,6 +142,8 @@ def _get_persisted_builtin(self, object_): keys = None values = None if len(object_) > 0: + # @todo - fix it properly, why is __locals__ being + # duplicated ? keys = [key for key in object_.keys() if key != '__locals__'][0] values = object_[keys] return ('builtin', 'dict', diff --git a/rope/base/pyobjectsdef.py b/rope/base/pyobjectsdef.py index b1e3dd952..b7aef6273 100644 --- a/rope/base/pyobjectsdef.py +++ b/rope/base/pyobjectsdef.py @@ -77,12 +77,8 @@ def get_name(self): def get_param_names(self, special_args=True): # TODO: handle tuple parameters - if hasattr(ast, 'arg'): # Py3 - result = [node.arg for node in self.arguments.args - if isinstance(node, ast.arg)] - else: # Py2 - result = [node.id for node in self.arguments.args - if isinstance(node, ast.Name)] + result = [pycompat.get_ast_arg_arg(node) for node in self.arguments.args + if isinstance(node, pycompat.ast_arg_type)] if special_args: if self.arguments.vararg: result.append(pycompat.get_ast_arg_arg(self.arguments.vararg)) @@ -484,12 +480,8 @@ def _FunctionDef(self, node): if len(node.args.args) > 0: first = node.args.args[0] new_visitor = None - if hasattr(ast, 'arg'): # Py3 - if isinstance(first, ast.arg): - new_visitor = _ClassInitVisitor(self, first.arg) - else: # Py2 - if isinstance(first, ast.Name): - new_visitor = _ClassInitVisitor(self, first.id) + if isinstance(first, pycompat.ast_arg_type): + new_visitor = _ClassInitVisitor(self, pycompat.get_ast_arg_arg(first)) if new_visitor is not None: for child in ast.get_child_nodes(node): ast.walk(child, new_visitor) diff --git a/rope/base/utils/pycompat.py b/rope/base/utils/pycompat.py index 7c5f421c4..bc6d9be39 100644 --- a/rope/base/utils/pycompat.py +++ b/rope/base/utils/pycompat.py @@ -44,4 +44,5 @@ def get_ast_arg_arg(node): return node.id def get_ast_with_items(node): - return [node] + # @todo, do we need to handle all with items in python 2 ? + return [node] From 51e84c8b7f8b40f0fbd82f16c4fdeaef20c31969 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 15:18:21 +0100 Subject: [PATCH 79/92] proper fix for patched ast except handler --- rope/refactor/patchedast.py | 2 +- ropetest/refactor/patchedasttest.py | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 38a4ae5c6..f37cbb58d 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -653,7 +653,7 @@ def _excepthandler(self, node): children.append(node.type) if node.name: children.append(self.semicolon_or_as_in_except) - children.append(node.name) + children.append(ast.Name(id=node.name) if pycompat.PY3 else node.name) children.append(':') children.extend(node.body) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index 728bd336d..c22c6a358 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -821,13 +821,12 @@ def test_try_except_node__with_as_syntax(self): ast_frag = patchedast.get_patched_ast(source, True) checker = _ResultChecker(self, ast_frag) node_to_test = 'Try' if pycompat.PY3 else 'TryExcept' - is_catched_exception_ast_type = pycompat.PY2 checker.check_children( node_to_test, ['try', '', ':', '\n ', 'Pass', '\n', ('excepthandler', 'ExceptHandler')]) checker.check_children( ('excepthandler', 'ExceptHandler'), - ['except', ' ', 'Name', ' ', 'as', ' ', 'Name' if is_catched_exception_ast_type else 'e', '', ':', + ['except', ' ', 'Name', ' ', 'as', ' ', 'Name', '', ':', '\n ', 'Pass']) @testutils.only_for('2.5') From 968084fe896965dfc6f142c5ac4cdddf993ee558 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 15:35:06 +0100 Subject: [PATCH 80/92] fixes to travis yml --- .travis.yml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/.travis.yml b/.travis.yml index e3378a496..1a2e1e088 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,6 @@ language: python sudo: false python: - - "2.6" - "2.7" - "pypy" - "3.3" @@ -11,8 +10,4 @@ matrix: allow_failures: - python: "pypy" - python: "pypy3" - - python: "3.3" - - python: "3.4" -before_script: - - '[ "${TRAVIS_PYTHON_VERSION}" = "2.6" ] && travis_retry pip install unittest2 || /bin/true' script: python setup.py test From 945bdf391f6825f1349df8e5659e79807ddd7d90 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 19:24:55 +0100 Subject: [PATCH 81/92] fixed way how we get path to stdlib --- rope/base/stdmods.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rope/base/stdmods.py b/rope/base/stdmods.py index 683f72ebb..112e8beee 100644 --- a/rope/base/stdmods.py +++ b/rope/base/stdmods.py @@ -12,8 +12,8 @@ def _stdlib_path(): return sysconfig.get_python_lib(standard_lib=True, plat_specific=True) elif pycompat.PY3: - import sysconfig - return sysconfig.get_config_var('LIBDIR') + os.sep + 'python' + '.'.join(map(str, sys.version_info[0:2])) + import inspect + return os.path.dirname(inspect.getsourcefile(inspect)) @utils.cached(1) From aa29337f505196b79b1df60919d7fee3bca420e7 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 19:37:03 +0100 Subject: [PATCH 82/92] fixed problem for dlls --- rope/base/stdmods.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rope/base/stdmods.py b/rope/base/stdmods.py index 112e8beee..819cef6aa 100644 --- a/rope/base/stdmods.py +++ b/rope/base/stdmods.py @@ -53,7 +53,7 @@ def dynload_modules(): path = os.path.join(dynload_path, name) if os.path.isfile(path): if name.endswith('.dll'): - result.add(os.path.splitext(name)[0]) + result.add(os.path.splitext(normalize_so_name(name))[0]) if name.endswith('.so'): result.add(normalize_so_name(name)) return result From b8670963cbb81108922226287169ab0788d14cfa Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 19:41:55 +0100 Subject: [PATCH 83/92] minor fix --- ropetest/refactor/patchedasttest.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index c22c6a358..436323547 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -374,9 +374,9 @@ def test_function_node2(self): 'Function', ['def', ' ', 'f', '', '(', '', 'arguments', '', ')', '', ':', '\n ', 'Expr', '\n ', 'Pass']) - expected_arg_name = pycompat.ast_arg_type.__name__ + expected_ast_arg_name = pycompat.ast_arg_type.__name__ checker.check_children( - 'arguments', [expected_arg_name, '', ',', + 'arguments', [expected_ast_arg_name, '', ',', ' ', '**', '', 'p2']) @testutils.only_for_versions_lower('3') From 1a7c4995a44352aa327e40d9bfad91d03fde67da Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 19:50:28 +0100 Subject: [PATCH 84/92] ugly way how to debug travis test --- ropetest/builtinstest.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ropetest/builtinstest.py b/ropetest/builtinstest.py index df365449d..9c1b1c5ce 100644 --- a/ropetest/builtinstest.py +++ b/ropetest/builtinstest.py @@ -497,6 +497,7 @@ def test_nonexistent_modules_2(self): def test_time_in_std_mods(self): import rope.base.stdmods + self.assertEqual(['time'], rope.base.stdmods.standard_modules()) self.assertTrue('time' in rope.base.stdmods.standard_modules()) From e6ba06f6e87631ca05b42aa35f1f4c5e547dcc61 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 19:56:30 +0100 Subject: [PATCH 85/92] proper fix how to get correct names of the standard modules --- rope/base/stdmods.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/rope/base/stdmods.py b/rope/base/stdmods.py index 819cef6aa..5e868c2ad 100644 --- a/rope/base/stdmods.py +++ b/rope/base/stdmods.py @@ -41,7 +41,9 @@ def normalize_so_name(name): """ Handle different types of python installations """ - return re.sub('\.cpython-\d+', '', os.path.splitext(name)[0].replace('module', '')) + if "cpython" in name: + return os.path.splitext(os.path.splitext(name)[0])[0] + return os.path.splitext(name)[0] @utils.cached(1) @@ -53,7 +55,7 @@ def dynload_modules(): path = os.path.join(dynload_path, name) if os.path.isfile(path): if name.endswith('.dll'): - result.add(os.path.splitext(normalize_so_name(name))[0]) + result.add(normalize_so_name(name)) if name.endswith('.so'): result.add(normalize_so_name(name)) return result From 070225a2ae350fc9555d001e65d4e14b96770a40 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 20:00:29 +0100 Subject: [PATCH 86/92] remove debug --- ropetest/builtinstest.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ropetest/builtinstest.py b/ropetest/builtinstest.py index 9c1b1c5ce..df365449d 100644 --- a/ropetest/builtinstest.py +++ b/ropetest/builtinstest.py @@ -497,7 +497,6 @@ def test_nonexistent_modules_2(self): def test_time_in_std_mods(self): import rope.base.stdmods - self.assertEqual(['time'], rope.base.stdmods.standard_modules()) self.assertTrue('time' in rope.base.stdmods.standard_modules()) From 244e0328d116964bf315f590ccac65a6a9c3c51e Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 20:10:51 +0100 Subject: [PATCH 87/92] minor fixes --- rope/refactor/patchedast.py | 2 +- ropetest/refactor/patchedasttest.py | 22 ++++++++++++++-------- 2 files changed, 15 insertions(+), 9 deletions(-) diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index f37cbb58d..38a4ae5c6 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -653,7 +653,7 @@ def _excepthandler(self, node): children.append(node.type) if node.name: children.append(self.semicolon_or_as_in_except) - children.append(ast.Name(id=node.name) if pycompat.PY3 else node.name) + children.append(node.name) children.append(':') children.extend(node.body) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index 436323547..1c3d8e5ee 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -374,9 +374,9 @@ def test_function_node2(self): 'Function', ['def', ' ', 'f', '', '(', '', 'arguments', '', ')', '', ':', '\n ', 'Expr', '\n ', 'Pass']) - expected_ast_arg_name = pycompat.ast_arg_type.__name__ + expected_child = pycompat.ast_arg_type.__name__ checker.check_children( - 'arguments', [expected_ast_arg_name, '', ',', + 'arguments', [expected_child, '', ',', ' ', '**', '', 'p2']) @testutils.only_for_versions_lower('3') @@ -550,9 +550,9 @@ def test_lambda_node(self): checker.check_region('Lambda', 0, len(source) - 1) checker.check_children( 'Lambda', ['lambda', ' ', 'arguments', '', ':', ' ', 'Name']) - expected_arg_name = pycompat.ast_arg_type.__name__ + expected_child = pycompat.ast_arg_type.__name__ checker.check_children( - 'arguments', [expected_arg_name, '', ',', ' ', expected_arg_name, '', '=', '', + 'arguments', [expected_child, '', ',', ' ', expected_child, '', '=', '', 'Num', '', ',', ' ', '*', '', 'z']) def test_list_node(self): @@ -824,10 +824,16 @@ def test_try_except_node__with_as_syntax(self): checker.check_children( node_to_test, ['try', '', ':', '\n ', 'Pass', '\n', ('excepthandler', 'ExceptHandler')]) - checker.check_children( - ('excepthandler', 'ExceptHandler'), - ['except', ' ', 'Name', ' ', 'as', ' ', 'Name', '', ':', - '\n ', 'Pass']) + if pycompat.PY3: + checker.check_children( + ('excepthandler', 'ExceptHandler'), + ['except', ' ', 'Name', ' ', 'as', ' ', 'e', '', ':', + '\n ', 'Pass']) + else: + checker.check_children( + ('excepthandler', 'ExceptHandler'), + ['except', ' ', 'Name', ' ', 'as', ' ', 'Name', '', ':', + '\n ', 'Pass']) @testutils.only_for('2.5') def test_try_except_and_finally_node(self): From 1cb6c26d3ed13ce5ccee9596cf6b5271934c09b7 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 20:15:27 +0100 Subject: [PATCH 88/92] minor fix --- ropetest/refactor/patchedasttest.py | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/ropetest/refactor/patchedasttest.py b/ropetest/refactor/patchedasttest.py index 1c3d8e5ee..75ec41a92 100644 --- a/ropetest/refactor/patchedasttest.py +++ b/ropetest/refactor/patchedasttest.py @@ -824,16 +824,11 @@ def test_try_except_node__with_as_syntax(self): checker.check_children( node_to_test, ['try', '', ':', '\n ', 'Pass', '\n', ('excepthandler', 'ExceptHandler')]) - if pycompat.PY3: - checker.check_children( - ('excepthandler', 'ExceptHandler'), - ['except', ' ', 'Name', ' ', 'as', ' ', 'e', '', ':', - '\n ', 'Pass']) - else: - checker.check_children( - ('excepthandler', 'ExceptHandler'), - ['except', ' ', 'Name', ' ', 'as', ' ', 'Name', '', ':', - '\n ', 'Pass']) + expected_child = 'e' if pycompat.PY3 else 'Name' + checker.check_children( + ('excepthandler', 'ExceptHandler'), + ['except', ' ', 'Name', ' ', 'as', ' ', expected_child, '', ':', + '\n ', 'Pass']) @testutils.only_for('2.5') def test_try_except_and_finally_node(self): From c7bbc9afe532fbc770a22a23e44937be8546e4e1 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 20:18:38 +0100 Subject: [PATCH 89/92] updated image which shows if tests passed on travis --- README.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.rst b/README.rst index 74b504448..a5aa55b7b 100644 --- a/README.rst +++ b/README.rst @@ -61,5 +61,5 @@ Have a look at `COPYING`_ for more information. .. _`docs/library.rst`: docs/library.html .. _`COPYING`: COPYING -.. image:: https://secure.travis-ci.org/python-rope/rope.png +.. image:: https://secure.travis-ci.org/sergeyglazyrindev/rope.png :alt: Build Status From 42dccb7db2fa2aa591211c2d95ac4e3db3b8d7c3 Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 21:19:05 +0100 Subject: [PATCH 90/92] removed @todo comment --- rope/base/utils/pycompat.py | 1 - 1 file changed, 1 deletion(-) diff --git a/rope/base/utils/pycompat.py b/rope/base/utils/pycompat.py index bc6d9be39..ff78b8f81 100644 --- a/rope/base/utils/pycompat.py +++ b/rope/base/utils/pycompat.py @@ -44,5 +44,4 @@ def get_ast_arg_arg(node): return node.id def get_ast_with_items(node): - # @todo, do we need to handle all with items in python 2 ? return [node] From 3619997e6c6ddc95a956683786a47e6140b85ccf Mon Sep 17 00:00:00 2001 From: Sergey Glazyrin Date: Sun, 14 Feb 2016 23:19:44 +0100 Subject: [PATCH 91/92] added source of the orderedset --- rope/base/utils/datastructures.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/rope/base/utils/datastructures.py b/rope/base/utils/datastructures.py index df7ece406..0cb16cf2b 100644 --- a/rope/base/utils/datastructures.py +++ b/rope/base/utils/datastructures.py @@ -1,3 +1,6 @@ +# this snippet was taken from this link +# http://code.activestate.com/recipes/576694/ + import collections From 8a0260bb09a3522ec047964a357c005fe205a171 Mon Sep 17 00:00:00 2001 From: emacsway Date: Mon, 15 Feb 2016 02:54:51 +0200 Subject: [PATCH 92/92] 100% tests are passed in Python 3.3, 3.4. So, we can declare that Python3 is supported for now (but not fully completed yet) --- setup.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/setup.py b/setup.py index 258dcc05d..3abde705f 100644 --- a/setup.py +++ b/setup.py @@ -38,6 +38,13 @@ def run(self): 'License :: OSI Approved :: GNU General Public License (GPL)', 'Natural Language :: English', 'Programming Language :: Python', + 'Programming Language :: Python :: 2', + 'Programming Language :: Python :: 2.7', + 'Programming Language :: Python :: 3', + 'Programming Language :: Python :: 3.2', + 'Programming Language :: Python :: 3.3', + 'Programming Language :: Python :: 3.4', + 'Programming Language :: Python :: 3.5', 'Topic :: Software Development']