pylint: upgrade to 1.4.0

third_party/pylint/testutils.py

 # Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
 # http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This program is free software; you can redistribute it and/or modify it under
 # the terms of the GNU General Public License as published by the Free Software
 # Foundation; either version 2 of the License, or (at your option) any later
 # version.
 #
 # This program is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License along with
 # this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """functional/non regression tests for pylint"""
-from __future__ import with_statement
+from __future__ import print_function
 
 import collections
 import contextlib
 import functools
+import os
 import sys
 import re
+import unittest
+import tempfile
+import tokenize
 
 from glob import glob
-from os import linesep
+from os import linesep, getcwd, sep
 from os.path import abspath, basename, dirname, isdir, join, splitext
-from cStringIO import StringIO
 
-from logilab.common import testlib
+from astroid import test_utils
 
 from pylint import checkers
 from pylint.utils import PyLintASTWalker
 from pylint.reporters import BaseReporter
 from pylint.interfaces import IReporter
 from pylint.lint import PyLinter
 
+import six
+from six.moves import StringIO
+
 
 # Utils
 
 SYS_VERS_STR = '%d%d%d' % sys.version_info[:3]
 TITLE_UNDERLINES = ['', '=', '-', '.']
 PREFIX = abspath(dirname(__file__))
 PY3K = sys.version_info[0] == 3
 
 def fix_path():
     sys.path.insert(0, PREFIX)
@@ skipping 34 matching lines @@
             outfile = join(msg_dir, fbase + '.txt')
         result.append((infile, outfile))
     return result
 
 
 class TestReporter(BaseReporter):
     """reporter storing plain text messages"""
 
     __implements____ = IReporter
 
-    def __init__(self):
+    def __init__(self): # pylint: disable=super-init-not-called
+
         self.message_ids = {}
         self.reset()
+        self.path_strip_prefix = getcwd() + sep
 
     def reset(self):
         self.out = StringIO()
         self.messages = []
 
     def add_message(self, msg_id, location, msg):
         """manage message of different type and in the context of path """
         _, _, obj, line, _ = location
         self.message_ids[msg_id] = 1
         if obj:
             obj = ':%s' % obj
         sigle = msg_id[0]
         if PY3K and linesep != '\n':
             # 2to3 writes os.linesep instead of using
             # the previosly used line separators
             msg = msg.replace('\r\n', '\n')
         self.messages.append('%s:%3s%s: %s' % (sigle, line, obj, msg))
 
     def finalize(self):
         self.messages.sort()
         for msg in self.messages:
-            print >> self.out, msg
+            print(msg, file=self.out)
         result = self.out.getvalue()
         self.reset()
         return result
 
     def display_results(self, layout):
         """ignore layouts"""
 
 
-if sys.version_info < (2, 6):
-    class Message(tuple):
-        def __new__(cls, msg_id, line=None, node=None, args=None):
-            return tuple.__new__(cls, (msg_id, line, node, args))
-
-        @property
-        def msg_id(self):
-            return self[0]
-        @property
-        def line(self):
-            return self[1]
-        @property
-        def node(self):
-            return self[2]
-        @property
-        def args(self):
-            return self[3]
-
-
-else:
-    class Message(collections.namedtuple('Message',
-                                         ['msg_id', 'line', 'node', 'args'])):
-        def __new__(cls, msg_id, line=None, node=None, args=None):
-            return tuple.__new__(cls, (msg_id, line, node, args))
+class Message(collections.namedtuple('Message',
+                                     ['msg_id', 'line', 'node', 'args'])):
+    def __new__(cls, msg_id, line=None, node=None, args=None):
+        return tuple.__new__(cls, (msg_id, line, node, args))
 
 
 class UnittestLinter(object):
     """A fake linter class to capture checker messages."""
+    # pylint: disable=unused-argument, no-self-use
 
     def __init__(self):
         self._messages = []
         self.stats = {}
 
     def release_messages(self):
         try:
             return self._messages
         finally:
             self._messages = []
 
-    def add_message(self, msg_id, line=None, node=None, args=None):
+    def add_message(self, msg_id, line=None, node=None, args=None,
+                    confidence=None):
         self._messages.append(Message(msg_id, line, node, args))
 
     def is_message_enabled(self, *unused_args):
         return True
 
     def add_stats(self, **kwargs):
-        for name, value in kwargs.iteritems():
+        for name, value in six.iteritems(kwargs):
             self.stats[name] = value
         return self.stats
 
     @property
     def options_providers(self):
         return linter.options_providers
 
 def set_config(**kwargs):
     """Decorator for setting config values on a checker."""
     def _Wrapper(fun):
         @functools.wraps(fun)
         def _Forward(self):
-            for key, value in kwargs.iteritems():
+            for key, value in six.iteritems(kwargs):
                 setattr(self.checker.config, key, value)
             if isinstance(self, CheckerTestCase):
                 # reopen checker in case, it may be interested in configuration change
                 self.checker.open()
             fun(self)
 
         return _Forward
     return _Wrapper
 
 
-class CheckerTestCase(testlib.TestCase):
+class CheckerTestCase(unittest.TestCase):
     """A base testcase class for unittesting individual checker classes."""
     CHECKER_CLASS = None
     CONFIG = {}
 
     def setUp(self):
         self.linter = UnittestLinter()
         self.checker = self.CHECKER_CLASS(self.linter) # pylint: disable=not-callable
-        for key, value in self.CONFIG.iteritems():
+        for key, value in six.iteritems(self.CONFIG):
             setattr(self.checker.config, key, value)
         self.checker.open()
 
     @contextlib.contextmanager
     def assertNoMessages(self):
         """Assert that no messages are added by the given method."""
         with self.assertAddsMessages():
             yield
 
     @contextlib.contextmanager
@@ skipping 29 matching lines @@
 if linesep != '\n':
     LINE_RGX = re.compile(linesep)
     def ulines(string):
         return LINE_RGX.sub('\n', string)
 else:
     def ulines(string):
         return string
 
 INFO_TEST_RGX = re.compile(r'^func_i\d\d\d\d$')
 
-def exception_str(self, ex):
+def exception_str(self, ex): # pylint: disable=unused-argument
     """function used to replace default __str__ method of exception instances"""
     return 'in %s\n:: %s' % (ex.file, ', '.join(ex.args))
 
 # Test classes
 
-class LintTestUsingModule(testlib.TestCase):
+class LintTestUsingModule(unittest.TestCase):
     INPUT_DIR = None
     DEFAULT_PACKAGE = 'input'
     package = DEFAULT_PACKAGE
     linter = linter
     module = None
     depends = None
     output = None
     _TEST_TYPE = 'module'
+    maxDiff = None
 
     def shortDescription(self):
         values = {'mode' : self._TEST_TYPE,
                   'input': self.module,
                   'pkg':   self.package,
                   'cls':   self.__class__.__name__}
 
         if self.package == self.DEFAULT_PACKAGE:
             msg = '%(mode)s test of input file "%(input)s" (%(cls)s)'
         else:
@@ skipping 11 matching lines @@
         self.assertMultiLineEqual(self._get_expected().strip()+'\n',
                                   got.strip()+'\n')
 
     def _test(self, tocheck):
         if INFO_TEST_RGX.match(self.module):
             self.linter.enable('I')
         else:
             self.linter.disable('I')
         try:
             self.linter.check(tocheck)
-        except Exception, ex:
+        except Exception as ex:
             # need finalization to restore a correct state
             self.linter.reporter.finalize()
             ex.file = tocheck
-            print ex
+            print(ex)
             ex.__str__ = exception_str
             raise
         self._check_result(self.linter.reporter.finalize())
 
     def _has_output(self):
         return not self.module.startswith('func_noerror_')
 
     def _get_expected(self):
         if self._has_output() and self.output:
             with open(self.output, 'U') as fobj:
@@ skipping 26 matching lines @@
             except IOError:
                 expected = ''
             if got != expected:
                 with open(self.output, 'w') as fobj:
                     fobj.write(got)
 
 # Callback
 
 def cb_test_gen(base_class):
     def call(input_dir, msg_dir, module_file, messages_file, dependencies):
+        # pylint: disable=no-init
         class LintTC(base_class):
             module = module_file.replace('.py', '')
             output = messages_file
             depends = dependencies or None
-            tags = testlib.Tags(('generated', 'pylint_input_%s' % module))
             INPUT_DIR = input_dir
             MSG_DIR = msg_dir
         return LintTC
     return call
 
 # Main function
 
 def make_tests(input_dir, msg_dir, filter_rgx, callbacks):
     """generate tests classes from test info
 
     return the list of generated test classes
     """
     if filter_rgx:
         is_to_run = re.compile(filter_rgx).search
     else:
         is_to_run = lambda x: 1
     tests = []
     for module_file, messages_file in (
             get_tests_info(input_dir, msg_dir, 'func_', '')
     ):
-        if not is_to_run(module_file):
+        if not is_to_run(module_file) or module_file.endswith('.pyc'):
             continue
         base = module_file.replace('func_', '').replace('.py', '')
 
         dependencies = get_tests_info(input_dir, msg_dir, base, '.py')
 
         for callback in callbacks:
             test = callback(input_dir, msg_dir, module_file, messages_file,
                             dependencies)
             if test:
                 tests.append(test)
     return tests
+
+def tokenize_str(code):
+    return list(tokenize.generate_tokens(StringIO(code).readline))
+
+@contextlib.contextmanager
+def create_tempfile(content=None):
+    """Create a new temporary file.
+
+    If *content* parameter is given, then it will be written
+    in the temporary file, before passing it back.
+    This is a context manager and should be used with a *with* statement.
+    """
+    # Can't use tempfile.NamedTemporaryFile here
+    # because on Windows the file must be closed before writing to it,
+    # see http://bugs.python.org/issue14243
+    fd, tmp = tempfile.mkstemp()
+    if content:
+        if sys.version_info >= (3, 0):
+            # erff
+            os.write(fd, bytes(content, 'ascii'))
+        else:
+            os.write(fd, content)
+    try:
+        yield tmp
+    finally:
+        os.close(fd)
+        os.remove(tmp)
+
+@contextlib.contextmanager
+def create_file_backed_module(code):
+    """Create an astroid module for the given code, backed by a real file."""
+    with create_tempfile() as temp:
+        module = test_utils.build_module(code)
+        module.file = temp
+        yield module