From b19f43dbf059c46aca0e416bedb43c65c511f42b Mon Sep 17 00:00:00 2001 From: Ezio Melotti Date: Sun, 24 Jan 2010 20:59:24 +0000 Subject: 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 ........ --- Lib/test/string_tests.py | 18 ++++++------- Lib/test/support.py | 28 ++------------------ Lib/test/test_pprint.py | 67 +++++++++++++++++++++++------------------------- 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 -- cgit v0.12