Merged revisions 77729 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r77729 | ezio.melotti | 2010-01-24 22:48:35 +0200 (Sun, 24 Jan 2010) | 1 line

  remove archaic functions from test_support
........

3 files changed, 43 insertions, 70 deletions

diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py
index 922f62f..d81b153 100644
--- a/Lib/test/string_tests.py
+++ b/Lib/test/string_tests.py
@@ -990,15 +990,15 @@ class MixinStrUnicodeUserStringTest:
         self.checkraises(TypeError, 'hello', 'endswith', (42,))
 
     def test___contains__(self):
-        self.checkequal(True, '', '__contains__', '')         # vereq('' in '', True)
-        self.checkequal(True, 'abc', '__contains__', '')      # vereq('' in 'abc', True)
-        self.checkequal(False, 'abc', '__contains__', '\0')   # vereq('\0' in 'abc', False)
-        self.checkequal(True, '\0abc', '__contains__', '\0')  # vereq('\0' in '\0abc', True)
-        self.checkequal(True, 'abc\0', '__contains__', '\0')  # vereq('\0' in 'abc\0', True)
-        self.checkequal(True, '\0abc', '__contains__', 'a')   # vereq('a' in '\0abc', True)
-        self.checkequal(True, 'asdf', '__contains__', 'asdf') # vereq('asdf' in 'asdf', True)
-        self.checkequal(False, 'asd', '__contains__', 'asdf') # vereq('asdf' in 'asd', False)
-        self.checkequal(False, '', '__contains__', 'asdf')    # vereq('asdf' in '', False)
+        self.checkequal(True, '', '__contains__', '')
+        self.checkequal(True, 'abc', '__contains__', '')
+        self.checkequal(False, 'abc', '__contains__', '\0')
+        self.checkequal(True, '\0abc', '__contains__', '\0')
+        self.checkequal(True, 'abc\0', '__contains__', '\0')
+        self.checkequal(True, '\0abc', '__contains__', 'a')
+        self.checkequal(True, 'asdf', '__contains__', 'asdf')
+        self.checkequal(False, 'asd', '__contains__', 'asdf')
+        self.checkequal(False, '', '__contains__', 'asdf')
 
     def test_subscript(self):
         self.checkequal('a', 'abc', '__getitem__', 0)
diff --git a/Lib/test/support.py b/Lib/test/support.py
index 7b0241a..8115020 100644
--- a/Lib/test/support.py
+++ b/Lib/test/support.py
@@ -21,8 +21,8 @@ __all__ = ["Error", "TestFailed", "ResourceDenied", "import_module",
            "verbose", "use_resources", "max_memuse", "record_original_stdout",
            "get_original_stdout", "unload", "unlink", "rmtree", "forget",
            "is_resource_enabled", "requires", "find_unused_port", "bind_port",
-           "fcmp", "is_jython", "TESTFN", "HOST", "FUZZ", "findfile", "verify",
-           "vereq", "sortdict", "check_syntax_error", "open_urlresource",
+           "fcmp", "is_jython", "TESTFN", "HOST", "FUZZ", "findfile",
+           "sortdict", "check_syntax_error", "open_urlresource",
            "check_warnings", "CleanImport", "EnvironmentVarGuard",
            "TransientResource", "captured_output", "captured_stdout",
            "time_out", "socket_peer_reset", "ioerror_peer_reset",
@@ -400,30 +400,6 @@ def findfile(file, here=__file__):
         if os.path.exists(fn): return fn
     return file
 
-def verify(condition, reason='test failed'):
-    """Verify that condition is true. If not, raise TestFailed.
-
-       The optional argument reason can be given to provide
-       a better error text.
-    """
-
-    if not condition:
-        raise TestFailed(reason)
-
-def vereq(a, b):
-    """Raise TestFailed if a == b is false.
-
-    This is better than verify(a == b) because, in case of failure, the
-    error message incorporates repr(a) and repr(b) so you can see the
-    inputs.
-
-    Note that "not (a == b)" isn't necessarily the same as "a != b"; the
-    former is tested.
-    """
-
-    if not (a == b):
-        raise TestFailed("%r == %r" % (a, b))
-
 def sortdict(dict):
     "Like repr(dict), but in sorted order."
     items = sorted(dict.items())
diff --git a/Lib/test/test_pprint.py b/Lib/test/test_pprint.py
index 4370935..ad3a193 100644
--- a/Lib/test/test_pprint.py
+++ b/Lib/test/test_pprint.py
@@ -39,20 +39,19 @@ class QueryTestCase(unittest.TestCase):
 
     def test_basic(self):
         # Verify .isrecursive() and .isreadable() w/o recursion
-        verify = self.assertTrue
         pp = pprint.PrettyPrinter()
         for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, "yaddayadda",
                      self.a, self.b):
             # module-level convenience functions
-            verify(not pprint.isrecursive(safe),
-                   "expected not isrecursive for %r" % (safe,))
-            verify(pprint.isreadable(safe),
-                   "expected isreadable for %r" % (safe,))
+            self.assertFalse(pprint.isrecursive(safe),
+                             "expected not isrecursive for %r" % (safe,))
+            self.assertTrue(pprint.isreadable(safe),
+                            "expected isreadable for %r" % (safe,))
             # PrettyPrinter methods
-            verify(not pp.isrecursive(safe),
-                   "expected not isrecursive for %r" % (safe,))
-            verify(pp.isreadable(safe),
-                   "expected isreadable for %r" % (safe,))
+            self.assertFalse(pp.isrecursive(safe),
+                             "expected not isrecursive for %r" % (safe,))
+            self.assertTrue(pp.isreadable(safe),
+                            "expected isreadable for %r" % (safe,))
 
     def test_knotted(self):
         # Verify .isrecursive() and .isreadable() w/ recursion
@@ -62,14 +61,13 @@ class QueryTestCase(unittest.TestCase):
         self.d = {}
         self.d[0] = self.d[1] = self.d[2] = self.d
 
-        verify = self.assertTrue
         pp = pprint.PrettyPrinter()
 
         for icky in self.a, self.b, self.d, (self.d, self.d):
-            verify(pprint.isrecursive(icky), "expected isrecursive")
-            verify(not pprint.isreadable(icky),  "expected not isreadable")
-            verify(pp.isrecursive(icky), "expected isrecursive")
-            verify(not pp.isreadable(icky),  "expected not isreadable")
+            self.assertTrue(pprint.isrecursive(icky), "expected isrecursive")
+            self.assertFalse(pprint.isreadable(icky), "expected not isreadable")
+            self.assertTrue(pp.isrecursive(icky), "expected isrecursive")
+            self.assertFalse(pp.isreadable(icky), "expected not isreadable")
 
         # Break the cycles.
         self.d.clear()
@@ -78,31 +76,30 @@ class QueryTestCase(unittest.TestCase):
 
         for safe in self.a, self.b, self.d, (self.d, self.d):
             # module-level convenience functions
-            verify(not pprint.isrecursive(safe),
-                   "expected not isrecursive for %r" % (safe,))
-            verify(pprint.isreadable(safe),
-                   "expected isreadable for %r" % (safe,))
+            self.assertFalse(pprint.isrecursive(safe),
+                             "expected not isrecursive for %r" % (safe,))
+            self.assertTrue(pprint.isreadable(safe),
+                            "expected isreadable for %r" % (safe,))
             # PrettyPrinter methods
-            verify(not pp.isrecursive(safe),
-                   "expected not isrecursive for %r" % (safe,))
-            verify(pp.isreadable(safe),
-                   "expected isreadable for %r" % (safe,))
+            self.assertFalse(pp.isrecursive(safe),
+                             "expected not isrecursive for %r" % (safe,))
+            self.assertTrue(pp.isreadable(safe),
+                            "expected isreadable for %r" % (safe,))
 
     def test_unreadable(self):
         # Not recursive but not readable anyway
-        verify = self.assertTrue
         pp = pprint.PrettyPrinter()
         for unreadable in type(3), pprint, pprint.isrecursive:
             # module-level convenience functions
-            verify(not pprint.isrecursive(unreadable),
-                   "expected not isrecursive for %r" % (unreadable,))
-            verify(not pprint.isreadable(unreadable),
-                   "expected not isreadable for %r" % (unreadable,))
+            self.assertFalse(pprint.isrecursive(unreadable),
+                             "expected not isrecursive for %r" % (unreadable,))
+            self.assertFalse(pprint.isreadable(unreadable),
+                             "expected not isreadable for %r" % (unreadable,))
             # PrettyPrinter methods
-            verify(not pp.isrecursive(unreadable),
-                   "expected not isrecursive for %r" % (unreadable,))
-            verify(not pp.isreadable(unreadable),
-                   "expected not isreadable for %r" % (unreadable,))
+            self.assertFalse(pp.isrecursive(unreadable),
+                             "expected not isrecursive for %r" % (unreadable,))
+            self.assertFalse(pp.isreadable(unreadable),
+                             "expected not isreadable for %r" % (unreadable,))
 
     def test_same_as_repr(self):
         # Simple objects, small containers and classes that overwrite __repr__
@@ -113,12 +110,11 @@ class QueryTestCase(unittest.TestCase):
         # it sorted a dict display if and only if the display required
         # multiple lines.  For that reason, dicts with more than one element
         # aren't tested here.
-        verify = self.assertTrue
         for simple in (0, 0, 0+0j, 0.0, "", b"",
                        (), tuple2(), tuple3(),
                        [], list2(), list3(),
                        {}, dict2(), dict3(),
-                       verify, pprint,
+                       self.assertTrue, pprint,
                        -6, -6, -6-6j, -1.5, "x", b"x", (3,), [3], {3: 6},
                        (1,2), [3,4], {5: 6},
                        tuple2((1,2)), tuple3((1,2)), tuple3(range(100)),
@@ -130,8 +126,9 @@ class QueryTestCase(unittest.TestCase):
             for function in "pformat", "saferepr":
                 f = getattr(pprint, function)
                 got = f(simple)
-                verify(native == got, "expected %s got %s from pprint.%s" %
-                                      (native, got, function))
+                self.assertEqual(native, got,
+                                 "expected %s got %s from pprint.%s" %
+                                 (native, got, function))
 
     def test_basic_line_wrap(self):
         # verify basic line-wrapping operation