Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Merged revisions 77731 via svnmerge from 

svn+ssh://pythondev@svn.python.org/python/branches/py3k

................
  r77731 | ezio.melotti | 2010-01-24 22:59:24 +0200 (Sun, 24 Jan 2010) | 9 lines

  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
  ........
................
This commit is contained in:
Ezio Melotti 2010-01-24 21:02:05 +00:00
parent 95a3633c96
commit fcdf9f215e
3 changed files with 43 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
Lib/test/string_tests.py
View File

@ -962,15 +962,15 @@ class MixinStrUnicodeUserStringTest:
self.checkraises(TypeError, 'hello', 'endswith', (42,)) self.checkraises(TypeError, 'hello', 'endswith', (42,))
def test___contains__(self): def test___contains__(self):
self.checkequal(True, '', '__contains__', '') # vereq('' in '', True) self.checkequal(True, '', '__contains__', '')
self.checkequal(True, 'abc', '__contains__', '') # vereq('' in 'abc', True) self.checkequal(True, 'abc', '__contains__', '')
self.checkequal(False, 'abc', '__contains__', '\0') # vereq('\0' in 'abc', False) self.checkequal(False, 'abc', '__contains__', '\0')
self.checkequal(True, '\0abc', '__contains__', '\0') # vereq('\0' in '\0abc', True) self.checkequal(True, '\0abc', '__contains__', '\0')
self.checkequal(True, 'abc\0', '__contains__', '\0') # vereq('\0' in 'abc\0', True) self.checkequal(True, 'abc\0', '__contains__', '\0')
self.checkequal(True, '\0abc', '__contains__', 'a') # vereq('a' in '\0abc', True) self.checkequal(True, '\0abc', '__contains__', 'a')
self.checkequal(True, 'asdf', '__contains__', 'asdf') # vereq('asdf' in 'asdf', True) self.checkequal(True, 'asdf', '__contains__', 'asdf')
self.checkequal(False, 'asd', '__contains__', 'asdf') # vereq('asdf' in 'asd', False) self.checkequal(False, 'asd', '__contains__', 'asdf')
self.checkequal(False, '', '__contains__', 'asdf') # vereq('asdf' in '', False) self.checkequal(False, '', '__contains__', 'asdf')
def test_subscript(self): def test_subscript(self):
self.checkequal('a', 'abc', '__getitem__', 0) self.checkequal('a', 'abc', '__getitem__', 0)

28
Lib/test/support.py
View File

@ -21,8 +21,8 @@ __all__ = ["Error", "TestFailed", "ResourceDenied", "import_module",
"verbose", "use_resources", "max_memuse", "record_original_stdout", "verbose", "use_resources", "max_memuse", "record_original_stdout",
"get_original_stdout", "unload", "unlink", "rmtree", "forget", "get_original_stdout", "unload", "unlink", "rmtree", "forget",
"is_resource_enabled", "requires", "find_unused_port", "bind_port", "is_resource_enabled", "requires", "find_unused_port", "bind_port",
"fcmp", "is_jython", "TESTFN", "HOST", "FUZZ", "findfile", "verify", "fcmp", "is_jython", "TESTFN", "HOST", "FUZZ", "findfile",
"vereq", "sortdict", "check_syntax_error", "open_urlresource", "sortdict", "check_syntax_error", "open_urlresource",
"check_warnings", "CleanImport", "EnvironmentVarGuard", "check_warnings", "CleanImport", "EnvironmentVarGuard",
"TransientResource", "captured_output", "captured_stdout", "TransientResource", "captured_output", "captured_stdout",
"time_out", "socket_peer_reset", "ioerror_peer_reset", "time_out", "socket_peer_reset", "ioerror_peer_reset",
@ -396,30 +396,6 @@ def findfile(file, here=__file__):
if os.path.exists(fn): return fn if os.path.exists(fn): return fn
return file 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): def sortdict(dict):
"Like repr(dict), but in sorted order." "Like repr(dict), but in sorted order."
items = sorted(dict.items()) items = sorted(dict.items())

67
Lib/test/test_pprint.py
View File

@ -39,20 +39,19 @@ class QueryTestCase(unittest.TestCase):
def test_basic(self): def test_basic(self):
# Verify .isrecursive() and .isreadable() w/o recursion # Verify .isrecursive() and .isreadable() w/o recursion
verify = self.assertTrue
pp = pprint.PrettyPrinter() pp = pprint.PrettyPrinter()
for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, "yaddayadda", for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, "yaddayadda",
self.a, self.b): self.a, self.b):
# module-level convenience functions # module-level convenience functions
verify(not pprint.isrecursive(safe), self.assertFalse(pprint.isrecursive(safe),
"expected not isrecursive for %r" % (safe,)) "expected not isrecursive for %r" % (safe,))
verify(pprint.isreadable(safe), self.assertTrue(pprint.isreadable(safe),
"expected isreadable for %r" % (safe,)) "expected isreadable for %r" % (safe,))
# PrettyPrinter methods # PrettyPrinter methods
verify(not pp.isrecursive(safe), self.assertFalse(pp.isrecursive(safe),
"expected not isrecursive for %r" % (safe,)) "expected not isrecursive for %r" % (safe,))
verify(pp.isreadable(safe), self.assertTrue(pp.isreadable(safe),
"expected isreadable for %r" % (safe,)) "expected isreadable for %r" % (safe,))
def test_knotted(self): def test_knotted(self):
# Verify .isrecursive() and .isreadable() w/ recursion # Verify .isrecursive() and .isreadable() w/ recursion
@ -62,14 +61,13 @@ class QueryTestCase(unittest.TestCase):
self.d = {} self.d = {}
self.d[0] = self.d[1] = self.d[2] = self.d self.d[0] = self.d[1] = self.d[2] = self.d
verify = self.assertTrue
pp = pprint.PrettyPrinter() pp = pprint.PrettyPrinter()
for icky in self.a, self.b, self.d, (self.d, self.d): for icky in self.a, self.b, self.d, (self.d, self.d):
verify(pprint.isrecursive(icky), "expected isrecursive") self.assertTrue(pprint.isrecursive(icky), "expected isrecursive")
verify(not pprint.isreadable(icky), "expected not isreadable") self.assertFalse(pprint.isreadable(icky), "expected not isreadable")
verify(pp.isrecursive(icky), "expected isrecursive") self.assertTrue(pp.isrecursive(icky), "expected isrecursive")
verify(not pp.isreadable(icky), "expected not isreadable") self.assertFalse(pp.isreadable(icky), "expected not isreadable")
# Break the cycles. # Break the cycles.
self.d.clear() self.d.clear()
@ -78,31 +76,30 @@ class QueryTestCase(unittest.TestCase):
for safe in self.a, self.b, self.d, (self.d, self.d): for safe in self.a, self.b, self.d, (self.d, self.d):
# module-level convenience functions # module-level convenience functions
verify(not pprint.isrecursive(safe), self.assertFalse(pprint.isrecursive(safe),
"expected not isrecursive for %r" % (safe,)) "expected not isrecursive for %r" % (safe,))
verify(pprint.isreadable(safe), self.assertTrue(pprint.isreadable(safe),
"expected isreadable for %r" % (safe,)) "expected isreadable for %r" % (safe,))
# PrettyPrinter methods # PrettyPrinter methods
verify(not pp.isrecursive(safe), self.assertFalse(pp.isrecursive(safe),
"expected not isrecursive for %r" % (safe,)) "expected not isrecursive for %r" % (safe,))
verify(pp.isreadable(safe), self.assertTrue(pp.isreadable(safe),
"expected isreadable for %r" % (safe,)) "expected isreadable for %r" % (safe,))
def test_unreadable(self): def test_unreadable(self):
# Not recursive but not readable anyway # Not recursive but not readable anyway
verify = self.assertTrue
pp = pprint.PrettyPrinter() pp = pprint.PrettyPrinter()
for unreadable in type(3), pprint, pprint.isrecursive: for unreadable in type(3), pprint, pprint.isrecursive:
# module-level convenience functions # module-level convenience functions
verify(not pprint.isrecursive(unreadable), self.assertFalse(pprint.isrecursive(unreadable),
"expected not isrecursive for %r" % (unreadable,)) "expected not isrecursive for %r" % (unreadable,))
verify(not pprint.isreadable(unreadable), self.assertFalse(pprint.isreadable(unreadable),
"expected not isreadable for %r" % (unreadable,)) "expected not isreadable for %r" % (unreadable,))
# PrettyPrinter methods # PrettyPrinter methods
verify(not pp.isrecursive(unreadable), self.assertFalse(pp.isrecursive(unreadable),
"expected not isrecursive for %r" % (unreadable,)) "expected not isrecursive for %r" % (unreadable,))
verify(not pp.isreadable(unreadable), self.assertFalse(pp.isreadable(unreadable),
"expected not isreadable for %r" % (unreadable,)) "expected not isreadable for %r" % (unreadable,))
def test_same_as_repr(self): def test_same_as_repr(self):
# Simple objects, small containers and classes that overwrite __repr__ # 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 # it sorted a dict display if and only if the display required
# multiple lines. For that reason, dicts with more than one element # multiple lines. For that reason, dicts with more than one element
# aren't tested here. # aren't tested here.
verify = self.assertTrue
for simple in (0, 0, 0+0j, 0.0, "", b"", for simple in (0, 0, 0+0j, 0.0, "", b"",
(), tuple2(), tuple3(), (), tuple2(), tuple3(),
[], list2(), list3(), [], list2(), list3(),
{}, dict2(), dict3(), {}, dict2(), dict3(),
verify, pprint, self.assertTrue, pprint,
-6, -6, -6-6j, -1.5, "x", b"x", (3,), [3], {3: 6}, -6, -6, -6-6j, -1.5, "x", b"x", (3,), [3], {3: 6},
(1,2), [3,4], {5: 6}, (1,2), [3,4], {5: 6},
tuple2((1,2)), tuple3((1,2)), tuple3(range(100)), tuple2((1,2)), tuple3((1,2)), tuple3(range(100)),
@ -130,8 +126,9 @@ class QueryTestCase(unittest.TestCase):
for function in "pformat", "saferepr": for function in "pformat", "saferepr":
f = getattr(pprint, function) f = getattr(pprint, function)
got = f(simple) got = f(simple)
verify(native == got, "expected %s got %s from pprint.%s" % self.assertEqual(native, got,
(native, got, function)) "expected %s got %s from pprint.%s" %
(native, got, function))
def test_basic_line_wrap(self): def test_basic_line_wrap(self):
# verify basic line-wrapping operation # verify basic line-wrapping operation