pylint: upgrade to 1.3.1

third_party/logilab/common/testlib.py

 # -*- coding: utf-8 -*-
-# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# copyright 2003-2012 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of logilab-common.
 #
 # logilab-common is free software: you can redistribute it and/or modify it under
 # the terms of the GNU Lesser General Public License as published by the Free
 # Software Foundation, either version 2.1 of the License, or (at your option) any
 # later version.
 #
 # logilab-common is distributed in the hope that it will be useful, but WITHOUT
@@ skipping 16 matching lines @@
  -t  testdir -- directory where the tests will be found
  -x  exclude -- add a test to exclude
  -p  profile -- profiled execution
  -d  dbc     -- enable design-by-contract
  -m  match   -- only run test matching the tag pattern which follow
 
 If no non-option arguments are present, prefixes used are 'test',
 'regrtest', 'smoketest' and 'unittest'.
 
 """
+
+from __future__ import print_function
+
 __docformat__ = "restructuredtext en"
 # modified copy of some functions from test/regrtest.py from PyXml
 # disable camel case warning
 # pylint: disable=C0103
 
 import sys
 import os, os.path as osp
 import re
 import traceback
 import inspect
 import difflib
 import tempfile
 import math
 import warnings
 from shutil import rmtree
 from operator import itemgetter
-from ConfigParser import ConfigParser
+from itertools import dropwhile
+from inspect import isgeneratorfunction
+
+from six import string_types
+from six.moves import builtins, range, configparser, input
+
 from logilab.common.deprecation import deprecated
-from itertools import dropwhile
 
 import unittest as unittest_legacy
 if not getattr(unittest_legacy, "__package__", None):
     try:
         import unittest2 as unittest
         from unittest2 import SkipTest
     except ImportError:
-        sys.exit("You have to install python-unittest2 to use this module")
+        raise ImportError("You have to install python-unittest2 to use %s" % __name__)
 else:
     import unittest
     from unittest import SkipTest
 
-try:
-    from functools import wraps
-except ImportError:
-    def wraps(wrapped):
-        def proxy(callable):
-            callable.__name__ = wrapped.__name__
-            return callable
-        return proxy
-try:
-    from test import test_support
-except ImportError:
-    # not always available
-    class TestSupport:
-        def unload(self, test):
-            pass
-    test_support = TestSupport()
+from functools import wraps
 
-# pylint: disable=W0622
-from logilab.common.compat import any, InheritableSet, callable
-# pylint: enable=W0622
 from logilab.common.debugger import Debugger, colorize_source
 from logilab.common.decorators import cached, classproperty
 from logilab.common import textutils
 
 
 __all__ = ['main', 'unittest_main', 'find_tests', 'run_test', 'spawn']
 
 DEFAULT_PREFIXES = ('test', 'regrtest', 'smoketest', 'unittest',
                     'func', 'validation')
 
-
-if sys.version_info >= (2, 6):
-    # FIXME : this does not work as expected / breaks tests on testlib
-    # however testlib does not work on py3k for many reasons ...
-    from inspect import CO_GENERATOR
-else:
-    from compiler.consts import CO_GENERATOR
-
-if sys.version_info >= (3, 0):
-    def is_generator(function):
-        flags = function.__code__.co_flags
-        return flags & CO_GENERATOR
-
-else:
-    def is_generator(function):
-        flags = function.func_code.co_flags
-        return flags & CO_GENERATOR
+is_generator = deprecated('[lgc 0.63] use inspect.isgeneratorfunction')(isgeneratorfunction)
 
 # used by unittest to count the number of relevant levels in the traceback
 __unittest = 1
 
 
 def with_tempdir(callable):
     """A decorator ensuring no temporary file left when the function return
     Work only for temporary file create with the tempfile module"""
+    if isgeneratorfunction(callable):
+        def proxy(*args, **kwargs):
+            old_tmpdir = tempfile.gettempdir()
+            new_tmpdir = tempfile.mkdtemp(prefix="temp-lgc-")
+            tempfile.tempdir = new_tmpdir
+            try:
+                for x in callable(*args, **kwargs):
+                    yield x
+            finally:
+                try:
+                    rmtree(new_tmpdir, ignore_errors=True)
+                finally:
+                    tempfile.tempdir = old_tmpdir
+        return proxy
+
     @wraps(callable)
     def proxy(*args, **kargs):
 
         old_tmpdir = tempfile.gettempdir()
         new_tmpdir = tempfile.mkdtemp(prefix="temp-lgc-")
         tempfile.tempdir = new_tmpdir
         try:
             return callable(*args, **kargs)
         finally:
             try:
@@ skipping 48 matching lines @@
     """starts an interactive shell so that the user can inspect errors
     """
     debuggers = result.debuggers
     descrs = result.error_descrs + result.fail_descrs
     if len(debuggers) == 1:
         # don't ask for test name if there's only one failure
         debuggers[0].start()
     else:
         while True:
             testindex = 0
-            print "Choose a test to debug:"
+            print("Choose a test to debug:")
             # order debuggers in the same way than errors were printed
-            print "\n".join(['\t%s : %s' % (i, descr) for i, (_, descr)
-                in enumerate(descrs)])
-            print "Type 'exit' (or ^D) to quit"
-            print
+            print("\n".join(['\t%s : %s' % (i, descr) for i, (_, descr)
+                  in enumerate(descrs)]))
+            print("Type 'exit' (or ^D) to quit")
+            print()
             try:
-                todebug = raw_input('Enter a test name: ')
+                todebug = input('Enter a test name: ')
                 if todebug.strip().lower() == 'exit':
-                    print
+                    print()
                     break
                 else:
                     try:
                         testindex = int(todebug)
                         debugger = debuggers[descrs[testindex][0]]
                     except (ValueError, IndexError):
-                        print "ERROR: invalid test number %r" % (todebug, )
+                        print("ERROR: invalid test number %r" % (todebug, ))
                     else:
                         debugger.start()
             except (EOFError, KeyboardInterrupt):
-                print
+                print()
                 break
 
 
 # test utils ##################################################################
 
 class SkipAwareTestResult(unittest._TextTestResult):
 
     def __init__(self, stream, descriptions, verbosity,
                  exitfirst=False, pdbmode=False, cvg=None, colorize=False):
         super(SkipAwareTestResult, self).__init__(stream,
@@ skipping 133 matching lines @@
     # add testlib specific deprecation warning and switch to new api
     if hasattr(module, 'teardown_module'):
         warnings.warn('Please rename teardown_module() to tearDownModule() instead.',
                       DeprecationWarning)
         setattr(module, 'tearDownModule', module.teardown_module)
     # end of monkey-patching
     tearDownModule = getattr(module, 'tearDownModule', None)
     if tearDownModule is not None:
         try:
             tearDownModule()
-        except Exception, e:
+        except Exception as e:
             if isinstance(result, _DebugResult):
                 raise
             errorName = 'tearDownModule (%s)' % previousModule
             self._addClassOrModuleLevelException(result, e, errorName)
 
 @monkeypatch(unittest.TestSuite)
 def _handleModuleFixture(self, test, result):
     previousModule = self._get_previous_module(result)
     currentModule = test.__class__.__module__
     if currentModule == previousModule:
         return
     self._handleModuleTearDown(result)
     result._moduleSetUpFailed = False
     try:
         module = sys.modules[currentModule]
     except KeyError:
         return
     # add testlib specific deprecation warning and switch to new api
     if hasattr(module, 'setup_module'):
         warnings.warn('Please rename setup_module() to setUpModule() instead.',
                       DeprecationWarning)
         setattr(module, 'setUpModule', module.setup_module)
     # end of monkey-patching
     setUpModule = getattr(module, 'setUpModule', None)
     if setUpModule is not None:
         try:
             setUpModule()
-        except Exception, e:
+        except Exception as e:
             if isinstance(result, _DebugResult):
                 raise
             result._moduleSetUpFailed = True
             errorName = 'setUpModule (%s)' % currentModule
             self._addClassOrModuleLevelException(result, e, errorName)
 
 # backward compatibility: TestSuite might be imported from lgc.testlib
 TestSuite = unittest.TestSuite
 
 class keywords(dict):
@@ skipping 35 matching lines @@
 
     return args, kwargs
 
 
 class InnerTest(tuple):
     def __new__(cls, name, *data):
         instance = tuple.__new__(cls, data)
         instance.name = name
         return instance
 
-class Tags(InheritableSet): # 2.4 compat
+class Tags(set):
     """A set of tag able validate an expression"""
 
     def __init__(self, *tags, **kwargs):
         self.inherit = kwargs.pop('inherit', True)
         if kwargs:
            raise TypeError("%s are an invalid keyword argument for this function" % kwargs.keys())
 
-        if len(tags) == 1 and not isinstance(tags[0], basestring):
+        if len(tags) == 1 and not isinstance(tags[0], string_types):
             tags = tags[0]
         super(Tags, self).__init__(tags, **kwargs)
 
     def __getitem__(self, key):
         return key in self
 
     def match(self, exp):
         return eval(exp, {}, self)
 
 
 # duplicate definition from unittest2 of the _deprecate decorator
 def _deprecate(original_func):
     def deprecated_func(*args, **kwargs):
         warnings.warn(
             ('Please use %s instead.' % original_func.__name__),
             DeprecationWarning, 2)
         return original_func(*args, **kwargs)
     return deprecated_func
 
 class TestCase(unittest.TestCase):
     """A unittest.TestCase extension with some additional methods."""
     maxDiff = None
     pdbclass = Debugger
     tags = Tags()
 
     def __init__(self, methodName='runTest'):
         super(TestCase, self).__init__(methodName)
-        # internal API changed in python2.4 and needed by DocTestCase
-        if sys.version_info >= (2, 4):
-            self.__exc_info = sys.exc_info
-            self.__testMethodName = self._testMethodName
-        else:
-            # let's give easier access to _testMethodName to every subclasses
-            if hasattr(self, "__testMethodName"):
-                self._testMethodName = self.__testMethodName
+        self.__exc_info = sys.exc_info
+        self.__testMethodName = self._testMethodName
         self._current_test_descr = None
         self._options_ = None
 
     @classproperty
     @cached
     def datadir(cls): # pylint: disable=E0213
         """helper attribute holding the standard test's data directory
 
         NOTE: this is a logilab's standard
         """
@@ skipping 21 matching lines @@
         """
         if self._current_test_descr is not None:
             return self._current_test_descr
         return super(TestCase, self).shortDescription()
 
     def quiet_run(self, result, func, *args, **kwargs):
         try:
             func(*args, **kwargs)
         except (KeyboardInterrupt, SystemExit):
             raise
+        except unittest.SkipTest as e:
+            if hasattr(result, 'addSkip'):
+                result.addSkip(self, str(e))
+            else:
+                warnings.warn("TestResult has no addSkip method, skips not reported",
+                              RuntimeWarning, 2)
+                result.addSuccess(self)
+            return False
         except:
             result.addError(self, self.__exc_info())
             return False
         return True
 
     def _get_test_method(self):
         """return the test method"""
         return getattr(self, self._testMethodName)
 
     def optval(self, option, default=None):
         """return the option value or default if the option is not define"""
         return getattr(self._options_, option, default)
 
     def __call__(self, result=None, runcondition=None, options=None):
         """rewrite TestCase.__call__ to support generative tests
         This is mostly a copy/paste from unittest.py (i.e same
         variable names, same logic, except for the generative tests part)
         """
         from logilab.common.pytest import FILE_RESTART
         if result is None:
             result = self.defaultTestResult()
         result.pdbclass = self.pdbclass
         self._options_ = options
         # if result.cvg:
         #     result.cvg.start()
         testMethod = self._get_test_method()
+        if (getattr(self.__class__, "__unittest_skip__", False) or
+            getattr(testMethod, "__unittest_skip__", False)):
+            # If the class or method was skipped.
+            try:
+                skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')
+                            or getattr(testMethod, '__unittest_skip_why__', ''))
+                self._addSkip(result, skip_why)
+            finally:
+                result.stopTest(self)
+            return
         if runcondition and not runcondition(testMethod):
             return # test is skipped
         result.startTest(self)
         try:
             if not self.quiet_run(result, self.setUp):
                 return
-            generative = is_generator(testMethod.im_func)
+            generative = isgeneratorfunction(testMethod)
             # generative tests
             if generative:
                 self._proceed_generative(result, testMethod,
                                          runcondition)
             else:
                 status = self._proceed(result, testMethod)
                 success = (status == 0)
             if not self.quiet_run(result, self.tearDown):
                 return
             if not generative and success:
                 if hasattr(options, "exitfirst") and options.exitfirst:
                     # add this test to restart file
                     try:
                         restartfile = open(FILE_RESTART, 'a')
                         try:
                             descr = '.'.join((self.__class__.__module__,
                                               self.__class__.__name__,
                                               self._testMethodName))
                             restartfile.write(descr+os.linesep)
                         finally:
                             restartfile.close()
-                    except Exception, ex:
-                        print >> sys.__stderr__, "Error while saving \
-succeeded test into", osp.join(os.getcwd(), FILE_RESTART)
-                        raise ex
+                    except Exception:
+                        print("Error while saving succeeded test into",
+                              osp.join(os.getcwd(), FILE_RESTART),
+                              file=sys.__stderr__)
+                        raise
                 result.addSuccess(self)
         finally:
             # if result.cvg:
             #     result.cvg.stop()
             result.stopTest(self)
 
     def _proceed_generative(self, result, testfunc, runcondition=None):
         # cancel startTest()'s increment
         result.testsRun -= 1
         success = True
@@ skipping 36 matching lines @@
         successful
         """
         kwargs = kwargs or {}
         try:
             testfunc(*args, **kwargs)
         except self.failureException:
             result.addFailure(self, self.__exc_info())
             return 1
         except KeyboardInterrupt:
             raise
-        except InnerTestSkipped, e:
+        except InnerTestSkipped as e:
             result.addSkip(self, e)
             return 1
-        except SkipTest, e:
+        except SkipTest as e:
             result.addSkip(self, e)
             return 0
         except:
             result.addError(self, self.__exc_info())
             return 2
         return 0
 
     def defaultTestResult(self):
         """return a new instance of the defaultTestResult"""
         return SkipAwareTestResult()
@@ skipping 33 matching lines @@
             msgs.append('dict2 is lacking %r' % dict1)
         if msg:
             self.failureException(msg)
         elif msgs:
             if context is not None:
                 base = '%s\n' % context
             else:
                 base = ''
             self.fail(base + '\n'.join(msgs))
 
-    @deprecated('Please use assertItemsEqual instead.')
+    @deprecated('Please use assertCountEqual instead.')
     def assertUnorderedIterableEquals(self, got, expected, msg=None):
         """compares two iterable and shows difference between both
 
         :param got: the unordered Iterable that we found
         :param expected: the expected unordered Iterable
         :param msg: custom message (String) in case of failure
         """
         got, expected = list(got), list(expected)
         self.assertSetEqual(set(got), set(expected), msg)
         if len(got) != len(expected):
@@ skipping 101 matching lines @@
                         Only available with element tree
         """
         try:
             from xml.etree.ElementTree import parse
             self._assertETXMLWellFormed(stream, parse, msg)
         except ImportError:
             from xml.sax import make_parser, SAXParseException
             parser = make_parser()
             try:
                 parser.parse(stream)
-            except SAXParseException, ex:
+            except SAXParseException as ex:
                 if msg is None:
                     stream.seek(0)
-                    for _ in xrange(ex.getLineNumber()):
+                    for _ in range(ex.getLineNumber()):
                         line = stream.readline()
                     pointer = ('' * (ex.getLineNumber() - 1)) + '^'
                     msg = 'XML stream not well formed: %s\n%s%s' % (ex, line, pointer)
                 self.fail(msg)
 
     @deprecated('Non-standard: please copy test method to your TestCase class')
     def assertXMLStringWellFormed(self, xml_string, msg=None, context=2):
         """asserts the XML string is well-formed (no DTD conformance check)
 
         :param context: number of context lines in standard message
@@ skipping 17 matching lines @@
                         Only available with element tree
         """
         from xml.parsers.expat import ExpatError
         try:
             from xml.etree.ElementTree import ParseError
         except ImportError:
             # compatibility for <python2.7
             ParseError = ExpatError
         try:
             parse(data)
-        except (ExpatError, ParseError), ex:
+        except (ExpatError, ParseError) as ex:
             if msg is None:
                 if hasattr(data, 'readlines'): #file like object
                     data.seek(0)
                     lines = data.readlines()
                 else:
                     lines = data.splitlines(True)
                 nb_lines = len(lines)
                 context_lines = []
 
                 # catch when ParseError doesn't set valid lineno
                 if ex.lineno is not None:
                     if context < 0:
                         start = 1
                         end   = nb_lines
                     else:
                         start = max(ex.lineno-context, 1)
                         end   = min(ex.lineno+context, nb_lines)
                     line_number_length = len('%i' % end)
                     line_pattern = " %%%ii: %%s" % line_number_length
 
-                    for line_no in xrange(start, ex.lineno):
+                    for line_no in range(start, ex.lineno):
                         context_lines.append(line_pattern % (line_no, lines[line_no-1]))
                     context_lines.append(line_pattern % (ex.lineno, lines[ex.lineno-1]))
                     context_lines.append('%s^\n' % (' ' * (1 + line_number_length + 2 +ex.offset)))
-                    for line_no in xrange(ex.lineno+1, end+1):
+                    for line_no in range(ex.lineno+1, end+1):
                         context_lines.append(line_pattern % (line_no, lines[line_no-1]))
 
                 rich_context = ''.join(context_lines)
                 msg = 'XML stream not well formed: %s\n%s' % (ex, rich_context)
             self.fail(msg)
 
     @deprecated('Non-standard: please copy test method to your TestCase class')
     def assertXMLEqualsTuple(self, element, tup):
         """compare an ElementTree Element to a tuple formatted as follow:
         (tagname, [attrib[, children[, text[, tail]]]])"""
         # check tag
         self.assertTextEquals(element.tag, tup[0])
         # check attrib
         if len(element.attrib) or len(tup)>1:
             if len(tup)<=1:
                 self.fail( "tuple %s has no attributes (%s expected)"%(tup,
                     dict(element.attrib)))
             self.assertDictEqual(element.attrib, tup[1])
         # check children
         if len(element) or len(tup)>2:
             if len(tup)<=2:
                 self.fail( "tuple %s has no children (%i expected)"%(tup,
                     len(element)))
             if len(element) != len(tup[2]):
                 self.fail( "tuple %s has %i children%s (%i expected)"%(tup,
                     len(tup[2]),
                         ('', 's')[len(tup[2])>1], len(element)))
-            for index in xrange(len(tup[2])):
+            for index in range(len(tup[2])):
                 self.assertXMLEqualsTuple(element[index], tup[2][index])
         #check text
         if element.text or len(tup)>3:
             if len(tup)<=3:
                 self.fail( "tuple %s has no text value (%r expected)"%(tup,
                     element.text))
             self.assertTextEquals(element.text, tup[3])
         #check tail
         if element.tail or len(tup)>4:
             if len(tup)<=4:
                 self.fail( "tuple %s has no tail value (%r expected)"%(tup,
                     element.tail))
             self.assertTextEquals(element.tail, tup[4])
 
     def _difftext(self, lines1, lines2, junk=None, msg_prefix='Texts differ'):
         junk = junk or (' ', '\t')
         # result is a generator
         result = difflib.ndiff(lines1, lines2, charjunk=lambda x: x in junk)
         read = []
         for line in result:
             read.append(line)
             # lines that don't start with a ' ' are diff ones
             if not line.startswith(' '):
                 self.fail('\n'.join(['%s\n'%msg_prefix]+read + list(result)))
 
     @deprecated('Non-standard. Please use assertMultiLineEqual instead.')
     def assertTextEquals(self, text1, text2, junk=None,
             msg_prefix='Text differ', striplines=False):
         """compare two multiline strings (using difflib and splitlines())
-        
+
         :param text1: a Python BaseString
         :param text2: a second Python Basestring
         :param junk: List of Caracters
         :param msg_prefix: String (message prefix)
         :param striplines: Boolean to trigger line stripping before comparing
         """
         msg = []
-        if not isinstance(text1, basestring):
+        if not isinstance(text1, string_types):
             msg.append('text1 is not a string (%s)'%(type(text1)))
-        if not isinstance(text2, basestring):
+        if not isinstance(text2, string_types):
             msg.append('text2 is not a string (%s)'%(type(text2)))
         if msg:
             self.fail('\n'.join(msg))
         lines1 = text1.strip().splitlines(True)
         lines2 = text2.strip().splitlines(True)
         if striplines:
             lines1 = [line.strip() for line in lines1]
             lines2 = [line.strip() for line in lines2]
         self._difftext(lines1, lines2, junk,  msg_prefix)
     assertTextEqual = assertTextEquals
@@ skipping 35 matching lines @@
 
         all_b = [ (ipath[len(path_b):].lstrip('/'), idirs, ifiles)
                     for ipath, idirs, ifiles in os.walk(path_b)]
         all_b.sort(key=itemgetter(0))
 
         iter_a, iter_b = iter(all_a), iter(all_b)
         partial_iter = True
         ipath_a, idirs_a, ifiles_a = data_a = None, None, None
         while True:
             try:
-                ipath_a, idirs_a, ifiles_a = datas_a = iter_a.next()
+                ipath_a, idirs_a, ifiles_a = datas_a = next(iter_a)
                 partial_iter = False
-                ipath_b, idirs_b, ifiles_b = datas_b = iter_b.next()
+                ipath_b, idirs_b, ifiles_b = datas_b = next(iter_b)
                 partial_iter = True
 
 
-                self.assert_(ipath_a == ipath_b,
+                self.assertTrue(ipath_a == ipath_b,
                     "unexpected %s in %s while looking %s from %s" %
                     (ipath_a, path_a, ipath_b, path_b))
 
 
                 errors = {}
                 sdirs_a = set(idirs_a)
                 sdirs_b = set(idirs_b)
                 errors["unexpected directories"] = sdirs_a - sdirs_b
                 errors["missing directories"] = sdirs_b - sdirs_a
 
                 sfiles_a = set(ifiles_a)
                 sfiles_b = set(ifiles_b)
                 errors["unexpected files"] = sfiles_a - sfiles_b
                 errors["missing files"] = sfiles_b - sfiles_a
 
 
                 msgs = [ "%s: %s"% (name, items)
-                    for name, items in errors.iteritems() if items]
+                    for name, items in errors.items() if items]
 
                 if msgs:
                     msgs.insert(0, "%s and %s differ :" % (
                         osp.join(path_a, ipath_a),
                         osp.join(path_b, ipath_b),
                         ))
                     self.fail("\n".join(msgs))
 
                 for files in (ifiles_a, ifiles_b):
                     files.sort()
@@ skipping 19 matching lines @@
         if strict:
             warnings.warn('[API] Non-standard. Strict parameter has vanished',
                           DeprecationWarning, stacklevel=2)
         if msg is None:
             if strict:
                 msg = '%r is not of class %s but of %s'
             else:
                 msg = '%r is not an instance of %s but of %s'
             msg = msg % (obj, klass, type(obj))
         if strict:
-            self.assert_(obj.__class__ is klass, msg)
+            self.assertTrue(obj.__class__ is klass, msg)
         else:
-            self.assert_(isinstance(obj, klass), msg)
+            self.assertTrue(isinstance(obj, klass), msg)
 
     @deprecated('Please use assertIsNone instead.')
     def assertNone(self, obj, msg=None):
         """assert obj is None
 
         :param obj: Python Object to be tested
         """
         if msg is None:
             msg = "reference to %r when None expected"%(obj,)
-        self.assert_( obj is None, msg )
+        self.assertTrue( obj is None, msg )
 
     @deprecated('Please use assertIsNotNone instead.')
     def assertNotNone(self, obj, msg=None):
         """assert obj is not None"""
         if msg is None:
             msg = "unexpected reference to None"
-        self.assert_( obj is not None, msg )
+        self.assertTrue( obj is not None, msg )
 
     @deprecated('Non-standard. Please use assertAlmostEqual instead.')
     def assertFloatAlmostEquals(self, obj, other, prec=1e-5,
                                 relative=False, msg=None):
         """compares if two floats have a distance smaller than expected
         precision.
 
         :param obj: a Float
         :param other: another Float to be comparted to <obj>
         :param prec: a Float describing the precision
         :param relative: boolean switching to relative/absolute precision
         :param msg: a String for a custom message
         """
         if msg is None:
             msg = "%r != %r" % (obj, other)
         if relative:
             prec = prec*math.fabs(obj)
-        self.assert_(math.fabs(obj - other) < prec, msg)
+        self.assertTrue(math.fabs(obj - other) < prec, msg)
 
     def failUnlessRaises(self, excClass, callableObj=None, *args, **kwargs):
         """override default failUnlessRaises method to return the raised
         exception instance.
 
         Fail unless an exception of class excClass is thrown
         by callableObj when invoked with arguments args and keyword
         arguments kwargs. If a different type of exception is
         thrown, it will not be caught, and the test case will be
         deemed to have suffered an error, exactly as for an
         unexpected exception.
 
         CAUTION! There are subtle differences between Logilab and unittest2
         - exc is not returned in standard version
         - context capabilities in standard version
         - try/except/else construction (minor)
 
         :param excClass: the Exception to be raised
         :param callableObj: a callable Object which should raise <excClass>
         :param args: a List of arguments for <callableObj>
         :param kwargs: a List of keyword arguments  for <callableObj>
         """
         # XXX cube vcslib : test_branches_from_app
         if callableObj is None:
             _assert = super(TestCase, self).assertRaises
             return _assert(excClass, callableObj, *args, **kwargs)
         try:
             callableObj(*args, **kwargs)
-        except excClass, exc:
+        except excClass as exc:
             class ProxyException:
                 def __init__(self, obj):
                     self._obj = obj
                 def __getattr__(self, attr):
                     warn_msg = ("This exception was retrieved with the old testlib way "
                                 "`exc = self.assertRaises(Exc, callable)`, please use "
                                 "the context manager instead'")
                     warnings.warn(warn_msg, DeprecationWarning, 2)
                     return self._obj.__getattribute__(attr)
             return ProxyException(exc)
         else:
             if hasattr(excClass, '__name__'):
                 excName = excClass.__name__
             else:
                 excName = str(excClass)
             raise self.failureException("%s not raised" % excName)
 
     assertRaises = failUnlessRaises
 
+    if sys.version_info >= (3,2):
+        assertItemsEqual = unittest.TestCase.assertCountEqual
+    else:
+        assertCountEqual = unittest.TestCase.assertItemsEqual
+        if sys.version_info < (2,7):
+            def assertIsNotNone(self, value, *args, **kwargs):
+                self.assertNotEqual(None, value, *args, **kwargs)
+
+TestCase.assertItemsEqual = deprecated('assertItemsEqual is deprecated, use assertCountEqual')(
+    TestCase.assertItemsEqual)
 
 import doctest
 
 class SkippedSuite(unittest.TestSuite):
     def test(self):
         """just there to trigger test execution"""
         self.skipped_test('doctest module has no DocTestSuite class')
 
 
 class DocTestFinder(doctest.DocTestFinder):
 
     def __init__(self, *args, **kwargs):
         self.skipped = kwargs.pop('skipped', ())
         doctest.DocTestFinder.__init__(self, *args, **kwargs)
 
     def _get_test(self, obj, name, module, globs, source_lines):
         """override default _get_test method to be able to skip tests
         according to skipped attribute's value
-
-        Note: Python (<=2.4) use a _name_filter which could be used for that
-              purpose but it's no longer available in 2.5
-              Python 2.5 seems to have a [SKIP] flag
         """
         if getattr(obj, '__name__', '') in self.skipped:
             return None
         return doctest.DocTestFinder._get_test(self, obj, name, module,
                                                globs, source_lines)
 
 
 class DocTest(TestCase):
     """trigger module doctest
     I don't know how to make unittest.main consider the DocTestSuite instance
     without this hack
     """
     skipped = ()
     def __call__(self, result=None, runcondition=None, options=None):\
         # pylint: disable=W0613
         try:
             finder = DocTestFinder(skipped=self.skipped)
-            if sys.version_info >= (2, 4):
-                suite = doctest.DocTestSuite(self.module, test_finder=finder)
-                if sys.version_info >= (2, 5):
-                    # XXX iirk
-                    doctest.DocTestCase._TestCase__exc_info = sys.exc_info
-            else:
-                suite = doctest.DocTestSuite(self.module)
+            suite = doctest.DocTestSuite(self.module, test_finder=finder)
+            # XXX iirk
+            doctest.DocTestCase._TestCase__exc_info = sys.exc_info
         except AttributeError:
             suite = SkippedSuite()
-        return suite.run(result)
+        # doctest may gork the builtins dictionnary
+        # This happen to the "_" entry used by gettext
+        old_builtins = builtins.__dict__.copy()
+        try:
+            return suite.run(result)
+        finally:
+            builtins.__dict__.clear()
+            builtins.__dict__.update(old_builtins)
     run = __call__
 
     def test(self):
         """just there to trigger test execution"""
 
 MAILBOX = None
 
 class MockSMTP:
     """fake smtplib.SMTP"""
 
     def __init__(self, host, port):
         self.host = host
         self.port = port
         global MAILBOX
         self.reveived = MAILBOX = []
 
     def set_debuglevel(self, debuglevel):
         """ignore debug level"""
 
     def sendmail(self, fromaddr, toaddres, body):
         """push sent mail in the mailbox"""
         self.reveived.append((fromaddr, toaddres, body))
 
     def quit(self):
         """ignore quit"""
 
 
-class MockConfigParser(ConfigParser):
+class MockConfigParser(configparser.ConfigParser):
     """fake ConfigParser.ConfigParser"""
 
     def __init__(self, options):
-        ConfigParser.__init__(self)
+        configparser.ConfigParser.__init__(self)
         for section, pairs in options.iteritems():
             self.add_section(section)
             for key, value in pairs.iteritems():
                 self.set(section, key, value)
     def write(self, _):
         raise NotImplementedError()
 
 
 class MockConnection:
     """fake DB-API 2.0 connexion AND cursor (i.e. cursor() return self)"""
@@ skipping 113 matching lines @@
         try:
             __import__(module)
             return f
         except ImportError:
             def new_f(self, *args, **kwargs):
                 self.skipTest('%s can not be imported.' % module)
             new_f.__name__ = f.__name__
             return new_f
     return check_require_module