cpython.git - https://github.com/python/cpython.git

diff options

author	Raymond Hettinger <python@rcn.com>	2010-08-06 09:52:17 (GMT)
committer	Raymond Hettinger <python@rcn.com>	2010-08-06 09:52:17 (GMT)
commit	38bf2ccf4c461a1c65aafffccb87ddb38cf52b5c (patch)
tree	e359de50a65fdc1d75ff18c6ca35baf6cef4e3e4 /Python/symtable.c
parent	4f3086f264742c5c09cc658fb2031773554eccea (diff)
download	cpython-38bf2ccf4c461a1c65aafffccb87ddb38cf52b5c.zip cpython-38bf2ccf4c461a1c65aafffccb87ddb38cf52b5c.tar.gz cpython-38bf2ccf4c461a1c65aafffccb87ddb38cf52b5c.tar.bz2

Issue8757: Implicit set-to-frozenset conversion not thread-safe.

Diffstat (limited to 'Python/symtable.c')

0 files changed, 0 insertions, 0 deletions

| 6 +- Lib/test/test_cmd_line_script.py | 8 +- Lib/test/test_codecs.py | 10 +- Lib/test/test_codeop.py | 6 +- Lib/test/test_collections.py | 144 +++--- Lib/test/test_compile.py | 10 +- Lib/test/test_complex.py | 10 +- Lib/test/test_contains.py | 36 +- Lib/test/test_contextlib.py | 20 +- Lib/test/test_copy.py | 124 ++--- Lib/test/test_copyreg.py | 8 +- Lib/test/test_csv.py | 8 +- Lib/test/test_datetime.py | 338 ++++++------- Lib/test/test_dbm.py | 6 +- Lib/test/test_dbm_dumb.py | 2 +- Lib/test/test_dbm_gnu.py | 8 +- Lib/test/test_dbm_ndbm.py | 4 +- Lib/test/test_decimal.py | 88 ++-- Lib/test/test_defaultdict.py | 24 +- Lib/test/test_deque.py | 10 +- Lib/test/test_descr.py | 318 ++++++------ Lib/test/test_dict.py | 52 +- Lib/test/test_dictviews.py | 22 +- Lib/test/test_docxmlrpc.py | 8 +- Lib/test/test_dummy_thread.py | 38 +- Lib/test/test_epoll.py | 20 +- Lib/test/test_errno.py | 6 +- Lib/test/test_exceptions.py | 50 +- Lib/test/test_file.py | 8 +- Lib/test/test_filecmp.py | 26 +- Lib/test/test_fileinput.py | 6 +- Lib/test/test_fileio.py | 12 +- Lib/test/test_float.py | 60 +-- Lib/test/test_fnmatch.py | 4 +- Lib/test/test_ftplib.py | 4 +- Lib/test/test_funcattrs.py | 18 +- Lib/test/test_functools.py | 18 +- Lib/test/test_genericpath.py | 4 +- Lib/test/test_getargs2.py | 142 +++--- Lib/test/test_getopt.py | 10 +- Lib/test/test_gettext.py | 2 +- Lib/test/test_grammar.py | 26 +- Lib/test/test_grp.py | 8 +- Lib/test/test_gzip.py | 6 +- Lib/test/test_hash.py | 2 +- Lib/test/test_hashlib.py | 2 +- Lib/test/test_heapq.py | 2 +- Lib/test/test_hmac.py | 8 +- Lib/test/test_http_cookiejar.py | 220 ++++---- Lib/test/test_httplib.py | 4 +- Lib/test/test_httpservers.py | 4 +- Lib/test/test_imp.py | 2 +- Lib/test/test_import.py | 14 +- Lib/test/test_importhooks.py | 2 +- Lib/test/test_index.py | 22 +- Lib/test/test_inspect.py | 66 +-- Lib/test/test_int.py | 12 +- Lib/test/test_io.py | 26 +- Lib/test/test_ioctl.py | 4 +- Lib/test/test_iter.py | 22 +- Lib/test/test_itertools.py | 14 +- Lib/test/test_kqueue.py | 10 +- Lib/test/test_largefile.py | 2 +- Lib/test/test_list.py | 8 +- Lib/test/test_logging.py | 52 +- Lib/test/test_long.py | 26 +- Lib/test/test_macpath.py | 42 +- Lib/test/test_mailbox.py | 174 +++---- Lib/test/test_math.py | 148 +++--- Lib/test/test_memoryio.py | 4 +- Lib/test/test_memoryview.py | 10 +- Lib/test/test_mimetypes.py | 2 +- Lib/test/test_minidom.py | 2 +- Lib/test/test_mmap.py | 4 +- Lib/test/test_module.py | 4 +- Lib/test/test_modulefinder.py | 6 +- Lib/test/test_multibytecodec.py | 4 +- Lib/test/test_multibytecodec_support.py | 4 +- Lib/test/test_netrc.py | 6 +- Lib/test/test_normalization.py | 14 +- Lib/test/test_opcodes.py | 2 +- Lib/test/test_operator.py | 272 +++++----- Lib/test/test_optparse.py | 64 +-- Lib/test/test_os.py | 14 +- Lib/test/test_ossaudiodev.py | 8 +- Lib/test/test_parser.py | 18 +- Lib/test/test_peepholer.py | 62 +-- Lib/test/test_pep247.py | 6 +- Lib/test/test_pep277.py | 4 +- Lib/test/test_pep3120.py | 2 +- Lib/test/test_pep352.py | 10 +- Lib/test/test_pkg.py | 22 +- Lib/test/test_pkgimport.py | 2 +- Lib/test/test_platform.py | 6 +- Lib/test/test_poplib.py | 2 +- Lib/test/test_posix.py | 18 +- Lib/test/test_posixpath.py | 28 +- Lib/test/test_pprint.py | 8 +- Lib/test/test_property.py | 4 +- Lib/test/test_pwd.py | 18 +- Lib/test/test_pyclbr.py | 8 +- Lib/test/test_pydoc.py | 6 +- Lib/test/test_queue.py | 28 +- Lib/test/test_raise.py | 34 +- Lib/test/test_random.py | 30 +- Lib/test/test_range.py | 12 +- Lib/test/test_re.py | 2 +- Lib/test/test_reprlib.py | 20 +- Lib/test/test_richcmp.py | 18 +- Lib/test/test_robotparser.py | 4 +- Lib/test/test_runpy.py | 58 +-- Lib/test/test_scope.py | 10 +- Lib/test/test_set.py | 118 ++--- Lib/test/test_shutil.py | 24 +- Lib/test/test_signal.py | 6 +- Lib/test/test_site.py | 32 +- Lib/test/test_slice.py | 2 +- Lib/test/test_socket.py | 54 +- Lib/test/test_stringprep.py | 80 +-- Lib/test/test_strptime.py | 94 ++-- Lib/test/test_struct.py | 4 +- Lib/test/test_structseq.py | 16 +- Lib/test/test_subprocess.py | 14 +- Lib/test/test_symtable.py | 2 +- Lib/test/test_sys.py | 102 ++-- Lib/test/test_tarfile.py | 86 ++-- Lib/test/test_tempfile.py | 112 ++--- Lib/test/test_threading.py | 30 +- Lib/test/test_threading_local.py | 2 +- Lib/test/test_time.py | 48 +- Lib/test/test_timeout.py | 16 +- Lib/test/test_tokenize.py | 2 +- Lib/test/test_traceback.py | 50 +- Lib/test/test_tuple.py | 12 +- Lib/test/test_types.py | 4 +- Lib/test/test_unary.py | 18 +- Lib/test/test_unicode.py | 76 +-- Lib/test/test_unicode_file.py | 38 +- Lib/test/test_unicodedata.py | 14 +- Lib/test/test_urllib.py | 26 +- Lib/test/test_urllib2.py | 58 +-- Lib/test/test_urllib2_localnet.py | 6 +- Lib/test/test_urllib2net.py | 6 +- Lib/test/test_urllibnet.py | 22 +- Lib/test/test_userdict.py | 14 +- Lib/test/test_uuid.py | 8 +- Lib/test/test_warnings.py | 64 +-- Lib/test/test_weakref.py | 164 +++--- Lib/test/test_weakset.py | 80 +-- Lib/test/test_winreg.py | 2 +- Lib/test/test_wsgiref.py | 44 +- Lib/test/test_xdrlib.py | 6 +- Lib/test/test_xmlrpc.py | 16 +- Lib/test/test_xmlrpc_net.py | 2 +- Lib/test/test_zipfile.py | 76 +-- Lib/test/test_zipimport.py | 4 +- Lib/test/test_zipimport_support.py | 8 +- Lib/test/test_zlib.py | 20 +- Lib/tkinter/test/test_tkinter/test_text.py | 12 +- Lib/tkinter/test/test_ttk/test_extensions.py | 82 +-- Lib/tkinter/test/test_ttk/test_functions.py | 156 +++--- Lib/tkinter/test/test_ttk/test_style.py | 30 +- Lib/tkinter/test/test_ttk/test_widgets.py | 560 ++++++++++----------- 274 files changed, 4543 insertions(+), 4543 deletions(-) diff --git a/Lib/ctypes/test/test_anon.py b/Lib/ctypes/test/test_anon.py index 99e02cb..d892b59 100644 --- a/Lib/ctypes/test/test_anon.py +++ b/Lib/ctypes/test/test_anon.py @@ -14,22 +14,22 @@ class AnonTest(unittest.TestCase): ("y", c_int)] _anonymous_ = ["_"] - self.failUnlessEqual(Y.a.offset, sizeof(c_int)) - self.failUnlessEqual(Y.b.offset, sizeof(c_int)) + self.assertEqual(Y.a.offset, sizeof(c_int)) + self.assertEqual(Y.b.offset, sizeof(c_int)) - self.failUnlessEqual(ANON.a.offset, 0) - self.failUnlessEqual(ANON.b.offset, 0) + self.assertEqual(ANON.a.offset, 0) + self.assertEqual(ANON.b.offset, 0) def test_anon_nonseq(self): # TypeError: _anonymous_ must be a sequence - self.failUnlessRaises(TypeError, + self.assertRaises(TypeError, lambda: type(Structure)("Name", (Structure,), {"_fields_": [], "_anonymous_": 42})) def test_anon_nonmember(self): # AttributeError: type object 'Name' has no attribute 'x' - self.failUnlessRaises(AttributeError, + self.assertRaises(AttributeError, lambda: type(Structure)("Name", (Structure,), {"_fields_": [], @@ -50,11 +50,11 @@ class AnonTest(unittest.TestCase): ("y", c_int)] _anonymous_ = ["_"] - self.failUnlessEqual(Y.x.offset, 0) - self.failUnlessEqual(Y.a.offset, sizeof(c_int)) - self.failUnlessEqual(Y.b.offset, sizeof(c_int)) - self.failUnlessEqual(Y._.offset, sizeof(c_int)) - self.failUnlessEqual(Y.y.offset, sizeof(c_int) * 2) + self.assertEqual(Y.x.offset, 0) + self.assertEqual(Y.a.offset, sizeof(c_int)) + self.assertEqual(Y.b.offset, sizeof(c_int)) + self.assertEqual(Y._.offset, sizeof(c_int)) + self.assertEqual(Y.y.offset, sizeof(c_int) * 2) if __name__ == "__main__": unittest.main() diff --git a/Lib/ctypes/test/test_array_in_pointer.py b/Lib/ctypes/test/test_array_in_pointer.py index 6bed1f1..ca1edcf 100644 --- a/Lib/ctypes/test/test_array_in_pointer.py +++ b/Lib/ctypes/test/test_array_in_pointer.py @@ -26,7 +26,7 @@ class Test(unittest.TestCase): c.pvalues = val_array # memory contains 4 NUL bytes now, that's correct - self.failUnlessEqual("00-00-00-00", dump(val_array)) + self.assertEqual("00-00-00-00", dump(val_array)) # set the values of the array through the pointer: for i in range(4): @@ -35,7 +35,7 @@ class Test(unittest.TestCase): values = [c.pvalues[i].val for i in range(4)] # These are the expected results: here s the bug! - self.failUnlessEqual( + self.assertEqual( (values, dump(val_array)), ([1, 2, 3, 4], "01-02-03-04") ) @@ -45,7 +45,7 @@ class Test(unittest.TestCase): val_array = (Value * 4)() # memory contains 4 NUL bytes now, that's correct - self.failUnlessEqual("00-00-00-00", dump(val_array)) + self.assertEqual("00-00-00-00", dump(val_array)) ptr = cast(val_array, POINTER(Value)) # set the values of the array through the pointer: @@ -55,7 +55,7 @@ class Test(unittest.TestCase): values = [ptr[i].val for i in range(4)] # These are the expected results: here s the bug! - self.failUnlessEqual( + self.assertEqual( (values, dump(val_array)), ([1, 2, 3, 4], "01-02-03-04") ) diff --git a/Lib/ctypes/test/test_arrays.py b/Lib/ctypes/test/test_arrays.py index 8b5476d..c0cdfd5 100644 --- a/Lib/ctypes/test/test_arrays.py +++ b/Lib/ctypes/test/test_arrays.py @@ -19,23 +19,23 @@ class ArrayTestCase(unittest.TestCase): ia = int_array(*init) # length of instance ok? - self.failUnlessEqual(len(ia), alen) + self.assertEqual(len(ia), alen) # slot values ok? values = [ia[i] for i in range(len(init))] - self.failUnlessEqual(values, init) + self.assertEqual(values, init) # change the items from operator import setitem new_values = list(range(42, 42+alen)) [setitem(ia, n, new_values[n]) for n in range(alen)] values = [ia[i] for i in range(len(init))] - self.failUnlessEqual(values, new_values) + self.assertEqual(values, new_values) # are the items initialized to 0? ia = int_array() values = [ia[i] for i in range(len(init))] - self.failUnlessEqual(values, [0] * len(init)) + self.assertEqual(values, [0] * len(init)) # Too many in itializers should be caught self.assertRaises(IndexError, int_array, *range(alen*2)) @@ -48,14 +48,14 @@ class ArrayTestCase(unittest.TestCase): # CharArray("abc") self.assertRaises(TypeError, CharArray, "abc") - self.failUnlessEqual(ca[0], b"a") - self.failUnlessEqual(ca[1], b"b") - self.failUnlessEqual(ca[2], b"c") - self.failUnlessEqual(ca[-3], b"a") - self.failUnlessEqual(ca[-2], b"b") - self.failUnlessEqual(ca[-1], b"c") + self.assertEqual(ca[0], b"a") + self.assertEqual(ca[1], b"b") + self.assertEqual(ca[2], b"c") + self.assertEqual(ca[-3], b"a") + self.assertEqual(ca[-2], b"b") + self.assertEqual(ca[-1], b"c") - self.failUnlessEqual(len(ca), 3) + self.assertEqual(len(ca), 3) # cannot delete items from operator import delitem @@ -69,34 +69,34 @@ class ArrayTestCase(unittest.TestCase): na = numarray() values = [na[i] for i in range(alen)] - self.failUnlessEqual(values, [0] * alen) + self.assertEqual(values, [0] * alen) na = numarray(*[c_int()] * alen) values = [na[i] for i in range(alen)] - self.failUnlessEqual(values, [0]*alen) + self.assertEqual(values, [0]*alen) na = numarray(1, 2, 3, 4, 5) values = [i for i in na] - self.failUnlessEqual(values, [1, 2, 3, 4, 5]) + self.assertEqual(values, [1, 2, 3, 4, 5]) na = numarray(*map(c_int, (1, 2, 3, 4, 5))) values = [i for i in na] - self.failUnlessEqual(values, [1, 2, 3, 4, 5]) + self.assertEqual(values, [1, 2, 3, 4, 5]) def test_classcache(self): - self.failUnless(not ARRAY(c_int, 3) is ARRAY(c_int, 4)) - self.failUnless(ARRAY(c_int, 3) is ARRAY(c_int, 3)) + self.assertTrue(not ARRAY(c_int, 3) is ARRAY(c_int, 4)) + self.assertTrue(ARRAY(c_int, 3) is ARRAY(c_int, 3)) def test_from_address(self): # Failed with 0.9.8, reported by JUrner p = create_string_buffer("foo") sz = (c_char * 3).from_address(addressof(p)) - self.failUnlessEqual(sz[:], b"foo") - self.failUnlessEqual(sz[::], b"foo") - self.failUnlessEqual(sz[::-1], b"oof") - self.failUnlessEqual(sz[::3], b"f") - self.failUnlessEqual(sz[1:4:2], b"o") - self.failUnlessEqual(sz.value, b"foo") + self.assertEqual(sz[:], b"foo") + self.assertEqual(sz[::], b"foo") + self.assertEqual(sz[::-1], b"oof") + self.assertEqual(sz[::3], b"f") + self.assertEqual(sz[1:4:2], b"o") + self.assertEqual(sz.value, b"foo") try: create_unicode_buffer @@ -106,12 +106,12 @@ class ArrayTestCase(unittest.TestCase): def test_from_addressW(self): p = create_unicode_buffer("foo") sz = (c_wchar * 3).from_address(addressof(p)) - self.failUnlessEqual(sz[:], "foo") - self.failUnlessEqual(sz[::], "foo") - self.failUnlessEqual(sz[::-1], "oof") - self.failUnlessEqual(sz[::3], "f") - self.failUnlessEqual(sz[1:4:2], "o") - self.failUnlessEqual(sz.value, "foo") + self.assertEqual(sz[:], "foo") + self.assertEqual(sz[::], "foo") + self.assertEqual(sz[::-1], "oof") + self.assertEqual(sz[::3], "f") + self.assertEqual(sz[1:4:2], "o") + self.assertEqual(sz.value, "foo") def test_cache(self): # Array types are cached internally in the _ctypes extension, @@ -125,7 +125,7 @@ class ArrayTestCase(unittest.TestCase): # Create a new array type based on it: t1 = my_int * 1 t2 = my_int * 1 - self.failUnless(t1 is t2) + self.assertTrue(t1 is t2) if __name__ == '__main__': unittest.main() diff --git a/Lib/ctypes/test/test_as_parameter.py b/Lib/ctypes/test/test_as_parameter.py index 884361c..835398f 100644 --- a/Lib/ctypes/test/test_as_parameter.py +++ b/Lib/ctypes/test/test_as_parameter.py @@ -25,8 +25,8 @@ class BasicWrapTestCase(unittest.TestCase): f = dll._testfunc_i_bhilfd f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double] result = f(self.wrap(1), self.wrap("x"), self.wrap(3), self.wrap(4), self.wrap(5.0), self.wrap(6.0)) - self.failUnlessEqual(result, 139) - self.failUnless(type(result), int) + self.assertEqual(result, 139) + self.assertTrue(type(result), int) def test_pointers(self): f = dll._testfunc_p_p @@ -39,18 +39,18 @@ class BasicWrapTestCase(unittest.TestCase): v = c_int(42) - self.failUnlessEqual(pointer(v).contents.value, 42) + self.assertEqual(pointer(v).contents.value, 42) result = f(self.wrap(pointer(v))) - self.failUnlessEqual(type(result), POINTER(c_int)) - self.failUnlessEqual(result.contents.value, 42) + self.assertEqual(type(result), POINTER(c_int)) + self.assertEqual(result.contents.value, 42) # This on works... result = f(self.wrap(pointer(v))) - self.failUnlessEqual(result.contents.value, v.value) + self.assertEqual(result.contents.value, v.value) p = pointer(c_int(99)) result = f(self.wrap(p)) - self.failUnlessEqual(result.contents.value, 99) + self.assertEqual(result.contents.value, 99) def test_shorts(self): f = dll._testfunc_callback_i_if @@ -67,7 +67,7 @@ class BasicWrapTestCase(unittest.TestCase): cb = CallBack(callback) f(self.wrap(2**18), self.wrap(cb)) - self.failUnlessEqual(args, expected) + self.assertEqual(args, expected) ################################################################ @@ -84,17 +84,17 @@ class BasicWrapTestCase(unittest.TestCase): cb = MyCallback(callback) result = f(self.wrap(-10), self.wrap(cb)) - self.failUnlessEqual(result, -18) + self.assertEqual(result, -18) # test with prototype f.argtypes = [c_int, MyCallback] cb = MyCallback(callback) result = f(self.wrap(-10), self.wrap(cb)) - self.failUnlessEqual(result, -18) + self.assertEqual(result, -18) result = f(self.wrap(-10), self.wrap(cb)) - self.failUnlessEqual(result, -18) + self.assertEqual(result, -18) AnotherCallback = CALLBACK_FUNCTYPE(c_int, c_int, c_int, c_int, c_int) @@ -116,12 +116,12 @@ class BasicWrapTestCase(unittest.TestCase): def callback(value): #print "called back with", value - self.failUnlessEqual(type(value), int) + self.assertEqual(type(value), int) return value cb = MyCallback(callback) result = f(self.wrap(-10), self.wrap(cb)) - self.failUnlessEqual(result, -18) + self.assertEqual(result, -18) def test_longlong_callbacks(self): @@ -133,12 +133,12 @@ class BasicWrapTestCase(unittest.TestCase): f.argtypes = [c_longlong, MyCallback] def callback(value): - self.failUnless(isinstance(value, int)) + self.assertTrue(isinstance(value, int)) return value & 0x7FFFFFFF cb = MyCallback(callback) - self.failUnlessEqual(13577625587, int(f(self.wrap(1000000000000), self.wrap(cb)))) + self.assertEqual(13577625587, int(f(self.wrap(1000000000000), self.wrap(cb)))) def test_byval(self): # without prototype @@ -148,7 +148,7 @@ class BasicWrapTestCase(unittest.TestCase): result = dll._testfunc_byval(ptin, byref(ptout)) got = result, ptout.x, ptout.y expected = 3, 1, 2 - self.failUnlessEqual(got, expected) + self.assertEqual(got, expected) # with prototype ptin = POINT(101, 102) @@ -158,7 +158,7 @@ class BasicWrapTestCase(unittest.TestCase): result = dll._testfunc_byval(self.wrap(ptin), byref(ptout)) got = result, ptout.x, ptout.y expected = 203, 101, 102 - self.failUnlessEqual(got, expected) + self.assertEqual(got, expected) def test_struct_return_2H(self): class S2H(Structure): @@ -168,7 +168,7 @@ class BasicWrapTestCase(unittest.TestCase): dll.ret_2h_func.argtypes = [S2H] inp = S2H(99, 88) s2h = dll.ret_2h_func(self.wrap(inp)) - self.failUnlessEqual((s2h.x, s2h.y), (99*2, 88*3)) + self.assertEqual((s2h.x, s2h.y), (99*2, 88*3)) def test_struct_return_8H(self): class S8I(Structure): @@ -184,7 +184,7 @@ class BasicWrapTestCase(unittest.TestCase): dll.ret_8i_func.argtypes = [S8I] inp = S8I(9, 8, 7, 6, 5, 4, 3, 2) s8i = dll.ret_8i_func(self.wrap(inp)) - self.failUnlessEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h), + self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h), (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9)) #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/Lib/ctypes/test/test_bitfields.py b/Lib/ctypes/test/test_bitfields.py index de1c619..4eb9571 100644 --- a/Lib/ctypes/test/test_bitfields.py +++ b/Lib/ctypes/test/test_bitfields.py @@ -37,14 +37,14 @@ class C_Test(unittest.TestCase): for name in "ABCDEFGHI": b = BITS() setattr(b, name, i) - self.failUnlessEqual((name, i, getattr(b, name)), (name, i, func(byref(b), name))) + self.assertEqual((name, i, getattr(b, name)), (name, i, func(byref(b), name))) def test_shorts(self): for i in range(256): for name in "MNOPQRS": b = BITS() setattr(b, name, i) - self.failUnlessEqual((name, i, getattr(b, name)), (name, i, func(byref(b), name))) + self.assertEqual((name, i, getattr(b, name)), (name, i, func(byref(b), name))) signed_int_types = (c_byte, c_short, c_int, c_long, c_longlong) unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong) @@ -58,10 +58,10 @@ class BitFieldTest(unittest.TestCase): ("b", c_longlong, 62), ("c", c_longlong, 1)] - self.failUnlessEqual(sizeof(X), sizeof(c_longlong)) + self.assertEqual(sizeof(X), sizeof(c_longlong)) x = X() x.a, x.b, x.c = -1, 7, -1 - self.failUnlessEqual((x.a, x.b, x.c), (-1, 7, -1)) + self.assertEqual((x.a, x.b, x.c), (-1, 7, -1)) def test_ulonglong(self): class X(Structure): @@ -69,11 +69,11 @@ class BitFieldTest(unittest.TestCase): ("b", c_ulonglong, 62), ("c", c_ulonglong, 1)] - self.failUnlessEqual(sizeof(X), sizeof(c_longlong)) + self.assertEqual(sizeof(X), sizeof(c_longlong)) x = X() - self.failUnlessEqual((x.a, x.b, x.c), (0, 0, 0)) + self.assertEqual((x.a, x.b, x.c), (0, 0, 0)) x.a, x.b, x.c = 7, 7, 7 - self.failUnlessEqual((x.a, x.b, x.c), (1, 7, 1)) + self.assertEqual((x.a, x.b, x.c), (1, 7, 1)) def test_signed(self): for c_typ in signed_int_types: @@ -82,14 +82,14 @@ class BitFieldTest(unittest.TestCase): ("a", c_typ, 3), ("b", c_typ, 3), ("c", c_typ, 1)] - self.failUnlessEqual(sizeof(X), sizeof(c_typ)*2) + self.assertEqual(sizeof(X), sizeof(c_typ)*2) x = X() - self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0)) + self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0)) x.a = -1 - self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, -1, 0, 0)) + self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, -1, 0, 0)) x.a, x.b = 0, -1 - self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, -1, 0)) + self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, -1, 0)) def test_unsigned(self): @@ -98,14 +98,14 @@ class BitFieldTest(unittest.TestCase): _fields_ = [("a", c_typ, 3), ("b", c_typ, 3), ("c", c_typ, 1)] - self.failUnlessEqual(sizeof(X), sizeof(c_typ)) + self.assertEqual(sizeof(X), sizeof(c_typ)) x = X() - self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0)) + self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0)) x.a = -1 - self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, 7, 0, 0)) + self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 7, 0, 0)) x.a, x.b = 0, -1 - self.failUnlessEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 7, 0)) + self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 7, 0)) def fail_fields(self, *fields): @@ -115,17 +115,17 @@ class BitFieldTest(unittest.TestCase): def test_nonint_types(self): # bit fields are not allowed on non-integer types. result = self.fail_fields(("a", c_char_p, 1)) - self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type c_char_p')) + self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char_p')) result = self.fail_fields(("a", c_void_p, 1)) - self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type c_void_p')) + self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_void_p')) if c_int != c_long: result = self.fail_fields(("a", POINTER(c_int), 1)) - self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type LP_c_int')) + self.assertEqual(result, (TypeError, 'bit fields not allowed for type LP_c_int')) result = self.fail_fields(("a", c_char, 1)) - self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type c_char')) + self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char')) try: c_wchar @@ -133,59 +133,59 @@ class BitFieldTest(unittest.TestCase): pass else: result = self.fail_fields(("a", c_wchar, 1)) - self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type c_wchar')) + self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_wchar')) class Dummy(Structure): _fields_ = [] result = self.fail_fields(("a", Dummy, 1)) - self.failUnlessEqual(result, (TypeError, 'bit fields not allowed for type Dummy')) + self.assertEqual(result, (TypeError, 'bit fields not allowed for type Dummy')) def test_single_bitfield_size(self): for c_typ in int_types: result = self.fail_fields(("a", c_typ, -1)) - self.failUnlessEqual(result, (ValueError, 'number of bits invalid for bit field')) + self.assertEqual(result, (ValueError, 'number of bits invalid for bit field')) result = self.fail_fields(("a", c_typ, 0)) - self.failUnlessEqual(result, (ValueError, 'number of bits invalid for bit field')) + self.assertEqual(result, (ValueError, 'number of bits invalid for bit field')) class X(Structure): _fields_ = [("a", c_typ, 1)] - self.failUnlessEqual(sizeof(X), sizeof(c_typ)) + self.assertEqual(sizeof(X), sizeof(c_typ)) class X(Structure): _fields_ = [("a", c_typ, sizeof(c_typ)*8)] - self.failUnlessEqual(sizeof(X), sizeof(c_typ)) + self.assertEqual(sizeof(X), sizeof(c_typ)) result = self.fail_fields(("a", c_typ, sizeof(c_typ)*8 + 1)) - self.failUnlessEqual(result, (ValueError, 'number of bits invalid for bit field')) + self.assertEqual(result, (ValueError, 'number of bits invalid for bit field')) def test_multi_bitfields_size(self): class X(Structure): _fields_ = [("a", c_short, 1), ("b", c_short, 14), ("c", c_short, 1)] - self.failUnlessEqual(sizeof(X), sizeof(c_short)) + self.assertEqual(sizeof(X), sizeof(c_short)) class X(Structure): _fields_ = [("a", c_short, 1), ("a1", c_short), ("b", c_short, 14), ("c", c_short, 1)] - self.failUnlessEqual(sizeof(X), sizeof(c_short)*3) - self.failUnlessEqual(X.a.offset, 0) - self.failUnlessEqual(X.a1.offset, sizeof(c_short)) - self.failUnlessEqual(X.b.offset, sizeof(c_short)*2) - self.failUnlessEqual(X.c.offset, sizeof(c_short)*2) + self.assertEqual(sizeof(X), sizeof(c_short)*3) + self.assertEqual(X.a.offset, 0) + self.assertEqual(X.a1.offset, sizeof(c_short)) + self.assertEqual(X.b.offset, sizeof(c_short)*2) + self.assertEqual(X.c.offset, sizeof(c_short)*2) class X(Structure): _fields_ = [("a", c_short, 3), ("b", c_short, 14), ("c", c_short, 14)] - self.failUnlessEqual(sizeof(X), sizeof(c_short)*3) - self.failUnlessEqual(X.a.offset, sizeof(c_short)*0) - self.failUnlessEqual(X.b.offset, sizeof(c_short)*1) - self.failUnlessEqual(X.c.offset, sizeof(c_short)*2) + self.assertEqual(sizeof(X), sizeof(c_short)*3) + self.assertEqual(X.a.offset, sizeof(c_short)*0) + self.assertEqual(X.b.offset, sizeof(c_short)*1) + self.assertEqual(X.c.offset, sizeof(c_short)*2) def get_except(self, func, *args, **kw): @@ -199,21 +199,21 @@ class BitFieldTest(unittest.TestCase): _fields_ = [("a", c_byte, 4), ("b", c_int, 4)] if os.name in ("nt", "ce"): - self.failUnlessEqual(sizeof(X), sizeof(c_int)*2) + self.assertEqual(sizeof(X), sizeof(c_int)*2) else: - self.failUnlessEqual(sizeof(X), sizeof(c_int)) + self.assertEqual(sizeof(X), sizeof(c_int)) def test_mixed_2(self): class X(Structure): _fields_ = [("a", c_byte, 4), ("b", c_int, 32)] - self.failUnlessEqual(sizeof(X), sizeof(c_int)*2) + self.assertEqual(sizeof(X), sizeof(c_int)*2) def test_mixed_3(self): class X(Structure): _fields_ = [("a", c_byte, 4), ("b", c_ubyte, 4)] - self.failUnlessEqual(sizeof(X), sizeof(c_byte)) + self.assertEqual(sizeof(X), sizeof(c_byte)) def test_mixed_4(self): class X(Structure): @@ -227,9 +227,9 @@ class BitFieldTest(unittest.TestCase): # does (unless GCC is run with '-mms-bitfields' which # produces code compatible with MSVC). if os.name in ("nt", "ce"): - self.failUnlessEqual(sizeof(X), sizeof(c_int) * 4) + self.assertEqual(sizeof(X), sizeof(c_int) * 4) else: - self.failUnlessEqual(sizeof(X), sizeof(c_int) * 2) + self.assertEqual(sizeof(X), sizeof(c_int) * 2) def test_anon_bitfields(self): # anonymous bit-fields gave a strange error message diff --git a/Lib/ctypes/test/test_buffers.py b/Lib/ctypes/test/test_buffers.py index 1f4091e..3f8a587 100644 --- a/Lib/ctypes/test/test_buffers.py +++ b/Lib/ctypes/test/test_buffers.py @@ -5,32 +5,32 @@ class StringBufferTestCase(unittest.TestCase): def test_buffer(self): b = create_string_buffer(32) - self.failUnlessEqual(len(b), 32) - self.failUnlessEqual(sizeof(b), 32 * sizeof(c_char)) - self.failUnless(type(b[0]) is bytes) + self.assertEqual(len(b), 32) + self.assertEqual(sizeof(b), 32 * sizeof(c_char)) + self.assertTrue(type(b[0]) is bytes) b = create_string_buffer("abc") - self.failUnlessEqual(len(b), 4) # trailing nul char - self.failUnlessEqual(sizeof(b), 4 * sizeof(c_char)) - self.failUnless(type(b[0]) is bytes) - self.failUnlessEqual(b[0], b"a") - self.failUnlessEqual(b[:], b"abc\0") - self.failUnlessEqual(b[::], b"abc\0") - self.failUnlessEqual(b[::-1], b"\0cba") - self.failUnlessEqual(b[::2], b"ac") - self.failUnlessEqual(b[::5], b"a") + self.assertEqual(len(b), 4) # trailing nul char + self.assertEqual(sizeof(b), 4 * sizeof(c_char)) + self.assertTrue(type(b[0]) is bytes) + self.assertEqual(b[0], b"a") + self.assertEqual(b[:], b"abc\0") + self.assertEqual(b[::], b"abc\0") + self.assertEqual(b[::-1], b"\0cba") + self.assertEqual(b[::2], b"ac") + self.assertEqual(b[::5], b"a") def test_string_conversion(self): b = create_string_buffer("abc") - self.failUnlessEqual(len(b), 4) # trailing nul char - self.failUnlessEqual(sizeof(b), 4 * sizeof(c_char)) - self.failUnless(type(b[0]) is bytes) - self.failUnlessEqual(b[0], b"a") - self.failUnlessEqual(b[:], b"abc\0") - self.failUnlessEqual(b[::], b"abc\0") - self.failUnlessEqual(b[::-1], b"\0cba") - self.failUnlessEqual(b[::2], b"ac") - self.failUnlessEqual(b[::5], b"a") + self.assertEqual(len(b), 4) # trailing nul char + self.assertEqual(sizeof(b), 4 * sizeof(c_char)) + self.assertTrue(type(b[0]) is bytes) + self.assertEqual(b[0], b"a") + self.assertEqual(b[:], b"abc\0") + self.assertEqual(b[::], b"abc\0") + self.assertEqual(b[::-1], b"\0cba") + self.assertEqual(b[::2], b"ac") + self.assertEqual(b[::5], b"a") try: c_wchar @@ -39,32 +39,32 @@ class StringBufferTestCase(unittest.TestCase): else: def test_unicode_buffer(self): b = create_unicode_buffer(32) - self.failUnlessEqual(len(b), 32) - self.failUnlessEqual(sizeof(b), 32 * sizeof(c_wchar)) - self.failUnless(type(b[0]) is str) + self.assertEqual(len(b), 32) + self.assertEqual(sizeof(b), 32 * sizeof(c_wchar)) + self.assertTrue(type(b[0]) is str) b = create_unicode_buffer("abc") - self.failUnlessEqual(len(b), 4) # trailing nul char - self.failUnlessEqual(sizeof(b), 4 * sizeof(c_wchar)) - self.failUnless(type(b[0]) is str) - self.failUnlessEqual(b[0], "a") - self.failUnlessEqual(b[:], "abc\0") - self.failUnlessEqual(b[::], "abc\0") - self.failUnlessEqual(b[::-1], "\0cba") - self.failUnlessEqual(b[::2], "ac") - self.failUnlessEqual(b[::5], "a") + self.assertEqual(len(b), 4) # trailing nul char + self.assertEqual(sizeof(b), 4 * sizeof(c_wchar)) + self.assertTrue(type(b[0]) is str) + self.assertEqual(b[0], "a") + self.assertEqual(b[:], "abc\0") + self.assertEqual(b[::], "abc\0") + self.assertEqual(b[::-1], "\0cba") + self.assertEqual(b[::2], "ac") + self.assertEqual(b[::5], "a") def test_unicode_conversion(self): b = create_unicode_buffer("abc") - self.failUnlessEqual(len(b), 4) # trailing nul char - self.failUnlessEqual(sizeof(b), 4 * sizeof(c_wchar)) - self.failUnless(type(b[0]) is str) - self.failUnlessEqual(b[0], "a") - self.failUnlessEqual(b[:], "abc\0") - self.failUnlessEqual(b[::], "abc\0") - self.failUnlessEqual(b[::-1], "\0cba") - self.failUnlessEqual(b[::2], "ac") - self.failUnlessEqual(b[::5], "a") + self.assertEqual(len(b), 4) # trailing nul char + self.assertEqual(sizeof(b), 4 * sizeof(c_wchar)) + self.assertTrue(type(b[0]) is str) + self.assertEqual(b[0], "a") + self.assertEqual(b[:], "abc\0") + self.assertEqual(b[::], "abc\0") + self.assertEqual(b[::-1], "\0cba") + self.assertEqual(b[::2], "ac") + self.assertEqual(b[::5], "a") if __name__ == "__main__": unittest.main() diff --git a/Lib/ctypes/test/test_byteswap.py b/Lib/ctypes/test/test_byteswap.py index 67fa44b..83cb667 100644 --- a/Lib/ctypes/test/test_byteswap.py +++ b/Lib/ctypes/test/test_byteswap.py @@ -23,131 +23,131 @@ class Test(unittest.TestCase): def test_endian_short(self): if sys.byteorder == "little": - self.failUnless(c_short.__ctype_le__ is c_short) - self.failUnless(c_short.__ctype_be__.__ctype_le__ is c_short) + self.assertTrue(c_short.__ctype_le__ is c_short) + self.assertTrue(c_short.__ctype_be__.__ctype_le__ is c_short) else: - self.failUnless(c_short.__ctype_be__ is c_short) - self.failUnless(c_short.__ctype_le__.__ctype_be__ is c_short) + self.assertTrue(c_short.__ctype_be__ is c_short) + self.assertTrue(c_short.__ctype_le__.__ctype_be__ is c_short) s = c_short.__ctype_be__(0x1234) - self.failUnlessEqual(bin(struct.pack(">h", 0x1234)), "1234") - self.failUnlessEqual(bin(s), "1234") - self.failUnlessEqual(s.value, 0x1234) + self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234") + self.assertEqual(bin(s), "1234") + self.assertEqual(s.value, 0x1234) s = c_short.__ctype_le__(0x1234) - self.failUnlessEqual(bin(struct.pack("h", 0x1234)), "1234") - self.failUnlessEqual(bin(s), "1234") - self.failUnlessEqual(s.value, 0x1234) + self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234") + self.assertEqual(bin(s), "1234") + self.assertEqual(s.value, 0x1234) s = c_ushort.__ctype_le__(0x1234) - self.failUnlessEqual(bin(struct.pack("i", 0x12345678)), "12345678") - self.failUnlessEqual(bin(s), "12345678") - self.failUnlessEqual(s.value, 0x12345678) + self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678") + self.assertEqual(bin(s), "12345678") + self.assertEqual(s.value, 0x12345678) s = c_int.__ctype_le__(0x12345678) - self.failUnlessEqual(bin(struct.pack("I", 0x12345678)), "12345678") - self.failUnlessEqual(bin(s), "12345678") - self.failUnlessEqual(s.value, 0x12345678) + self.assertEqual(bin(struct.pack(">I", 0x12345678)), "12345678") + self.assertEqual(bin(s), "12345678") + self.assertEqual(s.value, 0x12345678) s = c_uint.__ctype_le__(0x12345678) - self.failUnlessEqual(bin(struct.pack("q", 0x1234567890ABCDEF)), "1234567890ABCDEF") - self.failUnlessEqual(bin(s), "1234567890ABCDEF") - self.failUnlessEqual(s.value, 0x1234567890ABCDEF) + self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF") + self.assertEqual(bin(s), "1234567890ABCDEF") + self.assertEqual(s.value, 0x1234567890ABCDEF) s = c_longlong.__ctype_le__(0x1234567890ABCDEF) - self.failUnlessEqual(bin(struct.pack("Q", 0x1234567890ABCDEF)), "1234567890ABCDEF") - self.failUnlessEqual(bin(s), "1234567890ABCDEF") - self.failUnlessEqual(s.value, 0x1234567890ABCDEF) + self.assertEqual(bin(struct.pack(">Q", 0x1234567890ABCDEF)), "1234567890ABCDEF") + self.assertEqual(bin(s), "1234567890ABCDEF") + self.assertEqual(s.value, 0x1234567890ABCDEF) s = c_ulonglong.__ctype_le__(0x1234567890ABCDEF) - self.failUnlessEqual(bin(struct.pack("f", math.pi)), bin(s)) + self.assertAlmostEqual(s.value, math.pi, places=6) + self.assertEqual(bin(struct.pack(">f", math.pi)), bin(s)) def test_endian_double(self): if sys.byteorder == "little": - self.failUnless(c_double.__ctype_le__ is c_double) - self.failUnless(c_double.__ctype_be__.__ctype_le__ is c_double) + self.assertTrue(c_double.__ctype_le__ is c_double) + self.assertTrue(c_double.__ctype_be__.__ctype_le__ is c_double) else: - self.failUnless(c_double.__ctype_be__ is c_double) - self.failUnless(c_double.__ctype_le__.__ctype_be__ is c_double) + self.assertTrue(c_double.__ctype_be__ is c_double) + self.assertTrue(c_double.__ctype_le__.__ctype_be__ is c_double) s = c_double(math.pi) - self.failUnlessEqual(s.value, math.pi) - self.failUnlessEqual(bin(struct.pack("d", math.pi)), bin(s)) + self.assertEqual(s.value, math.pi) + self.assertEqual(bin(struct.pack("d", math.pi)), bin(s)) s = c_double.__ctype_le__(math.pi) - self.failUnlessEqual(s.value, math.pi) - self.failUnlessEqual(bin(struct.pack("d", math.pi)), bin(s)) + self.assertEqual(s.value, math.pi) + self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s)) def test_endian_other(self): - self.failUnless(c_byte.__ctype_le__ is c_byte) - self.failUnless(c_byte.__ctype_be__ is c_byte) + self.assertTrue(c_byte.__ctype_le__ is c_byte) + self.assertTrue(c_byte.__ctype_be__ is c_byte) - self.failUnless(c_ubyte.__ctype_le__ is c_ubyte) - self.failUnless(c_ubyte.__ctype_be__ is c_ubyte) + self.assertTrue(c_ubyte.__ctype_le__ is c_ubyte) + self.assertTrue(c_ubyte.__ctype_be__ is c_ubyte) - self.failUnless(c_char.__ctype_le__ is c_char) - self.failUnless(c_char.__ctype_be__ is c_char) + self.assertTrue(c_char.__ctype_le__ is c_char) + self.assertTrue(c_char.__ctype_be__ is c_char) def test_struct_fields_1(self): if sys.byteorder == "little": @@ -219,7 +219,7 @@ class Test(unittest.TestCase): s1 = S(0x12, 0x1234, 0x12345678, 3.14) s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14) - self.failUnlessEqual(bin(s1), bin(s2)) + self.assertEqual(bin(s1), bin(s2)) def test_unaligned_nonnative_struct_fields(self): if sys.byteorder == "little": @@ -247,7 +247,7 @@ class Test(unittest.TestCase): s1.i = 0x12345678 s1.d = 3.14 s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14) - self.failUnlessEqual(bin(s1), bin(s2)) + self.assertEqual(bin(s1), bin(s2)) def test_unaligned_native_struct_fields(self): if sys.byteorder == "little": @@ -274,7 +274,7 @@ class Test(unittest.TestCase): s1.i = 0x12345678 s1.d = 3.14 s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14) - self.failUnlessEqual(bin(s1), bin(s2)) + self.assertEqual(bin(s1), bin(s2)) if __name__ == "__main__": unittest.main() diff --git a/Lib/ctypes/test/test_callbacks.py b/Lib/ctypes/test/test_callbacks.py index bf580ae..1bef33f 100644 --- a/Lib/ctypes/test/test_callbacks.py +++ b/Lib/ctypes/test/test_callbacks.py @@ -17,18 +17,18 @@ class Callbacks(unittest.TestCase): PROTO = self.functype.__func__(typ, typ) result = PROTO(self.callback)(arg) if typ == c_float: - self.failUnlessAlmostEqual(result, arg, places=5) + self.assertAlmostEqual(result, arg, places=5) else: - self.failUnlessEqual(self.got_args, (arg,)) - self.failUnlessEqual(result, arg) + self.assertEqual(self.got_args, (arg,)) + self.assertEqual(result, arg) PROTO = self.functype.__func__(typ, c_byte, typ) result = PROTO(self.callback)(-3, arg) if typ == c_float: - self.failUnlessAlmostEqual(result, arg, places=5) + self.assertAlmostEqual(result, arg, places=5) else: - self.failUnlessEqual(self.got_args, (-3, arg)) - self.failUnlessEqual(result, arg) + self.assertEqual(self.got_args, (-3, arg)) + self.assertEqual(result, arg) ################ @@ -103,7 +103,7 @@ class Callbacks(unittest.TestCase): # ...but this call doesn't leak any more. Where is the refcount? self.check_type(py_object, o) after = grc(o) - self.failUnlessEqual((after, o), (before, o)) + self.assertEqual((after, o), (before, o)) def test_unsupported_restype_1(self): # Only "fundamental" result types are supported for callback @@ -148,7 +148,7 @@ class SampleCallbacksTestCase(unittest.TestCase): result = integrate(0.0, 1.0, CALLBACK(func), 10) diff = abs(result - 1./3.) - self.failUnless(diff < 0.01, "%s not less than 0.01" % diff) + self.assertTrue(diff < 0.01, "%s not less than 0.01" % diff) ################################################################ diff --git a/Lib/ctypes/test/test_cast.py b/Lib/ctypes/test/test_cast.py index cb7524e..04ed5ca 100644 --- a/Lib/ctypes/test/test_cast.py +++ b/Lib/ctypes/test/test_cast.py @@ -9,15 +9,15 @@ class Test(unittest.TestCase): # casting an array to a pointer works. ptr = cast(array, POINTER(c_int)) - self.failUnlessEqual([ptr[i] for i in range(3)], [42, 17, 2]) + self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2]) if 2*sizeof(c_short) == sizeof(c_int): ptr = cast(array, POINTER(c_short)) if sys.byteorder == "little": - self.failUnlessEqual([ptr[i] for i in range(6)], + self.assertEqual([ptr[i] for i in range(6)], [42, 0, 17, 0, 2, 0]) else: - self.failUnlessEqual([ptr[i] for i in range(6)], + self.assertEqual([ptr[i] for i in range(6)], [0, 42, 0, 17, 0, 2]) def test_address2pointer(self): @@ -25,54 +25,54 @@ class Test(unittest.TestCase): address = addressof(array) ptr = cast(c_void_p(address), POINTER(c_int)) - self.failUnlessEqual([ptr[i] for i in range(3)], [42, 17, 2]) + self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2]) ptr = cast(address, POINTER(c_int)) - self.failUnlessEqual([ptr[i] for i in range(3)], [42, 17, 2]) + self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2]) def test_p2a_objects(self): array = (c_char_p * 5)() - self.failUnlessEqual(array._objects, None) + self.assertEqual(array._objects, None) array[0] = "foo bar" - self.failUnlessEqual(array._objects, {'0': b"foo bar"}) + self.assertEqual(array._objects, {'0': b"foo bar"}) p = cast(array, POINTER(c_char_p)) # array and p share a common _objects attribute - self.failUnless(p._objects is array._objects) - self.failUnlessEqual(array._objects, {'0': b"foo bar", id(array): array}) + self.assertTrue(p._objects is array._objects) + self.assertEqual(array._objects, {'0': b"foo bar", id(array): array}) p[0] = "spam spam" - self.failUnlessEqual(p._objects, {'0': b"spam spam", id(array): array}) - self.failUnless(array._objects is p._objects) + self.assertEqual(p._objects, {'0': b"spam spam", id(array): array}) + self.assertTrue(array._objects is p._objects) p[1] = "foo bar" - self.failUnlessEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array}) - self.failUnless(array._objects is p._objects) + self.assertEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array}) + self.assertTrue(array._objects is p._objects) def test_other(self): p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int)) - self.failUnlessEqual(p[:4], [1,2, 3, 4]) - self.failUnlessEqual(p[:4:], [1, 2, 3, 4]) - self.failUnlessEqual(p[3:-1:-1], [4, 3, 2, 1]) - self.failUnlessEqual(p[:4:3], [1, 4]) + self.assertEqual(p[:4], [1,2, 3, 4]) + self.assertEqual(p[:4:], [1, 2, 3, 4]) + self.assertEqual(p[3:-1:-1], [4, 3, 2, 1]) + self.assertEqual(p[:4:3], [1, 4]) c_int() - self.failUnlessEqual(p[:4], [1, 2, 3, 4]) - self.failUnlessEqual(p[:4:], [1, 2, 3, 4]) - self.failUnlessEqual(p[3:-1:-1], [4, 3, 2, 1]) - self.failUnlessEqual(p[:4:3], [1, 4]) + self.assertEqual(p[:4], [1, 2, 3, 4]) + self.assertEqual(p[:4:], [1, 2, 3, 4]) + self.assertEqual(p[3:-1:-1], [4, 3, 2, 1]) + self.assertEqual(p[:4:3], [1, 4]) p[2] = 96 - self.failUnlessEqual(p[:4], [1, 2, 96, 4]) - self.failUnlessEqual(p[:4:], [1, 2, 96, 4]) - self.failUnlessEqual(p[3:-1:-1], [4, 96, 2, 1]) - self.failUnlessEqual(p[:4:3], [1, 4]) + self.assertEqual(p[:4], [1, 2, 96, 4]) + self.assertEqual(p[:4:], [1, 2, 96, 4]) + self.assertEqual(p[3:-1:-1], [4, 96, 2, 1]) + self.assertEqual(p[:4:3], [1, 4]) c_int() - self.failUnlessEqual(p[:4], [1, 2, 96, 4]) - self.failUnlessEqual(p[:4:], [1, 2, 96, 4]) - self.failUnlessEqual(p[3:-1:-1], [4, 96, 2, 1]) - self.failUnlessEqual(p[:4:3], [1, 4]) + self.assertEqual(p[:4], [1, 2, 96, 4]) + self.assertEqual(p[:4:], [1, 2, 96, 4]) + self.assertEqual(p[3:-1:-1], [4, 96, 2, 1]) + self.assertEqual(p[:4:3], [1, 4]) def test_char_p(self): # This didn't work: bad argument to internal function s = c_char_p("hiho") - self.failUnlessEqual(cast(cast(s, c_void_p), c_char_p).value, + self.assertEqual(cast(cast(s, c_void_p), c_char_p).value, "hiho") try: @@ -82,7 +82,7 @@ class Test(unittest.TestCase): else: def test_wchar_p(self): s = c_wchar_p("hiho") - self.failUnlessEqual(cast(cast(s, c_void_p), c_wchar_p).value, + self.assertEqual(cast(cast(s, c_void_p), c_wchar_p).value, "hiho") if __name__ == "__main__": diff --git a/Lib/ctypes/test/test_cfuncs.py b/Lib/ctypes/test/test_cfuncs.py index 8f97fc4..493cbe9 100644 --- a/Lib/ctypes/test/test_cfuncs.py +++ b/Lib/ctypes/test/test_cfuncs.py @@ -17,176 +17,176 @@ class CFunctions(unittest.TestCase): def test_byte(self): self._dll.tf_b.restype = c_byte self._dll.tf_b.argtypes = (c_byte,) - self.failUnlessEqual(self._dll.tf_b(-126), -42) - self.failUnlessEqual(self.S(), -126) + self.assertEqual(self._dll.tf_b(-126), -42) + self.assertEqual(self.S(), -126) def test_byte_plus(self): self._dll.tf_bb.restype = c_byte self._dll.tf_bb.argtypes = (c_byte, c_byte) - self.failUnlessEqual(self._dll.tf_bb(0, -126), -42) - self.failUnlessEqual(self.S(), -126) + self.assertEqual(self._dll.tf_bb(0, -126), -42) + self.assertEqual(self.S(), -126) def test_ubyte(self): self._dll.tf_B.restype = c_ubyte self._dll.tf_B.argtypes = (c_ubyte,) - self.failUnlessEqual(self._dll.tf_B(255), 85) - self.failUnlessEqual(self.U(), 255) + self.assertEqual(self._dll.tf_B(255), 85) + self.assertEqual(self.U(), 255) def test_ubyte_plus(self): self._dll.tf_bB.restype = c_ubyte self._dll.tf_bB.argtypes = (c_byte, c_ubyte) - self.failUnlessEqual(self._dll.tf_bB(0, 255), 85) - self.failUnlessEqual(self.U(), 255) + self.assertEqual(self._dll.tf_bB(0, 255), 85) + self.assertEqual(self.U(), 255) def test_short(self): self._dll.tf_h.restype = c_short self._dll.tf_h.argtypes = (c_short,) - self.failUnlessEqual(self._dll.tf_h(-32766), -10922) - self.failUnlessEqual(self.S(), -32766) + self.assertEqual(self._dll.tf_h(-32766), -10922) + self.assertEqual(self.S(), -32766) def test_short_plus(self): self._dll.tf_bh.restype = c_short self._dll.tf_bh.argtypes = (c_byte, c_short) - self.failUnlessEqual(self._dll.tf_bh(0, -32766), -10922) - self.failUnlessEqual(self.S(), -32766) + self.assertEqual(self._dll.tf_bh(0, -32766), -10922) + self.assertEqual(self.S(), -32766) def test_ushort(self): self._dll.tf_H.restype = c_ushort self._dll.tf_H.argtypes = (c_ushort,) - self.failUnlessEqual(self._dll.tf_H(65535), 21845) - self.failUnlessEqual(self.U(), 65535) + self.assertEqual(self._dll.tf_H(65535), 21845) + self.assertEqual(self.U(), 65535) def test_ushort_plus(self): self._dll.tf_bH.restype = c_ushort self._dll.tf_bH.argtypes = (c_byte, c_ushort) - self.failUnlessEqual(self._dll.tf_bH(0, 65535), 21845) - self.failUnlessEqual(self.U(), 65535) + self.assertEqual(self._dll.tf_bH(0, 65535), 21845) + self.assertEqual(self.U(), 65535) def test_int(self): self._dll.tf_i.restype = c_int self._dll.tf_i.argtypes = (c_int,) - self.failUnlessEqual(self._dll.tf_i(-2147483646), -715827882) - self.failUnlessEqual(self.S(), -2147483646) + self.assertEqual(self._dll.tf_i(-2147483646), -715827882) + self.assertEqual(self.S(), -2147483646) def test_int_plus(self): self._dll.tf_bi.restype = c_int self._dll.tf_bi.argtypes = (c_byte, c_int) - self.failUnlessEqual(self._dll.tf_bi(0, -2147483646), -715827882) - self.failUnlessEqual(self.S(), -2147483646) + self.assertEqual(self._dll.tf_bi(0, -2147483646), -715827882) + self.assertEqual(self.S(), -2147483646) def test_uint(self): self._dll.tf_I.restype = c_uint self._dll.tf_I.argtypes = (c_uint,) - self.failUnlessEqual(self._dll.tf_I(4294967295), 1431655765) - self.failUnlessEqual(self.U(), 4294967295) + self.assertEqual(self._dll.tf_I(4294967295), 1431655765) + self.assertEqual(self.U(), 4294967295) def test_uint_plus(self): self._dll.tf_bI.restype = c_uint self._dll.tf_bI.argtypes = (c_byte, c_uint) - self.failUnlessEqual(self._dll.tf_bI(0, 4294967295), 1431655765) - self.failUnlessEqual(self.U(), 4294967295) + self.assertEqual(self._dll.tf_bI(0, 4294967295), 1431655765) + self.assertEqual(self.U(), 4294967295) def test_long(self): self._dll.tf_l.restype = c_long self._dll.tf_l.argtypes = (c_long,) - self.failUnlessEqual(self._dll.tf_l(-2147483646), -715827882) - self.failUnlessEqual(self.S(), -2147483646) + self.assertEqual(self._dll.tf_l(-2147483646), -715827882) + self.assertEqual(self.S(), -2147483646) def test_long_plus(self): self._dll.tf_bl.restype = c_long self._dll.tf_bl.argtypes = (c_byte, c_long) - self.failUnlessEqual(self._dll.tf_bl(0, -2147483646), -715827882) - self.failUnlessEqual(self.S(), -2147483646) + self.assertEqual(self._dll.tf_bl(0, -2147483646), -715827882) + self.assertEqual(self.S(), -2147483646) def test_ulong(self): self._dll.tf_L.restype = c_ulong self._dll.tf_L.argtypes = (c_ulong,) - self.failUnlessEqual(self._dll.tf_L(4294967295), 1431655765) - self.failUnlessEqual(self.U(), 4294967295) + self.assertEqual(self._dll.tf_L(4294967295), 1431655765) + self.assertEqual(self.U(), 4294967295) def test_ulong_plus(self): self._dll.tf_bL.restype = c_ulong self._dll.tf_bL.argtypes = (c_char, c_ulong) - self.failUnlessEqual(self._dll.tf_bL(' ', 4294967295), 1431655765) - self.failUnlessEqual(self.U(), 4294967295) + self.assertEqual(self._dll.tf_bL(' ', 4294967295), 1431655765) + self.assertEqual(self.U(), 4294967295) def test_longlong(self): self._dll.tf_q.restype = c_longlong self._dll.tf_q.argtypes = (c_longlong, ) - self.failUnlessEqual(self._dll.tf_q(-9223372036854775806), -3074457345618258602) - self.failUnlessEqual(self.S(), -9223372036854775806) + self.assertEqual(self._dll.tf_q(-9223372036854775806), -3074457345618258602) + self.assertEqual(self.S(), -9223372036854775806) def test_longlong_plus(self): self._dll.tf_bq.restype = c_longlong self._dll.tf_bq.argtypes = (c_byte, c_longlong) - self.failUnlessEqual(self._dll.tf_bq(0, -9223372036854775806), -3074457345618258602) - self.failUnlessEqual(self.S(), -9223372036854775806) + self.assertEqual(self._dll.tf_bq(0, -9223372036854775806), -3074457345618258602) + self.assertEqual(self.S(), -9223372036854775806) def test_ulonglong(self): self._dll.tf_Q.restype = c_ulonglong self._dll.tf_Q.argtypes = (c_ulonglong, ) - self.failUnlessEqual(self._dll.tf_Q(18446744073709551615), 6148914691236517205) - self.failUnlessEqual(self.U(), 18446744073709551615) + self.assertEqual(self._dll.tf_Q(18446744073709551615), 6148914691236517205) + self.assertEqual(self.U(), 18446744073709551615) def test_ulonglong_plus(self): self._dll.tf_bQ.restype = c_ulonglong self._dll.tf_bQ.argtypes = (c_byte, c_ulonglong) - self.failUnlessEqual(self._dll.tf_bQ(0, 18446744073709551615), 6148914691236517205) - self.failUnlessEqual(self.U(), 18446744073709551615) + self.assertEqual(self._dll.tf_bQ(0, 18446744073709551615), 6148914691236517205) + self.assertEqual(self.U(), 18446744073709551615) def test_float(self): self._dll.tf_f.restype = c_float self._dll.tf_f.argtypes = (c_float,) - self.failUnlessEqual(self._dll.tf_f(-42.), -14.) - self.failUnlessEqual(self.S(), -42) + self.assertEqual(self._dll.tf_f(-42.), -14.) + self.assertEqual(self.S(), -42) def test_float_plus(self): self._dll.tf_bf.restype = c_float self._dll.tf_bf.argtypes = (c_byte, c_float) - self.failUnlessEqual(self._dll.tf_bf(0, -42.), -14.) - self.failUnlessEqual(self.S(), -42) + self.assertEqual(self._dll.tf_bf(0, -42.), -14.) + self.assertEqual(self.S(), -42) def test_double(self): self._dll.tf_d.restype = c_double self._dll.tf_d.argtypes = (c_double,) - self.failUnlessEqual(self._dll.tf_d(42.), 14.) - self.failUnlessEqual(self.S(), 42) + self.assertEqual(self._dll.tf_d(42.), 14.) + self.assertEqual(self.S(), 42) def test_double_plus(self): self._dll.tf_bd.restype = c_double self._dll.tf_bd.argtypes = (c_byte, c_double) - self.failUnlessEqual(self._dll.tf_bd(0, 42.), 14.) - self.failUnlessEqual(self.S(), 42) + self.assertEqual(self._dll.tf_bd(0, 42.), 14.) + self.assertEqual(self.S(), 42) def test_longdouble(self): self._dll.tf_D.restype = c_longdouble self._dll.tf_D.argtypes = (c_longdouble,) - self.failUnlessEqual(self._dll.tf_D(42.), 14.) - self.failUnlessEqual(self.S(), 42) + self.assertEqual(self._dll.tf_D(42.), 14.) + self.assertEqual(self.S(), 42) def test_longdouble_plus(self): self._dll.tf_bD.restype = c_longdouble self._dll.tf_bD.argtypes = (c_byte, c_longdouble) - self.failUnlessEqual(self._dll.tf_bD(0, 42.), 14.) - self.failUnlessEqual(self.S(), 42) + self.assertEqual(self._dll.tf_bD(0, 42.), 14.) + self.assertEqual(self.S(), 42) def test_callwithresult(self): def process_result(result): return result * 2 self._dll.tf_i.restype = process_result self._dll.tf_i.argtypes = (c_int,) - self.failUnlessEqual(self._dll.tf_i(42), 28) - self.failUnlessEqual(self.S(), 42) - self.failUnlessEqual(self._dll.tf_i(-42), -28) - self.failUnlessEqual(self.S(), -42) + self.assertEqual(self._dll.tf_i(42), 28) + self.assertEqual(self.S(), 42) + self.assertEqual(self._dll.tf_i(-42), -28) + self.assertEqual(self.S(), -42) def test_void(self): self._dll.tv_i.restype = None self._dll.tv_i.argtypes = (c_int,) - self.failUnlessEqual(self._dll.tv_i(42), None) - self.failUnlessEqual(self.S(), 42) - self.failUnlessEqual(self._dll.tv_i(-42), None) - self.failUnlessEqual(self.S(), -42) + self.assertEqual(self._dll.tv_i(42), None) + self.assertEqual(self.S(), 42) + self.assertEqual(self._dll.tv_i(-42), None) + self.assertEqual(self.S(), -42) # The following repeates the above tests with stdcall functions (where # they are available) diff --git a/Lib/ctypes/test/test_checkretval.py b/Lib/ctypes/test/test_checkretval.py index d15bd2e..01ccc57 100644 --- a/Lib/ctypes/test/test_checkretval.py +++ b/Lib/ctypes/test/test_checkretval.py @@ -14,16 +14,16 @@ class Test(unittest.TestCase): import _ctypes_test dll = CDLL(_ctypes_test.__file__) - self.failUnlessEqual(42, dll._testfunc_p_p(42)) + self.assertEqual(42, dll._testfunc_p_p(42)) dll._testfunc_p_p.restype = CHECKED - self.failUnlessEqual("42", dll._testfunc_p_p(42)) + self.assertEqual("42", dll._testfunc_p_p(42)) dll._testfunc_p_p.restype = None - self.failUnlessEqual(None, dll._testfunc_p_p(42)) + self.assertEqual(None, dll._testfunc_p_p(42)) del dll._testfunc_p_p.restype - self.failUnlessEqual(42, dll._testfunc_p_p(42)) + self.assertEqual(42, dll._testfunc_p_p(42)) try: oledll @@ -31,7 +31,7 @@ class Test(unittest.TestCase): pass else: def test_oledll(self): - self.failUnlessRaises(WindowsError, + self.assertRaises(WindowsError, oledll.oleaut32.CreateTypeLib2, 0, None, None) diff --git a/Lib/ctypes/test/test_errno.py b/Lib/ctypes/test/test_errno.py index b80656b..0254c3b 100644 --- a/Lib/ctypes/test/test_errno.py +++ b/Lib/ctypes/test/test_errno.py @@ -15,11 +15,11 @@ class Test(unittest.TestCase): libc_open.argtypes = c_char_p, c_int - self.failUnlessEqual(libc_open("", 0), -1) - self.failUnlessEqual(get_errno(), errno.ENOENT) + self.assertEqual(libc_open("", 0), -1) + self.assertEqual(get_errno(), errno.ENOENT) - self.failUnlessEqual(set_errno(32), errno.ENOENT) - self.failUnlessEqual(get_errno(), 32) + self.assertEqual(set_errno(32), errno.ENOENT) + self.assertEqual(get_errno(), 32) def _worker(): @@ -31,14 +31,14 @@ class Test(unittest.TestCase): else: libc_open = libc.open libc_open.argtypes = c_char_p, c_int - self.failUnlessEqual(libc_open("", 0), -1) - self.failUnlessEqual(get_errno(), 0) + self.assertEqual(libc_open("", 0), -1) + self.assertEqual(get_errno(), 0) t = threading.Thread(target=_worker) t.start() t.join() - self.failUnlessEqual(get_errno(), 32) + self.assertEqual(get_errno(), 32) set_errno(0) if os.name == "nt": @@ -48,11 +48,11 @@ class Test(unittest.TestCase): GetModuleHandle = dll.GetModuleHandleA GetModuleHandle.argtypes = [c_wchar_p] - self.failUnlessEqual(0, GetModuleHandle("foo")) - self.failUnlessEqual(get_last_error(), 126) + self.assertEqual(0, GetModuleHandle("foo")) + self.assertEqual(get_last_error(), 126) - self.failUnlessEqual(set_last_error(32), 126) - self.failUnlessEqual(get_last_error(), 32) + self.assertEqual(set_last_error(32), 126) + self.assertEqual(get_last_error(), 32) def _worker(): set_last_error(0) @@ -62,13 +62,13 @@ class Test(unittest.TestCase): GetModuleHandle.argtypes = [c_wchar_p] GetModuleHandle("bar") - self.failUnlessEqual(get_last_error(), 0) + self.assertEqual(get_last_error(), 0) t = threading.Thread(target=_worker) t.start() t.join() - self.failUnlessEqual(get_last_error(), 32) + self.assertEqual(get_last_error(), 32) set_last_error(0) diff --git a/Lib/ctypes/test/test_find.py b/Lib/ctypes/test/test_find.py index dc05093..c54b69b 100644 --- a/Lib/ctypes/test/test_find.py +++ b/Lib/ctypes/test/test_find.py @@ -76,7 +76,7 @@ class Test_OpenGL_libs(unittest.TestCase): ## sqrt = libm.sqrt ## sqrt.argtypes = (c_double,) ## sqrt.restype = c_double -## self.failUnlessEqual(sqrt(2), math.sqrt(2)) +## self.assertEqual(sqrt(2), math.sqrt(2)) if __name__ == "__main__": unittest.main() diff --git a/Lib/ctypes/test/test_frombuffer.py b/Lib/ctypes/test/test_frombuffer.py index 23e2dcb..92d6158 100644 --- a/Lib/ctypes/test/test_frombuffer.py +++ b/Lib/ctypes/test/test_frombuffer.py @@ -16,14 +16,14 @@ class Test(unittest.TestCase): y = X.from_buffer(a) self.assertEqual(y.c_int, a[0]) - self.failIf(y.init_called) + self.assertFalse(y.init_called) self.assertEqual(x[:], a.tolist()) a[0], a[-1] = 200, -200 self.assertEqual(x[:], a.tolist()) - self.assert_(a in x._objects.values()) + self.assertTrue(a in x._objects.values()) self.assertRaises(ValueError, c_int.from_buffer, a, -1) @@ -49,7 +49,7 @@ class Test(unittest.TestCase): y = X.from_buffer_copy(a) self.assertEqual(y.c_int, a[0]) - self.failIf(y.init_called) + self.assertFalse(y.init_called) self.assertEqual(x[:], list(range(16))) diff --git a/Lib/ctypes/test/test_funcptr.py b/Lib/ctypes/test/test_funcptr.py index 56099cc..1b29317 100644 --- a/Lib/ctypes/test/test_funcptr.py +++ b/Lib/ctypes/test/test_funcptr.py @@ -18,10 +18,10 @@ class CFuncPtrTestCase(unittest.TestCase): return len(args) x = X(func) - self.failUnlessEqual(x.restype, c_int) - self.failUnlessEqual(x.argtypes, (c_int, c_int)) - self.failUnlessEqual(sizeof(x), sizeof(c_voidp)) - self.failUnlessEqual(sizeof(X), sizeof(c_voidp)) + self.assertEqual(x.restype, c_int) + self.assertEqual(x.argtypes, (c_int, c_int)) + self.assertEqual(sizeof(x), sizeof(c_voidp)) + self.assertEqual(sizeof(X), sizeof(c_voidp)) def test_first(self): StdCallback = WINFUNCTYPE(c_int, c_int, c_int) @@ -33,12 +33,12 @@ class CFuncPtrTestCase(unittest.TestCase): s = StdCallback(func) c = CdeclCallback(func) - self.failUnlessEqual(s(1, 2), 3) - self.failUnlessEqual(c(1, 2), 3) + self.assertEqual(s(1, 2), 3) + self.assertEqual(c(1, 2), 3) # The following no longer raises a TypeError - it is now # possible, as in C, to call cdecl functions with more parameters. #self.assertRaises(TypeError, c, 1, 2, 3) - self.failUnlessEqual(c(1, 2, 3, 4, 5, 6), 3) + self.assertEqual(c(1, 2, 3, 4, 5, 6), 3) if not WINFUNCTYPE is CFUNCTYPE and os.name != "ce": self.assertRaises(TypeError, s, 1, 2, 3) @@ -75,9 +75,9 @@ class CFuncPtrTestCase(unittest.TestCase): ## "lpfnWndProc", WNDPROC_2(wndproc)) # instead: - self.failUnless(WNDPROC is WNDPROC_2) + self.assertTrue(WNDPROC is WNDPROC_2) # 'wndclass.lpfnWndProc' leaks 94 references. Why? - self.failUnlessEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10) + self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10) f = wndclass.lpfnWndProc @@ -85,7 +85,7 @@ class CFuncPtrTestCase(unittest.TestCase): del wndclass del wndproc - self.failUnlessEqual(f(10, 11, 12, 13), 46) + self.assertEqual(f(10, 11, 12, 13), 46) def test_dllfunctions(self): @@ -97,8 +97,8 @@ class CFuncPtrTestCase(unittest.TestCase): strchr = lib.my_strchr strchr.restype = c_char_p strchr.argtypes = (c_char_p, c_char) - self.failUnlessEqual(strchr("abcdefghi", "b"), "bcdefghi") - self.failUnlessEqual(strchr("abcdefghi", "x"), None) + self.assertEqual(strchr("abcdefghi", "b"), "bcdefghi") + self.assertEqual(strchr("abcdefghi", "x"), None) strtok = lib.my_strtok @@ -118,10 +118,10 @@ class CFuncPtrTestCase(unittest.TestCase): ## b.value = s ## b = c_string(s) - self.failUnlessEqual(strtok(b, b"\n"), "a") - self.failUnlessEqual(strtok(None, b"\n"), "b") - self.failUnlessEqual(strtok(None, b"\n"), "c") - self.failUnlessEqual(strtok(None, b"\n"), None) + self.assertEqual(strtok(b, b"\n"), "a") + self.assertEqual(strtok(None, b"\n"), "b") + self.assertEqual(strtok(None, b"\n"), "c") + self.assertEqual(strtok(None, b"\n"), None) if __name__ == '__main__': unittest.main() diff --git a/Lib/ctypes/test/test_functions.py b/Lib/ctypes/test/test_functions.py index 3af11cc..303ce07 100644 --- a/Lib/ctypes/test/test_functions.py +++ b/Lib/ctypes/test/test_functions.py @@ -71,8 +71,8 @@ class FunctionTestCase(unittest.TestCase): f = dll._testfunc_i_bhilfd f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double] result = f(1, "x", 3, 4, 5.0, 6.0) - self.failUnlessEqual(result, 139) - self.failUnlessEqual(type(result), int) + self.assertEqual(result, 139) + self.assertEqual(type(result), int) def test_wchar_result(self): try: @@ -83,38 +83,38 @@ class FunctionTestCase(unittest.TestCase): f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double] f.restype = c_wchar result = f(0, 0, 0, 0, 0, 0) - self.failUnlessEqual(result, '\x00') + self.assertEqual(result, '\x00') def test_voidresult(self): f = dll._testfunc_v f.restype = None f.argtypes = [c_int, c_int, POINTER(c_int)] result = c_int() - self.failUnlessEqual(None, f(1, 2, byref(result))) - self.failUnlessEqual(result.value, 3) + self.assertEqual(None, f(1, 2, byref(result))) + self.assertEqual(result.value, 3) def test_intresult(self): f = dll._testfunc_i_bhilfd f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double] f.restype = c_int result = f(1, 2, 3, 4, 5.0, 6.0) - self.failUnlessEqual(result, 21) - self.failUnlessEqual(type(result), int) + self.assertEqual(result, 21) + self.assertEqual(type(result), int) result = f(-1, -2, -3, -4, -5.0, -6.0) - self.failUnlessEqual(result, -21) - self.failUnlessEqual(type(result), int) + self.assertEqual(result, -21) + self.assertEqual(type(result), int) # If we declare the function to return a short, # is the high part split off? f.restype = c_short result = f(1, 2, 3, 4, 5.0, 6.0) - self.failUnlessEqual(result, 21) - self.failUnlessEqual(type(result), int) + self.assertEqual(result, 21) + self.assertEqual(type(result), int) result = f(1, 2, 3, 0x10004, 5.0, 6.0) - self.failUnlessEqual(result, 21) - self.failUnlessEqual(type(result), int) + self.assertEqual(result, 21) + self.assertEqual(type(result), int) # You cannot assing character format codes as restype any longer self.assertRaises(TypeError, setattr, f, "restype", "i") @@ -124,36 +124,36 @@ class FunctionTestCase(unittest.TestCase): f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double] f.restype = c_float result = f(1, 2, 3, 4, 5.0, 6.0) - self.failUnlessEqual(result, 21) - self.failUnlessEqual(type(result), float) + self.assertEqual(result, 21) + self.assertEqual(type(result), float) result = f(-1, -2, -3, -4, -5.0, -6.0) - self.failUnlessEqual(result, -21) - self.failUnlessEqual(type(result), float) + self.assertEqual(result, -21) + self.assertEqual(type(result), float) def test_doubleresult(self): f = dll._testfunc_d_bhilfd f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double] f.restype = c_double result = f(1, 2, 3, 4, 5.0, 6.0) - self.failUnlessEqual(result, 21) - self.failUnlessEqual(type(result), float) + self.assertEqual(result, 21) + self.assertEqual(type(result), float) result = f(-1, -2, -3, -4, -5.0, -6.0) - self.failUnlessEqual(result, -21) - self.failUnlessEqual(type(result), float) + self.assertEqual(result, -21) + self.assertEqual(type(result), float) def test_longdoubleresult(self): f = dll._testfunc_D_bhilfD f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_longdouble] f.restype = c_longdouble result = f(1, 2, 3, 4, 5.0, 6.0) - self.failUnlessEqual(result, 21) - self.failUnlessEqual(type(result), float) + self.assertEqual(result, 21) + self.assertEqual(type(result), float) result = f(-1, -2, -3, -4, -5.0, -6.0) - self.failUnlessEqual(result, -21) - self.failUnlessEqual(type(result), float) + self.assertEqual(result, -21) + self.assertEqual(type(result), float) def test_longlongresult(self): try: @@ -164,23 +164,23 @@ class FunctionTestCase(unittest.TestCase): f.restype = c_longlong f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double] result = f(1, 2, 3, 4, 5.0, 6.0) - self.failUnlessEqual(result, 21) + self.assertEqual(result, 21) f = dll._testfunc_q_bhilfdq f.restype = c_longlong f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double, c_longlong] result = f(1, 2, 3, 4, 5.0, 6.0, 21) - self.failUnlessEqual(result, 42) + self.assertEqual(result, 42) def test_stringresult(self): f = dll._testfunc_p_p f.argtypes = None f.restype = c_char_p result = f(b"123") - self.failUnlessEqual(result, "123") + self.assertEqual(result, "123") result = f(None) - self.failUnlessEqual(result, None) + self.assertEqual(result, None) def test_pointers(self): f = dll._testfunc_p_p @@ -193,29 +193,29 @@ class FunctionTestCase(unittest.TestCase): v = c_int(42) - self.failUnlessEqual(pointer(v).contents.value, 42) + self.assertEqual(pointer(v).contents.value, 42) result = f(pointer(v)) - self.failUnlessEqual(type(result), POINTER(c_int)) - self.failUnlessEqual(result.contents.value, 42) + self.assertEqual(type(result), POINTER(c_int)) + self.assertEqual(result.contents.value, 42) # This on works... result = f(pointer(v)) - self.failUnlessEqual(result.contents.value, v.value) + self.assertEqual(result.contents.value, v.value) p = pointer(c_int(99)) result = f(p) - self.failUnlessEqual(result.contents.value, 99) + self.assertEqual(result.contents.value, 99) arg = byref(v) result = f(arg) - self.failIfEqual(result.contents, v.value) + self.assertNotEqual(result.contents, v.value) self.assertRaises(ArgumentError, f, byref(c_short(22))) # It is dangerous, however, because you don't control the lifetime # of the pointer: result = f(byref(c_int(99))) - self.failIfEqual(result.contents, 99) + self.assertNotEqual(result.contents, 99) def test_errors(self): f = dll._testfunc_p_p @@ -242,7 +242,7 @@ class FunctionTestCase(unittest.TestCase): cb = CallBack(callback) f(2**18, cb) - self.failUnlessEqual(args, expected) + self.assertEqual(args, expected) ################################################################ @@ -259,13 +259,13 @@ class FunctionTestCase(unittest.TestCase): cb = MyCallback(callback) result = f(-10, cb) - self.failUnlessEqual(result, -18) + self.assertEqual(result, -18) # test with prototype f.argtypes = [c_int, MyCallback] cb = MyCallback(callback) result = f(-10, cb) - self.failUnlessEqual(result, -18) + self.assertEqual(result, -18) AnotherCallback = WINFUNCTYPE(c_int, c_int, c_int, c_int, c_int) @@ -288,12 +288,12 @@ class FunctionTestCase(unittest.TestCase): def callback(value): #print "called back with", value - self.failUnlessEqual(type(value), int) + self.assertEqual(type(value), int) return value cb = MyCallback(callback) result = f(-10, cb) - self.failUnlessEqual(result, -18) + self.assertEqual(result, -18) def test_longlong_callbacks(self): @@ -305,12 +305,12 @@ class FunctionTestCase(unittest.TestCase): f.argtypes = [c_longlong, MyCallback] def callback(value): - self.failUnless(isinstance(value, int)) + self.assertTrue(isinstance(value, int)) return value & 0x7FFFFFFF cb = MyCallback(callback) - self.failUnlessEqual(13577625587, f(1000000000000, cb)) + self.assertEqual(13577625587, f(1000000000000, cb)) def test_errors(self): self.assertRaises(AttributeError, getattr, dll, "_xxx_yyy") @@ -325,7 +325,7 @@ class FunctionTestCase(unittest.TestCase): result = dll._testfunc_byval(ptin, byref(ptout)) got = result, ptout.x, ptout.y expected = 3, 1, 2 - self.failUnlessEqual(got, expected) + self.assertEqual(got, expected) # with prototype ptin = POINT(101, 102) @@ -335,7 +335,7 @@ class FunctionTestCase(unittest.TestCase): result = dll._testfunc_byval(ptin, byref(ptout)) got = result, ptout.x, ptout.y expected = 203, 101, 102 - self.failUnlessEqual(got, expected) + self.assertEqual(got, expected) def test_struct_return_2H(self): class S2H(Structure): @@ -345,7 +345,7 @@ class FunctionTestCase(unittest.TestCase): dll.ret_2h_func.argtypes = [S2H] inp = S2H(99, 88) s2h = dll.ret_2h_func(inp) - self.failUnlessEqual((s2h.x, s2h.y), (99*2, 88*3)) + self.assertEqual((s2h.x, s2h.y), (99*2, 88*3)) if sys.platform == "win32": def test_struct_return_2H_stdcall(self): @@ -356,7 +356,7 @@ class FunctionTestCase(unittest.TestCase): windll.s_ret_2h_func.restype = S2H windll.s_ret_2h_func.argtypes = [S2H] s2h = windll.s_ret_2h_func(S2H(99, 88)) - self.failUnlessEqual((s2h.x, s2h.y), (99*2, 88*3)) + self.assertEqual((s2h.x, s2h.y), (99*2, 88*3)) def test_struct_return_8H(self): class S8I(Structure): @@ -372,7 +372,7 @@ class FunctionTestCase(unittest.TestCase): dll.ret_8i_func.argtypes = [S8I] inp = S8I(9, 8, 7, 6, 5, 4, 3, 2) s8i = dll.ret_8i_func(inp) - self.failUnlessEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h), + self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h), (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9)) if sys.platform == "win32": @@ -390,7 +390,7 @@ class FunctionTestCase(unittest.TestCase): windll.s_ret_8i_func.argtypes = [S8I] inp = S8I(9, 8, 7, 6, 5, 4, 3, 2) s8i = windll.s_ret_8i_func(inp) - self.failUnlessEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h), + self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h), (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9)) def test_sf1651235(self): @@ -401,7 +401,7 @@ class FunctionTestCase(unittest.TestCase): return 0 callback = proto(callback) - self.failUnlessRaises(ArgumentError, lambda: callback((1, 2, 3, 4), POINT())) + self.assertRaises(ArgumentError, lambda: callback((1, 2, 3, 4), POINT())) if __name__ == '__main__': unittest.main() diff --git a/Lib/ctypes/test/test_incomplete.py b/Lib/ctypes/test/test_incomplete.py index af9f504..1e03e9f 100644 --- a/Lib/ctypes/test/test_incomplete.py +++ b/Lib/ctypes/test/test_incomplete.py @@ -30,7 +30,7 @@ class MyTestCase(unittest.TestCase): for i in range(8): result.append(p.name) p = p.next[0] - self.failUnlessEqual(result, ["foo", "bar"] * 4) + self.assertEqual(result, ["foo", "bar"] * 4) # to not leak references, we must clean _pointer_type_cache from ctypes import _pointer_type_cache diff --git a/Lib/ctypes/test/test_init.py b/Lib/ctypes/test/test_init.py index e4dfe36..94928c8 100644 --- a/Lib/ctypes/test/test_init.py +++ b/Lib/ctypes/test/test_init.py @@ -24,17 +24,17 @@ class InitTest(unittest.TestCase): # make sure the only accessing a nested structure # doesn't call the structure's __new__ and __init__ y = Y() - self.failUnlessEqual((y.x.a, y.x.b), (0, 0)) - self.failUnlessEqual(y.x.new_was_called, False) + self.assertEqual((y.x.a, y.x.b), (0, 0)) + self.assertEqual(y.x.new_was_called, False) # But explicitely creating an X structure calls __new__ and __init__, of course. x = X() - self.failUnlessEqual((x.a, x.b), (9, 12)) - self.failUnlessEqual(x.new_was_called, True) + self.assertEqual((x.a, x.b), (9, 12)) + self.assertEqual(x.new_was_called, True) y.x = x - self.failUnlessEqual((y.x.a, y.x.b), (9, 12)) - self.failUnlessEqual(y.x.new_was_called, False) + self.assertEqual((y.x.a, y.x.b), (9, 12)) + self.assertEqual(y.x.new_was_called, False) if __name__ == "__main__": unittest.main() diff --git a/Lib/ctypes/test/test_internals.py b/Lib/ctypes/test/test_internals.py index c6a51a7..f7d9a1b 100644 --- a/Lib/ctypes/test/test_internals.py +++ b/Lib/ctypes/test/test_internals.py @@ -18,22 +18,22 @@ What about pointers? """ class ObjectsTestCase(unittest.TestCase): - def failUnlessSame(self, a, b): - self.failUnlessEqual(id(a), id(b)) + def assertTrueSame(self, a, b): + self.assertEqual(id(a), id(b)) def test_ints(self): i = 42000123 rc = grc(i) ci = c_int(i) - self.failUnlessEqual(rc, grc(i)) - self.failUnlessEqual(ci._objects, None) + self.assertEqual(rc, grc(i)) + self.assertEqual(ci._objects, None) def test_c_char_p(self): s = b"Hello, World" rc = grc(s) cs = c_char_p(s) - self.failUnlessEqual(rc + 1, grc(s)) - self.failUnlessSame(cs._objects, s) + self.assertEqual(rc + 1, grc(s)) + self.assertTrueSame(cs._objects, s) def test_simple_struct(self): class X(Structure): @@ -42,10 +42,10 @@ class ObjectsTestCase(unittest.TestCase): a = 421234 b = 421235 x = X() - self.failUnlessEqual(x._objects, None) + self.assertEqual(x._objects, None) x.a = a x.b = b - self.failUnlessEqual(x._objects, None) + self.assertEqual(x._objects, None) def test_embedded_structs(self): class X(Structure): @@ -55,13 +55,13 @@ class ObjectsTestCase(unittest.TestCase): _fields_ = [("x", X), ("y", X)] y = Y() - self.failUnlessEqual(y._objects, None) + self.assertEqual(y._objects, None) x1, x2 = X(), X() y.x, y.y = x1, x2 - self.failUnlessEqual(y._objects, {"0": {}, "1": {}}) + self.assertEqual(y._objects, {"0": {}, "1": {}}) x1.a, x2.b = 42, 93 - self.failUnlessEqual(y._objects, {"0": {}, "1": {}}) + self.assertEqual(y._objects, {"0": {}, "1": {}}) def test_xxx(self): class X(Structure): @@ -76,12 +76,12 @@ class ObjectsTestCase(unittest.TestCase): x = X() x.a = s1 x.b = s2 - self.failUnlessEqual(x._objects, {"0": bytes(s1, "ascii"), + self.assertEqual(x._objects, {"0": bytes(s1, "ascii"), "1": bytes(s2, "ascii")}) y = Y() y.x = x - self.failUnlessEqual(y._objects, {"0": {"0": bytes(s1, "ascii"), + self.assertEqual(y._objects, {"0": {"0": bytes(s1, "ascii"), "1": bytes(s2, "ascii")}}) ## x = y.x ## del y @@ -93,7 +93,7 @@ class ObjectsTestCase(unittest.TestCase): A = c_int*4 a = A(11, 22, 33, 44) - self.failUnlessEqual(a._objects, None) + self.assertEqual(a._objects, None) x = X() x.data = a diff --git a/Lib/ctypes/test/test_keeprefs.py b/Lib/ctypes/test/test_keeprefs.py index 75e227c..b90765a 100644 --- a/Lib/ctypes/test/test_keeprefs.py +++ b/Lib/ctypes/test/test_keeprefs.py @@ -91,7 +91,7 @@ class PointerTestCase(unittest.TestCase): def test_p_cint(self): i = c_int(42) x = pointer(i) - self.failUnlessEqual(x._objects, {'1': i}) + self.assertEqual(x._objects, {'1': i}) class DeletePointerTestCase(unittest.TestCase): def X_test(self): diff --git a/Lib/ctypes/test/test_libc.py b/Lib/ctypes/test/test_libc.py index fa4c0c9..cce409f 100644 --- a/Lib/ctypes/test/test_libc.py +++ b/Lib/ctypes/test/test_libc.py @@ -13,9 +13,9 @@ class LibTest(unittest.TestCase): def test_sqrt(self): lib.my_sqrt.argtypes = c_double, lib.my_sqrt.restype = c_double - self.failUnlessEqual(lib.my_sqrt(4.0), 2.0) + self.assertEqual(lib.my_sqrt(4.0), 2.0) import math - self.failUnlessEqual(lib.my_sqrt(2.0), math.sqrt(2.0)) + self.assertEqual(lib.my_sqrt(2.0), math.sqrt(2.0)) def test_qsort(self): comparefunc = CFUNCTYPE(c_int, POINTER(c_char), POINTER(c_char)) @@ -27,7 +27,7 @@ class LibTest(unittest.TestCase): chars = create_string_buffer("spam, spam, and spam") lib.my_qsort(chars, len(chars)-1, sizeof(c_char), comparefunc(sort)) - self.failUnlessEqual(chars.raw, b" ,,aaaadmmmnpppsss\x00") + self.assertEqual(chars.raw, b" ,,aaaadmmmnpppsss\x00") if __name__ == "__main__": unittest.main() diff --git a/Lib/ctypes/test/test_loading.py b/Lib/ctypes/test/test_loading.py index b83828a..07b69ec 100644 --- a/Lib/ctypes/test/test_loading.py +++ b/Lib/ctypes/test/test_loading.py @@ -43,7 +43,7 @@ class LoaderTest(unittest.TestCase): if os.name in ("nt", "ce"): def test_load_library(self): - self.failIf(libc_name is None) + self.assertFalse(libc_name is None) if is_resource_enabled("printing"): print(find_library("kernel32")) print(find_library("user32")) @@ -70,9 +70,9 @@ class LoaderTest(unittest.TestCase): a_name = addressof(func_name) f_ord_addr = c_void_p.from_address(a_ord).value f_name_addr = c_void_p.from_address(a_name).value - self.failUnlessEqual(hex(f_ord_addr), hex(f_name_addr)) + self.assertEqual(hex(f_ord_addr), hex(f_name_addr)) - self.failUnlessRaises(AttributeError, dll.__getitem__, 1234) + self.assertRaises(AttributeError, dll.__getitem__, 1234) if os.name == "nt": def test_1703286_A(self): @@ -94,13 +94,13 @@ class LoaderTest(unittest.TestCase): advapi32 = windll.advapi32 # Calling CloseEventLog with a NULL argument should fail, # but the call should not segfault or so. - self.failUnlessEqual(0, advapi32.CloseEventLog(None)) + self.assertEqual(0, advapi32.CloseEventLog(None)) windll.kernel32.GetProcAddress.argtypes = c_void_p, c_char_p windll.kernel32.GetProcAddress.restype = c_void_p proc = windll.kernel32.GetProcAddress(advapi32._handle, "CloseEventLog") - self.failUnless(proc) + self.assertTrue(proc) # This is the real test: call the function via 'call_function' - self.failUnlessEqual(0, call_function(proc, (None,))) + self.assertEqual(0, call_function(proc, (None,))) if __name__ == "__main__": unittest.main() diff --git a/Lib/ctypes/test/test_macholib.py b/Lib/ctypes/test/test_macholib.py index f2ee035..eda846d 100644 --- a/Lib/ctypes/test/test_macholib.py +++ b/Lib/ctypes/test/test_macholib.py @@ -48,14 +48,14 @@ class MachOTest(unittest.TestCase): if sys.platform == "darwin": def test_find(self): - self.failUnlessEqual(find_lib('pthread'), + self.assertEqual(find_lib('pthread'), '/usr/lib/libSystem.B.dylib') result = find_lib('z') - self.failUnless(result.startswith('/usr/lib/libz.1')) - self.failUnless(result.endswith('.dylib')) + self.assertTrue(result.startswith('/usr/lib/libz.1')) + self.assertTrue(result.endswith('.dylib')) - self.failUnlessEqual(find_lib('IOKit'), + self.assertEqual(find_lib('IOKit'), '/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit') if __name__ == "__main__": diff --git a/Lib/ctypes/test/test_memfunctions.py b/Lib/ctypes/test/test_memfunctions.py index 4bee77f..7082b55 100644 --- a/Lib/ctypes/test/test_memfunctions.py +++ b/Lib/ctypes/test/test_memfunctions.py @@ -19,45 +19,45 @@ class MemFunctionsTest(unittest.TestCase): a = create_string_buffer(1000000) p = b"Hello, World" result = memmove(a, p, len(p)) - self.failUnlessEqual(a.value, b"Hello, World") + self.assertEqual(a.value, b"Hello, World") - self.failUnlessEqual(string_at(result), b"Hello, World") - self.failUnlessEqual(string_at(result, 5), b"Hello") - self.failUnlessEqual(string_at(result, 16), b"Hello, World\0\0\0\0") - self.failUnlessEqual(string_at(result, 0), b"") + self.assertEqual(string_at(result), b"Hello, World") + self.assertEqual(string_at(result, 5), b"Hello") + self.assertEqual(string_at(result, 16), b"Hello, World\0\0\0\0") + self.assertEqual(string_at(result, 0), b"") def test_memset(self): a = create_string_buffer(1000000) result = memset(a, ord('x'), 16) - self.failUnlessEqual(a.value, b"xxxxxxxxxxxxxxxx") + self.assertEqual(a.value, b"xxxxxxxxxxxxxxxx") - self.failUnlessEqual(string_at(result), b"xxxxxxxxxxxxxxxx") - self.failUnlessEqual(string_at(a), b"xxxxxxxxxxxxxxxx") - self.failUnlessEqual(string_at(a, 20), b"xxxxxxxxxxxxxxxx\0\0\0\0") + self.assertEqual(string_at(result), b"xxxxxxxxxxxxxxxx") + self.assertEqual(string_at(a), b"xxxxxxxxxxxxxxxx") + self.assertEqual(string_at(a, 20), b"xxxxxxxxxxxxxxxx\0\0\0\0") def test_cast(self): a = (c_ubyte * 32)(*map(ord, "abcdef")) - self.failUnlessEqual(cast(a, c_char_p).value, "abcdef") - self.failUnlessEqual(cast(a, POINTER(c_byte))[:7], + self.assertEqual(cast(a, c_char_p).value, "abcdef") + self.assertEqual(cast(a, POINTER(c_byte))[:7], [97, 98, 99, 100, 101, 102, 0]) - self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:], + self.assertEqual(cast(a, POINTER(c_byte))[:7:], [97, 98, 99, 100, 101, 102, 0]) - self.failUnlessEqual(cast(a, POINTER(c_byte))[6:-1:-1], + self.assertEqual(cast(a, POINTER(c_byte))[6:-1:-1], [0, 102, 101, 100, 99, 98, 97]) - self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:2], + self.assertEqual(cast(a, POINTER(c_byte))[:7:2], [97, 99, 101, 0]) - self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:7], + self.assertEqual(cast(a, POINTER(c_byte))[:7:7], [97]) def test_string_at(self): s = string_at(b"foo bar") # XXX The following may be wrong, depending on how Python # manages string instances - self.failUnlessEqual(2, sys.getrefcount(s)) - self.failUnless(s, "foo bar") + self.assertEqual(2, sys.getrefcount(s)) + self.assertTrue(s, "foo bar") - self.failUnlessEqual(string_at(b"foo bar", 7), b"foo bar") - self.failUnlessEqual(string_at(b"foo bar", 3), b"foo") + self.assertEqual(string_at(b"foo bar", 7), b"foo bar") + self.assertEqual(string_at(b"foo bar", 3), b"foo") try: create_unicode_buffer @@ -68,12 +68,12 @@ class MemFunctionsTest(unittest.TestCase): p = create_unicode_buffer("Hello, World") a = create_unicode_buffer(1000000) result = memmove(a, p, len(p) * sizeof(c_wchar)) - self.failUnlessEqual(a.value, "Hello, World") + self.assertEqual(a.value, "Hello, World") - self.failUnlessEqual(wstring_at(a), "Hello, World") - self.failUnlessEqual(wstring_at(a, 5), "Hello") - self.failUnlessEqual(wstring_at(a, 16), "Hello, World\0\0\0\0") - self.failUnlessEqual(wstring_at(a, 0), "") + self.assertEqual(wstring_at(a), "Hello, World") + self.assertEqual(wstring_at(a, 5), "Hello") + self.assertEqual(wstring_at(a, 16), "Hello, World\0\0\0\0") + self.assertEqual(wstring_at(a, 0), "") if __name__ == "__main__": unittest.main() diff --git a/Lib/ctypes/test/test_numbers.py b/Lib/ctypes/test/test_numbers.py index c0732de..24d7293 100644 --- a/Lib/ctypes/test/test_numbers.py +++ b/Lib/ctypes/test/test_numbers.py @@ -55,25 +55,25 @@ class NumberTestCase(unittest.TestCase): def test_default_init(self): # default values are set to zero for t in signed_types + unsigned_types + float_types: - self.failUnlessEqual(t().value, 0) + self.assertEqual(t().value, 0) def test_unsigned_values(self): # the value given to the constructor is available # as the 'value' attribute for t, (l, h) in zip(unsigned_types, unsigned_ranges): - self.failUnlessEqual(t(l).value, l) - self.failUnlessEqual(t(h).value, h) + self.assertEqual(t(l).value, l) + self.assertEqual(t(h).value, h) def test_signed_values(self): # see above for t, (l, h) in zip(signed_types, signed_ranges): - self.failUnlessEqual(t(l).value, l) - self.failUnlessEqual(t(h).value, h) + self.assertEqual(t(l).value, l) + self.assertEqual(t(h).value, h) def test_bool_values(self): from operator import truth for t, v in zip(bool_types, bool_values): - self.failUnlessEqual(t(v).value, truth(v)) + self.assertEqual(t(v).value, truth(v)) def test_typeerror(self): # Only numbers are allowed in the contructor, @@ -93,13 +93,13 @@ class NumberTestCase(unittest.TestCase): # the from_param class method attribute always # returns PyCArgObject instances for t in signed_types + unsigned_types + float_types: - self.failUnlessEqual(ArgType, type(t.from_param(0))) + self.assertEqual(ArgType, type(t.from_param(0))) def test_byref(self): # calling byref returns also a PyCArgObject instance for t in signed_types + unsigned_types + float_types + bool_types: parm = byref(t()) - self.failUnlessEqual(ArgType, type(parm)) + self.assertEqual(ArgType, type(parm)) def test_floats(self): @@ -110,10 +110,10 @@ class NumberTestCase(unittest.TestCase): return 2.0 f = FloatLike() for t in float_types: - self.failUnlessEqual(t(2.0).value, 2.0) - self.failUnlessEqual(t(2).value, 2.0) - self.failUnlessEqual(t(2).value, 2.0) - self.failUnlessEqual(t(f).value, 2.0) + self.assertEqual(t(2.0).value, 2.0) + self.assertEqual(t(2).value, 2.0) + self.assertEqual(t(2).value, 2.0) + self.assertEqual(t(f).value, 2.0) def test_integers(self): class FloatLike(object): @@ -129,7 +129,7 @@ class NumberTestCase(unittest.TestCase): for t in signed_types + unsigned_types: self.assertRaises(TypeError, t, 3.14) self.assertRaises(TypeError, t, f) - self.failUnlessEqual(t(i).value, 2) + self.assertEqual(t(i).value, 2) def test_sizes(self): for t in signed_types + unsigned_types + float_types + bool_types: @@ -138,9 +138,9 @@ class NumberTestCase(unittest.TestCase): except struct.error: continue # sizeof of the type... - self.failUnlessEqual(sizeof(t), size) + self.assertEqual(sizeof(t), size) # and sizeof of an instance - self.failUnlessEqual(sizeof(t()), size) + self.assertEqual(sizeof(t()), size) def test_alignments(self): for t in signed_types + unsigned_types + float_types: @@ -148,10 +148,10 @@ class NumberTestCase(unittest.TestCase): align = struct.calcsize("c%c" % code) - struct.calcsize(code) # alignment of the type... - self.failUnlessEqual((code, alignment(t)), + self.assertEqual((code, alignment(t)), (code, align)) # and alignment of an instance - self.failUnlessEqual((code, alignment(t())), + self.assertEqual((code, alignment(t())), (code, align)) def test_int_from_address(self): @@ -167,12 +167,12 @@ class NumberTestCase(unittest.TestCase): # v now is an integer at an 'external' memory location v = t.from_address(a.buffer_info()[0]) - self.failUnlessEqual(v.value, a[0]) - self.failUnlessEqual(type(v), t) + self.assertEqual(v.value, a[0]) + self.assertEqual(type(v), t) # changing the value at the memory location changes v's value also a[0] = 42 - self.failUnlessEqual(v.value, a[0]) + self.assertEqual(v.value, a[0]) def test_float_from_address(self): @@ -180,11 +180,11 @@ class NumberTestCase(unittest.TestCase): for t in float_types: a = array(t._type_, [3.14]) v = t.from_address(a.buffer_info()[0]) - self.failUnlessEqual(v.value, a[0]) - self.failUnless(type(v) is t) + self.assertEqual(v.value, a[0]) + self.assertTrue(type(v) is t) a[0] = 2.3456e17 - self.failUnlessEqual(v.value, a[0]) - self.failUnless(type(v) is t) + self.assertEqual(v.value, a[0]) + self.assertTrue(type(v) is t) def test_char_from_address(self): from ctypes import c_char @@ -193,11 +193,11 @@ class NumberTestCase(unittest.TestCase): a = array('b', [0]) a[0] = ord('x') v = c_char.from_address(a.buffer_info()[0]) - self.failUnlessEqual(v.value, b'x') - self.failUnless(type(v) is c_char) + self.assertEqual(v.value, b'x') + self.assertTrue(type(v) is c_char) a[0] = ord('?') - self.failUnlessEqual(v.value, b'?') + self.assertEqual(v.value, b'?') # array does not support c_bool / 't' # def test_bool_from_address(self): @@ -205,11 +205,11 @@ class NumberTestCase(unittest.TestCase): # from array import array # a = array(c_bool._type_, [True]) # v = t.from_address(a.buffer_info()[0]) - # self.failUnlessEqual(v.value, a[0]) - # self.failUnlessEqual(type(v) is t) + # self.assertEqual(v.value, a[0]) + # self.assertEqual(type(v) is t) # a[0] = False - # self.failUnlessEqual(v.value, a[0]) - # self.failUnlessEqual(type(v) is t) + # self.assertEqual(v.value, a[0]) + # self.assertEqual(type(v) is t) def test_init(self): # c_int() can be initialized from Python's int, and c_int. diff --git a/Lib/ctypes/test/test_parameters.py b/Lib/ctypes/test/test_parameters.py index 4c80bdf..10eddd4 100644 --- a/Lib/ctypes/test/test_parameters.py +++ b/Lib/ctypes/test/test_parameters.py @@ -33,8 +33,8 @@ class SimpleTypesTestCase(unittest.TestCase): return value * 4 from_param = classmethod(from_param) - self.failUnlessEqual(CVOIDP.from_param("abc"), "abcabc") - self.failUnlessEqual(CCHARP.from_param("abc"), "abcabcabcabc") + self.assertEqual(CVOIDP.from_param("abc"), "abcabc") + self.assertEqual(CCHARP.from_param("abc"), "abcabcabcabc") try: from ctypes import c_wchar_p @@ -46,7 +46,7 @@ class SimpleTypesTestCase(unittest.TestCase): return value * 3 from_param = classmethod(from_param) - self.failUnlessEqual(CWCHARP.from_param("abc"), "abcabcabc") + self.assertEqual(CWCHARP.from_param("abc"), "abcabcabc") # XXX Replace by c_char_p tests def test_cstrings(self): @@ -55,10 +55,10 @@ class SimpleTypesTestCase(unittest.TestCase): # c_char_p.from_param on a Python String packs the string # into a cparam object s = b"123" - self.failUnless(c_char_p.from_param(s)._obj is s) + self.assertTrue(c_char_p.from_param(s)._obj is s) # new in 0.9.1: convert (encode) unicode to ascii - self.failUnlessEqual(c_char_p.from_param("123")._obj, b"123") + self.assertEqual(c_char_p.from_param("123")._obj, b"123") self.assertRaises(UnicodeEncodeError, c_char_p.from_param, "123\377") self.assertRaises(TypeError, c_char_p.from_param, 42) @@ -66,7 +66,7 @@ class SimpleTypesTestCase(unittest.TestCase): # calling c_char_p.from_param with a c_char_p instance # returns the argument itself: a = c_char_p("123") - self.failUnless(c_char_p.from_param(a) is a) + self.assertTrue(c_char_p.from_param(a) is a) def test_cw_strings(self): from ctypes import byref @@ -77,15 +77,15 @@ class SimpleTypesTestCase(unittest.TestCase): return s = "123" if sys.platform == "win32": - self.failUnless(c_wchar_p.from_param(s)._obj is s) + self.assertTrue(c_wchar_p.from_param(s)._obj is s) self.assertRaises(TypeError, c_wchar_p.from_param, 42) # new in 0.9.1: convert (decode) ascii to unicode - self.failUnlessEqual(c_wchar_p.from_param("123")._obj, "123") + self.assertEqual(c_wchar_p.from_param("123")._obj, "123") self.assertRaises(UnicodeDecodeError, c_wchar_p.from_param, b"123\377") pa = c_wchar_p.from_param(c_wchar_p("123")) - self.failUnlessEqual(type(pa), c_wchar_p) + self.assertEqual(type(pa), c_wchar_p) def test_int_pointers(self): from ctypes import c_short, c_uint, c_int, c_long, POINTER, pointer @@ -94,10 +94,10 @@ class SimpleTypesTestCase(unittest.TestCase): ## p = pointer(c_int(42)) ## x = LPINT.from_param(p) x = LPINT.from_param(pointer(c_int(42))) - self.failUnlessEqual(x.contents.value, 42) - self.failUnlessEqual(LPINT(c_int(42)).contents.value, 42) + self.assertEqual(x.contents.value, 42) + self.assertEqual(LPINT(c_int(42)).contents.value, 42) - self.failUnlessEqual(LPINT.from_param(None), 0) + self.assertEqual(LPINT.from_param(None), 0) if c_int != c_long: self.assertRaises(TypeError, LPINT.from_param, pointer(c_long(42))) @@ -133,8 +133,8 @@ class SimpleTypesTestCase(unittest.TestCase): from ctypes import c_short, c_uint, c_int, c_long, POINTER INTARRAY = c_int * 3 ia = INTARRAY() - self.failUnlessEqual(len(ia), 3) - self.failUnlessEqual([ia[i] for i in range(3)], [0, 0, 0]) + self.assertEqual(len(ia), 3) + self.assertEqual([ia[i] for i in range(3)], [0, 0, 0]) # Pointers are only compatible with arrays containing items of # the same type! @@ -161,8 +161,8 @@ class SimpleTypesTestCase(unittest.TestCase): return None func.argtypes = (Adapter(),) - self.failUnlessEqual(func(None), None) - self.failUnlessEqual(func(object()), None) + self.assertEqual(func(None), None) + self.assertEqual(func(object()), None) class Adapter(object): def from_param(cls, obj): @@ -171,7 +171,7 @@ class SimpleTypesTestCase(unittest.TestCase): func.argtypes = (Adapter(),) # don't know how to convert parameter 1 self.assertRaises(ArgumentError, func, object()) - self.failUnlessEqual(func(c_void_p(42)), 42) + self.assertEqual(func(c_void_p(42)), 42) class Adapter(object): def from_param(cls, obj): diff --git a/Lib/ctypes/test/test_pep3118.py b/Lib/ctypes/test/test_pep3118.py index b839ac2..fa6461f 100644 --- a/Lib/ctypes/test/test_pep3118.py +++ b/Lib/ctypes/test/test_pep3118.py @@ -24,23 +24,23 @@ class Test(unittest.TestCase): ob = tp() v = memoryview(ob) try: - self.failUnlessEqual(normalize(v.format), normalize(fmt)) + self.assertEqual(normalize(v.format), normalize(fmt)) if shape is not None: - self.failUnlessEqual(len(v), shape[0]) + self.assertEqual(len(v), shape[0]) else: - self.failUnlessEqual(len(v) * sizeof(itemtp), sizeof(ob)) - self.failUnlessEqual(v.itemsize, sizeof(itemtp)) - self.failUnlessEqual(v.shape, shape) + self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob)) + self.assertEqual(v.itemsize, sizeof(itemtp)) + self.assertEqual(v.shape, shape) # ctypes object always have a non-strided memory block - self.failUnlessEqual(v.strides, None) + self.assertEqual(v.strides, None) # they are always read/write - self.failIf(v.readonly) + self.assertFalse(v.readonly) if v.shape: n = 1 for dim in v.shape: n = n * dim - self.failUnlessEqual(n * v.itemsize, len(v.tobytes())) + self.assertEqual(n * v.itemsize, len(v.tobytes())) except: # so that we can see the failing type print(tp) @@ -51,23 +51,23 @@ class Test(unittest.TestCase): ob = tp() v = memoryview(ob) try: - self.failUnlessEqual(v.format, fmt) + self.assertEqual(v.format, fmt) if shape is not None: - self.failUnlessEqual(len(v), shape[0]) + self.assertEqual(len(v), shape[0]) else: - self.failUnlessEqual(len(v) * sizeof(itemtp), sizeof(ob)) - self.failUnlessEqual(v.itemsize, sizeof(itemtp)) - self.failUnlessEqual(v.shape, shape) + self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob)) + self.assertEqual(v.itemsize, sizeof(itemtp)) + self.assertEqual(v.shape, shape) # ctypes object always have a non-strided memory block - self.failUnlessEqual(v.strides, None) + self.assertEqual(v.strides, None) # they are always read/write - self.failIf(v.readonly) + self.assertFalse(v.readonly) if v.shape: n = 1 for dim in v.shape: n = n * dim - self.failUnlessEqual(n, len(v)) + self.assertEqual(n, len(v)) except: # so that we can see the failing type print(tp) diff --git a/Lib/ctypes/test/test_pickling.py b/Lib/ctypes/test/test_pickling.py index d88f08b..8c91222 100644 --- a/Lib/ctypes/test/test_pickling.py +++ b/Lib/ctypes/test/test_pickling.py @@ -27,8 +27,8 @@ class PickleTest(unittest.TestCase): c_double(3.14), ]: dst = self.loads(self.dumps(src)) - self.failUnlessEqual(src.__dict__, dst.__dict__) - self.failUnlessEqual(memoryview(src).tobytes(), + self.assertEqual(src.__dict__, dst.__dict__) + self.assertEqual(memoryview(src).tobytes(), memoryview(dst).tobytes()) def test_struct(self): @@ -36,17 +36,17 @@ class PickleTest(unittest.TestCase): x = X() x.a = 42 - self.failUnlessEqual(X.init_called, 1) + self.assertEqual(X.init_called, 1) y = self.loads(self.dumps(x)) # loads must NOT call __init__ - self.failUnlessEqual(X.init_called, 1) + self.assertEqual(X.init_called, 1) # ctypes instances are identical when the instance __dict__ # and the memory buffer are identical - self.failUnlessEqual(y.__dict__, x.__dict__) - self.failUnlessEqual(memoryview(y).tobytes(), + self.assertEqual(y.__dict__, x.__dict__) + self.assertEqual(memoryview(y).tobytes(), memoryview(x).tobytes()) def test_unpickable(self): diff --git a/Lib/ctypes/test/test_pointers.py b/Lib/ctypes/test/test_pointers.py index 86429c0..6e61d30 100644 --- a/Lib/ctypes/test/test_pointers.py +++ b/Lib/ctypes/test/test_pointers.py @@ -17,7 +17,7 @@ class PointersTestCase(unittest.TestCase): POINTER(c_ulong)(c_ulong(22)) # Pointer can't set contents: has no _type_ - self.failUnlessRaises(TypeError, A, c_ulong(33)) + self.assertRaises(TypeError, A, c_ulong(33)) def test_pass_pointers(self): dll = CDLL(_ctypes_test.__file__) @@ -27,12 +27,12 @@ class PointersTestCase(unittest.TestCase): i = c_int(12345678) ## func.argtypes = (POINTER(c_int),) address = func(byref(i)) - self.failUnlessEqual(c_int.from_address(address).value, 12345678) + self.assertEqual(c_int.from_address(address).value, 12345678) func.restype = POINTER(c_int) res = func(pointer(i)) - self.failUnlessEqual(res.contents.value, 12345678) - self.failUnlessEqual(res[0], 12345678) + self.assertEqual(res.contents.value, 12345678) + self.assertEqual(res[0], 12345678) def test_change_pointers(self): dll = CDLL(_ctypes_test.__file__) @@ -43,18 +43,18 @@ class PointersTestCase(unittest.TestCase): func.argtypes = (POINTER(c_int),) res = func(pointer(i)) - self.failUnlessEqual(res[0], 87654) - self.failUnlessEqual(res.contents.value, 87654) + self.assertEqual(res[0], 87654) + self.assertEqual(res.contents.value, 87654) # C code: *res = 54345 res[0] = 54345 - self.failUnlessEqual(i.value, 54345) + self.assertEqual(i.value, 54345) # C code: # int x = 12321; # res = &x res.contents = c_int(12321) - self.failUnlessEqual(i.value, 54345) + self.assertEqual(i.value, 54345) def test_callbacks_with_pointers(self): # a function type receiving a pointer @@ -78,7 +78,7 @@ class PointersTestCase(unittest.TestCase): ## i = c_int(42) ## callback(byref(i)) -## self.failUnless(i.value == 84) +## self.assertTrue(i.value == 84) doit(callback) ## print self.result @@ -91,11 +91,11 @@ class PointersTestCase(unittest.TestCase): i = ct(42) p = pointer(i) ## print type(p.contents), ct - self.failUnless(type(p.contents) is ct) + self.assertTrue(type(p.contents) is ct) # p.contents is the same as p[0] ## print p.contents -## self.failUnless(p.contents == 42) -## self.failUnless(p[0] == 42) +## self.assertTrue(p.contents == 42) +## self.assertTrue(p[0] == 42) self.assertRaises(TypeError, delitem, p, 0) @@ -117,9 +117,9 @@ class PointersTestCase(unittest.TestCase): pt = pointer(Table(1, 2, 3)) - self.failUnlessEqual(pt.contents.a, 1) - self.failUnlessEqual(pt.contents.b, 2) - self.failUnlessEqual(pt.contents.c, 3) + self.assertEqual(pt.contents.a, 1) + self.assertEqual(pt.contents.b, 2) + self.assertEqual(pt.contents.c, 3) pt.contents.c = 33 @@ -130,8 +130,8 @@ class PointersTestCase(unittest.TestCase): p = pointer(c_int(42)) # Although a pointer can be indexed, it ha no length self.assertRaises(TypeError, len, p) - self.failUnlessEqual(p[0], 42) - self.failUnlessEqual(p.contents.value, 42) + self.assertEqual(p[0], 42) + self.assertEqual(p.contents.value, 42) def test_charpp(self): """Test that a character pointer-to-pointer is correctly passed""" @@ -156,20 +156,20 @@ class PointersTestCase(unittest.TestCase): pp = pointer(p) q = pointer(y) pp[0] = q # <== - self.failUnlessEqual(p[0], 6) + self.assertEqual(p[0], 6) def test_c_void_p(self): # http://sourceforge.net/tracker/?func=detail&aid=1518190&group_id=5470&atid=105470 if sizeof(c_void_p) == 4: - self.failUnlessEqual(c_void_p(0xFFFFFFFF).value, + self.assertEqual(c_void_p(0xFFFFFFFF).value, c_void_p(-1).value) - self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value, + self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value, c_void_p(-1).value) elif sizeof(c_void_p) == 8: - self.failUnlessEqual(c_void_p(0xFFFFFFFF).value, + self.assertEqual(c_void_p(0xFFFFFFFF).value, 0xFFFFFFFF) - self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value, + self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value, c_void_p(-1).value) - self.failUnlessEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFF).value, + self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFF).value, c_void_p(-1).value) self.assertRaises(TypeError, c_void_p, 3.14) # make sure floats are NOT accepted @@ -177,16 +177,16 @@ class PointersTestCase(unittest.TestCase): def test_pointers_bool(self): # NULL pointers have a boolean False value, non-NULL pointers True. - self.failUnlessEqual(bool(POINTER(c_int)()), False) - self.failUnlessEqual(bool(pointer(c_int())), True) + self.assertEqual(bool(POINTER(c_int)()), False) + self.assertEqual(bool(pointer(c_int())), True) - self.failUnlessEqual(bool(CFUNCTYPE(None)(0)), False) - self.failUnlessEqual(bool(CFUNCTYPE(None)(42)), True) + self.assertEqual(bool(CFUNCTYPE(None)(0)), False) + self.assertEqual(bool(CFUNCTYPE(None)(42)), True) # COM methods are boolean True: if sys.platform == "win32": mth = WINFUNCTYPE(None)(42, "name", (), None) - self.failUnlessEqual(bool(mth), True) + self.assertEqual(bool(mth), True) if __name__ == '__main__': unittest.main() diff --git a/Lib/ctypes/test/test_prototypes.py b/Lib/ctypes/test/test_prototypes.py index e098e7b..9041750 100644 --- a/Lib/ctypes/test/test_prototypes.py +++ b/Lib/ctypes/test/test_prototypes.py @@ -58,23 +58,23 @@ class CharPointersTestCase(unittest.TestCase): try: func() except TypeError as details: - self.failUnlessEqual(str(details), "required argument 'input' missing") + self.assertEqual(str(details), "required argument 'input' missing") else: self.fail("TypeError not raised") - self.failUnlessEqual(func(None), None) - self.failUnlessEqual(func(input=None), None) + self.assertEqual(func(None), None) + self.assertEqual(func(input=None), None) def test_int_pointer_arg(self): func = testdll._testfunc_p_p func.restype = c_long - self.failUnlessEqual(0, func(0)) + self.assertEqual(0, func(0)) ci = c_int(0) func.argtypes = POINTER(c_int), - self.failUnlessEqual(positive_address(addressof(ci)), + self.assertEqual(positive_address(addressof(ci)), positive_address(func(byref(ci)))) func.argtypes = c_char_p, @@ -91,45 +91,45 @@ class CharPointersTestCase(unittest.TestCase): func.restype = c_char_p func.argtypes = POINTER(c_char), - self.failUnlessEqual(None, func(None)) - self.failUnlessEqual("123", func("123")) - self.failUnlessEqual(None, func(c_char_p(None))) - self.failUnlessEqual("123", func(c_char_p("123"))) + self.assertEqual(None, func(None)) + self.assertEqual("123", func("123")) + self.assertEqual(None, func(c_char_p(None))) + self.assertEqual("123", func(c_char_p("123"))) - self.failUnlessEqual("123", func(c_buffer("123"))) + self.assertEqual("123", func(c_buffer("123"))) ca = c_char("a") - self.failUnlessEqual("a", func(pointer(ca))[0]) - self.failUnlessEqual("a", func(byref(ca))[0]) + self.assertEqual("a", func(pointer(ca))[0]) + self.assertEqual("a", func(byref(ca))[0]) def test_c_char_p_arg(self): func = testdll._testfunc_p_p func.restype = c_char_p func.argtypes = c_char_p, - self.failUnlessEqual(None, func(None)) - self.failUnlessEqual("123", func("123")) - self.failUnlessEqual(None, func(c_char_p(None))) - self.failUnlessEqual("123", func(c_char_p("123"))) + self.assertEqual(None, func(None)) + self.assertEqual("123", func("123")) + self.assertEqual(None, func(c_char_p(None))) + self.assertEqual("123", func(c_char_p("123"))) - self.failUnlessEqual("123", func(c_buffer("123"))) + self.assertEqual("123", func(c_buffer("123"))) ca = c_char("a") - self.failUnlessEqual("a", func(pointer(ca))[0]) - self.failUnlessEqual("a", func(byref(ca))[0]) + self.assertEqual("a", func(pointer(ca))[0]) + self.assertEqual("a", func(byref(ca))[0]) def test_c_void_p_arg(self): func = testdll._testfunc_p_p func.restype = c_char_p func.argtypes = c_void_p, - self.failUnlessEqual(None, func(None)) - self.failUnlessEqual("123", func(b"123")) - self.failUnlessEqual("123", func(c_char_p("123"))) - self.failUnlessEqual(None, func(c_char_p(None))) + self.assertEqual(None, func(None)) + self.assertEqual("123", func(b"123")) + self.assertEqual("123", func(c_char_p("123"))) + self.assertEqual(None, func(c_char_p(None))) - self.failUnlessEqual("123", func(c_buffer("123"))) + self.assertEqual("123", func(c_buffer("123"))) ca = c_char("a") - self.failUnlessEqual("a", func(pointer(ca))[0]) - self.failUnlessEqual("a", func(byref(ca))[0]) + self.assertEqual("a", func(pointer(ca))[0]) + self.assertEqual("a", func(byref(ca))[0]) func(byref(c_int())) func(pointer(c_int())) @@ -140,8 +140,8 @@ class CharPointersTestCase(unittest.TestCase): except NameError: pass else: - self.failUnlessEqual(None, func(c_wchar_p(None))) - self.failUnlessEqual("123", func(c_wchar_p("123"))) + self.assertEqual(None, func(c_wchar_p(None))) + self.assertEqual("123", func(c_wchar_p("123"))) def test_instance(self): func = testdll._testfunc_p_p @@ -151,10 +151,10 @@ class CharPointersTestCase(unittest.TestCase): _as_parameter_ = None func.argtypes = c_void_p, - self.failUnlessEqual(None, func(X())) + self.assertEqual(None, func(X())) func.argtypes = None - self.failUnlessEqual(None, func(X())) + self.assertEqual(None, func(X())) try: c_wchar @@ -174,15 +174,15 @@ else: func.restype = c_wchar_p func.argtypes = POINTER(c_wchar), - self.failUnlessEqual(None, func(None)) - self.failUnlessEqual("123", func("123")) - self.failUnlessEqual(None, func(c_wchar_p(None))) - self.failUnlessEqual("123", func(c_wchar_p("123"))) + self.assertEqual(None, func(None)) + self.assertEqual("123", func("123")) + self.assertEqual(None, func(c_wchar_p(None))) + self.assertEqual("123", func(c_wchar_p("123"))) - self.failUnlessEqual("123", func(c_wbuffer("123"))) + self.assertEqual("123", func(c_wbuffer("123"))) ca = c_wchar("a") - self.failUnlessEqual("a", func(pointer(ca))[0]) - self.failUnlessEqual("a", func(byref(ca))[0]) + self.assertEqual("a", func(pointer(ca))[0]) + self.assertEqual("a", func(byref(ca))[0]) def test_c_wchar_p_arg(self): func = testdll._testfunc_p_p @@ -191,16 +191,16 @@ else: c_wchar_p.from_param("123") - self.failUnlessEqual(None, func(None)) - self.failUnlessEqual("123", func("123")) - self.failUnlessEqual(None, func(c_wchar_p(None))) - self.failUnlessEqual("123", func(c_wchar_p("123"))) + self.assertEqual(None, func(None)) + self.assertEqual("123", func("123")) + self.assertEqual(None, func(c_wchar_p(None))) + self.assertEqual("123", func(c_wchar_p("123"))) # XXX Currently, these raise TypeErrors, although they shouldn't: - self.failUnlessEqual("123", func(c_wbuffer("123"))) + self.assertEqual("123", func(c_wbuffer("123"))) ca = c_wchar("a") - self.failUnlessEqual("a", func(pointer(ca))[0]) - self.failUnlessEqual("a", func(byref(ca))[0]) + self.assertEqual("a", func(pointer(ca))[0]) + self.assertEqual("a", func(byref(ca))[0]) class ArrayTest(unittest.TestCase): def test(self): diff --git a/Lib/ctypes/test/test_python_api.py b/Lib/ctypes/test/test_python_api.py index 674f9ab..b74767a 100644 --- a/Lib/ctypes/test/test_python_api.py +++ b/Lib/ctypes/test/test_python_api.py @@ -23,7 +23,7 @@ class PythonAPITestCase(unittest.TestCase): PyBytes_FromStringAndSize.restype = py_object PyBytes_FromStringAndSize.argtypes = c_char_p, c_py_ssize_t - self.failUnlessEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc") + self.assertEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc") def test_PyString_FromString(self): pythonapi.PyBytes_FromString.restype = py_object @@ -32,10 +32,10 @@ class PythonAPITestCase(unittest.TestCase): s = b"abc" refcnt = grc(s) pyob = pythonapi.PyBytes_FromString(s) - self.failUnlessEqual(grc(s), refcnt) - self.failUnlessEqual(s, pyob) + self.assertEqual(grc(s), refcnt) + self.assertEqual(s, pyob) del pyob - self.failUnlessEqual(grc(s), refcnt) + self.assertEqual(grc(s), refcnt) if is_resource_enabled("refcount"): # This test is unreliable, because it is possible that code in @@ -44,28 +44,28 @@ class PythonAPITestCase(unittest.TestCase): def test_PyLong_Long(self): ref42 = grc(42) pythonapi.PyLong_FromLong.restype = py_object - self.failUnlessEqual(pythonapi.PyLong_FromLong(42), 42) + self.assertEqual(pythonapi.PyLong_FromLong(42), 42) - self.failUnlessEqual(grc(42), ref42) + self.assertEqual(grc(42), ref42) pythonapi.PyLong_AsLong.argtypes = (py_object,) pythonapi.PyLong_AsLong.restype = c_long res = pythonapi.PyLong_AsLong(42) - self.failUnlessEqual(grc(res), ref42 + 1) + self.assertEqual(grc(res), ref42 + 1) del res - self.failUnlessEqual(grc(42), ref42) + self.assertEqual(grc(42), ref42) def test_PyObj_FromPtr(self): s = "abc def ghi jkl" ref = grc(s) # id(python-object) is the address pyobj = PyObj_FromPtr(id(s)) - self.failUnless(s is pyobj) + self.assertTrue(s is pyobj) - self.failUnlessEqual(grc(s), ref + 1) + self.assertEqual(grc(s), ref + 1) del pyobj - self.failUnlessEqual(grc(s), ref) + self.assertEqual(grc(s), ref) def test_PyOS_snprintf(self): PyOS_snprintf = pythonapi.PyOS_snprintf @@ -73,18 +73,18 @@ class PythonAPITestCase(unittest.TestCase): buf = c_buffer(256) PyOS_snprintf(buf, sizeof(buf), "Hello from %s", b"ctypes") - self.failUnlessEqual(buf.value, b"Hello from ctypes") + self.assertEqual(buf.value, b"Hello from ctypes") PyOS_snprintf(buf, sizeof(buf), "Hello from %s (%d, %d, %d)", b"ctypes", 1, 2, 3) - self.failUnlessEqual(buf.value, b"Hello from ctypes (1, 2, 3)") + self.assertEqual(buf.value, b"Hello from ctypes (1, 2, 3)") # not enough arguments - self.failUnlessRaises(TypeError, PyOS_snprintf, buf) + self.assertRaises(TypeError, PyOS_snprintf, buf) def test_pyobject_repr(self): - self.failUnlessEqual(repr(py_object()), "py_object()") - self.failUnlessEqual(repr(py_object(42)), "py_object(42)") - self.failUnlessEqual(repr(py_object(object)), "py_object(%r)" % object) + self.assertEqual(repr(py_object()), "py_object()") + self.assertEqual(repr(py_object(42)), "py_object(42)") + self.assertEqual(repr(py_object(object)), "py_object(%r)" % object) if __name__ == "__main__": unittest.main() diff --git a/Lib/ctypes/test/test_random_things.py b/Lib/ctypes/test/test_random_things.py index 6b2c1b1..2520a5e 100644 --- a/Lib/ctypes/test/test_random_things.py +++ b/Lib/ctypes/test/test_random_things.py @@ -20,7 +20,7 @@ if sys.platform == "win32": hdll = windll.kernel32.LoadLibraryA(b"kernel32") funcaddr = windll.kernel32.GetProcAddress(hdll, "GetModuleHandleA") - self.failUnlessEqual(call_function(funcaddr, (None,)), + self.assertEqual(call_function(funcaddr, (None,)), windll.kernel32.GetModuleHandleA(None)) class CallbackTracbackTestCase(unittest.TestCase): @@ -49,25 +49,25 @@ class CallbackTracbackTestCase(unittest.TestCase): def test_ValueError(self): cb = CFUNCTYPE(c_int, c_int)(callback_func) out = self.capture_stderr(cb, 42) - self.failUnlessEqual(out.splitlines()[-1], + self.assertEqual(out.splitlines()[-1], "ValueError: 42") def test_IntegerDivisionError(self): cb = CFUNCTYPE(c_int, c_int)(callback_func) out = self.capture_stderr(cb, 0) - self.failUnlessEqual(out.splitlines()[-1][:19], + self.assertEqual(out.splitlines()[-1][:19], "ZeroDivisionError: ") def test_FloatDivisionError(self): cb = CFUNCTYPE(c_int, c_double)(callback_func) out = self.capture_stderr(cb, 0.0) - self.failUnlessEqual(out.splitlines()[-1][:19], + self.assertEqual(out.splitlines()[-1][:19], "ZeroDivisionError: ") def test_TypeErrorDivisionError(self): cb = CFUNCTYPE(c_int, c_char_p)(callback_func) out = self.capture_stderr(cb, "spam") - self.failUnlessEqual(out.splitlines()[-1], + self.assertEqual(out.splitlines()[-1], "TypeError: " "unsupported operand type(s) for /: 'int' and 'str'") diff --git a/Lib/ctypes/test/test_refcounts.py b/Lib/ctypes/test/test_refcounts.py index 448f292..35a81aa 100644 --- a/Lib/ctypes/test/test_refcounts.py +++ b/Lib/ctypes/test/test_refcounts.py @@ -21,17 +21,17 @@ class RefcountTestCase(unittest.TestCase): #print "called back with", value return value - self.failUnlessEqual(grc(callback), 2) + self.assertEqual(grc(callback), 2) cb = MyCallback(callback) - self.failUnless(grc(callback) > 2) + self.assertTrue(grc(callback) > 2) result = f(-10, cb) - self.failUnlessEqual(result, -18) + self.assertEqual(result, -18) cb = None gc.collect() - self.failUnlessEqual(grc(callback), 2) + self.assertEqual(grc(callback), 2) def test_refcount(self): @@ -39,19 +39,19 @@ class RefcountTestCase(unittest.TestCase): def func(*args): pass # this is the standard refcount for func - self.failUnlessEqual(grc(func), 2) + self.assertEqual(grc(func), 2) # the CFuncPtr instance holds atr least one refcount on func: f = OtherCallback(func) - self.failUnless(grc(func) > 2) + self.assertTrue(grc(func) > 2) # and may release it again del f - self.failUnless(grc(func) >= 2) + self.assertTrue(grc(func) >= 2) # but now it must be gone gc.collect() - self.failUnless(grc(func) == 2) + self.assertTrue(grc(func) == 2) class X(ctypes.Structure): _fields_ = [("a", OtherCallback)] @@ -59,27 +59,27 @@ class RefcountTestCase(unittest.TestCase): x.a = OtherCallback(func) # the CFuncPtr instance holds atr least one refcount on func: - self.failUnless(grc(func) > 2) + self.assertTrue(grc(func) > 2) # and may release it again del x - self.failUnless(grc(func) >= 2) + self.assertTrue(grc(func) >= 2) # and now it must be gone again gc.collect() - self.failUnlessEqual(grc(func), 2) + self.assertEqual(grc(func), 2) f = OtherCallback(func) # the CFuncPtr instance holds atr least one refcount on func: - self.failUnless(grc(func) > 2) + self.assertTrue(grc(func) > 2) # create a cycle f.cycle = f del f gc.collect() - self.failUnlessEqual(grc(func), 2) + self.assertEqual(grc(func), 2) class AnotherLeak(unittest.TestCase): def test_callback(self): @@ -92,7 +92,7 @@ class AnotherLeak(unittest.TestCase): a = sys.getrefcount(ctypes.c_int) f(1, 2) - self.failUnlessEqual(sys.getrefcount(ctypes.c_int), a) + self.assertEqual(sys.getrefcount(ctypes.c_int), a) if __name__ == '__main__': unittest.main() diff --git a/Lib/ctypes/test/test_repr.py b/Lib/ctypes/test/test_repr.py index 3f1e819..9a1e238 100644 --- a/Lib/ctypes/test/test_repr.py +++ b/Lib/ctypes/test/test_repr.py @@ -18,12 +18,12 @@ class ReprTest(unittest.TestCase): def test_numbers(self): for typ in subclasses: base = typ.__bases__[0] - self.failUnless(repr(base(42)).startswith(base.__name__)) - self.failUnlessEqual(": " "expected string, int found") cls, msg = self.get_except(Person, "Someone", ("a", "b", "c")) - self.failUnlessEqual(cls, RuntimeError) + self.assertEqual(cls, RuntimeError) if issubclass(Exception, object): - self.failUnlessEqual(msg, + self.assertEqual(msg, "(Phone) : too many initializers") else: - self.failUnlessEqual(msg, "(Phone) TypeError: too many initializers") + self.assertEqual(msg, "(Phone) TypeError: too many initializers") def get_except(self, func, *args): @@ -331,7 +331,7 @@ class StructureTestCase(unittest.TestCase): ## # same as 'class X(Structure): pass' ## # fails, since we need either a _fields_ or a _abstract_ attribute ## cls, msg = self.get_except(meta, "X", (Structure,), {}) -## self.failUnlessEqual((cls, msg), +## self.assertEqual((cls, msg), ## (AttributeError, "class must define a '_fields_' attribute")) def test_abstract_class(self): @@ -339,15 +339,15 @@ class StructureTestCase(unittest.TestCase): _abstract_ = "something" # try 'X()' cls, msg = self.get_except(eval, "X()", locals()) - self.failUnlessEqual((cls, msg), (TypeError, "abstract class")) + self.assertEqual((cls, msg), (TypeError, "abstract class")) def test_methods(self): ## class X(Structure): ## _fields_ = [] - self.failUnless("in_dll" in dir(type(Structure))) - self.failUnless("from_address" in dir(type(Structure))) - self.failUnless("in_dll" in dir(type(Structure))) + self.assertTrue("in_dll" in dir(type(Structure))) + self.assertTrue("from_address" in dir(type(Structure))) + self.assertTrue("in_dll" in dir(type(Structure))) class PointerMemberTestCase(unittest.TestCase): @@ -360,7 +360,7 @@ class PointerMemberTestCase(unittest.TestCase): # We can assign arrays of the correct type s.array = (c_int * 3)(1, 2, 3) items = [s.array[i] for i in range(3)] - self.failUnlessEqual(items, [1, 2, 3]) + self.assertEqual(items, [1, 2, 3]) # The following are bugs, but are included here because the unittests # also describe the current behaviour. @@ -371,14 +371,14 @@ class PointerMemberTestCase(unittest.TestCase): s.array[0] = 42 items = [s.array[i] for i in range(3)] - self.failUnlessEqual(items, [42, 2, 3]) + self.assertEqual(items, [42, 2, 3]) s.array[0] = 1 ## s.array[1] = 42 items = [s.array[i] for i in range(3)] - self.failUnlessEqual(items, [1, 2, 3]) + self.assertEqual(items, [1, 2, 3]) def test_none_to_pointer_fields(self): class S(Structure): @@ -388,7 +388,7 @@ class PointerMemberTestCase(unittest.TestCase): s = S() s.x = 12345678 s.p = None - self.failUnlessEqual(s.x, 12345678) + self.assertEqual(s.x, 12345678) class TestRecursiveStructure(unittest.TestCase): def test_contains_itself(self): @@ -398,7 +398,7 @@ class TestRecursiveStructure(unittest.TestCase): try: Recursive._fields_ = [("next", Recursive)] except AttributeError as details: - self.failUnless("Structure or union cannot contain itself" in + self.assertTrue("Structure or union cannot contain itself" in str(details)) else: self.fail("Structure or union cannot contain itself") @@ -415,7 +415,7 @@ class TestRecursiveStructure(unittest.TestCase): try: Second._fields_ = [("first", First)] except AttributeError as details: - self.failUnless("_fields_ is final" in + self.assertTrue("_fields_ is final" in str(details)) else: self.fail("AttributeError not raised") diff --git a/Lib/ctypes/test/test_unaligned_structures.py b/Lib/ctypes/test/test_unaligned_structures.py index 89343ba..bcacfc8 100644 --- a/Lib/ctypes/test/test_unaligned_structures.py +++ b/Lib/ctypes/test/test_unaligned_structures.py @@ -28,18 +28,18 @@ class TestStructures(unittest.TestCase): def test_native(self): for typ in structures: ## print typ.value - self.failUnlessEqual(typ.value.offset, 1) + self.assertEqual(typ.value.offset, 1) o = typ() o.value = 4 - self.failUnlessEqual(o.value, 4) + self.assertEqual(o.value, 4) def test_swapped(self): for typ in byteswapped_structures: ## print >> sys.stderr, typ.value - self.failUnlessEqual(typ.value.offset, 1) + self.assertEqual(typ.value.offset, 1) o = typ() o.value = 4 - self.failUnlessEqual(o.value, 4) + self.assertEqual(o.value, 4) if __name__ == '__main__': unittest.main() diff --git a/Lib/ctypes/test/test_unicode.py b/Lib/ctypes/test/test_unicode.py index 0eae59b..7d628f2 100644 --- a/Lib/ctypes/test/test_unicode.py +++ b/Lib/ctypes/test/test_unicode.py @@ -22,55 +22,55 @@ else: def test_ascii_strict(self): ctypes.set_conversion_mode("ascii", "strict") # no conversions take place with unicode arguments - self.failUnlessEqual(wcslen("abc"), 3) - self.failUnlessEqual(wcslen("ab\u2070"), 3) + self.assertEqual(wcslen("abc"), 3) + self.assertEqual(wcslen("ab\u2070"), 3) # string args are converted - self.failUnlessEqual(wcslen("abc"), 3) - self.failUnlessRaises(ctypes.ArgumentError, wcslen, b"ab\xe4") + self.assertEqual(wcslen("abc"), 3) + self.assertRaises(ctypes.ArgumentError, wcslen, b"ab\xe4") def test_ascii_replace(self): ctypes.set_conversion_mode("ascii", "replace") - self.failUnlessEqual(wcslen("abc"), 3) - self.failUnlessEqual(wcslen("ab\u2070"), 3) - self.failUnlessEqual(wcslen("abc"), 3) - self.failUnlessEqual(wcslen("ab\xe4"), 3) + self.assertEqual(wcslen("abc"), 3) + self.assertEqual(wcslen("ab\u2070"), 3) + self.assertEqual(wcslen("abc"), 3) + self.assertEqual(wcslen("ab\xe4"), 3) def test_ascii_ignore(self): ctypes.set_conversion_mode("ascii", "ignore") - self.failUnlessEqual(wcslen("abc"), 3) - self.failUnlessEqual(wcslen("ab\u2070"), 3) + self.assertEqual(wcslen("abc"), 3) + self.assertEqual(wcslen("ab\u2070"), 3) # ignore error mode skips non-ascii characters - self.failUnlessEqual(wcslen("abc"), 3) - self.failUnlessEqual(wcslen(b"\xe4\xf6\xfc\xdf"), 0) + self.assertEqual(wcslen("abc"), 3) + self.assertEqual(wcslen(b"\xe4\xf6\xfc\xdf"), 0) def test_latin1_strict(self): ctypes.set_conversion_mode("latin-1", "strict") - self.failUnlessEqual(wcslen("abc"), 3) - self.failUnlessEqual(wcslen("ab\u2070"), 3) - self.failUnlessEqual(wcslen("abc"), 3) - self.failUnlessEqual(wcslen("\xe4\xf6\xfc\xdf"), 4) + self.assertEqual(wcslen("abc"), 3) + self.assertEqual(wcslen("ab\u2070"), 3) + self.assertEqual(wcslen("abc"), 3) + self.assertEqual(wcslen("\xe4\xf6\xfc\xdf"), 4) def test_buffers(self): ctypes.set_conversion_mode("ascii", "strict") buf = ctypes.create_unicode_buffer("abc") - self.failUnlessEqual(len(buf), 3+1) + self.assertEqual(len(buf), 3+1) ctypes.set_conversion_mode("ascii", "replace") buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc") - self.failUnlessEqual(buf[:], "ab\uFFFD\uFFFD\uFFFD\0") - self.failUnlessEqual(buf[::], "ab\uFFFD\uFFFD\uFFFD\0") - self.failUnlessEqual(buf[::-1], "\0\uFFFD\uFFFD\uFFFDba") - self.failUnlessEqual(buf[::2], "a\uFFFD\uFFFD") - self.failUnlessEqual(buf[6:5:-1], "") + self.assertEqual(buf[:], "ab\uFFFD\uFFFD\uFFFD\0") + self.assertEqual(buf[::], "ab\uFFFD\uFFFD\uFFFD\0") + self.assertEqual(buf[::-1], "\0\uFFFD\uFFFD\uFFFDba") + self.assertEqual(buf[::2], "a\uFFFD\uFFFD") + self.assertEqual(buf[6:5:-1], "") ctypes.set_conversion_mode("ascii", "ignore") buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc") # is that correct? not sure. But with 'ignore', you get what you pay for.. - self.failUnlessEqual(buf[:], "ab\0\0\0\0") - self.failUnlessEqual(buf[::], "ab\0\0\0\0") - self.failUnlessEqual(buf[::-1], "\0\0\0\0ba") - self.failUnlessEqual(buf[::2], "a\0\0") - self.failUnlessEqual(buf[6:5:-1], "") + self.assertEqual(buf[:], "ab\0\0\0\0") + self.assertEqual(buf[::], "ab\0\0\0\0") + self.assertEqual(buf[::-1], "\0\0\0\0ba") + self.assertEqual(buf[::2], "a\0\0") + self.assertEqual(buf[6:5:-1], "") import _ctypes_test func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p @@ -88,41 +88,41 @@ else: def test_ascii_replace(self): ctypes.set_conversion_mode("ascii", "strict") - self.failUnlessEqual(func("abc"), "abc") - self.failUnlessEqual(func("abc"), "abc") + self.assertEqual(func("abc"), "abc") + self.assertEqual(func("abc"), "abc") self.assertRaises(ctypes.ArgumentError, func, "ab\xe4") def test_ascii_ignore(self): ctypes.set_conversion_mode("ascii", "ignore") - self.failUnlessEqual(func("abc"), "abc") - self.failUnlessEqual(func("abc"), "abc") - self.failUnlessEqual(func("\xe4\xf6\xfc\xdf"), "") + self.assertEqual(func("abc"), "abc") + self.assertEqual(func("abc"), "abc") + self.assertEqual(func("\xe4\xf6\xfc\xdf"), "") def test_ascii_replace(self): ctypes.set_conversion_mode("ascii", "replace") - self.failUnlessEqual(func("abc"), "abc") - self.failUnlessEqual(func("abc"), "abc") - self.failUnlessEqual(func("\xe4\xf6\xfc\xdf"), "????") + self.assertEqual(func("abc"), "abc") + self.assertEqual(func("abc"), "abc") + self.assertEqual(func("\xe4\xf6\xfc\xdf"), "????") def test_buffers(self): ctypes.set_conversion_mode("ascii", "strict") buf = ctypes.create_string_buffer("abc") - self.failUnlessEqual(len(buf), 3+1) + self.assertEqual(len(buf), 3+1) ctypes.set_conversion_mode("ascii", "replace") buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc") - self.failUnlessEqual(buf[:], b"ab???\0") - self.failUnlessEqual(buf[::], b"ab???\0") - self.failUnlessEqual(buf[::-1], b"\0???ba") - self.failUnlessEqual(buf[::2], b"a??") - self.failUnlessEqual(buf[6:5:-1], b"") + self.assertEqual(buf[:], b"ab???\0") + self.assertEqual(buf[::], b"ab???\0") + self.assertEqual(buf[::-1], b"\0???ba") + self.assertEqual(buf[::2], b"a??") + self.assertEqual(buf[6:5:-1], b"") ctypes.set_conversion_mode("ascii", "ignore") buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc") # is that correct? not sure. But with 'ignore', you get what you pay for.. - self.failUnlessEqual(buf[:], b"ab\0\0\0\0") - self.failUnlessEqual(buf[::], b"ab\0\0\0\0") - self.failUnlessEqual(buf[::-1], b"\0\0\0\0ba") + self.assertEqual(buf[:], b"ab\0\0\0\0") + self.assertEqual(buf[::], b"ab\0\0\0\0") + self.assertEqual(buf[::-1], b"\0\0\0\0ba") if __name__ == '__main__': unittest.main() diff --git a/Lib/ctypes/test/test_values.py b/Lib/ctypes/test/test_values.py index 476b7b7..e464102 100644 --- a/Lib/ctypes/test/test_values.py +++ b/Lib/ctypes/test/test_values.py @@ -15,13 +15,13 @@ class ValuesTestCase(unittest.TestCase): ctdll = CDLL(_ctypes_test.__file__) an_integer = c_int.in_dll(ctdll, "an_integer") x = an_integer.value - self.failUnlessEqual(x, ctdll.get_an_integer()) + self.assertEqual(x, ctdll.get_an_integer()) an_integer.value *= 2 - self.failUnlessEqual(x*2, ctdll.get_an_integer()) + self.assertEqual(x*2, ctdll.get_an_integer()) # To avoid test failures when this test is repeated several # times the original value must be restored an_integer.value = x - self.failUnlessEqual(x, ctdll.get_an_integer()) + self.assertEqual(x, ctdll.get_an_integer()) def test_undefined(self): ctdll = CDLL(_ctypes_test.__file__) @@ -40,11 +40,11 @@ class ValuesTestCase(unittest.TestCase): # docstrings are also removed in the latter case. opt = c_int.in_dll(pydll, "Py_OptimizeFlag").value if __debug__: - self.failUnlessEqual(opt, 0) + self.assertEqual(opt, 0) elif ValuesTestCase.__doc__ is not None: - self.failUnlessEqual(opt, 1) + self.assertEqual(opt, 1) else: - self.failUnlessEqual(opt, 2) + self.assertEqual(opt, 2) def test_frozentable(self): # Python exports a PyImport_FrozenModules symbol. This is a @@ -76,7 +76,7 @@ class ValuesTestCase(unittest.TestCase): expected = [("__hello__", 104), ("__phello__", -104), ("__phello__.spam", 104)] else: expected = [("__hello__", 100), ("__phello__", -100), ("__phello__.spam", 100)] - self.failUnlessEqual(items, expected) + self.assertEqual(items, expected) from ctypes import _pointer_type_cache del _pointer_type_cache[struct_frozen] diff --git a/Lib/ctypes/test/test_varsize_struct.py b/Lib/ctypes/test/test_varsize_struct.py index 06d2323..f409500 100644 --- a/Lib/ctypes/test/test_varsize_struct.py +++ b/Lib/ctypes/test/test_varsize_struct.py @@ -7,44 +7,44 @@ class VarSizeTest(unittest.TestCase): _fields_ = [("item", c_int), ("array", c_int * 1)] - self.failUnlessEqual(sizeof(X), sizeof(c_int) * 2) + self.assertEqual(sizeof(X), sizeof(c_int) * 2) x = X() x.item = 42 x.array[0] = 100 - self.failUnlessEqual(sizeof(x), sizeof(c_int) * 2) + self.assertEqual(sizeof(x), sizeof(c_int) * 2) # make room for one additional item new_size = sizeof(X) + sizeof(c_int) * 1 resize(x, new_size) - self.failUnlessEqual(sizeof(x), new_size) - self.failUnlessEqual((x.item, x.array[0]), (42, 100)) + self.assertEqual(sizeof(x), new_size) + self.assertEqual((x.item, x.array[0]), (42, 100)) # make room for 10 additional items new_size = sizeof(X) + sizeof(c_int) * 9 resize(x, new_size) - self.failUnlessEqual(sizeof(x), new_size) - self.failUnlessEqual((x.item, x.array[0]), (42, 100)) + self.assertEqual(sizeof(x), new_size) + self.assertEqual((x.item, x.array[0]), (42, 100)) # make room for one additional item new_size = sizeof(X) + sizeof(c_int) * 1 resize(x, new_size) - self.failUnlessEqual(sizeof(x), new_size) - self.failUnlessEqual((x.item, x.array[0]), (42, 100)) + self.assertEqual(sizeof(x), new_size) + self.assertEqual((x.item, x.array[0]), (42, 100)) def test_array_invalid_length(self): # cannot create arrays with non-positive size - self.failUnlessRaises(ValueError, lambda: c_int * -1) - self.failUnlessRaises(ValueError, lambda: c_int * -3) + self.assertRaises(ValueError, lambda: c_int * -1) + self.assertRaises(ValueError, lambda: c_int * -3) def test_zerosized_array(self): array = (c_int * 0)() # accessing elements of zero-sized arrays raise IndexError - self.failUnlessRaises(IndexError, array.__setitem__, 0, None) - self.failUnlessRaises(IndexError, array.__getitem__, 0) - self.failUnlessRaises(IndexError, array.__setitem__, 1, None) - self.failUnlessRaises(IndexError, array.__getitem__, 1) - self.failUnlessRaises(IndexError, array.__setitem__, -1, None) - self.failUnlessRaises(IndexError, array.__getitem__, -1) + self.assertRaises(IndexError, array.__setitem__, 0, None) + self.assertRaises(IndexError, array.__getitem__, 0) + self.assertRaises(IndexError, array.__setitem__, 1, None) + self.assertRaises(IndexError, array.__getitem__, 1) + self.assertRaises(IndexError, array.__setitem__, -1, None) + self.assertRaises(IndexError, array.__getitem__, -1) if __name__ == "__main__": unittest.main() diff --git a/Lib/ctypes/test/test_win32.py b/Lib/ctypes/test/test_win32.py index 5067b60..5dedd9f 100644 --- a/Lib/ctypes/test/test_win32.py +++ b/Lib/ctypes/test/test_win32.py @@ -18,7 +18,7 @@ if sys.platform == "win32" and sizeof(c_void_p) == sizeof(c_int): self.assertRaises(ValueError, IsWindow) # This one should succeeed... - self.failUnlessEqual(0, IsWindow(0)) + self.assertEqual(0, IsWindow(0)) # ValueError: Procedure probably called with too many arguments (8 bytes in excess) self.assertRaises(ValueError, IsWindow, 0, 0, 0) @@ -49,13 +49,13 @@ if sys.platform == "win32": class TestWintypes(unittest.TestCase): def test_HWND(self): from ctypes import wintypes - self.failUnlessEqual(sizeof(wintypes.HWND), sizeof(c_void_p)) + self.assertEqual(sizeof(wintypes.HWND), sizeof(c_void_p)) def test_PARAM(self): from ctypes import wintypes - self.failUnlessEqual(sizeof(wintypes.WPARAM), + self.assertEqual(sizeof(wintypes.WPARAM), sizeof(c_void_p)) - self.failUnlessEqual(sizeof(wintypes.LPARAM), + self.assertEqual(sizeof(wintypes.LPARAM), sizeof(c_void_p)) def test_COMError(self): @@ -84,7 +84,7 @@ class Structures(unittest.TestCase): pt = POINT(10, 10) rect = RECT(0, 0, 20, 20) - self.failUnlessEqual(1, dll.PointInRect(byref(rect), pt)) + self.assertEqual(1, dll.PointInRect(byref(rect), pt)) if __name__ == '__main__': unittest.main() diff --git a/Lib/distutils/tests/test_archive_util.py b/Lib/distutils/tests/test_archive_util.py index 663b335..d88e0b3 100644 --- a/Lib/distutils/tests/test_archive_util.py +++ b/Lib/distutils/tests/test_archive_util.py @@ -47,7 +47,7 @@ class ArchiveUtilTestCase(support.TempdirManager, # check if the compressed tarball was created tarball = base_name + '.tar.gz' - self.assert_(os.path.exists(tarball)) + self.assertTrue(os.path.exists(tarball)) # trying an uncompressed one base_name = os.path.join(tmpdir2, 'archive') @@ -58,7 +58,7 @@ class ArchiveUtilTestCase(support.TempdirManager, finally: os.chdir(old_dir) tarball = base_name + '.tar' - self.assert_(os.path.exists(tarball)) + self.assertTrue(os.path.exists(tarball)) def _tarinfo(self, path): tar = tarfile.open(path) @@ -96,7 +96,7 @@ class ArchiveUtilTestCase(support.TempdirManager, # check if the compressed tarball was created tarball = base_name + '.tar.gz' - self.assert_(os.path.exists(tarball)) + self.assertTrue(os.path.exists(tarball)) # now create another tarball using `tar` tarball2 = os.path.join(tmpdir, 'archive2.tar.gz') @@ -110,7 +110,7 @@ class ArchiveUtilTestCase(support.TempdirManager, finally: os.chdir(old_dir) - self.assert_(os.path.exists(tarball2)) + self.assertTrue(os.path.exists(tarball2)) # let's compare both tarballs self.assertEquals(self._tarinfo(tarball), self._tarinfo(tarball2)) @@ -123,7 +123,7 @@ class ArchiveUtilTestCase(support.TempdirManager, finally: os.chdir(old_dir) tarball = base_name + '.tar' - self.assert_(os.path.exists(tarball)) + self.assertTrue(os.path.exists(tarball)) # now for a dry_run base_name = os.path.join(tmpdir2, 'archive') @@ -134,7 +134,7 @@ class ArchiveUtilTestCase(support.TempdirManager, finally: os.chdir(old_dir) tarball = base_name + '.tar' - self.assert_(os.path.exists(tarball)) + self.assertTrue(os.path.exists(tarball)) @unittest.skipUnless(find_executable('compress'), 'The compress program is required') @@ -151,7 +151,7 @@ class ArchiveUtilTestCase(support.TempdirManager, finally: os.chdir(old_dir) tarball = base_name + '.tar.Z' - self.assert_(os.path.exists(tarball)) + self.assertTrue(os.path.exists(tarball)) self.assertEquals(len(w.warnings), 1) # same test with dry_run @@ -165,7 +165,7 @@ class ArchiveUtilTestCase(support.TempdirManager, dry_run=True) finally: os.chdir(old_dir) - self.assert_(not os.path.exists(tarball)) + self.assertTrue(not os.path.exists(tarball)) self.assertEquals(len(w.warnings), 1) @unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run') diff --git a/Lib/distutils/tests/test_bdist_rpm.py b/Lib/distutils/tests/test_bdist_rpm.py index 2d84007..c271567 100644 --- a/Lib/distutils/tests/test_bdist_rpm.py +++ b/Lib/distutils/tests/test_bdist_rpm.py @@ -74,7 +74,7 @@ class BuildRpmTestCase(support.TempdirManager, cmd.run() dist_created = os.listdir(os.path.join(pkg_dir, 'dist')) - self.assert_('foo-0.1-1.noarch.rpm' in dist_created) + self.assertTrue('foo-0.1-1.noarch.rpm' in dist_created) def test_no_optimize_flag(self): @@ -114,7 +114,7 @@ class BuildRpmTestCase(support.TempdirManager, cmd.run() dist_created = os.listdir(os.path.join(pkg_dir, 'dist')) - self.assert_('foo-0.1-1.noarch.rpm' in dist_created) + self.assertTrue('foo-0.1-1.noarch.rpm' in dist_created) os.remove(os.path.join(pkg_dir, 'dist', 'foo-0.1-1.noarch.rpm')) def test_suite(): diff --git a/Lib/distutils/tests/test_bdist_wininst.py b/Lib/distutils/tests/test_bdist_wininst.py index f2cb4fd..9b1ba6d 100644 --- a/Lib/distutils/tests/test_bdist_wininst.py +++ b/Lib/distutils/tests/test_bdist_wininst.py @@ -21,7 +21,7 @@ class BuildWinInstTestCase(support.TempdirManager, # and make sure it finds it and returns its content # no matter what platform we have exe_file = cmd.get_exe_bytes() - self.assert_(len(exe_file) > 10) + self.assertTrue(len(exe_file) > 10) def test_suite(): return unittest.makeSuite(BuildWinInstTestCase) diff --git a/Lib/distutils/tests/test_build_clib.py b/Lib/distutils/tests/test_build_clib.py index 47d85cd..536cd67 100644 --- a/Lib/distutils/tests/test_build_clib.py +++ b/Lib/distutils/tests/test_build_clib.py @@ -135,7 +135,7 @@ class BuildCLibTestCase(support.TempdirManager, cmd.run() # let's check the result - self.assert_('libfoo.a' in os.listdir(build_temp)) + self.assertTrue('libfoo.a' in os.listdir(build_temp)) def test_suite(): return unittest.makeSuite(BuildCLibTestCase) diff --git a/Lib/distutils/tests/test_build_ext.py b/Lib/distutils/tests/test_build_ext.py index 9861ee2..1221fd4 100644 --- a/Lib/distutils/tests/test_build_ext.py +++ b/Lib/distutils/tests/test_build_ext.py @@ -74,15 +74,15 @@ class BuildExtTestCase(TempdirManager, import xx for attr in ('error', 'foo', 'new', 'roj'): - self.assert_(hasattr(xx, attr)) + self.assertTrue(hasattr(xx, attr)) self.assertEquals(xx.foo(2, 5), 7) self.assertEquals(xx.foo(13,15), 28) self.assertEquals(xx.new().demo(), None) doc = 'This is a template module just for instruction.' self.assertEquals(xx.__doc__, doc) - self.assert_(isinstance(xx.Null(), xx.Null)) - self.assert_(isinstance(xx.Str(), xx.Str)) + self.assertTrue(isinstance(xx.Null(), xx.Null)) + self.assertTrue(isinstance(xx.Str(), xx.Str)) def tearDown(self): # Get everything back to normal @@ -114,7 +114,7 @@ class BuildExtTestCase(TempdirManager, _config_vars['Py_ENABLE_SHARED'] = old_var # make sure we get some library dirs under solaris - self.assert_(len(cmd.library_dirs) > 0) + self.assertTrue(len(cmd.library_dirs) > 0) def test_user_site(self): # site.USER_SITE was introduced in 2.6 @@ -128,7 +128,7 @@ class BuildExtTestCase(TempdirManager, # making sure the user option is there options = [name for name, short, lable in cmd.user_options] - self.assert_('user' in options) + self.assertTrue('user' in options) # setting a value cmd.user = 1 @@ -144,9 +144,9 @@ class BuildExtTestCase(TempdirManager, # see if include_dirs and library_dirs # were set - self.assert_(lib in cmd.library_dirs) - self.assert_(lib in cmd.rpath) - self.assert_(incl in cmd.include_dirs) + self.assertTrue(lib in cmd.library_dirs) + self.assertTrue(lib in cmd.rpath) + self.assertTrue(incl in cmd.include_dirs) def test_optional_extension(self): @@ -175,10 +175,10 @@ class BuildExtTestCase(TempdirManager, from distutils import sysconfig py_include = sysconfig.get_python_inc() - self.assert_(py_include in cmd.include_dirs) + self.assertTrue(py_include in cmd.include_dirs) plat_py_include = sysconfig.get_python_inc(plat_specific=1) - self.assert_(plat_py_include in cmd.include_dirs) + self.assertTrue(plat_py_include in cmd.include_dirs) # make sure cmd.libraries is turned into a list # if it's a string @@ -192,7 +192,7 @@ class BuildExtTestCase(TempdirManager, cmd = build_ext(dist) cmd.library_dirs = 'my_lib_dir' cmd.finalize_options() - self.assert_('my_lib_dir' in cmd.library_dirs) + self.assertTrue('my_lib_dir' in cmd.library_dirs) # make sure rpath is turned into a list # if it's a list of os.pathsep's paths @@ -257,13 +257,13 @@ class BuildExtTestCase(TempdirManager, 'some': 'bar'})] cmd.check_extensions_list(exts) ext = exts[0] - self.assert_(isinstance(ext, Extension)) + self.assertTrue(isinstance(ext, Extension)) # check_extensions_list adds in ext the values passed # when they are in ('include_dirs', 'library_dirs', 'libraries' # 'extra_objects', 'extra_compile_args', 'extra_link_args') self.assertEquals(ext.libraries, 'foo') - self.assert_(not hasattr(ext, 'some')) + self.assertTrue(not hasattr(ext, 'some')) # 'macros' element of build info dict must be 1- or 2-tuple exts = [('foo.bar', {'sources': [''], 'libraries': 'foo', @@ -321,7 +321,7 @@ class BuildExtTestCase(TempdirManager, so_file = cmd.get_outputs()[0] finally: os.chdir(old_wd) - self.assert_(os.path.exists(so_file)) + self.assertTrue(os.path.exists(so_file)) self.assertEquals(os.path.splitext(so_file)[-1], sysconfig.get_config_var('SO')) so_dir = os.path.dirname(so_file) @@ -330,7 +330,7 @@ class BuildExtTestCase(TempdirManager, cmd.inplace = 0 cmd.run() so_file = cmd.get_outputs()[0] - self.assert_(os.path.exists(so_file)) + self.assertTrue(os.path.exists(so_file)) self.assertEquals(os.path.splitext(so_file)[-1], sysconfig.get_config_var('SO')) so_dir = os.path.dirname(so_file) diff --git a/Lib/distutils/tests/test_build_py.py b/Lib/distutils/tests/test_build_py.py index 75b6624..8ad3bbc 100644 --- a/Lib/distutils/tests/test_build_py.py +++ b/Lib/distutils/tests/test_build_py.py @@ -52,9 +52,9 @@ class BuildPyTestCase(support.TempdirManager, self.assertEqual(len(cmd.get_outputs()), 3) pkgdest = os.path.join(destination, "pkg") files = os.listdir(pkgdest) - self.assert_("__init__.py" in files) - self.assert_("__init__.pyc" in files) - self.assert_("README.txt" in files) + self.assertTrue("__init__.py" in files) + self.assertTrue("__init__.pyc" in files) + self.assertTrue("README.txt" in files) def test_empty_package_dir (self): # See SF 1668596/1720897. diff --git a/Lib/distutils/tests/test_build_scripts.py b/Lib/distutils/tests/test_build_scripts.py index b55eb58..b1d2d07 100644 --- a/Lib/distutils/tests/test_build_scripts.py +++ b/Lib/distutils/tests/test_build_scripts.py @@ -16,12 +16,12 @@ class BuildScriptsTestCase(support.TempdirManager, def test_default_settings(self): cmd = self.get_build_scripts_cmd("/foo/bar", []) - self.assert_(not cmd.force) - self.assert_(cmd.build_dir is None) + self.assertTrue(not cmd.force) + self.assertTrue(cmd.build_dir is None) cmd.finalize_options() - self.assert_(cmd.force) + self.assertTrue(cmd.force) self.assertEqual(cmd.build_dir, "/foo/bar") def test_build(self): @@ -37,7 +37,7 @@ class BuildScriptsTestCase(support.TempdirManager, built = os.listdir(target) for name in expected: - self.assert_(name in built) + self.assertTrue(name in built) def get_build_scripts_cmd(self, target, scripts): import sys @@ -100,7 +100,7 @@ class BuildScriptsTestCase(support.TempdirManager, built = os.listdir(target) for name in expected: - self.assert_(name in built) + self.assertTrue(name in built) def test_suite(): return unittest.makeSuite(BuildScriptsTestCase) diff --git a/Lib/distutils/tests/test_clean.py b/Lib/distutils/tests/test_clean.py index 3026032..dbc4ee2 100755 --- a/Lib/distutils/tests/test_clean.py +++ b/Lib/distutils/tests/test_clean.py @@ -35,7 +35,7 @@ class cleanTestCase(support.TempdirManager, # make sure the files where removed for name, path in dirs: - self.assert_(not os.path.exists(path), + self.assertTrue(not os.path.exists(path), '%s was not removed' % path) # let's run the command again (should spit warnings but suceed) diff --git a/Lib/distutils/tests/test_cmd.py b/Lib/distutils/tests/test_cmd.py index 8f2b36f..d6438b5 100644 --- a/Lib/distutils/tests/test_cmd.py +++ b/Lib/distutils/tests/test_cmd.py @@ -70,7 +70,7 @@ class CommandTestCase(unittest.TestCase): cmd.option2 = None cmd.ensure_string('option2', 'xxx') - self.assert_(hasattr(cmd, 'option2')) + self.assertTrue(hasattr(cmd, 'option2')) cmd.option3 = 1 self.assertRaises(DistutilsOptionError, cmd.ensure_string, 'option3') diff --git a/Lib/distutils/tests/test_config.py b/Lib/distutils/tests/test_config.py index 0f97cf7..879689d 100644 --- a/Lib/distutils/tests/test_config.py +++ b/Lib/distutils/tests/test_config.py @@ -102,9 +102,9 @@ class PyPIRCCommandTestCase(support.TempdirManager, def test_server_empty_registration(self): cmd = self._cmd(self.dist) rc = cmd._get_rc_file() - self.assert_(not os.path.exists(rc)) + self.assertTrue(not os.path.exists(rc)) cmd._store_pypirc('tarek', 'xxx') - self.assert_(os.path.exists(rc)) + self.assertTrue(os.path.exists(rc)) content = open(rc).read() self.assertEquals(content, WANTED) diff --git a/Lib/distutils/tests/test_config_cmd.py b/Lib/distutils/tests/test_config_cmd.py index bacf13a..ef2e7bc 100644 --- a/Lib/distutils/tests/test_config_cmd.py +++ b/Lib/distutils/tests/test_config_cmd.py @@ -73,14 +73,14 @@ class ConfigTestCase(support.LoggingSilencer, self.write_file(f2, 'xxx') for f in (f1, f2): - self.assert_(os.path.exists(f)) + self.assertTrue(os.path.exists(f)) pkg_dir, dist = self.create_dist() cmd = config(dist) cmd._clean(f1, f2) for f in (f1, f2): - self.assert_(not os.path.exists(f)) + self.assertTrue(not os.path.exists(f)) def test_suite(): return unittest.makeSuite(ConfigTestCase) diff --git a/Lib/distutils/tests/test_dist.py b/Lib/distutils/tests/test_dist.py index 4076039..9f795f4 100644 --- a/Lib/distutils/tests/test_dist.py +++ b/Lib/distutils/tests/test_dist.py @@ -72,7 +72,7 @@ class DistributionTestCase(support.LoggingSilencer, self.assertEqual(d.get_command_packages(), ["distutils.command", "foo.bar", "distutils.tests"]) cmd = d.get_command_obj("test_dist") - self.assert_(isinstance(cmd, test_dist)) + self.assertTrue(isinstance(cmd, test_dist)) self.assertEqual(cmd.sample_option, "sometext") def test_command_packages_configfile(self): @@ -157,10 +157,10 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard, "version": "1.0"} dist = Distribution(attrs) meta = self.format_metadata(dist) - self.assert_("Metadata-Version: 1.0" in meta) - self.assert_("provides:" not in meta.lower()) - self.assert_("requires:" not in meta.lower()) - self.assert_("obsoletes:" not in meta.lower()) + self.assertTrue("Metadata-Version: 1.0" in meta) + self.assertTrue("provides:" not in meta.lower()) + self.assertTrue("requires:" not in meta.lower()) + self.assertTrue("obsoletes:" not in meta.lower()) def test_provides(self): attrs = {"name": "package", @@ -172,9 +172,9 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard, self.assertEqual(dist.get_provides(), ["package", "package.sub"]) meta = self.format_metadata(dist) - self.assert_("Metadata-Version: 1.1" in meta) - self.assert_("requires:" not in meta.lower()) - self.assert_("obsoletes:" not in meta.lower()) + self.assertTrue("Metadata-Version: 1.1" in meta) + self.assertTrue("requires:" not in meta.lower()) + self.assertTrue("obsoletes:" not in meta.lower()) def test_provides_illegal(self): self.assertRaises(ValueError, Distribution, @@ -192,11 +192,11 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard, self.assertEqual(dist.get_requires(), ["other", "another (==1.0)"]) meta = self.format_metadata(dist) - self.assert_("Metadata-Version: 1.1" in meta) - self.assert_("provides:" not in meta.lower()) - self.assert_("Requires: other" in meta) - self.assert_("Requires: another (==1.0)" in meta) - self.assert_("obsoletes:" not in meta.lower()) + self.assertTrue("Metadata-Version: 1.1" in meta) + self.assertTrue("provides:" not in meta.lower()) + self.assertTrue("Requires: other" in meta) + self.assertTrue("Requires: another (==1.0)" in meta) + self.assertTrue("obsoletes:" not in meta.lower()) def test_requires_illegal(self): self.assertRaises(ValueError, Distribution, @@ -214,11 +214,11 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard, self.assertEqual(dist.get_obsoletes(), ["other", "another (<1.0)"]) meta = self.format_metadata(dist) - self.assert_("Metadata-Version: 1.1" in meta) - self.assert_("provides:" not in meta.lower()) - self.assert_("requires:" not in meta.lower()) - self.assert_("Obsoletes: other" in meta) - self.assert_("Obsoletes: another (<1.0)" in meta) + self.assertTrue("Metadata-Version: 1.1" in meta) + self.assertTrue("provides:" not in meta.lower()) + self.assertTrue("requires:" not in meta.lower()) + self.assertTrue("Obsoletes: other" in meta) + self.assertTrue("Obsoletes: another (<1.0)" in meta) def test_obsoletes_illegal(self): self.assertRaises(ValueError, Distribution, @@ -252,14 +252,14 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard, if sys.platform in ('linux', 'darwin'): self.environ['HOME'] = temp_dir files = dist.find_config_files() - self.assert_(user_filename in files) + self.assertTrue(user_filename in files) # win32-style if sys.platform == 'win32': # home drive should be found self.environ['HOME'] = temp_dir files = dist.find_config_files() - self.assert_(user_filename in files, + self.assertTrue(user_filename in files, '%r not found in %r' % (user_filename, files)) finally: os.remove(user_filename) @@ -285,7 +285,7 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard, output = [line for line in s.getvalue().split('\n') if line.strip() != ''] - self.assert_(len(output) > 0) + self.assertTrue(len(output) > 0) def test_suite(): suite = unittest.TestSuite() diff --git a/Lib/distutils/tests/test_install.py b/Lib/distutils/tests/test_install.py index 8d7e972..d0ad5ce 100644 --- a/Lib/distutils/tests/test_install.py +++ b/Lib/distutils/tests/test_install.py @@ -88,7 +88,7 @@ class InstallTestCase(support.TempdirManager, def _test_user_site(self): for key in ('nt_user', 'unix_user', 'os2_home'): - self.assert_(key in INSTALL_SCHEMES) + self.assertTrue(key in INSTALL_SCHEMES) dist = Distribution({'name': 'xx'}) cmd = install(dist) @@ -96,24 +96,24 @@ class InstallTestCase(support.TempdirManager, # making sure the user option is there options = [name for name, short, lable in cmd.user_options] - self.assert_('user' in options) + self.assertTrue('user' in options) # setting a value cmd.user = 1 # user base and site shouldn't be created yet - self.assert_(not os.path.exists(self.user_base)) - self.assert_(not os.path.exists(self.user_site)) + self.assertTrue(not os.path.exists(self.user_base)) + self.assertTrue(not os.path.exists(self.user_site)) # let's run finalize cmd.ensure_finalized() # now they should - self.assert_(os.path.exists(self.user_base)) - self.assert_(os.path.exists(self.user_site)) + self.assertTrue(os.path.exists(self.user_base)) + self.assertTrue(os.path.exists(self.user_site)) - self.assert_('userbase' in cmd.config_vars) - self.assert_('usersite' in cmd.config_vars) + self.assertTrue('userbase' in cmd.config_vars) + self.assertTrue('usersite' in cmd.config_vars) def test_handle_extra_path(self): dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'}) diff --git a/Lib/distutils/tests/test_install_data.py b/Lib/distutils/tests/test_install_data.py index 73c4037..7072136 100644 --- a/Lib/distutils/tests/test_install_data.py +++ b/Lib/distutils/tests/test_install_data.py @@ -35,9 +35,9 @@ class InstallDataTestCase(support.TempdirManager, # let's check the result self.assertEquals(len(cmd.get_outputs()), 2) rtwo = os.path.split(two)[-1] - self.assert_(os.path.exists(os.path.join(inst2, rtwo))) + self.assertTrue(os.path.exists(os.path.join(inst2, rtwo))) rone = os.path.split(one)[-1] - self.assert_(os.path.exists(os.path.join(inst, rone))) + self.assertTrue(os.path.exists(os.path.join(inst, rone))) cmd.outfiles = [] # let's try with warn_dir one @@ -47,8 +47,8 @@ class InstallDataTestCase(support.TempdirManager, # let's check the result self.assertEquals(len(cmd.get_outputs()), 2) - self.assert_(os.path.exists(os.path.join(inst2, rtwo))) - self.assert_(os.path.exists(os.path.join(inst, rone))) + self.assertTrue(os.path.exists(os.path.join(inst2, rtwo))) + self.assertTrue(os.path.exists(os.path.join(inst, rone))) cmd.outfiles = [] # now using root and empty dir @@ -65,8 +65,8 @@ class InstallDataTestCase(support.TempdirManager, # let's check the result self.assertEquals(len(cmd.get_outputs()), 4) - self.assert_(os.path.exists(os.path.join(inst2, rtwo))) - self.assert_(os.path.exists(os.path.join(inst, rone))) + self.assertTrue(os.path.exists(os.path.join(inst2, rtwo))) + self.assertTrue(os.path.exists(os.path.join(inst, rone))) def test_suite(): return unittest.makeSuite(InstallDataTestCase) diff --git a/Lib/distutils/tests/test_install_lib.py b/Lib/distutils/tests/test_install_lib.py index d768166..793b95c 100644 --- a/Lib/distutils/tests/test_install_lib.py +++ b/Lib/distutils/tests/test_install_lib.py @@ -39,8 +39,8 @@ class InstallLibTestCase(support.TempdirManager, f = os.path.join(pkg_dir, 'foo.py') self.write_file(f, '# python file') cmd.byte_compile([f]) - self.assert_(os.path.exists(os.path.join(pkg_dir, 'foo.pyc'))) - self.assert_(os.path.exists(os.path.join(pkg_dir, 'foo.pyo'))) + self.assertTrue(os.path.exists(os.path.join(pkg_dir, 'foo.pyc'))) + self.assertTrue(os.path.exists(os.path.join(pkg_dir, 'foo.pyo'))) def test_get_outputs(self): pkg_dir, dist = self.create_dist() @@ -57,7 +57,7 @@ class InstallLibTestCase(support.TempdirManager, cmd.distribution.script_name = 'setup.py' # get_output should return 4 elements - self.assert_(len(cmd.get_outputs()) >= 2) + self.assertTrue(len(cmd.get_outputs()) >= 2) def test_get_inputs(self): pkg_dir, dist = self.create_dist() diff --git a/Lib/distutils/tests/test_install_scripts.py b/Lib/distutils/tests/test_install_scripts.py index fffa6ef..b7eb625 100644 --- a/Lib/distutils/tests/test_install_scripts.py +++ b/Lib/distutils/tests/test_install_scripts.py @@ -23,15 +23,15 @@ class InstallScriptsTestCase(support.TempdirManager, skip_build=1, ) cmd = install_scripts(dist) - self.assert_(not cmd.force) - self.assert_(not cmd.skip_build) - self.assert_(cmd.build_dir is None) - self.assert_(cmd.install_dir is None) + self.assertTrue(not cmd.force) + self.assertTrue(not cmd.skip_build) + self.assertTrue(cmd.build_dir is None) + self.assertTrue(cmd.install_dir is None) cmd.finalize_options() - self.assert_(cmd.force) - self.assert_(cmd.skip_build) + self.assertTrue(cmd.force) + self.assertTrue(cmd.skip_build) self.assertEqual(cmd.build_dir, "/foo/bar") self.assertEqual(cmd.install_dir, "/splat/funk") @@ -69,7 +69,7 @@ class InstallScriptsTestCase(support.TempdirManager, installed = os.listdir(target) for name in expected: - self.assert_(name in installed) + self.assertTrue(name in installed) def test_suite(): diff --git a/Lib/distutils/tests/test_msvc9compiler.py b/Lib/distutils/tests/test_msvc9compiler.py index 11e5a47..7382798 100644 --- a/Lib/distutils/tests/test_msvc9compiler.py +++ b/Lib/distutils/tests/test_msvc9compiler.py @@ -46,7 +46,7 @@ class msvc9compilerTestCase(unittest.TestCase): # windows registeries versions. path = r'Software\Microsoft\Notepad' v = Reg.get_value(path, "lfitalic") - self.assert_(v in (0, 1)) + self.assertTrue(v in (0, 1)) import winreg HKCU = winreg.HKEY_CURRENT_USER @@ -54,7 +54,7 @@ class msvc9compilerTestCase(unittest.TestCase): self.assertEquals(keys, None) keys = Reg.read_keys(HKCU, r'Software\Microsoft') - self.assert_('Notepad' in keys) + self.assertTrue('Notepad' in keys) def test_suite(): return unittest.makeSuite(msvc9compilerTestCase) diff --git a/Lib/distutils/tests/test_register.py b/Lib/distutils/tests/test_register.py index d9ff3ec..c03ad10 100644 --- a/Lib/distutils/tests/test_register.py +++ b/Lib/distutils/tests/test_register.py @@ -96,7 +96,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): cmd = self._get_cmd() # we shouldn't have a .pypirc file yet - self.assert_(not os.path.exists(self.rc)) + self.assertTrue(not os.path.exists(self.rc)) # patching input and getpass.getpass # so register gets happy @@ -115,7 +115,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): del register_module.input # we should have a brand new .pypirc file - self.assert_(os.path.exists(self.rc)) + self.assertTrue(os.path.exists(self.rc)) # with the content similar to WANTED_PYPIRC content = open(self.rc).read() @@ -133,13 +133,13 @@ class RegisterTestCase(PyPIRCCommandTestCase): # let's see what the server received : we should # have 2 similar requests - self.assert_(self.conn.reqs, 2) + self.assertTrue(self.conn.reqs, 2) req1 = dict(self.conn.reqs[0].headers) req2 = dict(self.conn.reqs[1].headers) self.assertEquals(req1['Content-length'], '1374') self.assertEquals(req2['Content-length'], '1374') - self.assert_((b'xxx') in self.conn.reqs[1].data) + self.assertTrue((b'xxx') in self.conn.reqs[1].data) def test_password_not_in_file(self): @@ -165,11 +165,11 @@ class RegisterTestCase(PyPIRCCommandTestCase): del register_module.input # we should have send a request - self.assert_(self.conn.reqs, 1) + self.assertTrue(self.conn.reqs, 1) req = self.conn.reqs[0] headers = dict(req.headers) self.assertEquals(headers['Content-length'], '608') - self.assert_((b'tarek') in req.data) + self.assertTrue((b'tarek') in req.data) def test_password_reset(self): # this test runs choice 3 @@ -183,11 +183,11 @@ class RegisterTestCase(PyPIRCCommandTestCase): del register_module.input # we should have send a request - self.assert_(self.conn.reqs, 1) + self.assertTrue(self.conn.reqs, 1) req = self.conn.reqs[0] headers = dict(req.headers) self.assertEquals(headers['Content-length'], '290') - self.assert_((b'tarek') in req.data) + self.assertTrue((b'tarek') in req.data) def test_strict(self): # testing the script option diff --git a/Lib/distutils/tests/test_sysconfig.py b/Lib/distutils/tests/test_sysconfig.py index 2d8fa27..eb36204 100644 --- a/Lib/distutils/tests/test_sysconfig.py +++ b/Lib/distutils/tests/test_sysconfig.py @@ -21,12 +21,12 @@ class SysconfigTestCase(support.EnvironGuard, def test_get_config_h_filename(self): config_h = sysconfig.get_config_h_filename() - self.assert_(os.path.isfile(config_h), config_h) + self.assertTrue(os.path.isfile(config_h), config_h) def test_get_python_lib(self): lib_dir = sysconfig.get_python_lib() # XXX doesn't work on Linux when Python was never installed before - #self.assert_(os.path.isdir(lib_dir), lib_dir) + #self.assertTrue(os.path.isdir(lib_dir), lib_dir) # test for pythonxx.lib? self.assertNotEqual(sysconfig.get_python_lib(), sysconfig.get_python_lib(prefix=TESTFN)) @@ -36,14 +36,14 @@ class SysconfigTestCase(support.EnvironGuard, # This is not much of a test. We make sure Python.h exists # in the directory returned by get_python_inc() but we don't know # it is the correct file. - self.assert_(os.path.isdir(inc_dir), inc_dir) + self.assertTrue(os.path.isdir(inc_dir), inc_dir) python_h = os.path.join(inc_dir, "Python.h") - self.assert_(os.path.isfile(python_h), python_h) + self.assertTrue(os.path.isfile(python_h), python_h) def test_get_config_vars(self): cvars = sysconfig.get_config_vars() - self.assert_(isinstance(cvars, dict)) - self.assert_(cvars) + self.assertTrue(isinstance(cvars, dict)) + self.assertTrue(cvars) def test_customize_compiler(self): diff --git a/Lib/distutils/tests/test_upload.py b/Lib/distutils/tests/test_upload.py index 95e4ac3..828f20c 100644 --- a/Lib/distutils/tests/test_upload.py +++ b/Lib/distutils/tests/test_upload.py @@ -107,7 +107,7 @@ class uploadTestCase(PyPIRCCommandTestCase): # what did we send ? headers = dict(self.conn.headers) self.assertEquals(headers['Content-length'], '2087') - self.assert_(headers['Content-type'].startswith('multipart/form-data')) + self.assertTrue(headers['Content-type'].startswith('multipart/form-data')) self.assertEquals(self.conn.requests, [('POST', '/pypi')]) self.assert_((b'xxx') in self.conn.body) diff --git a/Lib/distutils/tests/test_util.py b/Lib/distutils/tests/test_util.py index cee7d52..c0acf5f 100644 --- a/Lib/distutils/tests/test_util.py +++ b/Lib/distutils/tests/test_util.py @@ -225,10 +225,10 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase): no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N') for y in yes: - self.assert_(strtobool(y)) + self.assertTrue(strtobool(y)) for n in no: - self.assert_(not strtobool(n)) + self.assertTrue(not strtobool(n)) def test_rfc822_escape(self): header = 'I am a\npoor\nlonesome\nheader\n' diff --git a/Lib/email/test/test_email.py b/Lib/email/test/test_email.py index 86e3537..25885c7 100644 --- a/Lib/email/test/test_email.py +++ b/Lib/email/test/test_email.py @@ -53,7 +53,7 @@ def openfile(filename, *args, **kws): # Base test class class TestEmailBase(unittest.TestCase): def ndiffAssertEqual(self, first, second): - """Like failUnlessEqual except use ndiff for readable output.""" + """Like assertEqual except use ndiff for readable output.""" if first != second: sfirst = str(first) ssecond = str(second) @@ -222,12 +222,12 @@ class TestMessageAPI(TestEmailBase): msg['From'] = 'Me' msg['to'] = 'You' # Check for case insensitivity - self.failUnless('from' in msg) - self.failUnless('From' in msg) - self.failUnless('FROM' in msg) - self.failUnless('to' in msg) - self.failUnless('To' in msg) - self.failUnless('TO' in msg) + self.assertTrue('from' in msg) + self.assertTrue('From' in msg) + self.assertTrue('FROM' in msg) + self.assertTrue('to' in msg) + self.assertTrue('To' in msg) + self.assertTrue('TO' in msg) def test_as_string(self): eq = self.ndiffAssertEqual @@ -237,7 +237,7 @@ class TestMessageAPI(TestEmailBase): eq(text, str(msg)) fullrepr = msg.as_string(unixfrom=True) lines = fullrepr.split('\n') - self.failUnless(lines[0].startswith('From ')) + self.assertTrue(lines[0].startswith('From ')) eq(text, NL.join(lines[1:])) def test_bad_param(self): @@ -307,12 +307,12 @@ class TestMessageAPI(TestEmailBase): '"Jim&&Jill"') def test_field_containment(self): - unless = self.failUnless + unless = self.assertTrue msg = email.message_from_string('Header: exists') unless('header' in msg) unless('Header' in msg) unless('HEADER' in msg) - self.failIf('headerx' in msg) + self.assertFalse('headerx' in msg) def test_set_param(self): eq = self.assertEqual @@ -952,7 +952,7 @@ class TestMIMEAudio(unittest.TestCase): def test_add_header(self): eq = self.assertEqual - unless = self.failUnless + unless = self.assertTrue self._au.add_header('Content-Disposition', 'attachment', filename='audiotest.au') eq(self._au['content-disposition'], @@ -992,7 +992,7 @@ class TestMIMEImage(unittest.TestCase): def test_add_header(self): eq = self.assertEqual - unless = self.failUnless + unless = self.assertTrue self._im.add_header('Content-Disposition', 'attachment', filename='dingusfish.gif') eq(self._im['content-disposition'], @@ -1036,7 +1036,7 @@ class TestMIMEText(unittest.TestCase): def test_types(self): eq = self.assertEqual - unless = self.failUnless + unless = self.assertTrue eq(self._msg.get_content_type(), 'text/plain') eq(self._msg.get_param('charset'), 'us-ascii') missing = [] @@ -1046,7 +1046,7 @@ class TestMIMEText(unittest.TestCase): def test_payload(self): self.assertEqual(self._msg.get_payload(), 'hello there') - self.failUnless(not self._msg.is_multipart()) + self.assertTrue(not self._msg.is_multipart()) def test_charset(self): eq = self.assertEqual @@ -1097,7 +1097,7 @@ This is the dingus fish. def test_hierarchy(self): # convenience eq = self.assertEqual - unless = self.failUnless + unless = self.assertTrue raises = self.assertRaises # tests m = self._msg @@ -1411,7 +1411,7 @@ Content-Type: text/plain -- XXXX-- ''') - self.failUnless(msg.is_multipart()) + self.assertTrue(msg.is_multipart()) eq(msg.get_boundary(), ' XXXX') eq(len(msg.get_payload()), 2) @@ -1441,7 +1441,7 @@ class TestNonConformant(TestEmailBase): eq(msg.get_content_subtype(), 'plain') def test_same_boundary_inner_outer(self): - unless = self.failUnless + unless = self.assertTrue msg = self._msgobj('msg_15.txt') # XXX We can probably eventually do better inner = msg.get_payload(0) @@ -1451,7 +1451,7 @@ class TestNonConformant(TestEmailBase): errors.StartBoundaryNotFoundDefect)) def test_multipart_no_boundary(self): - unless = self.failUnless + unless = self.assertTrue msg = self._msgobj('msg_25.txt') unless(isinstance(msg.get_payload(), str)) self.assertEqual(len(msg.defects), 2) @@ -1509,7 +1509,7 @@ counter to RFC 2822, there's no separating newline here """) def test_lying_multipart(self): - unless = self.failUnless + unless = self.assertTrue msg = self._msgobj('msg_41.txt') unless(hasattr(msg, 'defects')) self.assertEqual(len(msg.defects), 2) @@ -1529,7 +1529,7 @@ counter to RFC 2822, there's no separating newline here # [*] This message is missing its start boundary bad = outer.get_payload(1).get_payload(0) self.assertEqual(len(bad.defects), 1) - self.failUnless(isinstance(bad.defects[0], + self.assertTrue(isinstance(bad.defects[0], errors.StartBoundaryNotFoundDefect)) def test_first_line_is_continuation_header(self): @@ -1539,7 +1539,7 @@ counter to RFC 2822, there's no separating newline here eq(msg.keys(), []) eq(msg.get_payload(), 'Line 2\nLine 3') eq(len(msg.defects), 1) - self.failUnless(isinstance(msg.defects[0], + self.assertTrue(isinstance(msg.defects[0], errors.FirstHeaderLineIsContinuationDefect)) eq(msg.defects[0].line, ' Line 1\n') @@ -1607,7 +1607,7 @@ class TestMIMEMessage(TestEmailBase): def test_valid_argument(self): eq = self.assertEqual - unless = self.failUnless + unless = self.assertTrue subject = 'A sub-message' m = Message() m['Subject'] = subject @@ -1651,20 +1651,20 @@ Here is the body of the message. def test_parse_message_rfc822(self): eq = self.assertEqual - unless = self.failUnless + unless = self.assertTrue msg = self._msgobj('msg_11.txt') eq(msg.get_content_type(), 'message/rfc822') payload = msg.get_payload() unless(isinstance(payload, list)) eq(len(payload), 1) submsg = payload[0] - self.failUnless(isinstance(submsg, Message)) + self.assertTrue(isinstance(submsg, Message)) eq(submsg['subject'], 'An enclosed message') eq(submsg.get_payload(), 'Here is the body of the message.\n') def test_dsn(self): eq = self.assertEqual - unless = self.failUnless + unless = self.assertTrue # msg 16 is a Delivery Status Notification, see RFC 1894 msg = self._msgobj('msg_16.txt') eq(msg.get_content_type(), 'multipart/report') @@ -2002,7 +2002,7 @@ class TestIdempotent(TestEmailBase): def test_content_type(self): eq = self.assertEquals - unless = self.failUnless + unless = self.assertTrue # Get a message object and reset the seek pointer for other tests msg, text = self._msgobj('msg_05.txt') eq(msg.get_content_type(), 'multipart/report') @@ -2024,7 +2024,7 @@ class TestIdempotent(TestEmailBase): eq(msg2.get_payload(), 'Yadda yadda yadda\n') msg3 = msg.get_payload(2) eq(msg3.get_content_type(), 'message/rfc822') - self.failUnless(isinstance(msg3, Message)) + self.assertTrue(isinstance(msg3, Message)) payload = msg3.get_payload() unless(isinstance(payload, list)) eq(len(payload), 1) @@ -2034,7 +2034,7 @@ class TestIdempotent(TestEmailBase): def test_parser(self): eq = self.assertEquals - unless = self.failUnless + unless = self.assertTrue msg, text = self._msgobj('msg_06.txt') # Check some of the outer headers eq(msg.get_content_type(), 'message/rfc822') @@ -2044,9 +2044,9 @@ class TestIdempotent(TestEmailBase): unless(isinstance(payload, list)) eq(len(payload), 1) msg1 = payload[0] - self.failUnless(isinstance(msg1, Message)) + self.assertTrue(isinstance(msg1, Message)) eq(msg1.get_content_type(), 'text/plain') - self.failUnless(isinstance(msg1.get_payload(), str)) + self.assertTrue(isinstance(msg1.get_payload(), str)) eq(msg1.get_payload(), '\n') @@ -2077,7 +2077,7 @@ class TestMiscellaneous(TestEmailBase): self.assertEqual(text, s.getvalue()) def test_message_from_string_with_class(self): - unless = self.failUnless + unless = self.assertTrue with openfile('msg_01.txt') as fp: text = fp.read() @@ -2095,7 +2095,7 @@ class TestMiscellaneous(TestEmailBase): unless(isinstance(subpart, MyMessage)) def test_message_from_file_with_class(self): - unless = self.failUnless + unless = self.assertTrue # Create a subclass class MyMessage(Message): pass @@ -2217,7 +2217,7 @@ Foo def test_charset_richcomparisons(self): eq = self.assertEqual - ne = self.failIfEqual + ne = self.assertNotEqual cset1 = Charset() cset2 = Charset() eq(cset1, 'us-ascii') @@ -2410,8 +2410,8 @@ class TestParsers(TestEmailBase): eq(msg['from'], 'ppp-request@zzz.org') eq(msg['to'], 'ppp@zzz.org') eq(msg.get_content_type(), 'multipart/mixed') - self.failIf(msg.is_multipart()) - self.failUnless(isinstance(msg.get_payload(), str)) + self.assertFalse(msg.is_multipart()) + self.assertTrue(isinstance(msg.get_payload(), str)) def test_whitespace_continuation(self): eq = self.assertEqual @@ -2613,18 +2613,18 @@ class TestQuopri(unittest.TestCase): def test_quopri_header_check(self): for c in self.hlit: - self.failIf(quoprimime.header_check(c), + self.assertFalse(quoprimime.header_check(c), 'Should not be header quopri encoded: %s' % chr(c)) for c in self.hnon: - self.failUnless(quoprimime.header_check(c), + self.assertTrue(quoprimime.header_check(c), 'Should be header quopri encoded: %s' % chr(c)) def test_quopri_body_check(self): for c in self.blit: - self.failIf(quoprimime.body_check(c), + self.assertFalse(quoprimime.body_check(c), 'Should not be body quopri encoded: %s' % chr(c)) for c in self.bnon: - self.failUnless(quoprimime.body_check(c), + self.assertTrue(quoprimime.body_check(c), 'Should be body quopri encoded: %s' % chr(c)) def test_header_quopri_len(self): @@ -2789,7 +2789,7 @@ class TestHeader(TestEmailBase): h = Header("I am the very model of a modern Major-General; I've information vegetable, animal, and mineral; I know the kings of England, and I quote the fights historical from Marathon to Waterloo, in order categorical; I'm very well acquainted, too, with matters mathematical; I understand equations, both the simple and quadratical; about binomial theorem I'm teeming with a lot o' news, with many cheerful facts about the square of the hypotenuse.", maxlinelen=76) for l in h.encode(splitchars=' ').split('\n '): - self.failUnless(len(l) <= 76) + self.assertTrue(len(l) <= 76) def test_multilingual(self): eq = self.ndiffAssertEqual @@ -3166,7 +3166,7 @@ Content-Type: text/html; NAME*0=file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOC ''' msg = email.message_from_string(m) param = msg.get_param('NAME') - self.failIf(isinstance(param, tuple)) + self.assertFalse(isinstance(param, tuple)) self.assertEqual( param, 'file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm') @@ -3319,7 +3319,7 @@ Content-Type: application/x-foo; name*0=\"Frank's\"; name*1=\" Document\" """ msg = email.message_from_string(m) param = msg.get_param('name') - self.failIf(isinstance(param, tuple)) + self.assertFalse(isinstance(param, tuple)) self.assertEqual(param, "Frank's Document") def test_rfc2231_tick_attack_extended(self): @@ -3343,7 +3343,7 @@ Content-Type: application/x-foo; """ msg = email.message_from_string(m) param = msg.get_param('name') - self.failIf(isinstance(param, tuple)) + self.assertFalse(isinstance(param, tuple)) self.assertEqual(param, "us-ascii'en-us'Frank's Document") def test_rfc2231_no_extended_values(self): diff --git a/Lib/importlib/test/builtin/test_finder.py b/Lib/importlib/test/builtin/test_finder.py index ef8e8fe..40f690e 100644 --- a/Lib/importlib/test/builtin/test_finder.py +++ b/Lib/importlib/test/builtin/test_finder.py @@ -14,7 +14,7 @@ class FinderTests(abc.FinderTests): # Common case. with util.uncache(builtin_util.NAME): found = machinery.BuiltinImporter.find_module(builtin_util.NAME) - self.assert_(found) + self.assertTrue(found) def test_package(self): # Built-in modules cannot be a package. @@ -35,14 +35,14 @@ class FinderTests(abc.FinderTests): def test_failure(self): assert 'importlib' not in sys.builtin_module_names loader = machinery.BuiltinImporter.find_module('importlib') - self.assert_(loader is None) + self.assertTrue(loader is None) def test_ignore_path(self): # The value for 'path' should always trigger a failed import. with util.uncache(builtin_util.NAME): loader = machinery.BuiltinImporter.find_module(builtin_util.NAME, ['pkg']) - self.assert_(loader is None) + self.assertTrue(loader is None) diff --git a/Lib/importlib/test/builtin/test_loader.py b/Lib/importlib/test/builtin/test_loader.py index cfedb5d..dff00ce 100644 --- a/Lib/importlib/test/builtin/test_loader.py +++ b/Lib/importlib/test/builtin/test_loader.py @@ -18,10 +18,10 @@ class LoaderTests(abc.LoaderTests): def verify(self, module): """Verify that the module matches against what it should have.""" - self.assert_(isinstance(module, types.ModuleType)) + self.assertTrue(isinstance(module, types.ModuleType)) for attr, value in self.verification.items(): self.assertEqual(getattr(module, attr), value) - self.assert_(module.__name__ in sys.modules) + self.assertTrue(module.__name__ in sys.modules) load_module = staticmethod(lambda name: machinery.BuiltinImporter.load_module(name)) @@ -49,7 +49,7 @@ class LoaderTests(abc.LoaderTests): with util.uncache(builtin_util.NAME): module1 = self.load_module(builtin_util.NAME) module2 = self.load_module(builtin_util.NAME) - self.assert_(module1 is module2) + self.assertTrue(module1 is module2) def test_unloadable(self): name = 'dssdsdfff' @@ -70,17 +70,17 @@ class InspectLoaderTests(unittest.TestCase): def test_get_code(self): # There is no code object. result = machinery.BuiltinImporter.get_code(builtin_util.NAME) - self.assert_(result is None) + self.assertTrue(result is None) def test_get_source(self): # There is no source. result = machinery.BuiltinImporter.get_source(builtin_util.NAME) - self.assert_(result is None) + self.assertTrue(result is None) def test_is_package(self): # Cannot be a package. result = machinery.BuiltinImporter.is_package(builtin_util.NAME) - self.assert_(not result) + self.assertTrue(not result) def test_not_builtin(self): # Modules not built-in should raise ImportError. diff --git a/Lib/importlib/test/extension/test_finder.py b/Lib/importlib/test/extension/test_finder.py index 39e26a7..546a176 100644 --- a/Lib/importlib/test/extension/test_finder.py +++ b/Lib/importlib/test/extension/test_finder.py @@ -13,7 +13,7 @@ class FinderTests(abc.FinderTests): return importer.find_module(fullname) def test_module(self): - self.assert_(self.find_module(util.NAME)) + self.assertTrue(self.find_module(util.NAME)) def test_package(self): # Extension modules cannot be an __init__ for a package. @@ -32,7 +32,7 @@ class FinderTests(abc.FinderTests): pass def test_failure(self): - self.assert_(self.find_module('asdfjkl;') is None) + self.assertTrue(self.find_module('asdfjkl;') is None) # XXX Raise an exception if someone tries to use the 'path' argument? diff --git a/Lib/importlib/test/extension/test_loader.py b/Lib/importlib/test/extension/test_loader.py index 157a3b6..71841c6 100644 --- a/Lib/importlib/test/extension/test_loader.py +++ b/Lib/importlib/test/extension/test_loader.py @@ -23,8 +23,8 @@ class LoaderTests(abc.LoaderTests): ('__file__', ext_util.FILEPATH), ('__package__', '')]: self.assertEqual(getattr(module, attr), value) - self.assert_(ext_util.NAME in sys.modules) - self.assert_(isinstance(module.__loader__, + self.assertTrue(ext_util.NAME in sys.modules) + self.assertTrue(isinstance(module.__loader__, _bootstrap._ExtensionFileLoader)) def test_package(self): @@ -39,7 +39,7 @@ class LoaderTests(abc.LoaderTests): with util.uncache(ext_util.NAME): module1 = self.load_module(ext_util.NAME) module2 = self.load_module(ext_util.NAME) - self.assert_(module1 is module2) + self.assertTrue(module1 is module2) def test_state_after_failure(self): # No easy way to trigger a failure after a successful import. diff --git a/Lib/importlib/test/extension/test_path_hook.py b/Lib/importlib/test/extension/test_path_hook.py index 8532956..bf2f411 100644 --- a/Lib/importlib/test/extension/test_path_hook.py +++ b/Lib/importlib/test/extension/test_path_hook.py @@ -19,7 +19,7 @@ class PathHookTests(unittest.TestCase): def test_success(self): # Path hook should handle a directory where a known extension module # exists. - self.assert_(hasattr(self.hook(util.PATH), 'find_module')) + self.assertTrue(hasattr(self.hook(util.PATH), 'find_module')) def test_main(): diff --git a/Lib/importlib/test/frozen/test_finder.py b/Lib/importlib/test/frozen/test_finder.py index 8caac48..db88379 100644 --- a/Lib/importlib/test/frozen/test_finder.py +++ b/Lib/importlib/test/frozen/test_finder.py @@ -15,15 +15,15 @@ class FinderTests(abc.FinderTests): def test_module(self): name = '__hello__' loader = self.find(name) - self.assert_(hasattr(loader, 'load_module')) + self.assertTrue(hasattr(loader, 'load_module')) def test_package(self): loader = self.find('__phello__') - self.assert_(hasattr(loader, 'load_module')) + self.assertTrue(hasattr(loader, 'load_module')) def test_module_in_package(self): loader = self.find('__phello__.spam', ['__phello__']) - self.assert_(hasattr(loader, 'load_module')) + self.assertTrue(hasattr(loader, 'load_module')) def test_package_in_package(self): # No frozen package within another package to test with. @@ -35,7 +35,7 @@ class FinderTests(abc.FinderTests): def test_failure(self): loader = self.find('') - self.assert_(loader is None) + self.assertTrue(loader is None) def test_main(): diff --git a/Lib/importlib/test/frozen/test_loader.py b/Lib/importlib/test/frozen/test_loader.py index 472d6ec..fa64f30 100644 --- a/Lib/importlib/test/frozen/test_loader.py +++ b/Lib/importlib/test/frozen/test_loader.py @@ -43,7 +43,7 @@ class LoaderTests(abc.LoaderTests): with util.uncache('__hello__'): module1 = machinery.FrozenImporter.load_module('__hello__') module2 = machinery.FrozenImporter.load_module('__hello__') - self.assert_(module1 is module2) + self.assertTrue(module1 is module2) def test_state_after_failure(self): # No way to trigger an error in a frozen module. @@ -65,12 +65,12 @@ class InspectLoaderTests(unittest.TestCase): code = machinery.FrozenImporter.get_code(name) mod = imp.new_module(name) exec(code, mod.__dict__) - self.assert_(hasattr(mod, 'initialized')) + self.assertTrue(hasattr(mod, 'initialized')) def test_get_source(self): # Should always return None. result = machinery.FrozenImporter.get_source('__hello__') - self.assert_(result is None) + self.assertTrue(result is None) def test_is_package(self): # Should be able to tell what is a package. @@ -78,7 +78,7 @@ class InspectLoaderTests(unittest.TestCase): ('__phello__.spam', False)) for name, is_package in test_for: result = machinery.FrozenImporter.is_package(name) - self.assert_(bool(result) == is_package) + self.assertTrue(bool(result) == is_package) def test_failure(self): # Raise ImportError for modules that are not frozen. diff --git a/Lib/importlib/test/import_/test_caching.py b/Lib/importlib/test/import_/test_caching.py index e37c69a..cf65b23 100644 --- a/Lib/importlib/test/import_/test_caching.py +++ b/Lib/importlib/test/import_/test_caching.py @@ -53,8 +53,8 @@ class UseCache(unittest.TestCase): with self.create_mock('pkg.__init__', 'pkg.module') as importer: with util.import_state(meta_path=[importer]): module = import_util.import_('pkg.module') - self.assert_(hasattr(module, 'module')) - self.assert_(id(module.module), id(sys.modules['pkg.module'])) + self.assertTrue(hasattr(module, 'module')) + self.assertTrue(id(module.module), id(sys.modules['pkg.module'])) # See test_using_cache_after_loader() for reasoning. @import_util.importlib_only @@ -63,7 +63,7 @@ class UseCache(unittest.TestCase): with self.create_mock('pkg.__init__', 'pkg.module') as importer: with util.import_state(meta_path=[importer]): module = import_util.import_('pkg', fromlist=['module']) - self.assert_(hasattr(module, 'module')) + self.assertTrue(hasattr(module, 'module')) self.assertEquals(id(module.module), id(sys.modules['pkg.module'])) diff --git a/Lib/importlib/test/import_/test_fromlist.py b/Lib/importlib/test/import_/test_fromlist.py index 266a495..340235b 100644 --- a/Lib/importlib/test/import_/test_fromlist.py +++ b/Lib/importlib/test/import_/test_fromlist.py @@ -59,7 +59,7 @@ class HandlingFromlist(unittest.TestCase): with util.import_state(meta_path=[importer]): module = import_util.import_('module', fromlist=['non_existent']) self.assertEquals(module.__name__, 'module') - self.assert_(not hasattr(module, 'non_existent')) + self.assertTrue(not hasattr(module, 'non_existent')) def test_module_from_package(self): # [module] @@ -67,7 +67,7 @@ class HandlingFromlist(unittest.TestCase): with util.import_state(meta_path=[importer]): module = import_util.import_('pkg', fromlist=['module']) self.assertEquals(module.__name__, 'pkg') - self.assert_(hasattr(module, 'module')) + self.assertTrue(hasattr(module, 'module')) self.assertEquals(module.module.__name__, 'pkg.module') def test_no_module_from_package(self): @@ -76,7 +76,7 @@ class HandlingFromlist(unittest.TestCase): with util.import_state(meta_path=[importer]): module = import_util.import_('pkg', fromlist='non_existent') self.assertEquals(module.__name__, 'pkg') - self.assert_(not hasattr(module, 'non_existent')) + self.assertTrue(not hasattr(module, 'non_existent')) def test_empty_string(self): with util.mock_modules('pkg.__init__', 'pkg.mod') as importer: @@ -91,7 +91,7 @@ class HandlingFromlist(unittest.TestCase): mock['pkg'].__all__ = ['module'] module = import_util.import_('pkg', fromlist=['*']) self.assertEquals(module.__name__, 'pkg') - self.assert_(hasattr(module, 'module')) + self.assertTrue(hasattr(module, 'module')) self.assertEqual(module.module.__name__, 'pkg.module') def test_star_with_others(self): @@ -102,8 +102,8 @@ class HandlingFromlist(unittest.TestCase): mock['pkg'].__all__ = ['module1'] module = import_util.import_('pkg', fromlist=['module2', '*']) self.assertEquals(module.__name__, 'pkg') - self.assert_(hasattr(module, 'module1')) - self.assert_(hasattr(module, 'module2')) + self.assertTrue(hasattr(module, 'module1')) + self.assertTrue(hasattr(module, 'module2')) self.assertEquals(module.module1.__name__, 'pkg.module1') self.assertEquals(module.module2.__name__, 'pkg.module2') diff --git a/Lib/importlib/test/import_/test_meta_path.py b/Lib/importlib/test/import_/test_meta_path.py index 69859b1..5486694 100644 --- a/Lib/importlib/test/import_/test_meta_path.py +++ b/Lib/importlib/test/import_/test_meta_path.py @@ -64,7 +64,7 @@ class CallSignature(unittest.TestCase): self.assertEquals(len(args), 2) self.assertEquals(len(kwargs), 0) self.assertEquals(args[0], mod_name) - self.assert_(args[1] is None) + self.assertTrue(args[1] is None) def test_with_path(self): # [path set] @@ -82,9 +82,9 @@ class CallSignature(unittest.TestCase): args = log[1][0] kwargs = log[1][1] # Assuming all arguments are positional. - self.assert_(not kwargs) + self.assertTrue(not kwargs) self.assertEquals(args[0], mod_name) - self.assert_(args[1] is path) + self.assertTrue(args[1] is path) diff --git a/Lib/importlib/test/import_/test_packages.py b/Lib/importlib/test/import_/test_packages.py index 5912c1f..b41c36f 100644 --- a/Lib/importlib/test/import_/test_packages.py +++ b/Lib/importlib/test/import_/test_packages.py @@ -13,7 +13,7 @@ class ParentModuleTests(unittest.TestCase): with util.mock_modules('pkg.__init__', 'pkg.module') as mock: with util.import_state(meta_path=[mock]): module = import_util.import_('pkg.module') - self.assert_('pkg' in sys.modules) + self.assertTrue('pkg' in sys.modules) def test_bad_parent(self): with util.mock_modules('pkg.module') as mock: diff --git a/Lib/importlib/test/import_/test_path.py b/Lib/importlib/test/import_/test_path.py index ede9b5f..0e055b1 100644 --- a/Lib/importlib/test/import_/test_path.py +++ b/Lib/importlib/test/import_/test_path.py @@ -19,7 +19,7 @@ class FinderTests(unittest.TestCase): # Test None returned upon not finding a suitable finder. module = '' with util.import_state(): - self.assert_(machinery.PathFinder.find_module(module) is None) + self.assertTrue(machinery.PathFinder.find_module(module) is None) def test_sys_path(self): # Test that sys.path is used when 'path' is None. @@ -30,7 +30,7 @@ class FinderTests(unittest.TestCase): with util.import_state(path_importer_cache={path: importer}, path=[path]): loader = machinery.PathFinder.find_module(module) - self.assert_(loader is importer) + self.assertTrue(loader is importer) def test_path(self): # Test that 'path' is used when set. @@ -40,7 +40,7 @@ class FinderTests(unittest.TestCase): importer = util.mock_modules(module) with util.import_state(path_importer_cache={path: importer}): loader = machinery.PathFinder.find_module(module, [path]) - self.assert_(loader is importer) + self.assertTrue(loader is importer) def test_path_hooks(self): # Test that sys.path_hooks is used. @@ -51,16 +51,16 @@ class FinderTests(unittest.TestCase): hook = import_util.mock_path_hook(path, importer=importer) with util.import_state(path_hooks=[hook]): loader = machinery.PathFinder.find_module(module, [path]) - self.assert_(loader is importer) - self.assert_(path in sys.path_importer_cache) - self.assert_(sys.path_importer_cache[path] is importer) + self.assertTrue(loader is importer) + self.assertTrue(path in sys.path_importer_cache) + self.assertTrue(sys.path_importer_cache[path] is importer) def test_path_importer_cache_has_None(self): # Test that if sys.path_importer_cache has None that None is returned. clear_cache = {path: None for path in sys.path} with util.import_state(path_importer_cache=clear_cache): for name in ('asynchat', 'sys', ''): - self.assert_(machinery.PathFinder.find_module(name) is None) + self.assertTrue(machinery.PathFinder.find_module(name) is None) def test_path_importer_cache_has_None_continues(self): # Test that having None in sys.path_importer_cache causes the search to @@ -71,7 +71,7 @@ class FinderTests(unittest.TestCase): with util.import_state(path=['1', '2'], path_importer_cache={'1': None, '2': importer}): loader = machinery.PathFinder.find_module(module) - self.assert_(loader is importer) + self.assertTrue(loader is importer) @@ -88,15 +88,15 @@ class DefaultPathFinderTests(unittest.TestCase): with util.import_state(): nothing = _bootstrap._DefaultPathFinder.find_module(module, path=[existing_path]) - self.assert_(nothing is None) - self.assert_(existing_path in sys.path_importer_cache) - self.assert_(not isinstance(sys.path_importer_cache[existing_path], + self.assertTrue(nothing is None) + self.assertTrue(existing_path in sys.path_importer_cache) + self.assertTrue(not isinstance(sys.path_importer_cache[existing_path], imp.NullImporter)) nothing = _bootstrap._DefaultPathFinder.find_module(module, path=[bad_path]) - self.assert_(nothing is None) - self.assert_(bad_path in sys.path_importer_cache) - self.assert_(isinstance(sys.path_importer_cache[bad_path], + self.assertTrue(nothing is None) + self.assertTrue(bad_path in sys.path_importer_cache) + self.assertTrue(isinstance(sys.path_importer_cache[bad_path], imp.NullImporter)) def test_path_importer_cache_has_None(self): @@ -113,7 +113,7 @@ class DefaultPathFinderTests(unittest.TestCase): with util.import_state(path_importer_cache={path: None}): loader = _bootstrap._DefaultPathFinder.find_module(module, path=[path]) - self.assert_(loader is importer) + self.assertTrue(loader is importer) finally: _bootstrap._DEFAULT_PATH_HOOK = original_hook diff --git a/Lib/importlib/test/import_/test_relative_imports.py b/Lib/importlib/test/import_/test_relative_imports.py index dca0699..5547d4c 100644 --- a/Lib/importlib/test/import_/test_relative_imports.py +++ b/Lib/importlib/test/import_/test_relative_imports.py @@ -79,7 +79,7 @@ class RelativeImports(unittest.TestCase): import_util.import_('pkg') # For __import__(). module = import_util.import_('', global_, fromlist=['mod2'], level=1) self.assertEqual(module.__name__, 'pkg') - self.assert_(hasattr(module, 'mod2')) + self.assertTrue(hasattr(module, 'mod2')) self.assertEqual(module.mod2.attr, 'pkg.mod2') self.relative_import_test(create, globals_, callback) @@ -105,7 +105,7 @@ class RelativeImports(unittest.TestCase): module = import_util.import_('', global_, fromlist=['module'], level=1) self.assertEqual(module.__name__, 'pkg') - self.assert_(hasattr(module, 'module')) + self.assertTrue(hasattr(module, 'module')) self.assertEqual(module.module.attr, 'pkg.module') self.relative_import_test(create, globals_, callback) @@ -129,7 +129,7 @@ class RelativeImports(unittest.TestCase): module = import_util.import_('', global_, fromlist=['subpkg2'], level=2) self.assertEqual(module.__name__, 'pkg') - self.assert_(hasattr(module, 'subpkg2')) + self.assertTrue(hasattr(module, 'subpkg2')) self.assertEqual(module.subpkg2.attr, 'pkg.subpkg2.__init__') def test_deep_import(self): diff --git a/Lib/importlib/test/source/test_abc_loader.py b/Lib/importlib/test/source/test_abc_loader.py index 9acc4ad..1ce83fb 100644 --- a/Lib/importlib/test/source/test_abc_loader.py +++ b/Lib/importlib/test/source/test_abc_loader.py @@ -133,10 +133,10 @@ class PyLoaderTests(testing_abc.LoaderTests): mock = self.mocker({name: path}) with util.uncache(name): module = mock.load_module(name) - self.assert_(name in sys.modules) + self.assertTrue(name in sys.modules) self.eq_attrs(module, __name__=name, __file__=path, __package__='', __loader__=mock) - self.assert_(not hasattr(module, '__path__')) + self.assertTrue(not hasattr(module, '__path__')) return mock, name def test_package(self): @@ -145,7 +145,7 @@ class PyLoaderTests(testing_abc.LoaderTests): mock = self.mocker({name: path}) with util.uncache(name): module = mock.load_module(name) - self.assert_(name in sys.modules) + self.assertTrue(name in sys.modules) self.eq_attrs(module, __name__=name, __file__=path, __path__=[os.path.dirname(path)], __package__=name, __loader__=mock) @@ -171,8 +171,8 @@ class PyLoaderTests(testing_abc.LoaderTests): with util.uncache(name): sys.modules[name] = module loaded_module = mock.load_module(name) - self.assert_(loaded_module is module) - self.assert_(sys.modules[name] is module) + self.assertTrue(loaded_module is module) + self.assertTrue(sys.modules[name] is module) return mock, name def test_state_after_failure(self): @@ -184,8 +184,8 @@ class PyLoaderTests(testing_abc.LoaderTests): with util.uncache(name): sys.modules[name] = module self.assertRaises(ZeroDivisionError, mock.load_module, name) - self.assert_(sys.modules[name] is module) - self.assert_(hasattr(module, 'blah')) + self.assertTrue(sys.modules[name] is module) + self.assertTrue(hasattr(module, 'blah')) return mock def test_unloadable(self): @@ -194,7 +194,7 @@ class PyLoaderTests(testing_abc.LoaderTests): mock.source = b"1/0" with util.uncache(name): self.assertRaises(ZeroDivisionError, mock.load_module, name) - self.assert_(name not in sys.modules) + self.assertTrue(name not in sys.modules) return mock @@ -293,7 +293,7 @@ class SkipWritingBytecodeTests(unittest.TestCase): sys.dont_write_bytecode = dont_write_bytecode with util.uncache(name): mock.load_module(name) - self.assert_((name in mock.module_bytecode) is not + self.assertTrue((name in mock.module_bytecode) is not dont_write_bytecode) def test_no_bytecode_written(self): @@ -319,7 +319,7 @@ class RegeneratedBytecodeTests(unittest.TestCase): 'magic': bad_magic}}) with util.uncache(name): mock.load_module(name) - self.assert_(name in mock.module_bytecode) + self.assertTrue(name in mock.module_bytecode) magic = mock.module_bytecode[name][:4] self.assertEqual(magic, imp.get_magic()) @@ -332,7 +332,7 @@ class RegeneratedBytecodeTests(unittest.TestCase): {name: {'path': 'path/to/mod.bytecode', 'mtime': old_mtime}}) with util.uncache(name): mock.load_module(name) - self.assert_(name in mock.module_bytecode) + self.assertTrue(name in mock.module_bytecode) mtime = importlib._r_long(mock.module_bytecode[name][4:8]) self.assertEqual(mtime, PyPycLoaderMock.default_mtime) diff --git a/Lib/importlib/test/source/test_file_loader.py b/Lib/importlib/test/source/test_file_loader.py index d01a2a7..0384e7d 100644 --- a/Lib/importlib/test/source/test_file_loader.py +++ b/Lib/importlib/test/source/test_file_loader.py @@ -23,7 +23,7 @@ class SimpleTest(unittest.TestCase): loader = _bootstrap._PyPycFileLoader('_temp', mapping['_temp'], False) module = loader.load_module('_temp') - self.assert_('_temp' in sys.modules) + self.assertTrue('_temp' in sys.modules) check = {'__name__': '_temp', '__file__': mapping['_temp'], '__package__': ''} for attr, value in check.items(): @@ -35,7 +35,7 @@ class SimpleTest(unittest.TestCase): mapping['_pkg.__init__'], True) module = loader.load_module('_pkg') - self.assert_('_pkg' in sys.modules) + self.assertTrue('_pkg' in sys.modules) check = {'__name__': '_pkg', '__file__': mapping['_pkg.__init__'], '__path__': [os.path.dirname(mapping['_pkg.__init__'])], '__package__': '_pkg'} @@ -48,7 +48,7 @@ class SimpleTest(unittest.TestCase): loader = _bootstrap._PyPycFileLoader('_pkg.mod', mapping['_pkg.mod'], False) module = loader.load_module('_pkg.mod') - self.assert_('_pkg.mod' in sys.modules) + self.assertTrue('_pkg.mod' in sys.modules) check = {'__name__': '_pkg.mod', '__file__': mapping['_pkg.mod'], '__package__': '_pkg'} for attr, value in check.items(): @@ -73,7 +73,7 @@ class SimpleTest(unittest.TestCase): # than the original mtime. loader.source_mtime = self.fake_mtime(loader.source_mtime) module = loader.load_module('_temp') - self.assert_('testing_var' in module.__dict__, + self.assertTrue('testing_var' in module.__dict__, "'testing_var' not in " "{0}".format(list(module.__dict__.keys()))) self.assertEqual(module, sys.modules['_temp']) @@ -105,7 +105,7 @@ class SimpleTest(unittest.TestCase): loader = _bootstrap._PyPycFileLoader('_temp', mapping['_temp'], False) self.assertRaises(SyntaxError, loader.load_module, '_temp') - self.assert_('_temp' not in sys.modules) + self.assertTrue('_temp' not in sys.modules) class BadBytecodeTest(unittest.TestCase): @@ -124,7 +124,7 @@ class BadBytecodeTest(unittest.TestCase): def import_(self, file, module_name): loader = _bootstrap._PyPycFileLoader(module_name, file, False) module = loader.load_module(module_name) - self.assert_(module_name in sys.modules) + self.assertTrue(module_name in sys.modules) # [bad magic] @source_util.writes_bytecode_files @@ -168,7 +168,7 @@ class BadBytecodeTest(unittest.TestCase): bytecode_file.write(b'AAAA') self.assertRaises(ValueError, self.import_, mapping['_temp'], '_temp') - self.assert_('_temp' not in sys.modules) + self.assertTrue('_temp' not in sys.modules) def test_main(): diff --git a/Lib/importlib/test/source/test_finder.py b/Lib/importlib/test/source/test_finder.py index dd56429..c495c5a 100644 --- a/Lib/importlib/test/source/test_finder.py +++ b/Lib/importlib/test/source/test_finder.py @@ -53,7 +53,7 @@ class FinderTests(abc.FinderTests): for name in unlink: os.unlink(mapping[name]) loader = self.import_(mapping['.root'], test) - self.assert_(hasattr(loader, 'load_module')) + self.assertTrue(hasattr(loader, 'load_module')) return loader def test_module(self): @@ -79,7 +79,7 @@ class FinderTests(abc.FinderTests): with source_util.create_modules('pkg.__init__', 'pkg.sub') as mapping: pkg_dir = os.path.dirname(mapping['pkg.__init__']) loader = self.import_(pkg_dir, 'pkg.sub') - self.assert_(hasattr(loader, 'load_module')) + self.assertTrue(hasattr(loader, 'load_module')) # [sub package] def test_package_in_package(self): @@ -87,7 +87,7 @@ class FinderTests(abc.FinderTests): with context as mapping: pkg_dir = os.path.dirname(mapping['pkg.__init__']) loader = self.import_(pkg_dir, 'pkg.sub') - self.assert_(hasattr(loader, 'load_module')) + self.assertTrue(hasattr(loader, 'load_module')) # [sub empty] def test_empty_sub_directory(self): @@ -105,13 +105,13 @@ class FinderTests(abc.FinderTests): # XXX This is not a blackbox test! name = '_temp' loader = self.run_test(name, {'{0}.__init__'.format(name), name}) - self.assert_('__init__' in loader._base_path) + self.assertTrue('__init__' in loader._base_path) def test_failure(self): with source_util.create_modules('blah') as mapping: nothing = self.import_(mapping['.root'], 'sdfsadsadf') - self.assert_(nothing is None) + self.assertTrue(nothing is None) # [empty dir] def test_empty_dir(self): diff --git a/Lib/importlib/test/source/test_path_hook.py b/Lib/importlib/test/source/test_path_hook.py index 71ca508..3efb3be 100644 --- a/Lib/importlib/test/source/test_path_hook.py +++ b/Lib/importlib/test/source/test_path_hook.py @@ -10,7 +10,7 @@ class PathHookTest(unittest.TestCase): def test_success(self): # XXX Only work on existing directories? with source_util.create_modules('dummy') as mapping: - self.assert_(hasattr(_bootstrap._FileFinder(mapping['.root']), + self.assertTrue(hasattr(_bootstrap._FileFinder(mapping['.root']), 'find_module')) diff --git a/Lib/importlib/test/test_util.py b/Lib/importlib/test/test_util.py index 706128a..406477d 100644 --- a/Lib/importlib/test/test_util.py +++ b/Lib/importlib/test/test_util.py @@ -29,8 +29,8 @@ class ModuleForLoaderTests(unittest.TestCase): module_name = 'a.b.c' with test_util.uncache(module_name): module = self.return_module(module_name) - self.assert_(module_name in sys.modules) - self.assert_(isinstance(module, types.ModuleType)) + self.assertTrue(module_name in sys.modules) + self.assertTrue(isinstance(module, types.ModuleType)) self.assertEqual(module.__name__, module_name) def test_reload(self): @@ -40,7 +40,7 @@ class ModuleForLoaderTests(unittest.TestCase): with test_util.uncache(name): sys.modules[name] = module returned_module = self.return_module(name) - self.assert_(sys.modules[name] is returned_module) + self.assertTrue(sys.modules[name] is returned_module) def test_new_module_failure(self): # Test that a module is removed from sys.modules if added but an @@ -48,7 +48,7 @@ class ModuleForLoaderTests(unittest.TestCase): name = 'a.b.c' with test_util.uncache(name): self.raise_exception(name) - self.assert_(name not in sys.modules) + self.assertTrue(name not in sys.modules) def test_reload_failure(self): # Test that a failure on reload leaves the module in-place. @@ -57,7 +57,7 @@ class ModuleForLoaderTests(unittest.TestCase): with test_util.uncache(name): sys.modules[name] = module self.raise_exception(name) - self.assert_(sys.modules[name] is module) + self.assertTrue(sys.modules[name] is module) class SetPackageTests(unittest.TestCase): @@ -71,7 +71,7 @@ class SetPackageTests(unittest.TestCase): fxn = lambda: module wrapped = util.set_package(fxn) wrapped() - self.assert_(hasattr(module, '__package__')) + self.assertTrue(hasattr(module, '__package__')) self.assertEqual(expect, module.__package__) def test_top_level(self): diff --git a/Lib/json/tests/test_decode.py b/Lib/json/tests/test_decode.py index 78e7e07..4610c6c 100644 --- a/Lib/json/tests/test_decode.py +++ b/Lib/json/tests/test_decode.py @@ -8,12 +8,12 @@ from collections import OrderedDict class TestDecode(TestCase): def test_decimal(self): rval = json.loads('1.1', parse_float=decimal.Decimal) - self.assert_(isinstance(rval, decimal.Decimal)) + self.assertTrue(isinstance(rval, decimal.Decimal)) self.assertEquals(rval, decimal.Decimal('1.1')) def test_float(self): rval = json.loads('1', parse_int=float) - self.assert_(isinstance(rval, float)) + self.assertTrue(isinstance(rval, float)) self.assertEquals(rval, 1.0) def test_object_pairs_hook(self): diff --git a/Lib/json/tests/test_speedups.py b/Lib/json/tests/test_speedups.py index 8ff9a38..3a84ddf 100644 --- a/Lib/json/tests/test_speedups.py +++ b/Lib/json/tests/test_speedups.py @@ -7,9 +7,9 @@ from json import encoder class TestSpeedups(TestCase): def test_scanstring(self): self.assertEquals(decoder.scanstring.__module__, "_json") - self.assert_(decoder.scanstring is decoder.c_scanstring) + self.assertTrue(decoder.scanstring is decoder.c_scanstring) def test_encode_basestring_ascii(self): self.assertEquals(encoder.encode_basestring_ascii.__module__, "_json") - self.assert_(encoder.encode_basestring_ascii is + self.assertTrue(encoder.encode_basestring_ascii is encoder.c_encode_basestring_ascii) diff --git a/Lib/test/mapping_tests.py b/Lib/test/mapping_tests.py index b8bbc9a..c34bd59 100644 --- a/Lib/test/mapping_tests.py +++ b/Lib/test/mapping_tests.py @@ -50,15 +50,15 @@ class BasicTestMappingProtocol(unittest.TestCase): for key, value in self.reference.items(): self.assertEqual(d[key], value) knownkey = list(self.other.keys())[0] - self.failUnlessRaises(KeyError, lambda:d[knownkey]) + self.assertRaises(KeyError, lambda:d[knownkey]) #len self.assertEqual(len(p), 0) self.assertEqual(len(d), len(self.reference)) #__contains__ for k in self.reference: - self.assert_(k in d) + self.assertTrue(k in d) for k in self.other: - self.failIf(k in d) + self.assertFalse(k in d) #cmp self.assertEqual(p, p) self.assertEqual(d, d) @@ -69,10 +69,10 @@ class BasicTestMappingProtocol(unittest.TestCase): if not d: self.fail("Full mapping must compare to True") # keys(), items(), iterkeys() ... def check_iterandlist(iter, lst, ref): - self.assert_(hasattr(iter, '__next__')) - self.assert_(hasattr(iter, '__iter__')) + self.assertTrue(hasattr(iter, '__next__')) + self.assertTrue(hasattr(iter, '__iter__')) x = list(iter) - self.assert_(set(x)==set(lst)==set(ref)) + self.assertTrue(set(x)==set(lst)==set(ref)) check_iterandlist(iter(d.keys()), list(d.keys()), self.reference.keys()) check_iterandlist(iter(d), list(d.keys()), self.reference.keys()) @@ -85,7 +85,7 @@ class BasicTestMappingProtocol(unittest.TestCase): knownkey, knownvalue = next(iter(self.other.items())) self.assertEqual(d.get(key, knownvalue), value) self.assertEqual(d.get(knownkey, knownvalue), knownvalue) - self.failIf(knownkey in d) + self.assertFalse(knownkey in d) def test_write(self): # Test for write operations on mapping @@ -96,7 +96,7 @@ class BasicTestMappingProtocol(unittest.TestCase): self.assertEqual(p[key], value) for key in self.reference.keys(): del p[key] - self.failUnlessRaises(KeyError, lambda:p[key]) + self.assertRaises(KeyError, lambda:p[key]) p = self._empty_mapping() #update p.update(self.reference) @@ -115,16 +115,16 @@ class BasicTestMappingProtocol(unittest.TestCase): self.assertEqual(d[knownkey], knownvalue) #pop self.assertEqual(d.pop(knownkey), knownvalue) - self.failIf(knownkey in d) + self.assertFalse(knownkey in d) self.assertRaises(KeyError, d.pop, knownkey) default = 909 d[knownkey] = knownvalue self.assertEqual(d.pop(knownkey, default), knownvalue) - self.failIf(knownkey in d) + self.assertFalse(knownkey in d) self.assertEqual(d.pop(knownkey, default), default) #popitem key, value = d.popitem() - self.failIf(key in d) + self.assertFalse(key in d) self.assertEqual(value, self.reference[key]) p=self._empty_mapping() self.assertRaises(KeyError, p.popitem) @@ -133,17 +133,17 @@ class BasicTestMappingProtocol(unittest.TestCase): self.assertEqual(self._empty_mapping(), self._empty_mapping()) def test_bool(self): - self.assert_(not self._empty_mapping()) - self.assert_(self.reference) - self.assert_(bool(self._empty_mapping()) is False) - self.assert_(bool(self.reference) is True) + self.assertTrue(not self._empty_mapping()) + self.assertTrue(self.reference) + self.assertTrue(bool(self._empty_mapping()) is False) + self.assertTrue(bool(self.reference) is True) def test_keys(self): d = self._empty_mapping() self.assertEqual(list(d.keys()), []) d = self.reference - self.assert_(list(self.inmapping.keys())[0] in d.keys()) - self.assert_(list(self.other.keys())[0] not in d.keys()) + self.assertTrue(list(self.inmapping.keys())[0] in d.keys()) + self.assertTrue(list(self.other.keys())[0] not in d.keys()) self.assertRaises(TypeError, d.keys, None) def test_values(self): @@ -268,10 +268,10 @@ class BasicTestMappingProtocol(unittest.TestCase): def test_get(self): d = self._empty_mapping() - self.assert_(d.get(list(self.other.keys())[0]) is None) + self.assertTrue(d.get(list(self.other.keys())[0]) is None) self.assertEqual(d.get(list(self.other.keys())[0], 3), 3) d = self.reference - self.assert_(d.get(list(self.other.keys())[0]) is None) + self.assertTrue(d.get(list(self.other.keys())[0]) is None) self.assertEqual(d.get(list(self.other.keys())[0], 3), 3) self.assertEqual(d.get(list(self.inmapping.keys())[0]), list(self.inmapping.values())[0]) @@ -304,15 +304,15 @@ class BasicTestMappingProtocol(unittest.TestCase): class TestMappingProtocol(BasicTestMappingProtocol): def test_constructor(self): BasicTestMappingProtocol.test_constructor(self) - self.assert_(self._empty_mapping() is not self._empty_mapping()) + self.assertTrue(self._empty_mapping() is not self._empty_mapping()) self.assertEqual(self.type2test(x=1, y=2), {"x": 1, "y": 2}) def test_bool(self): BasicTestMappingProtocol.test_bool(self) - self.assert_(not self._empty_mapping()) - self.assert_(self._full_mapping({"x": "y"})) - self.assert_(bool(self._empty_mapping()) is False) - self.assert_(bool(self._full_mapping({"x": "y"})) is True) + self.assertTrue(not self._empty_mapping()) + self.assertTrue(self._full_mapping({"x": "y"})) + self.assertTrue(bool(self._empty_mapping()) is False) + self.assertTrue(bool(self._full_mapping({"x": "y"})) is True) def test_keys(self): BasicTestMappingProtocol.test_keys(self) @@ -320,9 +320,9 @@ class TestMappingProtocol(BasicTestMappingProtocol): self.assertEqual(list(d.keys()), []) d = self._full_mapping({'a': 1, 'b': 2}) k = d.keys() - self.assert_('a' in k) - self.assert_('b' in k) - self.assert_('c' not in k) + self.assertTrue('a' in k) + self.assertTrue('b' in k) + self.assertTrue('c' not in k) def test_values(self): BasicTestMappingProtocol.test_values(self) @@ -337,12 +337,12 @@ class TestMappingProtocol(BasicTestMappingProtocol): def test_contains(self): d = self._empty_mapping() - self.assert_(not ('a' in d)) - self.assert_('a' not in d) + self.assertTrue(not ('a' in d)) + self.assertTrue('a' not in d) d = self._full_mapping({'a': 1, 'b': 2}) - self.assert_('a' in d) - self.assert_('b' in d) - self.assert_('c' not in d) + self.assertTrue('a' in d) + self.assertTrue('b' in d) + self.assertTrue('c' not in d) self.assertRaises(TypeError, d.__contains__) @@ -421,7 +421,7 @@ class TestMappingProtocol(BasicTestMappingProtocol): def test_fromkeys(self): self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) d = self._empty_mapping() - self.assert_(not(d.fromkeys('abc') is d)) + self.assertTrue(not(d.fromkeys('abc') is d)) self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0}) self.assertEqual(d.fromkeys([]), {}) @@ -432,17 +432,17 @@ class TestMappingProtocol(BasicTestMappingProtocol): class dictlike(self.type2test): pass self.assertEqual(dictlike.fromkeys('a'), {'a':None}) self.assertEqual(dictlike().fromkeys('a'), {'a':None}) - self.assert_(dictlike.fromkeys('a').__class__ is dictlike) - self.assert_(dictlike().fromkeys('a').__class__ is dictlike) + self.assertTrue(dictlike.fromkeys('a').__class__ is dictlike) + self.assertTrue(dictlike().fromkeys('a').__class__ is dictlike) # FIXME: the following won't work with UserDict, because it's an old style class - # self.assert_(type(dictlike.fromkeys('a')) is dictlike) + # self.assertTrue(type(dictlike.fromkeys('a')) is dictlike) class mydict(self.type2test): def __new__(cls): return collections.UserDict() ud = mydict.fromkeys('ab') self.assertEqual(ud, {'a':None, 'b':None}) # FIXME: the following won't work with UserDict, because it's an old style class - # self.assert_(isinstance(ud, collections.UserDict)) + # self.assertTrue(isinstance(ud, collections.UserDict)) self.assertRaises(TypeError, dict.fromkeys) class Exc(Exception): pass @@ -472,16 +472,16 @@ class TestMappingProtocol(BasicTestMappingProtocol): self.assertEqual(d.copy(), {1:1, 2:2, 3:3}) d = self._empty_mapping() self.assertEqual(d.copy(), d) - self.assert_(isinstance(d.copy(), d.__class__)) + self.assertTrue(isinstance(d.copy(), d.__class__)) self.assertRaises(TypeError, d.copy, None) def test_get(self): BasicTestMappingProtocol.test_get(self) d = self._empty_mapping() - self.assert_(d.get('c') is None) + self.assertTrue(d.get('c') is None) self.assertEqual(d.get('c', 3), 3) d = self._full_mapping({'a' : 1, 'b' : 2}) - self.assert_(d.get('c') is None) + self.assertTrue(d.get('c') is None) self.assertEqual(d.get('c', 3), 3) self.assertEqual(d.get('a'), 1) self.assertEqual(d.get('a', 3), 1) @@ -489,9 +489,9 @@ class TestMappingProtocol(BasicTestMappingProtocol): def test_setdefault(self): BasicTestMappingProtocol.test_setdefault(self) d = self._empty_mapping() - self.assert_(d.setdefault('key0') is None) + self.assertTrue(d.setdefault('key0') is None) d.setdefault('key0', []) - self.assert_(d.setdefault('key0') is None) + self.assertTrue(d.setdefault('key0') is None) d.setdefault('key', []).append(3) self.assertEqual(d['key'][0], 3) d.setdefault('key', []).append(4) @@ -517,9 +517,9 @@ class TestMappingProtocol(BasicTestMappingProtocol): self.assertEqual(va, int(ka)) kb, vb = tb = b.popitem() self.assertEqual(vb, int(kb)) - self.assert_(not(copymode < 0 and ta != tb)) - self.assert_(not a) - self.assert_(not b) + self.assertTrue(not(copymode < 0 and ta != tb)) + self.assertTrue(not a) + self.assertTrue(not b) def test_pop(self): BasicTestMappingProtocol.test_pop(self) @@ -577,7 +577,7 @@ class TestHashMappingProtocol(TestMappingProtocol): return collections.UserDict() ud = mydict.fromkeys('ab') self.assertEqual(ud, {'a':None, 'b':None}) - self.assert_(isinstance(ud, collections.UserDict)) + self.assertTrue(isinstance(ud, collections.UserDict)) def test_pop(self): TestMappingProtocol.test_pop(self) diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py index 3ed26b8..19704ae 100644 --- a/Lib/test/pickletester.py +++ b/Lib/test/pickletester.py @@ -449,7 +449,7 @@ class AbstractPickleTests(unittest.TestCase): s = self.dumps(l, proto) x = self.loads(s) self.assertEqual(len(x), 1) - self.assert_(x is x[0]) + self.assertTrue(x is x[0]) def test_recursive_tuple(self): t = ([],) @@ -459,7 +459,7 @@ class AbstractPickleTests(unittest.TestCase): x = self.loads(s) self.assertEqual(len(x), 1) self.assertEqual(len(x[0]), 1) - self.assert_(x is x[0][0]) + self.assertTrue(x is x[0][0]) def test_recursive_dict(self): d = {} @@ -468,7 +468,7 @@ class AbstractPickleTests(unittest.TestCase): s = self.dumps(d, proto) x = self.loads(s) self.assertEqual(list(x.keys()), [1]) - self.assert_(x[1] is x) + self.assertTrue(x[1] is x) def test_recursive_inst(self): i = C() @@ -477,7 +477,7 @@ class AbstractPickleTests(unittest.TestCase): s = self.dumps(i, 2) x = self.loads(s) self.assertEqual(dir(x), dir(i)) - self.assert_(x.attr is x) + self.assertTrue(x.attr is x) def test_recursive_multi(self): l = [] @@ -491,7 +491,7 @@ class AbstractPickleTests(unittest.TestCase): self.assertEqual(len(x), 1) self.assertEqual(dir(x[0]), dir(i)) self.assertEqual(list(x[0].attr.keys()), [1]) - self.assert_(x[0].attr[1] is x) + self.assertTrue(x[0].attr[1] is x) def test_get(self): self.assertRaises(KeyError, self.loads, b'g0\np0') @@ -639,7 +639,7 @@ class AbstractPickleTests(unittest.TestCase): try: self.loads(badpickle) except ValueError as detail: - self.failUnless(str(detail).startswith( + self.assertTrue(str(detail).startswith( "unsupported pickle protocol")) else: self.fail("expected bad protocol number to raise ValueError") @@ -720,7 +720,7 @@ class AbstractPickleTests(unittest.TestCase): for x in None, False, True: s = self.dumps(x, proto) y = self.loads(s) - self.assert_(x is y, (proto, x, s, y)) + self.assertTrue(x is y, (proto, x, s, y)) expected = expected_opcode[proto, x] self.assertEqual(opcode_in_pickle(expected, s), True) @@ -770,8 +770,8 @@ class AbstractPickleTests(unittest.TestCase): # Dump using protocol 1 for comparison. s1 = self.dumps(x, 1) - self.assert_(__name__.encode("utf-8") in s1) - self.assert_(b"MyList" in s1) + self.assertTrue(__name__.encode("utf-8") in s1) + self.assertTrue(b"MyList" in s1) self.assertEqual(opcode_in_pickle(opcode, s1), False) y = self.loads(s1) @@ -780,8 +780,8 @@ class AbstractPickleTests(unittest.TestCase): # Dump using protocol 2 for test. s2 = self.dumps(x, 2) - self.assert_(__name__.encode("utf-8") not in s2) - self.assert_(b"MyList" not in s2) + self.assertTrue(__name__.encode("utf-8") not in s2) + self.assertTrue(b"MyList" not in s2) self.assertEqual(opcode_in_pickle(opcode, s2), True, repr(s2)) y = self.loads(s2) @@ -825,7 +825,7 @@ class AbstractPickleTests(unittest.TestCase): if proto == 0: self.assertEqual(num_appends, 0) else: - self.failUnless(num_appends >= 2) + self.assertTrue(num_appends >= 2) def test_dict_chunking(self): n = 10 # too small to chunk @@ -848,7 +848,7 @@ class AbstractPickleTests(unittest.TestCase): if proto == 0: self.assertEqual(num_setitems, 0) else: - self.failUnless(num_setitems >= 2) + self.assertTrue(num_setitems >= 2) def test_simple_newobj(self): x = object.__new__(SimpleNewObj) # avoid __init__ diff --git a/Lib/test/test___all__.py b/Lib/test/test___all__.py index 4b56749..8ebe568 100644 --- a/Lib/test/test___all__.py +++ b/Lib/test/test___all__.py @@ -17,7 +17,7 @@ class AllTest(unittest.TestCase): # Silent fail here seems the best route since some modules # may not be available in all environments. return - self.failUnless(hasattr(sys.modules[modname], "__all__"), + self.assertTrue(hasattr(sys.modules[modname], "__all__"), "%s has no __all__ attribute" % modname) names = {} exec("from %s import *" % modname, names) diff --git a/Lib/test/test___future__.py b/Lib/test/test___future__.py index 9d98746..f41b879 100644 --- a/Lib/test/test___future__.py +++ b/Lib/test/test___future__.py @@ -15,7 +15,7 @@ class FutureTest(unittest.TestCase): for name in dir(__future__): obj = getattr(__future__, name, None) if obj is not None and isinstance(obj, __future__._Feature): - self.assert_( + self.assertTrue( name in given_feature_names, "%r should have been in all_feature_names" % name ) @@ -30,7 +30,7 @@ class FutureTest(unittest.TestCase): optional = value.getOptionalRelease() mandatory = value.getMandatoryRelease() - a = self.assert_ + a = self.assertTrue e = self.assertEqual def check(t, name): a(isinstance(t, tuple), "%s isn't tuple" % name) diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py index 4965c42..c3482d6 100644 --- a/Lib/test/test_abc.py +++ b/Lib/test/test_abc.py @@ -42,23 +42,23 @@ class TestABC(unittest.TestCase): def bar(self): pass # concrete self.assertEqual(C.__abstractmethods__, {"foo"}) self.assertRaises(TypeError, C) # because foo is abstract - self.assert_(isabstract(C)) + self.assertTrue(isabstract(C)) class D(C): def bar(self): pass # concrete override of concrete self.assertEqual(D.__abstractmethods__, {"foo"}) self.assertRaises(TypeError, D) # because foo is still abstract - self.assert_(isabstract(D)) + self.assertTrue(isabstract(D)) class E(D): def foo(self): pass self.assertEqual(E.__abstractmethods__, set()) E() # now foo is concrete, too - self.failIf(isabstract(E)) + self.assertFalse(isabstract(E)) class F(E): @abstractthing def bar(self): pass # abstract override of concrete self.assertEqual(F.__abstractmethods__, {"bar"}) self.assertRaises(TypeError, F) # because bar is abstract now - self.assert_(isabstract(F)) + self.assertTrue(isabstract(F)) def test_subclass_oldstyle_class(self): class A: @@ -142,41 +142,41 @@ class TestABC(unittest.TestCase): def test_registration_transitiveness(self): class A(metaclass=abc.ABCMeta): pass - self.failUnless(issubclass(A, A)) - self.failUnless(issubclass(A, (A,))) + self.assertTrue(issubclass(A, A)) + self.assertTrue(issubclass(A, (A,))) class B(metaclass=abc.ABCMeta): pass - self.failIf(issubclass(A, B)) - self.failIf(issubclass(A, (B,))) - self.failIf(issubclass(B, A)) - self.failIf(issubclass(B, (A,))) + self.assertFalse(issubclass(A, B)) + self.assertFalse(issubclass(A, (B,))) + self.assertFalse(issubclass(B, A)) + self.assertFalse(issubclass(B, (A,))) class C(metaclass=abc.ABCMeta): pass A.register(B) class B1(B): pass - self.failUnless(issubclass(B1, A)) - self.failUnless(issubclass(B1, (A,))) + self.assertTrue(issubclass(B1, A)) + self.assertTrue(issubclass(B1, (A,))) class C1(C): pass B1.register(C1) - self.failIf(issubclass(C, B)) - self.failIf(issubclass(C, (B,))) - self.failIf(issubclass(C, B1)) - self.failIf(issubclass(C, (B1,))) - self.failUnless(issubclass(C1, A)) - self.failUnless(issubclass(C1, (A,))) - self.failUnless(issubclass(C1, B)) - self.failUnless(issubclass(C1, (B,))) - self.failUnless(issubclass(C1, B1)) - self.failUnless(issubclass(C1, (B1,))) + self.assertFalse(issubclass(C, B)) + self.assertFalse(issubclass(C, (B,))) + self.assertFalse(issubclass(C, B1)) + self.assertFalse(issubclass(C, (B1,))) + self.assertTrue(issubclass(C1, A)) + self.assertTrue(issubclass(C1, (A,))) + self.assertTrue(issubclass(C1, B)) + self.assertTrue(issubclass(C1, (B,))) + self.assertTrue(issubclass(C1, B1)) + self.assertTrue(issubclass(C1, (B1,))) C1.register(int) class MyInt(int): pass - self.failUnless(issubclass(MyInt, A)) - self.failUnless(issubclass(MyInt, (A,))) - self.failUnless(isinstance(42, A)) - self.failUnless(isinstance(42, (A,))) + self.assertTrue(issubclass(MyInt, A)) + self.assertTrue(issubclass(MyInt, (A,))) + self.assertTrue(isinstance(42, A)) + self.assertTrue(isinstance(42, (A,))) def test_all_new_methods_are_called(self): class A(metaclass=abc.ABCMeta): diff --git a/Lib/test/test_abstract_numbers.py b/Lib/test/test_abstract_numbers.py index e20f2d4..d0164c0 100644 --- a/Lib/test/test_abstract_numbers.py +++ b/Lib/test/test_abstract_numbers.py @@ -9,8 +9,8 @@ from test import support class TestNumbers(unittest.TestCase): def test_int(self): - self.failUnless(issubclass(int, Integral)) - self.failUnless(issubclass(int, Complex)) + self.assertTrue(issubclass(int, Integral)) + self.assertTrue(issubclass(int, Complex)) self.assertEqual(7, int(7).real) self.assertEqual(0, int(7).imag) @@ -19,16 +19,16 @@ class TestNumbers(unittest.TestCase): self.assertEqual(1, int(7).denominator) def test_float(self): - self.failIf(issubclass(float, Rational)) - self.failUnless(issubclass(float, Real)) + self.assertFalse(issubclass(float, Rational)) + self.assertTrue(issubclass(float, Real)) self.assertEqual(7.3, float(7.3).real) self.assertEqual(0, float(7.3).imag) self.assertEqual(7.3, float(7.3).conjugate()) def test_complex(self): - self.failIf(issubclass(complex, Real)) - self.failUnless(issubclass(complex, Complex)) + self.assertFalse(issubclass(complex, Real)) + self.assertTrue(issubclass(complex, Complex)) c1, c2 = complex(3, 2), complex(4,1) # XXX: This is not ideal, but see the comment in math_trunc(). diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py index 8e22839..7ae34a9 100755 --- a/Lib/test/test_array.py +++ b/Lib/test/test_array.py @@ -49,7 +49,7 @@ class BaseTest(unittest.TestCase): def test_constructor(self): a = array.array(self.typecode) self.assertEqual(a.typecode, self.typecode) - self.assert_(a.itemsize>=self.minitemsize) + self.assertTrue(a.itemsize>=self.minitemsize) self.assertRaises(TypeError, array.array, self.typecode, None) def test_len(self): @@ -64,10 +64,10 @@ class BaseTest(unittest.TestCase): a = array.array(self.typecode, self.example) self.assertRaises(TypeError, a.buffer_info, 42) bi = a.buffer_info() - self.assert_(isinstance(bi, tuple)) + self.assertTrue(isinstance(bi, tuple)) self.assertEqual(len(bi), 2) - self.assert_(isinstance(bi[0], int)) - self.assert_(isinstance(bi[1], int)) + self.assertTrue(isinstance(bi[0], int)) + self.assertTrue(isinstance(bi[1], int)) self.assertEqual(bi[1], len(a)) def test_byteswap(self): @@ -216,39 +216,39 @@ class BaseTest(unittest.TestCase): def test_cmp(self): a = array.array(self.typecode, self.example) - self.assert_((a == 42) is False) - self.assert_((a != 42) is True) + self.assertTrue((a == 42) is False) + self.assertTrue((a != 42) is True) - self.assert_((a == a) is True) - self.assert_((a != a) is False) - self.assert_((a < a) is False) - self.assert_((a <= a) is True) - self.assert_((a > a) is False) - self.assert_((a >= a) is True) + self.assertTrue((a == a) is True) + self.assertTrue((a != a) is False) + self.assertTrue((a < a) is False) + self.assertTrue((a <= a) is True) + self.assertTrue((a > a) is False) + self.assertTrue((a >= a) is True) al = array.array(self.typecode, self.smallerexample) ab = array.array(self.typecode, self.biggerexample) - self.assert_((a == 2*a) is False) - self.assert_((a != 2*a) is True) - self.assert_((a < 2*a) is True) - self.assert_((a <= 2*a) is True) - self.assert_((a > 2*a) is False) - self.assert_((a >= 2*a) is False) - - self.assert_((a == al) is False) - self.assert_((a != al) is True) - self.assert_((a < al) is False) - self.assert_((a <= al) is False) - self.assert_((a > al) is True) - self.assert_((a >= al) is True) - - self.assert_((a == ab) is False) - self.assert_((a != ab) is True) - self.assert_((a < ab) is True) - self.assert_((a <= ab) is True) - self.assert_((a > ab) is False) - self.assert_((a >= ab) is False) + self.assertTrue((a == 2*a) is False) + self.assertTrue((a != 2*a) is True) + self.assertTrue((a < 2*a) is True) + self.assertTrue((a <= 2*a) is True) + self.assertTrue((a > 2*a) is False) + self.assertTrue((a >= 2*a) is False) + + self.assertTrue((a == al) is False) + self.assertTrue((a != al) is True) + self.assertTrue((a < al) is False) + self.assertTrue((a <= al) is False) + self.assertTrue((a > al) is True) + self.assertTrue((a >= al) is True) + + self.assertTrue((a == ab) is False) + self.assertTrue((a != ab) is True) + self.assertTrue((a < ab) is True) + self.assertTrue((a <= ab) is True) + self.assertTrue((a > ab) is False) + self.assertTrue((a >= ab) is False) def test_add(self): a = array.array(self.typecode, self.example) \ @@ -267,7 +267,7 @@ class BaseTest(unittest.TestCase): a = array.array(self.typecode, self.example[::-1]) b = a a += array.array(self.typecode, 2*self.example) - self.assert_(a is b) + self.assertTrue(a is b) self.assertEqual( a, array.array(self.typecode, self.example[::-1]+2*self.example) @@ -310,22 +310,22 @@ class BaseTest(unittest.TestCase): b = a a *= 5 - self.assert_(a is b) + self.assertTrue(a is b) self.assertEqual( a, array.array(self.typecode, 5*self.example) ) a *= 0 - self.assert_(a is b) + self.assertTrue(a is b) self.assertEqual(a, array.array(self.typecode)) a *= 1000 - self.assert_(a is b) + self.assertTrue(a is b) self.assertEqual(a, array.array(self.typecode)) a *= -1 - self.assert_(a is b) + self.assertTrue(a is b) self.assertEqual(a, array.array(self.typecode)) a = array.array(self.typecode, self.example) diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py index 54a3b35..c22d0d4 100644 --- a/Lib/test/test_ast.py +++ b/Lib/test/test_ast.py @@ -116,20 +116,20 @@ eval_tests = [ class AST_Tests(unittest.TestCase): - def _assert_order(self, ast_node, parent_pos): + def _assertTrueorder(self, ast_node, parent_pos): if not isinstance(ast_node, ast.AST) or ast_node._fields is None: return if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)): node_pos = (ast_node.lineno, ast_node.col_offset) - self.assert_(node_pos >= parent_pos) + self.assertTrue(node_pos >= parent_pos) parent_pos = (ast_node.lineno, ast_node.col_offset) for name in ast_node._fields: value = getattr(ast_node, name) if isinstance(value, list): for child in value: - self._assert_order(child, parent_pos) + self._assertTrueorder(child, parent_pos) elif value is not None: - self._assert_order(value, parent_pos) + self._assertTrueorder(value, parent_pos) def test_snippets(self): for input, output, kind in ((exec_tests, exec_results, "exec"), @@ -138,7 +138,7 @@ class AST_Tests(unittest.TestCase): for i, o in zip(input, output): ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST) self.assertEquals(to_tuple(ast_tree), o) - self._assert_order(ast_tree, (0, 0)) + self._assertTrueorder(ast_tree, (0, 0)) def test_nodeclasses(self): x = ast.BinOp(1, 2, 3, lineno=0) diff --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py index e03b4d4..8567821 100644 --- a/Lib/test/test_augassign.py +++ b/Lib/test/test_augassign.py @@ -60,7 +60,7 @@ class AugAssignTest(unittest.TestCase): y[1:2] += [1] self.assertEquals(x, [1, 2, 1, 2, 3]) - self.assert_(x is y) + self.assertTrue(x is y) def testCustomMethods1(self): @@ -85,23 +85,23 @@ class AugAssignTest(unittest.TestCase): y = x x += 10 - self.assert_(isinstance(x, aug_test)) - self.assert_(y is not x) + self.assertTrue(isinstance(x, aug_test)) + self.assertTrue(y is not x) self.assertEquals(x.val, 11) x = aug_test2(2) y = x x += 10 - self.assert_(y is x) + self.assertTrue(y is x) self.assertEquals(x.val, 12) x = aug_test3(3) y = x x += 10 - self.assert_(isinstance(x, aug_test3)) - self.assert_(y is not x) + self.assertTrue(isinstance(x, aug_test3)) + self.assertTrue(y is not x) self.assertEquals(x.val, 13) diff --git a/Lib/test/test_base64.py b/Lib/test/test_base64.py index 149ac8a..fadee6d 100644 --- a/Lib/test/test_base64.py +++ b/Lib/test/test_base64.py @@ -204,7 +204,7 @@ class BaseXYTestCase(unittest.TestCase): self.assertRaises(TypeError, base64.b16decode, "") def test_ErrorHeritage(self): - self.assert_(issubclass(binascii.Error, ValueError)) + self.assertTrue(issubclass(binascii.Error, ValueError)) diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py index 091893e..030ada5 100644 --- a/Lib/test/test_bigmem.py +++ b/Lib/test/test_bigmem.py @@ -80,12 +80,12 @@ class BaseStrTest: _ = self.from_latin1 SUBSTR = _(' abc def ghi') s = _('-') * size + SUBSTR - self.failUnless(s.endswith(SUBSTR)) - self.failUnless(s.endswith(s)) + self.assertTrue(s.endswith(SUBSTR)) + self.assertTrue(s.endswith(s)) s2 = _('...') + s - self.failUnless(s2.endswith(s)) - self.failIf(s.endswith(_('a') + SUBSTR)) - self.failIf(SUBSTR.endswith(s)) + self.assertTrue(s2.endswith(s)) + self.assertFalse(s.endswith(_('a') + SUBSTR)) + self.assertFalse(SUBSTR.endswith(s)) @bigmemtest(minsize=_2G + 10, memuse=2) def test_expandtabs(self, size): @@ -139,27 +139,27 @@ class BaseStrTest: _ = self.from_latin1 SUBSTR = _('123456') s = _('a') * size + SUBSTR - self.failUnless(s.isalnum()) + self.assertTrue(s.isalnum()) s += _('.') - self.failIf(s.isalnum()) + self.assertFalse(s.isalnum()) @bigmemtest(minsize=_2G, memuse=2) def test_isalpha(self, size): _ = self.from_latin1 SUBSTR = _('zzzzzzz') s = _('a') * size + SUBSTR - self.failUnless(s.isalpha()) + self.assertTrue(s.isalpha()) s += _('.') - self.failIf(s.isalpha()) + self.assertFalse(s.isalpha()) @bigmemtest(minsize=_2G, memuse=2) def test_isdigit(self, size): _ = self.from_latin1 SUBSTR = _('123456') s = _('9') * size + SUBSTR - self.failUnless(s.isdigit()) + self.assertTrue(s.isdigit()) s += _('z') - self.failIf(s.isdigit()) + self.assertFalse(s.isdigit()) @bigmemtest(minsize=_2G, memuse=2) def test_islower(self, size): @@ -168,9 +168,9 @@ class BaseStrTest: chr(c) for c in range(255) if not chr(c).isupper())) repeats = size // len(chars) + 2 s = chars * repeats - self.failUnless(s.islower()) + self.assertTrue(s.islower()) s += _('A') - self.failIf(s.islower()) + self.assertFalse(s.islower()) @bigmemtest(minsize=_2G, memuse=2) def test_isspace(self, size): @@ -178,20 +178,20 @@ class BaseStrTest: whitespace = _(' \f\n\r\t\v') repeats = size // len(whitespace) + 2 s = whitespace * repeats - self.failUnless(s.isspace()) + self.assertTrue(s.isspace()) s += _('j') - self.failIf(s.isspace()) + self.assertFalse(s.isspace()) @bigmemtest(minsize=_2G, memuse=2) def test_istitle(self, size): _ = self.from_latin1 SUBSTR = _('123456') s = _('').join([_('A'), _('a') * size, SUBSTR]) - self.failUnless(s.istitle()) + self.assertTrue(s.istitle()) s += _('A') - self.failUnless(s.istitle()) + self.assertTrue(s.istitle()) s += _('aA') - self.failIf(s.istitle()) + self.assertFalse(s.istitle()) @bigmemtest(minsize=_2G, memuse=2) def test_isupper(self, size): @@ -200,9 +200,9 @@ class BaseStrTest: chr(c) for c in range(255) if not chr(c).islower())) repeats = size // len(chars) + 2 s = chars * repeats - self.failUnless(s.isupper()) + self.assertTrue(s.isupper()) s += _('a') - self.failIf(s.isupper()) + self.assertFalse(s.isupper()) @bigmemtest(minsize=_2G, memuse=2) def test_join(self, size): @@ -211,15 +211,15 @@ class BaseStrTest: x = s.join([_('aaaaa'), _('bbbbb')]) self.assertEquals(x.count(_('a')), 5) self.assertEquals(x.count(_('b')), 5) - self.failUnless(x.startswith(_('aaaaaA'))) - self.failUnless(x.endswith(_('Abbbbb'))) + self.assertTrue(x.startswith(_('aaaaaA'))) + self.assertTrue(x.endswith(_('Abbbbb'))) @bigmemtest(minsize=_2G + 10, memuse=1) def test_ljust(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) - self.failUnless(s.startswith(SUBSTR + _(' '))) + self.assertTrue(s.startswith(SUBSTR + _(' '))) self.assertEquals(len(s), size) self.assertEquals(s.strip(), SUBSTR.strip()) @@ -244,7 +244,7 @@ class BaseStrTest: # Type-specific optimization if isinstance(s, (str, bytes)): stripped = s.lstrip() - self.failUnless(stripped is s) + self.assertTrue(stripped is s) @bigmemtest(minsize=_2G + 10, memuse=2) def test_replace(self, size): @@ -299,7 +299,7 @@ class BaseStrTest: _ = self.from_latin1 SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) - self.failUnless(s.startswith(SUBSTR + _(' '))) + self.assertTrue(s.startswith(SUBSTR + _(' '))) self.assertEquals(len(s), size) self.assertEquals(s.strip(), SUBSTR.strip()) @@ -316,7 +316,7 @@ class BaseStrTest: # Type-specific optimization if isinstance(s, (str, bytes)): stripped = s.rstrip() - self.failUnless(stripped is s) + self.assertTrue(stripped is s) # The test takes about size bytes to build a string, and then about # sqrt(size) substrings of sqrt(size) in size and a list to @@ -378,9 +378,9 @@ class BaseStrTest: _ = self.from_latin1 SUBSTR = _(' abc def ghi') s = _('-') * size + SUBSTR - self.failUnless(s.startswith(s)) - self.failUnless(s.startswith(_('-') * size)) - self.failIf(s.startswith(SUBSTR)) + self.assertTrue(s.startswith(s)) + self.assertTrue(s.startswith(_('-') * size)) + self.assertFalse(s.startswith(SUBSTR)) @bigmemtest(minsize=_2G, memuse=1) def test_strip(self, size): @@ -412,8 +412,8 @@ class BaseStrTest: SUBSTR = _('SpaaHAaaAaham') s = SUBSTR * (size // len(SUBSTR) + 2) s = s.title() - self.failUnless(s.startswith((SUBSTR * 3).title())) - self.failUnless(s.endswith(SUBSTR.lower() * 3)) + self.assertTrue(s.startswith((SUBSTR * 3).title())) + self.assertTrue(s.endswith(SUBSTR.lower() * 3)) @bigmemtest(minsize=_2G, memuse=2) def test_translate(self, size): @@ -451,8 +451,8 @@ class BaseStrTest: _ = self.from_latin1 SUBSTR = _('-568324723598234') s = SUBSTR.zfill(size) - self.failUnless(s.endswith(_('0') + SUBSTR[1:])) - self.failUnless(s.startswith(_('-0'))) + self.assertTrue(s.endswith(_('0') + SUBSTR[1:])) + self.assertTrue(s.startswith(_('-0'))) self.assertEquals(len(s), size) self.assertEquals(s.count(_('0')), size - len(SUBSTR)) @@ -519,12 +519,12 @@ class BaseStrTest: edge = _('-') * (size // 2) s = _('').join([edge, SUBSTR, edge]) del edge - self.failUnless(SUBSTR in s) - self.failIf(SUBSTR * 2 in s) - self.failUnless(_('-') in s) - self.failIf(_('a') in s) + self.assertTrue(SUBSTR in s) + self.assertFalse(SUBSTR * 2 in s) + self.assertTrue(_('-') in s) + self.assertFalse(_('a') in s) s += _('a') - self.failUnless(_('a') in s) + self.assertTrue(_('a') in s) @bigmemtest(minsize=_2G + 10, memuse=2) def test_compare(self, size): @@ -534,10 +534,10 @@ class BaseStrTest: self.assertEqual(s1, s2) del s2 s2 = s1 + _('a') - self.failIf(s1 == s2) + self.assertFalse(s1 == s2) del s2 s2 = _('.') * size - self.failIf(s1 == s2) + self.assertFalse(s1 == s2) @bigmemtest(minsize=_2G + 10, memuse=1) def test_hash(self, size): @@ -552,7 +552,7 @@ class BaseStrTest: h1 = hash(s) del s s = _('\x00') * (size + 1) - self.failIf(h1 == hash(s)) + self.assertFalse(h1 == hash(s)) class StrTest(unittest.TestCase, BaseStrTest): @@ -623,7 +623,7 @@ class StrTest(unittest.TestCase, BaseStrTest): except MemoryError: pass # acceptable on 32-bit else: - self.failUnless(s == eval(r)) + self.assertTrue(s == eval(r)) @bigmemtest(minsize=_2G + 10, memuse=character_size * 2) def test_format(self, size): @@ -633,8 +633,8 @@ class StrTest(unittest.TestCase, BaseStrTest): del sf sf = '..%s..' % (s,) self.assertEquals(len(sf), len(s) + 4) - self.failUnless(sf.startswith('..-')) - self.failUnless(sf.endswith('-..')) + self.assertTrue(sf.startswith('..-')) + self.assertTrue(sf.endswith('-..')) del s, sf size //= 2 @@ -682,8 +682,8 @@ class StrTest(unittest.TestCase, BaseStrTest): s = "\uAAAA" * size for f in (repr, ascii): r = f(s) - self.failUnless(len(r) > size) - self.failUnless(r.endswith(r"\uaaaa'"), r[-10:]) + self.assertTrue(len(r) > size) + self.assertTrue(r.endswith(r"\uaaaa'"), r[-10:]) del r # The character takes 4 bytes even in UCS-2 builds because it will @@ -693,8 +693,8 @@ class StrTest(unittest.TestCase, BaseStrTest): s = "\U0001AAAA" * size for f in (repr, ascii): r = f(s) - self.failUnless(len(r) > size) - self.failUnless(r.endswith(r"\U0001aaaa'"), r[-12:]) + self.assertTrue(len(r) > size) + self.assertTrue(r.endswith(r"\U0001aaaa'"), r[-12:]) del r @@ -740,10 +740,10 @@ class TupleTest(unittest.TestCase): self.assertEqual(t1, t2) del t2 t2 = ('',) * (size + 1) - self.failIf(t1 == t2) + self.assertFalse(t1 == t2) del t2 t2 = (1,) * size - self.failIf(t1 == t2) + self.assertFalse(t1 == t2) # Test concatenating into a single tuple of more than 2G in length, # and concatenating a tuple of more than 2G in length separately, so @@ -768,9 +768,9 @@ class TupleTest(unittest.TestCase): def test_contains(self, size): t = (1, 2, 3, 4, 5) * size self.assertEquals(len(t), size * 5) - self.failUnless(5 in t) - self.failIf((1, 2, 3, 4, 5) in t) - self.failIf(0 in t) + self.assertTrue(5 in t) + self.assertFalse((1, 2, 3, 4, 5) in t) + self.assertFalse(0 in t) @bigmemtest(minsize=_2G + 10, memuse=8) def test_hash(self, size): @@ -778,7 +778,7 @@ class TupleTest(unittest.TestCase): h1 = hash(t1) del t1 t2 = (0,) * (size + 1) - self.failIf(h1 == hash(t2)) + self.assertFalse(h1 == hash(t2)) @bigmemtest(minsize=_2G + 10, memuse=8) def test_index_and_slice(self, size): @@ -874,10 +874,10 @@ class ListTest(unittest.TestCase): self.assertEqual(l1, l2) del l2 l2 = [''] * (size + 1) - self.failIf(l1 == l2) + self.assertFalse(l1 == l2) del l2 l2 = [2] * size - self.failIf(l1 == l2) + self.assertFalse(l1 == l2) # Test concatenating into a single list of more than 2G in length, # and concatenating a list of more than 2G in length separately, so @@ -902,8 +902,8 @@ class ListTest(unittest.TestCase): l = [sys.stdout] * size l += l self.assertEquals(len(l), size * 2) - self.failUnless(l[0] is l[-1]) - self.failUnless(l[size - 1] is l[size + 1]) + self.assertTrue(l[0] is l[-1]) + self.assertTrue(l[size - 1] is l[size + 1]) @bigmemtest(minsize=_2G // 2 + 2, memuse=24) def test_inplace_concat_small(self, size): @@ -917,14 +917,14 @@ class ListTest(unittest.TestCase): def test_contains(self, size): l = [1, 2, 3, 4, 5] * size self.assertEquals(len(l), size * 5) - self.failUnless(5 in l) - self.failIf([1, 2, 3, 4, 5] in l) - self.failIf(0 in l) + self.assertTrue(5 in l) + self.assertFalse([1, 2, 3, 4, 5] in l) + self.assertFalse(0 in l) @bigmemtest(minsize=_2G + 10, memuse=8) def test_hash(self, size): l = [0] * size - self.failUnlessRaises(TypeError, hash, l) + self.assertRaises(TypeError, hash, l) @bigmemtest(minsize=_2G + 10, memuse=8) def test_index_and_slice(self, size): @@ -984,7 +984,7 @@ class ListTest(unittest.TestCase): # Like test_concat, split in two. def basic_test_repeat(self, size): l = [] * size - self.failIf(l) + self.assertFalse(l) l = [''] * size self.assertEquals(len(l), size) l = l * 2 @@ -1002,13 +1002,13 @@ class ListTest(unittest.TestCase): l = [''] l *= size self.assertEquals(len(l), size) - self.failUnless(l[0] is l[-1]) + self.assertTrue(l[0] is l[-1]) del l l = [''] * size l *= 2 self.assertEquals(len(l), size * 2) - self.failUnless(l[size - 1] is l[-1]) + self.assertTrue(l[size - 1] is l[-1]) @bigmemtest(minsize=_2G // 2 + 2, memuse=16) def test_inplace_repeat_small(self, size): @@ -1042,8 +1042,8 @@ class ListTest(unittest.TestCase): l = [object()] * size l.append(object()) self.assertEquals(len(l), size+1) - self.failUnless(l[-3] is l[-2]) - self.failIf(l[-2] is l[-1]) + self.assertTrue(l[-3] is l[-2]) + self.assertFalse(l[-2] is l[-1]) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) def test_count(self, size): @@ -1055,8 +1055,8 @@ class ListTest(unittest.TestCase): l = [object] * size l.extend(l) self.assertEquals(len(l), size * 2) - self.failUnless(l[0] is l[-1]) - self.failUnless(l[size - 1] is l[size + 1]) + self.assertTrue(l[0] is l[-1]) + self.assertTrue(l[size - 1] is l[size + 1]) @bigmemtest(minsize=_2G // 2 + 2, memuse=16) def test_extend_small(self, size): diff --git a/Lib/test/test_binascii.py b/Lib/test/test_binascii.py index d4ab6bf..65de81b 100755 --- a/Lib/test/test_binascii.py +++ b/Lib/test/test_binascii.py @@ -14,8 +14,8 @@ class BinASCIITest(unittest.TestCase): def test_exceptions(self): # Check module exceptions - self.assert_(issubclass(binascii.Error, Exception)) - self.assert_(issubclass(binascii.Incomplete, Exception)) + self.assertTrue(issubclass(binascii.Error, Exception)) + self.assertTrue(issubclass(binascii.Incomplete, Exception)) def test_functions(self): # Check presence of all functions @@ -26,10 +26,10 @@ class BinASCIITest(unittest.TestCase): prefixes.extend(["crc_", "rlecode_", "rledecode_"]) for prefix in prefixes: name = prefix + suffix - self.assert_(hasattr(getattr(binascii, name), '__call__')) + self.assertTrue(hasattr(getattr(binascii, name), '__call__')) self.assertRaises(TypeError, getattr(binascii, name)) for name in ("hexlify", "unhexlify"): - self.assert_(hasattr(getattr(binascii, name), '__call__')) + self.assertTrue(hasattr(getattr(binascii, name), '__call__')) self.assertRaises(TypeError, getattr(binascii, name)) def test_base64valid(self): diff --git a/Lib/test/test_binop.py b/Lib/test/test_binop.py index 0dc18dd..5d77f23 100644 --- a/Lib/test/test_binop.py +++ b/Lib/test/test_binop.py @@ -210,10 +210,10 @@ class RatTestCase(unittest.TestCase): self.assertEqual(gcd(-10, -2), -2) for i in range(1, 20): for j in range(1, 20): - self.assert_(gcd(i, j) > 0) - self.assert_(gcd(-i, j) < 0) - self.assert_(gcd(i, -j) > 0) - self.assert_(gcd(-i, -j) < 0) + self.assertTrue(gcd(i, j) > 0) + self.assertTrue(gcd(-i, j) < 0) + self.assertTrue(gcd(i, -j) > 0) + self.assertTrue(gcd(-i, -j) < 0) def test_constructor(self): a = Rat(10, 15) diff --git a/Lib/test/test_bisect.py b/Lib/test/test_bisect.py index df2f8b1..93b8613 100644 --- a/Lib/test/test_bisect.py +++ b/Lib/test/test_bisect.py @@ -130,14 +130,14 @@ class TestBisect(unittest.TestCase): elem = randrange(-1, n+1) ip = self.module.bisect_left(data, elem) if ip < len(data): - self.failUnless(elem <= data[ip]) + self.assertTrue(elem <= data[ip]) if ip > 0: - self.failUnless(data[ip-1] < elem) + self.assertTrue(data[ip-1] < elem) ip = self.module.bisect_right(data, elem) if ip < len(data): - self.failUnless(elem < data[ip]) + self.assertTrue(elem < data[ip]) if ip > 0: - self.failUnless(data[ip-1] <= elem) + self.assertTrue(data[ip-1] <= elem) def test_optionalSlicing(self): for func, data, elem, expected in self.precomputedCases: @@ -146,15 +146,15 @@ class TestBisect(unittest.TestCase): for hi in range(3,8): hi = min(len(data), hi) ip = func(data, elem, lo, hi) - self.failUnless(lo <= ip <= hi) + self.assertTrue(lo <= ip <= hi) if func is self.module.bisect_left and ip < hi: - self.failUnless(elem <= data[ip]) + self.assertTrue(elem <= data[ip]) if func is self.module.bisect_left and ip > lo: - self.failUnless(data[ip-1] < elem) + self.assertTrue(data[ip-1] < elem) if func is self.module.bisect_right and ip < hi: - self.failUnless(elem < data[ip]) + self.assertTrue(elem < data[ip]) if func is self.module.bisect_right and ip > lo: - self.failUnless(data[ip-1] <= elem) + self.assertTrue(data[ip-1] <= elem) self.assertEqual(ip, max(lo, min(hi, expected))) def test_backcompatibility(self): diff --git a/Lib/test/test_bool.py b/Lib/test/test_bool.py index 80229aa..3a68dfc 100644 --- a/Lib/test/test_bool.py +++ b/Lib/test/test_bool.py @@ -8,10 +8,10 @@ import os class BoolTest(unittest.TestCase): def assertIs(self, a, b): - self.assert_(a is b) + self.assertTrue(a is b) def assertIsNot(self, a, b): - self.assert_(a is not b) + self.assertTrue(a is not b) def test_subclass(self): try: @@ -221,15 +221,15 @@ class BoolTest(unittest.TestCase): def test_boolean(self): self.assertEqual(True & 1, 1) - self.assert_(not isinstance(True & 1, bool)) + self.assertTrue(not isinstance(True & 1, bool)) self.assertIs(True & True, True) self.assertEqual(True | 1, 1) - self.assert_(not isinstance(True | 1, bool)) + self.assertTrue(not isinstance(True | 1, bool)) self.assertIs(True | True, True) self.assertEqual(True ^ 1, 0) - self.assert_(not isinstance(True ^ 1, bool)) + self.assertTrue(not isinstance(True ^ 1, bool)) self.assertIs(True ^ True, False) def test_fileclosed(self): diff --git a/Lib/test/test_bufio.py b/Lib/test/test_bufio.py index 7d617d3..5ab6f5a 100644 --- a/Lib/test/test_bufio.py +++ b/Lib/test/test_bufio.py @@ -34,7 +34,7 @@ class BufferSizeTest(unittest.TestCase): line = f.readline() self.assertEqual(line, s) line = f.readline() - self.assert_(not line) # Must be at EOF + self.assertTrue(not line) # Must be at EOF f.close() finally: support.unlink(support.TESTFN) diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py index 28af247..cac4555 100644 --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -176,24 +176,24 @@ class BuiltinTest(unittest.TestCase): def test_neg(self): x = -sys.maxsize-1 - self.assert_(isinstance(x, int)) + self.assertTrue(isinstance(x, int)) self.assertEqual(-x, sys.maxsize+1) # XXX(nnorwitz): This test case for callable should probably be removed. def test_callable(self): - self.assert_(hasattr(len, '__call__')) + self.assertTrue(hasattr(len, '__call__')) def f(): pass - self.assert_(hasattr(f, '__call__')) + self.assertTrue(hasattr(f, '__call__')) class C: def meth(self): pass - self.assert_(hasattr(C, '__call__')) + self.assertTrue(hasattr(C, '__call__')) x = C() - self.assert_(hasattr(x.meth, '__call__')) - self.assert_(not hasattr(x, '__call__')) + self.assertTrue(hasattr(x.meth, '__call__')) + self.assertTrue(not hasattr(x, '__call__')) class D(C): def __call__(self): pass y = D() - self.assert_(hasattr(y, '__call__')) + self.assertTrue(hasattr(y, '__call__')) y() def test_chr(self): @@ -220,7 +220,7 @@ class BuiltinTest(unittest.TestCase): self.assertRaises((OverflowError, ValueError), chr, 2**32) def test_cmp(self): - self.assert_(not hasattr(builtins, "cmp")) + self.assertTrue(not hasattr(builtins, "cmp")) def test_compile(self): compile('print(1)\n', '', 'exec') @@ -252,11 +252,11 @@ class BuiltinTest(unittest.TestCase): # dir() - local scope local_var = 1 - self.assert_('local_var' in dir()) + self.assertTrue('local_var' in dir()) # dir(module) import sys - self.assert_('exit' in dir(sys)) + self.assertTrue('exit' in dir(sys)) # dir(module_with_invalid__dict__) import types @@ -266,8 +266,8 @@ class BuiltinTest(unittest.TestCase): self.assertRaises(TypeError, dir, f) # dir(type) - self.assert_("strip" in dir(str)) - self.assert_("__mro__" not in dir(str)) + self.assertTrue("strip" in dir(str)) + self.assertTrue("__mro__" not in dir(str)) # dir(obj) class Foo(object): @@ -276,13 +276,13 @@ class BuiltinTest(unittest.TestCase): self.y = 8 self.z = 9 f = Foo() - self.assert_("y" in dir(f)) + self.assertTrue("y" in dir(f)) # dir(obj_no__dict__) class Foo(object): __slots__ = [] f = Foo() - self.assert_("__repr__" in dir(f)) + self.assertTrue("__repr__" in dir(f)) # dir(obj_no__class__with__dict__) # (an ugly trick to cause getattr(f, "__class__") to fail) @@ -291,15 +291,15 @@ class BuiltinTest(unittest.TestCase): def __init__(self): self.bar = "wow" f = Foo() - self.assert_("__repr__" not in dir(f)) - self.assert_("bar" in dir(f)) + self.assertTrue("__repr__" not in dir(f)) + self.assertTrue("bar" in dir(f)) # dir(obj_using __dir__) class Foo(object): def __dir__(self): return ["kan", "ga", "roo"] f = Foo() - self.assert_(dir(f) == ["ga", "kan", "roo"]) + self.assertTrue(dir(f) == ["ga", "kan", "roo"]) # dir(obj__dir__not_list) class Foo(object): @@ -334,10 +334,10 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(divmod(-sys.maxsize-1, -1), (sys.maxsize+1, 0)) - self.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) - self.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) - self.assert_(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75))) - self.assert_(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25))) + self.assertTrue(not fcmp(divmod(3.25, 1.0), (3.0, 0.25))) + self.assertTrue(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75))) + self.assertTrue(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75))) + self.assertTrue(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25))) self.assertRaises(TypeError, divmod) @@ -489,7 +489,7 @@ class BuiltinTest(unittest.TestCase): def test_getattr(self): import sys - self.assert_(getattr(sys, 'stdout') is sys.stdout) + self.assertTrue(getattr(sys, 'stdout') is sys.stdout) self.assertRaises(TypeError, getattr, sys, 1) self.assertRaises(TypeError, getattr, sys, 1, "foo") self.assertRaises(TypeError, getattr) @@ -497,7 +497,7 @@ class BuiltinTest(unittest.TestCase): def test_hasattr(self): import sys - self.assert_(hasattr(sys, 'stdout')) + self.assertTrue(hasattr(sys, 'stdout')) self.assertRaises(TypeError, hasattr, sys, 1) self.assertRaises(TypeError, hasattr) self.assertEqual(False, hasattr(sys, chr(sys.maxunicode))) @@ -575,11 +575,11 @@ class BuiltinTest(unittest.TestCase): c = C() d = D() e = E() - self.assert_(isinstance(c, C)) - self.assert_(isinstance(d, C)) - self.assert_(not isinstance(e, C)) - self.assert_(not isinstance(c, D)) - self.assert_(not isinstance('foo', E)) + self.assertTrue(isinstance(c, C)) + self.assertTrue(isinstance(d, C)) + self.assertTrue(not isinstance(e, C)) + self.assertTrue(not isinstance(c, D)) + self.assertTrue(not isinstance('foo', E)) self.assertRaises(TypeError, isinstance, E, 'foo') self.assertRaises(TypeError, isinstance) @@ -593,9 +593,9 @@ class BuiltinTest(unittest.TestCase): c = C() d = D() e = E() - self.assert_(issubclass(D, C)) - self.assert_(issubclass(C, C)) - self.assert_(not issubclass(C, D)) + self.assertTrue(issubclass(D, C)) + self.assertTrue(issubclass(C, C)) + self.assertTrue(not issubclass(C, D)) self.assertRaises(TypeError, issubclass, 'foo', E) self.assertRaises(TypeError, issubclass, E, 'foo') self.assertRaises(TypeError, issubclass) @@ -958,18 +958,18 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2]) seq = list(range(a, b, c)) - self.assert_(a in seq) - self.assert_(b not in seq) + self.assertTrue(a in seq) + self.assertTrue(b not in seq) self.assertEqual(len(seq), 2) seq = list(range(b, a, -c)) - self.assert_(b in seq) - self.assert_(a not in seq) + self.assertTrue(b in seq) + self.assertTrue(a not in seq) self.assertEqual(len(seq), 2) seq = list(range(-a, -b, -c)) - self.assert_(-a in seq) - self.assert_(-b not in seq) + self.assertTrue(-a in seq) + self.assertTrue(-b not in seq) self.assertEqual(len(seq), 2) self.assertRaises(TypeError, range) diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py index 992f3d2..caea909 100644 --- a/Lib/test/test_bytes.py +++ b/Lib/test/test_bytes.py @@ -102,22 +102,22 @@ class BaseBytesTest(unittest.TestCase): b3 = self.type2test([1, 3]) self.assertEqual(b1, b2) - self.failUnless(b2 != b3) - self.failUnless(b1 <= b2) - self.failUnless(b1 <= b3) - self.failUnless(b1 < b3) - self.failUnless(b1 >= b2) - self.failUnless(b3 >= b2) - self.failUnless(b3 > b2) - - self.failIf(b1 != b2) - self.failIf(b2 == b3) - self.failIf(b1 > b2) - self.failIf(b1 > b3) - self.failIf(b1 >= b3) - self.failIf(b1 < b2) - self.failIf(b3 < b2) - self.failIf(b3 <= b2) + self.assertTrue(b2 != b3) + self.assertTrue(b1 <= b2) + self.assertTrue(b1 <= b3) + self.assertTrue(b1 < b3) + self.assertTrue(b1 >= b2) + self.assertTrue(b3 >= b2) + self.assertTrue(b3 > b2) + + self.assertFalse(b1 != b2) + self.assertFalse(b2 == b3) + self.assertFalse(b1 > b2) + self.assertFalse(b1 > b3) + self.assertFalse(b1 >= b3) + self.assertFalse(b1 < b2) + self.assertFalse(b3 < b2) + self.assertFalse(b3 <= b2) def test_compare_to_str(self): warnings.simplefilter('ignore', BytesWarning) @@ -220,27 +220,27 @@ class BaseBytesTest(unittest.TestCase): def test_contains(self): b = self.type2test(b"abc") - self.failUnless(ord('a') in b) - self.failUnless(int(ord('a')) in b) - self.failIf(200 in b) - self.failIf(200 in b) + self.assertTrue(ord('a') in b) + self.assertTrue(int(ord('a')) in b) + self.assertFalse(200 in b) + self.assertFalse(200 in b) self.assertRaises(ValueError, lambda: 300 in b) self.assertRaises(ValueError, lambda: -1 in b) self.assertRaises(TypeError, lambda: None in b) self.assertRaises(TypeError, lambda: float(ord('a')) in b) self.assertRaises(TypeError, lambda: "a" in b) for f in bytes, bytearray: - self.failUnless(f(b"") in b) - self.failUnless(f(b"a") in b) - self.failUnless(f(b"b") in b) - self.failUnless(f(b"c") in b) - self.failUnless(f(b"ab") in b) - self.failUnless(f(b"bc") in b) - self.failUnless(f(b"abc") in b) - self.failIf(f(b"ac") in b) - self.failIf(f(b"d") in b) - self.failIf(f(b"dab") in b) - self.failIf(f(b"abd") in b) + self.assertTrue(f(b"") in b) + self.assertTrue(f(b"a") in b) + self.assertTrue(f(b"b") in b) + self.assertTrue(f(b"c") in b) + self.assertTrue(f(b"ab") in b) + self.assertTrue(f(b"bc") in b) + self.assertTrue(f(b"abc") in b) + self.assertFalse(f(b"ac") in b) + self.assertFalse(f(b"d") in b) + self.assertFalse(f(b"dab") in b) + self.assertFalse(f(b"abd") in b) def test_fromhex(self): self.assertRaises(TypeError, self.type2test.fromhex) @@ -626,7 +626,7 @@ class ByteArrayTest(BaseBytesTest): b += b"def" self.assertEqual(b, b"abcdef") self.assertEqual(b, b1) - self.failUnless(b is b1) + self.assertTrue(b is b1) b += b"xyz" self.assertEqual(b, b"abcdefxyz") try: @@ -642,7 +642,7 @@ class ByteArrayTest(BaseBytesTest): b *= 3 self.assertEqual(b, b"abcabcabc") self.assertEqual(b, b1) - self.failUnless(b is b1) + self.assertTrue(b is b1) def test_irepeat_1char(self): b = bytearray(b"x") @@ -650,17 +650,17 @@ class ByteArrayTest(BaseBytesTest): b *= 100 self.assertEqual(b, b"x"*100) self.assertEqual(b, b1) - self.failUnless(b is b1) + self.assertTrue(b is b1) def test_alloc(self): b = bytearray() alloc = b.__alloc__() - self.assert_(alloc >= 0) + self.assertTrue(alloc >= 0) seq = [alloc] for i in range(100): b += b"x" alloc = b.__alloc__() - self.assert_(alloc >= len(b)) + self.assertTrue(alloc >= len(b)) if alloc not in seq: seq.append(alloc) @@ -759,7 +759,7 @@ class ByteArrayTest(BaseBytesTest): a, b, c = bytearray(b"x").partition(b"y") self.assertEqual(b, b"") self.assertEqual(c, b"") - self.assert_(b is not c) + self.assertTrue(b is not c) b += b"!" self.assertEqual(c, b"") a, b, c = bytearray(b"x").partition(b"y") @@ -769,7 +769,7 @@ class ByteArrayTest(BaseBytesTest): b, c, a = bytearray(b"x").rpartition(b"y") self.assertEqual(b, b"") self.assertEqual(c, b"") - self.assert_(b is not c) + self.assertTrue(b is not c) b += b"!" self.assertEqual(c, b"") c, b, a = bytearray(b"x").rpartition(b"y") @@ -860,10 +860,10 @@ class AssortedBytesTest(unittest.TestCase): self.assertEqual(bytes(b"abc") <= b"ab", False) def test_doc(self): - self.failUnless(bytearray.__doc__ != None) - self.failUnless(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__) - self.failUnless(bytes.__doc__ != None) - self.failUnless(bytes.__doc__.startswith("bytes("), bytes.__doc__) + self.assertTrue(bytearray.__doc__ != None) + self.assertTrue(bytearray.__doc__.startswith("bytearray("), bytearray.__doc__) + self.assertTrue(bytes.__doc__ != None) + self.assertTrue(bytes.__doc__.startswith("bytes("), bytes.__doc__) def test_from_bytearray(self): sample = bytes(b"Hello world\n\x80\x81\xfe\xff") @@ -920,7 +920,7 @@ class AssortedBytesTest(unittest.TestCase): def test_return_self(self): # bytearray.replace must always return a new bytearray b = bytearray() - self.failIf(b.replace(b'', b'') is b) + self.assertFalse(b.replace(b'', b'') is b) def test_compare(self): if sys.flags.bytes_warning: @@ -997,20 +997,20 @@ class ByteArraySubclass(bytearray): class ByteArraySubclassTest(unittest.TestCase): def test_basic(self): - self.assert_(issubclass(ByteArraySubclass, bytearray)) - self.assert_(isinstance(ByteArraySubclass(), bytearray)) + self.assertTrue(issubclass(ByteArraySubclass, bytearray)) + self.assertTrue(isinstance(ByteArraySubclass(), bytearray)) a, b = b"abcd", b"efgh" _a, _b = ByteArraySubclass(a), ByteArraySubclass(b) # test comparison operators with subclass instances - self.assert_(_a == _a) - self.assert_(_a != _b) - self.assert_(_a < _b) - self.assert_(_a <= _b) - self.assert_(_b >= _a) - self.assert_(_b > _a) - self.assert_(_a is not a) + self.assertTrue(_a == _a) + self.assertTrue(_a != _b) + self.assertTrue(_a < _b) + self.assertTrue(_a <= _b) + self.assertTrue(_b >= _a) + self.assertTrue(_b > _a) + self.assertTrue(_a is not a) # test concat of subclass instances self.assertEqual(a + b, _a + _b) @@ -1018,7 +1018,7 @@ class ByteArraySubclassTest(unittest.TestCase): self.assertEqual(a + b, _a + b) # test repeat - self.assert_(a*5 == _a*5) + self.assertTrue(a*5 == _a*5) def test_join(self): # Make sure join returns a NEW object for single item sequences @@ -1026,12 +1026,12 @@ class ByteArraySubclassTest(unittest.TestCase): # Make sure that it is of the appropriate type. s1 = ByteArraySubclass(b"abcd") s2 = bytearray().join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is bytearray, type(s2)) + self.assertTrue(s1 is not s2) + self.assertTrue(type(s2) is bytearray, type(s2)) # Test reverse, calling join on subclass s3 = s1.join([b"abcd"]) - self.assert_(type(s3) is bytearray) + self.assertTrue(type(s3) is bytearray) def test_pickle(self): a = ByteArraySubclass(b"abcd") diff --git a/Lib/test/test_capi.py b/Lib/test/test_capi.py index d3d2226..0460679 100644 --- a/Lib/test/test_capi.py +++ b/Lib/test/test_capi.py @@ -24,7 +24,7 @@ class CAPITest(unittest.TestCase): def test_instancemethod(self): inst = InstanceMethod() self.assertEqual(id(inst), inst.id()) - self.assert_(inst.testfunction() is inst) + self.assertTrue(inst.testfunction() is inst) self.assertEqual(inst.testfunction.__doc__, testfunction.__doc__) self.assertEqual(InstanceMethod.testfunction.__doc__, testfunction.__doc__) @@ -64,7 +64,7 @@ class TestPendingCalls(unittest.TestCase): if context and not context.event.is_set(): continue count += 1 - self.failUnless(count < 10000, + self.assertTrue(count < 10000, "timeout waiting for %i callbacks, got %i"%(n, len(l))) if False and support.verbose: print("(%i)"%(len(l),)) diff --git a/Lib/test/test_cfgparser.py b/Lib/test/test_cfgparser.py index 12fd00c..a3d2640 100644 --- a/Lib/test/test_cfgparser.py +++ b/Lib/test/test_cfgparser.py @@ -76,16 +76,16 @@ class TestCaseBase(unittest.TestCase): eq(cf.get('Spaces', 'key with spaces'), 'value') eq(cf.get('Spaces', 'another with spaces'), 'splat!') - self.failIf('__name__' in cf.options("Foo Bar"), + self.assertFalse('__name__' in cf.options("Foo Bar"), '__name__ "option" should not be exposed by the API!') # Make sure the right things happen for remove_option(); # added to include check for SourceForge bug #123324: - self.failUnless(cf.remove_option('Foo Bar', 'foo'), + self.assertTrue(cf.remove_option('Foo Bar', 'foo'), "remove_option() failed to report existence of option") - self.failIf(cf.has_option('Foo Bar', 'foo'), + self.assertFalse(cf.has_option('Foo Bar', 'foo'), "remove_option() failed to remove option") - self.failIf(cf.remove_option('Foo Bar', 'foo'), + self.assertFalse(cf.remove_option('Foo Bar', 'foo'), "remove_option() failed to report non-existence of option" " that was removed") @@ -107,10 +107,10 @@ class TestCaseBase(unittest.TestCase): eq(cf.options("a"), ["b"]) eq(cf.get("a", "b"), "value", "could not locate option, expecting case-insensitive option names") - self.failUnless(cf.has_option("a", "b")) + self.assertTrue(cf.has_option("a", "b")) cf.set("A", "A-B", "A-B value") for opt in ("a-b", "A-b", "a-B", "A-B"): - self.failUnless( + self.assertTrue( cf.has_option("A", opt), "has_option() returned false for option which should exist") eq(cf.options("A"), ["a-b"]) @@ -127,7 +127,7 @@ class TestCaseBase(unittest.TestCase): # SF bug #561822: cf = self.fromstring("[section]\nnekey=nevalue\n", defaults={"key":"value"}) - self.failUnless(cf.has_option("section", "Key")) + self.assertTrue(cf.has_option("section", "Key")) def test_default_case_sensitivity(self): @@ -163,7 +163,7 @@ class TestCaseBase(unittest.TestCase): cf = self.newconfig() self.assertEqual(cf.sections(), [], "new ConfigParser should have no defined sections") - self.failIf(cf.has_section("Foo"), + self.assertFalse(cf.has_section("Foo"), "new ConfigParser should have no acknowledged sections") self.assertRaises(configparser.NoSectionError, cf.options, "Foo") @@ -202,8 +202,8 @@ class TestCaseBase(unittest.TestCase): "E5=FALSE AND MORE" ) for x in range(1, 5): - self.failUnless(cf.getboolean('BOOLTEST', 't%d' % x)) - self.failIf(cf.getboolean('BOOLTEST', 'f%d' % x)) + self.assertTrue(cf.getboolean('BOOLTEST', 't%d' % x)) + self.assertFalse(cf.getboolean('BOOLTEST', 'f%d' % x)) self.assertRaises(ValueError, cf.getboolean, 'BOOLTEST', 'e%d' % x) diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py index 87028b5..ef7dfa5 100644 --- a/Lib/test/test_cgi.py +++ b/Lib/test/test_cgi.py @@ -143,7 +143,7 @@ class CgiTests(unittest.TestCase): # test individual fields for key in expect.keys(): expect_val = expect[key] - self.assert_(key in fs) + self.assertTrue(key in fs) if len(expect_val) > 1: self.assertEqual(fs.getvalue(key), expect_val) else: @@ -194,7 +194,7 @@ class CgiTests(unittest.TestCase): # if we're not chunking properly, readline is only called twice # (by read_binary); if we are chunking properly, it will be called 5 times # as long as the chunksize is 1 << 16. - self.assert_(f.numcalls > 2) + self.assertTrue(f.numcalls > 2) def test_fieldstorage_multipart(self): #Test basic FieldStorage multipart parsing diff --git a/Lib/test/test_cmath.py b/Lib/test/test_cmath.py index 17cb566..2d2deff 100755 --- a/Lib/test/test_cmath.py +++ b/Lib/test/test_cmath.py @@ -412,7 +412,7 @@ class CMathTests(unittest.TestCase): # real or imaginary part NaN for z in complex_nans: - self.assert_(math.isnan(phase(z))) + self.assertTrue(math.isnan(phase(z))) def test_abs(self): # zeros @@ -425,18 +425,18 @@ class CMathTests(unittest.TestCase): # real or imaginary part NaN self.assertEqual(abs(complex(NAN, -INF)), INF) - self.assert_(math.isnan(abs(complex(NAN, -2.3)))) - self.assert_(math.isnan(abs(complex(NAN, -0.0)))) - self.assert_(math.isnan(abs(complex(NAN, 0.0)))) - self.assert_(math.isnan(abs(complex(NAN, 2.3)))) + self.assertTrue(math.isnan(abs(complex(NAN, -2.3)))) + self.assertTrue(math.isnan(abs(complex(NAN, -0.0)))) + self.assertTrue(math.isnan(abs(complex(NAN, 0.0)))) + self.assertTrue(math.isnan(abs(complex(NAN, 2.3)))) self.assertEqual(abs(complex(NAN, INF)), INF) self.assertEqual(abs(complex(-INF, NAN)), INF) - self.assert_(math.isnan(abs(complex(-2.3, NAN)))) - self.assert_(math.isnan(abs(complex(-0.0, NAN)))) - self.assert_(math.isnan(abs(complex(0.0, NAN)))) - self.assert_(math.isnan(abs(complex(2.3, NAN)))) + self.assertTrue(math.isnan(abs(complex(-2.3, NAN)))) + self.assertTrue(math.isnan(abs(complex(-0.0, NAN)))) + self.assertTrue(math.isnan(abs(complex(0.0, NAN)))) + self.assertTrue(math.isnan(abs(complex(2.3, NAN)))) self.assertEqual(abs(complex(INF, NAN)), INF) - self.assert_(math.isnan(abs(complex(NAN, NAN)))) + self.assertTrue(math.isnan(abs(complex(NAN, NAN)))) # result overflows if float.__getformat__("double").startswith("IEEE"): @@ -455,26 +455,26 @@ class CMathTests(unittest.TestCase): self.assertCEqual(rect(1, -pi/2), (0, -1.)) def test_isnan(self): - self.failIf(cmath.isnan(1)) - self.failIf(cmath.isnan(1j)) - self.failIf(cmath.isnan(INF)) - self.assert_(cmath.isnan(NAN)) - self.assert_(cmath.isnan(complex(NAN, 0))) - self.assert_(cmath.isnan(complex(0, NAN))) - self.assert_(cmath.isnan(complex(NAN, NAN))) - self.assert_(cmath.isnan(complex(NAN, INF))) - self.assert_(cmath.isnan(complex(INF, NAN))) + self.assertFalse(cmath.isnan(1)) + self.assertFalse(cmath.isnan(1j)) + self.assertFalse(cmath.isnan(INF)) + self.assertTrue(cmath.isnan(NAN)) + self.assertTrue(cmath.isnan(complex(NAN, 0))) + self.assertTrue(cmath.isnan(complex(0, NAN))) + self.assertTrue(cmath.isnan(complex(NAN, NAN))) + self.assertTrue(cmath.isnan(complex(NAN, INF))) + self.assertTrue(cmath.isnan(complex(INF, NAN))) def test_isinf(self): - self.failIf(cmath.isinf(1)) - self.failIf(cmath.isinf(1j)) - self.failIf(cmath.isinf(NAN)) - self.assert_(cmath.isinf(INF)) - self.assert_(cmath.isinf(complex(INF, 0))) - self.assert_(cmath.isinf(complex(0, INF))) - self.assert_(cmath.isinf(complex(INF, INF))) - self.assert_(cmath.isinf(complex(NAN, INF))) - self.assert_(cmath.isinf(complex(INF, NAN))) + self.assertFalse(cmath.isinf(1)) + self.assertFalse(cmath.isinf(1j)) + self.assertFalse(cmath.isinf(NAN)) + self.assertTrue(cmath.isinf(INF)) + self.assertTrue(cmath.isinf(complex(INF, 0))) + self.assertTrue(cmath.isinf(complex(0, INF))) + self.assertTrue(cmath.isinf(complex(INF, INF))) + self.assertTrue(cmath.isinf(complex(NAN, INF))) + self.assertTrue(cmath.isinf(complex(INF, NAN))) def test_main(): diff --git a/Lib/test/test_cmd_line.py b/Lib/test/test_cmd_line.py index ef3c109..87ae2b6 100644 --- a/Lib/test/test_cmd_line.py +++ b/Lib/test/test_cmd_line.py @@ -169,7 +169,7 @@ class CmdLineTest(unittest.TestCase): p.stdin.flush() data, rc = _kill_python_and_exit_code(p) self.assertEqual(rc, 0) - self.assert_(data.startswith(b'x'), data) + self.assertTrue(data.startswith(b'x'), data) def test_large_PYTHONPATH(self): with test.support.EnvironmentVarGuard() as env: @@ -178,8 +178,8 @@ class CmdLineTest(unittest.TestCase): env['PYTHONPATH'] = path1 + os.pathsep + path2 p = _spawn_python('-S', '-c', 'import sys; print(sys.path)') stdout, _ = p.communicate() - self.assert_(path1.encode('ascii') in stdout) - self.assert_(path2.encode('ascii') in stdout) + self.assertTrue(path1.encode('ascii') in stdout) + self.assertTrue(path2.encode('ascii') in stdout) def test_main(): diff --git a/Lib/test/test_cmd_line_script.py b/Lib/test/test_cmd_line_script.py index e060ec1..7114681 100644 --- a/Lib/test/test_cmd_line_script.py +++ b/Lib/test/test_cmd_line_script.py @@ -154,9 +154,9 @@ class CmdLineTest(unittest.TestCase): print(printed_file) print(printed_package) print(printed_argv0) - self.assert_(printed_file in data) - self.assert_(printed_package in data) - self.assert_(printed_argv0 in data) + self.assertTrue(printed_file in data) + self.assertTrue(printed_package in data) + self.assertTrue(printed_argv0 in data) def _check_import_error(self, script_name, expected_msg, *cmd_line_switches): @@ -166,7 +166,7 @@ class CmdLineTest(unittest.TestCase): print('Output from test script %r:' % script_name) print(data) print('Expected output: %r' % expected_msg) - self.assert_(expected_msg in data) + self.assertTrue(expected_msg in data) def test_basic_script(self): with temp_dir() as script_dir: diff --git a/Lib/test/test_codecs.py b/Lib/test/test_codecs.py index e060471..9f73453 100644 --- a/Lib/test/test_codecs.py +++ b/Lib/test/test_codecs.py @@ -29,14 +29,14 @@ class MixInCheckStateHandling: d = codecs.getincrementaldecoder(encoding)() part1 = d.decode(s[:i]) state = d.getstate() - self.assert_(isinstance(state[1], int)) + self.assertTrue(isinstance(state[1], int)) # Check that the condition stated in the documentation for # IncrementalDecoder.getstate() holds if not state[1]: # reset decoder to the default state without anything buffered d.setstate((state[0][:0], 0)) # Feeding the previous input may not produce any output - self.assert_(not d.decode(state[0])) + self.assertTrue(not d.decode(state[0])) # The decoder must return to the same state self.assertEqual(state, d.getstate()) # Create a new decoder and set it to the state @@ -296,7 +296,7 @@ class UTF32Test(ReadTest): f.write("spam") d = s.getvalue() # check whether there is exactly one BOM in it - self.assert_(d == self.spamle or d == self.spambe) + self.assertTrue(d == self.spamle or d == self.spambe) # try to read it back s = io.BytesIO(d) f = reader(s) @@ -429,7 +429,7 @@ class UTF16Test(ReadTest): f.write("spam") d = s.getvalue() # check whether there is exactly one BOM in it - self.assert_(d == self.spamle or d == self.spambe) + self.assertTrue(d == self.spamle or d == self.spambe) # try to read it back s = io.BytesIO(d) f = reader(s) @@ -1335,7 +1335,7 @@ class BasicUnicodeTest(unittest.TestCase, MixInCheckStateHandling): for c in s: writer.write(c) chunk = q.read() - self.assert_(type(chunk) is bytes, type(chunk)) + self.assertTrue(type(chunk) is bytes, type(chunk)) encodedresult += chunk q = Queue(b"") reader = codecs.getreader(encoding)(q) diff --git a/Lib/test/test_codeop.py b/Lib/test/test_codeop.py index 134c3ae..ad44121 100644 --- a/Lib/test/test_codeop.py +++ b/Lib/test/test_codeop.py @@ -23,7 +23,7 @@ class CodeopTests(unittest.TestCase): '''succeed iff str is a valid piece of code''' if is_jython: code = compile_command(str, "", symbol) - self.assert_(code) + self.assertTrue(code) if symbol == "single": d,r = {},{} saved_stdout = sys.stdout @@ -52,9 +52,9 @@ class CodeopTests(unittest.TestCase): compile_command(str,symbol=symbol) self.fail("No exception thrown for invalid code") except SyntaxError: - self.assert_(is_syntax) + self.assertTrue(is_syntax) except OverflowError: - self.assert_(not is_syntax) + self.assertTrue(not is_syntax) def test_valid(self): av = self.assertValid diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py index 8387564..ded8b70 100644 --- a/Lib/test/test_collections.py +++ b/Lib/test/test_collections.py @@ -44,9 +44,9 @@ class TestNamedTuple(unittest.TestCase): namedtuple('_', 'a b c') # Test leading underscores in a typename nt = namedtuple('nt', 'the quick brown fox') # check unicode input - self.assert_("u'" not in repr(nt._fields)) + self.assertTrue("u'" not in repr(nt._fields)) nt = namedtuple('nt', ('the', 'quick')) # check unicode input - self.assert_("u'" not in repr(nt._fields)) + self.assertTrue("u'" not in repr(nt._fields)) self.assertRaises(TypeError, Point._make, [11]) # catch too few args self.assertRaises(TypeError, Point._make, [11, 22, 33]) # catch too many args @@ -75,8 +75,8 @@ class TestNamedTuple(unittest.TestCase): self.assertRaises(TypeError, eval, 'Point(XXX=1, y=2)', locals()) # wrong keyword argument self.assertRaises(TypeError, eval, 'Point(x=1)', locals()) # missing keyword argument self.assertEqual(repr(p), 'Point(x=11, y=22)') - self.assert_('__dict__' not in dir(p)) # verify instance has no dict - self.assert_('__weakref__' not in dir(p)) + self.assertTrue('__dict__' not in dir(p)) # verify instance has no dict + self.assertTrue('__weakref__' not in dir(p)) self.assertEqual(p, Point._make([11, 22])) # test _make classmethod self.assertEqual(p._fields, ('x', 'y')) # test _fields attribute self.assertEqual(p._replace(x=1), (1, 22)) # test _replace method @@ -103,7 +103,7 @@ class TestNamedTuple(unittest.TestCase): Point = namedtuple('Point', 'x y') p = Point(11, 22) - self.assert_(isinstance(p, tuple)) + self.assertTrue(isinstance(p, tuple)) self.assertEqual(p, (11, 22)) # matches a real tuple self.assertEqual(tuple(p), (11, 22)) # coercable to a real tuple self.assertEqual(list(p), [11, 22]) # coercable to a list @@ -236,8 +236,8 @@ class TestOneTrickPonyABCs(ABCTestCase): # Check some non-hashables non_samples = [bytearray(), list(), set(), dict()] for x in non_samples: - self.failIf(isinstance(x, Hashable), repr(x)) - self.failIf(issubclass(type(x), Hashable), repr(type(x))) + self.assertFalse(isinstance(x, Hashable), repr(x)) + self.assertFalse(issubclass(type(x), Hashable), repr(type(x))) # Check some hashables samples = [None, int(), float(), complex(), @@ -246,23 +246,23 @@ class TestOneTrickPonyABCs(ABCTestCase): int, list, object, type, bytes() ] for x in samples: - self.failUnless(isinstance(x, Hashable), repr(x)) - self.failUnless(issubclass(type(x), Hashable), repr(type(x))) + self.assertTrue(isinstance(x, Hashable), repr(x)) + self.assertTrue(issubclass(type(x), Hashable), repr(type(x))) self.assertRaises(TypeError, Hashable) # Check direct subclassing class H(Hashable): def __hash__(self): return super().__hash__() self.assertEqual(hash(H()), 0) - self.failIf(issubclass(int, H)) + self.assertFalse(issubclass(int, H)) self.validate_abstract_methods(Hashable, '__hash__') def test_Iterable(self): # Check some non-iterables non_samples = [None, 42, 3.14, 1j] for x in non_samples: - self.failIf(isinstance(x, Iterable), repr(x)) - self.failIf(issubclass(type(x), Iterable), repr(type(x))) + self.assertFalse(isinstance(x, Iterable), repr(x)) + self.assertFalse(issubclass(type(x), Iterable), repr(type(x))) # Check some iterables samples = [bytes(), str(), tuple(), list(), set(), frozenset(), dict(), @@ -271,21 +271,21 @@ class TestOneTrickPonyABCs(ABCTestCase): (x for x in []), ] for x in samples: - self.failUnless(isinstance(x, Iterable), repr(x)) - self.failUnless(issubclass(type(x), Iterable), repr(type(x))) + self.assertTrue(isinstance(x, Iterable), repr(x)) + self.assertTrue(issubclass(type(x), Iterable), repr(type(x))) # Check direct subclassing class I(Iterable): def __iter__(self): return super().__iter__() self.assertEqual(list(I()), []) - self.failIf(issubclass(str, I)) + self.assertFalse(issubclass(str, I)) self.validate_abstract_methods(Iterable, '__iter__') def test_Iterator(self): non_samples = [None, 42, 3.14, 1j, b"", "", (), [], {}, set()] for x in non_samples: - self.failIf(isinstance(x, Iterator), repr(x)) - self.failIf(issubclass(type(x), Iterator), repr(type(x))) + self.assertFalse(isinstance(x, Iterator), repr(x)) + self.assertFalse(issubclass(type(x), Iterator), repr(type(x))) samples = [iter(bytes()), iter(str()), iter(tuple()), iter(list()), iter(dict()), iter(set()), iter(frozenset()), @@ -295,8 +295,8 @@ class TestOneTrickPonyABCs(ABCTestCase): (x for x in []), ] for x in samples: - self.failUnless(isinstance(x, Iterator), repr(x)) - self.failUnless(issubclass(type(x), Iterator), repr(type(x))) + self.assertTrue(isinstance(x, Iterator), repr(x)) + self.assertTrue(issubclass(type(x), Iterator), repr(type(x))) self.validate_abstract_methods(Iterator, '__next__') def test_Sized(self): @@ -305,15 +305,15 @@ class TestOneTrickPonyABCs(ABCTestCase): (x for x in []), ] for x in non_samples: - self.failIf(isinstance(x, Sized), repr(x)) - self.failIf(issubclass(type(x), Sized), repr(type(x))) + self.assertFalse(isinstance(x, Sized), repr(x)) + self.assertFalse(issubclass(type(x), Sized), repr(type(x))) samples = [bytes(), str(), tuple(), list(), set(), frozenset(), dict(), dict().keys(), dict().items(), dict().values(), ] for x in samples: - self.failUnless(isinstance(x, Sized), repr(x)) - self.failUnless(issubclass(type(x), Sized), repr(type(x))) + self.assertTrue(isinstance(x, Sized), repr(x)) + self.assertTrue(issubclass(type(x), Sized), repr(type(x))) self.validate_abstract_methods(Sized, '__len__') def test_Container(self): @@ -322,15 +322,15 @@ class TestOneTrickPonyABCs(ABCTestCase): (x for x in []), ] for x in non_samples: - self.failIf(isinstance(x, Container), repr(x)) - self.failIf(issubclass(type(x), Container), repr(type(x))) + self.assertFalse(isinstance(x, Container), repr(x)) + self.assertFalse(issubclass(type(x), Container), repr(type(x))) samples = [bytes(), str(), tuple(), list(), set(), frozenset(), dict(), dict().keys(), dict().items(), ] for x in samples: - self.failUnless(isinstance(x, Container), repr(x)) - self.failUnless(issubclass(type(x), Container), repr(type(x))) + self.assertTrue(isinstance(x, Container), repr(x)) + self.assertTrue(issubclass(type(x), Container), repr(type(x))) self.validate_abstract_methods(Container, '__contains__') def test_Callable(self): @@ -340,32 +340,32 @@ class TestOneTrickPonyABCs(ABCTestCase): (x for x in []), ] for x in non_samples: - self.failIf(isinstance(x, Callable), repr(x)) - self.failIf(issubclass(type(x), Callable), repr(type(x))) + self.assertFalse(isinstance(x, Callable), repr(x)) + self.assertFalse(issubclass(type(x), Callable), repr(type(x))) samples = [lambda: None, type, int, object, len, list.append, [].append, ] for x in samples: - self.failUnless(isinstance(x, Callable), repr(x)) - self.failUnless(issubclass(type(x), Callable), repr(type(x))) + self.assertTrue(isinstance(x, Callable), repr(x)) + self.assertTrue(issubclass(type(x), Callable), repr(type(x))) self.validate_abstract_methods(Callable, '__call__') def test_direct_subclassing(self): for B in Hashable, Iterable, Iterator, Sized, Container, Callable: class C(B): pass - self.failUnless(issubclass(C, B)) - self.failIf(issubclass(int, C)) + self.assertTrue(issubclass(C, B)) + self.assertFalse(issubclass(int, C)) def test_registration(self): for B in Hashable, Iterable, Iterator, Sized, Container, Callable: class C: __hash__ = None # Make sure it isn't hashable by default - self.failIf(issubclass(C, B), B.__name__) + self.assertFalse(issubclass(C, B), B.__name__) B.register(C) - self.failUnless(issubclass(C, B)) + self.assertTrue(issubclass(C, B)) class WithSet(MutableSet): @@ -395,8 +395,8 @@ class TestCollectionABCs(ABCTestCase): def test_Set(self): for sample in [set, frozenset]: - self.failUnless(isinstance(sample(), Set)) - self.failUnless(issubclass(sample, Set)) + self.assertTrue(isinstance(sample(), Set)) + self.assertTrue(issubclass(sample, Set)) self.validate_abstract_methods(Set, '__contains__', '__iter__', '__len__') def test_hash_Set(self): @@ -412,13 +412,13 @@ class TestCollectionABCs(ABCTestCase): def __hash__(self): return self._hash() a, b = OneTwoThreeSet(), OneTwoThreeSet() - self.failUnless(hash(a) == hash(b)) + self.assertTrue(hash(a) == hash(b)) def test_MutableSet(self): - self.failUnless(isinstance(set(), MutableSet)) - self.failUnless(issubclass(set, MutableSet)) - self.failIf(isinstance(frozenset(), MutableSet)) - self.failIf(issubclass(frozenset, MutableSet)) + self.assertTrue(isinstance(set(), MutableSet)) + self.assertTrue(issubclass(set, MutableSet)) + self.assertFalse(isinstance(frozenset(), MutableSet)) + self.assertFalse(issubclass(frozenset, MutableSet)) self.validate_abstract_methods(MutableSet, '__contains__', '__iter__', '__len__', 'add', 'discard') @@ -457,46 +457,46 @@ class TestCollectionABCs(ABCTestCase): def test_Mapping(self): for sample in [dict]: - self.failUnless(isinstance(sample(), Mapping)) - self.failUnless(issubclass(sample, Mapping)) + self.assertTrue(isinstance(sample(), Mapping)) + self.assertTrue(issubclass(sample, Mapping)) self.validate_abstract_methods(Mapping, '__contains__', '__iter__', '__len__', '__getitem__') def test_MutableMapping(self): for sample in [dict]: - self.failUnless(isinstance(sample(), MutableMapping)) - self.failUnless(issubclass(sample, MutableMapping)) + self.assertTrue(isinstance(sample(), MutableMapping)) + self.assertTrue(issubclass(sample, MutableMapping)) self.validate_abstract_methods(MutableMapping, '__contains__', '__iter__', '__len__', '__getitem__', '__setitem__', '__delitem__') def test_Sequence(self): for sample in [tuple, list, bytes, str]: - self.failUnless(isinstance(sample(), Sequence)) - self.failUnless(issubclass(sample, Sequence)) - self.failUnless(isinstance(range(10), Sequence)) - self.failUnless(issubclass(range, Sequence)) - self.failUnless(issubclass(str, Sequence)) + self.assertTrue(isinstance(sample(), Sequence)) + self.assertTrue(issubclass(sample, Sequence)) + self.assertTrue(isinstance(range(10), Sequence)) + self.assertTrue(issubclass(range, Sequence)) + self.assertTrue(issubclass(str, Sequence)) self.validate_abstract_methods(Sequence, '__contains__', '__iter__', '__len__', '__getitem__') def test_ByteString(self): for sample in [bytes, bytearray]: - self.failUnless(isinstance(sample(), ByteString)) - self.failUnless(issubclass(sample, ByteString)) + self.assertTrue(isinstance(sample(), ByteString)) + self.assertTrue(issubclass(sample, ByteString)) for sample in [str, list, tuple]: - self.failIf(isinstance(sample(), ByteString)) - self.failIf(issubclass(sample, ByteString)) - self.failIf(isinstance(memoryview(b""), ByteString)) - self.failIf(issubclass(memoryview, ByteString)) + self.assertFalse(isinstance(sample(), ByteString)) + self.assertFalse(issubclass(sample, ByteString)) + self.assertFalse(isinstance(memoryview(b""), ByteString)) + self.assertFalse(issubclass(memoryview, ByteString)) def test_MutableSequence(self): for sample in [tuple, str, bytes]: - self.failIf(isinstance(sample(), MutableSequence)) - self.failIf(issubclass(sample, MutableSequence)) + self.assertFalse(isinstance(sample(), MutableSequence)) + self.assertFalse(issubclass(sample, MutableSequence)) for sample in [list, bytearray]: - self.failUnless(isinstance(sample(), MutableSequence)) - self.failUnless(issubclass(sample, MutableSequence)) - self.failIf(issubclass(str, MutableSequence)) + self.assertTrue(isinstance(sample(), MutableSequence)) + self.assertTrue(issubclass(sample, MutableSequence)) + self.assertFalse(issubclass(str, MutableSequence)) self.validate_abstract_methods(MutableSequence, '__contains__', '__iter__', '__len__', '__getitem__', '__setitem__', '__delitem__', 'insert') @@ -506,10 +506,10 @@ class TestCounter(unittest.TestCase): c = Counter('abcaba') self.assertEqual(c, Counter({'a':3 , 'b': 2, 'c': 1})) self.assertEqual(c, Counter(a=3, b=2, c=1)) - self.assert_(isinstance(c, dict)) - self.assert_(isinstance(c, Mapping)) - self.assert_(issubclass(Counter, dict)) - self.assert_(issubclass(Counter, Mapping)) + self.assertTrue(isinstance(c, dict)) + self.assertTrue(isinstance(c, Mapping)) + self.assertTrue(issubclass(Counter, dict)) + self.assertTrue(issubclass(Counter, Mapping)) self.assertEqual(len(c), 3) self.assertEqual(sum(c.values()), 6) self.assertEqual(sorted(c.values()), [1, 2, 3]) @@ -581,7 +581,7 @@ class TestCounter(unittest.TestCase): Counter(words), ]): msg = (i, dup, words) - self.assert_(dup is not words) + self.assertTrue(dup is not words) self.assertEquals(dup, words) self.assertEquals(len(dup), len(words)) self.assertEquals(type(dup), type(words)) @@ -597,7 +597,7 @@ class TestCounter(unittest.TestCase): def test_invariant_for_the_in_operator(self): c = Counter(a=10, b=-2, c=0) for elem in c: - self.assert_(elem in c) + self.assertTrue(elem in c) def test_multiset_operations(self): # Verify that adding a zero counter will strip zeros and negatives @@ -622,7 +622,7 @@ class TestCounter(unittest.TestCase): self.assertEqual(numberop(p[x], q[x]), result[x], (counterop, x, p, q)) # verify that results exclude non-positive counts - self.assert_(x>0 for x in result.values()) + self.assertTrue(x>0 for x in result.values()) elements = 'abcdef' for i in range(100): @@ -697,7 +697,7 @@ class TestOrderedDict(unittest.TestCase): pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)] od = OrderedDict(pairs) del od['a'] - self.assert_('a' not in od) + self.assertTrue('a' not in od) with self.assertRaises(KeyError): del od['a'] self.assertEqual(list(od.items()), pairs[:2] + pairs[3:]) @@ -778,7 +778,7 @@ class TestOrderedDict(unittest.TestCase): update_test, OrderedDict(od), ]): - self.assert_(dup is not od) + self.assertTrue(dup is not od) self.assertEquals(dup, od) self.assertEquals(list(dup.items()), list(od.items())) self.assertEquals(len(dup), len(od)) @@ -791,7 +791,7 @@ class TestOrderedDict(unittest.TestCase): od = OrderedDict(pairs) # yaml.dump(od) --> # '!!python/object/apply:__main__.OrderedDict\n- - [a, 1]\n - [b, 2]\n' - self.assert_(all(type(pair)==list for pair in od.__reduce__()[1])) + self.assertTrue(all(type(pair)==list for pair in od.__reduce__()[1])) def test_reduce_not_too_fat(self): # do not save instance dictionary if not needed diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py index 2b978eb..5d1f478 100644 --- a/Lib/test/test_compile.py +++ b/Lib/test/test_compile.py @@ -372,10 +372,10 @@ if 1: import __mangled_mod import __package__.module - self.assert_("_A__mangled" in A.f.__code__.co_varnames) - self.assert_("__not_mangled__" in A.f.__code__.co_varnames) - self.assert_("_A__mangled_mod" in A.f.__code__.co_varnames) - self.assert_("__package__" in A.f.__code__.co_varnames) + self.assertTrue("_A__mangled" in A.f.__code__.co_varnames) + self.assertTrue("__not_mangled__" in A.f.__code__.co_varnames) + self.assertTrue("_A__mangled_mod" in A.f.__code__.co_varnames) + self.assertTrue("__package__" in A.f.__code__.co_varnames) def test_compile_ast(self): fname = __file__ @@ -394,7 +394,7 @@ if 1: for fname, code in sample_code: co1 = compile(code, '%s1' % fname, 'exec') ast = compile(code, '%s2' % fname, 'exec', _ast.PyCF_ONLY_AST) - self.assert_(type(ast) == _ast.Module) + self.assertTrue(type(ast) == _ast.Module) co2 = compile(ast, '%s3' % fname, 'exec') self.assertEqual(co1, co2) # the code object's filename comes from the second compilation step diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py index f621186..faa7e1f 100644 --- a/Lib/test/test_complex.py +++ b/Lib/test/test_complex.py @@ -35,7 +35,7 @@ class ComplexTest(unittest.TestCase): if x == 0: return abs(y) < eps # check that relative difference < eps - self.assert_(abs((x-y)/y) < eps) + self.assertTrue(abs((x-y)/y) < eps) def assertFloatsAreIdentical(self, x, y): """assert that floats x and y are identical, in the sense that: @@ -66,7 +66,7 @@ class ComplexTest(unittest.TestCase): self.assertCloseAbs(x.imag, y.imag, eps) def assertIs(self, a, b): - self.assert_(a is b) + self.assertTrue(a is b) def check_div(self, x, y): """Compute complex z=x*y, and check that z/x==y and z/y==x.""" @@ -174,8 +174,8 @@ class ComplexTest(unittest.TestCase): def test_boolcontext(self): for i in range(100): - self.assert_(complex(random() + 1e-6, random() + 1e-6)) - self.assert_(not complex(0.0, 0.0)) + self.assertTrue(complex(random() + 1e-6, random() + 1e-6)) + self.assertTrue(not complex(0.0, 0.0)) def test_conjugate(self): self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j) @@ -257,7 +257,7 @@ class ComplexTest(unittest.TestCase): self.assertEqual(split_zeros(complex(-0., 1.).real), split_zeros(-0.)) c = 3.14 + 1j - self.assert_(complex(c) is c) + self.assertTrue(complex(c) is c) del c self.assertRaises(TypeError, complex, "1", "1") diff --git a/Lib/test/test_contains.py b/Lib/test/test_contains.py index 3f0b234..622dfd4 100644 --- a/Lib/test/test_contains.py +++ b/Lib/test/test_contains.py @@ -20,19 +20,19 @@ class TestContains(unittest.TestCase): a = base_set(1) b = myset(1) c = seq(1) - self.assert_(1 in b) - self.assert_(0 not in b) - self.assert_(1 in c) - self.assert_(0 not in c) + self.assertTrue(1 in b) + self.assertTrue(0 not in b) + self.assertTrue(1 in c) + self.assertTrue(0 not in c) self.assertRaises(TypeError, lambda: 1 in a) self.assertRaises(TypeError, lambda: 1 not in a) # test char in string - self.assert_('c' in 'abc') - self.assert_('d' not in 'abc') + self.assertTrue('c' in 'abc') + self.assertTrue('d' not in 'abc') - self.assert_('' in '') - self.assert_('' in 'abc') + self.assertTrue('' in '') + self.assertTrue('' in 'abc') self.assertRaises(TypeError, lambda: None in 'abc') @@ -40,15 +40,15 @@ class TestContains(unittest.TestCase): # a collection of tests on builtin sequence types a = range(10) for i in a: - self.assert_(i in a) - self.assert_(16 not in a) - self.assert_(a not in a) + self.assertTrue(i in a) + self.assertTrue(16 not in a) + self.assertTrue(a not in a) a = tuple(a) for i in a: - self.assert_(i in a) - self.assert_(16 not in a) - self.assert_(a not in a) + self.assertTrue(i in a) + self.assertTrue(16 not in a) + self.assertTrue(a not in a) class Deviant1: """Behaves strangely when compared @@ -64,7 +64,7 @@ class TestContains(unittest.TestCase): self.aList.remove(14) return 0 - self.assert_(Deviant1() not in Deviant1.aList) + self.assertTrue(Deviant1() not in Deviant1.aList) def test_nonreflexive(self): # containment and equality tests involving elements that are @@ -81,9 +81,9 @@ class TestContains(unittest.TestCase): for constructor in constructors: container = constructor(values) for elem in container: - self.assert_(elem in container) - self.assert_(container == constructor(values)) - self.assert_(container == container) + self.assertTrue(elem in container) + self.assertTrue(container == constructor(values)) + self.assertTrue(container == container) def test_main(): diff --git a/Lib/test/test_contextlib.py b/Lib/test/test_contextlib.py index f97cd81..015a0c5 100644 --- a/Lib/test/test_contextlib.py +++ b/Lib/test/test_contextlib.py @@ -54,7 +54,7 @@ class ContextManagerTestCase(unittest.TestCase): ctx = whee() ctx.__enter__() # Calling __exit__ should not result in an exception - self.failIf(ctx.__exit__(TypeError, TypeError("foo"), None)) + self.assertFalse(ctx.__exit__(TypeError, TypeError("foo"), None)) def test_contextmanager_trap_yield_after_throw(self): @contextmanager @@ -261,17 +261,17 @@ class FileContextTestCase(unittest.TestCase): try: f = None with open(tfn, "w") as f: - self.failIf(f.closed) + self.assertFalse(f.closed) f.write("Booh\n") - self.failUnless(f.closed) + self.assertTrue(f.closed) f = None try: with open(tfn, "r") as f: - self.failIf(f.closed) + self.assertFalse(f.closed) self.assertEqual(f.read(), "Booh\n") 1/0 except ZeroDivisionError: - self.failUnless(f.closed) + self.assertTrue(f.closed) else: self.fail("Didn't raise ZeroDivisionError") finally: @@ -283,16 +283,16 @@ class FileContextTestCase(unittest.TestCase): class LockContextTestCase(unittest.TestCase): def boilerPlate(self, lock, locked): - self.failIf(locked()) + self.assertFalse(locked()) with lock: - self.failUnless(locked()) - self.failIf(locked()) + self.assertTrue(locked()) + self.assertFalse(locked()) try: with lock: - self.failUnless(locked()) + self.assertTrue(locked()) 1/0 except ZeroDivisionError: - self.failIf(locked()) + self.assertFalse(locked()) else: self.fail("Didn't raise ZeroDivisionError") diff --git a/Lib/test/test_copy.py b/Lib/test/test_copy.py index 502bf3f..2af2109 100644 --- a/Lib/test/test_copy.py +++ b/Lib/test/test_copy.py @@ -17,8 +17,8 @@ class TestCopy(unittest.TestCase): # Attempt full line coverage of copy.py from top to bottom def test_exceptions(self): - self.assert_(copy.Error is copy.error) - self.assert_(issubclass(copy.Error, Exception)) + self.assertTrue(copy.Error is copy.error) + self.assertTrue(issubclass(copy.Error, Exception)) # The copy() method @@ -59,7 +59,7 @@ class TestCopy(unittest.TestCase): raise support.TestFailed("shouldn't call this") x = C() y = copy.copy(x) - self.assert_(y is x) + self.assertTrue(y is x) def test_copy_reduce(self): class C(object): @@ -67,7 +67,7 @@ class TestCopy(unittest.TestCase): return "" x = C() y = copy.copy(x) - self.assert_(y is x) + self.assertTrue(y is x) def test_copy_cant(self): class C(object): @@ -91,7 +91,7 @@ class TestCopy(unittest.TestCase): "hello", "hello\u1234", f.__code__, NewStyle, range(10), Classic, max] for x in tests: - self.assert_(copy.copy(x) is x, repr(x)) + self.assertTrue(copy.copy(x) is x, repr(x)) def test_copy_list(self): x = [1, 2, 3] @@ -185,9 +185,9 @@ class TestCopy(unittest.TestCase): x = [x, x] y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(y is not x) - self.assert_(y[0] is not x[0]) - self.assert_(y[0] is y[1]) + self.assertTrue(y is not x) + self.assertTrue(y[0] is not x[0]) + self.assertTrue(y[0] is y[1]) def test_deepcopy_issubclass(self): # XXX Note: there's no way to test the TypeError coming out of @@ -232,7 +232,7 @@ class TestCopy(unittest.TestCase): raise support.TestFailed("shouldn't call this") x = C() y = copy.deepcopy(x) - self.assert_(y is x) + self.assertTrue(y is x) def test_deepcopy_reduce(self): class C(object): @@ -240,7 +240,7 @@ class TestCopy(unittest.TestCase): return "" x = C() y = copy.deepcopy(x) - self.assert_(y is x) + self.assertTrue(y is x) def test_deepcopy_cant(self): class C(object): @@ -264,14 +264,14 @@ class TestCopy(unittest.TestCase): "hello", "hello\u1234", f.__code__, NewStyle, range(10), Classic, max] for x in tests: - self.assert_(copy.deepcopy(x) is x, repr(x)) + self.assertTrue(copy.deepcopy(x) is x, repr(x)) def test_deepcopy_list(self): x = [[1, 2], 3] y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(x is not y) - self.assert_(x[0] is not y[0]) + self.assertTrue(x is not y) + self.assertTrue(x[0] is not y[0]) def test_deepcopy_reflexive_list(self): x = [] @@ -279,16 +279,16 @@ class TestCopy(unittest.TestCase): y = copy.deepcopy(x) for op in comparisons: self.assertRaises(RuntimeError, op, y, x) - self.assert_(y is not x) - self.assert_(y[0] is y) + self.assertTrue(y is not x) + self.assertTrue(y[0] is y) self.assertEqual(len(y), 1) def test_deepcopy_tuple(self): x = ([1, 2], 3) y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(x is not y) - self.assert_(x[0] is not y[0]) + self.assertTrue(x is not y) + self.assertTrue(x[0] is not y[0]) def test_deepcopy_reflexive_tuple(self): x = ([],) @@ -296,16 +296,16 @@ class TestCopy(unittest.TestCase): y = copy.deepcopy(x) for op in comparisons: self.assertRaises(RuntimeError, op, y, x) - self.assert_(y is not x) - self.assert_(y[0] is not x[0]) - self.assert_(y[0][0] is y) + self.assertTrue(y is not x) + self.assertTrue(y[0] is not x[0]) + self.assertTrue(y[0][0] is y) def test_deepcopy_dict(self): x = {"foo": [1, 2], "bar": 3} y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(x is not y) - self.assert_(x["foo"] is not y["foo"]) + self.assertTrue(x is not y) + self.assertTrue(x["foo"] is not y["foo"]) def test_deepcopy_reflexive_dict(self): x = {} @@ -315,15 +315,15 @@ class TestCopy(unittest.TestCase): self.assertRaises(TypeError, op, y, x) for op in equality_comparisons: self.assertRaises(RuntimeError, op, y, x) - self.assert_(y is not x) - self.assert_(y['foo'] is y) + self.assertTrue(y is not x) + self.assertTrue(y['foo'] is y) self.assertEqual(len(y), 1) def test_deepcopy_keepalive(self): memo = {} x = 42 y = copy.deepcopy(x, memo) - self.assert_(memo[id(x)] is x) + self.assertTrue(memo[id(x)] is x) def test_deepcopy_inst_vanilla(self): class C: @@ -334,7 +334,7 @@ class TestCopy(unittest.TestCase): x = C([42]) y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(y.foo is not x.foo) + self.assertTrue(y.foo is not x.foo) def test_deepcopy_inst_deepcopy(self): class C: @@ -347,8 +347,8 @@ class TestCopy(unittest.TestCase): x = C([42]) y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(y is not x) - self.assert_(y.foo is not x.foo) + self.assertTrue(y is not x) + self.assertTrue(y.foo is not x.foo) def test_deepcopy_inst_getinitargs(self): class C: @@ -361,8 +361,8 @@ class TestCopy(unittest.TestCase): x = C([42]) y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(y is not x) - self.assert_(y.foo is not x.foo) + self.assertTrue(y is not x) + self.assertTrue(y.foo is not x.foo) def test_deepcopy_inst_getstate(self): class C: @@ -375,8 +375,8 @@ class TestCopy(unittest.TestCase): x = C([42]) y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(y is not x) - self.assert_(y.foo is not x.foo) + self.assertTrue(y is not x) + self.assertTrue(y.foo is not x.foo) def test_deepcopy_inst_setstate(self): class C: @@ -389,8 +389,8 @@ class TestCopy(unittest.TestCase): x = C([42]) y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(y is not x) - self.assert_(y.foo is not x.foo) + self.assertTrue(y is not x) + self.assertTrue(y.foo is not x.foo) def test_deepcopy_inst_getstate_setstate(self): class C: @@ -405,8 +405,8 @@ class TestCopy(unittest.TestCase): x = C([42]) y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(y is not x) - self.assert_(y.foo is not x.foo) + self.assertTrue(y is not x) + self.assertTrue(y.foo is not x.foo) def test_deepcopy_reflexive_inst(self): class C: @@ -414,8 +414,8 @@ class TestCopy(unittest.TestCase): x = C() x.foo = x y = copy.deepcopy(x) - self.assert_(y is not x) - self.assert_(y.foo is y) + self.assertTrue(y is not x) + self.assertTrue(y.foo is y) # _reconstruct() @@ -425,9 +425,9 @@ class TestCopy(unittest.TestCase): return "" x = C() y = copy.copy(x) - self.assert_(y is x) + self.assertTrue(y is x) y = copy.deepcopy(x) - self.assert_(y is x) + self.assertTrue(y is x) def test_reconstruct_nostate(self): class C(object): @@ -436,9 +436,9 @@ class TestCopy(unittest.TestCase): x = C() x.foo = 42 y = copy.copy(x) - self.assert_(y.__class__ is x.__class__) + self.assertTrue(y.__class__ is x.__class__) y = copy.deepcopy(x) - self.assert_(y.__class__ is x.__class__) + self.assertTrue(y.__class__ is x.__class__) def test_reconstruct_state(self): class C(object): @@ -452,7 +452,7 @@ class TestCopy(unittest.TestCase): self.assertEqual(y, x) y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(y.foo is not x.foo) + self.assertTrue(y.foo is not x.foo) def test_reconstruct_state_setstate(self): class C(object): @@ -468,7 +468,7 @@ class TestCopy(unittest.TestCase): self.assertEqual(y, x) y = copy.deepcopy(x) self.assertEqual(y, x) - self.assert_(y.foo is not x.foo) + self.assertTrue(y.foo is not x.foo) def test_reconstruct_reflexive(self): class C(object): @@ -476,8 +476,8 @@ class TestCopy(unittest.TestCase): x = C() x.foo = x y = copy.deepcopy(x) - self.assert_(y is not x) - self.assert_(y.foo is y) + self.assertTrue(y is not x) + self.assertTrue(y.foo is y) # Additions for Python 2.3 and pickle protocol 2 @@ -491,12 +491,12 @@ class TestCopy(unittest.TestCase): x = C([[1, 2], 3]) y = copy.copy(x) self.assertEqual(x, y) - self.assert_(x is not y) - self.assert_(x[0] is y[0]) + self.assertTrue(x is not y) + self.assertTrue(x[0] is y[0]) y = copy.deepcopy(x) self.assertEqual(x, y) - self.assert_(x is not y) - self.assert_(x[0] is not y[0]) + self.assertTrue(x is not y) + self.assertTrue(x[0] is not y[0]) def test_reduce_5tuple(self): class C(dict): @@ -508,12 +508,12 @@ class TestCopy(unittest.TestCase): x = C([("foo", [1, 2]), ("bar", 3)]) y = copy.copy(x) self.assertEqual(x, y) - self.assert_(x is not y) - self.assert_(x["foo"] is y["foo"]) + self.assertTrue(x is not y) + self.assertTrue(x["foo"] is y["foo"]) y = copy.deepcopy(x) self.assertEqual(x, y) - self.assert_(x is not y) - self.assert_(x["foo"] is not y["foo"]) + self.assertTrue(x is not y) + self.assertTrue(x["foo"] is not y["foo"]) def test_copy_slots(self): class C(object): @@ -521,7 +521,7 @@ class TestCopy(unittest.TestCase): x = C() x.foo = [42] y = copy.copy(x) - self.assert_(x.foo is y.foo) + self.assertTrue(x.foo is y.foo) def test_deepcopy_slots(self): class C(object): @@ -530,7 +530,7 @@ class TestCopy(unittest.TestCase): x.foo = [42] y = copy.deepcopy(x) self.assertEqual(x.foo, y.foo) - self.assert_(x.foo is not y.foo) + self.assertTrue(x.foo is not y.foo) def test_copy_list_subclass(self): class C(list): @@ -540,8 +540,8 @@ class TestCopy(unittest.TestCase): y = copy.copy(x) self.assertEqual(list(x), list(y)) self.assertEqual(x.foo, y.foo) - self.assert_(x[0] is y[0]) - self.assert_(x.foo is y.foo) + self.assertTrue(x[0] is y[0]) + self.assertTrue(x.foo is y.foo) def test_deepcopy_list_subclass(self): class C(list): @@ -551,8 +551,8 @@ class TestCopy(unittest.TestCase): y = copy.deepcopy(x) self.assertEqual(list(x), list(y)) self.assertEqual(x.foo, y.foo) - self.assert_(x[0] is not y[0]) - self.assert_(x.foo is not y.foo) + self.assertTrue(x[0] is not y[0]) + self.assertTrue(x.foo is not y.foo) def test_copy_tuple_subclass(self): class C(tuple): @@ -569,8 +569,8 @@ class TestCopy(unittest.TestCase): self.assertEqual(tuple(x), ([1, 2], 3)) y = copy.deepcopy(x) self.assertEqual(tuple(y), ([1, 2], 3)) - self.assert_(x is not y) - self.assert_(x[0] is not y[0]) + self.assertTrue(x is not y) + self.assertTrue(x[0] is not y[0]) def test_getstate_exc(self): class EvilState(object): diff --git a/Lib/test/test_copyreg.py b/Lib/test/test_copyreg.py index 48e58ea..4fb89d0 100644 --- a/Lib/test/test_copyreg.py +++ b/Lib/test/test_copyreg.py @@ -51,10 +51,10 @@ class CopyRegTestCase(unittest.TestCase): mod, func, code) copyreg.add_extension(mod, func, code) # Should be in the registry. - self.assert_(copyreg._extension_registry[mod, func] == code) - self.assert_(copyreg._inverted_registry[code] == (mod, func)) + self.assertTrue(copyreg._extension_registry[mod, func] == code) + self.assertTrue(copyreg._inverted_registry[code] == (mod, func)) # Shouldn't be in the cache. - self.assert_(code not in copyreg._extension_cache) + self.assertTrue(code not in copyreg._extension_cache) # Redundant registration should be OK. copyreg.add_extension(mod, func, code) # shouldn't blow up # Conflicting code. @@ -81,7 +81,7 @@ class CopyRegTestCase(unittest.TestCase): e.restore() # Shouldn't be there anymore. - self.assert_((mod, func) not in copyreg._extension_registry) + self.assertTrue((mod, func) not in copyreg._extension_registry) # The code *may* be in copyreg._extension_registry, though, if # we happened to pick on a registered code. So don't check for # that. diff --git a/Lib/test/test_csv.py b/Lib/test/test_csv.py index 7eb3a7f..95105be 100644 --- a/Lib/test/test_csv.py +++ b/Lib/test/test_csv.py @@ -315,7 +315,7 @@ class TestDialectRegistry(unittest.TestCase): expected_dialects.sort() csv.register_dialect(name, myexceltsv) try: - self.failUnless(csv.get_dialect(name).delimiter, '\t') + self.assertTrue(csv.get_dialect(name).delimiter, '\t') got_dialects = csv.list_dialects() got_dialects.sort() self.assertEqual(expected_dialects, got_dialects) @@ -326,8 +326,8 @@ class TestDialectRegistry(unittest.TestCase): name = 'fedcba' csv.register_dialect(name, delimiter=';') try: - self.failUnless(csv.get_dialect(name).delimiter, '\t') - self.failUnless(list(csv.reader('X;Y;Z', name)), ['X', 'Y', 'Z']) + self.assertTrue(csv.get_dialect(name).delimiter, '\t') + self.assertTrue(list(csv.reader('X;Y;Z', name)), ['X', 'Y', 'Z']) finally: csv.unregister_dialect(name) @@ -811,7 +811,7 @@ Stonecutters Seafood and Chop House, Lemont, IL, 12/19/02, Week Back # given that all three lines in sample3 are equal, # I think that any character could have been 'guessed' as the # delimiter, depending on dictionary order - self.assert_(dialect.delimiter in self.sample3) + self.assertTrue(dialect.delimiter in self.sample3) dialect = sniffer.sniff(self.sample3, delimiters="?,") self.assertEqual(dialect.delimiter, "?") dialect = sniffer.sniff(self.sample3, delimiters="/,") diff --git a/Lib/test/test_datetime.py b/Lib/test/test_datetime.py index b9d5959..8bf8420 100644 --- a/Lib/test/test_datetime.py +++ b/Lib/test/test_datetime.py @@ -77,9 +77,9 @@ class TestTZInfo(unittest.TestCase): def __init__(self, offset, name): self.__offset = offset self.__name = name - self.failUnless(issubclass(NotEnough, tzinfo)) + self.assertTrue(issubclass(NotEnough, tzinfo)) ne = NotEnough(3, "NotByALongShot") - self.failUnless(isinstance(ne, tzinfo)) + self.assertTrue(isinstance(ne, tzinfo)) dt = datetime.now() self.assertRaises(NotImplementedError, ne.tzname, dt) @@ -88,7 +88,7 @@ class TestTZInfo(unittest.TestCase): def test_normal(self): fo = FixedOffset(3, "Three") - self.failUnless(isinstance(fo, tzinfo)) + self.assertTrue(isinstance(fo, tzinfo)) for dt in datetime.now(), None: self.assertEqual(fo.utcoffset(dt), timedelta(minutes=3)) self.assertEqual(fo.tzname(dt), "Three") @@ -99,25 +99,25 @@ class TestTZInfo(unittest.TestCase): # carry no data), but they need to be picklable anyway else # concrete subclasses can't be pickled. orig = tzinfo.__new__(tzinfo) - self.failUnless(type(orig) is tzinfo) + self.assertTrue(type(orig) is tzinfo) for pickler, unpickler, proto in pickle_choices: green = pickler.dumps(orig, proto) derived = unpickler.loads(green) - self.failUnless(type(derived) is tzinfo) + self.assertTrue(type(derived) is tzinfo) def test_pickling_subclass(self): # Make sure we can pickle/unpickle an instance of a subclass. offset = timedelta(minutes=-300) orig = PicklableFixedOffset(offset, 'cookie') - self.failUnless(isinstance(orig, tzinfo)) - self.failUnless(type(orig) is PicklableFixedOffset) + self.assertTrue(isinstance(orig, tzinfo)) + self.assertTrue(type(orig) is PicklableFixedOffset) self.assertEqual(orig.utcoffset(None), offset) self.assertEqual(orig.tzname(None), 'cookie') for pickler, unpickler, proto in pickle_choices: green = pickler.dumps(orig, proto) derived = unpickler.loads(green) - self.failUnless(isinstance(derived, tzinfo)) - self.failUnless(type(derived) is PicklableFixedOffset) + self.assertTrue(isinstance(derived, tzinfo)) + self.assertTrue(type(derived) is PicklableFixedOffset) self.assertEqual(derived.utcoffset(None), offset) self.assertEqual(derived.tzname(None), 'cookie') @@ -134,16 +134,16 @@ class HarmlessMixedComparison: def test_harmless_mixed_comparison(self): me = self.theclass(1, 1, 1) - self.failIf(me == ()) - self.failUnless(me != ()) - self.failIf(() == me) - self.failUnless(() != me) + self.assertFalse(me == ()) + self.assertTrue(me != ()) + self.assertFalse(() == me) + self.assertTrue(() != me) - self.failUnless(me in [1, 20, [], me]) - self.failIf(me not in [1, 20, [], me]) + self.assertTrue(me in [1, 20, [], me]) + self.assertFalse(me not in [1, 20, [], me]) - self.failUnless([] in [me, 1, 20, []]) - self.failIf([] not in [me, 1, 20, []]) + self.assertTrue([] in [me, 1, 20, []]) + self.assertFalse([] not in [me, 1, 20, []]) def test_harmful_mixed_comparison(self): me = self.theclass(1, 1, 1) @@ -303,26 +303,26 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase): t1 = timedelta(2, 3, 4) t2 = timedelta(2, 3, 4) self.assertEqual(t1, t2) - self.failUnless(t1 <= t2) - self.failUnless(t1 >= t2) - self.failUnless(not t1 != t2) - self.failUnless(not t1 < t2) - self.failUnless(not t1 > t2) + self.assertTrue(t1 <= t2) + self.assertTrue(t1 >= t2) + self.assertTrue(not t1 != t2) + self.assertTrue(not t1 < t2) + self.assertTrue(not t1 > t2) for args in (3, 3, 3), (2, 4, 4), (2, 3, 5): t2 = timedelta(*args) # this is larger than t1 - self.failUnless(t1 < t2) - self.failUnless(t2 > t1) - self.failUnless(t1 <= t2) - self.failUnless(t2 >= t1) - self.failUnless(t1 != t2) - self.failUnless(t2 != t1) - self.failUnless(not t1 == t2) - self.failUnless(not t2 == t1) - self.failUnless(not t1 > t2) - self.failUnless(not t2 < t1) - self.failUnless(not t1 >= t2) - self.failUnless(not t2 <= t1) + self.assertTrue(t1 < t2) + self.assertTrue(t2 > t1) + self.assertTrue(t1 <= t2) + self.assertTrue(t2 >= t1) + self.assertTrue(t1 != t2) + self.assertTrue(t2 != t1) + self.assertTrue(not t1 == t2) + self.assertTrue(not t2 == t1) + self.assertTrue(not t1 > t2) + self.assertTrue(not t2 < t1) + self.assertTrue(not t1 >= t2) + self.assertTrue(not t2 <= t1) for badarg in OTHERSTUFF: self.assertEqual(t1 == badarg, False) @@ -368,7 +368,7 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase): # Verify td -> string -> td identity. s = repr(td) - self.failUnless(s.startswith('datetime.')) + self.assertTrue(s.startswith('datetime.')) s = s[9:] td2 = eval(s) self.assertEqual(td, td2) @@ -378,10 +378,10 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase): self.assertEqual(td, td2) def test_resolution_info(self): - self.assert_(isinstance(timedelta.min, timedelta)) - self.assert_(isinstance(timedelta.max, timedelta)) - self.assert_(isinstance(timedelta.resolution, timedelta)) - self.assert_(timedelta.max > timedelta.min) + self.assertTrue(isinstance(timedelta.min, timedelta)) + self.assertTrue(isinstance(timedelta.max, timedelta)) + self.assertTrue(isinstance(timedelta.resolution, timedelta)) + self.assertTrue(timedelta.max > timedelta.min) self.assertEqual(timedelta.min, timedelta(-999999999)) self.assertEqual(timedelta.max, timedelta(999999999, 24*3600-1, 1e6-1)) self.assertEqual(timedelta.resolution, timedelta(0, 0, 1)) @@ -428,11 +428,11 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase): (-1, 24*3600-1, 999999)) def test_bool(self): - self.failUnless(timedelta(1)) - self.failUnless(timedelta(0, 1)) - self.failUnless(timedelta(0, 0, 1)) - self.failUnless(timedelta(microseconds=1)) - self.failUnless(not timedelta(0)) + self.assertTrue(timedelta(1)) + self.assertTrue(timedelta(0, 1)) + self.assertTrue(timedelta(0, 0, 1)) + self.assertTrue(timedelta(microseconds=1)) + self.assertTrue(not timedelta(0)) def test_subclass_timedelta(self): @@ -448,17 +448,17 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase): return round(sum) t1 = T(days=1) - self.assert_(type(t1) is T) + self.assertTrue(type(t1) is T) self.assertEqual(t1.as_hours(), 24) t2 = T(days=-1, seconds=-3600) - self.assert_(type(t2) is T) + self.assertTrue(type(t2) is T) self.assertEqual(t2.as_hours(), -25) t3 = t1 + t2 - self.assert_(type(t3) is timedelta) + self.assertTrue(type(t3) is timedelta) t4 = T.from_td(t3) - self.assert_(type(t4) is T) + self.assertTrue(type(t4) is T) self.assertEqual(t3.days, t4.days) self.assertEqual(t3.seconds, t4.seconds) self.assertEqual(t3.microseconds, t4.microseconds) @@ -521,7 +521,7 @@ class TestDate(HarmlessMixedComparison, unittest.TestCase): self.theclass.today()): # Verify dt -> string -> date identity. s = repr(dt) - self.failUnless(s.startswith('datetime.')) + self.assertTrue(s.startswith('datetime.')) s = s[9:] dt2 = eval(s) self.assertEqual(dt, dt2) @@ -755,7 +755,7 @@ class TestDate(HarmlessMixedComparison, unittest.TestCase): # It worked or it didn't. If it didn't, assume it's reason #2, and # let the test pass if they're within half a second of each other. - self.failUnless(today == todayagain or + self.assertTrue(today == todayagain or abs(todayagain - today) < timedelta(seconds=0.5)) def test_weekday(self): @@ -891,10 +891,10 @@ class TestDate(HarmlessMixedComparison, unittest.TestCase): self.assertEqual(b.__format__(fmt), 'B') def test_resolution_info(self): - self.assert_(isinstance(self.theclass.min, self.theclass)) - self.assert_(isinstance(self.theclass.max, self.theclass)) - self.assert_(isinstance(self.theclass.resolution, timedelta)) - self.assert_(self.theclass.max > self.theclass.min) + self.assertTrue(isinstance(self.theclass.min, self.theclass)) + self.assertTrue(isinstance(self.theclass.max, self.theclass)) + self.assertTrue(isinstance(self.theclass.resolution, timedelta)) + self.assertTrue(self.theclass.max > self.theclass.min) def test_extreme_timedelta(self): big = self.theclass.max - self.theclass.min @@ -943,26 +943,26 @@ class TestDate(HarmlessMixedComparison, unittest.TestCase): t1 = self.theclass(2, 3, 4) t2 = self.theclass(2, 3, 4) self.assertEqual(t1, t2) - self.failUnless(t1 <= t2) - self.failUnless(t1 >= t2) - self.failUnless(not t1 != t2) - self.failUnless(not t1 < t2) - self.failUnless(not t1 > t2) + self.assertTrue(t1 <= t2) + self.assertTrue(t1 >= t2) + self.assertTrue(not t1 != t2) + self.assertTrue(not t1 < t2) + self.assertTrue(not t1 > t2) for args in (3, 3, 3), (2, 4, 4), (2, 3, 5): t2 = self.theclass(*args) # this is larger than t1 - self.failUnless(t1 < t2) - self.failUnless(t2 > t1) - self.failUnless(t1 <= t2) - self.failUnless(t2 >= t1) - self.failUnless(t1 != t2) - self.failUnless(t2 != t1) - self.failUnless(not t1 == t2) - self.failUnless(not t2 == t1) - self.failUnless(not t1 > t2) - self.failUnless(not t2 < t1) - self.failUnless(not t1 >= t2) - self.failUnless(not t2 <= t1) + self.assertTrue(t1 < t2) + self.assertTrue(t2 > t1) + self.assertTrue(t1 <= t2) + self.assertTrue(t2 >= t1) + self.assertTrue(t1 != t2) + self.assertTrue(t2 != t1) + self.assertTrue(not t1 == t2) + self.assertTrue(not t2 == t1) + self.assertTrue(not t1 > t2) + self.assertTrue(not t2 < t1) + self.assertTrue(not t1 >= t2) + self.assertTrue(not t2 <= t1) for badarg in OTHERSTUFF: self.assertEqual(t1 == badarg, False) @@ -1031,8 +1031,8 @@ class TestDate(HarmlessMixedComparison, unittest.TestCase): def test_bool(self): # All dates are considered true. - self.failUnless(self.theclass.min) - self.failUnless(self.theclass.max) + self.assertTrue(self.theclass.min) + self.assertTrue(self.theclass.max) def test_strftime_out_of_range(self): # For nasty technical reasons, we can't handle years before 1900. @@ -1155,7 +1155,7 @@ class TestDateTime(TestDate): self.theclass.now()): # Verify dt -> string -> datetime identity. s = repr(dt) - self.failUnless(s.startswith('datetime.')) + self.assertTrue(s.startswith('datetime.')) s = s[9:] dt2 = eval(s) self.assertEqual(dt, dt2) @@ -1228,7 +1228,7 @@ class TestDateTime(TestDate): dt2 = self.theclass(2002, 3, 1, 10, 0, 0) dt3 = self.theclass(2002, 3, 1, 9, 0, 0) self.assertEqual(dt1, dt3) - self.assert_(dt2 > dt3) + self.assertTrue(dt2 > dt3) # Make sure comparison doesn't forget microseconds, and isn't done # via comparing a float timestamp (an IEEE double doesn't have enough @@ -1239,7 +1239,7 @@ class TestDateTime(TestDate): us = timedelta(microseconds=1) dt2 = dt1 + us self.assertEqual(dt2 - dt1, us) - self.assert_(dt1 < dt2) + self.assertTrue(dt1 < dt2) def test_strftime_with_bad_tzname_replace(self): # verify ok if tzinfo.tzname().replace() returns a non-string @@ -1420,28 +1420,28 @@ class TestDateTime(TestDate): t1 = self.theclass(*args) t2 = self.theclass(*args) self.assertEqual(t1, t2) - self.failUnless(t1 <= t2) - self.failUnless(t1 >= t2) - self.failUnless(not t1 != t2) - self.failUnless(not t1 < t2) - self.failUnless(not t1 > t2) + self.assertTrue(t1 <= t2) + self.assertTrue(t1 >= t2) + self.assertTrue(not t1 != t2) + self.assertTrue(not t1 < t2) + self.assertTrue(not t1 > t2) for i in range(len(args)): newargs = args[:] newargs[i] = args[i] + 1 t2 = self.theclass(*newargs) # this is larger than t1 - self.failUnless(t1 < t2) - self.failUnless(t2 > t1) - self.failUnless(t1 <= t2) - self.failUnless(t2 >= t1) - self.failUnless(t1 != t2) - self.failUnless(t2 != t1) - self.failUnless(not t1 == t2) - self.failUnless(not t2 == t1) - self.failUnless(not t1 > t2) - self.failUnless(not t2 < t1) - self.failUnless(not t1 >= t2) - self.failUnless(not t2 <= t1) + self.assertTrue(t1 < t2) + self.assertTrue(t2 > t1) + self.assertTrue(t1 <= t2) + self.assertTrue(t2 >= t1) + self.assertTrue(t1 != t2) + self.assertTrue(t2 != t1) + self.assertTrue(not t1 == t2) + self.assertTrue(not t2 == t1) + self.assertTrue(not t1 > t2) + self.assertTrue(not t2 < t1) + self.assertTrue(not t1 >= t2) + self.assertTrue(not t2 <= t1) # A helper for timestamp constructor tests. @@ -1520,7 +1520,7 @@ class TestDateTime(TestDate): if abs(from_timestamp - from_now) <= tolerance: break # Else try again a few times. - self.failUnless(abs(from_timestamp - from_now) <= tolerance) + self.assertTrue(abs(from_timestamp - from_now) <= tolerance) def test_strptime(self): import _strptime @@ -1689,7 +1689,7 @@ class TestTime(HarmlessMixedComparison, unittest.TestCase): # Verify t -> string -> time identity. s = repr(t) - self.failUnless(s.startswith('datetime.')) + self.assertTrue(s.startswith('datetime.')) s = s[9:] t2 = eval(s) self.assertEqual(t, t2) @@ -1704,28 +1704,28 @@ class TestTime(HarmlessMixedComparison, unittest.TestCase): t1 = self.theclass(*args) t2 = self.theclass(*args) self.assertEqual(t1, t2) - self.failUnless(t1 <= t2) - self.failUnless(t1 >= t2) - self.failUnless(not t1 != t2) - self.failUnless(not t1 < t2) - self.failUnless(not t1 > t2) + self.assertTrue(t1 <= t2) + self.assertTrue(t1 >= t2) + self.assertTrue(not t1 != t2) + self.assertTrue(not t1 < t2) + self.assertTrue(not t1 > t2) for i in range(len(args)): newargs = args[:] newargs[i] = args[i] + 1 t2 = self.theclass(*newargs) # this is larger than t1 - self.failUnless(t1 < t2) - self.failUnless(t2 > t1) - self.failUnless(t1 <= t2) - self.failUnless(t2 >= t1) - self.failUnless(t1 != t2) - self.failUnless(t2 != t1) - self.failUnless(not t1 == t2) - self.failUnless(not t2 == t1) - self.failUnless(not t1 > t2) - self.failUnless(not t2 < t1) - self.failUnless(not t1 >= t2) - self.failUnless(not t2 <= t1) + self.assertTrue(t1 < t2) + self.assertTrue(t2 > t1) + self.assertTrue(t1 <= t2) + self.assertTrue(t2 >= t1) + self.assertTrue(t1 != t2) + self.assertTrue(t2 != t1) + self.assertTrue(not t1 == t2) + self.assertTrue(not t2 == t1) + self.assertTrue(not t1 > t2) + self.assertTrue(not t2 < t1) + self.assertTrue(not t1 >= t2) + self.assertTrue(not t2 <= t1) for badarg in OTHERSTUFF: self.assertEqual(t1 == badarg, False) @@ -1876,10 +1876,10 @@ class TestTime(HarmlessMixedComparison, unittest.TestCase): "%s(23, 15)" % name) def test_resolution_info(self): - self.assert_(isinstance(self.theclass.min, self.theclass)) - self.assert_(isinstance(self.theclass.max, self.theclass)) - self.assert_(isinstance(self.theclass.resolution, timedelta)) - self.assert_(self.theclass.max > self.theclass.min) + self.assertTrue(isinstance(self.theclass.min, self.theclass)) + self.assertTrue(isinstance(self.theclass.max, self.theclass)) + self.assertTrue(isinstance(self.theclass.resolution, timedelta)) + self.assertTrue(self.theclass.max > self.theclass.min) def test_pickling(self): args = 20, 59, 16, 64**2 @@ -1899,12 +1899,12 @@ class TestTime(HarmlessMixedComparison, unittest.TestCase): def test_bool(self): cls = self.theclass - self.failUnless(cls(1)) - self.failUnless(cls(0, 1)) - self.failUnless(cls(0, 0, 1)) - self.failUnless(cls(0, 0, 0, 1)) - self.failUnless(not cls(0)) - self.failUnless(not cls()) + self.assertTrue(cls(1)) + self.assertTrue(cls(0, 1)) + self.assertTrue(cls(0, 0, 1)) + self.assertTrue(cls(0, 0, 0, 1)) + self.assertTrue(not cls(0)) + self.assertTrue(not cls()) def test_replace(self): cls = self.theclass @@ -2001,7 +2001,7 @@ class TZInfoBase: def utcoffset(self, dt): pass b = BetterTry() t = cls(1, 1, 1, tzinfo=b) - self.failUnless(t.tzinfo is b) + self.assertTrue(t.tzinfo is b) def test_utc_offset_out_of_bounds(self): class Edgy(tzinfo): @@ -2040,9 +2040,9 @@ class TZInfoBase: for t in (cls(1, 1, 1), cls(1, 1, 1, tzinfo=None), cls(1, 1, 1, tzinfo=C1())): - self.failUnless(t.utcoffset() is None) - self.failUnless(t.dst() is None) - self.failUnless(t.tzname() is None) + self.assertTrue(t.utcoffset() is None) + self.assertTrue(t.dst() is None) + self.assertTrue(t.tzname() is None) class C3(tzinfo): def utcoffset(self, dt): return timedelta(minutes=-1439) @@ -2137,7 +2137,7 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase): self.assertEqual(t.minute, 0) self.assertEqual(t.second, 0) self.assertEqual(t.microsecond, 0) - self.failUnless(t.tzinfo is None) + self.assertTrue(t.tzinfo is None) def test_zones(self): est = FixedOffset(-300, "EST", 1) @@ -2152,25 +2152,25 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase): self.assertEqual(t1.tzinfo, est) self.assertEqual(t2.tzinfo, utc) self.assertEqual(t3.tzinfo, met) - self.failUnless(t4.tzinfo is None) + self.assertTrue(t4.tzinfo is None) self.assertEqual(t5.tzinfo, utc) self.assertEqual(t1.utcoffset(), timedelta(minutes=-300)) self.assertEqual(t2.utcoffset(), timedelta(minutes=0)) self.assertEqual(t3.utcoffset(), timedelta(minutes=60)) - self.failUnless(t4.utcoffset() is None) + self.assertTrue(t4.utcoffset() is None) self.assertRaises(TypeError, t1.utcoffset, "no args") self.assertEqual(t1.tzname(), "EST") self.assertEqual(t2.tzname(), "UTC") self.assertEqual(t3.tzname(), "MET") - self.failUnless(t4.tzname() is None) + self.assertTrue(t4.tzname() is None) self.assertRaises(TypeError, t1.tzname, "no args") self.assertEqual(t1.dst(), timedelta(minutes=1)) self.assertEqual(t2.dst(), timedelta(minutes=-2)) self.assertEqual(t3.dst(), timedelta(minutes=3)) - self.failUnless(t4.dst() is None) + self.assertTrue(t4.dst() is None) self.assertRaises(TypeError, t1.dst, "no args") self.assertEqual(hash(t1), hash(t2)) @@ -2246,7 +2246,7 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase): green = pickler.dumps(orig, proto) derived = unpickler.loads(green) self.assertEqual(orig, derived) - self.failUnless(isinstance(derived.tzinfo, PicklableFixedOffset)) + self.assertTrue(isinstance(derived.tzinfo, PicklableFixedOffset)) self.assertEqual(derived.utcoffset(), timedelta(minutes=-300)) self.assertEqual(derived.tzname(), 'cookie') @@ -2255,20 +2255,20 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase): cls = self.theclass t = cls(0, tzinfo=FixedOffset(-300, "")) - self.failUnless(t) + self.assertTrue(t) t = cls(5, tzinfo=FixedOffset(-300, "")) - self.failUnless(t) + self.assertTrue(t) t = cls(5, tzinfo=FixedOffset(300, "")) - self.failUnless(not t) + self.assertTrue(not t) t = cls(23, 59, tzinfo=FixedOffset(23*60 + 59, "")) - self.failUnless(not t) + self.assertTrue(not t) # Mostly ensuring this doesn't overflow internally. t = cls(0, tzinfo=FixedOffset(23*60 + 59, "")) - self.failUnless(t) + self.assertTrue(t) # But this should yield a value error -- the utcoffset is bogus. t = cls(0, tzinfo=FixedOffset(24*60, "")) @@ -2302,13 +2302,13 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase): # Ensure we can get rid of a tzinfo. self.assertEqual(base.tzname(), "+100") base2 = base.replace(tzinfo=None) - self.failUnless(base2.tzinfo is None) - self.failUnless(base2.tzname() is None) + self.assertTrue(base2.tzinfo is None) + self.assertTrue(base2.tzname() is None) # Ensure we can add one. base3 = base2.replace(tzinfo=z100) self.assertEqual(base, base3) - self.failUnless(base.tzinfo is base3.tzinfo) + self.assertTrue(base.tzinfo is base3.tzinfo) # Out of bounds. base = cls(1) @@ -2345,7 +2345,7 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase): # But if they're not identical, it isn't ignored. t2 = t2.replace(tzinfo=Varies()) - self.failUnless(t1 < t2) # t1's offset counter still going up + self.assertTrue(t1 < t2) # t1's offset counter still going up def test_subclass_timetz(self): @@ -2401,9 +2401,9 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): tzinfo=FixedOffset(-1439, "")) # Make sure those compare correctly, and w/o overflow. - self.failUnless(t1 < t2) - self.failUnless(t1 != t2) - self.failUnless(t2 > t1) + self.assertTrue(t1 < t2) + self.assertTrue(t1 != t2) + self.assertTrue(t2 > t1) self.assertEqual(t1, t1) self.assertEqual(t2, t2) @@ -2415,21 +2415,21 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): # Change t1 not to subtract a minute, and t1 should be larger. t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(0, "")) - self.failUnless(t1 > t2) + self.assertTrue(t1 > t2) # Change t1 to subtract 2 minutes, and t1 should be smaller. t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(2, "")) - self.failUnless(t1 < t2) + self.assertTrue(t1 < t2) # Back to the original t1, but make seconds resolve it. t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""), second=1) - self.failUnless(t1 > t2) + self.assertTrue(t1 > t2) # Likewise, but make microseconds resolve it. t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""), microsecond=1) - self.failUnless(t1 > t2) + self.assertTrue(t1 > t2) # Make t2 naive and it should fail. t2 = self.theclass.min @@ -2473,7 +2473,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): green = pickler.dumps(orig, proto) derived = unpickler.loads(green) self.assertEqual(orig, derived) - self.failUnless(isinstance(derived.tzinfo, + self.assertTrue(isinstance(derived.tzinfo, PicklableFixedOffset)) self.assertEqual(derived.utcoffset(), timedelta(minutes=-300)) self.assertEqual(derived.tzname(), 'cookie') @@ -2544,7 +2544,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): tz55 = FixedOffset(-330, "west 5:30") timeaware = now.time().replace(tzinfo=tz55) nowaware = self.theclass.combine(now.date(), timeaware) - self.failUnless(nowaware.tzinfo is tz55) + self.assertTrue(nowaware.tzinfo is tz55) self.assertEqual(nowaware.timetz(), timeaware) # Can't mix aware and non-aware. @@ -2563,15 +2563,15 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): # Adding a delta should preserve tzinfo. delta = timedelta(weeks=1, minutes=12, microseconds=5678) nowawareplus = nowaware + delta - self.failUnless(nowaware.tzinfo is tz55) + self.assertTrue(nowaware.tzinfo is tz55) nowawareplus2 = delta + nowaware - self.failUnless(nowawareplus2.tzinfo is tz55) + self.assertTrue(nowawareplus2.tzinfo is tz55) self.assertEqual(nowawareplus, nowawareplus2) # that - delta should be what we started with, and that - what we # started with should be delta. diff = nowawareplus - delta - self.failUnless(diff.tzinfo is tz55) + self.assertTrue(diff.tzinfo is tz55) self.assertEqual(nowaware, diff) self.assertRaises(TypeError, lambda: delta - nowawareplus) self.assertEqual(nowawareplus - nowaware, delta) @@ -2580,7 +2580,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): tzr = FixedOffset(random.randrange(-1439, 1440), "randomtimezone") # Attach it to nowawareplus. nowawareplus = nowawareplus.replace(tzinfo=tzr) - self.failUnless(nowawareplus.tzinfo is tzr) + self.assertTrue(nowawareplus.tzinfo is tzr) # Make sure the difference takes the timezone adjustments into account. got = nowaware - nowawareplus # Expected: (nowaware base - nowaware offset) - @@ -2607,7 +2607,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): off42 = FixedOffset(42, "42") another = meth(off42) again = meth(tz=off42) - self.failUnless(another.tzinfo is again.tzinfo) + self.assertTrue(another.tzinfo is again.tzinfo) self.assertEqual(another.utcoffset(), timedelta(minutes=42)) # Bad argument with and w/o naming the keyword. self.assertRaises(TypeError, meth, 16) @@ -2624,7 +2624,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): utc = FixedOffset(0, "utc", 0) for dummy in range(3): now = datetime.now(weirdtz) - self.failUnless(now.tzinfo is weirdtz) + self.assertTrue(now.tzinfo is weirdtz) utcnow = datetime.utcnow().replace(tzinfo=utc) now2 = utcnow.astimezone(weirdtz) if abs(now - now2) < timedelta(seconds=30): @@ -2645,7 +2645,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): off42 = FixedOffset(42, "42") another = meth(ts, off42) again = meth(ts, tz=off42) - self.failUnless(another.tzinfo is again.tzinfo) + self.assertTrue(another.tzinfo is again.tzinfo) self.assertEqual(another.utcoffset(), timedelta(minutes=42)) # Bad argument with and w/o naming the keyword. self.assertRaises(TypeError, meth, ts, 16) @@ -2840,13 +2840,13 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): # Ensure we can get rid of a tzinfo. self.assertEqual(base.tzname(), "+100") base2 = base.replace(tzinfo=None) - self.failUnless(base2.tzinfo is None) - self.failUnless(base2.tzname() is None) + self.assertTrue(base2.tzinfo is None) + self.assertTrue(base2.tzname() is None) # Ensure we can add one. base3 = base2.replace(tzinfo=z100) self.assertEqual(base, base3) - self.failUnless(base.tzinfo is base3.tzinfo) + self.assertTrue(base.tzinfo is base3.tzinfo) # Out of bounds. base = cls(2000, 2, 29) @@ -2859,20 +2859,20 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): fm5h = FixedOffset(-timedelta(hours=5), "m300") dt = self.theclass.now(tz=f44m) - self.failUnless(dt.tzinfo is f44m) + self.assertTrue(dt.tzinfo is f44m) # Replacing with degenerate tzinfo raises an exception. self.assertRaises(ValueError, dt.astimezone, fnone) # Ditto with None tz. self.assertRaises(TypeError, dt.astimezone, None) # Replacing with same tzinfo makes no change. x = dt.astimezone(dt.tzinfo) - self.failUnless(x.tzinfo is f44m) + self.assertTrue(x.tzinfo is f44m) self.assertEqual(x.date(), dt.date()) self.assertEqual(x.time(), dt.time()) # Replacing with different tzinfo does adjust. got = dt.astimezone(fm5h) - self.failUnless(got.tzinfo is fm5h) + self.assertTrue(got.tzinfo is fm5h) self.assertEqual(got.utcoffset(), timedelta(hours=-5)) expected = dt - dt.utcoffset() # in effect, convert to UTC expected += fm5h.utcoffset(dt) # and from there to local time @@ -2880,7 +2880,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): self.assertEqual(got.date(), expected.date()) self.assertEqual(got.time(), expected.time()) self.assertEqual(got.timetz(), expected.timetz()) - self.failUnless(got.tzinfo is expected.tzinfo) + self.assertTrue(got.tzinfo is expected.tzinfo) self.assertEqual(got, expected) def test_aware_subtract(self): @@ -2955,7 +2955,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase): # But if they're not identical, it isn't ignored. t2 = t2.replace(tzinfo=Varies()) - self.failUnless(t1 < t2) # t1's offset counter still going up + self.assertTrue(t1 < t2) # t1's offset counter still going up def test_subclass_datetimetz(self): @@ -3306,10 +3306,10 @@ class Oddballs(unittest.TestCase): # type comparison, despite that datetime is a subclass of date. as_date = date.today() as_datetime = datetime.combine(as_date, time()) - self.assert_(as_date != as_datetime) - self.assert_(as_datetime != as_date) - self.assert_(not as_date == as_datetime) - self.assert_(not as_datetime == as_date) + self.assertTrue(as_date != as_datetime) + self.assertTrue(as_datetime != as_date) + self.assertTrue(not as_date == as_datetime) + self.assertTrue(not as_datetime == as_date) self.assertRaises(TypeError, lambda: as_date < as_datetime) self.assertRaises(TypeError, lambda: as_datetime < as_date) self.assertRaises(TypeError, lambda: as_date <= as_datetime) diff --git a/Lib/test/test_dbm.py b/Lib/test/test_dbm.py index 35d12e4..818be45 100644 --- a/Lib/test/test_dbm.py +++ b/Lib/test/test_dbm.py @@ -57,7 +57,7 @@ class AnyDBMTestCase(unittest.TestCase): return keys def test_error(self): - self.assert_(issubclass(self.module.error, IOError)) + self.assertTrue(issubclass(self.module.error, IOError)) def test_anydbm_not_existing(self): self.assertRaises(dbm.error, dbm.open, _fname) @@ -154,9 +154,9 @@ class WhichDBTestCase(unittest.TestCase): self.d[k] = v self.assertEqual(sorted(self.d.keys()), sorted(k for (k, v) in a)) for k, v in a: - self.assert_(k in self.d) + self.assertTrue(k in self.d) self.assertEqual(self.d[k], v) - self.assert_(b'xxx' not in self.d) + self.assertTrue(b'xxx' not in self.d) self.assertRaises(KeyError, lambda: self.d[b'xxx']) self.d.close() diff --git a/Lib/test/test_dbm_dumb.py b/Lib/test/test_dbm_dumb.py index e2964aa..956eec6 100644 --- a/Lib/test/test_dbm_dumb.py +++ b/Lib/test/test_dbm_dumb.py @@ -118,7 +118,7 @@ class DumbDBMTestCase(unittest.TestCase): f['1'] = 'a' f.close() f = dumbdbm.open(_fname, 'r') - self.assert_('\u00fc' in f) + self.assertTrue('\u00fc' in f) self.assertEqual(f['\u00fc'.encode('utf-8')], self._dict['\u00fc'.encode('utf-8')]) self.assertEqual(f[b'1'], b'a') diff --git a/Lib/test/test_dbm_gnu.py b/Lib/test/test_dbm_gnu.py index 857aeb1..2173b92 100755 --- a/Lib/test/test_dbm_gnu.py +++ b/Lib/test/test_dbm_gnu.py @@ -24,11 +24,11 @@ class TestGdbm(unittest.TestCase): self.g[b'bytes'] = b'data' key_set = set(self.g.keys()) self.assertEqual(key_set, set([b'a', b'bytes', b'12345678910'])) - self.assert_(b'a' in self.g) + self.assertTrue(b'a' in self.g) self.assertEqual(self.g[b'bytes'], b'data') key = self.g.firstkey() while key: - self.assert_(key in key_set) + self.assertTrue(key in key_set) key_set.remove(key) key = self.g.nextkey(key) self.assertRaises(KeyError, lambda: self.g['xxx']) @@ -66,7 +66,7 @@ class TestGdbm(unittest.TestCase): self.g['x'] = 'x' * 10000 size1 = os.path.getsize(filename) - self.assert_(size0 < size1) + self.assertTrue(size0 < size1) del self.g['x'] # 'size' is supposed to be the same even after deleting an entry. @@ -74,7 +74,7 @@ class TestGdbm(unittest.TestCase): self.g.reorganize() size2 = os.path.getsize(filename) - self.assert_(size1 > size2 >= size0) + self.assertTrue(size1 > size2 >= size0) def test_main(): diff --git a/Lib/test/test_dbm_ndbm.py b/Lib/test/test_dbm_ndbm.py index c5e968f..141d4b3 100755 --- a/Lib/test/test_dbm_ndbm.py +++ b/Lib/test/test_dbm_ndbm.py @@ -19,12 +19,12 @@ class DbmTestCase(unittest.TestCase): def test_keys(self): self.d = dbm.ndbm.open(self.filename, 'c') - self.assert_(self.d.keys() == []) + self.assertTrue(self.d.keys() == []) self.d['a'] = 'b' self.d[b'bytes'] = b'data' self.d['12345678910'] = '019237410982340912840198242' self.d.keys() - self.assert_(b'a' in self.d) + self.assertTrue(b'a' in self.d) self.assertEqual(self.d[b'bytes'], b'data') self.d.close() diff --git a/Lib/test/test_decimal.py b/Lib/test/test_decimal.py index 01deeed..927fd1a 100644 --- a/Lib/test/test_decimal.py +++ b/Lib/test/test_decimal.py @@ -504,7 +504,7 @@ class DecimalExplicitConstructionTest(unittest.TestCase): # from int d = nc.create_decimal(456) - self.failUnless(isinstance(d, Decimal)) + self.assertTrue(isinstance(d, Decimal)) self.assertEqual(nc.create_decimal(45678), nc.create_decimal('457E+2')) @@ -1056,12 +1056,12 @@ class DecimalArithmeticOperatorsTest(unittest.TestCase): f = Decimal('2') for x, y in [(n, n), (n, i), (i, n), (n, f), (f, n), (s, n), (n, s), (s, i), (i, s), (s, f), (f, s), (s, s)]: - self.assert_(x != y) - self.assert_(not (x == y)) - self.assert_(not (x < y)) - self.assert_(not (x <= y)) - self.assert_(not (x > y)) - self.assert_(not (x >= y)) + self.assertTrue(x != y) + self.assertTrue(not (x == y)) + self.assertTrue(not (x < y)) + self.assertTrue(not (x <= y)) + self.assertTrue(not (x > y)) + self.assertTrue(not (x >= y)) # The following are two functions used to test threading in the next class @@ -1134,18 +1134,18 @@ class DecimalUsabilityTest(unittest.TestCase): dc = Decimal('45') #two Decimals - self.failUnless(dc > da) - self.failUnless(dc >= da) - self.failUnless(da < dc) - self.failUnless(da <= dc) + self.assertTrue(dc > da) + self.assertTrue(dc >= da) + self.assertTrue(da < dc) + self.assertTrue(da <= dc) self.assertEqual(da, db) - self.failUnless(da != dc) - self.failUnless(da <= db) - self.failUnless(da >= db) + self.assertTrue(da != dc) + self.assertTrue(da <= db) + self.assertTrue(da >= db) #a Decimal and an int - self.failUnless(dc > 23) - self.failUnless(23 < dc) + self.assertTrue(dc > 23) + self.assertTrue(23 < dc) self.assertEqual(dc, 45) #a Decimal and uncomparable @@ -1206,8 +1206,8 @@ class DecimalUsabilityTest(unittest.TestCase): #the same hash that to an int self.assertEqual(hash(Decimal(23)), hash(23)) self.assertRaises(TypeError, hash, Decimal('NaN')) - self.assert_(hash(Decimal('Inf'))) - self.assert_(hash(Decimal('-Inf'))) + self.assertTrue(hash(Decimal('Inf'))) + self.assertTrue(hash(Decimal('-Inf'))) # check that the value of the hash doesn't depend on the # current context (issue #1757) @@ -1234,22 +1234,22 @@ class DecimalUsabilityTest(unittest.TestCase): l2 = 28 #between Decimals - self.failUnless(min(d1,d2) is d1) - self.failUnless(min(d2,d1) is d1) - self.failUnless(max(d1,d2) is d2) - self.failUnless(max(d2,d1) is d2) + self.assertTrue(min(d1,d2) is d1) + self.assertTrue(min(d2,d1) is d1) + self.assertTrue(max(d1,d2) is d2) + self.assertTrue(max(d2,d1) is d2) #between Decimal and long - self.failUnless(min(d1,l2) is d1) - self.failUnless(min(l2,d1) is d1) - self.failUnless(max(l1,d2) is d2) - self.failUnless(max(d2,l1) is d2) + self.assertTrue(min(d1,l2) is d1) + self.assertTrue(min(l2,d1) is d1) + self.assertTrue(max(l1,d2) is d2) + self.assertTrue(max(d2,l1) is d2) def test_as_nonzero(self): #as false - self.failIf(Decimal(0)) + self.assertFalse(Decimal(0)) #as true - self.failUnless(Decimal('0.372')) + self.assertTrue(Decimal('0.372')) def test_tostring_methods(self): #Test str and repr methods. @@ -1519,10 +1519,10 @@ class DecimalUsabilityTest(unittest.TestCase): class DecimalPythonAPItests(unittest.TestCase): def test_abc(self): - self.assert_(issubclass(Decimal, numbers.Number)) - self.assert_(not issubclass(Decimal, numbers.Real)) - self.assert_(isinstance(Decimal(0), numbers.Number)) - self.assert_(not isinstance(Decimal(0), numbers.Real)) + self.assertTrue(issubclass(Decimal, numbers.Number)) + self.assertTrue(not issubclass(Decimal, numbers.Real)) + self.assertTrue(isinstance(Decimal(0), numbers.Number)) + self.assertTrue(not isinstance(Decimal(0), numbers.Real)) def test_pickle(self): d = Decimal('-3.141590000') @@ -1561,9 +1561,9 @@ class DecimalPythonAPItests(unittest.TestCase): '0.1000000000000000055511151231257827021181583404541015625') bigint = 12345678901234567890123456789 self.assertEqual(MyDecimal.from_float(bigint), MyDecimal(bigint)) - self.assert_(MyDecimal.from_float(float('nan')).is_qnan()) - self.assert_(MyDecimal.from_float(float('inf')).is_infinite()) - self.assert_(MyDecimal.from_float(float('-inf')).is_infinite()) + self.assertTrue(MyDecimal.from_float(float('nan')).is_qnan()) + self.assertTrue(MyDecimal.from_float(float('inf')).is_infinite()) + self.assertTrue(MyDecimal.from_float(float('-inf')).is_infinite()) self.assertEqual(str(MyDecimal.from_float(float('nan'))), str(Decimal('NaN'))) self.assertEqual(str(MyDecimal.from_float(float('inf'))), @@ -1610,8 +1610,8 @@ class ContextAPItests(unittest.TestCase): self.assertEqual(v1, v2) def test_equality_with_other_types(self): - self.assert_(Decimal(10) in ['a', 1.0, Decimal(10), (1,2), {}]) - self.assert_(Decimal(10) not in ['a', 1.0, (1,2), {}]) + self.assertTrue(Decimal(10) in ['a', 1.0, Decimal(10), (1,2), {}]) + self.assertTrue(Decimal(10) not in ['a', 1.0, (1,2), {}]) def test_copy(self): # All copies should be deep @@ -1631,9 +1631,9 @@ class WithStatementTest(unittest.TestCase): with localcontext() as enter_ctx: set_ctx = getcontext() final_ctx = getcontext() - self.assert_(orig_ctx is final_ctx, 'did not restore context correctly') - self.assert_(orig_ctx is not set_ctx, 'did not copy the context') - self.assert_(set_ctx is enter_ctx, '__enter__ returned wrong context') + self.assertTrue(orig_ctx is final_ctx, 'did not restore context correctly') + self.assertTrue(orig_ctx is not set_ctx, 'did not copy the context') + self.assertTrue(set_ctx is enter_ctx, '__enter__ returned wrong context') def test_localcontextarg(self): # Use a copy of the supplied context in the block @@ -1642,10 +1642,10 @@ class WithStatementTest(unittest.TestCase): with localcontext(new_ctx) as enter_ctx: set_ctx = getcontext() final_ctx = getcontext() - self.assert_(orig_ctx is final_ctx, 'did not restore context correctly') - self.assert_(set_ctx.prec == new_ctx.prec, 'did not set correct context') - self.assert_(new_ctx is not set_ctx, 'did not copy the context') - self.assert_(set_ctx is enter_ctx, '__enter__ returned wrong context') + self.assertTrue(orig_ctx is final_ctx, 'did not restore context correctly') + self.assertTrue(set_ctx.prec == new_ctx.prec, 'did not set correct context') + self.assertTrue(new_ctx is not set_ctx, 'did not copy the context') + self.assertTrue(set_ctx is enter_ctx, '__enter__ returned wrong context') class ContextFlags(unittest.TestCase): def test_flags_irrelevant(self): diff --git a/Lib/test/test_defaultdict.py b/Lib/test/test_defaultdict.py index 76fc6a6..e5a9bd5 100644 --- a/Lib/test/test_defaultdict.py +++ b/Lib/test/test_defaultdict.py @@ -25,21 +25,21 @@ class TestDefaultDict(unittest.TestCase): d1[13] d1[14] self.assertEqual(d1, {12: [42, 24], 13: [], 14: []}) - self.assert_(d1[12] is not d1[13] is not d1[14]) + self.assertTrue(d1[12] is not d1[13] is not d1[14]) d2 = defaultdict(list, foo=1, bar=2) self.assertEqual(d2.default_factory, list) self.assertEqual(d2, {"foo": 1, "bar": 2}) self.assertEqual(d2["foo"], 1) self.assertEqual(d2["bar"], 2) self.assertEqual(d2[42], []) - self.assert_("foo" in d2) - self.assert_("foo" in d2.keys()) - self.assert_("bar" in d2) - self.assert_("bar" in d2.keys()) - self.assert_(42 in d2) - self.assert_(42 in d2.keys()) - self.assert_(12 not in d2) - self.assert_(12 not in d2.keys()) + self.assertTrue("foo" in d2) + self.assertTrue("foo" in d2.keys()) + self.assertTrue("bar" in d2) + self.assertTrue("bar" in d2.keys()) + self.assertTrue(42 in d2) + self.assertTrue(42 in d2.keys()) + self.assertTrue(12 not in d2) + self.assertTrue(12 not in d2.keys()) d2.default_factory = None self.assertEqual(d2.default_factory, None) try: @@ -69,7 +69,7 @@ class TestDefaultDict(unittest.TestCase): self.assertEqual(repr(d2), "defaultdict(, {12: 42})") def foo(): return 43 d3 = defaultdict(foo) - self.assert_(d3.default_factory is foo) + self.assertTrue(d3.default_factory is foo) d3[13] self.assertEqual(repr(d3), "defaultdict(%s, {13: 43})" % repr(foo)) @@ -134,7 +134,7 @@ class TestDefaultDict(unittest.TestCase): d2 = copy.deepcopy(d1) self.assertEqual(d2.default_factory, foobar) self.assertEqual(d2, d1) - self.assert_(d1[1] is not d2[1]) + self.assertTrue(d1[1] is not d2[1]) d1.default_factory = list d2 = copy.deepcopy(d1) self.assertEqual(d2.default_factory, list) @@ -157,7 +157,7 @@ class TestDefaultDict(unittest.TestCase): def _factory(self): return [] d = sub() - self.assert_(repr(d).startswith( + self.assertTrue(repr(d).startswith( "defaultdict(= 0) + self.assertTrue(str(c1).find('C object at ') >= 0) self.assertEqual(str(c1), repr(c1)) - self.assert_(-1 not in c1) + self.assertTrue(-1 not in c1) for i in range(10): - self.assert_(i in c1) + self.assertTrue(i in c1) self.assertFalse(10 in c1) # Test the default behavior for dynamic classes class D(object): @@ -1673,21 +1673,21 @@ order (MRO) for bases """ raise IndexError d1 = D() d2 = D() - self.assert_(not not d1) + self.assertTrue(not not d1) self.assertNotEqual(id(d1), id(d2)) hash(d1) hash(d2) self.assertEqual(d1, d1) self.assertNotEqual(d1, d2) - self.assert_(not d1 != d1) - self.assert_(not d1 == d2) + self.assertTrue(not d1 != d1) + self.assertTrue(not d1 == d2) # Note that the module name appears in str/repr, and that varies # depending on whether this test is run standalone or from a framework. - self.assert_(str(d1).find('D object at ') >= 0) + self.assertTrue(str(d1).find('D object at ') >= 0) self.assertEqual(str(d1), repr(d1)) - self.assert_(-1 not in d1) + self.assertTrue(-1 not in d1) for i in range(10): - self.assert_(i in d1) + self.assertTrue(i in d1) self.assertFalse(10 in d1) # Test overridden behavior class Proxy(object): @@ -1719,22 +1719,22 @@ order (MRO) for bases """ p1 = Proxy(1) p_1 = Proxy(-1) self.assertFalse(p0) - self.assert_(not not p1) + self.assertTrue(not not p1) self.assertEqual(hash(p0), hash(0)) self.assertEqual(p0, p0) self.assertNotEqual(p0, p1) - self.assert_(not p0 != p0) + self.assertTrue(not p0 != p0) self.assertEqual(not p0, p1) - self.assert_(p0 < p1) - self.assert_(p0 <= p1) - self.assert_(p1 > p0) - self.assert_(p1 >= p0) + self.assertTrue(p0 < p1) + self.assertTrue(p0 <= p1) + self.assertTrue(p1 > p0) + self.assertTrue(p1 >= p0) self.assertEqual(str(p0), "Proxy:0") self.assertEqual(repr(p0), "Proxy(0)") p10 = Proxy(range(10)) self.assertFalse(-1 in p10) for i in range(10): - self.assert_(i in p10) + self.assertTrue(i in p10) self.assertFalse(10 in p10) def test_weakrefs(self): @@ -1755,7 +1755,7 @@ order (MRO) for bases """ try: weakref.ref(no) except TypeError as msg: - self.assert_(str(msg).find("weak reference") >= 0) + self.assertTrue(str(msg).find("weak reference") >= 0) else: self.fail("weakref.ref(no) should be illegal") class Weak(object): @@ -1792,18 +1792,18 @@ order (MRO) for bases """ self.assertFalse(hasattr(a, "x")) raw = C.__dict__['x'] - self.assert_(isinstance(raw, property)) + self.assertTrue(isinstance(raw, property)) attrs = dir(raw) - self.assert_("__doc__" in attrs) - self.assert_("fget" in attrs) - self.assert_("fset" in attrs) - self.assert_("fdel" in attrs) + self.assertTrue("__doc__" in attrs) + self.assertTrue("fget" in attrs) + self.assertTrue("fset" in attrs) + self.assertTrue("fdel" in attrs) self.assertEqual(raw.__doc__, "I'm the x property.") - self.assert_(raw.fget is C.__dict__['getx']) - self.assert_(raw.fset is C.__dict__['setx']) - self.assert_(raw.fdel is C.__dict__['delx']) + self.assertTrue(raw.fget is C.__dict__['getx']) + self.assertTrue(raw.fset is C.__dict__['setx']) + self.assertTrue(raw.fdel is C.__dict__['delx']) for attr in "__doc__", "fget", "fset", "fdel": try: @@ -1865,7 +1865,7 @@ order (MRO) for bases """ self.assertEqual(C.foo.__doc__, "hello") self.assertFalse(hasattr(c, "foo")) c.foo = -42 - self.assert_(hasattr(c, '_foo')) + self.assertTrue(hasattr(c, '_foo')) self.assertEqual(c._foo, 42) self.assertEqual(c.foo, 42) del c.foo @@ -2023,12 +2023,12 @@ order (MRO) for bases """ c = C() self.assertEqual(interesting(dir(c)), cstuff) - ## self.assert_('__self__' in dir(C.Cmethod)) + ## self.assertTrue('__self__' in dir(C.Cmethod)) c.cdata = 2 c.cmethod = lambda self: 0 self.assertEqual(interesting(dir(c)), cstuff + ['cdata', 'cmethod']) - ## self.assert_('__self__' in dir(c.Cmethod)) + ## self.assertTrue('__self__' in dir(c.Cmethod)) class A(C): Adata = 1 @@ -2036,13 +2036,13 @@ order (MRO) for bases """ astuff = ['Adata', 'Amethod'] + cstuff self.assertEqual(interesting(dir(A)), astuff) - ## self.assert_('__self__' in dir(A.Amethod)) + ## self.assertTrue('__self__' in dir(A.Amethod)) a = A() self.assertEqual(interesting(dir(a)), astuff) a.adata = 42 a.amethod = lambda self: 3 self.assertEqual(interesting(dir(a)), astuff + ['adata', 'amethod']) - ## self.assert_('__self__' in dir(a.Amethod)) + ## self.assertTrue('__self__' in dir(a.Amethod)) # Try a module subclass. import sys @@ -2226,13 +2226,13 @@ order (MRO) for bases """ a = hexint(12345) self.assertEqual(a, 12345) self.assertEqual(int(a), 12345) - self.assert_(int(a).__class__ is int) + self.assertTrue(int(a).__class__ is int) self.assertEqual(hash(a), hash(12345)) - self.assert_((+a).__class__ is int) - self.assert_((a >> 0).__class__ is int) - self.assert_((a << 0).__class__ is int) - self.assert_((hexint(0) << 12).__class__ is int) - self.assert_((hexint(0) >> 12).__class__ is int) + self.assertTrue((+a).__class__ is int) + self.assertTrue((a >> 0).__class__ is int) + self.assertTrue((a << 0).__class__ is int) + self.assertTrue((hexint(0) << 12).__class__ is int) + self.assertTrue((hexint(0) >> 12).__class__ is int) class octlong(int): __slots__ = [] @@ -2252,36 +2252,36 @@ order (MRO) for bases """ self.assertEqual(a, 12345) self.assertEqual(int(a), 12345) self.assertEqual(hash(a), hash(12345)) - self.assert_(int(a).__class__ is int) - self.assert_((+a).__class__ is int) - self.assert_((-a).__class__ is int) - self.assert_((-octlong(0)).__class__ is int) - self.assert_((a >> 0).__class__ is int) - self.assert_((a << 0).__class__ is int) - self.assert_((a - 0).__class__ is int) - self.assert_((a * 1).__class__ is int) - self.assert_((a ** 1).__class__ is int) - self.assert_((a // 1).__class__ is int) - self.assert_((1 * a).__class__ is int) - self.assert_((a | 0).__class__ is int) - self.assert_((a ^ 0).__class__ is int) - self.assert_((a & -1).__class__ is int) - self.assert_((octlong(0) << 12).__class__ is int) - self.assert_((octlong(0) >> 12).__class__ is int) - self.assert_(abs(octlong(0)).__class__ is int) + self.assertTrue(int(a).__class__ is int) + self.assertTrue((+a).__class__ is int) + self.assertTrue((-a).__class__ is int) + self.assertTrue((-octlong(0)).__class__ is int) + self.assertTrue((a >> 0).__class__ is int) + self.assertTrue((a << 0).__class__ is int) + self.assertTrue((a - 0).__class__ is int) + self.assertTrue((a * 1).__class__ is int) + self.assertTrue((a ** 1).__class__ is int) + self.assertTrue((a // 1).__class__ is int) + self.assertTrue((1 * a).__class__ is int) + self.assertTrue((a | 0).__class__ is int) + self.assertTrue((a ^ 0).__class__ is int) + self.assertTrue((a & -1).__class__ is int) + self.assertTrue((octlong(0) << 12).__class__ is int) + self.assertTrue((octlong(0) >> 12).__class__ is int) + self.assertTrue(abs(octlong(0)).__class__ is int) # Because octlong overrides __add__, we can't check the absence of +0 # optimizations using octlong. class longclone(int): pass a = longclone(1) - self.assert_((a + 0).__class__ is int) - self.assert_((0 + a).__class__ is int) + self.assertTrue((a + 0).__class__ is int) + self.assertTrue((0 + a).__class__ is int) # Check that negative clones don't segfault a = longclone(-1) self.assertEqual(a.__dict__, {}) - self.assertEqual(int(a), -1) # self.assert_ PyNumber_Long() copies the sign bit + self.assertEqual(int(a), -1) # self.assertTrue PyNumber_Long() copies the sign bit class precfloat(float): __slots__ = ['prec'] @@ -2293,9 +2293,9 @@ order (MRO) for bases """ a = precfloat(12345) self.assertEqual(a, 12345.0) self.assertEqual(float(a), 12345.0) - self.assert_(float(a).__class__ is float) + self.assertTrue(float(a).__class__ is float) self.assertEqual(hash(a), hash(12345.0)) - self.assert_((+a).__class__ is float) + self.assertTrue((+a).__class__ is float) class madcomplex(complex): def __repr__(self): @@ -2343,20 +2343,20 @@ order (MRO) for bases """ self.assertEqual(v, t) a = madtuple((1,2,3,4,5)) self.assertEqual(tuple(a), (1,2,3,4,5)) - self.assert_(tuple(a).__class__ is tuple) + self.assertTrue(tuple(a).__class__ is tuple) self.assertEqual(hash(a), hash((1,2,3,4,5))) - self.assert_(a[:].__class__ is tuple) - self.assert_((a * 1).__class__ is tuple) - self.assert_((a * 0).__class__ is tuple) - self.assert_((a + ()).__class__ is tuple) + self.assertTrue(a[:].__class__ is tuple) + self.assertTrue((a * 1).__class__ is tuple) + self.assertTrue((a * 0).__class__ is tuple) + self.assertTrue((a + ()).__class__ is tuple) a = madtuple(()) self.assertEqual(tuple(a), ()) - self.assert_(tuple(a).__class__ is tuple) - self.assert_((a + a).__class__ is tuple) - self.assert_((a * 0).__class__ is tuple) - self.assert_((a * 1).__class__ is tuple) - self.assert_((a * 2).__class__ is tuple) - self.assert_(a[:].__class__ is tuple) + self.assertTrue(tuple(a).__class__ is tuple) + self.assertTrue((a + a).__class__ is tuple) + self.assertTrue((a * 0).__class__ is tuple) + self.assertTrue((a * 1).__class__ is tuple) + self.assertTrue((a * 2).__class__ is tuple) + self.assertTrue(a[:].__class__ is tuple) class madstring(str): _rev = None @@ -2378,48 +2378,48 @@ order (MRO) for bases """ self.assertEqual(u, s) s = madstring("12345") self.assertEqual(str(s), "12345") - self.assert_(str(s).__class__ is str) + self.assertTrue(str(s).__class__ is str) base = "\x00" * 5 s = madstring(base) self.assertEqual(s, base) self.assertEqual(str(s), base) - self.assert_(str(s).__class__ is str) + self.assertTrue(str(s).__class__ is str) self.assertEqual(hash(s), hash(base)) self.assertEqual({s: 1}[base], 1) self.assertEqual({base: 1}[s], 1) - self.assert_((s + "").__class__ is str) + self.assertTrue((s + "").__class__ is str) self.assertEqual(s + "", base) - self.assert_(("" + s).__class__ is str) + self.assertTrue(("" + s).__class__ is str) self.assertEqual("" + s, base) - self.assert_((s * 0).__class__ is str) + self.assertTrue((s * 0).__class__ is str) self.assertEqual(s * 0, "") - self.assert_((s * 1).__class__ is str) + self.assertTrue((s * 1).__class__ is str) self.assertEqual(s * 1, base) - self.assert_((s * 2).__class__ is str) + self.assertTrue((s * 2).__class__ is str) self.assertEqual(s * 2, base + base) - self.assert_(s[:].__class__ is str) + self.assertTrue(s[:].__class__ is str) self.assertEqual(s[:], base) - self.assert_(s[0:0].__class__ is str) + self.assertTrue(s[0:0].__class__ is str) self.assertEqual(s[0:0], "") - self.assert_(s.strip().__class__ is str) + self.assertTrue(s.strip().__class__ is str) self.assertEqual(s.strip(), base) - self.assert_(s.lstrip().__class__ is str) + self.assertTrue(s.lstrip().__class__ is str) self.assertEqual(s.lstrip(), base) - self.assert_(s.rstrip().__class__ is str) + self.assertTrue(s.rstrip().__class__ is str) self.assertEqual(s.rstrip(), base) identitytab = {} - self.assert_(s.translate(identitytab).__class__ is str) + self.assertTrue(s.translate(identitytab).__class__ is str) self.assertEqual(s.translate(identitytab), base) - self.assert_(s.replace("x", "x").__class__ is str) + self.assertTrue(s.replace("x", "x").__class__ is str) self.assertEqual(s.replace("x", "x"), base) - self.assert_(s.ljust(len(s)).__class__ is str) + self.assertTrue(s.ljust(len(s)).__class__ is str) self.assertEqual(s.ljust(len(s)), base) - self.assert_(s.rjust(len(s)).__class__ is str) + self.assertTrue(s.rjust(len(s)).__class__ is str) self.assertEqual(s.rjust(len(s)), base) - self.assert_(s.center(len(s)).__class__ is str) + self.assertTrue(s.center(len(s)).__class__ is str) self.assertEqual(s.center(len(s)), base) - self.assert_(s.lower().__class__ is str) + self.assertTrue(s.lower().__class__ is str) self.assertEqual(s.lower(), base) class madunicode(str): @@ -2438,47 +2438,47 @@ order (MRO) for bases """ base = "12345" u = madunicode(base) self.assertEqual(str(u), base) - self.assert_(str(u).__class__ is str) + self.assertTrue(str(u).__class__ is str) self.assertEqual(hash(u), hash(base)) self.assertEqual({u: 1}[base], 1) self.assertEqual({base: 1}[u], 1) - self.assert_(u.strip().__class__ is str) + self.assertTrue(u.strip().__class__ is str) self.assertEqual(u.strip(), base) - self.assert_(u.lstrip().__class__ is str) + self.assertTrue(u.lstrip().__class__ is str) self.assertEqual(u.lstrip(), base) - self.assert_(u.rstrip().__class__ is str) + self.assertTrue(u.rstrip().__class__ is str) self.assertEqual(u.rstrip(), base) - self.assert_(u.replace("x", "x").__class__ is str) + self.assertTrue(u.replace("x", "x").__class__ is str) self.assertEqual(u.replace("x", "x"), base) - self.assert_(u.replace("xy", "xy").__class__ is str) + self.assertTrue(u.replace("xy", "xy").__class__ is str) self.assertEqual(u.replace("xy", "xy"), base) - self.assert_(u.center(len(u)).__class__ is str) + self.assertTrue(u.center(len(u)).__class__ is str) self.assertEqual(u.center(len(u)), base) - self.assert_(u.ljust(len(u)).__class__ is str) + self.assertTrue(u.ljust(len(u)).__class__ is str) self.assertEqual(u.ljust(len(u)), base) - self.assert_(u.rjust(len(u)).__class__ is str) + self.assertTrue(u.rjust(len(u)).__class__ is str) self.assertEqual(u.rjust(len(u)), base) - self.assert_(u.lower().__class__ is str) + self.assertTrue(u.lower().__class__ is str) self.assertEqual(u.lower(), base) - self.assert_(u.upper().__class__ is str) + self.assertTrue(u.upper().__class__ is str) self.assertEqual(u.upper(), base) - self.assert_(u.capitalize().__class__ is str) + self.assertTrue(u.capitalize().__class__ is str) self.assertEqual(u.capitalize(), base) - self.assert_(u.title().__class__ is str) + self.assertTrue(u.title().__class__ is str) self.assertEqual(u.title(), base) - self.assert_((u + "").__class__ is str) + self.assertTrue((u + "").__class__ is str) self.assertEqual(u + "", base) - self.assert_(("" + u).__class__ is str) + self.assertTrue(("" + u).__class__ is str) self.assertEqual("" + u, base) - self.assert_((u * 0).__class__ is str) + self.assertTrue((u * 0).__class__ is str) self.assertEqual(u * 0, "") - self.assert_((u * 1).__class__ is str) + self.assertTrue((u * 1).__class__ is str) self.assertEqual(u * 1, base) - self.assert_((u * 2).__class__ is str) + self.assertTrue((u * 2).__class__ is str) self.assertEqual(u * 2, base + base) - self.assert_(u[:].__class__ is str) + self.assertTrue(u[:].__class__ is str) self.assertEqual(u[:], base) - self.assert_(u[0:0].__class__ is str) + self.assertTrue(u[0:0].__class__ is str) self.assertEqual(u[0:0], "") class sublist(list): @@ -2597,7 +2597,7 @@ order (MRO) for bases """ self.assertEqual(d[cistr('one')], 1) self.assertEqual(d[cistr('tWo')], 2) self.assertEqual(d[cistr('THrEE')], 3) - self.assert_(cistr('ONe') in d) + self.assertTrue(cistr('ONe') in d) self.assertEqual(d.get(cistr('thrEE')), 3) def test_classic_comparisons(self): @@ -2654,13 +2654,13 @@ order (MRO) for bases """ for x in 1, 2, 3: for y in 1, 2, 3: for op in "<", "<=", "==", "!=", ">", ">=": - self.assert_(eval("c[x] %s c[y]" % op) == + self.assertTrue(eval("c[x] %s c[y]" % op) == eval("x %s y" % op), "x=%d, y=%d" % (x, y)) - self.assert_(eval("c[x] %s y" % op) == + self.assertTrue(eval("c[x] %s y" % op) == eval("x %s y" % op), "x=%d, y=%d" % (x, y)) - self.assert_(eval("x %s c[y]" % op) == + self.assertTrue(eval("x %s c[y]" % op) == eval("x %s y" % op), "x=%d, y=%d" % (x, y)) @@ -2733,11 +2733,11 @@ order (MRO) for bases """ for x in 1, 2, 3: for y in 1, 2, 3: for op in "<", "<=", "==", "!=", ">", ">=": - self.assert_(eval("c[x] %s c[y]" % op) == eval("x %s y" % op), + self.assertTrue(eval("c[x] %s c[y]" % op) == eval("x %s y" % op), "x=%d, y=%d" % (x, y)) - self.assert_(eval("c[x] %s y" % op) == eval("x %s y" % op), + self.assertTrue(eval("c[x] %s y" % op) == eval("x %s y" % op), "x=%d, y=%d" % (x, y)) - self.assert_(eval("x %s c[y]" % op) == eval("x %s y" % op), + self.assertTrue(eval("x %s c[y]" % op) == eval("x %s y" % op), "x=%d, y=%d" % (x, y)) def test_descrdoc(self): @@ -2777,9 +2777,9 @@ order (MRO) for bases """ for cls2 in C, D, E, F: x = cls() x.__class__ = cls2 - self.assert_(x.__class__ is cls2) + self.assertTrue(x.__class__ is cls2) x.__class__ = cls - self.assert_(x.__class__ is cls) + self.assertTrue(x.__class__ is cls) def cant(x, C): try: x.__class__ = C @@ -2835,11 +2835,11 @@ order (MRO) for bases """ x = cls() x.a = 1 x.__class__ = cls2 - self.assert_(x.__class__ is cls2, + self.assertTrue(x.__class__ is cls2, "assigning %r as __class__ for %r silently failed" % (cls2, x)) self.assertEqual(x.a, 1) x.__class__ = cls - self.assert_(x.__class__ is cls, + self.assertTrue(x.__class__ is cls, "assigning %r as __class__ for %r silently failed" % (cls, x)) self.assertEqual(x.a, 1) for cls in G, J, K, L, M, N, P, R, list, Int: @@ -3008,7 +3008,7 @@ order (MRO) for bases """ for cls in C, C1, C2: s = pickle.dumps(cls, bin) cls2 = pickle.loads(s) - self.assert_(cls2 is cls) + self.assertTrue(cls2 is cls) a = C1(1, 2); a.append(42); a.append(24) b = C2("hello", "world", 42) @@ -3038,7 +3038,7 @@ order (MRO) for bases """ import copy for cls in C, C1, C2: cls2 = copy.deepcopy(cls) - self.assert_(cls2 is cls) + self.assertTrue(cls2 is cls) a = C1(1, 2); a.append(42); a.append(24) b = C2("hello", "world", 42) @@ -3581,8 +3581,8 @@ order (MRO) for bases """ __slots__=() if support.check_impl_detail(): self.assertEqual(C.__basicsize__, B.__basicsize__) - self.assert_(hasattr(C, '__dict__')) - self.assert_(hasattr(C, '__weakref__')) + self.assertTrue(hasattr(C, '__dict__')) + self.assertTrue(hasattr(C, '__weakref__')) C().x = 2 def test_rmul(self): @@ -3916,29 +3916,29 @@ order (MRO) for bases """ pass a = C() pa = Proxy(a) - self.assert_(isinstance(a, C)) # Baseline - self.assert_(isinstance(pa, C)) # Test + self.assertTrue(isinstance(a, C)) # Baseline + self.assertTrue(isinstance(pa, C)) # Test # Test with a classic subclass class D(C): pass a = D() pa = Proxy(a) - self.assert_(isinstance(a, C)) # Baseline - self.assert_(isinstance(pa, C)) # Test + self.assertTrue(isinstance(a, C)) # Baseline + self.assertTrue(isinstance(pa, C)) # Test # Test with a new-style class class C(object): pass a = C() pa = Proxy(a) - self.assert_(isinstance(a, C)) # Baseline - self.assert_(isinstance(pa, C)) # Test + self.assertTrue(isinstance(a, C)) # Baseline + self.assertTrue(isinstance(pa, C)) # Test # Test with a new-style subclass class D(C): pass a = D() pa = Proxy(a) - self.assert_(isinstance(a, C)) # Baseline - self.assert_(isinstance(pa, C)) # Test + self.assertTrue(isinstance(a, C)) # Baseline + self.assertTrue(isinstance(pa, C)) # Test def test_proxy_super(self): # Testing super() for a proxy object... @@ -4067,17 +4067,17 @@ order (MRO) for bases """ l = [] self.assertEqual(l.__add__, l.__add__) self.assertEqual(l.__add__, [].__add__) - self.assert_(l.__add__ != [5].__add__) - self.assert_(l.__add__ != l.__mul__) - self.assert_(l.__add__.__name__ == '__add__') + self.assertTrue(l.__add__ != [5].__add__) + self.assertTrue(l.__add__ != l.__mul__) + self.assertTrue(l.__add__.__name__ == '__add__') if hasattr(l.__add__, '__self__'): # CPython - self.assert_(l.__add__.__self__ is l) - self.assert_(l.__add__.__objclass__ is list) + self.assertTrue(l.__add__.__self__ is l) + self.assertTrue(l.__add__.__objclass__ is list) else: # Python implementations where [].__add__ is a normal bound method - self.assert_(l.__add__.im_self is l) - self.assert_(l.__add__.im_class is list) + self.assertTrue(l.__add__.im_self is l) + self.assertTrue(l.__add__.im_class is list) self.assertEqual(l.__add__.__doc__, list.__add__.__doc__) try: hash(l.__add__) diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py index 1c9bca8..1519689 100644 --- a/Lib/test/test_dict.py +++ b/Lib/test/test_dict.py @@ -10,7 +10,7 @@ class DictTest(unittest.TestCase): def test_constructor(self): # calling built-in types without argument must return empty self.assertEqual(dict(), {}) - self.assert_(dict() is not {}) + self.assertTrue(dict() is not {}) def test_literal_constructor(self): # check literal constructor for different sized dicts (to exercise the BUILD_MAP oparg @@ -24,18 +24,18 @@ class DictTest(unittest.TestCase): self.assertEqual(eval(dictliteral), dict(items)) def test_bool(self): - self.assert_(not {}) - self.assert_({1: 2}) - self.assert_(bool({}) is False) - self.assert_(bool({1: 2}) is True) + self.assertTrue(not {}) + self.assertTrue({1: 2}) + self.assertTrue(bool({}) is False) + self.assertTrue(bool({1: 2}) is True) def test_keys(self): d = {} self.assertEqual(set(d.keys()), set()) d = {'a': 1, 'b': 2} k = d.keys() - self.assert_('a' in d) - self.assert_('b' in d) + self.assertTrue('a' in d) + self.assertTrue('b' in d) self.assertRaises(TypeError, d.keys, None) self.assertEqual(repr(dict(a=1).keys()), "dict_keys(['a'])") @@ -58,12 +58,12 @@ class DictTest(unittest.TestCase): def test_contains(self): d = {} - self.assert_(not ('a' in d)) - self.assert_('a' not in d) + self.assertTrue(not ('a' in d)) + self.assertTrue('a' not in d) d = {'a': 1, 'b': 2} - self.assert_('a' in d) - self.assert_('b' in d) - self.assert_('c' not in d) + self.assertTrue('a' in d) + self.assertTrue('b' in d) + self.assertTrue('c' not in d) self.assertRaises(TypeError, d.__contains__) @@ -197,7 +197,7 @@ class DictTest(unittest.TestCase): def test_fromkeys(self): self.assertEqual(dict.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) d = {} - self.assert_(not(d.fromkeys('abc') is d)) + self.assertTrue(not(d.fromkeys('abc') is d)) self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0}) self.assertEqual(d.fromkeys([]), {}) @@ -208,14 +208,14 @@ class DictTest(unittest.TestCase): class dictlike(dict): pass self.assertEqual(dictlike.fromkeys('a'), {'a':None}) self.assertEqual(dictlike().fromkeys('a'), {'a':None}) - self.assert_(type(dictlike.fromkeys('a')) is dictlike) - self.assert_(type(dictlike().fromkeys('a')) is dictlike) + self.assertTrue(type(dictlike.fromkeys('a')) is dictlike) + self.assertTrue(type(dictlike().fromkeys('a')) is dictlike) class mydict(dict): def __new__(cls): return collections.UserDict() ud = mydict.fromkeys('ab') self.assertEqual(ud, {'a':None, 'b':None}) - self.assert_(isinstance(ud, collections.UserDict)) + self.assertTrue(isinstance(ud, collections.UserDict)) self.assertRaises(TypeError, dict.fromkeys) class Exc(Exception): pass @@ -252,10 +252,10 @@ class DictTest(unittest.TestCase): def test_get(self): d = {} - self.assert_(d.get('c') is None) + self.assertTrue(d.get('c') is None) self.assertEqual(d.get('c', 3), 3) d = {'a' : 1, 'b' : 2} - self.assert_(d.get('c') is None) + self.assertTrue(d.get('c') is None) self.assertEqual(d.get('c', 3), 3) self.assertEqual(d.get('a'), 1) self.assertEqual(d.get('a', 3), 1) @@ -265,9 +265,9 @@ class DictTest(unittest.TestCase): def test_setdefault(self): # dict.setdefault() d = {} - self.assert_(d.setdefault('key0') is None) + self.assertTrue(d.setdefault('key0') is None) d.setdefault('key0', []) - self.assert_(d.setdefault('key0') is None) + self.assertTrue(d.setdefault('key0') is None) d.setdefault('key', []).append(3) self.assertEqual(d['key'][0], 3) d.setdefault('key', []).append(4) @@ -309,9 +309,9 @@ class DictTest(unittest.TestCase): self.assertEqual(va, int(ka)) kb, vb = tb = b.popitem() self.assertEqual(vb, int(kb)) - self.assert_(not(copymode < 0 and ta != tb)) - self.assert_(not a) - self.assert_(not b) + self.assertTrue(not(copymode < 0 and ta != tb)) + self.assertTrue(not a) + self.assertTrue(not b) d = {} self.assertRaises(KeyError, d.popitem) @@ -525,8 +525,8 @@ class DictTest(unittest.TestCase): d = D({1: 2, 3: 4}) self.assertEqual(d[1], 2) self.assertEqual(d[3], 4) - self.assert_(2 not in d) - self.assert_(2 not in d.keys()) + self.assertTrue(2 not in d) + self.assertTrue(2 not in d.keys()) self.assertEqual(d[2], 42) class E(dict): def __missing__(self, key): @@ -663,7 +663,7 @@ class DictTest(unittest.TestCase): obj.x = iter(obj.v) del obj, container gc.collect() - self.assert_(ref() is None, "Cycle was not collected") + self.assertTrue(ref() is None, "Cycle was not collected") def _not_tracked(self, t): # Nested containers can take several collections to untrack diff --git a/Lib/test/test_dictviews.py b/Lib/test/test_dictviews.py index 34883d2..4fee755 100644 --- a/Lib/test/test_dictviews.py +++ b/Lib/test/test_dictviews.py @@ -24,10 +24,10 @@ class DictSetTest(unittest.TestCase): self.assertNotEqual(keys, {1, "b"}) self.assertNotEqual(keys, {1}) self.assertNotEqual(keys, 42) - self.assert_(1 in keys) - self.assert_("a" in keys) - self.assert_(10 not in keys) - self.assert_("Z" not in keys) + self.assertTrue(1 in keys) + self.assertTrue("a" in keys) + self.assertTrue(10 not in keys) + self.assertTrue("Z" not in keys) self.assertEqual(d.keys(), d.keys()) e = {1: 11, "a": "def"} self.assertEqual(d.keys(), e.keys()) @@ -44,13 +44,13 @@ class DictSetTest(unittest.TestCase): self.assertNotEqual(items, {(1, 10), ("a", "def")}) self.assertNotEqual(items, {(1, 10)}) self.assertNotEqual(items, 42) - self.assert_((1, 10) in items) - self.assert_(("a", "ABC") in items) - self.assert_((1, 11) not in items) - self.assert_(1 not in items) - self.assert_(() not in items) - self.assert_((1,) not in items) - self.assert_((1, 2, 3) not in items) + self.assertTrue((1, 10) in items) + self.assertTrue(("a", "ABC") in items) + self.assertTrue((1, 11) not in items) + self.assertTrue(1 not in items) + self.assertTrue(() not in items) + self.assertTrue((1,) not in items) + self.assertTrue((1, 2, 3) not in items) self.assertEqual(d.items(), d.items()) e = d.copy() self.assertEqual(d.items(), e.items()) diff --git a/Lib/test/test_docxmlrpc.py b/Lib/test/test_docxmlrpc.py index bd96e23..7bffa48 100644 --- a/Lib/test/test_docxmlrpc.py +++ b/Lib/test/test_docxmlrpc.py @@ -104,7 +104,7 @@ class DocXMLRPCHTTPGETServer(unittest.TestCase): self.client.request("GET", "/") response = self.client.getresponse() - self.assert_( + self.assertTrue( b"""

<lambda>(x, y)

""" in response.read()) @@ -118,7 +118,7 @@ b"""

<lambda>(x, y)< self.client.request("GET", "/") response = self.client.getresponse().read() - self.assert_( # This is ugly ... how can it be made better? + self.assertTrue( # This is ugly ... how can it be made better? b"""
add(x, y)
Add two instances together. This follows PEP008, but has nothing \nto do with RFC1952. Case should matter: pEp008 and rFC1952. Things \nthat start with http and ftp should be auto-linked, too: \nhttp://google.com.
""" in response, response) @@ -131,7 +131,7 @@ b"""
add(x, y)
Add t self.client.request("GET", "/") response = self.client.getresponse().read() - self.assert_( + self.assertTrue( b"""system.methodHelp(method_name) system.methodHelp(\'add\') => "Adds two integers together" \n \nReturns a string containing documentation for the specified method. \nsystem.methodSignature(method_name) system.methodSignature(\'add\') => [double, int, int] \n \nReturns a list describing the signature of the method. In the \nabove example, the add method takes two integers as arguments \nand returns a double result. \n \nThis server does NOT support system.methodSignature. \ntest_method(arg) Test method\'s docs. This method truly does very little.""" in response) def test_autolink_dotted_methods(self): @@ -140,7 +140,7 @@ b"""system.methodHelp( self.client.request("GET", "/") response = self.client.getresponse() - self.assert_(b"""Try self.add, too.""" in + self.assertTrue(b"""Try self.add, too.""" in response.read()) def test_main(): diff --git a/Lib/test/test_dummy_thread.py b/Lib/test/test_dummy_thread.py index ecac3ee..240b61a 100644 --- a/Lib/test/test_dummy_thread.py +++ b/Lib/test/test_dummy_thread.py @@ -24,43 +24,43 @@ class LockTests(unittest.TestCase): def test_initlock(self): #Make sure locks start locked - self.failUnless(not self.lock.locked(), + self.assertTrue(not self.lock.locked(), "Lock object is not initialized unlocked.") def test_release(self): # Test self.lock.release() self.lock.acquire() self.lock.release() - self.failUnless(not self.lock.locked(), + self.assertTrue(not self.lock.locked(), "Lock object did not release properly.") def test_improper_release(self): #Make sure release of an unlocked thread raises _thread.error - self.failUnlessRaises(_thread.error, self.lock.release) + self.assertRaises(_thread.error, self.lock.release) def test_cond_acquire_success(self): #Make sure the conditional acquiring of the lock works. - self.failUnless(self.lock.acquire(0), + self.assertTrue(self.lock.acquire(0), "Conditional acquiring of the lock failed.") def test_cond_acquire_fail(self): #Test acquiring locked lock returns False self.lock.acquire(0) - self.failUnless(not self.lock.acquire(0), + self.assertTrue(not self.lock.acquire(0), "Conditional acquiring of a locked lock incorrectly " "succeeded.") def test_uncond_acquire_success(self): #Make sure unconditional acquiring of a lock works. self.lock.acquire() - self.failUnless(self.lock.locked(), + self.assertTrue(self.lock.locked(), "Uncondional locking failed.") def test_uncond_acquire_return_val(self): #Make sure that an unconditional locking returns True. - self.failUnless(self.lock.acquire(1) is True, + self.assertTrue(self.lock.acquire(1) is True, "Unconditional locking did not return True.") - self.failUnless(self.lock.acquire() is True) + self.assertTrue(self.lock.acquire() is True) def test_uncond_acquire_blocking(self): #Make sure that unconditional acquiring of a locked lock blocks. @@ -80,7 +80,7 @@ class LockTests(unittest.TestCase): end_time = int(time.time()) if support.verbose: print("done") - self.failUnless((end_time - start_time) >= DELAY, + self.assertTrue((end_time - start_time) >= DELAY, "Blocking by unconditional acquiring failed.") class MiscTests(unittest.TestCase): @@ -88,18 +88,18 @@ class MiscTests(unittest.TestCase): def test_exit(self): #Make sure _thread.exit() raises SystemExit - self.failUnlessRaises(SystemExit, _thread.exit) + self.assertRaises(SystemExit, _thread.exit) def test_ident(self): #Test sanity of _thread.get_ident() - self.failUnless(isinstance(_thread.get_ident(), int), + self.assertTrue(isinstance(_thread.get_ident(), int), "_thread.get_ident() returned a non-integer") - self.failUnless(_thread.get_ident() != 0, + self.assertTrue(_thread.get_ident() != 0, "_thread.get_ident() returned 0") def test_LockType(self): #Make sure _thread.LockType is the same type as _thread.allocate_locke() - self.failUnless(isinstance(_thread.allocate_lock(), _thread.LockType), + self.assertTrue(isinstance(_thread.allocate_lock(), _thread.LockType), "_thread.LockType is not an instance of what is " "returned by _thread.allocate_lock()") @@ -108,13 +108,13 @@ class MiscTests(unittest.TestCase): # should raise KeyboardInterrupt upon completion. def call_interrupt(): _thread.interrupt_main() - self.failUnlessRaises(KeyboardInterrupt, _thread.start_new_thread, + self.assertRaises(KeyboardInterrupt, _thread.start_new_thread, call_interrupt, tuple()) def test_interrupt_in_main(self): # Make sure that if interrupt_main is called in main threat that # KeyboardInterrupt is raised instantly. - self.failUnlessRaises(KeyboardInterrupt, _thread.interrupt_main) + self.assertRaises(KeyboardInterrupt, _thread.interrupt_main) class ThreadTests(unittest.TestCase): """Test thread creation.""" @@ -128,16 +128,16 @@ class ThreadTests(unittest.TestCase): testing_queue = queue.Queue(1) _thread.start_new_thread(arg_tester, (testing_queue, True, True)) result = testing_queue.get() - self.failUnless(result[0] and result[1], + self.assertTrue(result[0] and result[1], "Argument passing for thread creation using tuple failed") _thread.start_new_thread(arg_tester, tuple(), {'queue':testing_queue, 'arg1':True, 'arg2':True}) result = testing_queue.get() - self.failUnless(result[0] and result[1], + self.assertTrue(result[0] and result[1], "Argument passing for thread creation using kwargs failed") _thread.start_new_thread(arg_tester, (testing_queue, True), {'arg2':True}) result = testing_queue.get() - self.failUnless(result[0] and result[1], + self.assertTrue(result[0] and result[1], "Argument passing for thread creation using both tuple" " and kwargs failed") @@ -164,7 +164,7 @@ class ThreadTests(unittest.TestCase): time.sleep(DELAY) if support.verbose: print('done') - self.failUnless(testing_queue.qsize() == thread_count, + self.assertTrue(testing_queue.qsize() == thread_count, "Not all %s threads executed properly after %s sec." % (thread_count, DELAY)) diff --git a/Lib/test/test_epoll.py b/Lib/test/test_epoll.py index ab6bf0b..847b991 100644 --- a/Lib/test/test_epoll.py +++ b/Lib/test/test_epoll.py @@ -71,10 +71,10 @@ class TestEPoll(unittest.TestCase): ep = select.epoll(16) except OSError as e: raise AssertionError(str(e)) - self.assert_(ep.fileno() > 0, ep.fileno()) - self.assert_(not ep.closed) + self.assertTrue(ep.fileno() > 0, ep.fileno()) + self.assertTrue(not ep.closed) ep.close() - self.assert_(ep.closed) + self.assertTrue(ep.closed) self.assertRaises(ValueError, ep.fileno) def test_badcreate(self): @@ -141,7 +141,7 @@ class TestEPoll(unittest.TestCase): try: ep2.poll(1, 4) except IOError as e: - self.failUnlessEqual(e.args[0], errno.EBADF, e) + self.assertEqual(e.args[0], errno.EBADF, e) else: self.fail("epoll on closed fd didn't raise EBADF") @@ -157,7 +157,7 @@ class TestEPoll(unittest.TestCase): now = time.time() events = ep.poll(1, 4) then = time.time() - self.failIf(then - now > 0.1, then - now) + self.assertFalse(then - now > 0.1, then - now) events.sort() expected = [(client.fileno(), select.EPOLLOUT), @@ -165,12 +165,12 @@ class TestEPoll(unittest.TestCase): expected.sort() self.assertEquals(events, expected) - self.failIf(then - now > 0.01, then - now) + self.assertFalse(then - now > 0.01, then - now) now = time.time() events = ep.poll(timeout=2.1, maxevents=4) then = time.time() - self.failIf(events) + self.assertFalse(events) client.send(b"Hello!") server.send(b"world!!!") @@ -178,7 +178,7 @@ class TestEPoll(unittest.TestCase): now = time.time() events = ep.poll(1, 4) then = time.time() - self.failIf(then - now > 0.01) + self.assertFalse(then - now > 0.01) events.sort() expected = [(client.fileno(), select.EPOLLIN | select.EPOLLOUT), @@ -192,7 +192,7 @@ class TestEPoll(unittest.TestCase): now = time.time() events = ep.poll(1, 4) then = time.time() - self.failIf(then - now > 0.01) + self.assertFalse(then - now > 0.01) expected = [(server.fileno(), select.EPOLLOUT)] self.assertEquals(events, expected) @@ -211,7 +211,7 @@ class TestEPoll(unittest.TestCase): now = time.time() events = ep.poll(1, 4) then = time.time() - self.failIf(then - now > 0.01) + self.assertFalse(then - now > 0.01) server.close() ep.unregister(fd) diff --git a/Lib/test/test_errno.py b/Lib/test/test_errno.py index 28425e2..80edcc6 100755 --- a/Lib/test/test_errno.py +++ b/Lib/test/test_errno.py @@ -14,13 +14,13 @@ class ErrnoAttributeTests(unittest.TestCase): def test_for_improper_attributes(self): # No unexpected attributes should be on the module. for error_code in std_c_errors: - self.assert_(hasattr(errno, error_code), + self.assertTrue(hasattr(errno, error_code), "errno is missing %s" % error_code) def test_using_errorcode(self): # Every key value in errno.errorcode should be on the module. for value in errno.errorcode.values(): - self.assert_(hasattr(errno, value), 'no %s attr in errno' % value) + self.assertTrue(hasattr(errno, value), 'no %s attr in errno' % value) class ErrorcodeTests(unittest.TestCase): @@ -28,7 +28,7 @@ class ErrorcodeTests(unittest.TestCase): def test_attributes_in_errorcode(self): for attribute in errno.__dict__.keys(): if attribute.isupper(): - self.assert_(getattr(errno, attribute) in errno.errorcode, + self.assertTrue(getattr(errno, attribute) in errno.errorcode, 'no %s attr in errno.errorcode' % attribute) diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py index 8bb2079..89e6ebb 100644 --- a/Lib/test/test_exceptions.py +++ b/Lib/test/test_exceptions.py @@ -155,7 +155,7 @@ class ExceptionTests(unittest.TestCase): exc, err, tb = sys.exc_info() co = tb.tb_frame.f_code self.assertEquals(co.co_name, "test_capi1") - self.assert_(co.co_filename.endswith('test_exceptions.py')) + self.assertTrue(co.co_filename.endswith('test_exceptions.py')) else: self.fail("Expected exception") @@ -167,7 +167,7 @@ class ExceptionTests(unittest.TestCase): exc, err, tb = sys.exc_info() co = tb.tb_frame.f_code self.assertEquals(co.co_name, "__init__") - self.assert_(co.co_filename.endswith('test_exceptions.py')) + self.assertTrue(co.co_filename.endswith('test_exceptions.py')) co2 = tb.tb_frame.f_back.f_code self.assertEquals(co2.co_name, "test_capi2") else: @@ -189,12 +189,12 @@ class ExceptionTests(unittest.TestCase): except NameError: pass else: - self.failUnlessEqual(str(WindowsError(1001)), + self.assertEqual(str(WindowsError(1001)), "1001") - self.failUnlessEqual(str(WindowsError(1001, "message")), + self.assertEqual(str(WindowsError(1001, "message")), "[Error 1001] message") - self.failUnlessEqual(WindowsError(1001, "message").errno, 22) - self.failUnlessEqual(WindowsError(1001, "message").winerror, 1001) + self.assertEqual(WindowsError(1001, "message").errno, 22) + self.assertEqual(WindowsError(1001, "message").winerror, 1001) def testAttributes(self): # test that exception attributes are happy @@ -319,25 +319,25 @@ class ExceptionTests(unittest.TestCase): tb = sys.exc_info()[2] e = BaseException().with_traceback(tb) - self.failUnless(isinstance(e, BaseException)) + self.assertTrue(isinstance(e, BaseException)) self.assertEqual(e.__traceback__, tb) e = IndexError(5).with_traceback(tb) - self.failUnless(isinstance(e, IndexError)) + self.assertTrue(isinstance(e, IndexError)) self.assertEqual(e.__traceback__, tb) class MyException(Exception): pass e = MyException().with_traceback(tb) - self.failUnless(isinstance(e, MyException)) + self.assertTrue(isinstance(e, MyException)) self.assertEqual(e.__traceback__, tb) def testInvalidTraceback(self): try: Exception().__traceback__ = 5 except TypeError as e: - self.failUnless("__traceback__ must be a traceback" in str(e)) + self.assertTrue("__traceback__ must be a traceback" in str(e)) else: self.fail("No exception raised") @@ -402,10 +402,10 @@ class ExceptionTests(unittest.TestCase): def testUnicodeStrUsage(self): # Make sure both instances and classes have a str and unicode # representation. - self.failUnless(str(Exception)) - self.failUnless(str(Exception)) - self.failUnless(str(Exception('a'))) - self.failUnless(str(Exception('a'))) + self.assertTrue(str(Exception)) + self.assertTrue(str(Exception)) + self.assertTrue(str(Exception('a'))) + self.assertTrue(str(Exception('a'))) def testExceptionCleanupNames(self): # Make sure the local variable bound to the exception instance by @@ -413,9 +413,9 @@ class ExceptionTests(unittest.TestCase): try: raise Exception() except Exception as e: - self.failUnless(e) + self.assertTrue(e) del e - self.failIf('e' in locals()) + self.assertFalse('e' in locals()) def testExceptionCleanupState(self): # Make sure exception state is cleaned up as soon as the except @@ -441,7 +441,7 @@ class ExceptionTests(unittest.TestCase): pass obj = None obj = wr() - self.failUnless(obj is None, "%s" % obj) + self.assertTrue(obj is None, "%s" % obj) # Qualified "except" without "as" obj = MyObj() @@ -452,7 +452,7 @@ class ExceptionTests(unittest.TestCase): pass obj = None obj = wr() - self.failUnless(obj is None, "%s" % obj) + self.assertTrue(obj is None, "%s" % obj) # Bare "except" obj = MyObj() @@ -463,7 +463,7 @@ class ExceptionTests(unittest.TestCase): pass obj = None obj = wr() - self.failUnless(obj is None, "%s" % obj) + self.assertTrue(obj is None, "%s" % obj) # "except" with premature block leave obj = MyObj() @@ -475,7 +475,7 @@ class ExceptionTests(unittest.TestCase): break obj = None obj = wr() - self.failUnless(obj is None, "%s" % obj) + self.assertTrue(obj is None, "%s" % obj) # "except" block raising another exception obj = MyObj() @@ -493,7 +493,7 @@ class ExceptionTests(unittest.TestCase): e.__context__ = None obj = None obj = wr() - self.failUnless(obj is None, "%s" % obj) + self.assertTrue(obj is None, "%s" % obj) # Some complicated construct obj = MyObj() @@ -510,7 +510,7 @@ class ExceptionTests(unittest.TestCase): pass obj = None obj = wr() - self.failUnless(obj is None, "%s" % obj) + self.assertTrue(obj is None, "%s" % obj) # Inside an exception-silencing "with" block class Context: @@ -524,7 +524,7 @@ class ExceptionTests(unittest.TestCase): inner_raising_func() obj = None obj = wr() - self.failUnless(obj is None, "%s" % obj) + self.assertTrue(obj is None, "%s" % obj) def test_generator_leaking(self): # Test that generator exception state doesn't leak into the calling @@ -598,8 +598,8 @@ class ExceptionTests(unittest.TestCase): except RuntimeError: return sys.exc_info() e, v, tb = g() - self.assert_(isinstance(v, RuntimeError), type(v)) - self.assert_("maximum recursion depth exceeded" in str(v), str(v)) + self.assertTrue(isinstance(v, RuntimeError), type(v)) + self.assertTrue("maximum recursion depth exceeded" in str(v), str(v)) def test_MemoryError(self): diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py index 3360121..bd2d7c0 100644 --- a/Lib/test/test_file.py +++ b/Lib/test/test_file.py @@ -83,13 +83,13 @@ class AutoFileTests(unittest.TestCase): def testErrors(self): f = self.f self.assertEquals(f.name, TESTFN) - self.assert_(not f.isatty()) - self.assert_(not f.closed) + self.assertTrue(not f.isatty()) + self.assertTrue(not f.closed) if hasattr(f, "readinto"): self.assertRaises((IOError, TypeError), f.readinto, "") f.close() - self.assert_(f.closed) + self.assertTrue(f.closed) def testMethods(self): methods = [('fileno', ()), @@ -111,7 +111,7 @@ class AutoFileTests(unittest.TestCase): # __exit__ should close the file self.f.__exit__(None, None, None) - self.assert_(self.f.closed) + self.assertTrue(self.f.closed) for methodname, args in methods: method = getattr(self.f, methodname) diff --git a/Lib/test/test_filecmp.py b/Lib/test/test_filecmp.py index 22f0be7..c71a27a 100644 --- a/Lib/test/test_filecmp.py +++ b/Lib/test/test_filecmp.py @@ -25,19 +25,19 @@ class FileCompareTestCase(unittest.TestCase): os.unlink(self.name_diff) def test_matching(self): - self.failUnless(filecmp.cmp(self.name, self.name_same), + self.assertTrue(filecmp.cmp(self.name, self.name_same), "Comparing file to itself fails") - self.failUnless(filecmp.cmp(self.name, self.name_same, shallow=False), + self.assertTrue(filecmp.cmp(self.name, self.name_same, shallow=False), "Comparing file to itself fails") - self.failUnless(filecmp.cmp(self.name, self.name, shallow=False), + self.assertTrue(filecmp.cmp(self.name, self.name, shallow=False), "Comparing file to identical file fails") - self.failUnless(filecmp.cmp(self.name, self.name), + self.assertTrue(filecmp.cmp(self.name, self.name), "Comparing file to identical file fails") def test_different(self): - self.failIf(filecmp.cmp(self.name, self.name_diff), + self.assertFalse(filecmp.cmp(self.name, self.name_diff), "Mismatched files compare as equal") - self.failIf(filecmp.cmp(self.name, self.dir), + self.assertFalse(filecmp.cmp(self.name, self.dir), "File and directory compare as equal") class DirCompareTestCase(unittest.TestCase): @@ -69,19 +69,19 @@ class DirCompareTestCase(unittest.TestCase): shutil.rmtree(self.dir_diff) def test_cmpfiles(self): - self.failUnless(filecmp.cmpfiles(self.dir, self.dir, ['file']) == + self.assertTrue(filecmp.cmpfiles(self.dir, self.dir, ['file']) == (['file'], [], []), "Comparing directory to itself fails") - self.failUnless(filecmp.cmpfiles(self.dir, self.dir_same, ['file']) == + self.assertTrue(filecmp.cmpfiles(self.dir, self.dir_same, ['file']) == (['file'], [], []), "Comparing directory to same fails") # Try it with shallow=False - self.failUnless(filecmp.cmpfiles(self.dir, self.dir, ['file'], + self.assertTrue(filecmp.cmpfiles(self.dir, self.dir, ['file'], shallow=False) == (['file'], [], []), "Comparing directory to itself fails") - self.failUnless(filecmp.cmpfiles(self.dir, self.dir_same, ['file'], + self.assertTrue(filecmp.cmpfiles(self.dir, self.dir_same, ['file'], shallow=False), "Comparing directory to same fails") @@ -90,7 +90,7 @@ class DirCompareTestCase(unittest.TestCase): output.write('Different contents.\n') output.close() - self.failIf(filecmp.cmpfiles(self.dir, self.dir_same, + self.assertFalse(filecmp.cmpfiles(self.dir, self.dir_same, ['file', 'file2']) == (['file'], ['file2'], []), "Comparing mismatched directories fails") @@ -104,14 +104,14 @@ class DirCompareTestCase(unittest.TestCase): else: self.assertEqual([d.left_list, d.right_list],[['file'], ['file']]) self.assertEqual(d.common, ['file']) - self.failUnless(d.left_only == d.right_only == []) + self.assertTrue(d.left_only == d.right_only == []) self.assertEqual(d.same_files, ['file']) self.assertEqual(d.diff_files, []) # Check attributes for comparison of two different directories d = filecmp.dircmp(self.dir, self.dir_diff) self.assertEqual(d.left_list, ['file']) - self.failUnless(d.right_list == ['file', 'file2']) + self.assertTrue(d.right_list == ['file', 'file2']) self.assertEqual(d.common, ['file']) self.assertEqual(d.left_only, []) self.assertEqual(d.right_only, ['file2']) diff --git a/Lib/test/test_fileinput.py b/Lib/test/test_fileinput.py index a4d59e1..aae16ea 100644 --- a/Lib/test/test_fileinput.py +++ b/Lib/test/test_fileinput.py @@ -68,8 +68,8 @@ class BufferSizesTests(unittest.TestCase): self.assertEqual(fi.filename(), t2) self.assertEqual(fi.lineno(), 21) self.assertEqual(fi.filelineno(), 6) - self.failIf(fi.isfirstline()) - self.failIf(fi.isstdin()) + self.assertFalse(fi.isfirstline()) + self.assertFalse(fi.isstdin()) if verbose: print('%s. Nextfile (bs=%s)' % (start+2, bs)) @@ -138,7 +138,7 @@ class FileInputTests(unittest.TestCase): self.assertEqual(fi.filename(), t3) line = fi.readline() - self.failIf(line) + self.assertFalse(line) self.assertEqual(fi.lineno(), 1) self.assertEqual(fi.filelineno(), 0) self.assertEqual(fi.filename(), t4) diff --git a/Lib/test/test_fileio.py b/Lib/test/test_fileio.py index 657401e..679ed08 100644 --- a/Lib/test/test_fileio.py +++ b/Lib/test/test_fileio.py @@ -80,17 +80,17 @@ class AutoFileTests(unittest.TestCase): def testErrors(self): f = self.f - self.assert_(not f.isatty()) - self.assert_(not f.closed) + self.assertTrue(not f.isatty()) + self.assertTrue(not f.closed) #self.assertEquals(f.name, TESTFN) self.assertRaises(ValueError, f.read, 10) # Open for reading f.close() - self.assert_(f.closed) + self.assertTrue(f.closed) f = _FileIO(TESTFN, 'r') self.assertRaises(TypeError, f.readinto, "") - self.assert_(not f.closed) + self.assertTrue(not f.closed) f.close() - self.assert_(f.closed) + self.assertTrue(f.closed) def testMethods(self): methods = ['fileno', 'isatty', 'read', 'readinto', @@ -100,7 +100,7 @@ class AutoFileTests(unittest.TestCase): methods.remove('truncate') self.f.close() - self.assert_(self.f.closed) + self.assertTrue(self.f.closed) for methodname in methods: method = getattr(self.f, methodname) diff --git a/Lib/test/test_float.py b/Lib/test/test_float.py index e74e892..af5e13c 100644 --- a/Lib/test/test_float.py +++ b/Lib/test/test_float.py @@ -136,27 +136,27 @@ class GeneralFloatCases(unittest.TestCase): def test_float_containment(self): floats = (INF, -INF, 0.0, 1.0, NAN) for f in floats: - self.assert_(f in [f], "'%r' not in []" % f) - self.assert_(f in (f,), "'%r' not in ()" % f) - self.assert_(f in {f}, "'%r' not in set()" % f) - self.assert_(f in {f: None}, "'%r' not in {}" % f) + self.assertTrue(f in [f], "'%r' not in []" % f) + self.assertTrue(f in (f,), "'%r' not in ()" % f) + self.assertTrue(f in {f}, "'%r' not in set()" % f) + self.assertTrue(f in {f: None}, "'%r' not in {}" % f) self.assertEqual([f].count(f), 1, "[].count('%r') != 1" % f) - self.assert_(f in floats, "'%r' not in container" % f) + self.assertTrue(f in floats, "'%r' not in container" % f) for f in floats: # nonidentical containers, same type, same contents - self.assert_([f] == [f], "[%r] != [%r]" % (f, f)) - self.assert_((f,) == (f,), "(%r,) != (%r,)" % (f, f)) - self.assert_({f} == {f}, "{%r} != {%r}" % (f, f)) - self.assert_({f : None} == {f: None}, "{%r : None} != " + self.assertTrue([f] == [f], "[%r] != [%r]" % (f, f)) + self.assertTrue((f,) == (f,), "(%r,) != (%r,)" % (f, f)) + self.assertTrue({f} == {f}, "{%r} != {%r}" % (f, f)) + self.assertTrue({f : None} == {f: None}, "{%r : None} != " "{%r : None}" % (f, f)) # identical containers l, t, s, d = [f], (f,), {f}, {f: None} - self.assert_(l == l, "[%r] not equal to itself" % f) - self.assert_(t == t, "(%r,) not equal to itself" % f) - self.assert_(s == s, "{%r} not equal to itself" % f) - self.assert_(d == d, "{%r : None} not equal to itself" % f) + self.assertTrue(l == l, "[%r] not equal to itself" % f) + self.assertTrue(t == t, "(%r,) not equal to itself" % f) + self.assertTrue(s == s, "{%r} not equal to itself" % f) + self.assertTrue(d == d, "{%r : None} not equal to itself" % f) @@ -171,9 +171,9 @@ class FormatFunctionsTestCase(unittest.TestCase): float.__setformat__('float', self.save_formats['float']) def test_getformat(self): - self.assert_(float.__getformat__('double') in + self.assertTrue(float.__getformat__('double') in ['unknown', 'IEEE, big-endian', 'IEEE, little-endian']) - self.assert_(float.__getformat__('float') in + self.assertTrue(float.__getformat__('float') in ['unknown', 'IEEE, big-endian', 'IEEE, little-endian']) self.assertRaises(ValueError, float.__getformat__, 'chicken') self.assertRaises(TypeError, float.__getformat__, 1) @@ -493,12 +493,12 @@ class RoundTestCase(unittest.TestCase): # ways to create and represent inf and nan class InfNanTest(unittest.TestCase): def test_inf_from_str(self): - self.assert_(isinf(float("inf"))) - self.assert_(isinf(float("+inf"))) - self.assert_(isinf(float("-inf"))) - self.assert_(isinf(float("infinity"))) - self.assert_(isinf(float("+infinity"))) - self.assert_(isinf(float("-infinity"))) + self.assertTrue(isinf(float("inf"))) + self.assertTrue(isinf(float("+inf"))) + self.assertTrue(isinf(float("-inf"))) + self.assertTrue(isinf(float("infinity"))) + self.assertTrue(isinf(float("+infinity"))) + self.assertTrue(isinf(float("-infinity"))) self.assertEqual(repr(float("inf")), "inf") self.assertEqual(repr(float("+inf")), "inf") @@ -545,9 +545,9 @@ class InfNanTest(unittest.TestCase): self.assertEqual(str(-1e300 * 1e300), "-inf") def test_nan_from_str(self): - self.assert_(isnan(float("nan"))) - self.assert_(isnan(float("+nan"))) - self.assert_(isnan(float("-nan"))) + self.assertTrue(isnan(float("nan"))) + self.assertTrue(isnan(float("+nan"))) + self.assertTrue(isnan(float("-nan"))) self.assertEqual(repr(float("nan")), "nan") self.assertEqual(repr(float("+nan")), "nan") @@ -581,14 +581,14 @@ class InfNanTest(unittest.TestCase): self.assertEqual(str(-1e300 * 1e300 * 0), "nan") def notest_float_nan(self): - self.assert_(NAN.is_nan()) - self.failIf(INF.is_nan()) - self.failIf((0.).is_nan()) + self.assertTrue(NAN.is_nan()) + self.assertFalse(INF.is_nan()) + self.assertFalse((0.).is_nan()) def notest_float_inf(self): - self.assert_(INF.is_inf()) - self.failIf(NAN.is_inf()) - self.failIf((0.).is_inf()) + self.assertTrue(INF.is_inf()) + self.assertFalse(NAN.is_inf()) + self.assertFalse((0.).is_inf()) fromHex = float.fromhex toHex = float.hex diff --git a/Lib/test/test_fnmatch.py b/Lib/test/test_fnmatch.py index 30ccf69..2f701ca 100644 --- a/Lib/test/test_fnmatch.py +++ b/Lib/test/test_fnmatch.py @@ -9,11 +9,11 @@ from fnmatch import fnmatch, fnmatchcase class FnmatchTestCase(unittest.TestCase): def check_match(self, filename, pattern, should_match=1): if should_match: - self.assert_(fnmatch(filename, pattern), + self.assertTrue(fnmatch(filename, pattern), "expected %r to match pattern %r" % (filename, pattern)) else: - self.assert_(not fnmatch(filename, pattern), + self.assertTrue(not fnmatch(filename, pattern), "expected %r not to match pattern %r" % (filename, pattern)) diff --git a/Lib/test/test_ftplib.py b/Lib/test/test_ftplib.py index afc8fda..b83cba0 100644 --- a/Lib/test/test_ftplib.py +++ b/Lib/test/test_ftplib.py @@ -444,7 +444,7 @@ class TestTimeouts(TestCase): def testTimeoutDefault(self): # default -- use global socket timeout - self.assert_(socket.getdefaulttimeout() is None) + self.assertTrue(socket.getdefaulttimeout() is None) socket.setdefaulttimeout(30) try: ftp = ftplib.FTP("localhost") @@ -456,7 +456,7 @@ class TestTimeouts(TestCase): def testTimeoutNone(self): # no timeout -- do not use global socket timeout - self.assert_(socket.getdefaulttimeout() is None) + self.assertTrue(socket.getdefaulttimeout() is None) socket.setdefaulttimeout(30) try: ftp = ftplib.FTP("localhost", timeout=None) diff --git a/Lib/test/test_funcattrs.py b/Lib/test/test_funcattrs.py index b42f6cc..5765b4e 100644 --- a/Lib/test/test_funcattrs.py +++ b/Lib/test/test_funcattrs.py @@ -35,11 +35,11 @@ class FunctionPropertiesTest(FuncAttrsTest): def test_dir_includes_correct_attrs(self): self.b.known_attr = 7 - self.assert_('known_attr' in dir(self.b), + self.assertTrue('known_attr' in dir(self.b), "set attributes not in dir listing of method") # Test on underlying function object of method self.F.a.known_attr = 7 - self.assert_('known_attr' in dir(self.fi.a), "set attribute on function " + self.assertTrue('known_attr' in dir(self.fi.a), "set attribute on function " "implementations, should show up in next dir") def test_duplicate_function_equality(self): @@ -248,11 +248,11 @@ class CellTest(unittest.TestCase): # their presence should not be interpreted as providing any # guarantees about the semantics (or even existence) of cell # comparisons in future versions of CPython. - self.assert_(cell(2) < cell(3)) - self.assert_(empty_cell() < cell('saturday')) - self.assert_(empty_cell() == empty_cell()) - self.assert_(cell(-36) == cell(-36.0)) - self.assert_(cell(True) > empty_cell()) + self.assertTrue(cell(2) < cell(3)) + self.assertTrue(empty_cell() < cell('saturday')) + self.assertTrue(empty_cell() == empty_cell()) + self.assertTrue(cell(-36) == cell(-36.0)) + self.assertTrue(cell(True) > empty_cell()) class StaticMethodAttrsTest(unittest.TestCase): def test_func_attribute(self): @@ -260,10 +260,10 @@ class StaticMethodAttrsTest(unittest.TestCase): pass c = classmethod(f) - self.assert_(c.__func__ is f) + self.assertTrue(c.__func__ is f) s = staticmethod(f) - self.assert_(s.__func__ is f) + self.assertTrue(s.__func__ is f) def test_main(): diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py index dedfb1e..eff31e0 100644 --- a/Lib/test/test_functools.py +++ b/Lib/test/test_functools.py @@ -96,7 +96,7 @@ class TestPartial(unittest.TestCase): p = self.thetype(capture, *args) expected = args + ('x',) got, empty = p('x') - self.failUnless(expected == got and empty == {}) + self.assertTrue(expected == got and empty == {}) def test_keyword(self): # make sure keyword arguments are captured correctly @@ -104,15 +104,15 @@ class TestPartial(unittest.TestCase): p = self.thetype(capture, a=a) expected = {'a':a,'x':None} empty, got = p(x=None) - self.failUnless(expected == got and empty == ()) + self.assertTrue(expected == got and empty == ()) def test_no_side_effects(self): # make sure there are no side effects that affect subsequent calls p = self.thetype(capture, 0, a=1) args1, kw1 = p(1, b=2) - self.failUnless(args1 == (0,1) and kw1 == {'a':1,'b':2}) + self.assertTrue(args1 == (0,1) and kw1 == {'a':1,'b':2}) args2, kw2 = p() - self.failUnless(args2 == (0,) and kw2 == {'a':1}) + self.assertTrue(args2 == (0,) and kw2 == {'a':1}) def test_error_propagation(self): def f(x, y): @@ -172,13 +172,13 @@ class TestUpdateWrapper(unittest.TestCase): updated=functools.WRAPPER_UPDATES): # Check attributes were assigned for name in assigned: - self.failUnless(getattr(wrapper, name) is getattr(wrapped, name)) + self.assertTrue(getattr(wrapper, name) is getattr(wrapped, name)) # Check attributes were updated for name in updated: wrapper_attr = getattr(wrapper, name) wrapped_attr = getattr(wrapped, name) for key in wrapped_attr: - self.failUnless(wrapped_attr[key] is wrapper_attr[key]) + self.assertTrue(wrapped_attr[key] is wrapper_attr[key]) def test_default_update(self): def f(): @@ -204,7 +204,7 @@ class TestUpdateWrapper(unittest.TestCase): self.check_wrapper(wrapper, f, (), ()) self.assertEqual(wrapper.__name__, 'wrapper') self.assertEqual(wrapper.__doc__, None) - self.failIf(hasattr(wrapper, 'attr')) + self.assertFalse(hasattr(wrapper, 'attr')) def test_selective_update(self): def f(): @@ -229,7 +229,7 @@ class TestUpdateWrapper(unittest.TestCase): pass functools.update_wrapper(wrapper, max) self.assertEqual(wrapper.__name__, 'max') - self.assert_(wrapper.__doc__.startswith('max(')) + self.assertTrue(wrapper.__doc__.startswith('max(')) class TestWraps(TestUpdateWrapper): @@ -257,7 +257,7 @@ class TestWraps(TestUpdateWrapper): self.check_wrapper(wrapper, f, (), ()) self.assertEqual(wrapper.__name__, 'wrapper') self.assertEqual(wrapper.__doc__, None) - self.failIf(hasattr(wrapper, 'attr')) + self.assertFalse(hasattr(wrapper, 'attr')) def test_selective_update(self): def f(): diff --git a/Lib/test/test_genericpath.py b/Lib/test/test_genericpath.py index 9d0baeb..3be9c89 100644 --- a/Lib/test/test_genericpath.py +++ b/Lib/test/test_genericpath.py @@ -6,7 +6,7 @@ import genericpath class AllCommonTest(unittest.TestCase): def assertIs(self, a, b): - self.assert_(a is b) + self.assertTrue(a is b) def test_commonprefix(self): self.assertEqual( @@ -50,7 +50,7 @@ class AllCommonTest(unittest.TestCase): f.close() self.assertEqual(d, b"foobar") - self.assert_( + self.assertTrue( genericpath.getctime(support.TESTFN) <= genericpath.getmtime(support.TESTFN) ) diff --git a/Lib/test/test_getargs2.py b/Lib/test/test_getargs2.py index 34d8ee0..3ffc1cc 100644 --- a/Lib/test/test_getargs2.py +++ b/Lib/test/test_getargs2.py @@ -68,68 +68,68 @@ class Unsigned_TestCase(unittest.TestCase): from _testcapi import getargs_b # b returns 'unsigned char', and does range checking (0 ... UCHAR_MAX) self.assertRaises(TypeError, getargs_b, 3.14) - self.failUnlessEqual(99, getargs_b(Long())) - self.failUnlessEqual(99, getargs_b(Int())) + self.assertEqual(99, getargs_b(Long())) + self.assertEqual(99, getargs_b(Int())) self.assertRaises(OverflowError, getargs_b, -1) - self.failUnlessEqual(0, getargs_b(0)) - self.failUnlessEqual(UCHAR_MAX, getargs_b(UCHAR_MAX)) + self.assertEqual(0, getargs_b(0)) + self.assertEqual(UCHAR_MAX, getargs_b(UCHAR_MAX)) self.assertRaises(OverflowError, getargs_b, UCHAR_MAX + 1) - self.failUnlessEqual(42, getargs_b(42)) - self.failUnlessEqual(42, getargs_b(42)) + self.assertEqual(42, getargs_b(42)) + self.assertEqual(42, getargs_b(42)) self.assertRaises(OverflowError, getargs_b, VERY_LARGE) def test_B(self): from _testcapi import getargs_B # B returns 'unsigned char', no range checking self.assertRaises(TypeError, getargs_B, 3.14) - self.failUnlessEqual(99, getargs_B(Long())) - self.failUnlessEqual(99, getargs_B(Int())) + self.assertEqual(99, getargs_B(Long())) + self.assertEqual(99, getargs_B(Int())) - self.failUnlessEqual(UCHAR_MAX, getargs_B(-1)) - self.failUnlessEqual(UCHAR_MAX, getargs_B(-1)) - self.failUnlessEqual(0, getargs_B(0)) - self.failUnlessEqual(UCHAR_MAX, getargs_B(UCHAR_MAX)) - self.failUnlessEqual(0, getargs_B(UCHAR_MAX+1)) + self.assertEqual(UCHAR_MAX, getargs_B(-1)) + self.assertEqual(UCHAR_MAX, getargs_B(-1)) + self.assertEqual(0, getargs_B(0)) + self.assertEqual(UCHAR_MAX, getargs_B(UCHAR_MAX)) + self.assertEqual(0, getargs_B(UCHAR_MAX+1)) - self.failUnlessEqual(42, getargs_B(42)) - self.failUnlessEqual(42, getargs_B(42)) - self.failUnlessEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE)) + self.assertEqual(42, getargs_B(42)) + self.assertEqual(42, getargs_B(42)) + self.assertEqual(UCHAR_MAX & VERY_LARGE, getargs_B(VERY_LARGE)) def test_H(self): from _testcapi import getargs_H # H returns 'unsigned short', no range checking self.assertRaises(TypeError, getargs_H, 3.14) - self.failUnlessEqual(99, getargs_H(Long())) - self.failUnlessEqual(99, getargs_H(Int())) + self.assertEqual(99, getargs_H(Long())) + self.assertEqual(99, getargs_H(Int())) - self.failUnlessEqual(USHRT_MAX, getargs_H(-1)) - self.failUnlessEqual(0, getargs_H(0)) - self.failUnlessEqual(USHRT_MAX, getargs_H(USHRT_MAX)) - self.failUnlessEqual(0, getargs_H(USHRT_MAX+1)) + self.assertEqual(USHRT_MAX, getargs_H(-1)) + self.assertEqual(0, getargs_H(0)) + self.assertEqual(USHRT_MAX, getargs_H(USHRT_MAX)) + self.assertEqual(0, getargs_H(USHRT_MAX+1)) - self.failUnlessEqual(42, getargs_H(42)) - self.failUnlessEqual(42, getargs_H(42)) + self.assertEqual(42, getargs_H(42)) + self.assertEqual(42, getargs_H(42)) - self.failUnlessEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE)) + self.assertEqual(VERY_LARGE & USHRT_MAX, getargs_H(VERY_LARGE)) def test_I(self): from _testcapi import getargs_I # I returns 'unsigned int', no range checking self.assertRaises(TypeError, getargs_I, 3.14) - self.failUnlessEqual(99, getargs_I(Long())) - self.failUnlessEqual(99, getargs_I(Int())) + self.assertEqual(99, getargs_I(Long())) + self.assertEqual(99, getargs_I(Int())) - self.failUnlessEqual(UINT_MAX, getargs_I(-1)) - self.failUnlessEqual(0, getargs_I(0)) - self.failUnlessEqual(UINT_MAX, getargs_I(UINT_MAX)) - self.failUnlessEqual(0, getargs_I(UINT_MAX+1)) + self.assertEqual(UINT_MAX, getargs_I(-1)) + self.assertEqual(0, getargs_I(0)) + self.assertEqual(UINT_MAX, getargs_I(UINT_MAX)) + self.assertEqual(0, getargs_I(UINT_MAX+1)) - self.failUnlessEqual(42, getargs_I(42)) - self.failUnlessEqual(42, getargs_I(42)) + self.assertEqual(42, getargs_I(42)) + self.assertEqual(42, getargs_I(42)) - self.failUnlessEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE)) + self.assertEqual(VERY_LARGE & UINT_MAX, getargs_I(VERY_LARGE)) def test_k(self): from _testcapi import getargs_k @@ -139,47 +139,47 @@ class Unsigned_TestCase(unittest.TestCase): self.assertRaises(TypeError, getargs_k, Long()) self.assertRaises(TypeError, getargs_k, Int()) - self.failUnlessEqual(ULONG_MAX, getargs_k(-1)) - self.failUnlessEqual(0, getargs_k(0)) - self.failUnlessEqual(ULONG_MAX, getargs_k(ULONG_MAX)) - self.failUnlessEqual(0, getargs_k(ULONG_MAX+1)) + self.assertEqual(ULONG_MAX, getargs_k(-1)) + self.assertEqual(0, getargs_k(0)) + self.assertEqual(ULONG_MAX, getargs_k(ULONG_MAX)) + self.assertEqual(0, getargs_k(ULONG_MAX+1)) - self.failUnlessEqual(42, getargs_k(42)) - self.failUnlessEqual(42, getargs_k(42)) + self.assertEqual(42, getargs_k(42)) + self.assertEqual(42, getargs_k(42)) - self.failUnlessEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE)) + self.assertEqual(VERY_LARGE & ULONG_MAX, getargs_k(VERY_LARGE)) class Signed_TestCase(unittest.TestCase): def test_i(self): from _testcapi import getargs_i # i returns 'int', and does range checking (INT_MIN ... INT_MAX) self.assertRaises(TypeError, getargs_i, 3.14) - self.failUnlessEqual(99, getargs_i(Long())) - self.failUnlessEqual(99, getargs_i(Int())) + self.assertEqual(99, getargs_i(Long())) + self.assertEqual(99, getargs_i(Int())) self.assertRaises(OverflowError, getargs_i, INT_MIN-1) - self.failUnlessEqual(INT_MIN, getargs_i(INT_MIN)) - self.failUnlessEqual(INT_MAX, getargs_i(INT_MAX)) + self.assertEqual(INT_MIN, getargs_i(INT_MIN)) + self.assertEqual(INT_MAX, getargs_i(INT_MAX)) self.assertRaises(OverflowError, getargs_i, INT_MAX+1) - self.failUnlessEqual(42, getargs_i(42)) - self.failUnlessEqual(42, getargs_i(42)) + self.assertEqual(42, getargs_i(42)) + self.assertEqual(42, getargs_i(42)) self.assertRaises(OverflowError, getargs_i, VERY_LARGE) def test_l(self): from _testcapi import getargs_l # l returns 'long', and does range checking (LONG_MIN ... LONG_MAX) self.assertRaises(TypeError, getargs_l, 3.14) - self.failUnlessEqual(99, getargs_l(Long())) - self.failUnlessEqual(99, getargs_l(Int())) + self.assertEqual(99, getargs_l(Long())) + self.assertEqual(99, getargs_l(Int())) self.assertRaises(OverflowError, getargs_l, LONG_MIN-1) - self.failUnlessEqual(LONG_MIN, getargs_l(LONG_MIN)) - self.failUnlessEqual(LONG_MAX, getargs_l(LONG_MAX)) + self.assertEqual(LONG_MIN, getargs_l(LONG_MIN)) + self.assertEqual(LONG_MAX, getargs_l(LONG_MAX)) self.assertRaises(OverflowError, getargs_l, LONG_MAX+1) - self.failUnlessEqual(42, getargs_l(42)) - self.failUnlessEqual(42, getargs_l(42)) + self.assertEqual(42, getargs_l(42)) + self.assertEqual(42, getargs_l(42)) self.assertRaises(OverflowError, getargs_l, VERY_LARGE) def test_n(self): @@ -191,12 +191,12 @@ class Signed_TestCase(unittest.TestCase): self.assertRaises(TypeError, getargs_n, Int()) self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MIN-1) - self.failUnlessEqual(PY_SSIZE_T_MIN, getargs_n(PY_SSIZE_T_MIN)) - self.failUnlessEqual(PY_SSIZE_T_MAX, getargs_n(PY_SSIZE_T_MAX)) + self.assertEqual(PY_SSIZE_T_MIN, getargs_n(PY_SSIZE_T_MIN)) + self.assertEqual(PY_SSIZE_T_MAX, getargs_n(PY_SSIZE_T_MAX)) self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MAX+1) - self.failUnlessEqual(42, getargs_n(42)) - self.failUnlessEqual(42, getargs_n(42)) + self.assertEqual(42, getargs_n(42)) + self.assertEqual(42, getargs_n(42)) self.assertRaises(OverflowError, getargs_n, VERY_LARGE) @@ -204,18 +204,18 @@ class LongLong_TestCase(unittest.TestCase): def test_L(self): from _testcapi import getargs_L # L returns 'long long', and does range checking (LLONG_MIN ... LLONG_MAX) - self.failUnlessRaises(TypeError, getargs_L, "Hello") - self.failUnlessEqual(3, getargs_L(3.14)) - self.failUnlessEqual(99, getargs_L(Long())) - self.failUnlessEqual(99, getargs_L(Int())) + self.assertRaises(TypeError, getargs_L, "Hello") + self.assertEqual(3, getargs_L(3.14)) + self.assertEqual(99, getargs_L(Long())) + self.assertEqual(99, getargs_L(Int())) self.assertRaises(OverflowError, getargs_L, LLONG_MIN-1) - self.failUnlessEqual(LLONG_MIN, getargs_L(LLONG_MIN)) - self.failUnlessEqual(LLONG_MAX, getargs_L(LLONG_MAX)) + self.assertEqual(LLONG_MIN, getargs_L(LLONG_MIN)) + self.assertEqual(LLONG_MAX, getargs_L(LLONG_MAX)) self.assertRaises(OverflowError, getargs_L, LLONG_MAX+1) - self.failUnlessEqual(42, getargs_L(42)) - self.failUnlessEqual(42, getargs_L(42)) + self.assertEqual(42, getargs_L(42)) + self.assertEqual(42, getargs_L(42)) self.assertRaises(OverflowError, getargs_L, VERY_LARGE) def test_K(self): @@ -224,14 +224,14 @@ class LongLong_TestCase(unittest.TestCase): self.assertRaises(TypeError, getargs_K, 3.14) self.assertRaises(TypeError, getargs_K, Long()) self.assertRaises(TypeError, getargs_K, Int()) - self.failUnlessEqual(ULLONG_MAX, getargs_K(ULLONG_MAX)) - self.failUnlessEqual(0, getargs_K(0)) - self.failUnlessEqual(0, getargs_K(ULLONG_MAX+1)) + self.assertEqual(ULLONG_MAX, getargs_K(ULLONG_MAX)) + self.assertEqual(0, getargs_K(0)) + self.assertEqual(0, getargs_K(ULLONG_MAX+1)) - self.failUnlessEqual(42, getargs_K(42)) - self.failUnlessEqual(42, getargs_K(42)) + self.assertEqual(42, getargs_K(42)) + self.assertEqual(42, getargs_K(42)) - self.failUnlessEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE)) + self.assertEqual(VERY_LARGE & ULLONG_MAX, getargs_K(VERY_LARGE)) class Tuple_TestCase(unittest.TestCase): diff --git a/Lib/test/test_getopt.py b/Lib/test/test_getopt.py index b7a6309..20b5690 100644 --- a/Lib/test/test_getopt.py +++ b/Lib/test/test_getopt.py @@ -23,21 +23,21 @@ class GetoptTests(unittest.TestCase): self.assertRaises(getopt.GetoptError, *args, **kwargs) def test_short_has_arg(self): - self.failUnless(getopt.short_has_arg('a', 'a:')) - self.failIf(getopt.short_has_arg('a', 'a')) + self.assertTrue(getopt.short_has_arg('a', 'a:')) + self.assertFalse(getopt.short_has_arg('a', 'a')) self.assertError(getopt.short_has_arg, 'a', 'b') def test_long_has_args(self): has_arg, option = getopt.long_has_args('abc', ['abc=']) - self.failUnless(has_arg) + self.assertTrue(has_arg) self.assertEqual(option, 'abc') has_arg, option = getopt.long_has_args('abc', ['abc']) - self.failIf(has_arg) + self.assertFalse(has_arg) self.assertEqual(option, 'abc') has_arg, option = getopt.long_has_args('abc', ['abcd']) - self.failIf(has_arg) + self.assertFalse(has_arg) self.assertEqual(option, 'abcd') self.assertError(getopt.long_has_args, 'abc', ['def']) diff --git a/Lib/test/test_gettext.py b/Lib/test/test_gettext.py index 0023941..d667819 100644 --- a/Lib/test/test_gettext.py +++ b/Lib/test/test_gettext.py @@ -306,7 +306,7 @@ class UnicodeTranslationsTest(GettextBaseTest): self._ = self.t.gettext def test_unicode_msgid(self): - unless = self.failUnless + unless = self.assertTrue unless(isinstance(self._(''), str)) unless(isinstance(self._(''), str)) diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py index 977f0b8..b861207 100644 --- a/Lib/test/test_grammar.py +++ b/Lib/test/test_grammar.py @@ -38,9 +38,9 @@ class TokenTests(unittest.TestCase): if maxsize == 2147483647: self.assertEquals(-2147483647-1, -0o20000000000) # XXX -2147483648 - self.assert_(0o37777777777 > 0) - self.assert_(0xffffffff > 0) - self.assert_(0b1111111111111111111111111111111 > 0) + self.assertTrue(0o37777777777 > 0) + self.assertTrue(0xffffffff > 0) + self.assertTrue(0b1111111111111111111111111111111 > 0) for s in ('2147483648', '0o40000000000', '0x100000000', '0b10000000000000000000000000000000'): try: @@ -49,9 +49,9 @@ class TokenTests(unittest.TestCase): self.fail("OverflowError on huge integer literal %r" % s) elif maxsize == 9223372036854775807: self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000) - self.assert_(0o1777777777777777777777 > 0) - self.assert_(0xffffffffffffffff > 0) - self.assert_(0b11111111111111111111111111111111111111111111111111111111111111 > 0) + self.assertTrue(0o1777777777777777777777 > 0) + self.assertTrue(0xffffffffffffffff > 0) + self.assertTrue(0b11111111111111111111111111111111111111111111111111111111111111 > 0) for s in '9223372036854775808', '0o2000000000000000000000', \ '0x10000000000000000', \ '0b100000000000000000000000000000000000000000000000000000000000000': @@ -87,15 +87,15 @@ class TokenTests(unittest.TestCase): x = 3.1e4 def testStringLiterals(self): - x = ''; y = ""; self.assert_(len(x) == 0 and x == y) - x = '\''; y = "'"; self.assert_(len(x) == 1 and x == y and ord(x) == 39) - x = '"'; y = "\""; self.assert_(len(x) == 1 and x == y and ord(x) == 34) + x = ''; y = ""; self.assertTrue(len(x) == 0 and x == y) + x = '\''; y = "'"; self.assertTrue(len(x) == 1 and x == y and ord(x) == 39) + x = '"'; y = "\""; self.assertTrue(len(x) == 1 and x == y and ord(x) == 34) x = "doesn't \"shrink\" does it" y = 'doesn\'t "shrink" does it' - self.assert_(len(x) == 24 and x == y) + self.assertTrue(len(x) == 24 and x == y) x = "does \"shrink\" doesn't it" y = 'does "shrink" doesn\'t it' - self.assert_(len(x) == 24 and x == y) + self.assertTrue(len(x) == 24 and x == y) x = """ The "quick" brown fox @@ -128,7 +128,7 @@ the \'lazy\' dog.\n\ def testEllipsis(self): x = ... - self.assert_(x is Ellipsis) + self.assertTrue(x is Ellipsis) self.assertRaises(SyntaxError, eval, ".. .") class GrammarTests(unittest.TestCase): @@ -494,7 +494,7 @@ class GrammarTests(unittest.TestCase): nonlocal x, y def testAssert(self): - # assert_stmt: 'assert' test [',' test] + # assertTruestmt: 'assert' test [',' test] assert 1 assert 1, 1 assert lambda x:x diff --git a/Lib/test/test_grp.py b/Lib/test/test_grp.py index 1c1f75f..765b4b6 100755 --- a/Lib/test/test_grp.py +++ b/Lib/test/test_grp.py @@ -12,13 +12,13 @@ class GroupDatabaseTestCase(unittest.TestCase): # attributes promised by the docs self.assertEqual(len(value), 4) self.assertEqual(value[0], value.gr_name) - self.assert_(isinstance(value.gr_name, str)) + self.assertTrue(isinstance(value.gr_name, str)) self.assertEqual(value[1], value.gr_passwd) - self.assert_(isinstance(value.gr_passwd, str)) + self.assertTrue(isinstance(value.gr_passwd, str)) self.assertEqual(value[2], value.gr_gid) - self.assert_(isinstance(value.gr_gid, int)) + self.assertTrue(isinstance(value.gr_gid, int)) self.assertEqual(value[3], value.gr_mem) - self.assert_(isinstance(value.gr_mem, list)) + self.assertTrue(isinstance(value.gr_mem, list)) def test_values(self): entries = grp.getgrall() diff --git a/Lib/test/test_gzip.py b/Lib/test/test_gzip.py index baf3a21..d928635 100644 --- a/Lib/test/test_gzip.py +++ b/Lib/test/test_gzip.py @@ -91,7 +91,7 @@ class TestGzip(unittest.TestCase): while 1: L = f.readline(line_length) if not L and line_length != 0: break - self.assert_(len(L) <= line_length) + self.assertTrue(len(L) <= line_length) line_length = (line_length + 1) % 50 f.close() @@ -157,7 +157,7 @@ class TestGzip(unittest.TestCase): def test_1647484(self): for mode in ('wb', 'rb'): f = gzip.GzipFile(self.filename, mode) - self.assert_(hasattr(f, "name")) + self.assertTrue(hasattr(f, "name")) self.assertEqual(f.name, self.filename) f.close() @@ -169,7 +169,7 @@ class TestGzip(unittest.TestCase): fRead = gzip.GzipFile(self.filename) dataRead = fRead.read() self.assertEqual(dataRead, data1) - self.assert_(hasattr(fRead, 'mtime')) + self.assertTrue(hasattr(fRead, 'mtime')) self.assertEqual(fRead.mtime, mtime) fRead.close() diff --git a/Lib/test/test_hash.py b/Lib/test/test_hash.py index 5babc5a..569e5e0 100644 --- a/Lib/test/test_hash.py +++ b/Lib/test/test_hash.py @@ -91,7 +91,7 @@ class HashInheritanceTestCase(unittest.TestCase): objects = (self.default_expected + self.fixed_expected) for obj in objects: - self.assert_(isinstance(obj, Hashable), repr(obj)) + self.assertTrue(isinstance(obj, Hashable), repr(obj)) def test_not_hashable(self): for obj in self.error_expected: diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py index 5bfea6b..d0ad07d 100644 --- a/Lib/test/test_hashlib.py +++ b/Lib/test/test_hashlib.py @@ -36,7 +36,7 @@ class HashLibTestCase(unittest.TestCase): except ValueError: pass else: - self.assert_(0 == "hashlib didn't reject bogus hash name") + self.assertTrue(0 == "hashlib didn't reject bogus hash name") def test_hexdigest(self): for name in self.supported_hash_names: diff --git a/Lib/test/test_heapq.py b/Lib/test/test_heapq.py index 94c3992..5e3b0ee 100644 --- a/Lib/test/test_heapq.py +++ b/Lib/test/test_heapq.py @@ -46,7 +46,7 @@ class TestHeap(unittest.TestCase): for pos, item in enumerate(heap): if pos: # pos 0 has no parent parentpos = (pos-1) >> 1 - self.assert_(heap[parentpos] <= item) + self.assertTrue(heap[parentpos] <= item) def test_heapify(self): for size in range(30): diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py index 8dcbe7e..fb78eba 100644 --- a/Lib/test/test_hmac.py +++ b/Lib/test/test_hmac.py @@ -280,7 +280,7 @@ class CopyTestCase(unittest.TestCase): # Testing if attributes are of same type. h1 = hmac.HMAC(b"key") h2 = h1.copy() - self.failUnless(h1.digest_cons == h2.digest_cons, + self.assertTrue(h1.digest_cons == h2.digest_cons, "digest constructors don't match.") self.assertEqual(type(h1.inner), type(h2.inner), "Types of inner don't match.") @@ -292,10 +292,10 @@ class CopyTestCase(unittest.TestCase): h1 = hmac.HMAC(b"key") h2 = h1.copy() # Using id() in case somebody has overridden __eq__/__ne__. - self.failUnless(id(h1) != id(h2), "No real copy of the HMAC instance.") - self.failUnless(id(h1.inner) != id(h2.inner), + self.assertTrue(id(h1) != id(h2), "No real copy of the HMAC instance.") + self.assertTrue(id(h1.inner) != id(h2.inner), "No real copy of the attribute 'inner'.") - self.failUnless(id(h1.outer) != id(h2.outer), + self.assertTrue(id(h1.outer) != id(h2.outer), "No real copy of the attribute 'outer'.") def test_equality(self): diff --git a/Lib/test/test_http_cookiejar.py b/Lib/test/test_http_cookiejar.py index 5ec0c25..e5f7143 100644 --- a/Lib/test/test_http_cookiejar.py +++ b/Lib/test/test_http_cookiejar.py @@ -25,7 +25,7 @@ class DateTimeTests(TestCase): az = time2isoz() bz = time2isoz(500000) for text in (az, bz): - self.assert_(re.search(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\dZ$", text), + self.assertTrue(re.search(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\dZ$", text), "bad time2isoz format: %s %s" % (az, bz)) def test_http2time(self): @@ -74,7 +74,7 @@ class DateTimeTests(TestCase): t2 = http2time(s.lower()) t3 = http2time(s.upper()) - self.assert_(t == t2 == t3 == test_t, + self.assertTrue(t == t2 == t3 == test_t, "'%s' => %s, %s, %s (%s)" % (s, t, t2, t3, test_t)) def test_http2time_garbage(self): @@ -90,7 +90,7 @@ class DateTimeTests(TestCase): '01-01-1980 00:61:00', '01-01-1980 00:00:62', ]: - self.assert_(http2time(test) is None, + self.assertTrue(http2time(test) is None, "http2time(%s) is not None\n" "http2time(test) %s" % (test, http2time(test)) ) @@ -332,8 +332,8 @@ class CookieTests(TestCase): ]: request = urllib.request.Request(url) r = pol.domain_return_ok(domain, request) - if ok: self.assert_(r) - else: self.assert_(not r) + if ok: self.assertTrue(r) + else: self.assertTrue(not r) def test_missing_value(self): # missing = sign in Cookie: header is regarded by Mozilla as a missing @@ -343,10 +343,10 @@ class CookieTests(TestCase): interact_netscape(c, "http://www.acme.com/", 'eggs') interact_netscape(c, "http://www.acme.com/", '"spam"; path=/foo/') cookie = c._cookies["www.acme.com"]["/"]["eggs"] - self.assert_(cookie.value is None) + self.assertTrue(cookie.value is None) self.assertEquals(cookie.name, "eggs") cookie = c._cookies["www.acme.com"]['/foo/']['"spam"'] - self.assert_(cookie.value is None) + self.assertTrue(cookie.value is None) self.assertEquals(cookie.name, '"spam"') self.assertEquals(lwp_cookie_str(cookie), ( r'"spam"; path="/foo/"; domain="www.acme.com"; ' @@ -388,7 +388,7 @@ class CookieTests(TestCase): try: cookie = c._cookies["www.example.com"]["/"]["ni"] except KeyError: - self.assert_(version is None) # didn't expect a stored cookie + self.assertTrue(version is None) # didn't expect a stored cookie else: self.assertEqual(cookie.version, version) # 2965 cookies are unaffected @@ -410,28 +410,28 @@ class CookieTests(TestCase): cookie = c._cookies[".acme.com"]["/"]["spam"] self.assertEquals(cookie.domain, ".acme.com") - self.assert_(cookie.domain_specified) + self.assertTrue(cookie.domain_specified) self.assertEquals(cookie.port, DEFAULT_HTTP_PORT) - self.assert_(not cookie.port_specified) + self.assertTrue(not cookie.port_specified) # case is preserved - self.assert_(cookie.has_nonstandard_attr("blArgh") and + self.assertTrue(cookie.has_nonstandard_attr("blArgh") and not cookie.has_nonstandard_attr("blargh")) cookie = c._cookies["www.acme.com"]["/"]["ni"] self.assertEquals(cookie.domain, "www.acme.com") - self.assert_(not cookie.domain_specified) + self.assertTrue(not cookie.domain_specified) self.assertEquals(cookie.port, "80,8080") - self.assert_(cookie.port_specified) + self.assertTrue(cookie.port_specified) cookie = c._cookies["www.acme.com"]["/"]["nini"] - self.assert_(cookie.port is None) - self.assert_(not cookie.port_specified) + self.assertTrue(cookie.port is None) + self.assertTrue(not cookie.port_specified) # invalid expires should not cause cookie to be dropped foo = c._cookies["www.acme.com"]["/"]["foo"] spam = c._cookies["www.acme.com"]["/"]["foo"] - self.assert_(foo.expires is None) - self.assert_(spam.expires is None) + self.assertTrue(foo.expires is None) + self.assertTrue(spam.expires is None) def test_ns_parser_special_names(self): # names such as 'expires' are not special in first name=value pair @@ -441,8 +441,8 @@ class CookieTests(TestCase): interact_netscape(c, "http://www.acme.com/", 'version=eggs; spam=eggs') cookies = c._cookies["www.acme.com"]["/"] - self.assert_('expires' in cookies) - self.assert_('version' in cookies) + self.assertTrue('expires' in cookies) + self.assertTrue('version' in cookies) def test_expires(self): # if expires is in future, keep cookie... @@ -457,7 +457,7 @@ class CookieTests(TestCase): now) h = interact_netscape(c, "http://www.acme.com/") self.assertEquals(len(c), 1) - self.assert_('spam="bar"' in h and "foo" not in h) + self.assertTrue('spam="bar"' in h and "foo" not in h) # max-age takes precedence over expires, and zero max-age is request to # delete both new cookie and any old matching cookie @@ -478,7 +478,7 @@ class CookieTests(TestCase): self.assertEquals(len(c), 2) c.clear_session_cookies() self.assertEquals(len(c), 1) - self.assert_('spam="bar"' in h) + self.assertTrue('spam="bar"' in h) # XXX RFC 2965 expiry rules (some apply to V0 too) @@ -488,39 +488,39 @@ class CookieTests(TestCase): c = CookieJar(pol) interact_2965(c, "http://www.acme.com/", 'spam="bar"; Version="1"') - self.assert_("/" in c._cookies["www.acme.com"]) + self.assertTrue("/" in c._cookies["www.acme.com"]) c = CookieJar(pol) interact_2965(c, "http://www.acme.com/blah", 'eggs="bar"; Version="1"') - self.assert_("/" in c._cookies["www.acme.com"]) + self.assertTrue("/" in c._cookies["www.acme.com"]) c = CookieJar(pol) interact_2965(c, "http://www.acme.com/blah/rhubarb", 'eggs="bar"; Version="1"') - self.assert_("/blah/" in c._cookies["www.acme.com"]) + self.assertTrue("/blah/" in c._cookies["www.acme.com"]) c = CookieJar(pol) interact_2965(c, "http://www.acme.com/blah/rhubarb/", 'eggs="bar"; Version="1"') - self.assert_("/blah/rhubarb/" in c._cookies["www.acme.com"]) + self.assertTrue("/blah/rhubarb/" in c._cookies["www.acme.com"]) # Netscape c = CookieJar() interact_netscape(c, "http://www.acme.com/", 'spam="bar"') - self.assert_("/" in c._cookies["www.acme.com"]) + self.assertTrue("/" in c._cookies["www.acme.com"]) c = CookieJar() interact_netscape(c, "http://www.acme.com/blah", 'eggs="bar"') - self.assert_("/" in c._cookies["www.acme.com"]) + self.assertTrue("/" in c._cookies["www.acme.com"]) c = CookieJar() interact_netscape(c, "http://www.acme.com/blah/rhubarb", 'eggs="bar"') - self.assert_("/blah" in c._cookies["www.acme.com"]) + self.assertTrue("/blah" in c._cookies["www.acme.com"]) c = CookieJar() interact_netscape(c, "http://www.acme.com/blah/rhubarb/", 'eggs="bar"') - self.assert_("/blah/rhubarb" in c._cookies["www.acme.com"]) + self.assertTrue("/blah/rhubarb" in c._cookies["www.acme.com"]) def test_escape_path(self): cases = [ @@ -589,14 +589,14 @@ class CookieTests(TestCase): self.assertEquals(request_host(req), "www.acme.com") def test_is_HDN(self): - self.assert_(is_HDN("foo.bar.com")) - self.assert_(is_HDN("1foo2.3bar4.5com")) - self.assert_(not is_HDN("192.168.1.1")) - self.assert_(not is_HDN("")) - self.assert_(not is_HDN(".")) - self.assert_(not is_HDN(".foo.bar.com")) - self.assert_(not is_HDN("..foo")) - self.assert_(not is_HDN("foo.")) + self.assertTrue(is_HDN("foo.bar.com")) + self.assertTrue(is_HDN("1foo2.3bar4.5com")) + self.assertTrue(not is_HDN("192.168.1.1")) + self.assertTrue(not is_HDN("")) + self.assertTrue(not is_HDN(".")) + self.assertTrue(not is_HDN(".foo.bar.com")) + self.assertTrue(not is_HDN("..foo")) + self.assertTrue(not is_HDN("foo.")) def test_reach(self): self.assertEquals(reach("www.acme.com"), ".acme.com") @@ -609,40 +609,40 @@ class CookieTests(TestCase): self.assertEquals(reach("192.168.0.1"), "192.168.0.1") def test_domain_match(self): - self.assert_(domain_match("192.168.1.1", "192.168.1.1")) - self.assert_(not domain_match("192.168.1.1", ".168.1.1")) - self.assert_(domain_match("x.y.com", "x.Y.com")) - self.assert_(domain_match("x.y.com", ".Y.com")) - self.assert_(not domain_match("x.y.com", "Y.com")) - self.assert_(domain_match("a.b.c.com", ".c.com")) - self.assert_(not domain_match(".c.com", "a.b.c.com")) - self.assert_(domain_match("example.local", ".local")) - self.assert_(not domain_match("blah.blah", "")) - self.assert_(not domain_match("", ".rhubarb.rhubarb")) - self.assert_(domain_match("", "")) - - self.assert_(user_domain_match("acme.com", "acme.com")) - self.assert_(not user_domain_match("acme.com", ".acme.com")) - self.assert_(user_domain_match("rhubarb.acme.com", ".acme.com")) - self.assert_(user_domain_match("www.rhubarb.acme.com", ".acme.com")) - self.assert_(user_domain_match("x.y.com", "x.Y.com")) - self.assert_(user_domain_match("x.y.com", ".Y.com")) - self.assert_(not user_domain_match("x.y.com", "Y.com")) - self.assert_(user_domain_match("y.com", "Y.com")) - self.assert_(not user_domain_match(".y.com", "Y.com")) - self.assert_(user_domain_match(".y.com", ".Y.com")) - self.assert_(user_domain_match("x.y.com", ".com")) - self.assert_(not user_domain_match("x.y.com", "com")) - self.assert_(not user_domain_match("x.y.com", "m")) - self.assert_(not user_domain_match("x.y.com", ".m")) - self.assert_(not user_domain_match("x.y.com", "")) - self.assert_(not user_domain_match("x.y.com", ".")) - self.assert_(user_domain_match("192.168.1.1", "192.168.1.1")) + self.assertTrue(domain_match("192.168.1.1", "192.168.1.1")) + self.assertTrue(not domain_match("192.168.1.1", ".168.1.1")) + self.assertTrue(domain_match("x.y.com", "x.Y.com")) + self.assertTrue(domain_match("x.y.com", ".Y.com")) + self.assertTrue(not domain_match("x.y.com", "Y.com")) + self.assertTrue(domain_match("a.b.c.com", ".c.com")) + self.assertTrue(not domain_match(".c.com", "a.b.c.com")) + self.assertTrue(domain_match("example.local", ".local")) + self.assertTrue(not domain_match("blah.blah", "")) + self.assertTrue(not domain_match("", ".rhubarb.rhubarb")) + self.assertTrue(domain_match("", "")) + + self.assertTrue(user_domain_match("acme.com", "acme.com")) + self.assertTrue(not user_domain_match("acme.com", ".acme.com")) + self.assertTrue(user_domain_match("rhubarb.acme.com", ".acme.com")) + self.assertTrue(user_domain_match("www.rhubarb.acme.com", ".acme.com")) + self.assertTrue(user_domain_match("x.y.com", "x.Y.com")) + self.assertTrue(user_domain_match("x.y.com", ".Y.com")) + self.assertTrue(not user_domain_match("x.y.com", "Y.com")) + self.assertTrue(user_domain_match("y.com", "Y.com")) + self.assertTrue(not user_domain_match(".y.com", "Y.com")) + self.assertTrue(user_domain_match(".y.com", ".Y.com")) + self.assertTrue(user_domain_match("x.y.com", ".com")) + self.assertTrue(not user_domain_match("x.y.com", "com")) + self.assertTrue(not user_domain_match("x.y.com", "m")) + self.assertTrue(not user_domain_match("x.y.com", ".m")) + self.assertTrue(not user_domain_match("x.y.com", "")) + self.assertTrue(not user_domain_match("x.y.com", ".")) + self.assertTrue(user_domain_match("192.168.1.1", "192.168.1.1")) # not both HDNs, so must string-compare equal to match - self.assert_(not user_domain_match("192.168.1.1", ".168.1.1")) - self.assert_(not user_domain_match("192.168.1.1", ".")) + self.assertTrue(not user_domain_match("192.168.1.1", ".168.1.1")) + self.assertTrue(not user_domain_match("192.168.1.1", ".")) # empty string is a special case - self.assert_(not user_domain_match("192.168.1.1", "")) + self.assertTrue(not user_domain_match("192.168.1.1", "")) def test_wrong_domain(self): # Cookies whose effective request-host name does not domain-match the @@ -789,7 +789,7 @@ class CookieTests(TestCase): self.assertEquals(len(c), 2) # ... and check is doesn't get returned c.add_cookie_header(req) - self.assert_(not req.has_header("Cookie")) + self.assertTrue(not req.has_header("Cookie")) def test_domain_block(self): pol = DefaultCookiePolicy( @@ -813,7 +813,7 @@ class CookieTests(TestCase): self.assertEquals(len(c), 1) req = urllib.request.Request("http://www.roadrunner.net/") c.add_cookie_header(req) - self.assert_((req.has_header("Cookie") and + self.assertTrue((req.has_header("Cookie") and req.has_header("Cookie2"))) c.clear() @@ -829,7 +829,7 @@ class CookieTests(TestCase): self.assertEquals(len(c), 2) # ... and check is doesn't get returned c.add_cookie_header(req) - self.assert_(not req.has_header("Cookie")) + self.assertTrue(not req.has_header("Cookie")) def test_secure(self): for ns in True, False: @@ -847,10 +847,10 @@ class CookieTests(TestCase): url = "http://www.acme.com/" int(c, url, "foo1=bar%s%s" % (vs, whitespace)) int(c, url, "foo2=bar%s; secure%s" % (vs, whitespace)) - self.assert_( + self.assertTrue( not c._cookies["www.acme.com"]["/"]["foo1"].secure, "non-secure cookie registered secure") - self.assert_( + self.assertTrue( c._cookies["www.acme.com"]["/"]["foo2"].secure, "secure cookie registered non-secure") @@ -868,7 +868,7 @@ class CookieTests(TestCase): req = urllib.request.Request(url) self.assertEquals(len(c), 1) c.add_cookie_header(req) - self.assert_(req.has_header("Cookie")) + self.assertTrue(req.has_header("Cookie")) def test_domain_mirror(self): pol = DefaultCookiePolicy(rfc2965=True) @@ -877,21 +877,21 @@ class CookieTests(TestCase): url = "http://foo.bar.com/" interact_2965(c, url, "spam=eggs; Version=1") h = interact_2965(c, url) - self.assert_("Domain" not in h, + self.assertTrue("Domain" not in h, "absent domain returned with domain present") c = CookieJar(pol) url = "http://foo.bar.com/" interact_2965(c, url, 'spam=eggs; Version=1; Domain=.bar.com') h = interact_2965(c, url) - self.assert_('$Domain=".bar.com"' in h, "domain not returned") + self.assertTrue('$Domain=".bar.com"' in h, "domain not returned") c = CookieJar(pol) url = "http://foo.bar.com/" # note missing initial dot in Domain interact_2965(c, url, 'spam=eggs; Version=1; Domain=bar.com') h = interact_2965(c, url) - self.assert_('$Domain="bar.com"' in h, "domain not returned") + self.assertTrue('$Domain="bar.com"' in h, "domain not returned") def test_path_mirror(self): pol = DefaultCookiePolicy(rfc2965=True) @@ -900,14 +900,14 @@ class CookieTests(TestCase): url = "http://foo.bar.com/" interact_2965(c, url, "spam=eggs; Version=1") h = interact_2965(c, url) - self.assert_("Path" not in h, + self.assertTrue("Path" not in h, "absent path returned with path present") c = CookieJar(pol) url = "http://foo.bar.com/" interact_2965(c, url, 'spam=eggs; Version=1; Path=/') h = interact_2965(c, url) - self.assert_('$Path="/"' in h, "path not returned") + self.assertTrue('$Path="/"' in h, "path not returned") def test_port_mirror(self): pol = DefaultCookiePolicy(rfc2965=True) @@ -916,28 +916,28 @@ class CookieTests(TestCase): url = "http://foo.bar.com/" interact_2965(c, url, "spam=eggs; Version=1") h = interact_2965(c, url) - self.assert_("Port" not in h, + self.assertTrue("Port" not in h, "absent port returned with port present") c = CookieJar(pol) url = "http://foo.bar.com/" interact_2965(c, url, "spam=eggs; Version=1; Port") h = interact_2965(c, url) - self.assert_(re.search("\$Port([^=]|$)", h), + self.assertTrue(re.search("\$Port([^=]|$)", h), "port with no value not returned with no value") c = CookieJar(pol) url = "http://foo.bar.com/" interact_2965(c, url, 'spam=eggs; Version=1; Port="80"') h = interact_2965(c, url) - self.assert_('$Port="80"' in h, + self.assertTrue('$Port="80"' in h, "port with single value not returned with single value") c = CookieJar(pol) url = "http://foo.bar.com/" interact_2965(c, url, 'spam=eggs; Version=1; Port="80,8080"') h = interact_2965(c, url) - self.assert_('$Port="80,8080"' in h, + self.assertTrue('$Port="80,8080"' in h, "port with multiple values not returned with multiple " "values") @@ -948,7 +948,7 @@ class CookieTests(TestCase): 'Comment="does anybody read these?"; ' 'CommentURL="http://foo.bar.net/comment.html"') h = interact_2965(c, url) - self.assert_( + self.assertTrue( "Comment" not in h, "Comment or CommentURL cookie-attributes returned to server") @@ -977,7 +977,7 @@ class CookieTests(TestCase): for i in range(4): i = 0 for c in cs: - self.assert_(isinstance(c, Cookie)) + self.assertTrue(isinstance(c, Cookie)) self.assertEquals(c.version, versions[i]) self.assertEquals(c.name, names[i]) self.assertEquals(c.domain, domains[i]) @@ -1030,7 +1030,7 @@ class CookieTests(TestCase): headers = ["Set-Cookie: c=foo; expires=Foo Bar 12 33:22:11 2000"] c = cookiejar_from_cookie_headers(headers) cookie = c._cookies["www.example.com"]["/"]["c"] - self.assert_(cookie.expires is None) + self.assertTrue(cookie.expires is None) class LWPCookieTests(TestCase): @@ -1104,7 +1104,7 @@ class LWPCookieTests(TestCase): c.add_cookie_header(req) h = req.get_header("Cookie") - self.assert_("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and + self.assertTrue("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and "CUSTOMER=WILE_E_COYOTE" in h) headers.append('Set-Cookie: SHIPPING=FEDEX; path=/foo') @@ -1115,7 +1115,7 @@ class LWPCookieTests(TestCase): c.add_cookie_header(req) h = req.get_header("Cookie") - self.assert_("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and + self.assertTrue("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and "CUSTOMER=WILE_E_COYOTE" in h and "SHIPPING=FEDEX" not in h) @@ -1123,7 +1123,7 @@ class LWPCookieTests(TestCase): c.add_cookie_header(req) h = req.get_header("Cookie") - self.assert_(("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and + self.assertTrue(("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and "CUSTOMER=WILE_E_COYOTE" in h and h.startswith("SHIPPING=FEDEX;"))) @@ -1174,7 +1174,7 @@ class LWPCookieTests(TestCase): req = urllib.request.Request("http://www.acme.com/ammo") c.add_cookie_header(req) - self.assert_(re.search(r"PART_NUMBER=RIDING_ROCKET_0023;\s*" + self.assertTrue(re.search(r"PART_NUMBER=RIDING_ROCKET_0023;\s*" "PART_NUMBER=ROCKET_LAUNCHER_0001", req.get_header("Cookie"))) @@ -1209,7 +1209,7 @@ class LWPCookieTests(TestCase): cookie = interact_2965( c, 'http://www.acme.com/acme/login', 'Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"') - self.assert_(not cookie) + self.assertTrue(not cookie) # # 3. User Agent -> Server @@ -1231,7 +1231,7 @@ class LWPCookieTests(TestCase): cookie = interact_2965(c, 'http://www.acme.com/acme/pickitem', 'Part_Number="Rocket_Launcher_0001"; ' 'Version="1"; Path="/acme"'); - self.assert_(re.search( + self.assertTrue(re.search( r'^\$Version="?1"?; Customer="?WILE_E_COYOTE"?; \$Path="/acme"$', cookie)) @@ -1256,10 +1256,10 @@ class LWPCookieTests(TestCase): cookie = interact_2965(c, "http://www.acme.com/acme/shipping", 'Shipping="FedEx"; Version="1"; Path="/acme"') - self.assert_(re.search(r'^\$Version="?1"?;', cookie)) - self.assert_(re.search(r'Part_Number="?Rocket_Launcher_0001"?;' + self.assertTrue(re.search(r'^\$Version="?1"?;', cookie)) + self.assertTrue(re.search(r'Part_Number="?Rocket_Launcher_0001"?;' '\s*\$Path="\/acme"', cookie)) - self.assert_(re.search(r'Customer="?WILE_E_COYOTE"?;\s*\$Path="\/acme"', + self.assertTrue(re.search(r'Customer="?WILE_E_COYOTE"?;\s*\$Path="\/acme"', cookie)) # @@ -1281,7 +1281,7 @@ class LWPCookieTests(TestCase): # Transaction is complete. cookie = interact_2965(c, "http://www.acme.com/acme/process") - self.assert_( + self.assertTrue( re.search(r'Shipping="?FedEx"?;\s*\$Path="\/acme"', cookie) and "WILE_E_COYOTE" in cookie) @@ -1330,7 +1330,7 @@ class LWPCookieTests(TestCase): # than once. cookie = interact_2965(c, "http://www.acme.com/acme/ammo/...") - self.assert_( + self.assertTrue( re.search(r"Riding_Rocket_0023.*Rocket_Launcher_0001", cookie)) # A subsequent request by the user agent to the (same) server for a URL of @@ -1343,7 +1343,7 @@ class LWPCookieTests(TestCase): # the server. cookie = interact_2965(c, "http://www.acme.com/acme/parts/") - self.assert_("Rocket_Launcher_0001" in cookie and + self.assertTrue("Rocket_Launcher_0001" in cookie and "Riding_Rocket_0023" not in cookie) def test_rejection(self): @@ -1357,7 +1357,7 @@ class LWPCookieTests(TestCase): # illegal domain (no embedded dots) cookie = interact_2965(c, "http://www.acme.com", 'foo=bar; domain=".com"; version=1') - self.assert_(not c) + self.assertTrue(not c) # legal domain cookie = interact_2965(c, "http://www.acme.com", @@ -1449,11 +1449,11 @@ class LWPCookieTests(TestCase): c, "http://www.acme.com/foo%2f%25/<<%0anew\345/\346\370\345", 'bar=baz; path="/foo/"; version=1'); version_re = re.compile(r'^\$version=\"?1\"?', re.I) - self.assert_("foo=bar" in cookie and version_re.search(cookie)) + self.assertTrue("foo=bar" in cookie and version_re.search(cookie)) cookie = interact_2965( c, "http://www.acme.com/foo/%25/<<%0anew\345/\346\370\345") - self.assert_(not cookie) + self.assertTrue(not cookie) # unicode URL doesn't raise exception cookie = interact_2965(c, "http://www.acme.com/\xfc") @@ -1493,11 +1493,11 @@ class LWPCookieTests(TestCase): new_c = save_and_restore(c, True) self.assertEquals(len(new_c), 6) # none discarded - self.assert_("name='foo1', value='bar'" in repr(new_c)) + self.assertTrue("name='foo1', value='bar'" in repr(new_c)) new_c = save_and_restore(c, False) self.assertEquals(len(new_c), 4) # 2 of them discarded on save - self.assert_("name='foo1', value='bar'" in repr(new_c)) + self.assertTrue("name='foo1', value='bar'" in repr(new_c)) def test_netscape_misc(self): # Some additional Netscape cookies tests. @@ -1519,7 +1519,7 @@ class LWPCookieTests(TestCase): req = urllib.request.Request("http://foo.bar.acme.com/foo") c.add_cookie_header(req) - self.assert_( + self.assertTrue( "PART_NUMBER=3,4" in req.get_header("Cookie") and "Customer=WILE_E_COYOTE" in req.get_header("Cookie")) @@ -1530,11 +1530,11 @@ class LWPCookieTests(TestCase): "foo1=bar; PORT; Discard; Version=1;") cookie = interact_2965(c, "http://example/", 'foo2=bar; domain=".local"; Version=1') - self.assert_("foo1=bar" in cookie) + self.assertTrue("foo1=bar" in cookie) interact_2965(c, "http://example/", 'foo3=bar; Version=1') cookie = interact_2965(c, "http://example/") - self.assert_("foo2=bar" in cookie and len(c) == 3) + self.assertTrue("foo2=bar" in cookie and len(c) == 3) def test_intranet_domains_ns(self): c = CookieJar(DefaultCookiePolicy(rfc2965 = False)) @@ -1542,10 +1542,10 @@ class LWPCookieTests(TestCase): cookie = interact_netscape(c, "http://example/", 'foo2=bar; domain=.local') self.assertEquals(len(c), 2) - self.assert_("foo1=bar" in cookie) + self.assertTrue("foo1=bar" in cookie) cookie = interact_netscape(c, "http://example/") - self.assert_("foo2=bar" in cookie) + self.assertTrue("foo2=bar" in cookie) self.assertEquals(len(c), 2) def test_empty_path(self): @@ -1614,7 +1614,7 @@ class LWPCookieTests(TestCase): key = "%s_after" % cookie.value counter[key] = counter[key] + 1 - self.assert_(not ( + self.assertTrue(not ( # a permanent cookie got lost accidently counter["perm_after"] != counter["perm_before"] or # a session cookie hasn't been cleared diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py index d43c82d..2d76f7a 100644 --- a/Lib/test/test_httplib.py +++ b/Lib/test/test_httplib.py @@ -265,7 +265,7 @@ class TimeoutTest(TestCase): # and into the socket. # default -- use global socket timeout - self.assert_(socket.getdefaulttimeout() is None) + self.assertTrue(socket.getdefaulttimeout() is None) socket.setdefaulttimeout(30) try: httpConn = client.HTTPConnection(HOST, TimeoutTest.PORT) @@ -276,7 +276,7 @@ class TimeoutTest(TestCase): httpConn.close() # no timeout -- do not use global socket default - self.assert_(socket.getdefaulttimeout() is None) + self.assertTrue(socket.getdefaulttimeout() is None) socket.setdefaulttimeout(30) try: httpConn = client.HTTPConnection(HOST, TimeoutTest.PORT, diff --git a/Lib/test/test_httpservers.py b/Lib/test/test_httpservers.py index 837d4a6..13e4030 100644 --- a/Lib/test/test_httpservers.py +++ b/Lib/test/test_httpservers.py @@ -217,9 +217,9 @@ class SimpleHTTPServerTestCase(BaseTestCase): def check_status_and_reason(self, response, status, data=None): body = response.read() - self.assert_(response) + self.assertTrue(response) self.assertEquals(response.status, status) - self.assert_(response.reason != None) + self.assertTrue(response.reason != None) if data: self.assertEqual(data, body) diff --git a/Lib/test/test_imp.py b/Lib/test/test_imp.py index cc6792a..70169e0 100644 --- a/Lib/test/test_imp.py +++ b/Lib/test/test_imp.py @@ -12,7 +12,7 @@ class LockTests(unittest.TestCase): """Very basic test of import lock functions.""" def verify_lock_state(self, expected): - self.failUnlessEqual(imp.lock_held(), expected, + self.assertEqual(imp.lock_held(), expected, "expected imp.lock_held() to be %r" % expected) def testLock(self): LOOPS = 50 diff --git a/Lib/test/test_import.py b/Lib/test/test_import.py index 8196865..44e67c3 100644 --- a/Lib/test/test_import.py +++ b/Lib/test/test_import.py @@ -172,12 +172,12 @@ class ImportTest(unittest.TestCase): # import x.y.z binds x in the current namespace import test as x import test.support - self.assert_(x is test, x.__name__) - self.assert_(hasattr(test.support, "__file__")) + self.assertTrue(x is test, x.__name__) + self.assertTrue(hasattr(test.support, "__file__")) # import x.y.z as w binds z as w import test.support as y - self.assert_(y is test.support, y.__name__) + self.assertTrue(y is test.support, y.__name__) def test_import_initless_directory_warning(self): with warnings.catch_warnings(): @@ -195,7 +195,7 @@ class ImportTest(unittest.TestCase): sys.path.insert(0, os.curdir) try: mod = __import__(TESTFN) - self.assert_(TESTFN in sys.modules, "expected module in sys.modules") + self.assertTrue(TESTFN in sys.modules, "expected module in sys.modules") self.assertEquals(mod.a, 1, "module has wrong attribute values") self.assertEquals(mod.b, 2, "module has wrong attribute values") @@ -212,7 +212,7 @@ class ImportTest(unittest.TestCase): self.assertRaises(ZeroDivisionError, imp.reload, mod) # But we still expect the module to be in sys.modules. mod = sys.modules.get(TESTFN) - self.failIf(mod is None, "expected module to still be in sys.modules") + self.assertFalse(mod is None, "expected module to still be in sys.modules") # We should have replaced a w/ 10, but the old b value should # stick. @@ -234,12 +234,12 @@ class ImportTest(unittest.TestCase): sys.path.insert(0, os.curdir) try: mod = __import__(TESTFN) - self.failUnless(mod.__file__.endswith('.py')) + self.assertTrue(mod.__file__.endswith('.py')) os.remove(source) del sys.modules[TESTFN] mod = __import__(TESTFN) ext = mod.__file__[-4:] - self.failUnless(ext in ('.pyc', '.pyo'), ext) + self.assertTrue(ext in ('.pyc', '.pyo'), ext) finally: sys.path.pop(0) remove_files(TESTFN) diff --git a/Lib/test/test_importhooks.py b/Lib/test/test_importhooks.py index f267f79..bf2870d 100644 --- a/Lib/test/test_importhooks.py +++ b/Lib/test/test_importhooks.py @@ -177,7 +177,7 @@ class ImportHooksTestCase(ImportHooksBaseTestCase): TestImporter.modules['reloadmodule'] = (False, test_co) import reloadmodule - self.failIf(hasattr(reloadmodule,'reloaded')) + self.assertFalse(hasattr(reloadmodule,'reloaded')) import hooktestpackage.newrel self.assertEqual(hooktestpackage.newrel.get_name(), diff --git a/Lib/test/test_index.py b/Lib/test/test_index.py index 31609c3..ae905c2 100644 --- a/Lib/test/test_index.py +++ b/Lib/test/test_index.py @@ -59,10 +59,10 @@ class BaseTestCase(unittest.TestCase): def test_error(self): self.o.ind = 'dumb' self.n.ind = 'bad' - self.failUnlessRaises(TypeError, operator.index, self.o) - self.failUnlessRaises(TypeError, operator.index, self.n) - self.failUnlessRaises(TypeError, slice(self.o).indices, 0) - self.failUnlessRaises(TypeError, slice(self.n).indices, 0) + self.assertRaises(TypeError, operator.index, self.o) + self.assertRaises(TypeError, operator.index, self.n) + self.assertRaises(TypeError, slice(self.o).indices, 0) + self.assertRaises(TypeError, slice(self.n).indices, 0) class SeqTestCase(unittest.TestCase): @@ -114,11 +114,11 @@ class SeqTestCase(unittest.TestCase): self.o.ind = 'dumb' self.n.ind = 'bad' indexobj = lambda x, obj: obj.seq[x] - self.failUnlessRaises(TypeError, indexobj, self.o, self) - self.failUnlessRaises(TypeError, indexobj, self.n, self) + self.assertRaises(TypeError, indexobj, self.o, self) + self.assertRaises(TypeError, indexobj, self.n, self) sliceobj = lambda x, obj: obj.seq[x:] - self.failUnlessRaises(TypeError, sliceobj, self.o, self) - self.failUnlessRaises(TypeError, sliceobj, self.n, self) + self.assertRaises(TypeError, sliceobj, self.o, self) + self.assertRaises(TypeError, sliceobj, self.n, self) class ListTestCase(SeqTestCase): @@ -151,7 +151,7 @@ class ListTestCase(SeqTestCase): lst = [5, 6, 7, 8, 9, 11] l2 = lst.__imul__(self.n) - self.assert_(l2 is lst) + self.assertTrue(l2 is lst) self.assertEqual(lst, [5, 6, 7, 8, 9, 11] * 3) @@ -188,8 +188,8 @@ class OverflowTestCase(unittest.TestCase): (0, maxsize, 1)) def test_sequence_repeat(self): - self.failUnlessRaises(OverflowError, lambda: "a" * self.pos) - self.failUnlessRaises(OverflowError, lambda: "a" * self.neg) + self.assertRaises(OverflowError, lambda: "a" * self.pos) + self.assertRaises(OverflowError, lambda: "a" * self.neg) def test_main(): diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py index 37be205..c1df23e 100644 --- a/Lib/test/test_inspect.py +++ b/Lib/test/test_inspect.py @@ -52,13 +52,13 @@ class IsTestBase(unittest.TestCase): def istest(self, predicate, exp): obj = eval(exp) - self.failUnless(predicate(obj), '%s(%s)' % (predicate.__name__, exp)) + self.assertTrue(predicate(obj), '%s(%s)' % (predicate.__name__, exp)) for other in self.predicates - set([predicate]): if predicate == inspect.isgeneratorfunction and\ other == inspect.isfunction: continue - self.failIf(other(obj), 'not %s(%s)' % (other.__name__, exp)) + self.assertFalse(other(obj), 'not %s(%s)' % (other.__name__, exp)) def generator_function_example(self): for i in range(2): @@ -91,15 +91,15 @@ class TestPredicates(IsTestBase): self.istest(inspect.isgetsetdescriptor, 'type(tb.tb_frame).f_locals') else: - self.failIf(inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals)) + self.assertFalse(inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals)) if hasattr(types, 'MemberDescriptorType'): self.istest(inspect.ismemberdescriptor, 'datetime.timedelta.days') else: - self.failIf(inspect.ismemberdescriptor(datetime.timedelta.days)) + self.assertFalse(inspect.ismemberdescriptor(datetime.timedelta.days)) def test_isroutine(self): - self.assert_(inspect.isroutine(mod.spam)) - self.assert_(inspect.isroutine([].count)) + self.assertTrue(inspect.isroutine(mod.spam)) + self.assertTrue(inspect.isroutine([].count)) def test_isclass(self): self.istest(inspect.isclass, 'mod.StupidGit') @@ -117,8 +117,8 @@ class TestPredicates(IsTestBase): x = C() x.a = 42 members = dict(inspect.getmembers(x)) - self.assert_('a' in members) - self.assert_('b' not in members) + self.assertTrue('a' in members) + self.assertTrue('b' not in members) class TestInterpreterStack(IsTestBase): @@ -132,7 +132,7 @@ class TestInterpreterStack(IsTestBase): self.istest(inspect.isframe, 'mod.fr') def test_stack(self): - self.assert_(len(mod.st) >= 5) + self.assertTrue(len(mod.st) >= 5) self.assertEqual(revise(*mod.st[0][1:]), (modfile, 16, 'eggs', [' st = inspect.stack()\n'], 0)) self.assertEqual(revise(*mod.st[1][1:]), @@ -449,25 +449,25 @@ class TestClassesAndFunctions(unittest.TestCase): datablob = '1' attrs = attrs_wo_objs(A) - self.assert_(('s', 'static method', A) in attrs, 'missing static method') - self.assert_(('c', 'class method', A) in attrs, 'missing class method') - self.assert_(('p', 'property', A) in attrs, 'missing property') - self.assert_(('m', 'method', A) in attrs, + self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') + self.assertTrue(('c', 'class method', A) in attrs, 'missing class method') + self.assertTrue(('p', 'property', A) in attrs, 'missing property') + self.assertTrue(('m', 'method', A) in attrs, 'missing plain method: %r' % attrs) - self.assert_(('m1', 'method', A) in attrs, 'missing plain method') - self.assert_(('datablob', 'data', A) in attrs, 'missing data') + self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method') + self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') class B(A): def m(self): pass attrs = attrs_wo_objs(B) - self.assert_(('s', 'static method', A) in attrs, 'missing static method') - self.assert_(('c', 'class method', A) in attrs, 'missing class method') - self.assert_(('p', 'property', A) in attrs, 'missing property') - self.assert_(('m', 'method', B) in attrs, 'missing plain method') - self.assert_(('m1', 'method', A) in attrs, 'missing plain method') - self.assert_(('datablob', 'data', A) in attrs, 'missing data') + self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') + self.assertTrue(('c', 'class method', A) in attrs, 'missing class method') + self.assertTrue(('p', 'property', A) in attrs, 'missing property') + self.assertTrue(('m', 'method', B) in attrs, 'missing plain method') + self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method') + self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') class C(A): @@ -476,24 +476,24 @@ class TestClassesAndFunctions(unittest.TestCase): def c(self): pass attrs = attrs_wo_objs(C) - self.assert_(('s', 'static method', A) in attrs, 'missing static method') - self.assert_(('c', 'method', C) in attrs, 'missing plain method') - self.assert_(('p', 'property', A) in attrs, 'missing property') - self.assert_(('m', 'method', C) in attrs, 'missing plain method') - self.assert_(('m1', 'method', A) in attrs, 'missing plain method') - self.assert_(('datablob', 'data', A) in attrs, 'missing data') + self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') + self.assertTrue(('c', 'method', C) in attrs, 'missing plain method') + self.assertTrue(('p', 'property', A) in attrs, 'missing property') + self.assertTrue(('m', 'method', C) in attrs, 'missing plain method') + self.assertTrue(('m1', 'method', A) in attrs, 'missing plain method') + self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') class D(B, C): def m1(self): pass attrs = attrs_wo_objs(D) - self.assert_(('s', 'static method', A) in attrs, 'missing static method') - self.assert_(('c', 'method', C) in attrs, 'missing plain method') - self.assert_(('p', 'property', A) in attrs, 'missing property') - self.assert_(('m', 'method', B) in attrs, 'missing plain method') - self.assert_(('m1', 'method', D) in attrs, 'missing plain method') - self.assert_(('datablob', 'data', A) in attrs, 'missing data') + self.assertTrue(('s', 'static method', A) in attrs, 'missing static method') + self.assertTrue(('c', 'method', C) in attrs, 'missing plain method') + self.assertTrue(('p', 'property', A) in attrs, 'missing property') + self.assertTrue(('m', 'method', B) in attrs, 'missing plain method') + self.assertTrue(('m1', 'method', D) in attrs, 'missing plain method') + self.assertTrue(('datablob', 'data', A) in attrs, 'missing data') def test_main(): run_unittest(TestDecorators, TestRetrievingSourceCode, TestOneliners, diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py index dd40ef6..d56e1f0 100644 --- a/Lib/test/test_int.py +++ b/Lib/test/test_int.py @@ -52,15 +52,15 @@ class IntTestCases(unittest.TestCase): s = repr(-1-sys.maxsize) x = int(s) self.assertEqual(x+1, -sys.maxsize) - self.assert_(isinstance(x, int)) + self.assertTrue(isinstance(x, int)) # should return long self.assertEqual(int(s[1:]), sys.maxsize+1) # should return long x = int(1e100) - self.assert_(isinstance(x, int)) + self.assertTrue(isinstance(x, int)) x = int(-1e100) - self.assert_(isinstance(x, int)) + self.assertTrue(isinstance(x, int)) # SF bug 434186: 0x80000000/2 != 0x80000000>>1. @@ -78,7 +78,7 @@ class IntTestCases(unittest.TestCase): self.assertRaises(ValueError, int, '123\x00 245', 20) x = int('1' * 600) - self.assert_(isinstance(x, int)) + self.assertTrue(isinstance(x, int)) self.assertRaises(TypeError, int, 1, 12) @@ -96,8 +96,8 @@ class IntTestCases(unittest.TestCase): self.assertRaises(ValueError, int, "0b", 0) # Bug #3236: Return small longs from PyLong_FromString - self.assert_(int("10") is 10) - self.assert_(int("-1") is -1) + self.assertTrue(int("10") is 10) + self.assertTrue(int("-1") is -1) # SF bug 1334662: int(string, base) wrong answers # Various representations of 2**32 evaluated to 0 diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py index 407a8a4..a9094d9 100644 --- a/Lib/test/test_io.py +++ b/Lib/test/test_io.py @@ -391,7 +391,7 @@ class IOTest(unittest.TestCase): with self.open(support.TESTFN, "ab") as f: self.assertEqual(f.tell(), 3) with self.open(support.TESTFN, "a") as f: - self.assert_(f.tell() > 0) + self.assertTrue(f.tell() > 0) def test_destructor(self): record = [] @@ -509,7 +509,7 @@ class IOTest(unittest.TestCase): wr = weakref.ref(f) del f support.gc_collect() - self.assert_(wr() is None, wr) + self.assertTrue(wr() is None, wr) with self.open(support.TESTFN, "rb") as f: self.assertEqual(f.read(), b"abcxxx") @@ -615,8 +615,8 @@ class CommonBufferedTests: if s: # The destructor *may* have printed an unraisable error, check it self.assertEqual(len(s.splitlines()), 1) - self.assert_(s.startswith("Exception IOError: "), s) - self.assert_(s.endswith(" ignored"), s) + self.assertTrue(s.startswith("Exception IOError: "), s) + self.assertTrue(s.endswith(" ignored"), s) def test_repr(self): raw = self.MockRawIO() @@ -713,7 +713,7 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): self.assertEquals(b"e", bufio.read(1)) self.assertEquals(b"fg", bufio.read()) self.assertEquals(b"", bufio.peek(1)) - self.assert_(None is bufio.read()) + self.assertTrue(None is bufio.read()) self.assertEquals(b"", bufio.read()) def test_read_past_eof(self): @@ -815,7 +815,7 @@ class CBufferedReaderTest(BufferedReaderTest): wr = weakref.ref(f) del f support.gc_collect() - self.assert_(wr() is None, wr) + self.assertTrue(wr() is None, wr) class PyBufferedReaderTest(BufferedReaderTest): tp = pyio.BufferedReader @@ -864,7 +864,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): flushed = b"".join(writer._write_stack) # At least (total - 8) bytes were implicitly flushed, perhaps more # depending on the implementation. - self.assert_(flushed.startswith(contents[:-8]), flushed) + self.assertTrue(flushed.startswith(contents[:-8]), flushed) def check_writes(self, intermediate_func): # Lots of writes, test the flushed output is as expected. @@ -1075,7 +1075,7 @@ class CBufferedWriterTest(BufferedWriterTest): wr = weakref.ref(f) del f support.gc_collect() - self.assert_(wr() is None, wr) + self.assertTrue(wr() is None, wr) with self.open(support.TESTFN, "rb") as f: self.assertEqual(f.read(), b"123xxx") @@ -1585,7 +1585,7 @@ class TextIOWrapperTest(unittest.TestCase): t = self.TextIOWrapper(b, encoding="utf8") self.assertEqual(t.encoding, "utf8") t = self.TextIOWrapper(b) - self.assert_(t.encoding is not None) + self.assertTrue(t.encoding is not None) codecs.lookup(t.encoding) def test_encoding_errors_reading(self): @@ -1755,8 +1755,8 @@ class TextIOWrapperTest(unittest.TestCase): if s: # The destructor *may* have printed an unraisable error, check it self.assertEqual(len(s.splitlines()), 1) - self.assert_(s.startswith("Exception IOError: "), s) - self.assert_(s.endswith(" ignored"), s) + self.assertTrue(s.startswith("Exception IOError: "), s) + self.assertTrue(s.endswith(" ignored"), s) # Systematic tests of the text I/O API @@ -2074,7 +2074,7 @@ class CTextIOWrapperTest(TextIOWrapperTest): wr = weakref.ref(t) del t support.gc_collect() - self.assert_(wr() is None, wr) + self.assertTrue(wr() is None, wr) with self.open(support.TESTFN, "rb") as f: self.assertEqual(f.read(), b"456def") @@ -2298,7 +2298,7 @@ class MiscIOTest(unittest.TestCase): wr = weakref.ref(c) del c, b support.gc_collect() - self.assert_(wr() is None, wr) + self.assertTrue(wr() is None, wr) def test_abcs(self): # Test the visible base classes are ABCs. diff --git a/Lib/test/test_ioctl.py b/Lib/test/test_ioctl.py index dcb6695..50597ca 100644 --- a/Lib/test/test_ioctl.py +++ b/Lib/test/test_ioctl.py @@ -24,7 +24,7 @@ class IoctlTests(unittest.TestCase): tty = open("/dev/tty", "r") r = fcntl.ioctl(tty, termios.TIOCGPGRP, " ") rpgrp = struct.unpack("i", r)[0] - self.assert_(rpgrp in ids, "%s not in %s" % (rpgrp, ids)) + self.assertTrue(rpgrp in ids, "%s not in %s" % (rpgrp, ids)) def test_ioctl_mutate(self): import array @@ -34,7 +34,7 @@ class IoctlTests(unittest.TestCase): r = fcntl.ioctl(tty, termios.TIOCGPGRP, buf, 1) rpgrp = buf[0] self.assertEquals(r, 0) - self.assert_(rpgrp in ids, "%s not in %s" % (rpgrp, ids)) + self.assertTrue(rpgrp in ids, "%s not in %s" % (rpgrp, ids)) def test_ioctl_signed_unsigned_code_param(self): if not pty: diff --git a/Lib/test/test_iter.py b/Lib/test/test_iter.py index 7788502..a826598 100644 --- a/Lib/test/test_iter.py +++ b/Lib/test/test_iter.py @@ -75,7 +75,7 @@ class TestCase(unittest.TestCase): seq = list(range(10)) it = iter(seq) it2 = iter(it) - self.assert_(it is it2) + self.assertTrue(it is it2) # Test that for loops over iterators work def test_iter_for_loop(self): @@ -542,23 +542,23 @@ class TestCase(unittest.TestCase): def test_in_and_not_in(self): for sc5 in IteratingSequenceClass(5), SequenceClass(5): for i in range(5): - self.assert_(i in sc5) + self.assertTrue(i in sc5) for i in "abc", -1, 5, 42.42, (3, 4), [], {1: 1}, 3-12j, sc5: - self.assert_(i not in sc5) + self.assertTrue(i not in sc5) self.assertRaises(TypeError, lambda: 3 in 12) self.assertRaises(TypeError, lambda: 3 not in map) d = {"one": 1, "two": 2, "three": 3, 1j: 2j} for k in d: - self.assert_(k in d) - self.assert_(k not in d.values()) + self.assertTrue(k in d) + self.assertTrue(k not in d.values()) for v in d.values(): - self.assert_(v in d.values()) - self.assert_(v not in d) + self.assertTrue(v in d.values()) + self.assertTrue(v not in d) for k, v in d.items(): - self.assert_((k, v) in d.items()) - self.assert_((v, k) not in d.items()) + self.assertTrue((k, v) in d.items()) + self.assertTrue((v, k) not in d.items()) f = open(TESTFN, "w") try: @@ -569,9 +569,9 @@ class TestCase(unittest.TestCase): try: for chunk in "abc": f.seek(0, 0) - self.assert_(chunk not in f) + self.assertTrue(chunk not in f) f.seek(0, 0) - self.assert_((chunk + "\n") in f) + self.assertTrue((chunk + "\n") in f) finally: f.close() try: diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index af2efa0..d917262 100644 --- a/Lib/test/test_itertools.py +++ b/Lib/test/test_itertools.py @@ -131,7 +131,7 @@ class TestBasicOps(unittest.TestCase): self.assertEqual(len(c), r) # r-length combinations self.assertEqual(len(set(c)), r) # no duplicate elements self.assertEqual(list(c), sorted(c)) # keep original ordering - self.assert_(all(e in values for e in c)) # elements taken from input iterable + self.assertTrue(all(e in values for e in c)) # elements taken from input iterable self.assertEqual(list(c), [e for e in values if e in c]) # comb is a subsequence of the input iterable self.assertEqual(result, list(combinations1(values, r))) # matches first pure python version @@ -195,14 +195,14 @@ class TestBasicOps(unittest.TestCase): if n == 0 or r <= 1: self.assertEquals(result, regular_combs) # cases that should be identical else: - self.assert_(set(result) >= set(regular_combs)) # rest should be supersets of regular combs + self.assertTrue(set(result) >= set(regular_combs)) # rest should be supersets of regular combs for c in result: self.assertEqual(len(c), r) # r-length combinations noruns = [k for k,v in groupby(c)] # combo without consecutive repeats self.assertEqual(len(noruns), len(set(noruns))) # no repeats other than consecutive self.assertEqual(list(c), sorted(c)) # keep original ordering - self.assert_(all(e in values for e in c)) # elements taken from input iterable + self.assertTrue(all(e in values for e in c)) # elements taken from input iterable self.assertEqual(noruns, [e for e in values if e in c]) # comb is a subsequence of the input iterable self.assertEqual(result, list(cwr1(values, r))) # matches first pure python version @@ -265,7 +265,7 @@ class TestBasicOps(unittest.TestCase): for p in result: self.assertEqual(len(p), r) # r-length permutations self.assertEqual(len(set(p)), r) # no duplicate elements - self.assert_(all(e in values for e in p)) # elements taken from input iterable + self.assertTrue(all(e in values for e in p)) # elements taken from input iterable self.assertEqual(result, list(permutations1(values, r))) # matches first pure python version self.assertEqual(result, list(permutations2(values, r))) # matches second pure python version if r == n: @@ -836,7 +836,7 @@ class TestBasicOps(unittest.TestCase): # tee pass-through to copyable iterator a, b = tee('abc') c, d = tee(a) - self.assert_(a is c) + self.assertTrue(a is c) # test tee_new t1, t2 = tee('abc') @@ -844,7 +844,7 @@ class TestBasicOps(unittest.TestCase): self.assertRaises(TypeError, tnew) self.assertRaises(TypeError, tnew, 10) t3 = tnew(t1) - self.assert_(list(t1) == list(t2) == list(t3) == list('abc')) + self.assertTrue(list(t1) == list(t2) == list(t3) == list('abc')) # test that tee objects are weak referencable a, b = tee(range(10)) @@ -1356,7 +1356,7 @@ class SubclassWithKwargsTest(unittest.TestCase): Subclass(newarg=1) except TypeError as err: # we expect type errors because of wrong argument count - self.failIf("does not take keyword arguments" in err.args[0]) + self.assertFalse("does not take keyword arguments" in err.args[0]) libreftest = """ Doctest for examples in the library reference: libitertools.tex diff --git a/Lib/test/test_kqueue.py b/Lib/test/test_kqueue.py index 42ef958..dd1ecc8 100644 --- a/Lib/test/test_kqueue.py +++ b/Lib/test/test_kqueue.py @@ -15,10 +15,10 @@ if not hasattr(select, "kqueue"): class TestKQueue(unittest.TestCase): def test_create_queue(self): kq = select.kqueue() - self.assert_(kq.fileno() > 0, kq.fileno()) - self.assert_(not kq.closed) + self.assertTrue(kq.fileno() > 0, kq.fileno()) + self.assertTrue(not kq.closed) kq.close() - self.assert_(kq.closed) + self.assertTrue(kq.closed) self.assertRaises(ValueError, kq.fileno) def test_create_event(self): @@ -34,8 +34,8 @@ class TestKQueue(unittest.TestCase): self.assertEqual(ev.udata, 0) self.assertEqual(ev, ev) self.assertNotEqual(ev, other) - self.assert_(ev < other) - self.assert_(other >= ev) + self.assertTrue(ev < other) + self.assertTrue(other >= ev) for op in lt, le, gt, ge: self.assertRaises(TypeError, op, ev, None) self.assertRaises(TypeError, op, ev, 1) diff --git a/Lib/test/test_largefile.py b/Lib/test/test_largefile.py index 1e868e0..7fd3e0e 100644 --- a/Lib/test/test_largefile.py +++ b/Lib/test/test_largefile.py @@ -139,7 +139,7 @@ class LargeFileTest(unittest.TestCase): for pos in (2**31-1, 2**31, 2**31+1): with self.open(TESTFN, 'rb') as f: f.seek(pos) - self.assert_(f.seekable()) + self.assertTrue(f.seekable()) def test_main(): diff --git a/Lib/test/test_list.py b/Lib/test/test_list.py index 279afec..3510bd5 100644 --- a/Lib/test/test_list.py +++ b/Lib/test/test_list.py @@ -9,7 +9,7 @@ class ListTest(list_tests.CommonTest): l0_3 = [0, 1, 2, 3] l0_3_bis = list(l0_3) self.assertEqual(l0_3, l0_3_bis) - self.assert_(l0_3 is not l0_3_bis) + self.assertTrue(l0_3 is not l0_3_bis) self.assertEqual(list(()), []) self.assertEqual(list((0, 1, 2, 3)), [0, 1, 2, 3]) self.assertEqual(list(''), []) @@ -39,11 +39,11 @@ class ListTest(list_tests.CommonTest): def test_truth(self): super().test_truth() - self.assert_(not []) - self.assert_([42]) + self.assertTrue(not []) + self.assertTrue([42]) def test_identity(self): - self.assert_([] is not []) + self.assertTrue([] is not []) def test_len(self): super().test_len() diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py index 69ec491..72b26bb 100644 --- a/Lib/test/test_logging.py +++ b/Lib/test/test_logging.py @@ -99,7 +99,7 @@ class BaseTest(unittest.TestCase): finally: logging._releaseLock() - def assert_log_lines(self, expected_values, stream=None): + def assertTruelog_lines(self, expected_values, stream=None): """Match the collected log lines against the regular expression self.expected_log_pat, and compare the extracted group values to the expected_values list of tuples.""" @@ -165,7 +165,7 @@ class BuiltinLevelsTest(BaseTest): INF.debug(m()) - self.assert_log_lines([ + self.assertTruelog_lines([ ('ERR', 'CRITICAL', '1'), ('ERR', 'ERROR', '2'), ('INF', 'CRITICAL', '3'), @@ -197,7 +197,7 @@ class BuiltinLevelsTest(BaseTest): INF_ERR.info(m()) INF_ERR.debug(m()) - self.assert_log_lines([ + self.assertTruelog_lines([ ('INF.ERR', 'CRITICAL', '1'), ('INF.ERR', 'ERROR', '2'), ]) @@ -228,7 +228,7 @@ class BuiltinLevelsTest(BaseTest): INF_ERR_UNDEF.info(m()) INF_ERR_UNDEF.debug(m()) - self.assert_log_lines([ + self.assertTruelog_lines([ ('INF.UNDEF', 'CRITICAL', '1'), ('INF.UNDEF', 'ERROR', '2'), ('INF.UNDEF', 'WARNING', '3'), @@ -256,7 +256,7 @@ class BuiltinLevelsTest(BaseTest): GRANDCHILD.debug(m()) CHILD.debug(m()) - self.assert_log_lines([ + self.assertTruelog_lines([ ('INF.BADPARENT.UNDEF', 'CRITICAL', '1'), ('INF.BADPARENT.UNDEF', 'INFO', '2'), ('INF.BADPARENT', 'CRITICAL', '3'), @@ -285,7 +285,7 @@ class BasicFilterTest(BaseTest): spam_eggs_fish.info(self.next_message()) # Good. spam_bakedbeans.info(self.next_message()) - self.assert_log_lines([ + self.assertTruelog_lines([ ('spam.eggs', 'INFO', '2'), ('spam.eggs.fish', 'INFO', '3'), ]) @@ -367,7 +367,7 @@ class CustomLevelsAndFiltersTest(BaseTest): self.root_logger.setLevel(VERBOSE) # Levels >= 'Verbose' are good. self.log_at_all_levels(self.root_logger) - self.assert_log_lines([ + self.assertTruelog_lines([ ('Verbose', '5'), ('Sociable', '6'), ('Effusive', '7'), @@ -382,7 +382,7 @@ class CustomLevelsAndFiltersTest(BaseTest): try: # Levels >= 'Sociable' are good. self.log_at_all_levels(self.root_logger) - self.assert_log_lines([ + self.assertTruelog_lines([ ('Sociable', '6'), ('Effusive', '7'), ('Terse', '8'), @@ -413,12 +413,12 @@ class CustomLevelsAndFiltersTest(BaseTest): ('Taciturn', '9'), ('Silent', '10'), ] - self.assert_log_lines(first_lines) + self.assertTruelog_lines(first_lines) specific_filter = VerySpecificFilter() self.root_logger.addFilter(specific_filter) self.log_at_all_levels(self.root_logger) - self.assert_log_lines(first_lines + [ + self.assertTruelog_lines(first_lines + [ # Not only 'Garrulous' is still missing, but also 'Sociable' # and 'Taciturn' ('Boring', '11'), @@ -458,9 +458,9 @@ class MemoryHandlerTest(BaseTest): # The memory handler flushes to its target handler based on specific # criteria (message count and message level). self.mem_logger.debug(self.next_message()) - self.assert_log_lines([]) + self.assertTruelog_lines([]) self.mem_logger.info(self.next_message()) - self.assert_log_lines([]) + self.assertTruelog_lines([]) # This will flush because the level is >= logging.WARNING self.mem_logger.warn(self.next_message()) lines = [ @@ -468,19 +468,19 @@ class MemoryHandlerTest(BaseTest): ('INFO', '2'), ('WARNING', '3'), ] - self.assert_log_lines(lines) + self.assertTruelog_lines(lines) for n in (4, 14): for i in range(9): self.mem_logger.debug(self.next_message()) - self.assert_log_lines(lines) + self.assertTruelog_lines(lines) # This will flush because it's the 10th message since the last # flush. self.mem_logger.debug(self.next_message()) lines = lines + [('DEBUG', str(i)) for i in range(n, n + 10)] - self.assert_log_lines(lines) + self.assertTruelog_lines(lines) self.mem_logger.debug(self.next_message()) - self.assert_log_lines(lines) + self.assertTruelog_lines(lines) class ExceptionFormatter(logging.Formatter): @@ -650,11 +650,11 @@ class ConfigFileTest(BaseTest): logger.info(self.next_message()) # Outputs a message logger.error(self.next_message()) - self.assert_log_lines([ + self.assertTruelog_lines([ ('ERROR', '2'), ], stream=output) # Original logger output is empty. - self.assert_log_lines([]) + self.assertTruelog_lines([]) def test_config1_ok(self, config=config1): # A config file defining a sub-parser as well. @@ -664,12 +664,12 @@ class ConfigFileTest(BaseTest): # Both will output a message logger.info(self.next_message()) logger.error(self.next_message()) - self.assert_log_lines([ + self.assertTruelog_lines([ ('INFO', '1'), ('ERROR', '2'), ], stream=output) # Original logger output is empty. - self.assert_log_lines([]) + self.assertTruelog_lines([]) def test_config2_failure(self): # A simple config file which overrides the default settings. @@ -692,7 +692,7 @@ class ConfigFileTest(BaseTest): self.assertEquals(output.getvalue(), "ERROR:root:just testing\nGot a [RuntimeError]\n") # Original logger output is empty - self.assert_log_lines([]) + self.assertTruelog_lines([]) def test_config5_ok(self): self.test_config1_ok(config=self.config5) @@ -826,7 +826,7 @@ class MemoryTest(BaseTest): key = id(obj), repr(obj) self._survivors[key] = weakref.ref(obj) - def _assert_survival(self): + def _assertTruesurvival(self): """Assert that all objects watched for survival have survived.""" # Trigger cycle breaking. gc.collect() @@ -847,16 +847,16 @@ class MemoryTest(BaseTest): foo.setLevel(logging.DEBUG) self.root_logger.debug(self.next_message()) foo.debug(self.next_message()) - self.assert_log_lines([ + self.assertTruelog_lines([ ('foo', 'DEBUG', '2'), ]) del foo # foo has survived. - self._assert_survival() + self._assertTruesurvival() # foo has retained its settings. bar = logging.getLogger("foo") bar.debug(self.next_message()) - self.assert_log_lines([ + self.assertTruelog_lines([ ('foo', 'DEBUG', '2'), ('foo', 'DEBUG', '3'), ]) @@ -881,7 +881,7 @@ class EncodingTest(BaseTest): # check we wrote exactly those bytes, ignoring trailing \n etc f = open(fn, encoding="utf8") try: - self.failUnlessEqual(f.read().rstrip(), data) + self.assertEqual(f.read().rstrip(), data) finally: f.close() finally: diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py index 53d3e6b..1b5e6d4 100644 --- a/Lib/test/test_long.py +++ b/Lib/test/test_long.py @@ -65,7 +65,7 @@ class LongTest(unittest.TestCase): # The sign of the number is also random. def getran(self, ndigits): - self.assert_(ndigits > 0) + self.assertTrue(ndigits > 0) nbits_hi = ndigits * SHIFT nbits_lo = nbits_hi - SHIFT + 1 answer = 0 @@ -74,13 +74,13 @@ class LongTest(unittest.TestCase): while nbits < nbits_lo: bits = (r >> 1) + 1 bits = min(bits, nbits_hi - nbits) - self.assert_(1 <= bits <= SHIFT) + self.assertTrue(1 <= bits <= SHIFT) nbits = nbits + bits answer = answer << bits if r & 1: answer = answer | ((1 << bits) - 1) r = int(random.random() * (SHIFT * 2)) - self.assert_(nbits_lo <= nbits <= nbits_hi) + self.assertTrue(nbits_lo <= nbits <= nbits_hi) if random.random() < 0.5: answer = -answer return answer @@ -106,9 +106,9 @@ class LongTest(unittest.TestCase): eq(r, r2, Frm("divmod returns different mod than %% for %r and %r", x, y)) eq(x, q*y + r, Frm("x != q*y + r after divmod on x=%r, y=%r", x, y)) if y > 0: - self.assert_(0 <= r < y, Frm("bad mod from divmod on %r and %r", x, y)) + self.assertTrue(0 <= r < y, Frm("bad mod from divmod on %r and %r", x, y)) else: - self.assert_(y < r <= 0, Frm("bad mod from divmod on %r and %r", x, y)) + self.assertTrue(y < r <= 0, Frm("bad mod from divmod on %r and %r", x, y)) def test_division(self): digits = list(range(1, MAXDIGITS+1)) + list(range(KARATSUBA_CUTOFF, @@ -538,7 +538,7 @@ class LongTest(unittest.TestCase): y = int(x) except OverflowError: self.fail("int(long(sys.maxsize) + 1) mustn't overflow") - self.assert_(isinstance(y, int), + self.assertTrue(isinstance(y, int), "int(long(sys.maxsize) + 1) should have returned long") x = hugeneg_aslong - 1 @@ -546,14 +546,14 @@ class LongTest(unittest.TestCase): y = int(x) except OverflowError: self.fail("int(long(-sys.maxsize-1) - 1) mustn't overflow") - self.assert_(isinstance(y, int), + self.assertTrue(isinstance(y, int), "int(long(-sys.maxsize-1) - 1) should have returned long") class long2(int): pass x = long2(1<<100) y = int(x) - self.assert_(type(y) is int, + self.assertTrue(type(y) is int, "overflowing int conversion must return long not long subtype") # ----------------------------------- tests of auto int->long conversion @@ -958,7 +958,7 @@ class LongTest(unittest.TestCase): self.assertEqual(k, len(bin(x).lstrip('-0b'))) # Behaviour as specified in the docs if x != 0: - self.assert_(2**(k-1) <= abs(x) < 2**k) + self.assertTrue(2**(k-1) <= abs(x) < 2**k) else: self.assertEqual(k, 0) # Alternative definition: x.bit_length() == 1 + floor(log_2(x)) @@ -995,7 +995,7 @@ class LongTest(unittest.TestCase): got = round(k+offset, -1) expected = v+offset self.assertEqual(got, expected) - self.assert_(type(got) is int) + self.assertTrue(type(got) is int) # larger second argument self.assertEqual(round(-150, -2), -200) @@ -1034,7 +1034,7 @@ class LongTest(unittest.TestCase): got = round(10**k + 324678, -3) expect = 10**k + 325000 self.assertEqual(got, expect) - self.assert_(type(got) is int) + self.assertTrue(type(got) is int) # nonnegative second argument: round(x, n) should just return x for n in range(5): @@ -1042,7 +1042,7 @@ class LongTest(unittest.TestCase): x = random.randrange(-10000, 10000) got = round(x, n) self.assertEqual(got, x) - self.assert_(type(got) is int) + self.assertTrue(type(got) is int) for huge_n in 2**31-1, 2**31, 2**63-1, 2**63, 2**100, 10**100: self.assertEqual(round(8979323, huge_n), 8979323) @@ -1051,7 +1051,7 @@ class LongTest(unittest.TestCase): x = random.randrange(-10000, 10000) got = round(x) self.assertEqual(got, x) - self.assert_(type(got) is int) + self.assertTrue(type(got) is int) # bad second argument bad_exponents = ('brian', 2.0, 0j, None) diff --git a/Lib/test/test_macpath.py b/Lib/test/test_macpath.py index 368d8f5..e13865d 100644 --- a/Lib/test/test_macpath.py +++ b/Lib/test/test_macpath.py @@ -10,37 +10,37 @@ class MacPathTestCase(unittest.TestCase): def test_isabs(self): isabs = macpath.isabs - self.assert_(isabs("xx:yy")) - self.assert_(isabs("xx:yy:")) - self.assert_(isabs("xx:")) - self.failIf(isabs("foo")) - self.failIf(isabs(":foo")) - self.failIf(isabs(":foo:bar")) - self.failIf(isabs(":foo:bar:")) - - self.assert_(isabs(b"xx:yy")) - self.assert_(isabs(b"xx:yy:")) - self.assert_(isabs(b"xx:")) - self.failIf(isabs(b"foo")) - self.failIf(isabs(b":foo")) - self.failIf(isabs(b":foo:bar")) - self.failIf(isabs(b":foo:bar:")) + self.assertTrue(isabs("xx:yy")) + self.assertTrue(isabs("xx:yy:")) + self.assertTrue(isabs("xx:")) + self.assertFalse(isabs("foo")) + self.assertFalse(isabs(":foo")) + self.assertFalse(isabs(":foo:bar")) + self.assertFalse(isabs(":foo:bar:")) + + self.assertTrue(isabs(b"xx:yy")) + self.assertTrue(isabs(b"xx:yy:")) + self.assertTrue(isabs(b"xx:")) + self.assertFalse(isabs(b"foo")) + self.assertFalse(isabs(b":foo")) + self.assertFalse(isabs(b":foo:bar")) + self.assertFalse(isabs(b":foo:bar:")) def test_commonprefix(self): commonprefix = macpath.commonprefix - self.assert_(commonprefix(["home:swenson:spam", "home:swen:spam"]) + self.assertTrue(commonprefix(["home:swenson:spam", "home:swen:spam"]) == "home:swen") - self.assert_(commonprefix([":home:swen:spam", ":home:swen:eggs"]) + self.assertTrue(commonprefix([":home:swen:spam", ":home:swen:eggs"]) == ":home:swen:") - self.assert_(commonprefix([":home:swen:spam", ":home:swen:spam"]) + self.assertTrue(commonprefix([":home:swen:spam", ":home:swen:spam"]) == ":home:swen:spam") - self.assert_(commonprefix([b"home:swenson:spam", b"home:swen:spam"]) + self.assertTrue(commonprefix([b"home:swenson:spam", b"home:swen:spam"]) == b"home:swen") - self.assert_(commonprefix([b":home:swen:spam", b":home:swen:eggs"]) + self.assertTrue(commonprefix([b":home:swen:spam", b":home:swen:eggs"]) == b":home:swen:") - self.assert_(commonprefix([b":home:swen:spam", b":home:swen:spam"]) + self.assertTrue(commonprefix([b":home:swen:spam", b":home:swen:spam"]) == b":home:swen:spam") def test_split(self): diff --git a/Lib/test/test_mailbox.py b/Lib/test/test_mailbox.py index 655b639..8994340 100644 --- a/Lib/test/test_mailbox.py +++ b/Lib/test/test_mailbox.py @@ -21,16 +21,16 @@ class TestBase(unittest.TestCase): def _check_sample(self, msg): # Inspect a mailbox.Message representation of the sample message - self.assert_(isinstance(msg, email.message.Message)) - self.assert_(isinstance(msg, mailbox.Message)) + self.assertTrue(isinstance(msg, email.message.Message)) + self.assertTrue(isinstance(msg, mailbox.Message)) for key, value in _sample_headers.items(): - self.assert_(value in msg.get_all(key)) - self.assert_(msg.is_multipart()) + self.assertTrue(value in msg.get_all(key)) + self.assertTrue(msg.is_multipart()) self.assertEqual(len(msg.get_payload()), len(_sample_payloads)) for i, payload in enumerate(_sample_payloads): part = msg.get_payload(i) - self.assert_(isinstance(part, email.message.Message)) - self.assert_(not isinstance(part, mailbox.Message)) + self.assertTrue(isinstance(part, email.message.Message)) + self.assertTrue(not isinstance(part, mailbox.Message)) self.assertEqual(part.get_payload(), payload) def _delete_recursively(self, target): @@ -92,7 +92,7 @@ class TestMailbox(TestBase): self.assertEqual(len(self._box), 2) method(key0) l = len(self._box) - self.assert_(l == 1, "actual l: %s" % l) + self.assertTrue(l == 1, "actual l: %s" % l) self.assertRaises(KeyError, lambda: self._box[key0]) self.assertRaises(KeyError, lambda: method(key0)) self.assertEqual(self._box.get_string(key1), self._template % 1) @@ -100,7 +100,7 @@ class TestMailbox(TestBase): self.assertEqual(len(self._box), 2) method(key2) l = len(self._box) - self.assert_(l == 1, "actual l: %s" % l) + self.assertTrue(l == 1, "actual l: %s" % l) self.assertRaises(KeyError, lambda: self._box[key2]) self.assertRaises(KeyError, lambda: method(key2)) self.assertEqual(self._box.get_string(key1), self._template % 1) @@ -127,8 +127,8 @@ class TestMailbox(TestBase): msg = self._box.get(key0) self.assertEqual(msg['from'], 'foo') self.assertEqual(msg.get_payload(), '0') - self.assert_(self._box.get('foo') is None) - self.assert_(self._box.get('foo', False) is False) + self.assertTrue(self._box.get('foo') is None) + self.assertTrue(self._box.get('foo', False) is False) self._box.close() self._box = self._factory(self._path) key1 = self._box.add(self._template % 1) @@ -151,7 +151,7 @@ class TestMailbox(TestBase): key0 = self._box.add(self._template % 0) key1 = self._box.add(_sample_message) msg0 = self._box.get_message(key0) - self.assert_(isinstance(msg0, mailbox.Message)) + self.assertTrue(isinstance(msg0, mailbox.Message)) self.assertEqual(msg0['from'], 'foo') self.assertEqual(msg0.get_payload(), '0') self._check_sample(self._box.get_message(key1)) @@ -228,29 +228,29 @@ class TestMailbox(TestBase): count = 0 for value in returned_values: self.assertEqual(value['from'], 'foo') - self.assert_(int(value.get_payload()) < repetitions) + self.assertTrue(int(value.get_payload()) < repetitions) count += 1 self.assertEqual(len(values), count) def test_contains(self): # Check existence of keys using __contains__() method = self._box.__contains__ - self.assert_(not method('foo')) + self.assertTrue(not method('foo')) key0 = self._box.add(self._template % 0) - self.assert_(method(key0)) - self.assert_(not method('foo')) + self.assertTrue(method(key0)) + self.assertTrue(not method('foo')) key1 = self._box.add(self._template % 1) - self.assert_(method(key1)) - self.assert_(method(key0)) - self.assert_(not method('foo')) + self.assertTrue(method(key1)) + self.assertTrue(method(key0)) + self.assertTrue(not method('foo')) self._box.remove(key0) - self.assert_(not method(key0)) - self.assert_(method(key1)) - self.assert_(not method('foo')) + self.assertTrue(not method(key0)) + self.assertTrue(method(key1)) + self.assertTrue(not method('foo')) self._box.remove(key1) - self.assert_(not method(key1)) - self.assert_(not method(key0)) - self.assert_(not method('foo')) + self.assertTrue(not method(key1)) + self.assertTrue(not method(key0)) + self.assertTrue(not method('foo')) def test_len(self, repetitions=10): # Get message count @@ -297,7 +297,7 @@ class TestMailbox(TestBase): for i in range(iterations): self._box.add(self._template % i) for i, key in enumerate(keys): - self.assert_(self._box.get_string(key) == self._template % i) + self.assertTrue(self._box.get_string(key) == self._template % i) self._box.clear() self.assertEqual(len(self._box), 0) for i, key in enumerate(keys): @@ -306,19 +306,19 @@ class TestMailbox(TestBase): def test_pop(self): # Get and remove a message using pop() key0 = self._box.add(self._template % 0) - self.assert_(key0 in self._box) + self.assertTrue(key0 in self._box) key1 = self._box.add(self._template % 1) - self.assert_(key1 in self._box) + self.assertTrue(key1 in self._box) self.assertEqual(self._box.pop(key0).get_payload(), '0') - self.assert_(key0 not in self._box) - self.assert_(key1 in self._box) + self.assertTrue(key0 not in self._box) + self.assertTrue(key1 in self._box) key2 = self._box.add(self._template % 2) - self.assert_(key2 in self._box) + self.assertTrue(key2 in self._box) self.assertEqual(self._box.pop(key2).get_payload(), '2') - self.assert_(key2 not in self._box) - self.assert_(key1 in self._box) + self.assertTrue(key2 not in self._box) + self.assertTrue(key1 in self._box) self.assertEqual(self._box.pop(key1).get_payload(), '1') - self.assert_(key1 not in self._box) + self.assertTrue(key1 not in self._box) self.assertEqual(len(self._box), 0) def test_popitem(self, iterations=10): @@ -329,8 +329,8 @@ class TestMailbox(TestBase): seen = [] for i in range(10): key, msg = self._box.popitem() - self.assert_(key in keys) - self.assert_(key not in seen) + self.assertTrue(key in keys) + self.assertTrue(key not in seen) seen.append(key) self.assertEqual(int(msg.get_payload()), keys.index(key)) self.assertEqual(len(self._box), 0) @@ -377,11 +377,11 @@ class TestMailbox(TestBase): def test_lock_unlock(self): # Lock and unlock the mailbox - self.assert_(not os.path.exists(self._get_lock_path())) + self.assertTrue(not os.path.exists(self._get_lock_path())) self._box.lock() - self.assert_(os.path.exists(self._get_lock_path())) + self.assertTrue(os.path.exists(self._get_lock_path())) self._box.unlock() - self.assert_(not os.path.exists(self._get_lock_path())) + self.assertTrue(not os.path.exists(self._get_lock_path())) def test_close(self): # Close mailbox and flush changes to disk @@ -400,7 +400,7 @@ class TestMailbox(TestBase): keys = self._box.keys() self.assertEqual(len(keys), 3) for key in keys: - self.assert_(self._box.get_string(key) in contents) + self.assertTrue(self._box.get_string(key) in contents) oldbox.close() def test_dump_message(self): @@ -469,7 +469,7 @@ class TestMaildir(TestMailbox): msg.set_subdir('cur') msg.set_info('foo') key = self._box.add(msg) - self.assert_(os.path.exists(os.path.join(self._path, 'cur', '%s%sfoo' % + self.assertTrue(os.path.exists(os.path.join(self._path, 'cur', '%s%sfoo' % (key, self._box.colon)))) def test_get_MM(self): @@ -479,7 +479,7 @@ class TestMaildir(TestMailbox): msg.set_flags('RF') key = self._box.add(msg) msg_returned = self._box.get_message(key) - self.assert_(isinstance(msg_returned, mailbox.MaildirMessage)) + self.assertTrue(isinstance(msg_returned, mailbox.MaildirMessage)) self.assertEqual(msg_returned.get_subdir(), 'cur') self.assertEqual(msg_returned.get_flags(), 'FR') @@ -519,7 +519,7 @@ class TestMaildir(TestMailbox): box = mailbox.Maildir(self._path, factory=FakeMessage) box.colon = self._box.colon msg2 = box.get_message(key) - self.assert_(isinstance(msg2, FakeMessage)) + self.assertTrue(isinstance(msg2, FakeMessage)) def test_initialize_new(self): # Initialize a non-existent mailbox @@ -545,7 +545,7 @@ class TestMaildir(TestMailbox): for subdir in '', 'tmp', 'new', 'cur': path = os.path.join(self._path, subdir) mode = os.stat(path)[stat.ST_MODE] - self.assert_(stat.S_ISDIR(mode), "Not a directory: '%s'" % path) + self.assertTrue(stat.S_ISDIR(mode), "Not a directory: '%s'" % path) def test_list_folders(self): # List folders @@ -561,7 +561,7 @@ class TestMaildir(TestMailbox): self._box.add_folder('foo.bar') folder0 = self._box.get_folder('foo.bar') folder0.add(self._template % 'bar') - self.assert_(os.path.isdir(os.path.join(self._path, '.foo.bar'))) + self.assertTrue(os.path.isdir(os.path.join(self._path, '.foo.bar'))) folder1 = self._box.get_folder('foo.bar') self.assertEqual(folder1.get_string(folder1.keys()[0]), self._template % 'bar') @@ -571,7 +571,7 @@ class TestMaildir(TestMailbox): self._box.add_folder('one') self._box.add_folder('two') self.assertEqual(len(self._box.list_folders()), 2) - self.assert_(set(self._box.list_folders()) == set(('one', 'two'))) + self.assertTrue(set(self._box.list_folders()) == set(('one', 'two'))) self._box.remove_folder('one') self.assertEqual(len(self._box.list_folders()), 1) self.assertEqual(set(self._box.list_folders()), set(('two',))) @@ -596,14 +596,14 @@ class TestMaildir(TestMailbox): f.write("@") f.close() self._box.clean() - self.assert_(os.path.exists(foo_path)) - self.assert_(os.path.exists(bar_path)) + self.assertTrue(os.path.exists(foo_path)) + self.assertTrue(os.path.exists(bar_path)) foo_stat = os.stat(foo_path) os.utime(foo_path, (time.time() - 129600 - 2, foo_stat.st_mtime)) self._box.clean() - self.assert_(not os.path.exists(foo_path)) - self.assert_(os.path.exists(bar_path)) + self.assertTrue(not os.path.exists(foo_path)) + self.assertTrue(os.path.exists(bar_path)) def test_create_tmp(self, repetitions=10): # Create files in tmp directory @@ -623,13 +623,13 @@ class TestMaildir(TestMailbox): "tmp")), "File in wrong location: '%s'" % head) match = pattern.match(tail) - self.assert_(match is not None, "Invalid file name: '%s'" % tail) + self.assertTrue(match is not None, "Invalid file name: '%s'" % tail) groups = match.groups() if previous_groups is not None: - self.assert_(int(groups[0] >= previous_groups[0]), + self.assertTrue(int(groups[0] >= previous_groups[0]), "Non-monotonic seconds: '%s' before '%s'" % (previous_groups[0], groups[0])) - self.assert_(int(groups[1] >= previous_groups[1]) or + self.assertTrue(int(groups[1] >= previous_groups[1]) or groups[0] != groups[1], "Non-monotonic milliseconds: '%s' before '%s'" % (previous_groups[1], groups[1])) @@ -691,10 +691,10 @@ class TestMaildir(TestMailbox): return None box = self._factory(self._path, factory=dummy_factory) folder = box.add_folder('folder1') - self.assert_(folder._factory is dummy_factory) + self.assertTrue(folder._factory is dummy_factory) folder1_alias = box.get_folder('folder1') - self.assert_(folder1_alias._factory is dummy_factory) + self.assertTrue(folder1_alias._factory is dummy_factory) def test_directory_in_folder (self): # Test that mailboxes still work if there's a stray extra directory @@ -721,7 +721,7 @@ class TestMaildir(TestMailbox): os.umask(orig_umask) path = os.path.join(self._path, self._box._lookup(key)) mode = os.stat(path).st_mode - self.assert_(mode & 0o111 == 0) + self.assertTrue(mode & 0o111 == 0) def test_folder_file_perms(self): # From bug #3228, we want to verify that the file created inside a Maildir @@ -802,7 +802,7 @@ class _TestMboxMMDF(TestMailbox): self._box = self._factory(self._path) self.assertEqual(len(self._box), 3) for key in self._box.keys(): - self.assert_(self._box.get_string(key) in values) + self.assertTrue(self._box.get_string(key) in values) self._box.close() self.assertEqual(mtime, os.path.getmtime(self._path)) @@ -859,7 +859,7 @@ class _TestMboxMMDF(TestMailbox): self._box.lock() key2 = self._box.add(msg) self._box.flush() - self.assert_(self._box._locked) + self.assertTrue(self._box._locked) self._box.close() @@ -913,15 +913,15 @@ class TestMH(TestMailbox): new_folder = self._box.add_folder('foo.bar') folder0 = self._box.get_folder('foo.bar') folder0.add(self._template % 'bar') - self.assert_(os.path.isdir(os.path.join(self._path, 'foo.bar'))) + self.assertTrue(os.path.isdir(os.path.join(self._path, 'foo.bar'))) folder1 = self._box.get_folder('foo.bar') self.assertEqual(folder1.get_string(folder1.keys()[0]), self._template % 'bar') # Test for bug #1569790: verify that folders returned by .get_folder() # use the same factory function. - self.assert_(new_folder._factory is self._box._factory) - self.assert_(folder0._factory is self._box._factory) + self.assertTrue(new_folder._factory is self._box._factory) + self.assertTrue(folder0._factory is self._box._factory) def test_add_and_remove_folders(self): # Delete folders @@ -990,7 +990,7 @@ class TestMH(TestMailbox): {'foo':[key0,key1,key3], 'unseen':[key0], 'bar':[key3], 'replied':[key3]}) self._box.pack() - self.assert_(self._box.keys() == [1, 2, 3]) + self.assertTrue(self._box.keys() == [1, 2, 3]) key0 = key0 key1 = key0 + 1 key2 = key1 + 1 @@ -1082,11 +1082,11 @@ class TestMessage(TestBase): # Initialize without arguments msg = self._factory() self._post_initialize_hook(msg) - self.assert_(isinstance(msg, email.message.Message)) - self.assert_(isinstance(msg, mailbox.Message)) - self.assert_(isinstance(msg, self._factory)) + self.assertTrue(isinstance(msg, email.message.Message)) + self.assertTrue(isinstance(msg, mailbox.Message)) + self.assertTrue(isinstance(msg, self._factory)) self.assertEqual(msg.keys(), []) - self.assert_(not msg.is_multipart()) + self.assertTrue(not msg.is_multipart()) self.assertEqual(msg.get_payload(), None) def test_initialize_incorrectly(self): @@ -1159,7 +1159,7 @@ class TestMaildirMessage(TestMessage): def test_date(self): # Use get_date() and set_date() msg = mailbox.MaildirMessage(_sample_message) - self.assert_(abs(msg.get_date() - time.time()) < 60) + self.assertTrue(abs(msg.get_date() - time.time()) < 60) msg.set_date(0.0) self.assertEqual(msg.get_date(), 0.0) @@ -1234,7 +1234,7 @@ class _TestMboxMMDFMessage(TestMessage): # Check contents of "From " line if sender is None: sender = "MAILER-DAEMON" - self.assert_(re.match(sender + r" \w{3} \w{3} [\d ]\d [\d ]\d:\d{2}:" + self.assertTrue(re.match(sender + r" \w{3} \w{3} [\d ]\d [\d ]\d:\d{2}:" r"\d{2} \d{4}", msg.get_from()) is not None) @@ -1309,19 +1309,19 @@ class TestBabylMessage(TestMessage): msg = mailbox.BabylMessage(_sample_message) visible = msg.get_visible() self.assertEqual(visible.keys(), []) - self.assert_(visible.get_payload() is None) + self.assertTrue(visible.get_payload() is None) visible['User-Agent'] = 'FooBar 1.0' visible['X-Whatever'] = 'Blah' self.assertEqual(msg.get_visible().keys(), []) msg.set_visible(visible) visible = msg.get_visible() - self.assert_(visible.keys() == ['User-Agent', 'X-Whatever']) - self.assert_(visible['User-Agent'] == 'FooBar 1.0') + self.assertTrue(visible.keys() == ['User-Agent', 'X-Whatever']) + self.assertTrue(visible['User-Agent'] ==


context:
space:
mode: