1 files changed, 93 insertions, 0 deletions
diff --git a/test/backunittest.py b/test/backunittest.py
new file mode 100644
index 00000000..f606185f
--- /dev/null
+++ b/test/backunittest.py
@@ -0,0 +1,93 @@
+"""Implementations of unittest features from the future."""
+
+import difflib, re, sys, unittest
+
+from coverage.backward import set                   # pylint: disable-msg=W0622
+
+
+def _need(method):
+    """Do we need to define our own `method` method?"""
+    return not hasattr(unittest.TestCase, method)
+
+
+class TestCase(unittest.TestCase):
+    """Just like unittest.TestCase, but with assert methods added.
+
+    Designed to be compatible with 3.1 unittest.  Methods are only defined if
+    the builtin `unittest` doesn't have them.
+
+    """
+    if _need('assertTrue'):
+        def assertTrue(self, exp, msg=None):
+            """Assert that `exp` is true."""
+            if not exp:
+                self.fail(msg)
+
+    if _need('assertFalse'):
+        def assertFalse(self, exp, msg=None):
+            """Assert that `exp` is false."""
+            if exp:
+                self.fail(msg)
+
+    if _need('assertRaisesRegexp'):
+        def assertRaisesRegexp(self, excClass, regexp, callobj, *args, **kw):
+            """ Just like unittest.TestCase.assertRaises,
+                but checks that the message is right too.
+            """
+            try:
+                callobj(*args, **kw)
+            except excClass:
+                _, exc, _ = sys.exc_info()
+                excMsg = str(exc)
+                if re.search(regexp, excMsg):
+                    # Message provided, and we got the right one: it passes.
+                    return
+                else:
+                    # Message provided, and it didn't match: fail!
+                    raise self.failureException(
+                        "Right exception, wrong message: "
+                            "'%s' doesn't match '%s'" % (excMsg, regexp)
+                        )
+            # No need to catch other exceptions: They'll fail the test all by
+            # themselves!
+            else:
+                if hasattr(excClass, '__name__'):
+                    excName = excClass.__name__
+                else:
+                    excName = str(excClass)
+                raise self.failureException(
+                    "Expected to raise %s, didn't get an exception at all" %
+                    excName
+                    )
+
+    if _need('assertSameElements'):
+        def assertSameElements(self, s1, s2):
+            """Assert that the two arguments are equal as sets."""
+            self.assertEqual(set(s1), set(s2))
+
+    if _need('assertRegexpMatches'):
+        def assertRegexpMatches(self, s, regex):
+            """Assert that `s` matches `regex`."""
+            m = re.search(regex, s)
+            if not m:
+                raise self.failureException("%r doesn't match %r" % (s, regex))
+
+    if _need('assertMultiLineEqual'):
+        def assertMultiLineEqual(self, first, second, msg=None):
+            """Assert that two multi-line strings are equal.
+
+            If they aren't, show a nice diff.
+
+            """
+            # Adapted from Py3.1 unittest.
+            self.assertTrue(isinstance(first, str),
+                    'First argument is not a string')
+            self.assertTrue(isinstance(second, str),
+                    'Second argument is not a string')
+
+            if first != second:
+                message = ''.join(difflib.ndiff(first.splitlines(True),
+                                                    second.splitlines(True)))
+                if msg:
+                    message += " : " + msg
+                self.fail("Multi-line strings are unequal:\n" + message)