Rename our future-happy unittest methods to match their future versions, and let the future versions win if they exist.

7 files changed, 142 insertions, 85 deletions

diff --git a/test/backunittest.py b/test/backunittest.py
index 35003ee5..2088f2f7 100644
--- a/test/backunittest.py
+++ b/test/backunittest.py
@@ -4,68 +4,82 @@ 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.
+    Designed to be compatible with 3.1 unittest.  Methods are only defined if
+    the builtin `unittest` doesn't have them.
     
     """
-    def assert_raises_msg(self, excClass, msg, callableObj, *args, **kwargs):
-        """ Just like unittest.TestCase.assertRaises,
-            but checks that the message is right too.
-        """
-        try:
-            callableObj(*args, **kwargs)
-        except excClass:
-            _, exc, _ = sys.exc_info()
-            excMsg = str(exc)
-            if not msg:
-                # No message provided: it passes.
-                return  #pragma: no cover
-            elif excMsg == msg:
-                # Message provided, and we got the right message: it passes.
-                return
+    if _need('assertFalse'):
+        def assertFalse(self, exp):
+            """Assert that `exp` is false."""
+            if exp:
+                self.fail()
+
+    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:   #pragma: no cover
+                    # 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:   #pragma: no cover
-                # Message provided, and it didn't match: fail!
+                if hasattr(excClass, '__name__'):
+                    excName = excClass.__name__
+                else:
+                    excName = str(excClass)
                 raise self.failureException(
-                    "Right exception, wrong message: got '%s' expected '%s'" %
-                    (excMsg, msg)
+                    "Expected to raise %s, didn't get an exception at all" %
+                    excName
                     )
-        # No need to catch other exceptions: They'll fail the test all by
-        # themselves!
-        else:   #pragma: no cover
-            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
-                )
-
-    def assert_equal_sets(self, s1, s2):
-        """Assert that the two arguments are equal as sets."""
-        self.assertEqual(set(s1), set(s2))
 
-    def assert_matches(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('assertSameElements'):
+        def assertSameElements(self, s1, s2):
+            """Assert that the two arguments are equal as sets."""
+            self.assertEqual(set(s1), set(s2))
 
-    def assert_multiline_equal(self, first, second):
-        """Assert that two multi-line strings are equal.
-        
-        If they aren't, show a nice diff.
-        
-        """
-        # Adapted from Py3.1 unittest.
-        self.assert_(isinstance(first, str), (
-                'First argument is not a string'))
-        self.assert_(isinstance(second, str), (
-                'Second argument is not a string'))
+    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 first != second:
-            msg = ''.join(difflib.ndiff(first.splitlines(True),
+    if _need('assertMultiLineEqual'):
+        def assertMultiLineEqual(self, first, second):
+            """Assert that two multi-line strings are equal.
+            
+            If they aren't, show a nice diff.
+            
+            """
+            # Adapted from Py3.1 unittest.
+            self.assert_(isinstance(first, str), (
+                    'First argument is not a string'))
+            self.assert_(isinstance(second, str), (
+                    'Second argument is not a string'))
+    
+            if first != second:
+                msg = ''.join(difflib.ndiff(first.splitlines(True),
                                                     second.splitlines(True)))
-            self.fail("Multi-line strings are unequal:\n" + msg)
+                self.fail("Multi-line strings are unequal:\n" + msg)
diff --git a/test/coveragetest.py b/test/coveragetest.py
index 76ba1ec6..1fb04721 100644
--- a/test/coveragetest.py
+++ b/test/coveragetest.py
@@ -3,7 +3,7 @@
 import imp, os, random, shlex, shutil, sys, tempfile, textwrap
 
 import coverage
-from coverage.backward import set, sorted, StringIO # pylint: disable-msg=W0622
+from coverage.backward import sorted, StringIO      # pylint: disable-msg=W0622
 from backtest import run_command
 from backunittest import TestCase
 
diff --git a/test/test_api.py b/test/test_api.py
index 1a1f5412..932606fd 100644
--- a/test/test_api.py
+++ b/test/test_api.py
@@ -204,13 +204,13 @@ class ApiTest(CoverageTest):
             fooey = 17
             """)
 
-        self.assert_equal_sets(os.listdir("."), ["datatest1.py"])
+        self.assertSameElements(os.listdir("."), ["datatest1.py"])
         cov = coverage.coverage()
         cov.start()
         self.import_module("datatest1")
         cov.stop()
         cov.save()
-        self.assert_equal_sets(os.listdir("."),
+        self.assertSameElements(os.listdir("."),
                             ["datatest1.py", "datatest1.pyc", ".coverage"])
 
     def testDatafileSpecified(self):
@@ -219,13 +219,13 @@ class ApiTest(CoverageTest):
             fooey = 17
             """)
 
-        self.assert_equal_sets(os.listdir("."), ["datatest2.py"])
+        self.assertSameElements(os.listdir("."), ["datatest2.py"])
         cov = coverage.coverage(data_file="cov.data")
         cov.start()
         self.import_module("datatest2")
         cov.stop()
         cov.save()
-        self.assert_equal_sets(os.listdir("."),
+        self.assertSameElements(os.listdir("."),
                             ["datatest2.py", "datatest2.pyc", "cov.data"])
 
     def testDatafileAndSuffixSpecified(self):
@@ -234,13 +234,13 @@ class ApiTest(CoverageTest):
             fooey = 17
             """)
 
-        self.assert_equal_sets(os.listdir("."), ["datatest3.py"])
+        self.assertSameElements(os.listdir("."), ["datatest3.py"])
         cov = coverage.coverage(data_file="cov.data", data_suffix=".14")
         cov.start()
         self.import_module("datatest3")
         cov.stop()
         cov.save()
-        self.assert_equal_sets(os.listdir("."),
+        self.assertSameElements(os.listdir("."),
                             ["datatest3.py", "datatest3.pyc", "cov.data.14"])
 
     def testEmptyReporting(self):
diff --git a/test/test_coverage.py b/test/test_coverage.py
index 10cadfef..b9d622cd 100644
--- a/test/test_coverage.py
+++ b/test/test_coverage.py
@@ -1656,7 +1656,7 @@ class ProcessTest(CoverageTest):
         self.run_command("coverage run fleeting.py")
         os.remove("fleeting.py")
         out = self.run_command("coverage html -d htmlcov")
-        self.assert_matches(out, "No source for code: '.*fleeting.py'")
+        self.assertRegexpMatches(out, "No source for code: '.*fleeting.py'")
         self.assert_("Traceback" not in out)
 
         # It happens that the code paths are different for *.py and other
@@ -1668,17 +1668,17 @@ class ProcessTest(CoverageTest):
         self.run_command("coverage run fleeting")
         os.remove("fleeting")
         out = self.run_command("coverage html -d htmlcov")
-        self.assert_matches(out, "No source for code: '.*fleeting'")
+        self.assertRegexpMatches(out, "No source for code: '.*fleeting'")
         self.assert_("Traceback" not in out)
 
     def test_running_missing_file(self):
         out = self.run_command("coverage run xyzzy.py")
-        self.assert_matches(out, "No file to run: .*xyzzy.py")
+        self.assertRegexpMatches(out, "No file to run: .*xyzzy.py")
         self.assert_("Traceback" not in out)
 
     def test_no_data_to_report_on_annotate(self):
         # Reporting with no data produces a nice message and no output dir.
-        self.assert_raises_msg(
+        self.assertRaisesRegexp(
             CoverageException, "No data to report.",
             self.command_line, "annotate -d ann"
             )
@@ -1686,7 +1686,7 @@ class ProcessTest(CoverageTest):
 
     def test_no_data_to_report_on_html(self):
         # Reporting with no data produces a nice message and no output dir.
-        self.assert_raises_msg(
+        self.assertRaisesRegexp(
             CoverageException, "No data to report.",
             self.command_line, "html -d htmlcov"
             )
@@ -1694,7 +1694,7 @@ class ProcessTest(CoverageTest):
 
     def test_no_data_to_report_on_xml(self):
         # Reporting with no data produces a nice message.
-        self.assert_raises_msg(
+        self.assertRaisesRegexp(
             CoverageException, "No data to report.",
             self.command_line, "xml"
             )
diff --git a/test/test_data.py b/test/test_data.py
index 640f4f07..98acc2bb 100644
--- a/test/test_data.py
+++ b/test/test_data.py
@@ -32,7 +32,7 @@ class DataTest(CoverageTest):
         
     def assert_executed_files(self, covdata, execed):
         """Check that `covdata`'s executed files are `execed`."""
-        self.assert_equal_sets(covdata.executed_files(), execed)
+        self.assertSameElements(covdata.executed_files(), execed)
     
     def test_reading_empty(self):
         covdata = CoverageData()
@@ -92,9 +92,9 @@ class DataTest(CoverageTest):
             fdata.close()
         
         lines = data['lines']
-        self.assert_equal_sets(lines.keys(), EXECED_FILES_1)
-        self.assert_equal_sets(lines['a.py'], A_PY_LINES_1)
-        self.assert_equal_sets(lines['b.py'], B_PY_LINES_1)
+        self.assertSameElements(lines.keys(), EXECED_FILES_1)
+        self.assertSameElements(lines['a.py'], A_PY_LINES_1)
+        self.assertSameElements(lines['b.py'], B_PY_LINES_1)
         # If not measuring branches, there's no arcs entry.
         self.assertEqual(data.get('arcs', 'not there'), 'not there')
 
@@ -110,7 +110,7 @@ class DataTest(CoverageTest):
         finally:
             fdata.close()
         
-        self.assert_equal_sets(data['lines'].keys(), [])
+        self.assertSameElements(data['lines'].keys(), [])
         arcs = data['arcs']
-        self.assert_equal_sets(arcs['x.py'], X_PY_ARCS_3)
-        self.assert_equal_sets(arcs['y.py'], Y_PY_ARCS_3)
+        self.assertSameElements(arcs['x.py'], X_PY_ARCS_3)
+        self.assertSameElements(arcs['y.py'], Y_PY_ARCS_3)
diff --git a/test/test_phystokens.py b/test/test_phystokens.py
index fb0b5535..a01cc374 100644
--- a/test/test_phystokens.py
+++ b/test/test_phystokens.py
@@ -38,7 +38,7 @@ class PhysTokensTest(CoverageTest):
         # before comparing.
         source = re.sub("(?m)[ \t]+$", "", source)
         tokenized = re.sub("(?m)[ \t]+$", "", tokenized)
-        self.assert_multiline_equal(source, tokenized)
+        self.assertMultiLineEqual(source, tokenized)
 
     def check_file_tokenization(self, fname):
         """Use the contents of `fname` for `check_tokenization`."""
diff --git a/test/test_testing.py b/test/test_testing.py
index 4208c1d1..a239d14f 100644
--- a/test/test_testing.py
+++ b/test/test_testing.py
@@ -11,25 +11,68 @@ class TestingTest(TestCase):
 
     run_in_temp_dir = False
 
-    def test_assert_equal_sets(self):
-        self.assert_equal_sets(set(), set())
-        self.assert_equal_sets(set([1,2,3]), set([3,1,2]))
-        self.assertRaises(AssertionError, self.assert_equal_sets,
+    def please_raise(self, exc, msg):
+        """Raise an exception for testing assertRaisesRegexp."""
+        raise exc(msg)
+
+    def please_succeed(self):
+        """A simple successful method for testing assertRaisesRegexp."""
+        return "All is well"
+
+    def test_assert_same_elements(self):
+        self.assertSameElements(set(), set())
+        self.assertSameElements(set([1,2,3]), set([3,1,2]))
+        self.assertRaises(AssertionError, self.assertSameElements,
             set([1,2,3]), set()
             )
-        self.assertRaises(AssertionError, self.assert_equal_sets,
+        self.assertRaises(AssertionError, self.assertSameElements,
             set([1,2,3]), set([4,5,6])
             )
 
-    def test_assert_matches(self):
-        self.assert_matches("hello", "hel*o")
-        self.assert_matches("Oh, hello there!", "hel*o")
-        self.assertRaises(AssertionError, self.assert_matches,
+    def test_assert_regexp_matches(self):
+        self.assertRegexpMatches("hello", "hel*o")
+        self.assertRegexpMatches("Oh, hello there!", "hel*o")
+        self.assertRaises(AssertionError, self.assertRegexpMatches,
             "hello there", "^hello$"
             )
 
     def test_assert_multiline_equal(self):
-        self.assert_multiline_equal("hello", "hello")
-        self.assertRaises(AssertionError, self.assert_matches,
+        self.assertMultiLineEqual("hello", "hello")
+        self.assertRaises(AssertionError, self.assertMultiLineEqual,
             "hello there", "Hello there"
             )
+        self.assertRaises(AssertionError, self.assertMultiLineEqual,
+            "hello\nthere", "hello\nThere"
+            )
+
+    def test_assert_raises_regexp(self):
+        # Raising the right error with the right message passes.
+        self.assertRaisesRegexp(
+            ZeroDivisionError, "Wow! Zero!",
+            self.please_raise, ZeroDivisionError, "Wow! Zero!"
+            )
+        # Raising the right error with a match passes.
+        self.assertRaisesRegexp(
+            ZeroDivisionError, "Zero",
+            self.please_raise, ZeroDivisionError, "Wow! Zero!"
+            )
+        # Raising the right error with a mismatch fails.
+        self.assertRaises(AssertionError,
+            self.assertRaisesRegexp, ZeroDivisionError, "XYZ",
+            self.please_raise, ZeroDivisionError, "Wow! Zero!"
+            )
+        # Raising the right error with a mismatch fails.
+        self.assertRaises(AssertionError,
+            self.assertRaisesRegexp, ZeroDivisionError, "XYZ",
+            self.please_raise, ZeroDivisionError, "Wow! Zero!"
+            )
+        # Raising the wrong error raises the error itself.
+        self.assertRaises(ZeroDivisionError,
+            self.assertRaisesRegexp, IOError, "Wow! Zero!",
+            self.please_raise, ZeroDivisionError, "Wow! Zero!"
+            )
+        # Raising no error fails.
+        self.assertRaises(AssertionError,
+            self.assertRaisesRegexp, ZeroDivisionError, "XYZ",
+            self.please_succeed
+            )