diff -r cf606c403f14 Lib/ctypes/test/test_arrays.py --- a/Lib/ctypes/test/test_arrays.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_arrays.py Mon Nov 19 12:28:22 2012 +0200 @@ -84,8 +84,8 @@ self.assertEqual(values, [1, 2, 3, 4, 5]) def test_classcache(self): - self.assertTrue(not ARRAY(c_int, 3) is ARRAY(c_int, 4)) - self.assertTrue(ARRAY(c_int, 3) is ARRAY(c_int, 3)) + self.assertIsNot(ARRAY(c_int, 3), ARRAY(c_int, 4)) + self.assertIs(ARRAY(c_int, 3), ARRAY(c_int, 3)) def test_from_address(self): # Failed with 0.9.8, reported by JUrner @@ -125,7 +125,7 @@ # Create a new array type based on it: t1 = my_int * 1 t2 = my_int * 1 - self.assertTrue(t1 is t2) + self.assertIs(t1, t2) def test_subclass(self): class T(Array): diff -r cf606c403f14 Lib/ctypes/test/test_as_parameter.py --- a/Lib/ctypes/test/test_as_parameter.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_as_parameter.py Mon Nov 19 12:28:22 2012 +0200 @@ -134,7 +134,7 @@ f.argtypes = [c_longlong, MyCallback] def callback(value): - self.assertTrue(isinstance(value, int)) + self.assertIsInstance(value, int) return value & 0x7FFFFFFF cb = MyCallback(callback) diff -r cf606c403f14 Lib/ctypes/test/test_buffers.py --- a/Lib/ctypes/test/test_buffers.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_buffers.py Mon Nov 19 12:28:22 2012 +0200 @@ -7,12 +7,12 @@ b = create_string_buffer(32) self.assertEqual(len(b), 32) self.assertEqual(sizeof(b), 32 * sizeof(c_char)) - self.assertTrue(type(b[0]) is bytes) + self.assertIs(type(b[0]), bytes) b = create_string_buffer(b"abc") self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(sizeof(b), 4 * sizeof(c_char)) - self.assertTrue(type(b[0]) is bytes) + self.assertIs(type(b[0]), bytes) self.assertEqual(b[0], b"a") self.assertEqual(b[:], b"abc\0") self.assertEqual(b[::], b"abc\0") @@ -33,12 +33,12 @@ b = create_unicode_buffer(32) self.assertEqual(len(b), 32) self.assertEqual(sizeof(b), 32 * sizeof(c_wchar)) - self.assertTrue(type(b[0]) is str) + self.assertIs(type(b[0]), str) b = create_unicode_buffer("abc") self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(sizeof(b), 4 * sizeof(c_wchar)) - self.assertTrue(type(b[0]) is str) + self.assertIs(type(b[0]), str) self.assertEqual(b[0], "a") self.assertEqual(b[:], "abc\0") self.assertEqual(b[::], "abc\0") @@ -50,7 +50,7 @@ b = create_unicode_buffer("abc") self.assertEqual(len(b), 4) # trailing nul char self.assertEqual(sizeof(b), 4 * sizeof(c_wchar)) - self.assertTrue(type(b[0]) is str) + self.assertIs(type(b[0]), str) self.assertEqual(b[0], "a") self.assertEqual(b[:], "abc\0") self.assertEqual(b[::], "abc\0") diff -r cf606c403f14 Lib/ctypes/test/test_byteswap.py --- a/Lib/ctypes/test/test_byteswap.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_byteswap.py Mon Nov 19 12:28:22 2012 +0200 @@ -23,11 +23,11 @@ def test_endian_short(self): if sys.byteorder == "little": - self.assertTrue(c_short.__ctype_le__ is c_short) - self.assertTrue(c_short.__ctype_be__.__ctype_le__ is c_short) + self.assertIs(c_short.__ctype_le__, c_short) + self.assertIs(c_short.__ctype_be__.__ctype_le__, c_short) else: - self.assertTrue(c_short.__ctype_be__ is c_short) - self.assertTrue(c_short.__ctype_le__.__ctype_be__ is c_short) + self.assertIs(c_short.__ctype_be__, c_short) + self.assertIs(c_short.__ctype_le__.__ctype_be__, c_short) s = c_short.__ctype_be__(0x1234) self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234") self.assertEqual(bin(s), "1234") @@ -50,11 +50,11 @@ def test_endian_int(self): if sys.byteorder == "little": - self.assertTrue(c_int.__ctype_le__ is c_int) - self.assertTrue(c_int.__ctype_be__.__ctype_le__ is c_int) + self.assertIs(c_int.__ctype_le__, c_int) + self.assertIs(c_int.__ctype_be__.__ctype_le__, c_int) else: - self.assertTrue(c_int.__ctype_be__ is c_int) - self.assertTrue(c_int.__ctype_le__.__ctype_be__ is c_int) + self.assertIs(c_int.__ctype_be__, c_int) + self.assertIs(c_int.__ctype_le__.__ctype_be__, c_int) s = c_int.__ctype_be__(0x12345678) self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678") @@ -78,11 +78,11 @@ def test_endian_longlong(self): if sys.byteorder == "little": - self.assertTrue(c_longlong.__ctype_le__ is c_longlong) - self.assertTrue(c_longlong.__ctype_be__.__ctype_le__ is c_longlong) + self.assertIs(c_longlong.__ctype_le__, c_longlong) + self.assertIs(c_longlong.__ctype_be__.__ctype_le__, c_longlong) else: - self.assertTrue(c_longlong.__ctype_be__ is c_longlong) - self.assertTrue(c_longlong.__ctype_le__.__ctype_be__ is c_longlong) + self.assertIs(c_longlong.__ctype_be__, c_longlong) + self.assertIs(c_longlong.__ctype_le__.__ctype_be__, c_longlong) s = c_longlong.__ctype_be__(0x1234567890ABCDEF) self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF") @@ -106,11 +106,11 @@ def test_endian_float(self): if sys.byteorder == "little": - self.assertTrue(c_float.__ctype_le__ is c_float) - self.assertTrue(c_float.__ctype_be__.__ctype_le__ is c_float) + self.assertIs(c_float.__ctype_le__, c_float) + self.assertIs(c_float.__ctype_be__.__ctype_le__, c_float) else: - self.assertTrue(c_float.__ctype_be__ is c_float) - self.assertTrue(c_float.__ctype_le__.__ctype_be__ is c_float) + self.assertIs(c_float.__ctype_be__, c_float) + self.assertIs(c_float.__ctype_le__.__ctype_be__, c_float) s = c_float(math.pi) self.assertEqual(bin(struct.pack("f", math.pi)), bin(s)) # Hm, what's the precision of a float compared to a double? @@ -124,11 +124,11 @@ def test_endian_double(self): if sys.byteorder == "little": - self.assertTrue(c_double.__ctype_le__ is c_double) - self.assertTrue(c_double.__ctype_be__.__ctype_le__ is c_double) + self.assertIs(c_double.__ctype_le__, c_double) + self.assertIs(c_double.__ctype_be__.__ctype_le__, c_double) else: - self.assertTrue(c_double.__ctype_be__ is c_double) - self.assertTrue(c_double.__ctype_le__.__ctype_be__ is c_double) + self.assertIs(c_double.__ctype_be__, c_double) + self.assertIs(c_double.__ctype_le__.__ctype_be__, c_double) s = c_double(math.pi) self.assertEqual(s.value, math.pi) self.assertEqual(bin(struct.pack("d", math.pi)), bin(s)) @@ -140,14 +140,14 @@ self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s)) def test_endian_other(self): - self.assertTrue(c_byte.__ctype_le__ is c_byte) - self.assertTrue(c_byte.__ctype_be__ is c_byte) + self.assertIs(c_byte.__ctype_le__, c_byte) + self.assertIs(c_byte.__ctype_be__, c_byte) - self.assertTrue(c_ubyte.__ctype_le__ is c_ubyte) - self.assertTrue(c_ubyte.__ctype_be__ is c_ubyte) + self.assertIs(c_ubyte.__ctype_le__, c_ubyte) + self.assertIs(c_ubyte.__ctype_be__, c_ubyte) - self.assertTrue(c_char.__ctype_le__ is c_char) - self.assertTrue(c_char.__ctype_be__ is c_char) + self.assertIs(c_char.__ctype_le__, c_char) + self.assertIs(c_char.__ctype_be__, c_char) def test_struct_fields_1(self): if sys.byteorder == "little": diff -r cf606c403f14 Lib/ctypes/test/test_cast.py --- a/Lib/ctypes/test/test_cast.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_cast.py Mon Nov 19 12:28:22 2012 +0200 @@ -38,14 +38,14 @@ p = cast(array, POINTER(c_char_p)) # array and p share a common _objects attribute - self.assertTrue(p._objects is array._objects) + self.assertIs(p._objects, array._objects) self.assertEqual(array._objects, {'0': b"foo bar", id(array): array}) p[0] = b"spam spam" self.assertEqual(p._objects, {'0': b"spam spam", id(array): array}) - self.assertTrue(array._objects is p._objects) + self.assertIs(array._objects, p._objects) p[1] = b"foo bar" self.assertEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array}) - self.assertTrue(array._objects is p._objects) + self.assertIs(array._objects, p._objects) def test_other(self): p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int)) diff -r cf606c403f14 Lib/ctypes/test/test_frombuffer.py --- a/Lib/ctypes/test/test_frombuffer.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_frombuffer.py Mon Nov 19 12:28:22 2012 +0200 @@ -23,7 +23,7 @@ a[0], a[-1] = 200, -200 self.assertEqual(x[:], a.tolist()) - self.assertTrue(a in x._objects.values()) + self.assertIn(a, x._objects.values()) self.assertRaises(ValueError, c_int.from_buffer, a, -1) diff -r cf606c403f14 Lib/ctypes/test/test_funcptr.py --- a/Lib/ctypes/test/test_funcptr.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_funcptr.py Mon Nov 19 12:28:22 2012 +0200 @@ -75,7 +75,7 @@ ## "lpfnWndProc", WNDPROC_2(wndproc)) # instead: - self.assertTrue(WNDPROC is WNDPROC_2) + self.assertIs(WNDPROC, WNDPROC_2) # 'wndclass.lpfnWndProc' leaks 94 references. Why? self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10) diff -r cf606c403f14 Lib/ctypes/test/test_functions.py --- a/Lib/ctypes/test/test_functions.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_functions.py Mon Nov 19 12:28:22 2012 +0200 @@ -306,7 +306,7 @@ f.argtypes = [c_longlong, MyCallback] def callback(value): - self.assertTrue(isinstance(value, int)) + self.assertIsInstance(value, int) return value & 0x7FFFFFFF cb = MyCallback(callback) diff -r cf606c403f14 Lib/ctypes/test/test_loading.py --- a/Lib/ctypes/test/test_loading.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_loading.py Mon Nov 19 12:28:22 2012 +0200 @@ -43,7 +43,7 @@ if os.name in ("nt", "ce"): def test_load_library(self): - self.assertFalse(libc_name is None) + self.assertIsNotNone(libc_name) if is_resource_enabled("printing"): print(find_library("kernel32")) print(find_library("user32")) diff -r cf606c403f14 Lib/ctypes/test/test_numbers.py --- a/Lib/ctypes/test/test_numbers.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_numbers.py Mon Nov 19 12:28:22 2012 +0200 @@ -181,10 +181,10 @@ a = array(t._type_, [3.14]) v = t.from_address(a.buffer_info()[0]) self.assertEqual(v.value, a[0]) - self.assertTrue(type(v) is t) + self.assertIs(type(v), t) a[0] = 2.3456e17 self.assertEqual(v.value, a[0]) - self.assertTrue(type(v) is t) + self.assertIs(type(v), t) def test_char_from_address(self): from ctypes import c_char @@ -194,7 +194,7 @@ a[0] = ord('x') v = c_char.from_address(a.buffer_info()[0]) self.assertEqual(v.value, b'x') - self.assertTrue(type(v) is c_char) + self.assertIs(type(v), c_char) a[0] = ord('?') self.assertEqual(v.value, b'?') diff -r cf606c403f14 Lib/ctypes/test/test_parameters.py --- a/Lib/ctypes/test/test_parameters.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_parameters.py Mon Nov 19 12:28:22 2012 +0200 @@ -54,7 +54,7 @@ # c_char_p.from_param on a Python String packs the string # into a cparam object s = b"123" - self.assertTrue(c_char_p.from_param(s)._obj is s) + self.assertIs(c_char_p.from_param(s)._obj, s) # new in 0.9.1: convert (encode) unicode to ascii self.assertEqual(c_char_p.from_param(b"123")._obj, b"123") @@ -64,7 +64,7 @@ # calling c_char_p.from_param with a c_char_p instance # returns the argument itself: a = c_char_p(b"123") - self.assertTrue(c_char_p.from_param(a) is a) + self.assertIs(c_char_p.from_param(a), a) def test_cw_strings(self): from ctypes import byref diff -r cf606c403f14 Lib/ctypes/test/test_pointers.py --- a/Lib/ctypes/test/test_pointers.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_pointers.py Mon Nov 19 12:28:22 2012 +0200 @@ -78,7 +78,7 @@ ## i = c_int(42) ## callback(byref(i)) -## self.assertTrue(i.value == 84) +## self.assertEqual(i.value, 84) doit(callback) ## print self.result @@ -91,11 +91,11 @@ i = ct(42) p = pointer(i) ## print type(p.contents), ct - self.assertTrue(type(p.contents) is ct) + self.assertIs(type(p.contents), ct) # p.contents is the same as p[0] ## print p.contents -## self.assertTrue(p.contents == 42) -## self.assertTrue(p[0] == 42) +## self.assertEqual(p.contents, 42) +## self.assertEqual(p[0], 42) self.assertRaises(TypeError, delitem, p, 0) diff -r cf606c403f14 Lib/ctypes/test/test_python_api.py --- a/Lib/ctypes/test/test_python_api.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_python_api.py Mon Nov 19 12:28:22 2012 +0200 @@ -64,7 +64,7 @@ ref = grc(s) # id(python-object) is the address pyobj = PyObj_FromPtr(id(s)) - self.assertTrue(s is pyobj) + self.assertIs(s, pyobj) self.assertEqual(grc(s), ref + 1) del pyobj diff -r cf606c403f14 Lib/ctypes/test/test_refcounts.py --- a/Lib/ctypes/test/test_refcounts.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_refcounts.py Mon Nov 19 12:28:22 2012 +0200 @@ -26,7 +26,7 @@ self.assertEqual(grc(callback), 2) cb = MyCallback(callback) - self.assertTrue(grc(callback) > 2) + self.assertGreater(grc(callback), 2) result = f(-10, cb) self.assertEqual(result, -18) cb = None @@ -46,15 +46,15 @@ # the CFuncPtr instance holds atr least one refcount on func: f = OtherCallback(func) - self.assertTrue(grc(func) > 2) + self.assertGreater(grc(func), 2) # and may release it again del f - self.assertTrue(grc(func) >= 2) + self.assertGreaterEqual(grc(func), 2) # but now it must be gone gc.collect() - self.assertTrue(grc(func) == 2) + self.assertEqual(grc(func), 2) class X(ctypes.Structure): _fields_ = [("a", OtherCallback)] @@ -62,11 +62,11 @@ x.a = OtherCallback(func) # the CFuncPtr instance holds atr least one refcount on func: - self.assertTrue(grc(func) > 2) + self.assertGreater(grc(func), 2) # and may release it again del x - self.assertTrue(grc(func) >= 2) + self.assertGreaterEqual(grc(func), 2) # and now it must be gone again gc.collect() @@ -75,7 +75,7 @@ f = OtherCallback(func) # the CFuncPtr instance holds atr least one refcount on func: - self.assertTrue(grc(func) > 2) + self.assertGreater(grc(func), 2) # create a cycle f.cycle = f diff -r cf606c403f14 Lib/ctypes/test/test_strings.py --- a/Lib/ctypes/test/test_strings.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_strings.py Mon Nov 19 12:28:22 2012 +0200 @@ -115,24 +115,24 @@ # New in releases later than 0.4.0: # c_string(number) returns an empty string of size number - self.assertTrue(len(c_string(32).raw) == 32) + self.assertEqual(len(c_string(32).raw), 32) self.assertRaises(ValueError, c_string, -1) self.assertRaises(ValueError, c_string, 0) # These tests fail, because it is no longer initialized -## self.assertTrue(c_string(2).value == "") -## self.assertTrue(c_string(2).raw == "\000\000") - self.assertTrue(c_string(2).raw[-1] == "\000") - self.assertTrue(len(c_string(2).raw) == 2) +## self.assertEqual(c_string(2).value, "") +## self.assertEqual(c_string(2).raw, "\000\000") + self.assertEqual(c_string(2).raw[-1], "\000") + self.assertEqual(len(c_string(2).raw), 2) def XX_test_initialized_strings(self): - self.assertTrue(c_string("ab", 4).raw[:2] == "ab") - self.assertTrue(c_string("ab", 4).raw[:2:] == "ab") - self.assertTrue(c_string("ab", 4).raw[:2:-1] == "ba") - self.assertTrue(c_string("ab", 4).raw[:2:2] == "a") - self.assertTrue(c_string("ab", 4).raw[-1] == "\000") - self.assertTrue(c_string("ab", 2).raw == "a\000") + self.assertEqual(c_string("ab", 4).raw[:2], "ab") + self.assertEqual(c_string("ab", 4).raw[:2:], "ab") + self.assertEqual(c_string("ab", 4).raw[:2:-1], "ba") + self.assertEqual(c_string("ab", 4).raw[:2:2], "a") + self.assertEqual(c_string("ab", 4).raw[-1], "\000") + self.assertEqual(c_string("ab", 2).raw, "a\000") def XX_test_toolong(self): cs = c_string("abcdef") @@ -163,22 +163,22 @@ # XXX This behaviour is about to change: # len returns the size of the internal buffer in bytes. # This includes the terminating NUL character. - self.assertTrue(sizeof(cs) == 14) + self.assertEqual(sizeof(cs), 14) # The value property is the string up to the first terminating NUL. - self.assertTrue(cs.value == "abcdef") - self.assertTrue(c_wstring("abc\000def").value == "abc") + self.assertEqual(cs.value, "abcdef") + self.assertEqual(c_wstring("abc\000def").value, "abc") - self.assertTrue(c_wstring("abc\000def").value == "abc") + self.assertEqual(c_wstring("abc\000def").value, "abc") # The raw property is the total buffer contents: - self.assertTrue(cs.raw == "abcdef\000") - self.assertTrue(c_wstring("abc\000def").raw == "abc\000def\000") + self.assertEqual(cs.raw, "abcdef\000") + self.assertEqual(c_wstring("abc\000def").raw, "abc\000def\000") # We can change the value: cs.value = "ab" - self.assertTrue(cs.value == "ab") - self.assertTrue(cs.raw == "ab\000\000\000\000\000") + self.assertEqual(cs.value, "ab") + self.assertEqual(cs.raw, "ab\000\000\000\000\000") self.assertRaises(TypeError, c_wstring, "123") self.assertRaises(ValueError, c_wstring, 0) diff -r cf606c403f14 Lib/ctypes/test/test_structures.py --- a/Lib/ctypes/test/test_structures.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/ctypes/test/test_structures.py Mon Nov 19 12:28:22 2012 +0200 @@ -365,9 +365,9 @@ ## class X(Structure): ## _fields_ = [] - self.assertTrue("in_dll" in dir(type(Structure))) - self.assertTrue("from_address" in dir(type(Structure))) - self.assertTrue("in_dll" in dir(type(Structure))) + self.assertIn("in_dll", dir(type(Structure))) + self.assertIn("from_address", dir(type(Structure))) + self.assertIn("in_dll", dir(type(Structure))) def test_positional_args(self): # see also http://bugs.python.org/issue5042 @@ -437,7 +437,7 @@ try: Recursive._fields_ = [("next", Recursive)] except AttributeError as details: - self.assertTrue("Structure or union cannot contain itself" in + self.assertIn("Structure or union cannot contain itself", str(details)) else: self.fail("Structure or union cannot contain itself") @@ -454,7 +454,7 @@ try: Second._fields_ = [("first", First)] except AttributeError as details: - self.assertTrue("_fields_ is final" in + self.assertIn("_fields_ is final", str(details)) else: self.fail("AttributeError not raised") diff -r cf606c403f14 Lib/distutils/tests/test_archive_util.py --- a/Lib/distutils/tests/test_archive_util.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_archive_util.py Mon Nov 19 12:28:22 2012 +0200 @@ -210,7 +210,7 @@ dry_run=True) finally: os.chdir(old_dir) - self.assertTrue(not os.path.exists(tarball)) + self.assertFalse(os.path.exists(tarball)) self.assertEqual(len(w.warnings), 1) @unittest.skipUnless(ZIP_SUPPORT and ZLIB_SUPPORT, diff -r cf606c403f14 Lib/distutils/tests/test_bdist_rpm.py --- a/Lib/distutils/tests/test_bdist_rpm.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_bdist_rpm.py Mon Nov 19 12:28:22 2012 +0200 @@ -81,7 +81,7 @@ cmd.run() dist_created = os.listdir(os.path.join(pkg_dir, 'dist')) - self.assertTrue('foo-0.1-1.noarch.rpm' in dist_created) + self.assertIn('foo-0.1-1.noarch.rpm', dist_created) # bug #2945: upload ignores bdist_rpm files self.assertIn(('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm'), dist.dist_files) @@ -125,7 +125,7 @@ cmd.run() dist_created = os.listdir(os.path.join(pkg_dir, 'dist')) - self.assertTrue('foo-0.1-1.noarch.rpm' in dist_created) + self.assertIn('foo-0.1-1.noarch.rpm', dist_created) # bug #2945: upload ignores bdist_rpm files self.assertIn(('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm'), dist.dist_files) diff -r cf606c403f14 Lib/distutils/tests/test_bdist_wininst.py --- a/Lib/distutils/tests/test_bdist_wininst.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_bdist_wininst.py Mon Nov 19 12:28:22 2012 +0200 @@ -22,7 +22,7 @@ # and make sure it finds it and returns its content # no matter what platform we have exe_file = cmd.get_exe_bytes() - self.assertTrue(len(exe_file) > 10) + self.assertGreater(len(exe_file), 10) def test_suite(): return unittest.makeSuite(BuildWinInstTestCase) diff -r cf606c403f14 Lib/distutils/tests/test_build_clib.py --- a/Lib/distutils/tests/test_build_clib.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_build_clib.py Mon Nov 19 12:28:22 2012 +0200 @@ -137,7 +137,7 @@ cmd.run() # let's check the result - self.assertTrue('libfoo.a' in os.listdir(build_temp)) + self.assertIn('libfoo.a', os.listdir(build_temp)) def test_suite(): return unittest.makeSuite(BuildCLibTestCase) diff -r cf606c403f14 Lib/distutils/tests/test_build_ext.py --- a/Lib/distutils/tests/test_build_ext.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_build_ext.py Mon Nov 19 12:28:22 2012 +0200 @@ -75,8 +75,8 @@ self.assertEqual(xx.new().demo(), None) doc = 'This is a template module just for instruction.' self.assertEqual(xx.__doc__, doc) - self.assertTrue(isinstance(xx.Null(), xx.Null)) - self.assertTrue(isinstance(xx.Str(), xx.Str)) + self.assertIsInstance(xx.Null(), xx.Null) + self.assertIsInstance(xx.Str(), xx.Str) def tearDown(self): # Get everything back to normal @@ -109,7 +109,7 @@ _config_vars['Py_ENABLE_SHARED'] = old_var # make sure we get some library dirs under solaris - self.assertTrue(len(cmd.library_dirs) > 0) + self.assertGreater(len(cmd.library_dirs), 0) def test_user_site(self): # site.USER_SITE was introduced in 2.6 @@ -123,7 +123,7 @@ # making sure the user option is there options = [name for name, short, lable in cmd.user_options] - self.assertTrue('user' in options) + self.assertIn('user', options) # setting a value cmd.user = 1 @@ -170,10 +170,10 @@ from distutils import sysconfig py_include = sysconfig.get_python_inc() - self.assertTrue(py_include in cmd.include_dirs) + self.assertIn(py_include, cmd.include_dirs) plat_py_include = sysconfig.get_python_inc(plat_specific=1) - self.assertTrue(plat_py_include in cmd.include_dirs) + self.assertIn(plat_py_include, cmd.include_dirs) # make sure cmd.libraries is turned into a list # if it's a string @@ -254,13 +254,13 @@ 'some': 'bar'})] cmd.check_extensions_list(exts) ext = exts[0] - self.assertTrue(isinstance(ext, Extension)) + self.assertIsInstance(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.assertEqual(ext.libraries, 'foo') - self.assertTrue(not hasattr(ext, 'some')) + self.assertFalse(hasattr(ext, 'some')) # 'macros' element of build info dict must be 1- or 2-tuple exts = [('foo.bar', {'sources': [''], 'libraries': 'foo', diff -r cf606c403f14 Lib/distutils/tests/test_build_scripts.py --- a/Lib/distutils/tests/test_build_scripts.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_build_scripts.py Mon Nov 19 12:28:22 2012 +0200 @@ -17,8 +17,8 @@ def test_default_settings(self): cmd = self.get_build_scripts_cmd("/foo/bar", []) - self.assertTrue(not cmd.force) - self.assertTrue(cmd.build_dir is None) + self.assertFalse(cmd.force) + self.assertIsNone(cmd.build_dir) cmd.finalize_options() @@ -38,7 +38,7 @@ built = os.listdir(target) for name in expected: - self.assertTrue(name in built) + self.assertIn(name, built) def get_build_scripts_cmd(self, target, scripts): import sys @@ -103,7 +103,7 @@ built = os.listdir(target) for name in expected: - self.assertTrue(name in built) + self.assertIn(name, built) def test_suite(): return unittest.makeSuite(BuildScriptsTestCase) diff -r cf606c403f14 Lib/distutils/tests/test_clean.py --- a/Lib/distutils/tests/test_clean.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_clean.py Mon Nov 19 12:28:22 2012 +0200 @@ -36,7 +36,7 @@ # make sure the files where removed for name, path in dirs: - self.assertTrue(not os.path.exists(path), + self.assertFalse(os.path.exists(path), '%s was not removed' % path) # let's run the command again (should spit warnings but succeed) diff -r cf606c403f14 Lib/distutils/tests/test_config.py --- a/Lib/distutils/tests/test_config.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_config.py Mon Nov 19 12:28:22 2012 +0200 @@ -103,7 +103,7 @@ def test_server_empty_registration(self): cmd = self._cmd(self.dist) rc = cmd._get_rc_file() - self.assertTrue(not os.path.exists(rc)) + self.assertFalse(os.path.exists(rc)) cmd._store_pypirc('tarek', 'xxx') self.assertTrue(os.path.exists(rc)) f = open(rc) diff -r cf606c403f14 Lib/distutils/tests/test_config_cmd.py --- a/Lib/distutils/tests/test_config_cmd.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_config_cmd.py Mon Nov 19 12:28:22 2012 +0200 @@ -81,7 +81,7 @@ cmd._clean(f1, f2) for f in (f1, f2): - self.assertTrue(not os.path.exists(f)) + self.assertFalse(os.path.exists(f)) def test_suite(): return unittest.makeSuite(ConfigTestCase) diff -r cf606c403f14 Lib/distutils/tests/test_install.py --- a/Lib/distutils/tests/test_install.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_install.py Mon Nov 19 12:28:22 2012 +0200 @@ -236,7 +236,7 @@ self.test_record() finally: install_module.DEBUG = False - self.assertTrue(len(self.logs) > old_logs_len) + self.assertGreater(len(self.logs), old_logs_len) def test_suite(): diff -r cf606c403f14 Lib/distutils/tests/test_install_lib.py --- a/Lib/distutils/tests/test_install_lib.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_install_lib.py Mon Nov 19 12:28:22 2012 +0200 @@ -103,7 +103,7 @@ finally: sys.dont_write_bytecode = old_dont_write_bytecode - self.assertTrue('byte-compiling is disabled' in self.logs[0][1]) + self.assertIn('byte-compiling is disabled', self.logs[0][1]) def test_suite(): diff -r cf606c403f14 Lib/distutils/tests/test_install_scripts.py --- a/Lib/distutils/tests/test_install_scripts.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_install_scripts.py Mon Nov 19 12:28:22 2012 +0200 @@ -24,10 +24,10 @@ skip_build=1, ) cmd = install_scripts(dist) - 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) + self.assertFalse(cmd.force) + self.assertFalse(cmd.skip_build) + self.assertIsNone(cmd.build_dir) + self.assertIsNone(cmd.install_dir) cmd.finalize_options() @@ -72,7 +72,7 @@ installed = os.listdir(target) for name in expected: - self.assertTrue(name in installed) + self.assertIn(name, installed) def test_suite(): diff -r cf606c403f14 Lib/distutils/tests/test_msvc9compiler.py --- a/Lib/distutils/tests/test_msvc9compiler.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_msvc9compiler.py Mon Nov 19 12:28:22 2012 +0200 @@ -128,7 +128,7 @@ # windows registeries versions. path = r'Control Panel\Desktop' v = Reg.get_value(path, 'dragfullwindows') - self.assertTrue(v in ('0', '1', '2')) + self.assertIn(v, ('0', '1', '2')) import winreg HKCU = winreg.HKEY_CURRENT_USER @@ -136,7 +136,7 @@ self.assertEqual(keys, None) keys = Reg.read_keys(HKCU, r'Control Panel') - self.assertTrue('Desktop' in keys) + self.assertIn('Desktop', keys) def test_remove_visual_c_ref(self): from distutils.msvc9compiler import MSVCCompiler @@ -174,7 +174,7 @@ compiler = MSVCCompiler() got = compiler._remove_visual_c_ref(manifest) - self.assertIs(got, None) + self.assertIsNone(got) def test_suite(): diff -r cf606c403f14 Lib/distutils/tests/test_register.py --- a/Lib/distutils/tests/test_register.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_register.py Mon Nov 19 12:28:22 2012 +0200 @@ -96,7 +96,7 @@ cmd = self._get_cmd() # we shouldn't have a .pypirc file yet - self.assertTrue(not os.path.exists(self.rc)) + self.assertFalse(os.path.exists(self.rc)) # patching input and getpass.getpass # so register gets happy @@ -143,7 +143,7 @@ self.assertEqual(req1['Content-length'], '1374') self.assertEqual(req2['Content-length'], '1374') - self.assertTrue((b'xxx') in self.conn.reqs[1].data) + self.assertIn(b'xxx', self.conn.reqs[1].data) def test_password_not_in_file(self): @@ -173,7 +173,7 @@ req = self.conn.reqs[0] headers = dict(req.headers) self.assertEqual(headers['Content-length'], '608') - self.assertTrue((b'tarek') in req.data) + self.assertIn(b'tarek', req.data) def test_password_reset(self): # this test runs choice 3 @@ -191,7 +191,7 @@ req = self.conn.reqs[0] headers = dict(req.headers) self.assertEqual(headers['Content-length'], '290') - self.assertTrue((b'tarek') in req.data) + self.assertIn(b'tarek', req.data) def test_strict(self): # testing the script option diff -r cf606c403f14 Lib/distutils/tests/test_sysconfig.py --- a/Lib/distutils/tests/test_sysconfig.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_sysconfig.py Mon Nov 19 12:28:22 2012 +0200 @@ -50,7 +50,7 @@ def test_get_config_vars(self): cvars = sysconfig.get_config_vars() - self.assertTrue(isinstance(cvars, dict)) + self.assertIsInstance(cvars, dict) self.assertTrue(cvars) def test_srcdir(self): diff -r cf606c403f14 Lib/distutils/tests/test_upload.py --- a/Lib/distutils/tests/test_upload.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_upload.py Mon Nov 19 12:28:22 2012 +0200 @@ -126,10 +126,10 @@ headers = dict(self.conn.headers) self.assertEqual(headers['Content-length'], '2087') self.assertTrue(headers['Content-type'].startswith('multipart/form-data')) - self.assertFalse('\n' in headers['Authorization']) + self.assertNotIn('\n', headers['Authorization']) self.assertEqual(self.conn.requests, [('POST', '/pypi')]) - self.assertTrue((b'xxx') in self.conn.body) + self.assertIn(b'xxx', self.conn.body) def test_suite(): return unittest.makeSuite(uploadTestCase) diff -r cf606c403f14 Lib/distutils/tests/test_util.py --- a/Lib/distutils/tests/test_util.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/distutils/tests/test_util.py Mon Nov 19 12:28:22 2012 +0200 @@ -266,7 +266,7 @@ self.assertTrue(strtobool(y)) for n in no: - self.assertTrue(not strtobool(n)) + self.assertFalse(strtobool(n)) def test_rfc822_escape(self): header = 'I am a\npoor\nlonesome\nheader\n' diff -r cf606c403f14 Lib/lib2to3/tests/test_fixers.py --- a/Lib/lib2to3/tests/test_fixers.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/lib2to3/tests/test_fixers.py Mon Nov 19 12:28:22 2012 +0200 @@ -41,7 +41,7 @@ def warns(self, before, after, message, unchanged=False): tree = self._check(before, after) - self.assertTrue(message in "".join(self.fixer_log)) + self.assertIn(message, "".join(self.fixer_log)) if not unchanged: self.assertTrue(tree.was_changed) diff -r cf606c403f14 Lib/lib2to3/tests/test_main.py --- a/Lib/lib2to3/tests/test_main.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/lib2to3/tests/test_main.py Mon Nov 19 12:28:22 2012 +0200 @@ -49,9 +49,9 @@ ret = self.run_2to3_capture(["-"], input_stream, out_enc, err) self.assertEqual(ret, 0) output = out.getvalue().decode("ascii") - self.assertTrue("-print 'nothing'" in output) - self.assertTrue("WARNING: couldn't encode 's diff for " - "your terminal" in err.getvalue()) + self.assertIn("-print 'nothing'", output) + self.assertIn("WARNING: couldn't encode 's diff for " + "your terminal", err.getvalue()) def setup_test_source_trees(self): """Setup a test source tree and output destination tree.""" diff -r cf606c403f14 Lib/lib2to3/tests/test_parser.py --- a/Lib/lib2to3/tests/test_parser.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/lib2to3/tests/test_parser.py Mon Nov 19 12:28:22 2012 +0200 @@ -168,7 +168,7 @@ for filepath in support.all_project_files(): with open(filepath, "rb") as fp: encoding = tokenize.detect_encoding(fp.readline)[0] - self.assertTrue(encoding is not None, + self.assertIsNotNone(encoding, "can't detect encoding for %s" % filepath) with open(filepath, "r", encoding=encoding) as fp: source = fp.read() diff -r cf606c403f14 Lib/lib2to3/tests/test_pytree.py --- a/Lib/lib2to3/tests/test_pytree.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/lib2to3/tests/test_pytree.py Mon Nov 19 12:28:22 2012 +0200 @@ -143,12 +143,12 @@ l3 = pytree.Leaf(100, "bar") n1 = pytree.Node(1000, [l1, l2, l3]) self.assertEqual(n1.children, [l1, l2, l3]) - self.assertTrue(isinstance(n1.children, list)) + self.assertIsInstance(n1.children, list) self.assertFalse(n1.was_changed) l2new = pytree.Leaf(100, "-") l2.replace(l2new) self.assertEqual(n1.children, [l1, l2new, l3]) - self.assertTrue(isinstance(n1.children, list)) + self.assertIsInstance(n1.children, list) self.assertTrue(n1.was_changed) def test_replace_with_list(self): @@ -159,7 +159,7 @@ l2.replace([pytree.Leaf(100, "*"), pytree.Leaf(100, "*")]) self.assertEqual(str(n1), "foo**bar") - self.assertTrue(isinstance(n1.children, list)) + self.assertIsInstance(n1.children, list) def test_leaves(self): l1 = pytree.Leaf(100, "foo") @@ -330,7 +330,7 @@ n2 = pytree.Node(1000, []) p1 = pytree.Node(1000, [n1, n2]) - self.assertTrue(n1.next_sibling is n2) + self.assertIs(n1.next_sibling, n2) self.assertEqual(n2.next_sibling, None) self.assertEqual(p1.next_sibling, None) @@ -339,7 +339,7 @@ l2 = pytree.Leaf(100, "b") p1 = pytree.Node(1000, [l1, l2]) - self.assertTrue(l1.next_sibling is l2) + self.assertIs(l1.next_sibling, l2) self.assertEqual(l2.next_sibling, None) self.assertEqual(p1.next_sibling, None) @@ -348,7 +348,7 @@ n2 = pytree.Node(1000, []) p1 = pytree.Node(1000, [n1, n2]) - self.assertTrue(n2.prev_sibling is n1) + self.assertIs(n2.prev_sibling, n1) self.assertEqual(n1.prev_sibling, None) self.assertEqual(p1.prev_sibling, None) @@ -357,7 +357,7 @@ l2 = pytree.Leaf(100, "b") p1 = pytree.Node(1000, [l1, l2]) - self.assertTrue(l2.prev_sibling is l1) + self.assertIs(l2.prev_sibling, l1) self.assertEqual(l1.prev_sibling, None) self.assertEqual(p1.prev_sibling, None) @@ -430,7 +430,7 @@ r = {} self.assertTrue(pw.match_seq([l1, l3], r)) self.assertEqual(r, {"pl": l3, "pw": [l1, l3]}) - self.assertTrue(r["pl"] is l3) + self.assertIs(r["pl"], l3) r = {} def test_generate_matches(self): diff -r cf606c403f14 Lib/lib2to3/tests/test_refactor.py --- a/Lib/lib2to3/tests/test_refactor.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/lib2to3/tests/test_refactor.py Mon Nov 19 12:28:22 2012 +0200 @@ -49,8 +49,8 @@ def test_print_function_option(self): rt = self.rt({"print_function" : True}) - self.assertTrue(rt.grammar is pygram.python_grammar_no_print_statement) - self.assertTrue(rt.driver.grammar is + self.assertIs(rt.grammar, pygram.python_grammar_no_print_statement) + self.assertIs(rt.driver.grammar, pygram.python_grammar_no_print_statement) def test_write_unchanged_files_option(self): diff -r cf606c403f14 Lib/sqlite3/test/factory.py --- a/Lib/sqlite3/test/factory.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/sqlite3/test/factory.py Mon Nov 19 12:28:22 2012 +0200 @@ -47,9 +47,7 @@ self.con.close() def CheckIsInstance(self): - self.assertTrue(isinstance(self.con, - MyConnection), - "connection is not instance of MyConnection") + self.assertIsInstance(self.con, MyConnection) class CursorFactoryTests(unittest.TestCase): def setUp(self): @@ -60,9 +58,7 @@ def CheckIsInstance(self): cur = self.con.cursor(factory=MyCursor) - self.assertTrue(isinstance(cur, - MyCursor), - "cursor is not instance of MyCursor") + self.assertIsInstance(cur, MyCursor) class RowFactoryTestsBackwardsCompat(unittest.TestCase): def setUp(self): @@ -72,9 +68,7 @@ cur = self.con.cursor(factory=MyCursor) cur.execute("select 4+5 as foo") row = cur.fetchone() - self.assertTrue(isinstance(row, - dict), - "row is not instance of dict") + self.assertIsInstance(row, dict) cur.close() def tearDown(self): @@ -87,28 +81,24 @@ def CheckCustomFactory(self): self.con.row_factory = lambda cur, row: list(row) row = self.con.execute("select 1, 2").fetchone() - self.assertTrue(isinstance(row, - list), - "row is not instance of list") + self.assertIsInstance(row, list) def CheckSqliteRowIndex(self): self.con.row_factory = sqlite.Row row = self.con.execute("select 1 as a, 2 as b").fetchone() - self.assertTrue(isinstance(row, - sqlite.Row), - "row is not instance of sqlite.Row") + self.assertIsInstance(row, sqlite.Row) col1, col2 = row["a"], row["b"] - self.assertTrue(col1 == 1, "by name: wrong result for column 'a'") - self.assertTrue(col2 == 2, "by name: wrong result for column 'a'") + self.assertEqual(col1, 1, "by name: wrong result for column 'a'") + self.assertEqual(col2, 2, "by name: wrong result for column 'a'") col1, col2 = row["A"], row["B"] - self.assertTrue(col1 == 1, "by name: wrong result for column 'A'") - self.assertTrue(col2 == 2, "by name: wrong result for column 'B'") + self.assertEqual(col1, 1, "by name: wrong result for column 'A'") + self.assertEqual(col2, 2, "by name: wrong result for column 'B'") col1, col2 = row[0], row[1] - self.assertTrue(col1 == 1, "by index: wrong result for column 0") - self.assertTrue(col2 == 2, "by index: wrong result for column 1") + self.assertEqual(col1, 1, "by index: wrong result for column 0") + self.assertEqual(col2, 2, "by index: wrong result for column 1") def CheckSqliteRowIter(self): """Checks if the row object is iterable""" @@ -138,8 +128,8 @@ row_2 = self.con.execute("select 1 as a, 2 as b").fetchone() row_3 = self.con.execute("select 1 as a, 3 as b").fetchone() - self.assertTrue(row_1 == row_1) - self.assertTrue(row_1 == row_2) + self.assertEqual(row_1, row_1) + self.assertEqual(row_1, row_2) self.assertTrue(row_2 != row_3) self.assertFalse(row_1 != row_1) @@ -161,20 +151,20 @@ def CheckUnicode(self): austria = "Österreich" row = self.con.execute("select ?", (austria,)).fetchone() - self.assertTrue(type(row[0]) == str, "type of row[0] must be unicode") + self.assertEqual(type(row[0]), str, "type of row[0] must be unicode") def CheckString(self): self.con.text_factory = bytes austria = "Österreich" row = self.con.execute("select ?", (austria,)).fetchone() - self.assertTrue(type(row[0]) == bytes, "type of row[0] must be bytes") - self.assertTrue(row[0] == austria.encode("utf-8"), "column must equal original data in UTF-8") + self.assertEqual(type(row[0]), bytes, "type of row[0] must be bytes") + self.assertEqual(row[0], austria.encode("utf-8"), "column must equal original data in UTF-8") def CheckCustom(self): self.con.text_factory = lambda x: str(x, "utf-8", "ignore") austria = "Österreich" row = self.con.execute("select ?", (austria,)).fetchone() - self.assertTrue(type(row[0]) == str, "type of row[0] must be unicode") + self.assertEqual(type(row[0]), str, "type of row[0] must be unicode") self.assertTrue(row[0].endswith("reich"), "column must contain original data") def CheckOptimizedUnicode(self): @@ -185,8 +175,8 @@ germany = "Deutchland" a_row = self.con.execute("select ?", (austria,)).fetchone() d_row = self.con.execute("select ?", (germany,)).fetchone() - self.assertTrue(type(a_row[0]) == str, "type of non-ASCII row must be str") - self.assertTrue(type(d_row[0]) == str, "type of ASCII-only row must be str") + self.assertEqual(type(a_row[0]), str, "type of non-ASCII row must be str") + self.assertEqual(type(d_row[0]), str, "type of ASCII-only row must be str") def tearDown(self): self.con.close() diff -r cf606c403f14 Lib/sqlite3/test/hooks.py --- a/Lib/sqlite3/test/hooks.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/sqlite3/test/hooks.py Mon Nov 19 12:28:22 2012 +0200 @@ -143,7 +143,7 @@ create table bar (a, b) """) second_count = len(progress_calls) - self.assertTrue(first_count > second_count) + self.assertGreater(first_count, second_count) def CheckCancelOperation(self): """ diff -r cf606c403f14 Lib/test/datetimetester.py --- a/Lib/test/datetimetester.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/datetimetester.py Mon Nov 19 12:28:22 2012 +0200 @@ -115,11 +115,11 @@ # carry no data), but they need to be picklable anyway else # concrete subclasses can't be pickled. orig = tzinfo.__new__(tzinfo) - self.assertTrue(type(orig) is tzinfo) + self.assertIs(type(orig), tzinfo) for pickler, unpickler, proto in pickle_choices: green = pickler.dumps(orig, proto) derived = unpickler.loads(green) - self.assertTrue(type(derived) is tzinfo) + self.assertIs(type(derived), tzinfo) def test_pickling_subclass(self): # Make sure we can pickle/unpickle an instance of a subclass. @@ -479,9 +479,9 @@ self.assertEqual(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) + self.assertFalse(t1 != t2) + self.assertFalse(t1 < t2) + self.assertFalse(t1 > t2) for args in (3, 3, 3), (2, 4, 4), (2, 3, 5): t2 = timedelta(*args) # this is larger than t1 @@ -491,12 +491,12 @@ 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) + self.assertFalse(t1 == t2) + self.assertFalse(t2 == t1) + self.assertFalse(t1 > t2) + self.assertFalse(t2 < t1) + self.assertFalse(t1 >= t2) + self.assertFalse(t2 <= t1) for badarg in OTHERSTUFF: self.assertEqual(t1 == badarg, False) @@ -629,7 +629,7 @@ self.assertTrue(timedelta(0, 1)) self.assertTrue(timedelta(0, 0, 1)) self.assertTrue(timedelta(microseconds=1)) - self.assertTrue(not timedelta(0)) + self.assertFalse(timedelta(0)) def test_subclass_timedelta(self): @@ -645,17 +645,17 @@ return round(sum) t1 = T(days=1) - self.assertTrue(type(t1) is T) + self.assertIs(type(t1), T) self.assertEqual(t1.as_hours(), 24) t2 = T(days=-1, seconds=-3600) - self.assertTrue(type(t2) is T) + self.assertIs(type(t2), T) self.assertEqual(t2.as_hours(), -25) t3 = t1 + t2 - self.assertTrue(type(t3) is timedelta) + self.assertIs(type(t3), timedelta) t4 = T.from_td(t3) - self.assertTrue(type(t4) is T) + self.assertIs(type(t4), T) self.assertEqual(t3.days, t4.days) self.assertEqual(t3.seconds, t4.seconds) self.assertEqual(t3.microseconds, t4.microseconds) @@ -1007,8 +1007,8 @@ # 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.assertTrue(today == todayagain or - abs(todayagain - today) < timedelta(seconds=0.5)) + if today != todayagain: + self.assertAlmostEqual(todayagain, today, delta=timedelta(seconds=0.5)) def test_weekday(self): for i in range(7): @@ -1202,9 +1202,9 @@ self.assertEqual(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) + self.assertFalse(t1 != t2) + self.assertFalse(t1 < t2) + self.assertFalse(t1 > t2) for args in (3, 3, 3), (2, 4, 4), (2, 3, 5): t2 = self.theclass(*args) # this is larger than t1 @@ -1214,12 +1214,12 @@ 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) + self.assertFalse(t1 == t2) + self.assertFalse(t2 == t1) + self.assertFalse(t1 > t2) + self.assertFalse(t2 < t1) + self.assertFalse(t1 >= t2) + self.assertFalse(t2 <= t1) for badarg in OTHERSTUFF: self.assertEqual(t1 == badarg, False) @@ -1690,9 +1690,9 @@ self.assertEqual(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) + self.assertFalse(t1 != t2) + self.assertFalse(t1 < t2) + self.assertFalse(t1 > t2) for i in range(len(args)): newargs = args[:] @@ -1704,12 +1704,12 @@ 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) + self.assertFalse(t1 == t2) + self.assertFalse(t2 == t1) + self.assertFalse(t1 > t2) + self.assertFalse(t2 < t1) + self.assertFalse(t1 >= t2) + self.assertFalse(t2 <= t1) # A helper for timestamp constructor tests. @@ -1846,7 +1846,7 @@ if abs(from_timestamp - from_now) <= tolerance: break # Else try again a few times. - self.assertTrue(abs(from_timestamp - from_now) <= tolerance) + self.assertLessEqual(abs(from_timestamp - from_now), tolerance) def test_strptime(self): string = '2004-12-01 13:02:47.197' @@ -2072,9 +2072,9 @@ self.assertEqual(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) + self.assertFalse(t1 != t2) + self.assertFalse(t1 < t2) + self.assertFalse(t1 > t2) for i in range(len(args)): newargs = args[:] @@ -2086,12 +2086,12 @@ 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) + self.assertFalse(t1 == t2) + self.assertFalse(t2 == t1) + self.assertFalse(t1 > t2) + self.assertFalse(t2 < t1) + self.assertFalse(t1 >= t2) + self.assertFalse(t2 <= t1) for badarg in OTHERSTUFF: self.assertEqual(t1 == badarg, False) @@ -2269,8 +2269,8 @@ 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()) + self.assertFalse(cls(0)) + self.assertFalse(cls()) def test_replace(self): cls = self.theclass @@ -2367,7 +2367,7 @@ def utcoffset(self, dt): pass b = BetterTry() t = cls(1, 1, 1, tzinfo=b) - self.assertTrue(t.tzinfo is b) + self.assertIs(t.tzinfo, b) def test_utc_offset_out_of_bounds(self): class Edgy(tzinfo): @@ -2406,9 +2406,9 @@ for t in (cls(1, 1, 1), cls(1, 1, 1, tzinfo=None), cls(1, 1, 1, tzinfo=C1())): - self.assertTrue(t.utcoffset() is None) - self.assertTrue(t.dst() is None) - self.assertTrue(t.tzname() is None) + self.assertIsNone(t.utcoffset()) + self.assertIsNone(t.dst()) + self.assertIsNone(t.tzname()) class C3(tzinfo): def utcoffset(self, dt): return timedelta(minutes=-1439) @@ -2503,7 +2503,7 @@ self.assertEqual(t.minute, 0) self.assertEqual(t.second, 0) self.assertEqual(t.microsecond, 0) - self.assertTrue(t.tzinfo is None) + self.assertIsNone(t.tzinfo) def test_zones(self): est = FixedOffset(-300, "EST", 1) @@ -2518,25 +2518,25 @@ self.assertEqual(t1.tzinfo, est) self.assertEqual(t2.tzinfo, utc) self.assertEqual(t3.tzinfo, met) - self.assertTrue(t4.tzinfo is None) + self.assertIsNone(t4.tzinfo) 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.assertTrue(t4.utcoffset() is None) + self.assertIsNone(t4.utcoffset()) self.assertRaises(TypeError, t1.utcoffset, "no args") self.assertEqual(t1.tzname(), "EST") self.assertEqual(t2.tzname(), "UTC") self.assertEqual(t3.tzname(), "MET") - self.assertTrue(t4.tzname() is None) + self.assertIsNone(t4.tzname()) 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.assertTrue(t4.dst() is None) + self.assertIsNone(t4.dst()) self.assertRaises(TypeError, t1.dst, "no args") self.assertEqual(hash(t1), hash(t2)) @@ -2633,10 +2633,10 @@ self.assertTrue(t) t = cls(5, tzinfo=FixedOffset(300, "")) - self.assertTrue(not t) + self.assertFalse(t) t = cls(23, 59, tzinfo=FixedOffset(23*60 + 59, "")) - self.assertTrue(not t) + self.assertFalse(t) # Mostly ensuring this doesn't overflow internally. t = cls(0, tzinfo=FixedOffset(23*60 + 59, "")) @@ -2674,13 +2674,13 @@ # Ensure we can get rid of a tzinfo. self.assertEqual(base.tzname(), "+100") base2 = base.replace(tzinfo=None) - self.assertTrue(base2.tzinfo is None) - self.assertTrue(base2.tzname() is None) + self.assertIsNone(base2.tzinfo) + self.assertIsNone(base2.tzname()) # Ensure we can add one. base3 = base2.replace(tzinfo=z100) self.assertEqual(base, base3) - self.assertTrue(base.tzinfo is base3.tzinfo) + self.assertIs(base.tzinfo, base3.tzinfo) # Out of bounds. base = cls(1) @@ -2915,7 +2915,7 @@ tz55 = FixedOffset(-330, "west 5:30") timeaware = now.time().replace(tzinfo=tz55) nowaware = self.theclass.combine(now.date(), timeaware) - self.assertTrue(nowaware.tzinfo is tz55) + self.assertIs(nowaware.tzinfo, tz55) self.assertEqual(nowaware.timetz(), timeaware) # Can't mix aware and non-aware. @@ -2934,15 +2934,15 @@ # Adding a delta should preserve tzinfo. delta = timedelta(weeks=1, minutes=12, microseconds=5678) nowawareplus = nowaware + delta - self.assertTrue(nowaware.tzinfo is tz55) + self.assertIs(nowaware.tzinfo, tz55) nowawareplus2 = delta + nowaware - self.assertTrue(nowawareplus2.tzinfo is tz55) + self.assertIs(nowawareplus2.tzinfo, 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.assertTrue(diff.tzinfo is tz55) + self.assertIs(diff.tzinfo, tz55) self.assertEqual(nowaware, diff) self.assertRaises(TypeError, lambda: delta - nowawareplus) self.assertEqual(nowawareplus - nowaware, delta) @@ -2951,7 +2951,7 @@ tzr = FixedOffset(random.randrange(-1439, 1440), "randomtimezone") # Attach it to nowawareplus. nowawareplus = nowawareplus.replace(tzinfo=tzr) - self.assertTrue(nowawareplus.tzinfo is tzr) + self.assertIs(nowawareplus.tzinfo, tzr) # Make sure the difference takes the timezone adjustments into account. got = nowaware - nowawareplus # Expected: (nowaware base - nowaware offset) - @@ -2983,7 +2983,7 @@ off42 = FixedOffset(42, "42") another = meth(off42) again = meth(tz=off42) - self.assertTrue(another.tzinfo is again.tzinfo) + self.assertIs(another.tzinfo, again.tzinfo) self.assertEqual(another.utcoffset(), timedelta(minutes=42)) # Bad argument with and w/o naming the keyword. self.assertRaises(TypeError, meth, 16) @@ -3001,7 +3001,7 @@ timezone(timedelta(hours=15, minutes=58), "weirdtz"),]: for dummy in range(3): now = datetime.now(weirdtz) - self.assertTrue(now.tzinfo is weirdtz) + self.assertIs(now.tzinfo, weirdtz) utcnow = datetime.utcnow().replace(tzinfo=utc) now2 = utcnow.astimezone(weirdtz) if abs(now - now2) < timedelta(seconds=30): @@ -3022,7 +3022,7 @@ off42 = FixedOffset(42, "42") another = meth(ts, off42) again = meth(ts, tz=off42) - self.assertTrue(another.tzinfo is again.tzinfo) + self.assertIs(another.tzinfo, again.tzinfo) self.assertEqual(another.utcoffset(), timedelta(minutes=42)) # Bad argument with and w/o naming the keyword. self.assertRaises(TypeError, meth, ts, 16) @@ -3233,13 +3233,13 @@ # Ensure we can get rid of a tzinfo. self.assertEqual(base.tzname(), "+100") base2 = base.replace(tzinfo=None) - self.assertTrue(base2.tzinfo is None) - self.assertTrue(base2.tzname() is None) + self.assertIsNone(base2.tzinfo) + self.assertIsNone(base2.tzname()) # Ensure we can add one. base3 = base2.replace(tzinfo=z100) self.assertEqual(base, base3) - self.assertTrue(base.tzinfo is base3.tzinfo) + self.assertIs(base.tzinfo, base3.tzinfo) # Out of bounds. base = cls(2000, 2, 29) @@ -3252,18 +3252,18 @@ fm5h = FixedOffset(-timedelta(hours=5), "m300") dt = self.theclass.now(tz=f44m) - self.assertTrue(dt.tzinfo is f44m) + self.assertIs(dt.tzinfo, f44m) # Replacing with degenerate tzinfo raises an exception. self.assertRaises(ValueError, dt.astimezone, fnone) # Replacing with same tzinfo makes no change. x = dt.astimezone(dt.tzinfo) - self.assertTrue(x.tzinfo is f44m) + self.assertIs(x.tzinfo, f44m) self.assertEqual(x.date(), dt.date()) self.assertEqual(x.time(), dt.time()) # Replacing with different tzinfo does adjust. got = dt.astimezone(fm5h) - self.assertTrue(got.tzinfo is fm5h) + self.assertIs(got.tzinfo, 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 @@ -3271,7 +3271,7 @@ self.assertEqual(got.date(), expected.date()) self.assertEqual(got.time(), expected.time()) self.assertEqual(got.timetz(), expected.timetz()) - self.assertTrue(got.tzinfo is expected.tzinfo) + self.assertIs(got.tzinfo, expected.tzinfo) self.assertEqual(got, expected) @support.run_with_tz('UTC') @@ -3732,8 +3732,8 @@ as_datetime = datetime.combine(as_date, time()) 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.assertFalse(as_date == as_datetime) + self.assertFalse(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 -r cf606c403f14 Lib/test/json_tests/test_decode.py --- a/Lib/test/json_tests/test_decode.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/json_tests/test_decode.py Mon Nov 19 12:28:22 2012 +0200 @@ -7,12 +7,12 @@ class TestDecode: def test_decimal(self): rval = self.loads('1.1', parse_float=decimal.Decimal) - self.assertTrue(isinstance(rval, decimal.Decimal)) + self.assertIsInstance(rval, decimal.Decimal) self.assertEqual(rval, decimal.Decimal('1.1')) def test_float(self): rval = self.loads('1', parse_int=float) - self.assertTrue(isinstance(rval, float)) + self.assertIsInstance(rval, float) self.assertEqual(rval, 1.0) def test_empty_objects(self): diff -r cf606c403f14 Lib/test/mapping_tests.py --- a/Lib/test/mapping_tests.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/mapping_tests.py Mon Nov 19 12:28:22 2012 +0200 @@ -133,10 +133,10 @@ self.assertEqual(self._empty_mapping(), self._empty_mapping()) def test_bool(self): - self.assertTrue(not self._empty_mapping()) + self.assertFalse(self._empty_mapping()) self.assertTrue(self.reference) - self.assertTrue(bool(self._empty_mapping()) is False) - self.assertTrue(bool(self.reference) is True) + self.assertIs(bool(self._empty_mapping()), False) + self.assertIs(bool(self.reference), True) def test_keys(self): d = self._empty_mapping() @@ -268,10 +268,10 @@ def test_get(self): d = self._empty_mapping() - self.assertTrue(d.get(list(self.other.keys())[0]) is None) + self.assertIsNone(d.get(list(self.other.keys())[0])) self.assertEqual(d.get(list(self.other.keys())[0], 3), 3) d = self.reference - self.assertTrue(d.get(list(self.other.keys())[0]) is None) + self.assertIsNone(d.get(list(self.other.keys())[0])) 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 TestMappingProtocol(BasicTestMappingProtocol): def test_constructor(self): BasicTestMappingProtocol.test_constructor(self) - self.assertTrue(self._empty_mapping() is not self._empty_mapping()) + self.assertIsNot(self._empty_mapping(), self._empty_mapping()) self.assertEqual(self.type2test(x=1, y=2), {"x": 1, "y": 2}) def test_bool(self): BasicTestMappingProtocol.test_bool(self) - self.assertTrue(not self._empty_mapping()) + self.assertFalse(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) + self.assertIs(bool(self._empty_mapping()), False) + self.assertIs(bool(self._full_mapping({"x": "y"})), True) def test_keys(self): BasicTestMappingProtocol.test_keys(self) @@ -338,7 +338,7 @@ def test_contains(self): d = self._empty_mapping() self.assertNotIn('a', d) - self.assertTrue(not ('a' in d)) + self.assertFalse('a' in d) self.assertTrue('a' not in d) d = self._full_mapping({'a': 1, 'b': 2}) self.assertIn('a', d) @@ -422,7 +422,7 @@ def test_fromkeys(self): self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) d = self._empty_mapping() - self.assertTrue(not(d.fromkeys('abc') is d)) + self.assertIsNot(d.fromkeys('abc'), 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([]), {}) @@ -433,9 +433,9 @@ class dictlike(self.type2test): pass self.assertEqual(dictlike.fromkeys('a'), {'a':None}) self.assertEqual(dictlike().fromkeys('a'), {'a':None}) - self.assertTrue(dictlike.fromkeys('a').__class__ is dictlike) - self.assertTrue(dictlike().fromkeys('a').__class__ is dictlike) - self.assertTrue(type(dictlike.fromkeys('a')) is dictlike) + self.assertIs(dictlike.fromkeys('a').__class__, dictlike) + self.assertIs(dictlike().fromkeys('a').__class__, dictlike) + self.assertIs(type(dictlike.fromkeys('a')), dictlike) class mydict(self.type2test): def __new__(cls): return collections.UserDict() @@ -477,10 +477,10 @@ def test_get(self): BasicTestMappingProtocol.test_get(self) d = self._empty_mapping() - self.assertTrue(d.get('c') is None) + self.assertIsNone(d.get('c')) self.assertEqual(d.get('c', 3), 3) d = self._full_mapping({'a' : 1, 'b' : 2}) - self.assertTrue(d.get('c') is None) + self.assertIsNone(d.get('c')) self.assertEqual(d.get('c', 3), 3) self.assertEqual(d.get('a'), 1) self.assertEqual(d.get('a', 3), 1) @@ -488,9 +488,9 @@ def test_setdefault(self): BasicTestMappingProtocol.test_setdefault(self) d = self._empty_mapping() - self.assertTrue(d.setdefault('key0') is None) + self.assertIsNone(d.setdefault('key0')) d.setdefault('key0', []) - self.assertTrue(d.setdefault('key0') is None) + self.assertIsNone(d.setdefault('key0')) d.setdefault('key', []).append(3) self.assertEqual(d['key'][0], 3) d.setdefault('key', []).append(4) @@ -516,9 +516,10 @@ self.assertEqual(va, int(ka)) kb, vb = tb = b.popitem() self.assertEqual(vb, int(kb)) - self.assertTrue(not(copymode < 0 and ta != tb)) - self.assertTrue(not a) - self.assertTrue(not b) + if copymode < 0: + self.assertEqual(ta, tb) + self.assertFalse(a) + self.assertFalse(b) def test_pop(self): BasicTestMappingProtocol.test_pop(self) diff -r cf606c403f14 Lib/test/multibytecodec_support.py --- a/Lib/test/multibytecodec_support.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/multibytecodec_support.py Mon Nov 19 12:28:22 2012 +0200 @@ -57,13 +57,13 @@ if expected: result = func(source, scheme)[0] if func is self.decode: - self.assertTrue(type(result) is str, type(result)) + self.assertIs(type(result), str, type(result)) self.assertEqual(result, expected, '%a.decode(%r, %r)=%a != %a' % (source, self.encoding, scheme, result, expected)) else: - self.assertTrue(type(result) is bytes, type(result)) + self.assertIs(type(result), bytes, type(result)) self.assertEqual(result, expected, '%a.encode(%r, %r)=%a != %a' % (source, self.encoding, scheme, result, @@ -348,14 +348,14 @@ if expected: if isinstance(source, bytes): result = func(self.encoding, scheme) - self.assertTrue(type(result) is str, type(result)) + self.assertIs(type(result), str, type(result)) self.assertEqual(result, expected, '%a.decode(%r, %r)=%a != %a' % (source, self.encoding, scheme, result, expected)) else: result = func(self.encoding, scheme) - self.assertTrue(type(result) is bytes, type(result)) + self.assertIs(type(result), bytes, type(result)) self.assertEqual(result, expected, '%a.encode(%r, %r)=%a != %a' % (source, self.encoding, scheme, result, diff -r cf606c403f14 Lib/test/pickletester.py --- a/Lib/test/pickletester.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/pickletester.py Mon Nov 19 12:28:22 2012 +0200 @@ -553,7 +553,7 @@ s = self.dumps(l, proto) x = self.loads(s) self.assertEqual(len(x), 1) - self.assertTrue(x is x[0]) + self.assertIs(x, x[0]) def test_recursive_tuple(self): t = ([],) @@ -563,7 +563,7 @@ x = self.loads(s) self.assertEqual(len(x), 1) self.assertEqual(len(x[0]), 1) - self.assertTrue(x is x[0][0]) + self.assertIs(x, x[0][0]) def test_recursive_dict(self): d = {} @@ -572,7 +572,7 @@ s = self.dumps(d, proto) x = self.loads(s) self.assertEqual(list(x.keys()), [1]) - self.assertTrue(x[1] is x) + self.assertIs(x[1], x) def test_recursive_inst(self): i = C() @@ -581,7 +581,7 @@ s = self.dumps(i, 2) x = self.loads(s) self.assertEqual(dir(x), dir(i)) - self.assertTrue(x.attr is x) + self.assertIs(x.attr, x) def test_recursive_multi(self): l = [] @@ -595,7 +595,7 @@ self.assertEqual(len(x), 1) self.assertEqual(dir(x[0]), dir(i)) self.assertEqual(list(x[0].attr.keys()), [1]) - self.assertTrue(x[0].attr[1] is x) + self.assertIs(x[0].attr[1], x) def test_get(self): self.assertRaises(KeyError, self.loads, b'g0\np0') @@ -857,7 +857,7 @@ for x in None, False, True: s = self.dumps(x, proto) y = self.loads(s) - self.assertTrue(x is y, (proto, x, s, y)) + self.assertIs(x, y, (proto, x, s, y)) expected = expected_opcode[proto, x] self.assertEqual(opcode_in_pickle(expected, s), True) @@ -981,7 +981,7 @@ if proto == 0: self.assertEqual(num_appends, 0) else: - self.assertTrue(num_appends >= 2) + self.assertGreaterEqual(num_appends, 2) def test_dict_chunking(self): n = 10 # too small to chunk @@ -1004,7 +1004,7 @@ if proto == 0: self.assertEqual(num_setitems, 0) else: - self.assertTrue(num_setitems >= 2) + self.assertGreaterEqual(num_setitems, 2) def test_simple_newobj(self): x = object.__new__(SimpleNewObj) # avoid __init__ @@ -1236,8 +1236,8 @@ continue try: pickled = self.dumps(data, protocol=proto) - self.assertTrue(b"abcd" in pickled[:15]) - self.assertTrue(b"abcd" in pickled[-15:]) + self.assertIn(b"abcd", pickled[:15]) + self.assertIn(b"abcd", pickled[-15:]) finally: pickled = None finally: @@ -1265,8 +1265,8 @@ for proto in protocols: try: pickled = self.dumps(data, protocol=proto) - self.assertTrue(b"abcd" in pickled[:15]) - self.assertTrue(b"abcd" in pickled[-15:]) + self.assertIn(b"abcd", pickled[:15]) + self.assertIn(b"abcd", pickled[-15:]) finally: pickled = None finally: @@ -1553,7 +1553,7 @@ primed.memo.clear() self.assertEqual(unpickled_data2, data) - self.assertTrue(unpickled_data2 is unpickled_data1) + self.assertIs(unpickled_data2, unpickled_data1) def test_reusing_unpickler_objects(self): data1 = ["abcdefg", "abcdefg", 44] diff -r cf606c403f14 Lib/test/test_abc.py --- a/Lib/test/test_abc.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_abc.py Mon Nov 19 12:28:22 2012 +0200 @@ -314,11 +314,11 @@ class B: pass b = B() - self.assertFalse(isinstance(b, A)) - self.assertFalse(isinstance(b, (A,))) + self.assertNotIsInstance(b, A) + self.assertNotIsInstance(b, (A,)) A.register(B) - self.assertTrue(isinstance(b, A)) - self.assertTrue(isinstance(b, (A,))) + self.assertIsInstance(b, A) + self.assertIsInstance(b, (A,)) def test_registration_builtins(self): class A(metaclass=abc.ABCMeta): diff -r cf606c403f14 Lib/test/test_argparse.py --- a/Lib/test/test_argparse.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_argparse.py Mon Nov 19 12:28:22 2012 +0200 @@ -4133,7 +4133,7 @@ e = sys.exc_info()[1] expected = 'unknown action' msg = 'expected %r, found %r' % (expected, e) - self.assertTrue(expected in str(e), msg) + self.assertIn(expected, str(e), msg) def test_multiple_dest(self): parser = argparse.ArgumentParser() @@ -4144,7 +4144,7 @@ e = sys.exc_info()[1] expected = 'dest supplied twice for positional argument' msg = 'expected %r, found %r' % (expected, e) - self.assertTrue(expected in str(e), msg) + self.assertIn(expected, str(e), msg) def test_no_argument_actions(self): for action in ['store_const', 'store_true', 'store_false', diff -r cf606c403f14 Lib/test/test_array.py --- a/Lib/test/test_array.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_array.py Mon Nov 19 12:28:22 2012 +0200 @@ -443,39 +443,39 @@ def test_cmp(self): a = array.array(self.typecode, self.example) - self.assertTrue((a == 42) is False) - self.assertTrue((a != 42) is True) + self.assertIs(a == 42, False) + self.assertIs(a != 42, 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) + self.assertIs(a == a, True) + self.assertIs(a != a, False) + self.assertIs(a < a, False) + self.assertIs(a <= a, True) + self.assertIs(a > a, False) + self.assertIs(a >= a, True) al = array.array(self.typecode, self.smallerexample) ab = array.array(self.typecode, self.biggerexample) - 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.assertIs(a == 2*a, False) + self.assertIs(a != 2*a, True) + self.assertIs(a < 2*a, True) + self.assertIs(a <= 2*a, True) + self.assertIs(a > 2*a, False) + self.assertIs(a >= 2*a, 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.assertIs(a == al, False) + self.assertIs(a != al, True) + self.assertIs(a < al, False) + self.assertIs(a <= al, False) + self.assertIs(a > al, True) + self.assertIs(a >= al, 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) + self.assertIs(a == ab, False) + self.assertIs(a != ab, True) + self.assertIs(a < ab, True) + self.assertIs(a <= ab, True) + self.assertIs(a > ab, False) + self.assertIs(a >= ab, False) def test_add(self): a = array.array(self.typecode, self.example) \ @@ -494,7 +494,7 @@ a = array.array(self.typecode, self.example[::-1]) b = a a += array.array(self.typecode, 2*self.example) - self.assertTrue(a is b) + self.assertIs(a, b) self.assertEqual( a, array.array(self.typecode, self.example[::-1]+2*self.example) @@ -549,22 +549,22 @@ b = a a *= 5 - self.assertTrue(a is b) + self.assertIs(a, b) self.assertEqual( a, array.array(self.typecode, 5*self.example) ) a *= 0 - self.assertTrue(a is b) + self.assertIs(a, b) self.assertEqual(a, array.array(self.typecode)) a *= 1000 - self.assertTrue(a is b) + self.assertIs(a, b) self.assertEqual(a, array.array(self.typecode)) a *= -1 - self.assertTrue(a is b) + self.assertIs(a, b) self.assertEqual(a, array.array(self.typecode)) a = array.array(self.typecode, self.example) diff -r cf606c403f14 Lib/test/test_ast.py --- a/Lib/test/test_ast.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_ast.py Mon Nov 19 12:28:22 2012 +0200 @@ -185,7 +185,7 @@ return if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)): node_pos = (ast_node.lineno, ast_node.col_offset) - self.assertTrue(node_pos >= parent_pos) + self.assertGreaterEqual(node_pos, parent_pos) parent_pos = (ast_node.lineno, ast_node.col_offset) for name in ast_node._fields: value = getattr(ast_node, name) diff -r cf606c403f14 Lib/test/test_asyncore.py --- a/Lib/test/test_asyncore.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_asyncore.py Mon Nov 19 12:28:22 2012 +0200 @@ -340,7 +340,7 @@ if hasattr(os, 'strerror'): self.assertEqual(err, os.strerror(errno.EPERM)) err = asyncore._strerror(-1) - self.assertTrue(err != "") + self.assertNotEqual(err, "") class dispatcherwithsend_noread(asyncore.dispatcher_with_send): diff -r cf606c403f14 Lib/test/test_augassign.py --- a/Lib/test/test_augassign.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_augassign.py Mon Nov 19 12:28:22 2012 +0200 @@ -63,7 +63,7 @@ y[1:2] += [1] self.assertEqual(x, [1, 2, 1, 2, 3]) - self.assertTrue(x is y) + self.assertIs(x, y) def testCustomMethods1(self): @@ -89,14 +89,14 @@ x += 10 self.assertIsInstance(x, aug_test) - self.assertTrue(y is not x) + self.assertIsNot(y, x) self.assertEqual(x.val, 11) x = aug_test2(2) y = x x += 10 - self.assertTrue(y is x) + self.assertIs(y, x) self.assertEqual(x.val, 12) x = aug_test3(3) @@ -104,7 +104,7 @@ x += 10 self.assertIsInstance(x, aug_test3) - self.assertTrue(y is not x) + self.assertIsNot(y, x) self.assertEqual(x.val, 13) diff -r cf606c403f14 Lib/test/test_bigmem.py --- a/Lib/test/test_bigmem.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_bigmem.py Mon Nov 19 12:28:22 2012 +0200 @@ -118,7 +118,7 @@ _ = self.from_latin1 s = _('-') * size tabsize = 8 - self.assertTrue(s.expandtabs() == s) + self.assertEqual(s.expandtabs(), s) del s slen, remainder = divmod(size, tabsize) s = _(' \t') * slen @@ -270,7 +270,7 @@ # Type-specific optimization if isinstance(s, (str, bytes)): stripped = s.lstrip() - self.assertTrue(stripped is s) + self.assertIs(stripped, s) @bigmemtest(size=_2G + 10, memuse=2) def test_replace(self, size): @@ -342,7 +342,7 @@ # Type-specific optimization if isinstance(s, (str, bytes)): stripped = s.rstrip() - self.assertTrue(stripped is s) + self.assertIs(stripped, 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 @@ -536,12 +536,12 @@ edge = _('-') * (size // 2) s = _('').join([edge, SUBSTR, edge]) del edge - self.assertTrue(SUBSTR in s) - self.assertFalse(SUBSTR * 2 in s) - self.assertTrue(_('-') in s) - self.assertFalse(_('a') in s) + self.assertIn(SUBSTR, s) + self.assertNotIn(SUBSTR * 2, s) + self.assertIn(_('-'), s) + self.assertNotIn(_('a'), s) s += _('a') - self.assertTrue(_('a') in s) + self.assertIn(_('a'), s) @bigmemtest(size=_2G + 10, memuse=2) def test_compare(self, size): @@ -655,7 +655,7 @@ def test_format(self, size): s = '-' * size sf = '%s' % (s,) - self.assertTrue(s == sf) + self.assertEqual(s, sf) del sf sf = '..%s..' % (s,) self.assertEqual(len(sf), len(s) + 4) @@ -856,9 +856,9 @@ def test_contains(self, size): t = (1, 2, 3, 4, 5) * size self.assertEqual(len(t), size * 5) - self.assertTrue(5 in t) - self.assertFalse((1, 2, 3, 4, 5) in t) - self.assertFalse(0 in t) + self.assertIn(5, t) + self.assertNotIn((1, 2, 3, 4, 5), t) + self.assertNotIn(0, t) @bigmemtest(size=_2G + 10, memuse=8) def test_hash(self, size): @@ -866,7 +866,7 @@ h1 = hash(t1) del t1 t2 = (0,) * (size + 1) - self.assertFalse(h1 == hash(t2)) + self.assertNotEqual(h1, hash(t2)) @bigmemtest(size=_2G + 10, memuse=8) def test_index_and_slice(self, size): @@ -992,8 +992,8 @@ l = [sys.stdout] * size l += l self.assertEqual(len(l), size * 2) - self.assertTrue(l[0] is l[-1]) - self.assertTrue(l[size - 1] is l[size + 1]) + self.assertIs(l[0], l[-1]) + self.assertIs(l[size - 1], l[size + 1]) @bigmemtest(size=_2G // 2 + 2, memuse=24) def test_inplace_concat_small(self, size): @@ -1007,9 +1007,9 @@ def test_contains(self, size): l = [1, 2, 3, 4, 5] * size self.assertEqual(len(l), size * 5) - self.assertTrue(5 in l) - self.assertFalse([1, 2, 3, 4, 5] in l) - self.assertFalse(0 in l) + self.assertIn(5, l) + self.assertNotIn([1, 2, 3, 4, 5], l) + self.assertNotIn(0, l) @bigmemtest(size=_2G + 10, memuse=8) def test_hash(self, size): @@ -1092,13 +1092,13 @@ l = [''] l *= size self.assertEqual(len(l), size) - self.assertTrue(l[0] is l[-1]) + self.assertIs(l[0], l[-1]) del l l = [''] * size l *= 2 self.assertEqual(len(l), size * 2) - self.assertTrue(l[size - 1] is l[-1]) + self.assertIs(l[size - 1], l[-1]) @bigmemtest(size=_2G // 2 + 2, memuse=16) def test_inplace_repeat_small(self, size): @@ -1132,8 +1132,8 @@ l = [object()] * size l.append(object()) self.assertEqual(len(l), size+1) - self.assertTrue(l[-3] is l[-2]) - self.assertFalse(l[-2] is l[-1]) + self.assertIs(l[-3], l[-2]) + self.assertIsNot(l[-2], l[-1]) @bigmemtest(size=_2G // 5 + 2, memuse=8 * 5) def test_count(self, size): @@ -1145,8 +1145,8 @@ l = [object] * size l.extend(l) self.assertEqual(len(l), size * 2) - self.assertTrue(l[0] is l[-1]) - self.assertTrue(l[size - 1] is l[size + 1]) + self.assertIs(l[0], l[-1]) + self.assertIs(l[size - 1], l[size + 1]) @bigmemtest(size=_2G // 2 + 2, memuse=16) def test_extend_small(self, size): diff -r cf606c403f14 Lib/test/test_binop.py --- a/Lib/test/test_binop.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_binop.py Mon Nov 19 12:28:22 2012 +0200 @@ -211,10 +211,10 @@ self.assertEqual(gcd(-10, -2), -2) for i in range(1, 20): for j in range(1, 20): - self.assertTrue(gcd(i, j) > 0) - self.assertTrue(gcd(-i, j) < 0) - self.assertTrue(gcd(i, -j) > 0) - self.assertTrue(gcd(-i, -j) < 0) + self.assertGreater(gcd(i, j), 0) + self.assertLess(gcd(-i, j), 0) + self.assertGreater(gcd(i, -j), 0) + self.assertLess(gcd(-i, -j), 0) def test_constructor(self): a = Rat(10, 15) diff -r cf606c403f14 Lib/test/test_bisect.py --- a/Lib/test/test_bisect.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_bisect.py Mon Nov 19 12:28:22 2012 +0200 @@ -178,14 +178,14 @@ elem = randrange(-1, n+1) ip = self.module.bisect_left(data, elem) if ip < len(data): - self.assertTrue(elem <= data[ip]) + self.assertLessEqual(elem, data[ip]) if ip > 0: - self.assertTrue(data[ip-1] < elem) + self.assertLess(data[ip-1], elem) ip = self.module.bisect_right(data, elem) if ip < len(data): - self.assertTrue(elem < data[ip]) + self.assertLess(elem, data[ip]) if ip > 0: - self.assertTrue(data[ip-1] <= elem) + self.assertLessEqual(data[ip-1], elem) def test_optionalSlicing(self): for func, data, elem, expected in self.precomputedCases: @@ -196,13 +196,13 @@ ip = func(data, elem, lo, hi) self.assertTrue(lo <= ip <= hi) if func is self.module.bisect_left and ip < hi: - self.assertTrue(elem <= data[ip]) + self.assertLessEqual(elem, data[ip]) if func is self.module.bisect_left and ip > lo: - self.assertTrue(data[ip-1] < elem) + self.assertLess(data[ip-1], elem) if func is self.module.bisect_right and ip < hi: - self.assertTrue(elem < data[ip]) + self.assertLess(elem, data[ip]) if func is self.module.bisect_right and ip > lo: - self.assertTrue(data[ip-1] <= elem) + self.assertLessEqual(data[ip-1], elem) self.assertEqual(ip, max(lo, min(hi, expected))) def test_backcompatibility(self): diff -r cf606c403f14 Lib/test/test_buffer.py --- a/Lib/test/test_buffer.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_buffer.py Mon Nov 19 12:28:22 2012 +0200 @@ -1328,7 +1328,7 @@ # memoryview: reconstruct strides ex = ndarray(items, shape=shape, format=fmt) nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) - self.assertTrue(nd.strides == ()) + self.assertEqual(nd.strides, ()) mv = nd.memoryview_from_buffer() self.verify(mv, obj=None, itemsize=itemsize, fmt=fmt, readonly=1, @@ -1556,13 +1556,13 @@ nd = ndarray(items, shape=[5], format=fmt) for i, v in enumerate(nd): self.assertEqual(v, items[i]) - self.assertTrue(v in nd) + self.assertIn(v, nd) if is_memoryview_format(fmt): mv = memoryview(nd) for i, v in enumerate(mv): self.assertEqual(v, items[i]) - self.assertTrue(v in mv) + self.assertIn(v, mv) def test_ndarray_slice_invalid(self): items = [1,2,3,4,5,6,7,8] @@ -2493,8 +2493,8 @@ mv_err = e.__class__ if struct_err or mv_err: - self.assertIsNot(struct_err, None) - self.assertIsNot(mv_err, None) + self.assertIsNotNone(struct_err) + self.assertIsNotNone(mv_err) else: self.assertEqual(m[1], nd[1]) @@ -4249,7 +4249,7 @@ y = ndarray(x, getbuf=PyBUF_FULL_RO) z = ndarray(y, getbuf=PyBUF_FULL_RO) m = memoryview(z) - self.assertIs(y.obj, None) + self.assertIsNone(y.obj) self.assertIs(m.obj, z) self.verify(m, obj=z, itemsize=1, fmt=fmt, readonly=1, @@ -4263,7 +4263,7 @@ m = memoryview(z) # Clearly setting view.obj==NULL is inferior, since it # messes up the redirection chain: - self.assertIs(y.obj, None) + self.assertIsNone(y.obj) self.assertIs(z.obj, y) self.assertIs(m.obj, y) self.verify(m, obj=y, diff -r cf606c403f14 Lib/test/test_bufio.py --- a/Lib/test/test_bufio.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_bufio.py Mon Nov 19 12:28:22 2012 +0200 @@ -34,7 +34,7 @@ line = f.readline() self.assertEqual(line, s) line = f.readline() - self.assertTrue(not line) # Must be at EOF + self.assertFalse(line) # Must be at EOF f.close() finally: support.unlink(support.TESTFN) diff -r cf606c403f14 Lib/test/test_builtin.py --- a/Lib/test/test_builtin.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_builtin.py Mon Nov 19 12:28:22 2012 +0200 @@ -153,7 +153,7 @@ self.assertEqual(abs(0), 0) self.assertEqual(abs(1234), 1234) self.assertEqual(abs(-1234), 1234) - self.assertTrue(abs(-sys.maxsize-1) > 0) + self.assertGreater(abs(-sys.maxsize-1), 0) # float self.assertEqual(abs(0.0), 0.0) self.assertEqual(abs(3.14), 3.14) @@ -236,7 +236,7 @@ def test_neg(self): x = -sys.maxsize-1 - self.assertTrue(isinstance(x, int)) + self.assertIsInstance(x, int) self.assertEqual(-x, sys.maxsize+1) def test_callable(self): @@ -296,7 +296,7 @@ self.assertRaises((OverflowError, ValueError), chr, 2**32) def test_cmp(self): - self.assertTrue(not hasattr(builtins, "cmp")) + self.assertFalse(hasattr(builtins, "cmp")) def test_compile(self): compile('print(1)\n', '', 'exec') @@ -400,7 +400,7 @@ def __dir__(self): return ["kan", "ga", "roo"] f = Foo() - self.assertTrue(dir(f) == ["ga", "kan", "roo"]) + self.assertEqual(dir(f), ["ga", "kan", "roo"]) # dir(obj__dir__tuple) class Foo(object): @@ -408,7 +408,7 @@ return ("b", "c", "a") res = dir(Foo()) self.assertIsInstance(res, list) - self.assertTrue(res == ["a", "b", "c"]) + self.assertEqual(res, ["a", "b", "c"]) # dir(obj__dir__not_sequence) class Foo(object): @@ -630,7 +630,7 @@ self.check_iter_pickle(f1, list(f2)) def test_getattr(self): - self.assertTrue(getattr(sys, 'stdout') is sys.stdout) + self.assertIs(getattr(sys, 'stdout'), sys.stdout) self.assertRaises(TypeError, getattr, sys, 1) self.assertRaises(TypeError, getattr, sys, 1, "foo") self.assertRaises(TypeError, getattr) @@ -711,11 +711,11 @@ c = C() d = D() e = 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.assertIsInstance(c, C) + self.assertIsInstance(d, C) + self.assertNotIsInstance(e, C) + self.assertNotIsInstance(c, D) + self.assertNotIsInstance('foo', E) self.assertRaises(TypeError, isinstance, E, 'foo') self.assertRaises(TypeError, isinstance) @@ -731,7 +731,7 @@ e = E() self.assertTrue(issubclass(D, C)) self.assertTrue(issubclass(C, C)) - self.assertTrue(not issubclass(C, D)) + self.assertFalse(issubclass(C, D)) self.assertRaises(TypeError, issubclass, 'foo', E) self.assertRaises(TypeError, issubclass, E, 'foo') self.assertRaises(TypeError, issubclass) diff -r cf606c403f14 Lib/test/test_bytes.py --- a/Lib/test/test_bytes.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_bytes.py Mon Nov 19 12:28:22 2012 +0200 @@ -936,7 +936,7 @@ b += b"def" self.assertEqual(b, b"abcdef") self.assertEqual(b, b1) - self.assertTrue(b is b1) + self.assertIs(b, b1) b += b"xyz" self.assertEqual(b, b"abcdefxyz") try: @@ -952,7 +952,7 @@ b *= 3 self.assertEqual(b, b"abcabcabc") self.assertEqual(b, b1) - self.assertTrue(b is b1) + self.assertIs(b, b1) def test_irepeat_1char(self): b = bytearray(b"x") @@ -960,17 +960,17 @@ b *= 100 self.assertEqual(b, b"x"*100) self.assertEqual(b, b1) - self.assertTrue(b is b1) + self.assertIs(b, b1) def test_alloc(self): b = bytearray() alloc = b.__alloc__() - self.assertTrue(alloc >= 0) + self.assertGreaterEqual(alloc, 0) seq = [alloc] for i in range(100): b += b"x" alloc = b.__alloc__() - self.assertTrue(alloc >= len(b)) + self.assertGreaterEqual(alloc, len(b)) if alloc not in seq: seq.append(alloc) @@ -1061,17 +1061,17 @@ # Issue 4348. Make sure that operations that don't mutate the array # copy the bytes. b = bytearray(b'abc') - self.assertFalse(b is b.replace(b'abc', b'cde', 0)) + self.assertIsNot(b, b.replace(b'abc', b'cde', 0)) t = bytearray([i for i in range(256)]) x = bytearray(b'') - self.assertFalse(x is x.translate(t)) + self.assertIsNot(x, x.translate(t)) def test_partition_bytearray_doesnt_share_nullstring(self): a, b, c = bytearray(b"x").partition(b"y") self.assertEqual(b, b"") self.assertEqual(c, b"") - self.assertTrue(b is not c) + self.assertIsNot(b, c) b += b"!" self.assertEqual(c, b"") a, b, c = bytearray(b"x").partition(b"y") @@ -1081,7 +1081,7 @@ b, c, a = bytearray(b"x").rpartition(b"y") self.assertEqual(b, b"") self.assertEqual(c, b"") - self.assertTrue(b is not c) + self.assertIsNot(b, c) b += b"!" self.assertEqual(c, b"") c, b, a = bytearray(b"x").rpartition(b"y") @@ -1227,7 +1227,7 @@ def test_return_self(self): # bytearray.replace must always return a new bytearray b = bytearray() - self.assertFalse(b.replace(b'', b'') is b) + self.assertIsNot(b.replace(b'', b''), b) def test_compare(self): if sys.flags.bytes_warning: @@ -1272,14 +1272,14 @@ method = getattr(val, methname) newval = method(3) self.assertEqual(val, newval) - self.assertTrue(val is not newval, + self.assertIsNot(val, newval, methname+' returned self on a mutable object') for expr in ('val.split()[0]', 'val.rsplit()[0]', 'val.partition(b".")[0]', 'val.rpartition(b".")[2]', 'val.splitlines()[0]', 'val.replace(b"", b"")'): newval = eval(expr) self.assertEqual(val, newval) - self.assertTrue(val is not newval, + self.assertIsNot(val, newval, expr+' returned val on a mutable object') sep = self.marshal(b'') newval = sep.join([val]) @@ -1331,7 +1331,7 @@ self.assertTrue(_a <= _b) self.assertTrue(_b >= _a) self.assertTrue(_b > _a) - self.assertTrue(_a is not a) + self.assertIsNot(_a, a) # test concat of subclass instances self.assertEqual(a + b, _a + _b) @@ -1347,12 +1347,12 @@ # Make sure that it is of the appropriate type. s1 = self.subclass2test(b"abcd") s2 = self.type2test().join([s1]) - self.assertTrue(s1 is not s2) - self.assertTrue(type(s2) is self.type2test, type(s2)) + self.assertIsNot(s1, s2) + self.assertIs(type(s2), self.type2test) # Test reverse, calling join on subclass s3 = s1.join([b"abcd"]) - self.assertTrue(type(s3) is self.type2test) + self.assertIs(type(s3), self.type2test) def test_pickle(self): a = self.subclass2test(b"abcd") diff -r cf606c403f14 Lib/test/test_bz2.py --- a/Lib/test/test_bz2.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_bz2.py Mon Nov 19 12:28:22 2012 +0200 @@ -652,7 +652,7 @@ compressed = bz2.compress(data) bz2d = BZ2Decompressor() decompressed = bz2d.decompress(compressed) - self.assertTrue(decompressed == data) + self.assertEqual(decompressed, data) finally: data = None compressed = None diff -r cf606c403f14 Lib/test/test_capi.py --- a/Lib/test/test_capi.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_capi.py Mon Nov 19 12:28:22 2012 +0200 @@ -34,7 +34,7 @@ def test_instancemethod(self): inst = InstanceMethod() self.assertEqual(id(inst), inst.id()) - self.assertTrue(inst.testfunction() is inst) + self.assertIs(inst.testfunction(), inst) self.assertEqual(inst.testfunction.__doc__, testfunction.__doc__) self.assertEqual(InstanceMethod.testfunction.__doc__, testfunction.__doc__) @@ -141,7 +141,7 @@ if context and not context.event.is_set(): continue count += 1 - self.assertTrue(count < 10000, + self.assertLess(count, 10000, "timeout waiting for %i callbacks, got %i"%(n, len(l))) if False and support.verbose: print("(%i)"%(len(l),)) diff -r cf606c403f14 Lib/test/test_cgi.py --- a/Lib/test/test_cgi.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_cgi.py Mon Nov 19 12:28:22 2012 +0200 @@ -202,7 +202,7 @@ # 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.assertTrue(f.numcalls > 2) + self.assertGreater(f.numcalls, 2) f.close() def test_fieldstorage_multipart(self): diff -r cf606c403f14 Lib/test/test_cmd_line.py --- a/Lib/test/test_cmd_line.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_cmd_line.py Mon Nov 19 12:28:22 2012 +0200 @@ -82,8 +82,8 @@ p.stdin.write(b'Timer\n') p.stdin.write(b'exit()\n') data = kill_python(p) - self.assertTrue(data.find(b'1 loop') != -1) - self.assertTrue(data.find(b'__main__.Timer') != -1) + self.assertNotEqual(data.find(b'1 loop'), -1) + self.assertNotEqual(data.find(b'__main__.Timer'), -1) def test_run_code(self): # Test expected operation of the '-c' switch diff -r cf606c403f14 Lib/test/test_codecs.py --- a/Lib/test/test_codecs.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_codecs.py Mon Nov 19 12:28:22 2012 +0200 @@ -54,7 +54,7 @@ # 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.assertTrue(not d.decode(state[0])) + self.assertFalse(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 @@ -1577,7 +1577,7 @@ for c in s: writer.write(c) chunk = q.read() - self.assertTrue(type(chunk) is bytes, type(chunk)) + self.assertIs(type(chunk), bytes) encodedresult += chunk q = Queue(b"") reader = codecs.getreader(encoding)(q) diff -r cf606c403f14 Lib/test/test_codeop.py --- a/Lib/test/test_codeop.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_codeop.py Mon Nov 19 12:28:22 2012 +0200 @@ -54,7 +54,7 @@ except SyntaxError: self.assertTrue(is_syntax) except OverflowError: - self.assertTrue(not is_syntax) + self.assertFalse(is_syntax) def test_valid(self): av = self.assertValid diff -r cf606c403f14 Lib/test/test_collections.py --- a/Lib/test/test_collections.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_collections.py Mon Nov 19 12:28:22 2012 +0200 @@ -605,7 +605,7 @@ def __hash__(self): return self._hash() a, b = OneTwoThreeSet(), OneTwoThreeSet() - self.assertTrue(hash(a) == hash(b)) + self.assertEqual(hash(a), hash(b)) def test_MutableSet(self): self.assertIsInstance(set(), MutableSet) @@ -898,7 +898,7 @@ Counter(words), ]): msg = (i, dup, words) - self.assertTrue(dup is not words) + self.assertIsNot(dup, words) self.assertEqual(dup, words) self.assertEqual(len(dup), len(words)) self.assertEqual(type(dup), type(words)) @@ -923,7 +923,7 @@ def test_invariant_for_the_in_operator(self): c = Counter(a=10, b=-2, c=0) for elem in c: - self.assertTrue(elem in c) + self.assertIn(elem, c) self.assertIn(elem, c) def test_multiset_operations(self): @@ -1193,7 +1193,7 @@ update_test, OrderedDict(od), ]): - self.assertTrue(dup is not od) + self.assertIsNot(dup, od) self.assertEqual(dup, od) self.assertEqual(list(dup.items()), list(od.items())) self.assertEqual(len(dup), len(od)) diff -r cf606c403f14 Lib/test/test_compile.py --- a/Lib/test/test_compile.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_compile.py Mon Nov 19 12:28:22 2012 +0200 @@ -422,7 +422,7 @@ for fname, code in sample_code: co1 = compile(code, '%s1' % fname, 'exec') ast = compile(code, '%s2' % fname, 'exec', _ast.PyCF_ONLY_AST) - self.assertTrue(type(ast) == _ast.Module) + self.assertEqual(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 -r cf606c403f14 Lib/test/test_complex.py --- a/Lib/test/test_complex.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_complex.py Mon Nov 19 12:28:22 2012 +0200 @@ -204,7 +204,7 @@ def test_boolcontext(self): for i in range(100): self.assertTrue(complex(random() + 1e-6, random() + 1e-6)) - self.assertTrue(not complex(0.0, 0.0)) + self.assertFalse(complex(0.0, 0.0)) def test_conjugate(self): self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j) @@ -289,7 +289,7 @@ self.assertEqual(split_zeros(complex(-0., 1.).real), split_zeros(-0.)) c = 3.14 + 1j - self.assertTrue(complex(c) is c) + self.assertIs(complex(c), c) del c self.assertRaises(TypeError, complex, "1", "1") diff -r cf606c403f14 Lib/test/test_concurrent_futures.py --- a/Lib/test/test_concurrent_futures.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_concurrent_futures.py Mon Nov 19 12:28:22 2012 +0200 @@ -648,8 +648,7 @@ CANCELLED_FUTURE.exception, timeout=0) self.assertRaises(futures.CancelledError, CANCELLED_AND_NOTIFIED_FUTURE.exception, timeout=0) - self.assertTrue(isinstance(EXCEPTION_FUTURE.exception(timeout=0), - OSError)) + self.assertIsInstance(EXCEPTION_FUTURE.exception(timeout=0), OSError) self.assertEqual(SUCCESSFUL_FUTURE.exception(timeout=0), None) def test_exception_with_success(self): @@ -665,7 +664,7 @@ t = threading.Thread(target=notification) t.start() - self.assertTrue(isinstance(f1.exception(timeout=5), OSError)) + self.assertIsInstance(f1.exception(timeout=5), OSError) @test.support.reap_threads def test_main(): diff -r cf606c403f14 Lib/test/test_configparser.py --- a/Lib/test/test_configparser.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_configparser.py Mon Nov 19 12:28:22 2012 +0200 @@ -266,20 +266,20 @@ # mapping access del cf['Types'] - self.assertFalse('Types' in cf) + self.assertNotIn('Types', cf) with self.assertRaises(KeyError): del cf['Types'] with self.assertRaises(ValueError): del cf[self.default_section] del cf['Spacey Bar']['foo'] - self.assertFalse('foo' in cf['Spacey Bar']) + self.assertNotIn('foo', cf['Spacey Bar']) with self.assertRaises(KeyError): del cf['Spacey Bar']['foo'] - self.assertTrue('that_value' in cf['Spacey Bar']) + self.assertIn('that_value', cf['Spacey Bar']) with self.assertRaises(KeyError): del cf['Spacey Bar']['that_value'] del cf[self.default_section]['that_value'] - self.assertFalse('that_value' in cf['Spacey Bar']) + self.assertNotIn('that_value', cf['Spacey Bar']) with self.assertRaises(KeyError): del cf[self.default_section]['that_value'] with self.assertRaises(KeyError): @@ -484,7 +484,7 @@ with self.assertRaises(KeyError): # section names are case-sensitive cf["b"]["A"] = "value" - self.assertTrue("b" in cf["a"]) + self.assertIn("b", cf["a"]) cf["A"]["A-B"] = "A-B value" for opt in ("a-b", "A-b", "a-B", "A-B"): self.assertTrue( @@ -506,7 +506,7 @@ cf = self.fromstring("[section]\n" "nekey{}nevalue\n".format(self.delimiters[0]), defaults={"key":"value"}) - self.assertTrue("Key" in cf["section"]) + self.assertIn("Key", cf["section"]) def test_default_case_sensitivity(self): cf = self.newconfig({"foo": "Bar"}) @@ -1426,7 +1426,7 @@ error.filename = 'filename' self.assertEqual(error.source, 'filename') for warning in w: - self.assertTrue(warning.category is DeprecationWarning) + self.assertIs(warning.category, DeprecationWarning) def test_interpolation_validation(self): parser = configparser.ConfigParser() @@ -1455,7 +1455,7 @@ warnings.simplefilter("always", DeprecationWarning) parser.readfp(sio, filename='StringIO') for warning in w: - self.assertTrue(warning.category is DeprecationWarning) + self.assertIs(warning.category, DeprecationWarning) self.assertEqual(len(parser), 2) self.assertEqual(parser['section']['option'], 'value') @@ -1464,7 +1464,7 @@ warnings.simplefilter("always", DeprecationWarning) parser = configparser.SafeConfigParser() for warning in w: - self.assertTrue(warning.category is DeprecationWarning) + self.assertIs(warning.category, DeprecationWarning) def test_sectionproxy_repr(self): parser = configparser.ConfigParser() diff -r cf606c403f14 Lib/test/test_copyreg.py --- a/Lib/test/test_copyreg.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_copyreg.py Mon Nov 19 12:28:22 2012 +0200 @@ -51,8 +51,8 @@ mod, func, code) copyreg.add_extension(mod, func, code) # Should be in the registry. - self.assertTrue(copyreg._extension_registry[mod, func] == code) - self.assertTrue(copyreg._inverted_registry[code] == (mod, func)) + self.assertEqual(copyreg._extension_registry[mod, func], code) + self.assertEqual(copyreg._inverted_registry[code], (mod, func)) # Shouldn't be in the cache. self.assertNotIn(code, copyreg._extension_cache) # Redundant registration should be OK. diff -r cf606c403f14 Lib/test/test_crypt.py --- a/Lib/test/test_crypt.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_crypt.py Mon Nov 19 12:28:22 2012 +0200 @@ -26,7 +26,7 @@ def test_methods(self): # Gurantee that METHOD_CRYPT is the last method in crypt.methods. - self.assertTrue(len(crypt.methods) >= 1) + self.assertGreaterEqual(len(crypt.methods), 1) self.assertEqual(crypt.METHOD_CRYPT, crypt.methods[-1]) def test_main(): diff -r cf606c403f14 Lib/test/test_dbm.py --- a/Lib/test/test_dbm.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_dbm.py Mon Nov 19 12:28:22 2012 +0200 @@ -141,7 +141,7 @@ # and test that we can find it self.assertIn(b"1", f) # and read it - self.assertTrue(f[b"1"] == b"1") + self.assertEqual(f[b"1"], b"1") f.close() self.assertEqual(name, dbm.whichdb(_fname)) diff -r cf606c403f14 Lib/test/test_dbm_gnu.py --- a/Lib/test/test_dbm_gnu.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_dbm_gnu.py Mon Nov 19 12:28:22 2012 +0200 @@ -70,7 +70,7 @@ self.g['x'] = 'x' * 10000 size1 = os.path.getsize(filename) - self.assertTrue(size0 < size1) + self.assertLess(size0, size1) del self.g['x'] # 'size' is supposed to be the same even after deleting an entry. diff -r cf606c403f14 Lib/test/test_decimal.py --- a/Lib/test/test_decimal.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_decimal.py Mon Nov 19 12:28:22 2012 +0200 @@ -750,7 +750,7 @@ for v in [-2**63-1, -2**63, -2**31-1, -2**31, 0, 2**31-1, 2**31, 2**63-1, 2**63]: d = nc.create_decimal(v) - self.assertTrue(isinstance(d, Decimal)) + self.assertIsInstance(d, Decimal) self.assertEqual(int(d), v) nc.prec = 3 @@ -4868,7 +4868,7 @@ c = DefaultContext.copy() # Signal dict methods - self.assertTrue(Overflow in c.traps) + self.assertIn(Overflow, c.traps) c.clear_traps() for k in c.traps.keys(): c.traps[k] = True @@ -4879,7 +4879,7 @@ self.assertFalse(v) self.assertFalse(c.flags.get(Overflow)) - self.assertIs(c.flags.get("x"), None) + self.assertIsNone(c.flags.get("x")) self.assertEqual(c.flags.get("x", "y"), "y") self.assertRaises(TypeError, c.flags.get, "x", "y", "z") diff -r cf606c403f14 Lib/test/test_defaultdict.py --- a/Lib/test/test_defaultdict.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_defaultdict.py Mon Nov 19 12:28:22 2012 +0200 @@ -69,7 +69,7 @@ self.assertEqual(repr(d2), "defaultdict(, {12: 42})") def foo(): return 43 d3 = defaultdict(foo) - self.assertTrue(d3.default_factory is foo) + self.assertIs(d3.default_factory, foo) d3[13] self.assertEqual(repr(d3), "defaultdict(%s, {13: 43})" % repr(foo)) @@ -134,7 +134,7 @@ d2 = copy.deepcopy(d1) self.assertEqual(d2.default_factory, foobar) self.assertEqual(d2, d1) - self.assertTrue(d1[1] is not d2[1]) + self.assertIsNot(d1[1], d2[1]) d1.default_factory = list d2 = copy.deepcopy(d1) self.assertEqual(d2.default_factory, list) diff -r cf606c403f14 Lib/test/test_deque.py --- a/Lib/test/test_deque.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_deque.py Mon Nov 19 12:28:22 2012 +0200 @@ -244,7 +244,7 @@ d = deque(data[:i]) r = d.reverse() self.assertEqual(list(d), list(reversed(data[:i]))) - self.assertIs(r, None) + self.assertIsNone(r) d.reverse() self.assertEqual(list(d), data[:i]) self.assertRaises(TypeError, d.reverse, 1) # Arity is zero @@ -347,7 +347,7 @@ self.assertRaises(RuntimeError, d.remove, 'c') for x, y in zip(d, e): # verify that original order and values are retained. - self.assertTrue(x is y) + self.assertIs(x, y) # Handle evil mutator for match in (True, False): @@ -530,7 +530,7 @@ obj.x = iter(container) del obj, container gc.collect() - self.assertTrue(ref() is None, "Cycle was not collected") + self.assertIsNone(ref(), "Cycle was not collected") check_sizeof = support.check_sizeof diff -r cf606c403f14 Lib/test/test_descr.py --- a/Lib/test/test_descr.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_descr.py Mon Nov 19 12:28:22 2012 +0200 @@ -394,7 +394,7 @@ self.assertIsInstance({}, dict) d = dict() self.assertEqual(d, {}) - self.assertTrue(d.__class__ is dict) + self.assertIs(d.__class__, dict) self.assertIsInstance(d, dict) class C(dict): state = -1 @@ -572,7 +572,7 @@ def _set_x(self, x): self.__x = -x a = A() - self.assertTrue(not hasattr(a, "x")) + self.assertFalse(hasattr(a, "x")) a.x = 12 self.assertEqual(a.x, 12) self.assertEqual(a._A__x, -12) @@ -1130,7 +1130,7 @@ x = C() x.foo = 5 self.assertEqual(x.foo, 5) - self.assertTrue(type(slots[0]) is str) + self.assertIs(type(slots[0]), str) # this used to leak references try: class C(object): @@ -1845,17 +1845,17 @@ raise IndexError c1 = C() c2 = C() - self.assertTrue(not not c1) # What? + self.assertFalse(not c1) # What? self.assertNotEqual(id(c1), id(c2)) hash(c1) hash(c2) self.assertEqual(c1, c1) self.assertTrue(c1 != c2) - self.assertTrue(not c1 != c1) - self.assertTrue(not c1 == c2) + self.assertFalse(c1 != c1) + self.assertFalse(c1 == c2) # 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.assertTrue(str(c1).find('C object at ') >= 0) + self.assertGreaterEqual(str(c1).find('C object at '), 0) self.assertEqual(str(c1), repr(c1)) self.assertNotIn(-1, c1) for i in range(10): @@ -1868,17 +1868,17 @@ raise IndexError d1 = D() d2 = D() - self.assertTrue(not not d1) + self.assertFalse(not d1) self.assertNotEqual(id(d1), id(d2)) hash(d1) hash(d2) self.assertEqual(d1, d1) self.assertNotEqual(d1, d2) - self.assertTrue(not d1 != d1) - self.assertTrue(not d1 == d2) + self.assertFalse(d1 != d1) + self.assertFalse(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.assertTrue(str(d1).find('D object at ') >= 0) + self.assertGreaterEqual(str(d1).find('D object at '), 0) self.assertEqual(str(d1), repr(d1)) self.assertNotIn(-1, d1) for i in range(10): @@ -1914,11 +1914,11 @@ p1 = Proxy(1) p_1 = Proxy(-1) self.assertFalse(p0) - self.assertTrue(not not p1) + self.assertFalse(not p1) self.assertEqual(hash(p0), hash(0)) self.assertEqual(p0, p0) self.assertNotEqual(p0, p1) - self.assertTrue(not p0 != p0) + self.assertFalse(p0 != p0) self.assertEqual(not p0, p1) self.assertTrue(p0 < p1) self.assertTrue(p0 <= p1) @@ -1950,7 +1950,7 @@ try: weakref.ref(no) except TypeError as msg: - self.assertTrue(str(msg).find("weak reference") >= 0) + self.assertIn("weak reference", str(msg)) else: self.fail("weakref.ref(no) should be illegal") class Weak(object): @@ -1996,9 +1996,9 @@ self.assertIn("fdel", attrs) self.assertEqual(raw.__doc__, "I'm the x property.") - self.assertTrue(raw.fget is C.__dict__['getx']) - self.assertTrue(raw.fset is C.__dict__['setx']) - self.assertTrue(raw.fdel is C.__dict__['delx']) + self.assertIs(raw.fget, C.__dict__['getx']) + self.assertIs(raw.fset, C.__dict__['setx']) + self.assertIs(raw.fdel, C.__dict__['delx']) for attr in "__doc__", "fget", "fset", "fdel": try: @@ -2421,13 +2421,13 @@ a = hexint(12345) self.assertEqual(a, 12345) self.assertEqual(int(a), 12345) - self.assertTrue(int(a).__class__ is int) + self.assertIs(int(a).__class__, int) self.assertEqual(hash(a), hash(12345)) - 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) + self.assertIs((+a).__class__, int) + self.assertIs((a >> 0).__class__, int) + self.assertIs((a << 0).__class__, int) + self.assertIs((hexint(0) << 12).__class__, int) + self.assertIs((hexint(0) >> 12).__class__, int) class octlong(int): __slots__ = [] @@ -2444,31 +2444,31 @@ self.assertEqual(a, 12345) self.assertEqual(int(a), 12345) self.assertEqual(hash(a), hash(12345)) - 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) + self.assertIs(int(a).__class__, int) + self.assertIs((+a).__class__, int) + self.assertIs((-a).__class__, int) + self.assertIs((-octlong(0)).__class__, int) + self.assertIs((a >> 0).__class__, int) + self.assertIs((a << 0).__class__, int) + self.assertIs((a - 0).__class__, int) + self.assertIs((a * 1).__class__, int) + self.assertIs((a ** 1).__class__, int) + self.assertIs((a // 1).__class__, int) + self.assertIs((1 * a).__class__, int) + self.assertIs((a | 0).__class__, int) + self.assertIs((a ^ 0).__class__, int) + self.assertIs((a & -1).__class__, int) + self.assertIs((octlong(0) << 12).__class__, int) + self.assertIs((octlong(0) >> 12).__class__, int) + self.assertIs(abs(octlong(0)).__class__, int) # Because octlong overrides __add__, we can't check the absence of +0 # optimizations using octlong. class longclone(int): pass a = longclone(1) - self.assertTrue((a + 0).__class__ is int) - self.assertTrue((0 + a).__class__ is int) + self.assertIs((a + 0).__class__, int) + self.assertIs((0 + a).__class__, int) # Check that negative clones don't segfault a = longclone(-1) @@ -2485,9 +2485,9 @@ a = precfloat(12345) self.assertEqual(a, 12345.0) self.assertEqual(float(a), 12345.0) - self.assertTrue(float(a).__class__ is float) + self.assertIs(float(a).__class__, float) self.assertEqual(hash(a), hash(12345.0)) - self.assertTrue((+a).__class__ is float) + self.assertIs((+a).__class__, float) class madcomplex(complex): def __repr__(self): @@ -2535,20 +2535,20 @@ self.assertEqual(v, t) a = madtuple((1,2,3,4,5)) self.assertEqual(tuple(a), (1,2,3,4,5)) - self.assertTrue(tuple(a).__class__ is tuple) + self.assertIs(tuple(a).__class__, tuple) self.assertEqual(hash(a), hash((1,2,3,4,5))) - 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) + self.assertIs(a[:].__class__, tuple) + self.assertIs((a * 1).__class__, tuple) + self.assertIs((a * 0).__class__, tuple) + self.assertIs((a + ()).__class__, tuple) a = madtuple(()) self.assertEqual(tuple(a), ()) - 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) + self.assertIs(tuple(a).__class__, tuple) + self.assertIs((a + a).__class__, tuple) + self.assertIs((a * 0).__class__, tuple) + self.assertIs((a * 1).__class__, tuple) + self.assertIs((a * 2).__class__, tuple) + self.assertIs(a[:].__class__, tuple) class madstring(str): _rev = None @@ -2570,48 +2570,48 @@ self.assertEqual(u, s) s = madstring("12345") self.assertEqual(str(s), "12345") - self.assertTrue(str(s).__class__ is str) + self.assertIs(str(s).__class__, str) base = "\x00" * 5 s = madstring(base) self.assertEqual(s, base) self.assertEqual(str(s), base) - self.assertTrue(str(s).__class__ is str) + self.assertIs(str(s).__class__, str) self.assertEqual(hash(s), hash(base)) self.assertEqual({s: 1}[base], 1) self.assertEqual({base: 1}[s], 1) - self.assertTrue((s + "").__class__ is str) + self.assertIs((s + "").__class__, str) self.assertEqual(s + "", base) - self.assertTrue(("" + s).__class__ is str) + self.assertIs(("" + s).__class__, str) self.assertEqual("" + s, base) - self.assertTrue((s * 0).__class__ is str) + self.assertIs((s * 0).__class__, str) self.assertEqual(s * 0, "") - self.assertTrue((s * 1).__class__ is str) + self.assertIs((s * 1).__class__, str) self.assertEqual(s * 1, base) - self.assertTrue((s * 2).__class__ is str) + self.assertIs((s * 2).__class__, str) self.assertEqual(s * 2, base + base) - self.assertTrue(s[:].__class__ is str) + self.assertIs(s[:].__class__, str) self.assertEqual(s[:], base) - self.assertTrue(s[0:0].__class__ is str) + self.assertIs(s[0:0].__class__, str) self.assertEqual(s[0:0], "") - self.assertTrue(s.strip().__class__ is str) + self.assertIs(s.strip().__class__, str) self.assertEqual(s.strip(), base) - self.assertTrue(s.lstrip().__class__ is str) + self.assertIs(s.lstrip().__class__, str) self.assertEqual(s.lstrip(), base) - self.assertTrue(s.rstrip().__class__ is str) + self.assertIs(s.rstrip().__class__, str) self.assertEqual(s.rstrip(), base) identitytab = {} - self.assertTrue(s.translate(identitytab).__class__ is str) + self.assertIs(s.translate(identitytab).__class__, str) self.assertEqual(s.translate(identitytab), base) - self.assertTrue(s.replace("x", "x").__class__ is str) + self.assertIs(s.replace("x", "x").__class__, str) self.assertEqual(s.replace("x", "x"), base) - self.assertTrue(s.ljust(len(s)).__class__ is str) + self.assertIs(s.ljust(len(s)).__class__, str) self.assertEqual(s.ljust(len(s)), base) - self.assertTrue(s.rjust(len(s)).__class__ is str) + self.assertIs(s.rjust(len(s)).__class__, str) self.assertEqual(s.rjust(len(s)), base) - self.assertTrue(s.center(len(s)).__class__ is str) + self.assertIs(s.center(len(s)).__class__, str) self.assertEqual(s.center(len(s)), base) - self.assertTrue(s.lower().__class__ is str) + self.assertIs(s.lower().__class__, str) self.assertEqual(s.lower(), base) class madunicode(str): @@ -2630,47 +2630,47 @@ base = "12345" u = madunicode(base) self.assertEqual(str(u), base) - self.assertTrue(str(u).__class__ is str) + self.assertIs(str(u).__class__, str) self.assertEqual(hash(u), hash(base)) self.assertEqual({u: 1}[base], 1) self.assertEqual({base: 1}[u], 1) - self.assertTrue(u.strip().__class__ is str) + self.assertIs(u.strip().__class__, str) self.assertEqual(u.strip(), base) - self.assertTrue(u.lstrip().__class__ is str) + self.assertIs(u.lstrip().__class__, str) self.assertEqual(u.lstrip(), base) - self.assertTrue(u.rstrip().__class__ is str) + self.assertIs(u.rstrip().__class__, str) self.assertEqual(u.rstrip(), base) - self.assertTrue(u.replace("x", "x").__class__ is str) + self.assertIs(u.replace("x", "x").__class__, str) self.assertEqual(u.replace("x", "x"), base) - self.assertTrue(u.replace("xy", "xy").__class__ is str) + self.assertIs(u.replace("xy", "xy").__class__, str) self.assertEqual(u.replace("xy", "xy"), base) - self.assertTrue(u.center(len(u)).__class__ is str) + self.assertIs(u.center(len(u)).__class__, str) self.assertEqual(u.center(len(u)), base) - self.assertTrue(u.ljust(len(u)).__class__ is str) + self.assertIs(u.ljust(len(u)).__class__, str) self.assertEqual(u.ljust(len(u)), base) - self.assertTrue(u.rjust(len(u)).__class__ is str) + self.assertIs(u.rjust(len(u)).__class__, str) self.assertEqual(u.rjust(len(u)), base) - self.assertTrue(u.lower().__class__ is str) + self.assertIs(u.lower().__class__, str) self.assertEqual(u.lower(), base) - self.assertTrue(u.upper().__class__ is str) + self.assertIs(u.upper().__class__, str) self.assertEqual(u.upper(), base) - self.assertTrue(u.capitalize().__class__ is str) + self.assertIs(u.capitalize().__class__, str) self.assertEqual(u.capitalize(), base) - self.assertTrue(u.title().__class__ is str) + self.assertIs(u.title().__class__, str) self.assertEqual(u.title(), base) - self.assertTrue((u + "").__class__ is str) + self.assertIs((u + "").__class__, str) self.assertEqual(u + "", base) - self.assertTrue(("" + u).__class__ is str) + self.assertIs(("" + u).__class__, str) self.assertEqual("" + u, base) - self.assertTrue((u * 0).__class__ is str) + self.assertIs((u * 0).__class__, str) self.assertEqual(u * 0, "") - self.assertTrue((u * 1).__class__ is str) + self.assertIs((u * 1).__class__, str) self.assertEqual(u * 1, base) - self.assertTrue((u * 2).__class__ is str) + self.assertIs((u * 2).__class__, str) self.assertEqual(u * 2, base + base) - self.assertTrue(u[:].__class__ is str) + self.assertIs(u[:].__class__, str) self.assertEqual(u[:], base) - self.assertTrue(u[0:0].__class__ is str) + self.assertIs(u[0:0].__class__, str) self.assertEqual(u[0:0], "") class sublist(list): @@ -2969,9 +2969,9 @@ for cls2 in C, D, E, F: x = cls() x.__class__ = cls2 - self.assertTrue(x.__class__ is cls2) + self.assertIs(x.__class__, cls2) x.__class__ = cls - self.assertTrue(x.__class__ is cls) + self.assertIs(x.__class__, cls) def cant(x, C): try: x.__class__ = C @@ -3027,11 +3027,11 @@ x = cls() x.a = 1 x.__class__ = cls2 - self.assertTrue(x.__class__ is cls2, + self.assertIs(x.__class__, cls2, "assigning %r as __class__ for %r silently failed" % (cls2, x)) self.assertEqual(x.a, 1) x.__class__ = cls - self.assertTrue(x.__class__ is cls, + self.assertIs(x.__class__, 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: @@ -3200,7 +3200,7 @@ for cls in C, C1, C2: s = pickle.dumps(cls, bin) cls2 = pickle.loads(s) - self.assertTrue(cls2 is cls) + self.assertIs(cls2, cls) a = C1(1, 2); a.append(42); a.append(24) b = C2("hello", "world", 42) @@ -3230,7 +3230,7 @@ import copy for cls in C, C1, C2: cls2 = copy.deepcopy(cls) - self.assertTrue(cls2 is cls) + self.assertIs(cls2, cls) a = C1(1, 2); a.append(42); a.append(24) b = C2("hello", "world", 42) @@ -4260,17 +4260,17 @@ l = [] self.assertEqual(l.__add__, l.__add__) self.assertEqual(l.__add__, [].__add__) - self.assertTrue(l.__add__ != [5].__add__) - self.assertTrue(l.__add__ != l.__mul__) - self.assertTrue(l.__add__.__name__ == '__add__') + self.assertNotEqual(l.__add__, [5].__add__) + self.assertNotEqual(l.__add__, l.__mul__) + self.assertEqual(l.__add__.__name__, '__add__') if hasattr(l.__add__, '__self__'): # CPython - self.assertTrue(l.__add__.__self__ is l) - self.assertTrue(l.__add__.__objclass__ is list) + self.assertIs(l.__add__.__self__, l) + self.assertIs(l.__add__.__objclass__, list) else: # Python implementations where [].__add__ is a normal bound method - self.assertTrue(l.__add__.im_self is l) - self.assertTrue(l.__add__.im_class is list) + self.assertIs(l.__add__.im_self, l) + self.assertIs(l.__add__.im_class, list) self.assertEqual(l.__add__.__doc__, list.__add__.__doc__) try: hash(l.__add__) @@ -4437,7 +4437,7 @@ fake_str = FakeStr() # isinstance() reads __class__ - self.assertTrue(isinstance(fake_str, str)) + self.assertIsInstance(fake_str, str) # call a method descriptor with self.assertRaises(TypeError): diff -r cf606c403f14 Lib/test/test_dict.py --- a/Lib/test/test_dict.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_dict.py Mon Nov 19 12:28:22 2012 +0200 @@ -272,10 +272,10 @@ def test_get(self): d = {} - self.assertIs(d.get('c'), None) + self.assertIsNone(d.get('c')) self.assertEqual(d.get('c', 3), 3) d = {'a': 1, 'b': 2} - self.assertIs(d.get('c'), None) + self.assertIsNone(d.get('c')) self.assertEqual(d.get('c', 3), 3) self.assertEqual(d.get('a'), 1) self.assertEqual(d.get('a', 3), 1) @@ -285,9 +285,9 @@ def test_setdefault(self): # dict.setdefault() d = {} - self.assertIs(d.setdefault('key0'), None) + self.assertIsNone(d.setdefault('key0')) d.setdefault('key0', []) - self.assertIs(d.setdefault('key0'), None) + self.assertIsNone(d.setdefault('key0')) d.setdefault('key', []).append(3) self.assertEqual(d['key'][0], 3) d.setdefault('key', []).append(4) @@ -730,7 +730,7 @@ obj.x = iter(obj.v) del obj, container gc.collect() - self.assertIs(ref(), None, "Cycle was not collected") + self.assertIsNone(ref(), "Cycle was not collected") def _not_tracked(self, t): # Nested containers can take several collections to untrack @@ -861,7 +861,7 @@ # merely an object supporting the iterator protocol, yielding # the same objects as the original one. # self.assertEqual(type(itorg), type(it)) - self.assertTrue(isinstance(it, collections.abc.Iterator)) + self.assertIsInstance(it, collections.abc.Iterator) self.assertEqual(dict(it), data) it = pickle.loads(d) diff -r cf606c403f14 Lib/test/test_dummy_thread.py --- a/Lib/test/test_dummy_thread.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_dummy_thread.py Mon Nov 19 12:28:22 2012 +0200 @@ -24,14 +24,14 @@ def test_initlock(self): #Make sure locks start locked - self.assertTrue(not self.lock.locked(), + self.assertFalse(self.lock.locked(), "Lock object is not initialized unlocked.") def test_release(self): # Test self.lock.release() self.lock.acquire() self.lock.release() - self.assertTrue(not self.lock.locked(), + self.assertFalse(self.lock.locked(), "Lock object did not release properly.") def test_improper_release(self): @@ -46,7 +46,7 @@ def test_cond_acquire_fail(self): #Test acquiring locked lock returns False self.lock.acquire(0) - self.assertTrue(not self.lock.acquire(0), + self.assertFalse(self.lock.acquire(0), "Conditional acquiring of a locked lock incorrectly " "succeeded.") @@ -58,9 +58,9 @@ def test_uncond_acquire_return_val(self): #Make sure that an unconditional locking returns True. - self.assertTrue(self.lock.acquire(1) is True, + self.assertIs(self.lock.acquire(1), True, "Unconditional locking did not return True.") - self.assertTrue(self.lock.acquire() is True) + self.assertIs(self.lock.acquire(), True) def test_uncond_acquire_blocking(self): #Make sure that unconditional acquiring of a locked lock blocks. @@ -80,7 +80,7 @@ end_time = int(time.time()) if support.verbose: print("done") - self.assertTrue((end_time - start_time) >= DELAY, + self.assertGreaterEqual(end_time - start_time, DELAY, "Blocking by unconditional acquiring failed.") class MiscTests(unittest.TestCase): @@ -94,7 +94,7 @@ #Test sanity of _thread.get_ident() self.assertIsInstance(_thread.get_ident(), int, "_thread.get_ident() returned a non-integer") - self.assertTrue(_thread.get_ident() != 0, + self.assertNotEqual(_thread.get_ident(), 0, "_thread.get_ident() returned 0") def test_LockType(self): @@ -164,7 +164,7 @@ time.sleep(DELAY) if support.verbose: print('done') - self.assertTrue(testing_queue.qsize() == thread_count, + self.assertEqual(testing_queue.qsize(), thread_count, "Not all %s threads executed properly after %s sec." % (thread_count, DELAY)) diff -r cf606c403f14 Lib/test/test_email/test_defect_handling.py --- a/Lib/test/test_email/test_defect_handling.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_email/test_defect_handling.py Mon Nov 19 12:28:22 2012 +0200 @@ -59,8 +59,8 @@ inner = msg.get_payload(0) self.assertTrue(hasattr(inner, 'defects')) self.assertEqual(len(self.get_defects(inner)), 1) - self.assertTrue(isinstance(self.get_defects(inner)[0], - errors.StartBoundaryNotFoundDefect)) + self.assertIsInstance(self.get_defects(inner)[0], + errors.StartBoundaryNotFoundDefect) def test_multipart_no_boundary(self): source = textwrap.dedent("""\ @@ -84,12 +84,12 @@ with self._raise_point(errors.NoBoundaryInMultipartDefect): msg = self._str_msg(source) if self.raise_expected: return - self.assertTrue(isinstance(msg.get_payload(), str)) + self.assertIsInstance(msg.get_payload(), str) self.assertEqual(len(self.get_defects(msg)), 2) - self.assertTrue(isinstance(self.get_defects(msg)[0], - errors.NoBoundaryInMultipartDefect)) - self.assertTrue(isinstance(self.get_defects(msg)[1], - errors.MultipartInvariantViolationDefect)) + self.assertIsInstance(self.get_defects(msg)[0], + errors.NoBoundaryInMultipartDefect) + self.assertIsInstance(self.get_defects(msg)[1], + errors.MultipartInvariantViolationDefect) multipart_msg = textwrap.dedent("""\ Date: Wed, 14 Nov 2007 12:56:23 GMT @@ -153,10 +153,10 @@ if self.raise_expected: return self.assertTrue(hasattr(msg, 'defects')) self.assertEqual(len(self.get_defects(msg)), 2) - self.assertTrue(isinstance(self.get_defects(msg)[0], - errors.NoBoundaryInMultipartDefect)) - self.assertTrue(isinstance(self.get_defects(msg)[1], - errors.MultipartInvariantViolationDefect)) + self.assertIsInstance(self.get_defects(msg)[0], + errors.NoBoundaryInMultipartDefect) + self.assertIsInstance(self.get_defects(msg)[1], + errors.MultipartInvariantViolationDefect) def test_missing_start_boundary(self): source = textwrap.dedent("""\ @@ -193,8 +193,8 @@ if self.raise_expected: return bad = outer.get_payload(1).get_payload(0) self.assertEqual(len(self.get_defects(bad)), 1) - self.assertTrue(isinstance(self.get_defects(bad)[0], - errors.StartBoundaryNotFoundDefect)) + self.assertIsInstance(self.get_defects(bad)[0], + errors.StartBoundaryNotFoundDefect) def test_first_line_is_continuation_header(self): with self._raise_point(errors.FirstHeaderLineIsContinuationDefect): diff -r cf606c403f14 Lib/test/test_email/test_email.py --- a/Lib/test/test_email/test_email.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_email/test_email.py Mon Nov 19 12:28:22 2012 +0200 @@ -241,12 +241,12 @@ msg['From'] = 'Me' msg['to'] = 'You' # Check for case insensitivity - 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) + self.assertIn('from', msg) + self.assertIn('From', msg) + self.assertIn('FROM', msg) + self.assertIn('to', msg) + self.assertIn('To', msg) + self.assertIn('TO', msg) def test_as_string(self): eq = self.ndiffAssertEqual @@ -344,7 +344,7 @@ unless('header' in msg) unless('Header' in msg) unless('HEADER' in msg) - self.assertFalse('headerx' in msg) + self.assertNotIn('headerx', msg) def test_set_param(self): eq = self.assertEqual @@ -1438,7 +1438,7 @@ def test_payload(self): self.assertEqual(self._msg.get_payload(), 'hello there') - self.assertTrue(not self._msg.is_multipart()) + self.assertFalse(self._msg.is_multipart()) def test_charset(self): eq = self.assertEqual @@ -1457,7 +1457,7 @@ msg = MIMEText('hello there') eq(msg.get_charset(), 'us-ascii') eq(msg['content-type'], 'text/plain; charset="us-ascii"') - self.assertTrue('hello there' in msg.as_string()) + self.assertIn('hello there', msg.as_string()) def test_utf8_input(self): teststr = '\u043a\u0438\u0440\u0438\u043b\u0438\u0446\u0430' @@ -2000,8 +2000,8 @@ # [*] This message is missing its start boundary bad = outer.get_payload(1).get_payload(0) self.assertEqual(len(bad.defects), 1) - self.assertTrue(isinstance(bad.defects[0], - errors.StartBoundaryNotFoundDefect)) + self.assertIsInstance(bad.defects[0], + errors.StartBoundaryNotFoundDefect) # test_defect_handling def test_first_line_is_continuation_header(self): @@ -2219,7 +2219,7 @@ unless(isinstance(payload, list)) eq(len(payload), 1) submsg = payload[0] - self.assertTrue(isinstance(submsg, Message)) + self.assertIsInstance(submsg, Message) eq(submsg['subject'], 'An enclosed message') eq(submsg.get_payload(), 'Here is the body of the message.\n') @@ -2596,7 +2596,7 @@ eq(msg2.get_payload(), 'Yadda yadda yadda' + self.linesep) msg3 = msg.get_payload(2) eq(msg3.get_content_type(), 'message/rfc822') - self.assertTrue(isinstance(msg3, Message)) + self.assertIsInstance(msg3, Message) payload = msg3.get_payload() unless(isinstance(payload, list)) eq(len(payload), 1) @@ -2616,9 +2616,9 @@ unless(isinstance(payload, list)) eq(len(payload), 1) msg1 = payload[0] - self.assertTrue(isinstance(msg1, Message)) + self.assertIsInstance(msg1, Message) eq(msg1.get_content_type(), 'text/plain') - self.assertTrue(isinstance(msg1.get_payload(), str)) + self.assertIsInstance(msg1.get_payload(), str) eq(msg1.get_payload(), self.linesep) @@ -2686,7 +2686,7 @@ def __init__(self): super().__init__() msg = self._str_msg("Subject: test\n\ntest", MyMessage) - self.assertTrue(isinstance(msg, MyMessage)) + self.assertIsInstance(msg, MyMessage) def test__all__(self): module = __import__('email') @@ -3142,9 +3142,9 @@ break om.append(ol) n1 += 1 - self.assertTrue(n == n1) - self.assertTrue(len(om) == nt) - self.assertTrue(''.join([il for il, n in imt]) == ''.join(om)) + self.assertEqual(n, n1) + self.assertEqual(len(om), nt) + self.assertEqual(''.join([il for il, n in imt]), ''.join(om)) @@ -3159,7 +3159,7 @@ eq(msg['to'], '[email protected]') eq(msg.get_content_type(), 'multipart/mixed') self.assertFalse(msg.is_multipart()) - self.assertTrue(isinstance(msg.get_payload(), str)) + self.assertIsInstance(msg.get_payload(), str) def test_bytes_header_parser(self): eq = self.assertEqual @@ -3170,8 +3170,8 @@ eq(msg['to'], '[email protected]') eq(msg.get_content_type(), 'multipart/mixed') self.assertFalse(msg.is_multipart()) - self.assertTrue(isinstance(msg.get_payload(), str)) - self.assertTrue(isinstance(msg.get_payload(decode=True), bytes)) + self.assertIsInstance(msg.get_payload(), str) + self.assertIsInstance(msg.get_payload(decode=True), bytes) def test_whitespace_continuation(self): eq = self.assertEqual @@ -4211,7 +4211,7 @@ 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.assertTrue(len(l) <= 76) + self.assertLessEqual(len(l), 76) def test_multilingual(self): eq = self.ndiffAssertEqual @@ -4680,7 +4680,7 @@ ''' msg = email.message_from_string(m) param = msg.get_param('NAME') - self.assertFalse(isinstance(param, tuple)) + self.assertNotIsInstance(param, tuple) self.assertEqual( param, 'file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm') @@ -4839,7 +4839,7 @@ """ msg = email.message_from_string(m) param = msg.get_param('name') - self.assertFalse(isinstance(param, tuple)) + self.assertNotIsInstance(param, tuple) self.assertEqual(param, "Frank's Document") # test_headerregistry.TestContentTypeHeader.rfc2231_single_quote_in_value_with_charset_and_lang @@ -4865,7 +4865,7 @@ """ msg = email.message_from_string(m) param = msg.get_param('name') - self.assertFalse(isinstance(param, tuple)) + self.assertNotIsInstance(param, tuple) self.assertEqual(param, "us-ascii'en-us'Frank's Document") # test_headerregistry.TestContentTypeHeader.rfc2231_single_quotes_inside_quotes diff -r cf606c403f14 Lib/test/test_email/test_parser.py --- a/Lib/test/test_email/test_parser.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_email/test_parser.py Mon Nov 19 12:28:22 2012 +0200 @@ -18,7 +18,7 @@ msg = email.message_from_string("Subject: bogus\n\nmsg\n", self.MyMessage, policy=self.MyPolicy) - self.assertTrue(isinstance(msg, self.MyMessage)) + self.assertIsInstance(msg, self.MyMessage) self.assertIs(msg.check_policy, self.MyPolicy) def test_custom_message_gets_policy_if_possible_from_file(self): @@ -26,7 +26,7 @@ msg = email.message_from_file(source_file, self.MyMessage, policy=self.MyPolicy) - self.assertTrue(isinstance(msg, self.MyMessage)) + self.assertIsInstance(msg, self.MyMessage) self.assertIs(msg.check_policy, self.MyPolicy) # XXX add tests for other functions that take Message arg. diff -r cf606c403f14 Lib/test/test_email/test_utils.py --- a/Lib/test/test_email/test_utils.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_email/test_utils.py Mon Nov 19 12:28:22 2012 +0200 @@ -53,12 +53,12 @@ def test_localtime_is_tz_aware_daylight_true(self): test.support.patch(self, time, 'daylight', True) t = utils.localtime() - self.assertIsNot(t.tzinfo, None) + self.assertIsNotNone(t.tzinfo) def test_localtime_is_tz_aware_daylight_false(self): test.support.patch(self, time, 'daylight', False) t = utils.localtime() - self.assertIsNot(t.tzinfo, None) + self.assertIsNotNone(t.tzinfo) def test_localtime_daylight_true_dst_false(self): test.support.patch(self, time, 'daylight', True) diff -r cf606c403f14 Lib/test/test_epoll.py --- a/Lib/test/test_epoll.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_epoll.py Mon Nov 19 12:28:22 2012 +0200 @@ -70,8 +70,8 @@ ep = select.epoll(16) except OSError as e: raise AssertionError(str(e)) - self.assertTrue(ep.fileno() > 0, ep.fileno()) - self.assertTrue(not ep.closed) + self.assertGreater(ep.fileno(), 0) + self.assertFalse(ep.closed) ep.close() self.assertTrue(ep.closed) self.assertRaises(ValueError, ep.fileno) diff -r cf606c403f14 Lib/test/test_exceptions.py --- a/Lib/test/test_exceptions.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_exceptions.py Mon Nov 19 12:28:22 2012 +0200 @@ -500,7 +500,7 @@ pass obj = None obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # Qualified "except" without "as" obj = MyObj() @@ -511,7 +511,7 @@ pass obj = None obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # Bare "except" obj = MyObj() @@ -522,7 +522,7 @@ pass obj = None obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # "except" with premature block leave obj = MyObj() @@ -534,7 +534,7 @@ break obj = None obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # "except" block raising another exception obj = MyObj() @@ -555,7 +555,7 @@ # guarantee no ref cycles on CPython (don't gc_collect) if check_impl_detail(cpython=False): gc_collect() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # Some complicated construct obj = MyObj() @@ -574,7 +574,7 @@ if check_impl_detail(cpython=False): gc_collect() obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # Inside an exception-silencing "with" block class Context: @@ -590,7 +590,7 @@ if check_impl_detail(cpython=False): gc_collect() obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) def test_exception_target_in_nested_scope(self): # issue 4617: This used to raise a SyntaxError @@ -696,7 +696,7 @@ testfunc(g) g = obj = None obj = wr() - self.assertIs(obj, None) + self.assertIsNone(obj) def test_generator_throw_cleanup_exc_state(self): def do_throw(g): @@ -815,7 +815,7 @@ except RuntimeError: return sys.exc_info() e, v, tb = g() - self.assertTrue(isinstance(v, RuntimeError), type(v)) + self.assertIsInstance(v, RuntimeError, type(v)) self.assertIn("maximum recursion depth exceeded", str(v)) diff -r cf606c403f14 Lib/test/test_faulthandler.py --- a/Lib/test/test_faulthandler.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_faulthandler.py Mon Nov 19 12:28:22 2012 +0200 @@ -231,7 +231,7 @@ not_expected = 'Fatal Python error' stderr, exitcode = self.get_output(code) stder = '\n'.join(stderr) - self.assertTrue(not_expected not in stderr, + self.assertNotIn(not_expected, stderr, "%r is present in %r" % (not_expected, stderr)) self.assertNotEqual(exitcode, 0) diff -r cf606c403f14 Lib/test/test_file.py --- a/Lib/test/test_file.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_file.py Mon Nov 19 12:28:22 2012 +0200 @@ -83,8 +83,8 @@ def testErrors(self): f = self.f self.assertEqual(f.name, TESTFN) - self.assertTrue(not f.isatty()) - self.assertTrue(not f.closed) + self.assertFalse(f.isatty()) + self.assertFalse(f.closed) if hasattr(f, "readinto"): self.assertRaises((IOError, TypeError), f.readinto, "") diff -r cf606c403f14 Lib/test/test_filecmp.py --- a/Lib/test/test_filecmp.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_filecmp.py Mon Nov 19 12:28:22 2012 +0200 @@ -69,10 +69,10 @@ shutil.rmtree(self.dir_diff) def test_cmpfiles(self): - self.assertTrue(filecmp.cmpfiles(self.dir, self.dir, ['file']) == + self.assertEqual(filecmp.cmpfiles(self.dir, self.dir, ['file']), (['file'], [], []), "Comparing directory to itself fails") - self.assertTrue(filecmp.cmpfiles(self.dir, self.dir_same, ['file']) == + self.assertEqual(filecmp.cmpfiles(self.dir, self.dir_same, ['file']), (['file'], [], []), "Comparing directory to same fails") diff -r cf606c403f14 Lib/test/test_fileio.py --- a/Lib/test/test_fileio.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_fileio.py Mon Nov 19 12:28:22 2012 +0200 @@ -113,15 +113,15 @@ def testErrors(self): f = self.f - self.assertTrue(not f.isatty()) - self.assertTrue(not f.closed) + self.assertFalse(f.isatty()) + self.assertFalse(f.closed) #self.assertEqual(f.name, TESTFN) self.assertRaises(ValueError, f.read, 10) # Open for reading f.close() self.assertTrue(f.closed) f = _FileIO(TESTFN, 'r') self.assertRaises(TypeError, f.readinto, "") - self.assertTrue(not f.closed) + self.assertFalse(f.closed) f.close() self.assertTrue(f.closed) diff -r cf606c403f14 Lib/test/test_fnmatch.py --- a/Lib/test/test_fnmatch.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_fnmatch.py Mon Nov 19 12:28:22 2012 +0200 @@ -13,7 +13,7 @@ "expected %r to match pattern %r" % (filename, pattern)) else: - self.assertTrue(not fn(filename, pattern), + self.assertFalse(fn(filename, pattern), "expected %r not to match pattern %r" % (filename, pattern)) diff -r cf606c403f14 Lib/test/test_ftplib.py --- a/Lib/test/test_ftplib.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_ftplib.py Mon Nov 19 12:28:22 2012 +0200 @@ -932,7 +932,7 @@ def testTimeoutDefault(self): # default -- use global socket timeout - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: ftp = ftplib.FTP("localhost") @@ -944,13 +944,13 @@ def testTimeoutNone(self): # no timeout -- do not use global socket timeout - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: ftp = ftplib.FTP("localhost", timeout=None) finally: socket.setdefaulttimeout(None) - self.assertTrue(ftp.sock.gettimeout() is None) + self.assertIsNone(ftp.sock.gettimeout()) self.evt.wait() ftp.close() diff -r cf606c403f14 Lib/test/test_funcattrs.py --- a/Lib/test/test_funcattrs.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_funcattrs.py Mon Nov 19 12:28:22 2012 +0200 @@ -336,10 +336,10 @@ pass c = classmethod(f) - self.assertTrue(c.__func__ is f) + self.assertIs(c.__func__, f) s = staticmethod(f) - self.assertTrue(s.__func__ is f) + self.assertIs(s.__func__, f) class BuiltinFunctionPropertiesTest(unittest.TestCase): diff -r cf606c403f14 Lib/test/test_functools.py --- a/Lib/test/test_functools.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_functools.py Mon Nov 19 12:28:22 2012 +0200 @@ -225,13 +225,13 @@ updated=functools.WRAPPER_UPDATES): # Check attributes were assigned for name in assigned: - self.assertTrue(getattr(wrapper, name) is getattr(wrapped, name)) + self.assertIs(getattr(wrapper, name), 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.assertTrue(wrapped_attr[key] is wrapper_attr[key]) + self.assertIs(wrapped_attr[key], wrapper_attr[key]) def _default_update(self): def f(a:'This is a new annotation'): @@ -670,7 +670,7 @@ expected = orig(x, y) self.assertEqual(actual, expected) hits, misses, maxsize, currsize = f.cache_info() - self.assertTrue(hits > misses) + self.assertGreater(hits, misses) self.assertEqual(hits + misses, 1000) self.assertEqual(currsize, 20) diff -r cf606c403f14 Lib/test/test_gc.py --- a/Lib/test/test_gc.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_gc.py Mon Nov 19 12:28:22 2012 +0200 @@ -711,9 +711,9 @@ # Check that we got the right info dict for all callbacks for v in self.visit: info = v[2] - self.assertTrue("generation" in info) - self.assertTrue("collected" in info) - self.assertTrue("uncollectable" in info) + self.assertIn("generation", info) + self.assertIn("collected", info) + self.assertIn("uncollectable", info) def test_collect_generation(self): self.preclean() diff -r cf606c403f14 Lib/test/test_gdb.py --- a/Lib/test/test_gdb.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_gdb.py Mon Nov 19 12:28:22 2012 +0200 @@ -210,7 +210,7 @@ class PrettyPrintTests(DebuggerTests): def test_getting_backtrace(self): gdb_output = self.get_stack_trace('id(42)') - self.assertTrue(BREAKPOINT_FN in gdb_output) + self.assertIn(BREAKPOINT_FN, gdb_output) def assertGdbRepr(self, val, exp_repr=None, cmds_after_breakpoint=None): # Ensure that gdb's rendering of the value in a debugged process diff -r cf606c403f14 Lib/test/test_grammar.py --- a/Lib/test/test_grammar.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_grammar.py Mon Nov 19 12:28:22 2012 +0200 @@ -32,9 +32,9 @@ if maxsize == 2147483647: self.assertEqual(-2147483647-1, -0o20000000000) # XXX -2147483648 - self.assertTrue(0o37777777777 > 0) - self.assertTrue(0xffffffff > 0) - self.assertTrue(0b1111111111111111111111111111111 > 0) + self.assertGreater(0o37777777777, 0) + self.assertGreater(0xffffffff, 0) + self.assertGreater(0b1111111111111111111111111111111, 0) for s in ('2147483648', '0o40000000000', '0x100000000', '0b10000000000000000000000000000000'): try: @@ -43,9 +43,9 @@ self.fail("OverflowError on huge integer literal %r" % s) elif maxsize == 9223372036854775807: self.assertEqual(-9223372036854775807-1, -0o1000000000000000000000) - self.assertTrue(0o1777777777777777777777 > 0) - self.assertTrue(0xffffffffffffffff > 0) - self.assertTrue(0b11111111111111111111111111111111111111111111111111111111111111 > 0) + self.assertGreater(0o1777777777777777777777, 0) + self.assertGreater(0xffffffffffffffff, 0) + self.assertGreater(0b11111111111111111111111111111111111111111111111111111111111111, 0) for s in '9223372036854775808', '0o2000000000000000000000', \ '0x10000000000000000', \ '0b100000000000000000000000000000000000000000000000000000000000000': @@ -122,7 +122,7 @@ def test_ellipsis(self): x = ... - self.assertTrue(x is Ellipsis) + self.assertIs(x, Ellipsis) self.assertRaises(SyntaxError, eval, ".. .") def test_eof_error(self): diff -r cf606c403f14 Lib/test/test_gzip.py --- a/Lib/test/test_gzip.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_gzip.py Mon Nov 19 12:28:22 2012 +0200 @@ -151,7 +151,7 @@ while 1: L = f.readline(line_length) if not L and line_length != 0: break - self.assertTrue(len(L) <= line_length) + self.assertLessEqual(len(L), line_length) line_length = (line_length + 1) % 50 def test_readlines(self): diff -r cf606c403f14 Lib/test/test_heapq.py --- a/Lib/test/test_heapq.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_heapq.py Mon Nov 19 12:28:22 2012 +0200 @@ -61,7 +61,7 @@ for pos, item in enumerate(heap): if pos: # pos 0 has no parent parentpos = (pos-1) >> 1 - self.assertTrue(heap[parentpos] <= item) + self.assertLessEqual(heap[parentpos], item) def test_heapify(self): for size in range(30): diff -r cf606c403f14 Lib/test/test_hmac.py --- a/Lib/test/test_hmac.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_hmac.py Mon Nov 19 12:28:22 2012 +0200 @@ -286,7 +286,7 @@ # Testing if attributes are of same type. h1 = hmac.HMAC(b"key") h2 = h1.copy() - self.assertTrue(h1.digest_cons == h2.digest_cons, + self.assertEqual(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.") @@ -297,11 +297,11 @@ # Testing if the copy method created a real copy. h1 = hmac.HMAC(b"key") h2 = h1.copy() - # Using id() in case somebody has overridden __eq__/__ne__. - self.assertTrue(id(h1) != id(h2), "No real copy of the HMAC instance.") - self.assertTrue(id(h1.inner) != id(h2.inner), + # Using "is" in case somebody has overridden __eq__/__ne__. + self.assertIsNot(h1, h2, "No real copy of the HMAC instance.") + self.assertIsNot(h1.inner, h2.inner, "No real copy of the attribute 'inner'.") - self.assertTrue(id(h1.outer) != id(h2.outer), + self.assertIsNot(h1.outer, h2.outer, "No real copy of the attribute 'outer'.") def test_equality(self): diff -r cf606c403f14 Lib/test/test_http_cookiejar.py --- a/Lib/test/test_http_cookiejar.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_http_cookiejar.py Mon Nov 19 12:28:22 2012 +0200 @@ -93,7 +93,7 @@ '01-01-1980 00:61:00', '01-01-1980 00:00:62', ]: - self.assertTrue(http2time(test) is None, + self.assertIsNone(http2time(test), "http2time(%s) is not None\n" "http2time(test) %s" % (test, http2time(test)) ) @@ -348,7 +348,7 @@ request = urllib.request.Request(url) r = pol.domain_return_ok(domain, request) if ok: self.assertTrue(r) - else: self.assertTrue(not r) + else: self.assertFalse(r) def test_missing_value(self): # missing = sign in Cookie: header is regarded by Mozilla as a missing @@ -358,10 +358,10 @@ 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.assertTrue(cookie.value is None) + self.assertIsNone(cookie.value) self.assertEqual(cookie.name, "eggs") cookie = c._cookies["www.acme.com"]['/foo/']['"spam"'] - self.assertTrue(cookie.value is None) + self.assertIsNone(cookie.value) self.assertEqual(cookie.name, '"spam"') self.assertEqual(lwp_cookie_str(cookie), ( r'"spam"; path="/foo/"; domain="www.acme.com"; ' @@ -403,7 +403,7 @@ try: cookie = c._cookies["www.example.com"]["/"]["ni"] except KeyError: - self.assertTrue(version is None) # didn't expect a stored cookie + self.assertIsNone(version) # didn't expect a stored cookie else: self.assertEqual(cookie.version, version) # 2965 cookies are unaffected @@ -427,26 +427,26 @@ self.assertEqual(cookie.domain, ".acme.com") self.assertTrue(cookie.domain_specified) self.assertEqual(cookie.port, DEFAULT_HTTP_PORT) - self.assertTrue(not cookie.port_specified) + self.assertFalse(cookie.port_specified) # case is preserved self.assertTrue(cookie.has_nonstandard_attr("blArgh") and not cookie.has_nonstandard_attr("blargh")) cookie = c._cookies["www.acme.com"]["/"]["ni"] self.assertEqual(cookie.domain, "www.acme.com") - self.assertTrue(not cookie.domain_specified) + self.assertFalse(cookie.domain_specified) self.assertEqual(cookie.port, "80,8080") self.assertTrue(cookie.port_specified) cookie = c._cookies["www.acme.com"]["/"]["nini"] - self.assertTrue(cookie.port is None) - self.assertTrue(not cookie.port_specified) + self.assertIsNone(cookie.port) + self.assertFalse(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.assertTrue(foo.expires is None) - self.assertTrue(spam.expires is None) + self.assertIsNone(foo.expires) + self.assertIsNone(spam.expires) def test_ns_parser_special_names(self): # names such as 'expires' are not special in first name=value pair @@ -616,12 +616,12 @@ def test_is_HDN(self): 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.")) + self.assertFalse(is_HDN("192.168.1.1")) + self.assertFalse(is_HDN("")) + self.assertFalse(is_HDN(".")) + self.assertFalse(is_HDN(".foo.bar.com")) + self.assertFalse(is_HDN("..foo")) + self.assertFalse(is_HDN("foo.")) def test_reach(self): self.assertEqual(reach("www.acme.com"), ".acme.com") @@ -635,39 +635,39 @@ def test_domain_match(self): 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.assertFalse(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.assertFalse(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.assertFalse(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.assertFalse(domain_match("blah.blah", "")) + self.assertFalse(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.assertFalse(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.assertFalse(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.assertFalse(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.assertFalse(user_domain_match("x.y.com", "com")) + self.assertFalse(user_domain_match("x.y.com", "m")) + self.assertFalse(user_domain_match("x.y.com", ".m")) + self.assertFalse(user_domain_match("x.y.com", "")) + self.assertFalse(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.assertTrue(not user_domain_match("192.168.1.1", ".168.1.1")) - self.assertTrue(not user_domain_match("192.168.1.1", ".")) + self.assertFalse(user_domain_match("192.168.1.1", ".168.1.1")) + self.assertFalse(user_domain_match("192.168.1.1", ".")) # empty string is a special case - self.assertTrue(not user_domain_match("192.168.1.1", "")) + self.assertFalse(user_domain_match("192.168.1.1", "")) def test_wrong_domain(self): # Cookies whose effective request-host name does not domain-match the @@ -814,7 +814,7 @@ self.assertEqual(len(c), 2) # ... and check is doesn't get returned c.add_cookie_header(req) - self.assertTrue(not req.has_header("Cookie")) + self.assertFalse(req.has_header("Cookie")) def test_domain_block(self): pol = DefaultCookiePolicy( @@ -854,7 +854,7 @@ self.assertEqual(len(c), 2) # ... and check is doesn't get returned c.add_cookie_header(req) - self.assertTrue(not req.has_header("Cookie")) + self.assertFalse(req.has_header("Cookie")) def test_secure(self): for ns in True, False: @@ -1000,7 +1000,7 @@ for i in range(4): i = 0 for c in cs: - self.assertTrue(isinstance(c, Cookie)) + self.assertIsInstance(c, Cookie) self.assertEqual(c.version, versions[i]) self.assertEqual(c.name, names[i]) self.assertEqual(c.domain, domains[i]) @@ -1055,7 +1055,7 @@ 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.assertTrue(cookie.expires is None) + self.assertIsNone(cookie.expires) class LWPCookieTests(unittest.TestCase): @@ -1234,7 +1234,7 @@ cookie = interact_2965( c, 'http://www.acme.com/acme/login', 'Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"') - self.assertTrue(not cookie) + self.assertFalse(cookie) # # 3. User Agent -> Server @@ -1382,7 +1382,7 @@ # illegal domain (no embedded dots) cookie = interact_2965(c, "http://www.acme.com", 'foo=bar; domain=".com"; version=1') - self.assertTrue(not c) + self.assertFalse(c) # legal domain cookie = interact_2965(c, "http://www.acme.com", @@ -1479,7 +1479,7 @@ cookie = interact_2965( c, "http://www.acme.com/foo/%25/<<%0anew\345/\346\370\345") - self.assertTrue(not cookie) + self.assertFalse(cookie) # unicode URL doesn't raise exception cookie = interact_2965(c, "http://www.acme.com/\xfc") @@ -1640,13 +1640,12 @@ key = "%s_after" % cookie.value counter[key] = counter[key] + 1 - self.assertTrue(not ( # a permanent cookie got lost accidently - counter["perm_after"] != counter["perm_before"] or + self.assertEqual(counter["perm_after"], counter["perm_before"]) # a session cookie hasn't been cleared - counter["session_after"] != 0 or + self.assertEqual(counter["session_after"], 0) # we didn't have session cookies in the first place - counter["session_before"] == 0)) + self.assertNotEqual(counter["session_before"], 0) def test_main(verbose=None): diff -r cf606c403f14 Lib/test/test_httplib.py --- a/Lib/test/test_httplib.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_httplib.py Mon Nov 19 12:28:22 2012 +0200 @@ -132,7 +132,7 @@ conn.sock = FakeSocket(None) conn.putrequest('GET','/') conn.putheader('Content-length', 42) - self.assertTrue(b'Content-length: 42' in conn._buffer) + self.assertIn(b'Content-length: 42', conn._buffer) def test_ipv6host_header(self): # Default host header on IPv6 transaction should wrapped by [] if @@ -579,7 +579,7 @@ # and into the socket. # default -- use global socket timeout - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: httpConn = client.HTTPConnection(HOST, TimeoutTest.PORT) @@ -590,7 +590,7 @@ httpConn.close() # no timeout -- do not use global socket default - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: httpConn = client.HTTPConnection(HOST, TimeoutTest.PORT, diff -r cf606c403f14 Lib/test/test_httpservers.py --- a/Lib/test/test_httpservers.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_httpservers.py Mon Nov 19 12:28:22 2012 +0200 @@ -528,7 +528,7 @@ def verify_http_server_response(self, response): match = self.HTTPResponseMatch.search(response) - self.assertTrue(match is not None) + self.assertIsNotNone(match) def test_http_1_1(self): result = self.send_typical_request(b'GET / HTTP/1.1\r\n\r\n') diff -r cf606c403f14 Lib/test/test_import.py --- a/Lib/test/test_import.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_import.py Mon Nov 19 12:28:22 2012 +0200 @@ -185,12 +185,12 @@ # import x.y.z binds x in the current namespace import test as x import test.support - self.assertTrue(x is test, x.__name__) + self.assertIs(x, 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.assertTrue(y is test.support, y.__name__) + self.assertIs(y, test.support, y.__name__) def test_failing_reload(self): # A failing reload should leave the module object in sys.modules. @@ -218,7 +218,7 @@ self.assertRaises(ZeroDivisionError, imp.reload, mod) # But we still expect the module to be in sys.modules. mod = sys.modules.get(TESTFN) - self.assertIsNot(mod, None, "expected module to be in sys.modules") + self.assertIsNotNone(mod, "expected module to be in sys.modules") # We should have replaced a w/ 10, but the old b value should # stick. diff -r cf606c403f14 Lib/test/test_importlib/builtin/test_loader.py --- a/Lib/test/test_importlib/builtin/test_loader.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_importlib/builtin/test_loader.py Mon Nov 19 12:28:22 2012 +0200 @@ -84,7 +84,7 @@ def test_is_package(self): # Cannot be a package. result = machinery.BuiltinImporter.is_package(builtin_util.NAME) - self.assertTrue(not result) + self.assertFalse(result) def test_not_builtin(self): # Modules not built-in should raise ImportError. diff -r cf606c403f14 Lib/test/test_importlib/import_/test_fromlist.py --- a/Lib/test/test_importlib/import_/test_fromlist.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_importlib/import_/test_fromlist.py Mon Nov 19 12:28:22 2012 +0200 @@ -58,7 +58,7 @@ with util.import_state(meta_path=[importer]): module = import_util.import_('module', fromlist=['non_existent']) self.assertEqual(module.__name__, 'module') - self.assertTrue(not hasattr(module, 'non_existent')) + self.assertFalse(hasattr(module, 'non_existent')) def test_module_from_package(self): # [module] diff -r cf606c403f14 Lib/test/test_importlib/import_/test_meta_path.py --- a/Lib/test/test_importlib/import_/test_meta_path.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_importlib/import_/test_meta_path.py Mon Nov 19 12:28:22 2012 +0200 @@ -100,7 +100,7 @@ args = log[1][0] kwargs = log[1][1] # Assuming all arguments are positional. - self.assertTrue(not kwargs) + self.assertFalse(kwargs) self.assertEqual(args[0], mod_name) self.assertIs(args[1], path) diff -r cf606c403f14 Lib/test/test_importlib/source/test_abc_loader.py --- a/Lib/test/test_importlib/source/test_abc_loader.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_importlib/source/test_abc_loader.py Mon Nov 19 12:28:22 2012 +0200 @@ -171,7 +171,7 @@ with util.uncache(self.name): module = self.loader.load_module(self.name) self.verify_module(module) - self.assertTrue(not hasattr(module, '__path__')) + self.assertFalse(hasattr(module, '__path__')) def test_get_source_encoding(self): # Source is considered encoded in UTF-8 by default unless otherwise diff -r cf606c403f14 Lib/test/test_importlib/test_api.py --- a/Lib/test/test_importlib/test_api.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_importlib/test_api.py Mon Nov 19 12:28:22 2012 +0200 @@ -171,8 +171,7 @@ def test_no_frozen_importlib(self): # Should be able to import w/o _frozen_importlib being defined. module = support.import_fresh_module('importlib', blocked=['_frozen_importlib']) - self.assertFalse(isinstance(module.__loader__, - machinery.FrozenImporter)) + self.assertNotIsInstance(module.__loader__, machinery.FrozenImporter) def test_main(): diff -r cf606c403f14 Lib/test/test_inspect.py --- a/Lib/test/test_inspect.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_inspect.py Mon Nov 19 12:28:22 2012 +0200 @@ -161,7 +161,7 @@ self.istest(inspect.isframe, 'mod.fr') def test_stack(self): - self.assertTrue(len(mod.st) >= 5) + self.assertGreaterEqual(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:]), @@ -1925,7 +1925,7 @@ sig = inspect.signature(test) sig = sig.replace(return_annotation=None) - self.assertIs(sig.return_annotation, None) + self.assertIsNone(sig.return_annotation) sig = sig.replace(return_annotation=sig.empty) self.assertIs(sig.return_annotation, sig.empty) sig = sig.replace(return_annotation=42) @@ -1940,7 +1940,7 @@ P.VAR_POSITIONAL < P.KEYWORD_ONLY < P.VAR_KEYWORD) self.assertEqual(str(P.POSITIONAL_ONLY), 'POSITIONAL_ONLY') - self.assertTrue('POSITIONAL_ONLY' in repr(P.POSITIONAL_ONLY)) + self.assertIn('POSITIONAL_ONLY', repr(P.POSITIONAL_ONLY)) def test_signature_parameter_object(self): p = inspect.Parameter('foo', default=10, @@ -2012,7 +2012,7 @@ p2 = p2.replace(name=p2.empty) p2 = p2.replace(name='foo', default=None) - self.assertIs(p2.default, None) + self.assertIsNone(p2.default) self.assertNotEqual(p2, p) p2 = p2.replace(name='foo', default=p2.empty) diff -r cf606c403f14 Lib/test/test_int.py --- a/Lib/test/test_int.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_int.py Mon Nov 19 12:28:22 2012 +0200 @@ -101,8 +101,8 @@ self.assertRaises(ValueError, int, "0b", 0) # Bug #3236: Return small longs from PyLong_FromString - self.assertTrue(int("10") is 10) - self.assertTrue(int("-1") is -1) + self.assertIs(int("10"), 10) + self.assertIs(int("-1"), -1) # SF bug 1334662: int(string, base) wrong answers # Various representations of 2**32 evaluated to 0 diff -r cf606c403f14 Lib/test/test_io.py --- a/Lib/test/test_io.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_io.py Mon Nov 19 12:28:22 2012 +0200 @@ -457,7 +457,7 @@ with self.open(support.TESTFN, "ab") as f: self.assertEqual(f.tell(), 3) with self.open(support.TESTFN, "a") as f: - self.assertTrue(f.tell() > 0) + self.assertGreater(f.tell(), 0) def test_destructor(self): record = [] @@ -577,7 +577,7 @@ wr = weakref.ref(f) del f support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) with self.open(support.TESTFN, "rb") as f: self.assertEqual(f.read(), b"abcxxx") @@ -675,7 +675,7 @@ del MyIO del obj support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) class PyIOTest(IOTest): pass @@ -1060,7 +1060,7 @@ wr = weakref.ref(f) del f support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) class PyBufferedReaderTest(BufferedReaderTest): tp = pyio.BufferedReader @@ -1339,7 +1339,7 @@ wr = weakref.ref(f) del f support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) with self.open(support.TESTFN, "rb") as f: self.assertEqual(f.read(), b"123xxx") @@ -1949,7 +1949,7 @@ t = self.TextIOWrapper(b, encoding="utf-8") self.assertEqual(t.encoding, "utf-8") t = self.TextIOWrapper(b) - self.assertTrue(t.encoding is not None) + self.assertIsNotNone(t.encoding) codecs.lookup(t.encoding) def test_encoding_errors_reading(self): @@ -2536,7 +2536,7 @@ wr = weakref.ref(t) del t support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) with self.open(support.TESTFN, "rb") as f: self.assertEqual(f.read(), b"456def") @@ -2682,7 +2682,7 @@ def test___all__(self): for name in self.io.__all__: obj = getattr(self.io, name, None) - self.assertTrue(obj is not None, name) + self.assertIsNotNone(obj, name) if name == "open": continue elif "error" in name.lower() or name == "UnsupportedOperation": @@ -2771,7 +2771,7 @@ wr = weakref.ref(c) del c, b support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) def test_abcs(self): # Test the visible base classes are ABCs. @@ -2923,7 +2923,7 @@ received += iter(rf.read, None) sent, received = b''.join(sent), b''.join(received) - self.assertTrue(sent == received) + self.assertEqual(sent, received) self.assertTrue(wf.closed) self.assertTrue(rf.closed) diff -r cf606c403f14 Lib/test/test_ipaddress.py --- a/Lib/test/test_ipaddress.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_ipaddress.py Mon Nov 19 12:28:22 2012 +0200 @@ -877,13 +877,13 @@ 36893488147419103232) def testContains(self): - self.assertTrue(ipaddress.IPv4Interface('1.2.3.128/25') in + self.assertIn(ipaddress.IPv4Interface('1.2.3.128/25'), self.ipv4_network) - self.assertFalse(ipaddress.IPv4Interface('1.2.4.1/24') in + self.assertNotIn(ipaddress.IPv4Interface('1.2.4.1/24'), self.ipv4_network) # We can test addresses and string as well. addr1 = ipaddress.IPv4Address('1.2.3.37') - self.assertTrue(addr1 in self.ipv4_network) + self.assertIn(addr1, self.ipv4_network) # issue 61, bad network comparison on like-ip'd network objects # with identical broadcast addresses. self.assertFalse(ipaddress.IPv4Network('1.1.0.0/16').__contains__( @@ -1461,8 +1461,8 @@ dummy[self.ipv6_address] = None dummy[ip1] = None dummy[ip2] = None - self.assertTrue(self.ipv4_address in dummy) - self.assertTrue(ip2 in dummy) + self.assertIn(self.ipv4_address, dummy) + self.assertIn(ip2, dummy) def testIPBases(self): net = self.ipv4_network @@ -1575,9 +1575,9 @@ def testNetworkElementCaching(self): # V4 - make sure we're empty - self.assertFalse('network_address' in self.ipv4_network._cache) - self.assertFalse('broadcast_address' in self.ipv4_network._cache) - self.assertFalse('hostmask' in self.ipv4_network._cache) + self.assertNotIn('network_address', self.ipv4_network._cache) + self.assertNotIn('broadcast_address', self.ipv4_network._cache) + self.assertNotIn('hostmask', self.ipv4_network._cache) # V4 - populate and test self.assertEqual(self.ipv4_network.network_address, @@ -1588,12 +1588,12 @@ ipaddress.IPv4Address('0.0.0.255')) # V4 - check we're cached - self.assertTrue('broadcast_address' in self.ipv4_network._cache) - self.assertTrue('hostmask' in self.ipv4_network._cache) + self.assertIn('broadcast_address', self.ipv4_network._cache) + self.assertIn('hostmask', self.ipv4_network._cache) # V6 - make sure we're empty - self.assertFalse('broadcast_address' in self.ipv6_network._cache) - self.assertFalse('hostmask' in self.ipv6_network._cache) + self.assertNotIn('broadcast_address', self.ipv6_network._cache) + self.assertNotIn('hostmask', self.ipv6_network._cache) # V6 - populate and test self.assertEqual(self.ipv6_network.network_address, @@ -1613,11 +1613,11 @@ ipaddress.IPv6Address('::ffff:ffff:ffff:ffff')) # V6 - check we're cached - self.assertTrue('broadcast_address' in self.ipv6_network._cache) - self.assertTrue('hostmask' in self.ipv6_network._cache) + self.assertIn('broadcast_address', self.ipv6_network._cache) + self.assertIn('hostmask', self.ipv6_network._cache) self.assertTrue( 'broadcast_address' in self.ipv6_interface.network._cache) - self.assertTrue('hostmask' in self.ipv6_interface.network._cache) + self.assertIn('hostmask', self.ipv6_interface.network._cache) def testTeredo(self): # stolen from wikipedia diff -r cf606c403f14 Lib/test/test_iter.py --- a/Lib/test/test_iter.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_iter.py Mon Nov 19 12:28:22 2012 +0200 @@ -81,7 +81,7 @@ # Cannot assert type equality because dict iterators unpickle as list # iterators. # self.assertEqual(type(itorg), type(it)) - self.assertTrue(isinstance(it, collections.abc.Iterator)) + self.assertIsInstance(it, collections.abc.Iterator) self.assertEqual(list(it), seq) it = pickle.loads(d) @@ -102,7 +102,7 @@ seq = list(range(10)) it = iter(seq) it2 = iter(it) - self.assertTrue(it is it2) + self.assertIs(it, it2) # Test that for loops over iterators work def test_iter_for_loop(self): diff -r cf606c403f14 Lib/test/test_itertools.py --- a/Lib/test/test_itertools.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_itertools.py Mon Nov 19 12:28:22 2012 +0200 @@ -324,7 +324,7 @@ if n == 0 or r <= 1: self.assertEqual(result, regular_combs) # cases that should be identical else: - self.assertTrue(set(result) >= set(regular_combs)) # rest should be supersets of regular combs + self.assertGreaterEqual(set(result), set(regular_combs)) # rest should be supersets of regular combs for c in result: self.assertEqual(len(c), r) # r-length combinations @@ -1189,7 +1189,7 @@ # tee pass-through to copyable iterator a, b = tee('abc') c, d = tee(a) - self.assertTrue(a is c) + self.assertIs(a, c) # test tee_new t1, t2 = tee('abc') diff -r cf606c403f14 Lib/test/test_kqueue.py --- a/Lib/test/test_kqueue.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_kqueue.py Mon Nov 19 12:28:22 2012 +0200 @@ -17,7 +17,7 @@ def test_create_queue(self): kq = select.kqueue() self.assertTrue(kq.fileno() > 0, kq.fileno()) - self.assertTrue(not kq.closed) + self.assertFalse(kq.closed) kq.close() self.assertTrue(kq.closed) self.assertRaises(ValueError, kq.fileno) diff -r cf606c403f14 Lib/test/test_list.py --- a/Lib/test/test_list.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_list.py Mon Nov 19 12:28:22 2012 +0200 @@ -10,7 +10,7 @@ l0_3 = [0, 1, 2, 3] l0_3_bis = list(l0_3) self.assertEqual(l0_3, l0_3_bis) - self.assertTrue(l0_3 is not l0_3_bis) + self.assertIsNot(l0_3, l0_3_bis) self.assertEqual(list(()), []) self.assertEqual(list((0, 1, 2, 3)), [0, 1, 2, 3]) self.assertEqual(list(''), []) @@ -40,11 +40,11 @@ def test_truth(self): super().test_truth() - self.assertTrue(not []) + self.assertFalse([]) self.assertTrue([42]) def test_identity(self): - self.assertTrue([] is not []) + self.assertIsNot([], []) def test_len(self): super().test_len() diff -r cf606c403f14 Lib/test/test_logging.py --- a/Lib/test/test_logging.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_logging.py Mon Nov 19 12:28:22 2012 +0200 @@ -2912,7 +2912,7 @@ msg = self.next_message() self.que_logger.warning(msg) data = self.queue.get_nowait() - self.assertTrue(isinstance(data, logging.LogRecord)) + self.assertIsInstance(data, logging.LogRecord) self.assertEqual(data.name, self.que_logger.name) self.assertEqual((data.msg, data.args), (msg, None)) diff -r cf606c403f14 Lib/test/test_long.py --- a/Lib/test/test_long.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_long.py Mon Nov 19 12:28:22 2012 +0200 @@ -130,7 +130,7 @@ # The sign of the number is also random. def getran(self, ndigits): - self.assertTrue(ndigits > 0) + self.assertGreater(ndigits, 0) nbits_hi = ndigits * SHIFT nbits_lo = nbits_hi - SHIFT + 1 answer = 0 @@ -872,21 +872,21 @@ def test_small_ints(self): for i in range(-5, 257): - self.assertTrue(i is i + 0) - self.assertTrue(i is i * 1) - self.assertTrue(i is i - 0) - self.assertTrue(i is i // 1) - self.assertTrue(i is i & -1) - self.assertTrue(i is i | 0) - self.assertTrue(i is i ^ 0) - self.assertTrue(i is ~~i) - self.assertTrue(i is i**1) - self.assertTrue(i is int(str(i))) - self.assertTrue(i is i<<2>>2, str(i)) + self.assertIs(i, i + 0) + self.assertIs(i, i * 1) + self.assertIs(i, i - 0) + self.assertIs(i, i // 1) + self.assertIs(i, i & -1) + self.assertIs(i, i | 0) + self.assertIs(i, i ^ 0) + self.assertIs(i, ~~i) + self.assertIs(i, i**1) + self.assertIs(i, int(str(i))) + self.assertIs(i, i<<2>>2, str(i)) # corner cases i = 1 << 70 - self.assertTrue(i - i is 0) - self.assertTrue(0 * i is 0) + self.assertIs(i - i, 0) + self.assertIs(0 * i, 0) def test_bit_length(self): tiny = 1e-10 @@ -933,7 +933,7 @@ got = round(k+offset, -1) expected = v+offset self.assertEqual(got, expected) - self.assertTrue(type(got) is int) + self.assertIs(type(got), int) # larger second argument self.assertEqual(round(-150, -2), -200) @@ -972,7 +972,7 @@ got = round(10**k + 324678, -3) expect = 10**k + 325000 self.assertEqual(got, expect) - self.assertTrue(type(got) is int) + self.assertIs(type(got), int) # nonnegative second argument: round(x, n) should just return x for n in range(5): @@ -980,7 +980,7 @@ x = random.randrange(-10000, 10000) got = round(x, n) self.assertEqual(got, x) - self.assertTrue(type(got) is int) + self.assertIs(type(got), 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) @@ -989,7 +989,7 @@ x = random.randrange(-10000, 10000) got = round(x) self.assertEqual(got, x) - self.assertTrue(type(got) is int) + self.assertIs(type(got), int) # bad second argument bad_exponents = ('brian', 2.0, 0j, None) @@ -1194,15 +1194,15 @@ class myint(int): pass - self.assertTrue(type(myint.from_bytes(b'\x00', 'big')) is myint) + self.assertIs(type(myint.from_bytes(b'\x00', 'big')), myint) self.assertEqual(myint.from_bytes(b'\x01', 'big'), 1) - self.assertTrue( - type(myint.from_bytes(b'\x00', 'big', signed=False)) is myint) + self.assertIs( + type(myint.from_bytes(b'\x00', 'big', signed=False)), myint) self.assertEqual(myint.from_bytes(b'\x01', 'big', signed=False), 1) - self.assertTrue(type(myint.from_bytes(b'\x00', 'little')) is myint) + self.assertIs(type(myint.from_bytes(b'\x00', 'little')), myint) self.assertEqual(myint.from_bytes(b'\x01', 'little'), 1) - self.assertTrue(type(myint.from_bytes( - b'\x00', 'little', signed=False)) is myint) + self.assertIs(type(myint.from_bytes( + b'\x00', 'little', signed=False)), myint) self.assertEqual(myint.from_bytes(b'\x01', 'little', signed=False), 1) self.assertEqual( int.from_bytes([255, 0, 0], 'big', signed=True), -65536) diff -r cf606c403f14 Lib/test/test_mailbox.py --- a/Lib/test/test_mailbox.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_mailbox.py Mon Nov 19 12:28:22 2012 +0200 @@ -233,7 +233,7 @@ msg = self._box.get(key0) self.assertEqual(msg['from'], 'foo') self.assertEqual(msg.get_payload(), '0\n') - self.assertIs(self._box.get('foo'), None) + self.assertIsNone(self._box.get('foo')) self.assertIs(self._box.get('foo', False), False) self._box.close() self._box = self._factory(self._path) @@ -760,7 +760,7 @@ "tmp")), "File in wrong location: '%s'" % head) match = pattern.match(tail) - self.assertIsNot(match, None, "Invalid file name: '%s'" % tail) + self.assertIsNotNone(match, "Invalid file name: '%s'" % tail) groups = match.groups() if previous_groups is not None: self.assertGreaterEqual(int(groups[0]), int(previous_groups[0]), @@ -1405,7 +1405,7 @@ eMM = email.message_from_string(_sample_message) msg = self._factory(_sample_message) for attr in eMM.__dict__: - self.assertTrue(attr in msg.__dict__, + self.assertIn(attr, msg.__dict__, '{} attribute does not exist'.format(attr)) def test_become_message(self): @@ -1622,19 +1622,19 @@ msg = mailbox.BabylMessage(_sample_message) visible = msg.get_visible() self.assertEqual(visible.keys(), []) - self.assertIs(visible.get_payload(), None) + self.assertIsNone(visible.get_payload()) 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.assertTrue(visible.keys() == ['User-Agent', 'X-Whatever']) - self.assertTrue(visible['User-Agent'] == 'FooBar 1.0') + self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever']) + self.assertEqual(visible['User-Agent'], 'FooBar 1.0') self.assertEqual(visible['X-Whatever'], 'Blah') - self.assertIs(visible.get_payload(), None) + self.assertIsNone(visible.get_payload()) msg.update_visible() self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever']) - self.assertIs(visible.get_payload(), None) + self.assertIsNone(visible.get_payload()) visible = msg.get_visible() self.assertEqual(visible.keys(), ['User-Agent', 'Date', 'From', 'To', 'Subject']) @@ -2156,34 +2156,34 @@ self.mbox = mailbox.Maildir(support.TESTFN) #self.assertTrue(hasattr(self.mbox, "boxes")) #self.assertEqual(len(self.mbox.boxes), 0) - self.assertIs(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) + self.assertIsNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) def test_nonempty_maildir_cur(self): self.createMessage("cur") self.mbox = mailbox.Maildir(support.TESTFN) #self.assertEqual(len(self.mbox.boxes), 1) - self.assertIsNot(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) + self.assertIsNotNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) def test_nonempty_maildir_new(self): self.createMessage("new") self.mbox = mailbox.Maildir(support.TESTFN) #self.assertEqual(len(self.mbox.boxes), 1) - self.assertIsNot(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) + self.assertIsNotNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) def test_nonempty_maildir_both(self): self.createMessage("cur") self.createMessage("new") self.mbox = mailbox.Maildir(support.TESTFN) #self.assertEqual(len(self.mbox.boxes), 2) - self.assertIsNot(self.mbox.next(), None) - self.assertIsNot(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) + self.assertIsNotNone(self.mbox.next()) + self.assertIsNotNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) ## End: tests from the original module (for backward compatibility). diff -r cf606c403f14 Lib/test/test_memoryview.py --- a/Lib/test/test_memoryview.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_memoryview.py Mon Nov 19 12:28:22 2012 +0200 @@ -237,7 +237,7 @@ b = m = o = None # The cycle must be broken gc.collect() - self.assertTrue(wr() is None, wr()) + self.assertIsNone(wr()) # This exercises memory_clear(). m = MyView(tp(b'abc')) @@ -248,7 +248,7 @@ m = o = None # The cycle must be broken gc.collect() - self.assertTrue(wr() is None, wr()) + self.assertIsNone(wr()) def _check_released(self, m, tp): check = self.assertRaisesRegex(ValueError, "released") @@ -349,7 +349,7 @@ self.assertIs(wr(), m) del m test.support.gc_collect() - self.assertIs(wr(), None) + self.assertIsNone(wr()) self.assertIs(L[0], b) # Variations on source objects for the buffer: bytes-like objects, then arrays diff -r cf606c403f14 Lib/test/test_minidom.py --- a/Lib/test/test_minidom.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_minidom.py Mon Nov 19 12:28:22 2012 +0200 @@ -1524,7 +1524,7 @@ num_children_before = len(doc.childNodes) doc.removeChild(doc.childNodes[0]) num_children_after = len(doc.childNodes) - self.assertTrue(num_children_after == num_children_before - 1) + self.assertEqual(num_children_after, num_children_before - 1) def test_main(): run_unittest(MinidomTest) diff -r cf606c403f14 Lib/test/test_module.py --- a/Lib/test/test_module.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_module.py Mon Nov 19 12:28:22 2012 +0200 @@ -19,7 +19,7 @@ # An uninitialized module has no __dict__ or __name__, # and __doc__ is None foo = ModuleType.__new__(ModuleType) - self.assertTrue(foo.__dict__ is None) + self.assertIsNone(foo.__dict__) self.assertRaises(SystemError, dir, foo) try: s = foo.__name__ @@ -62,7 +62,7 @@ self.assertEqual(foo.bar, 42) self.assertEqual(foo.__dict__, {"__name__": "foo", "__doc__": "foodoc", "bar": 42}) - self.assertTrue(foo.__dict__ is d) + self.assertIs(foo.__dict__, d) @unittest.expectedFailure def test_dont_clear_dict(self): diff -r cf606c403f14 Lib/test/test_multiprocessing.py --- a/Lib/test/test_multiprocessing.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_multiprocessing.py Mon Nov 19 12:28:22 2012 +0200 @@ -201,9 +201,9 @@ authkey = current.authkey self.assertTrue(current.is_alive()) - self.assertTrue(not current.daemon) + self.assertFalse(current.daemon) self.assertIsInstance(authkey, bytes) - self.assertTrue(len(authkey) > 0) + self.assertGreater(len(authkey), 0) self.assertEqual(current.ident, os.getpid()) self.assertEqual(current.exitcode, None) @@ -246,7 +246,7 @@ self.assertEqual(p.is_alive(), False) self.assertEqual(p.daemon, True) self.assertNotIn(p, self.active_children()) - self.assertTrue(type(self.active_children()) is list) + self.assertIs(type(self.active_children()), list) self.assertEqual(p.exitcode, None) p.start() @@ -312,8 +312,8 @@ cpus = multiprocessing.cpu_count() except NotImplementedError: cpus = 1 - self.assertTrue(type(cpus) is int) - self.assertTrue(cpus >= 1) + self.assertIs(type(cpus), int) + self.assertGreaterEqual(cpus, 1) def test_active_children(self): self.assertEqual(type(self.active_children()), list) @@ -1603,7 +1603,7 @@ del n.job self.assertEqual(str(n), "Namespace(name='Bob')") self.assertTrue(hasattr(n, 'name')) - self.assertTrue(not hasattr(n, 'job')) + self.assertFalse(hasattr(n, 'job')) # # @@ -2800,7 +2800,7 @@ def test_enable_logging(self): logger = multiprocessing.get_logger() logger.setLevel(util.SUBWARNING) - self.assertTrue(logger is not None) + self.assertIsNotNone(logger) logger.debug('this will not be printed') logger.info('nor will this') logger.setLevel(LOG_LEVEL) diff -r cf606c403f14 Lib/test/test_operator.py --- a/Lib/test/test_operator.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_operator.py Mon Nov 19 12:28:22 2012 +0200 @@ -108,55 +108,55 @@ def test_add(self): self.assertRaises(TypeError, operator.add) self.assertRaises(TypeError, operator.add, None, None) - self.assertTrue(operator.add(3, 4) == 7) + self.assertEqual(operator.add(3, 4), 7) def test_bitwise_and(self): self.assertRaises(TypeError, operator.and_) self.assertRaises(TypeError, operator.and_, None, None) - self.assertTrue(operator.and_(0xf, 0xa) == 0xa) + self.assertEqual(operator.and_(0xf, 0xa), 0xa) def test_concat(self): self.assertRaises(TypeError, operator.concat) self.assertRaises(TypeError, operator.concat, None, None) - self.assertTrue(operator.concat('py', 'thon') == 'python') - self.assertTrue(operator.concat([1, 2], [3, 4]) == [1, 2, 3, 4]) - self.assertTrue(operator.concat(Seq1([5, 6]), Seq1([7])) == [5, 6, 7]) - self.assertTrue(operator.concat(Seq2([5, 6]), Seq2([7])) == [5, 6, 7]) + self.assertEqual(operator.concat('py', 'thon'), 'python') + self.assertEqual(operator.concat([1, 2], [3, 4]), [1, 2, 3, 4]) + self.assertEqual(operator.concat(Seq1([5, 6]), Seq1([7])), [5, 6, 7]) + self.assertEqual(operator.concat(Seq2([5, 6]), Seq2([7])), [5, 6, 7]) self.assertRaises(TypeError, operator.concat, 13, 29) def test_countOf(self): self.assertRaises(TypeError, operator.countOf) self.assertRaises(TypeError, operator.countOf, None, None) - self.assertTrue(operator.countOf([1, 2, 1, 3, 1, 4], 3) == 1) - self.assertTrue(operator.countOf([1, 2, 1, 3, 1, 4], 5) == 0) + self.assertEqual(operator.countOf([1, 2, 1, 3, 1, 4], 3), 1) + self.assertEqual(operator.countOf([1, 2, 1, 3, 1, 4], 5), 0) def test_delitem(self): a = [4, 3, 2, 1] self.assertRaises(TypeError, operator.delitem, a) self.assertRaises(TypeError, operator.delitem, a, None) - self.assertTrue(operator.delitem(a, 1) is None) - self.assertTrue(a == [4, 2, 1]) + self.assertIsNone(operator.delitem(a, 1)) + self.assertEqual(a, [4, 2, 1]) def test_floordiv(self): self.assertRaises(TypeError, operator.floordiv, 5) self.assertRaises(TypeError, operator.floordiv, None, None) - self.assertTrue(operator.floordiv(5, 2) == 2) + self.assertEqual(operator.floordiv(5, 2), 2) def test_truediv(self): self.assertRaises(TypeError, operator.truediv, 5) self.assertRaises(TypeError, operator.truediv, None, None) - self.assertTrue(operator.truediv(5, 2) == 2.5) + self.assertEqual(operator.truediv(5, 2), 2.5) def test_getitem(self): a = range(10) self.assertRaises(TypeError, operator.getitem) self.assertRaises(TypeError, operator.getitem, a, None) - self.assertTrue(operator.getitem(a, 2) == 2) + self.assertEqual(operator.getitem(a, 2), 2) def test_indexOf(self): self.assertRaises(TypeError, operator.indexOf) self.assertRaises(TypeError, operator.indexOf, None, None) - self.assertTrue(operator.indexOf([4, 3, 2, 1], 3) == 1) + self.assertEqual(operator.indexOf([4, 3, 2, 1], 3), 1) self.assertRaises(ValueError, operator.indexOf, [4, 3, 2, 1], 0) def test_invert(self): @@ -167,19 +167,19 @@ def test_lshift(self): self.assertRaises(TypeError, operator.lshift) self.assertRaises(TypeError, operator.lshift, None, 42) - self.assertTrue(operator.lshift(5, 1) == 10) - self.assertTrue(operator.lshift(5, 0) == 5) + self.assertEqual(operator.lshift(5, 1), 10) + self.assertEqual(operator.lshift(5, 0), 5) self.assertRaises(ValueError, operator.lshift, 2, -1) def test_mod(self): self.assertRaises(TypeError, operator.mod) self.assertRaises(TypeError, operator.mod, None, 42) - self.assertTrue(operator.mod(5, 2) == 1) + self.assertEqual(operator.mod(5, 2), 1) def test_mul(self): self.assertRaises(TypeError, operator.mul) self.assertRaises(TypeError, operator.mul, None, None) - self.assertTrue(operator.mul(5, 2) == 10) + self.assertEqual(operator.mul(5, 2), 10) def test_neg(self): self.assertRaises(TypeError, operator.neg) @@ -192,7 +192,7 @@ def test_bitwise_or(self): self.assertRaises(TypeError, operator.or_) self.assertRaises(TypeError, operator.or_, None, None) - self.assertTrue(operator.or_(0xa, 0x5) == 0xf) + self.assertEqual(operator.or_(0xa, 0x5), 0xf) def test_pos(self): self.assertRaises(TypeError, operator.pos) @@ -213,8 +213,8 @@ def test_rshift(self): self.assertRaises(TypeError, operator.rshift) self.assertRaises(TypeError, operator.rshift, None, 42) - self.assertTrue(operator.rshift(5, 1) == 2) - self.assertTrue(operator.rshift(5, 0) == 5) + self.assertEqual(operator.rshift(5, 1), 2) + self.assertEqual(operator.rshift(5, 0), 5) self.assertRaises(ValueError, operator.rshift, 2, -1) def test_contains(self): @@ -227,14 +227,14 @@ a = list(range(3)) self.assertRaises(TypeError, operator.setitem, a) self.assertRaises(TypeError, operator.setitem, a, None, None) - self.assertTrue(operator.setitem(a, 0, 2) is None) - self.assertTrue(a == [2, 1, 2]) + self.assertIsNone(operator.setitem(a, 0, 2)) + self.assertEqual(a, [2, 1, 2]) self.assertRaises(IndexError, operator.setitem, a, 4, 2) def test_sub(self): self.assertRaises(TypeError, operator.sub) self.assertRaises(TypeError, operator.sub, None, None) - self.assertTrue(operator.sub(5, 2) == 3) + self.assertEqual(operator.sub(5, 2), 3) def test_truth(self): class C(object): @@ -250,7 +250,7 @@ def test_bitwise_xor(self): self.assertRaises(TypeError, operator.xor) self.assertRaises(TypeError, operator.xor, None, None) - self.assertTrue(operator.xor(0xb, 0xc) == 0x7) + self.assertEqual(operator.xor(0xb, 0xc), 0x7) def test_is(self): a = b = 'xyzpdq' diff -r cf606c403f14 Lib/test/test_optparse.py --- a/Lib/test/test_optparse.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_optparse.py Mon Nov 19 12:28:22 2012 +0200 @@ -370,10 +370,10 @@ self.assertTrue(self.parser.has_option("--verbose")) def assertTrueremoved(self): - self.assertTrue(self.parser.get_option("-v") is None) - self.assertTrue(self.parser.get_option("--verbose") is None) - self.assertTrue(self.parser.get_option("-n") is None) - self.assertTrue(self.parser.get_option("--noisy") is None) + self.assertIsNone(self.parser.get_option("-v")) + self.assertIsNone(self.parser.get_option("--verbose")) + self.assertIsNone(self.parser.get_option("-n")) + self.assertIsNone(self.parser.get_option("--noisy")) self.assertFalse(self.parser.has_option("-v")) self.assertFalse(self.parser.has_option("--verbose")) @@ -797,13 +797,13 @@ (options, args) = self.assertParseOK(["-q"], {'verbose': 0}, []) - self.assertTrue(options.verbose is False) + self.assertIs(options.verbose, False) def test_bool_true(self): (options, args) = self.assertParseOK(["-v"], {'verbose': 1}, []) - self.assertTrue(options.verbose is True) + self.assertIs(options.verbose, True) def test_bool_flicker_on_and_off(self): self.assertParseOK(["-qvq", "-q", "-v"], @@ -1105,15 +1105,15 @@ if opt == "-x": self.assertEqual(option._short_opts, ["-x"]) self.assertEqual(option._long_opts, []) - self.assertTrue(parser_ is self.parser) - self.assertTrue(value is None) + self.assertIs(parser_, self.parser) + self.assertIsNone(value) self.assertEqual(vars(parser_.values), {'filename': None}) parser_.values.x = 42 elif opt == "--file": self.assertEqual(option._short_opts, ["-f"]) self.assertEqual(option._long_opts, ["--file"]) - self.assertTrue(parser_ is self.parser) + self.assertIs(parser_, self.parser) self.assertEqual(value, "foo") self.assertEqual(vars(parser_.values), {'filename': None, 'x': 42}) @@ -1151,7 +1151,7 @@ def process_tuple(self, option, opt, value, parser_, len, type): self.assertEqual(len, 3) - self.assertTrue(type is int) + self.assertIs(type, int) if opt == "-p": self.assertEqual(value, "1,2,3") @@ -1242,7 +1242,7 @@ option_list=options) def variable_args(self, option, opt, value, parser): - self.assertTrue(value is None) + self.assertIsNone(value) value = [] rargs = parser.rargs while rargs: @@ -1333,8 +1333,8 @@ verbose_opt = self.parser.get_option("--verbose") version_opt = self.parser.get_option("--version") - self.assertTrue(v_opt is version_opt) - self.assertTrue(v_opt is not verbose_opt) + self.assertIs(v_opt, version_opt) + self.assertIsNot(v_opt, verbose_opt) self.assertEqual(v_opt._long_opts, ["--version"]) self.assertEqual(version_opt._short_opts, ["-v"]) self.assertEqual(version_opt._long_opts, ["--version"]) diff -r cf606c403f14 Lib/test/test_os.py --- a/Lib/test/test_os.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_os.py Mon Nov 19 12:28:22 2012 +0200 @@ -1770,7 +1770,7 @@ break offset += sent total_sent += sent - self.assertTrue(sent <= nbytes) + self.assertLessEqual(sent, nbytes) self.assertEqual(offset, total_sent) self.assertEqual(total_sent, len(self.DATA)) @@ -1793,7 +1793,7 @@ break offset += sent total_sent += sent - self.assertTrue(sent <= nbytes) + self.assertLessEqual(sent, nbytes) self.client.shutdown(socket.SHUT_RDWR) self.client.close() diff -r cf606c403f14 Lib/test/test_ossaudiodev.py --- a/Lib/test/test_ossaudiodev.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_ossaudiodev.py Mon Nov 19 12:28:22 2012 +0200 @@ -76,7 +76,7 @@ # set parameters based on .au file headers dsp.setparameters(AFMT_S16_NE, nchannels, rate) - self.assertTrue(abs(expected_time - 3.51) < 1e-2, expected_time) + self.assertLess(abs(expected_time - 3.51), 1e-2, expected_time) t1 = time.time() dsp.write(data) dsp.close() @@ -84,7 +84,7 @@ elapsed_time = t2 - t1 percent_diff = (abs(elapsed_time - expected_time) / expected_time) * 100 - self.assertTrue(percent_diff <= 10.0, + self.assertLessEqual(percent_diff, 10.0, "elapsed time (%s) > 10%% off of expected time (%s)" % (elapsed_time, expected_time)) diff -r cf606c403f14 Lib/test/test_peepholer.py --- a/Lib/test/test_peepholer.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_peepholer.py Mon Nov 19 12:28:22 2012 +0200 @@ -168,9 +168,9 @@ return a not in {1, 2, 3} self.assertTrue(f(3)) - self.assertTrue(not f(4)) + self.assertFalse(f(4)) - self.assertTrue(not g(3)) + self.assertFalse(g(3)) self.assertTrue(g(4)) @@ -240,7 +240,7 @@ return -(1.0-1.0) self.assertNotIn('UNARY_', disassemble(negzero)) - self.assertTrue(copysign(1.0, negzero()) < 0) + self.assertLess(copysign(1.0, negzero()), 0) # Verify that unfoldables are skipped for line, elem in ( diff -r cf606c403f14 Lib/test/test_pep3120.py --- a/Lib/test/test_pep3120.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_pep3120.py Mon Nov 19 12:28:22 2012 +0200 @@ -20,7 +20,7 @@ import test.badsyntax_pep3120 except SyntaxError as msg: msg = str(msg).lower() - self.assertTrue('utf-8' in msg) + self.assertIn('utf-8', msg) else: self.fail("expected exception didn't occur") diff -r cf606c403f14 Lib/test/test_pep380.py --- a/Lib/test/test_pep380.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_pep380.py Mon Nov 19 12:28:22 2012 +0200 @@ -935,10 +935,11 @@ yield from g for stack in spam(gen()): - self.assertTrue('spam' in stack) + self.assertIn('spam', stack) for stack in spam(eggs(gen())): - self.assertTrue('spam' in stack and 'eggs' in stack) + self.assertIn('spam', stack) + self.assertIn('eggs', stack) def test_custom_iterator_return(self): # See issue #15568 diff -r cf606c403f14 Lib/test/test_platform.py --- a/Lib/test/test_platform.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_platform.py Mon Nov 19 12:28:22 2012 +0200 @@ -182,7 +182,7 @@ real_ver = ln.strip().split()[-1] break fd.close() - self.assertFalse(real_ver is None) + self.assertIsNotNone(real_ver) result_list = res[0].split('.') expect_list = real_ver.split('.') len_diff = len(result_list) - len(expect_list) diff -r cf606c403f14 Lib/test/test_poplib.py --- a/Lib/test/test_poplib.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_poplib.py Mon Nov 19 12:28:22 2012 +0200 @@ -344,7 +344,7 @@ serv.close() def testTimeoutDefault(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: pop = poplib.POP3(HOST, self.port) @@ -354,13 +354,13 @@ pop.sock.close() def testTimeoutNone(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: pop = poplib.POP3(HOST, self.port, timeout=None) finally: socket.setdefaulttimeout(None) - self.assertTrue(pop.sock.gettimeout() is None) + self.assertIsNone(pop.sock.gettimeout()) pop.sock.close() def testTimeoutValue(self): diff -r cf606c403f14 Lib/test/test_posix.py --- a/Lib/test/test_posix.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_posix.py Mon Nov 19 12:28:22 2012 +0200 @@ -448,17 +448,17 @@ self.assertRaises(OSError, posix.chdir, support.TESTFN) def test_listdir(self): - self.assertTrue(support.TESTFN in posix.listdir(os.curdir)) + self.assertIn(support.TESTFN, posix.listdir(os.curdir)) def test_listdir_default(self): # When listdir is called without argument, # it's the same as listdir(os.curdir). - self.assertTrue(support.TESTFN in posix.listdir()) + self.assertIn(support.TESTFN, posix.listdir()) def test_listdir_bytes(self): # When listdir is called with a bytes object, # the returned strings are of type bytes. - self.assertTrue(os.fsencode(support.TESTFN) in posix.listdir(b'.')) + self.assertIn(os.fsencode(support.TESTFN), posix.listdir(b'.')) @unittest.skipUnless(posix.listdir in os.supports_fd, "test needs fd support for posix.listdir()") diff -r cf606c403f14 Lib/test/test_property.py --- a/Lib/test/test_property.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_property.py Mon Nov 19 12:28:22 2012 +0200 @@ -87,8 +87,8 @@ self.assertEqual(base.spam, 10) self.assertEqual(base._spam, 10) delattr(base, "spam") - self.assertTrue(not hasattr(base, "spam")) - self.assertTrue(not hasattr(base, "_spam")) + self.assertFalse(hasattr(base, "spam")) + self.assertFalse(hasattr(base, "_spam")) base.spam = 20 self.assertEqual(base.spam, 20) self.assertEqual(base._spam, 20) diff -r cf606c403f14 Lib/test/test_pulldom.py --- a/Lib/test/test_pulldom.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_pulldom.py Mon Nov 19 12:28:22 2012 +0200 @@ -70,7 +70,7 @@ evt, node = next(items) self.assertEqual(pulldom.END_ELEMENT, evt) self.assertEqual("title", node.tagName) - self.assertTrue(title_node is node) + self.assertIs(title_node, node) evt, node = next(items) self.assertEqual(pulldom.CHARACTERS, evt) evt, node = next(items) diff -r cf606c403f14 Lib/test/test_pyexpat.py --- a/Lib/test/test_pyexpat.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_pyexpat.py Mon Nov 19 12:28:22 2012 +0200 @@ -274,7 +274,7 @@ self.assertEqual(len(L), 6) for entry in L: # L should have the same string repeated over and over. - self.assertTrue(tag is entry) + self.assertIs(tag, entry) def test_issue9402(self): # create an ExternalEntityParserCreate with buffer text @@ -421,7 +421,7 @@ self.parser.CurrentByteIndex, self.parser.CurrentLineNumber, self.parser.CurrentColumnNumber) - self.assertTrue(self.upto < len(self.expected_list), + self.assertLess(self.upto, len(self.expected_list), 'too many parser events') expected = self.expected_list[self.upto] self.assertEqual(pos, expected, diff -r cf606c403f14 Lib/test/test_queue.py --- a/Lib/test/test_queue.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_queue.py Mon Nov 19 12:28:22 2012 +0200 @@ -105,7 +105,7 @@ for i in range(QUEUE_SIZE-1): q.put(i) self.assertTrue(q.qsize(), "Queue should not be empty") - self.assertTrue(not qfull(q), "Queue should not be full") + self.assertFalse(qfull(q), "Queue should not be full") last = 2 * QUEUE_SIZE full = 3 * 2 * QUEUE_SIZE q.put(last) @@ -128,7 +128,7 @@ # Empty it for i in range(QUEUE_SIZE): q.get() - self.assertTrue(not q.qsize(), "Queue should be empty") + self.assertFalse(q.qsize(), "Queue should be empty") try: q.get(block=0) self.fail("Didn't appear to block with an empty queue") @@ -305,7 +305,7 @@ q.put("last") self.assertTrue(qfull(q), "Queue should be full") q.get() - self.assertTrue(not qfull(q), "Queue should not be full") + self.assertFalse(qfull(q), "Queue should not be full") q.put("last") self.assertTrue(qfull(q), "Queue should be full") # Test a blocking put @@ -313,7 +313,7 @@ # Empty it for i in range(QUEUE_SIZE): q.get() - self.assertTrue(not q.qsize(), "Queue should be empty") + self.assertFalse(q.qsize(), "Queue should be empty") q.put("first") q.fail_next_get = True try: @@ -330,7 +330,7 @@ pass self.assertTrue(q.qsize(), "Queue should not be empty") q.get() - self.assertTrue(not q.qsize(), "Queue should be empty") + self.assertFalse(q.qsize(), "Queue should be empty") q.fail_next_get = True try: self.do_exceptional_blocking_test(q.get, (), q.put, ('empty',), @@ -341,7 +341,7 @@ # put succeeded, but get failed. self.assertTrue(q.qsize(), "Queue should not be empty") q.get() - self.assertTrue(not q.qsize(), "Queue should be empty") + self.assertFalse(q.qsize(), "Queue should be empty") def test_failing_queue(self): # Test to make sure a queue is functioning correctly. diff -r cf606c403f14 Lib/test/test_raise.py --- a/Lib/test/test_raise.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_raise.py Mon Nov 19 12:28:22 2012 +0200 @@ -41,7 +41,7 @@ exc1 = e raise except IndexError as exc2: - self.assertTrue(exc1 is exc2) + self.assertIs(exc1, exc2) else: self.fail("No exception raised") @@ -85,7 +85,7 @@ except: raise ValueError() from None except ValueError as e: - self.assertTrue(isinstance(e.__context__, TypeError)) + self.assertIsInstance(e.__context__, TypeError) self.assertIsNone(e.__cause__) def test_with_reraise1(self): @@ -191,7 +191,7 @@ try: raise IndexError from cause except IndexError as e: - self.assertTrue(e.__cause__ is cause) + self.assertIs(e.__cause__, cause) else: self.fail("No exception raised") @@ -297,7 +297,7 @@ finally: raise OSError except OSError as e: - self.assertTrue(e.__context__ is None) + self.assertIsNone(e.__context__) else: self.fail("No exception raised") @@ -334,7 +334,7 @@ except ZeroDivisionError as e: raise e except ZeroDivisionError as e: - self.assertTrue(e.__context__ is None, e.__context__) + self.assertIsNone(e.__context__) def test_reraise_cycle_broken(self): # Non-trivial context cycles (through re-raising a previous exception) @@ -348,7 +348,7 @@ except ZeroDivisionError: raise a except NameError as e: - self.assertTrue(e.__context__.__context__ is None) + self.assertIsNone(e.__context__.__context__) def test_3118(self): # deleting the generator caused the __context__ to be cleared diff -r cf606c403f14 Lib/test/test_re.py --- a/Lib/test/test_re.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_re.py Mon Nov 19 12:28:22 2012 +0200 @@ -761,7 +761,7 @@ ["::", "::"]) def test_bug_926075(self): - self.assertTrue(re.compile('bug_926075') is not + self.assertIsNot(re.compile('bug_926075'), re.compile(b'bug_926075')) def test_bug_931848(self): diff -r cf606c403f14 Lib/test/test_richcmp.py --- a/Lib/test/test_richcmp.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_richcmp.py Mon Nov 19 12:28:22 2012 +0200 @@ -106,7 +106,7 @@ self.assertEqual(len(realres), len(expres)) for i in range(len(realres)): # results are bool, so we can use "is" here - self.assertTrue(realres[i] is expres[i]) + self.assertIs(realres[i], expres[i]) def test_mixed(self): # check that comparisons involving Vector objects @@ -163,7 +163,7 @@ for op in opmap[opname]: realres = op(ta, tb) realres = getattr(realres, "x", realres) - self.assertTrue(realres is expres) + self.assertIs(realres, expres) def test_values(self): # check all operators and all comparison results @@ -238,7 +238,7 @@ b.append(17) # Even recursive lists of different lengths are different, # but they cannot be ordered - self.assertTrue(not (a == b)) + self.assertFalse(a == b) self.assertTrue(a != b) self.assertRaises(RuntimeError, operator.lt, a, b) self.assertRaises(RuntimeError, operator.le, a, b) @@ -249,7 +249,7 @@ self.assertRaises(RuntimeError, operator.ne, a, b) a.insert(0, 11) b.insert(0, 12) - self.assertTrue(not (a == b)) + self.assertFalse(a == b) self.assertTrue(a != b) self.assertTrue(a < b) diff -r cf606c403f14 Lib/test/test_set.py --- a/Lib/test/test_set.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_set.py Mon Nov 19 12:28:22 2012 +0200 @@ -243,7 +243,7 @@ # Set iterators unpickle as list iterators due to the # undefined order of set items. # self.assertEqual(type(itorg), type(it)) - self.assertTrue(isinstance(it, collections.abc.Iterator)) + self.assertIsInstance(it, collections.abc.Iterator) self.assertEqual(self.thetype(it), data) it = pickle.loads(d) @@ -359,7 +359,7 @@ obj.x = iter(container) del obj, container gc.collect() - self.assertTrue(ref() is None, "Cycle was not collected") + self.assertIsNone(ref(), "Cycle was not collected") class TestSet(TestJointOps): thetype = set @@ -433,7 +433,7 @@ try: self.s.remove(key) except KeyError as e: - self.assertTrue(e.args[0] is key, + self.assertIs(e.args[0], key, "KeyError should be {0}, not {1}".format(key, e.args[0])) else: @@ -1492,7 +1492,7 @@ set_list = sorted(self.set, key=repr) self.assertEqual(len(dup_list), len(set_list)) for i in range(len(dup_list)): - self.assertTrue(dup_list[i] is set_list[i]) + self.assertIs(dup_list[i], set_list[i]) def test_deep_copy(self): dup = copy.deepcopy(self.set) diff -r cf606c403f14 Lib/test/test_shutil.py --- a/Lib/test/test_shutil.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_shutil.py Mon Nov 19 12:28:22 2012 +0200 @@ -343,8 +343,8 @@ self.assertEqual(src_link_stat.st_flags, dst_link_stat.st_flags) # tell to follow but dst is not a link shutil.copystat(src_link, dst, follow_symlinks=False) - self.assertTrue(abs(os.stat(src).st_mtime - os.stat(dst).st_mtime) < - 00000.1) + self.assertAlmostEqual(os.stat(src).st_mtime, os.stat(dst).st_mtime, + delta=0.1) @unittest.skipUnless(hasattr(os, 'chflags') and hasattr(errno, 'EOPNOTSUPP') and @@ -1511,7 +1511,7 @@ shutil.copyfile('srcfile', 'destfile') self.assertTrue(srcfile._entered) - self.assertTrue(srcfile._exited_with[0] is IOError) + self.assertIs(srcfile._exited_with[0], IOError) self.assertEqual(srcfile._exited_with[1].args, ('Cannot open "destfile"',)) @@ -1533,7 +1533,7 @@ self.assertTrue(srcfile._entered) self.assertTrue(destfile._entered) self.assertTrue(destfile._raised) - self.assertTrue(srcfile._exited_with[0] is IOError) + self.assertIs(srcfile._exited_with[0], IOError) self.assertEqual(srcfile._exited_with[1].args, ('Cannot close',)) @@ -1556,7 +1556,7 @@ self.assertTrue(srcfile._entered) self.assertTrue(destfile._entered) self.assertFalse(destfile._raised) - self.assertTrue(srcfile._exited_with[0] is None) + self.assertIsNone(srcfile._exited_with[0]) self.assertTrue(srcfile._raised) def test_move_dir_caseinsensitive(self): diff -r cf606c403f14 Lib/test/test_slice.py --- a/Lib/test/test_slice.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_slice.py Mon Nov 19 12:28:22 2012 +0200 @@ -135,7 +135,7 @@ obj = AnyClass() s = slice(obj) - self.assertTrue(s.stop is obj) + self.assertIs(s.stop, obj) def check_indices(self, slice, length): try: diff -r cf606c403f14 Lib/test/test_smtplib.py --- a/Lib/test/test_smtplib.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_smtplib.py Mon Nov 19 12:28:22 2012 +0200 @@ -96,7 +96,7 @@ def testTimeoutDefault(self): mock_socket.reply_with(b"220 Hola mundo") - self.assertTrue(mock_socket.getdefaulttimeout() is None) + self.assertIsNone(mock_socket.getdefaulttimeout()) mock_socket.setdefaulttimeout(30) self.assertEqual(mock_socket.getdefaulttimeout(), 30) try: @@ -108,13 +108,13 @@ def testTimeoutNone(self): mock_socket.reply_with(b"220 Hola mundo") - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: smtp = smtplib.SMTP(HOST, self.port, timeout=None) finally: socket.setdefaulttimeout(None) - self.assertTrue(smtp.sock.gettimeout() is None) + self.assertIsNone(smtp.sock.gettimeout()) smtp.close() def testTimeoutValue(self): diff -r cf606c403f14 Lib/test/test_socket.py --- a/Lib/test/test_socket.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_socket.py Mon Nov 19 12:28:22 2012 +0200 @@ -715,7 +715,7 @@ except socket.error: # Probably name lookup wasn't set up right; skip this test return - self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.") + self.assertGreaterEqual(ip.find('.'), 0, "Error resolving host to ip.") try: hname, aliases, ipaddrs = socket.gethostbyaddr(ip) except socket.error: @@ -1054,7 +1054,7 @@ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.addCleanup(sock.close) reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) - self.assertFalse(reuse != 0, "initial mode is reuse") + self.assertEqual(reuse, 0, "initial mode is reuse") def testSetSockOpt(self): # Testing setsockopt() @@ -1062,7 +1062,7 @@ self.addCleanup(sock.close) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) - self.assertFalse(reuse == 0, "failed to set reuse mode") + self.assertNotEqual(reuse, 0, "failed to set reuse mode") def testSendAfterClose(self): # testing send() after close() with timeout @@ -3548,7 +3548,7 @@ except socket.error: pass end = time.time() - self.assertTrue((end - start) < 1.0, "Error setting non-blocking mode.") + self.assertLess(end - start, 1.0, "Error setting non-blocking mode.") def _testSetBlocking(self): pass @@ -3569,7 +3569,7 @@ except socket.error: pass end = time.time() - self.assertTrue((end - start) < 1.0, "Error creating with non-blocking mode.") + self.assertLess(end - start, 1.0, "Error creating with non-blocking mode.") def _testInitNonBlocking(self): pass @@ -3784,10 +3784,10 @@ self.write_file.flush() def testClosedAttr(self): - self.assertTrue(not self.read_file.closed) + self.assertFalse(self.read_file.closed) def _testClosedAttr(self): - self.assertTrue(not self.write_file.closed) + self.assertFalse(self.write_file.closed) def testAttributes(self): self.assertEqual(self.read_file.mode, self.read_mode) @@ -4175,7 +4175,7 @@ testTimeoutDefault = _justAccept def _testTimeoutDefault(self): # passing no explicit timeout uses socket's global default - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(42) try: self.cli = socket.create_connection((HOST, self.port)) @@ -4187,7 +4187,7 @@ testTimeoutNone = _justAccept def _testTimeoutNone(self): # None timeout means the same as sock.settimeout(None) - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: self.cli = socket.create_connection((HOST, self.port), timeout=None) diff -r cf606c403f14 Lib/test/test_ssl.py --- a/Lib/test/test_ssl.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_ssl.py Mon Nov 19 12:28:22 2012 +0200 @@ -1925,7 +1925,7 @@ context.options |= ssl.OP_NO_COMPRESSION stats = server_params_test(context, context, chatty=True, connectionchatty=True) - self.assertIs(stats['compression'], None) + self.assertIsNone(stats['compression']) def test_dh_params(self): # Check we can get a connection with ephemeral Diffie-Hellman @@ -1946,7 +1946,7 @@ context.load_cert_chain(CERTFILE) stats = server_params_test(context, context, chatty=True, connectionchatty=True) - self.assertIs(stats['client_npn_protocol'], None) + self.assertIsNone(stats['client_npn_protocol']) @unittest.skipUnless(ssl.HAS_NPN, "NPN support needed for this test") def test_npn_protocols(self): diff -r cf606c403f14 Lib/test/test_strptime.py --- a/Lib/test/test_strptime.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_strptime.py Mon Nov 19 12:28:22 2012 +0200 @@ -116,13 +116,13 @@ def test_pattern(self): # Test TimeRE.pattern pattern_string = self.time_re.pattern(r"%a %A %d") - self.assertTrue(pattern_string.find(self.locale_time.a_weekday[2]) != -1, + self.assertNotEqual(pattern_string.find(self.locale_time.a_weekday[2]), -1, "did not find abbreviated weekday in pattern string '%s'" % pattern_string) - self.assertTrue(pattern_string.find(self.locale_time.f_weekday[4]) != -1, + self.assertNotEqual(pattern_string.find(self.locale_time.f_weekday[4]), -1, "did not find full weekday in pattern string '%s'" % pattern_string) - self.assertTrue(pattern_string.find(self.time_re['d']) != -1, + self.assertNotEqual(pattern_string.find(self.time_re['d']), -1, "did not find 'd' directive pattern string '%s'" % pattern_string) @@ -240,7 +240,7 @@ for bound in bounds: strp_output = _strptime._strptime_time(bound, '%y') expected_result = century + int(bound) - self.assertTrue(strp_output[0] == expected_result, + self.assertEqual(strp_output[0], expected_result, "'y' test failed; passed in '%s' " "and returned '%s'" % (bound, strp_output[0])) @@ -258,7 +258,7 @@ self.helper('H', 3) strf_output = time.strftime("%I %p", self.time_tuple) strp_output = _strptime._strptime_time(strf_output, "%I %p") - self.assertTrue(strp_output[3] == self.time_tuple[3], + self.assertEqual(strp_output[3], self.time_tuple[3], "testing of '%%I %%p' directive failed; '%s' -> %s != %s" % (strf_output, strp_output[3], self.time_tuple[3])) @@ -300,11 +300,11 @@ strp_output = _strptime._strptime_time(strf_output, "%Z") locale_time = _strptime.LocaleTime() if time.tzname[0] != time.tzname[1] or not time.daylight: - self.assertTrue(strp_output[8] == time_tuple[8], + self.assertEqual(strp_output[8], time_tuple[8], "timezone check failed; '%s' -> %s != %s" % (strf_output, strp_output[8], time_tuple[8])) else: - self.assertTrue(strp_output[8] == -1, + self.assertEqual(strp_output[8], -1, "LocaleTime().timezone has duplicate values and " "time.daylight but timezone value not set to -1") @@ -365,7 +365,7 @@ # Default return value should be (1900, 1, 1, 0, 0, 0, 0, 1, 0) defaults = (1900, 1, 1, 0, 0, 0, 0, 1, -1) strp_output = _strptime._strptime_time('1', '%m') - self.assertTrue(strp_output == defaults, + self.assertEqual(strp_output, defaults, "Default values for strptime() are incorrect;" " %s != %s" % (strp_output, defaults)) @@ -417,7 +417,7 @@ format_string = "%Y %m %d %H %M %S %w %Z" result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple), format_string) - self.assertTrue(result.tm_yday == self.time_tuple.tm_yday, + self.assertEqual(result.tm_yday, self.time_tuple.tm_yday, "Calculation of tm_yday failed; %s != %s" % (result.tm_yday, self.time_tuple.tm_yday)) @@ -440,7 +440,7 @@ format_string = "%Y %m %d %H %S %j %Z" result = _strptime._strptime_time(time.strftime(format_string, self.time_tuple), format_string) - self.assertTrue(result.tm_wday == self.time_tuple.tm_wday, + self.assertEqual(result.tm_wday, self.time_tuple.tm_wday, "Calculation of day of the week failed;" "%s != %s" % (result.tm_wday, self.time_tuple.tm_wday)) @@ -453,7 +453,7 @@ dt_date = datetime_date(*ymd_tuple) strp_input = dt_date.strftime(format_string) strp_output = _strptime._strptime_time(strp_input, format_string) - self.assertTrue(strp_output[:3] == ymd_tuple, + self.assertEqual(strp_output[:3], ymd_tuple, "%s(%s) test failed w/ '%s': %s != %s (%s != %s)" % (test_reason, directive, strp_input, strp_output[:3], ymd_tuple, diff -r cf606c403f14 Lib/test/test_structseq.py --- a/Lib/test/test_structseq.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_structseq.py Mon Nov 19 12:28:22 2012 +0200 @@ -70,11 +70,11 @@ t1 = time.gmtime() t2 = type(t1)(t1) self.assertEqual(t1, t2) - self.assertTrue(not (t1 < t2)) + self.assertFalse(t1 < t2) self.assertTrue(t1 <= t2) - self.assertTrue(not (t1 > t2)) + self.assertFalse(t1 > t2) self.assertTrue(t1 >= t2) - self.assertTrue(not (t1 != t2)) + self.assertFalse(t1 != t2) def test_fields(self): t = time.gmtime() diff -r cf606c403f14 Lib/test/test_symtable.py --- a/Lib/test/test_symtable.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_symtable.py Mon Nov 19 12:28:22 2012 +0200 @@ -122,7 +122,7 @@ self.assertTrue(self.top.lookup("namespace_test").is_namespace()) self.assertFalse(self.spam.lookup("x").is_namespace()) - self.assertTrue(self.top.lookup("spam").get_namespace() is self.spam) + self.assertIs(self.top.lookup("spam").get_namespace(), self.spam) ns_test = self.top.lookup("namespace_test") self.assertEqual(len(ns_test.get_namespaces()), 2) self.assertRaises(ValueError, ns_test.get_namespace) diff -r cf606c403f14 Lib/test/test_sys.py --- a/Lib/test/test_sys.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_sys.py Mon Nov 19 12:28:22 2012 +0200 @@ -42,7 +42,7 @@ dh(None) self.assertEqual(out.getvalue(), "") - self.assertTrue(not hasattr(builtins, "_")) + self.assertFalse(hasattr(builtins, "_")) dh(42) self.assertEqual(out.getvalue(), "42\n") self.assertEqual(builtins._, 42) @@ -198,7 +198,7 @@ self.assertRaises(ValueError, sys.setswitchinterval, 0.0) orig = sys.getswitchinterval() # sanity check - self.assertTrue(orig < 0.5, orig) + self.assertLess(orig, 0.5) try: for n in 0.00001, 0.05, 3.0, orig: sys.setswitchinterval(n) @@ -379,7 +379,7 @@ # Verify that the captured main-thread frame is _this_ frame. frame = d.pop(main_id) - self.assertTrue(frame is sys._getframe()) + self.assertIs(frame, sys._getframe()) # Verify that the captured thread frame is blocked in g456, called # from f123. This is a litte tricky, since various bits of @@ -410,7 +410,7 @@ d = sys._current_frames() self.assertEqual(len(d), 1) self.assertIn(0, d) - self.assertTrue(d[0] is sys._getframe()) + self.assertIs(d[0], sys._getframe()) def test_attributes(self): self.assertIsInstance(sys.api_version, int) @@ -424,8 +424,8 @@ self.assertEqual(len(sys.float_info), 11) self.assertEqual(sys.float_info.radix, 2) self.assertEqual(len(sys.int_info), 2) - self.assertTrue(sys.int_info.bits_per_digit % 5 == 0) - self.assertTrue(sys.int_info.sizeof_digit >= 1) + self.assertEqual(sys.int_info.bits_per_digit % 5, 0) + self.assertGreaterEqual(sys.int_info.sizeof_digit, 1) self.assertEqual(type(sys.int_info.bits_per_digit), int) self.assertEqual(type(sys.int_info.sizeof_digit), int) self.assertIsInstance(sys.hexversion, int) @@ -471,7 +471,7 @@ self.assertEqual(vi[2], vi.micro) self.assertEqual(vi[3], vi.releaselevel) self.assertEqual(vi[4], vi.serial) - self.assertTrue(vi > (1,0,0)) + self.assertGreater(vi, (1,0,0)) self.assertIsInstance(sys.float_repr_style, str) self.assertIn(sys.float_repr_style, ('short', 'legacy')) if not sys.platform.startswith('win'): @@ -495,9 +495,9 @@ numruns += 1 self.assertRaises(TypeError, sys.intern) s = "never interned before" + str(numruns) - self.assertTrue(sys.intern(s) is s) + self.assertIs(sys.intern(s), s) s2 = s.swapcase().swapcase() - self.assertTrue(sys.intern(s2) is s) + self.assertIs(sys.intern(s2), s) # Subclasses of string can't be interned, because they # provide too much opportunity for insane things to happen. diff -r cf606c403f14 Lib/test/test_sysconfig.py --- a/Lib/test/test_sysconfig.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_sysconfig.py Mon Nov 19 12:28:22 2012 +0200 @@ -286,7 +286,7 @@ # just making sure _main() runs and returns things in the stdout with captured_stdout() as output: _main() - self.assertTrue(len(output.getvalue().split('\n')) > 0) + self.assertGreater(len(output.getvalue().split('\n')), 0) @unittest.skipIf(sys.platform == "win32", "Does not apply to Windows") def test_ldshared_value(self): diff -r cf606c403f14 Lib/test/test_tarfile.py --- a/Lib/test/test_tarfile.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_tarfile.py Mon Nov 19 12:28:22 2012 +0200 @@ -58,7 +58,7 @@ tarinfo = self.tar.getmember("ustar/regtype") with self.tar.extractfile(tarinfo) as fobj: data = fobj.read() - self.assertTrue((len(data), md5sum(data)) == (tarinfo.size, md5_regtype), + self.assertEqual((len(data), md5sum(data)), (tarinfo.size, md5_regtype), "regular file extraction failed") def test_fileobj_readlines(self): @@ -70,11 +70,11 @@ with self.tar.extractfile(tarinfo) as fobj: fobj2 = io.TextIOWrapper(fobj) lines2 = fobj2.readlines() - self.assertTrue(lines1 == lines2, + self.assertEqual(lines1, lines2, "fileobj.readlines() failed") - self.assertTrue(len(lines2) == 114, + self.assertEqual(len(lines2), 114, "fileobj.readlines() failed") - self.assertTrue(lines2[83] == + self.assertEqual(lines2[83], "I will gladly admit that Python is not the fastest running scripting language.\n", "fileobj.readlines() failed") @@ -85,7 +85,7 @@ lines1 = fobj1.readlines() with self.tar.extractfile(tarinfo) as fobj2: lines2 = list(io.TextIOWrapper(fobj2)) - self.assertTrue(lines1 == lines2, + self.assertEqual(lines1, lines2, "fileobj.__iter__() failed") def test_fileobj_seek(self): @@ -110,12 +110,12 @@ self.assertEqual(2048, fobj.tell(), "seek() to positive relative position failed") s = fobj.read(10) - self.assertTrue(s == data[2048:2058], + self.assertEqual(s, data[2048:2058], "read() after seek failed") fobj.seek(0, 2) self.assertEqual(tarinfo.size, fobj.tell(), "seek() to file's end failed") - self.assertTrue(fobj.read() == b"", + self.assertEqual(fobj.read(), b"", "read() at file's end did not return empty string") fobj.seek(-tarinfo.size, 2) self.assertEqual(0, fobj.tell(), @@ -124,13 +124,13 @@ s1 = fobj.readlines() fobj.seek(512) s2 = fobj.readlines() - self.assertTrue(s1 == s2, + self.assertEqual(s1, s2, "readlines() after seek failed") fobj.seek(0) self.assertEqual(len(fobj.readline()), fobj.tell(), "tell() after readline() failed") fobj.seek(512) - self.assertTrue(len(fobj.readline()) + 512 == fobj.tell(), + self.assertEqual(len(fobj.readline()) + 512, fobj.tell(), "tell() after seek() and readline() failed") fobj.seek(0) line = fobj.readline() @@ -306,7 +306,7 @@ # Old V7 tars create directory members using an AREGTYPE # header with a "/" appended to the filename field. tarinfo = self.tar.getmember("misc/dirtype-old-v7") - self.assertTrue(tarinfo.type == tarfile.DIRTYPE, + self.assertEqual(tarinfo.type, tarfile.DIRTYPE, "v7 dirtype failed") def test_xstar_type(self): @@ -320,15 +320,15 @@ def test_check_members(self): for tarinfo in self.tar: - self.assertTrue(int(tarinfo.mtime) == 0o7606136617, + self.assertEqual(int(tarinfo.mtime), 0o7606136617, "wrong mtime for %s" % tarinfo.name) if not tarinfo.name.startswith("ustar/"): continue - self.assertTrue(tarinfo.uname == "tarfile", + self.assertEqual(tarinfo.uname, "tarfile", "wrong uname for %s" % tarinfo.name) def test_find_members(self): - self.assertTrue(self.tar.getmembers()[-1].name == "misc/eof", + self.assertEqual(self.tar.getmembers()[-1].name, "misc/eof", "could not find all members") @unittest.skipUnless(hasattr(os, "link"), @@ -449,7 +449,7 @@ tarinfo = self.tar.next() # get "regtype" (can't use getmember) with self.tar.extractfile(tarinfo) as fobj: data = fobj.read() - self.assertTrue((len(data), md5sum(data)) == (tarinfo.size, md5_regtype), + self.assertEqual((len(data), md5sum(data)), (tarinfo.size, md5_regtype), "regular file extraction failed") def test_provoke_stream_error(self): @@ -467,7 +467,7 @@ t2 = tar2.next() if t1 is None: break - self.assertTrue(t2 is not None, "stream.next() failed.") + self.assertIsNotNone(t2, "stream.next() failed.") if t2.islnk() or t2.issym(): self.assertRaises(tarfile.StreamError, tar2.extractfile, t2) @@ -477,7 +477,7 @@ v2 = tar2.extractfile(t2) if v1 is None: continue - self.assertTrue(v2 is not None, "stream.extractfile() failed") + self.assertIsNotNone(v2, "stream.extractfile() failed") self.assertEqual(v1.read(), v2.read(), "stream extraction failed") finally: tar1.close() @@ -573,7 +573,7 @@ def _test_member(self, tarinfo, chksum=None, **kwargs): if chksum is not None: - self.assertTrue(md5sum(self.tar.extractfile(tarinfo).read()) == chksum, + self.assertEqual(md5sum(self.tar.extractfile(tarinfo).read()), chksum, "wrong md5sum for %s" % tarinfo.name) kwargs["mtime"] = 0o7606136617 @@ -584,7 +584,7 @@ kwargs["uname"] = "tarfile" kwargs["gname"] = "tarfile" for k, v in kwargs.items(): - self.assertTrue(getattr(tarinfo, k) == v, + self.assertEqual(getattr(tarinfo, k), v, "wrong value in %s field of %s" % (k, tarinfo.name)) def test_find_regtype(self): @@ -671,7 +671,7 @@ tarinfo = self.tar.getmember(longname) except KeyError: self.fail("longname not found") - self.assertTrue(tarinfo.type != tarfile.DIRTYPE, "read longname as dirtype") + self.assertNotEqual(tarinfo.type, tarfile.DIRTYPE, "read longname as dirtype") def test_read_longlink(self): longname = self.subdir + "/" + "123/" * 125 + "longname" @@ -680,7 +680,7 @@ tarinfo = self.tar.getmember(longlink) except KeyError: self.fail("longlink not found") - self.assertTrue(tarinfo.linkname == longname, "linkname wrong") + self.assertEqual(tarinfo.linkname, longname, "linkname wrong") def test_truncated_longname(self): longname = self.subdir + "/" + "123/" * 125 + "longname" @@ -723,7 +723,7 @@ if self._fs_supports_holes(): s = os.stat(filename) - self.assertTrue(s.st_blocks * 512 < s.st_size) + self.assertLess(s.st_blocks * 512, s.st_size) def test_sparse_file_old(self): self._test_sparse_file("gnu/sparse") @@ -805,7 +805,7 @@ tar = tarfile.open(fileobj=fobj, mode=self.mode) tar.addfile(tarfile.TarInfo("foo")) tar.close() - self.assertTrue(fobj.closed is False, "external fileobjs must never closed") + self.assertIs(fobj.closed, False, "external fileobjs must never closed") class WriteTest(WriteTestBase): @@ -827,7 +827,7 @@ tar = tarfile.open(tmpname) try: - self.assertTrue(tar.getnames()[0] == name, + self.assertEqual(tar.getnames()[0], name, "failed to store 100 char filename") finally: tar.close() @@ -842,7 +842,7 @@ tar.add(path) finally: tar.close() - self.assertTrue(os.path.getsize(tmpname) > 0, + self.assertGreater(os.path.getsize(tmpname), 0, "tarfile is empty") # The test_*_size tests test for bug #1167128. @@ -914,15 +914,15 @@ dstname = os.path.abspath(tmpname) tar = tarfile.open(tmpname, self.mode) try: - self.assertTrue(tar.name == dstname, "archive name must be absolute") + self.assertEqual(tar.name, dstname, "archive name must be absolute") tar.add(dstname) - self.assertTrue(tar.getnames() == [], "added the archive to itself") + self.assertEqual(tar.getnames(), [], "added the archive to itself") cwd = os.getcwd() os.chdir(TEMPDIR) tar.add(dstname) os.chdir(cwd) - self.assertTrue(tar.getnames() == [], "added the archive to itself") + self.assertEqual(tar.getnames(), [], "added the archive to itself") finally: tar.close() @@ -1113,7 +1113,7 @@ with open(tmpname, "rb") as fobj: data = fobj.read() data = dec.decompress(data) - self.assertTrue(len(dec.unused_data) == 0, + self.assertEqual(len(dec.unused_data), 0, "found trailing data") elif self.mode.endswith("xz"): with lzma.LZMAFile(tmpname) as fobj: @@ -1122,7 +1122,7 @@ with open(tmpname, "rb") as fobj: data = fobj.read() - self.assertTrue(data.count(b"\0") == tarfile.RECORDSIZE, + self.assertEqual(data.count(b"\0"), tarfile.RECORDSIZE, "incorrect zero padding") def test_file_mode(self): @@ -1181,7 +1181,7 @@ v1 = self._calc_size(name, link) v2 = tar.offset - self.assertTrue(v1 == v2, "GNU longname/longlink creation failed") + self.assertEqual(v1, v2, "GNU longname/longlink creation failed") finally: tar.close() @@ -1252,18 +1252,18 @@ # The same name will be added as a REGTYPE every # time regardless of st_nlink. tarinfo = self.tar.gettarinfo(self.foo) - self.assertTrue(tarinfo.type == tarfile.REGTYPE, + self.assertEqual(tarinfo.type, tarfile.REGTYPE, "add file as regular failed") def test_add_hardlink(self): tarinfo = self.tar.gettarinfo(self.bar) - self.assertTrue(tarinfo.type == tarfile.LNKTYPE, + self.assertEqual(tarinfo.type, tarfile.LNKTYPE, "add file as hardlink failed") def test_dereference_hardlink(self): self.tar.dereference = True tarinfo = self.tar.gettarinfo(self.bar) - self.assertTrue(tarinfo.type == tarfile.REGTYPE, + self.assertEqual(tarinfo.type, tarfile.REGTYPE, "dereferencing hardlink failed") @@ -1286,10 +1286,10 @@ try: if link: l = tar.getmembers()[0].linkname - self.assertTrue(link == l, "PAX longlink creation failed") + self.assertEqual(link, l, "PAX longlink creation failed") else: n = tar.getmembers()[0].name - self.assertTrue(name == n, "PAX longname creation failed") + self.assertEqual(name, n, "PAX longname creation failed") finally: tar.close() @@ -1315,8 +1315,8 @@ self.assertEqual(tar.getmembers()[0].pax_headers, pax_headers) # Test if all the fields are strings. for key, val in tar.pax_headers.items(): - self.assertTrue(type(key) is not bytes) - self.assertTrue(type(val) is not bytes) + self.assertIsNot(type(key), bytes) + self.assertIsNot(type(val), bytes) if key in tarfile.PAX_NUMBER_FIELDS: try: tarfile.PAX_NUMBER_FIELDS[key](val) @@ -1399,10 +1399,10 @@ tar = tarfile.open(tarname, "r", encoding="iso8859-1", errors="strict") try: for t in tar: - self.assertTrue(type(t.name) is str) - self.assertTrue(type(t.linkname) is str) - self.assertTrue(type(t.uname) is str) - self.assertTrue(type(t.gname) is str) + self.assertIs(type(t.name), str) + self.assertIs(type(t.linkname), str) + self.assertIs(type(t.uname), str) + self.assertIs(type(t.gname), str) finally: tar.close() diff -r cf606c403f14 Lib/test/test_telnetlib.py --- a/Lib/test/test_telnetlib.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_telnetlib.py Mon Nov 19 12:28:22 2012 +0200 @@ -44,7 +44,7 @@ telnet.sock.close() def testTimeoutDefault(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: telnet = telnetlib.Telnet(HOST, self.port) @@ -55,13 +55,13 @@ def testTimeoutNone(self): # None, having other default - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: telnet = telnetlib.Telnet(HOST, self.port, timeout=None) finally: socket.setdefaulttimeout(None) - self.assertTrue(telnet.sock.gettimeout() is None) + self.assertIsNone(telnet.sock.gettimeout()) telnet.sock.close() def testTimeoutValue(self): @@ -237,7 +237,7 @@ # test 'at least one byte' telnet = test_telnet([b'x' * 500]) data = telnet.read_some() - self.assertTrue(len(data) >= 1) + self.assertGreaterEqual(len(data), 1) # test EOF telnet = test_telnet() data = telnet.read_some() @@ -339,7 +339,7 @@ telnet.set_option_negotiation_callback(nego.do_nego) txt = telnet.read_all() cmd = nego.seen - self.assertTrue(len(cmd) > 0) # we expect at least one command + self.assertGreater(len(cmd), 0) # we expect at least one command self.assertIn(cmd[:1], self.cmds) self.assertEqual(cmd[1:2], tl.NOOPT) self.assertEqual(data_len, len(txt + cmd)) diff -r cf606c403f14 Lib/test/test_tempfile.py --- a/Lib/test/test_tempfile.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_tempfile.py Mon Nov 19 12:28:22 2012 +0200 @@ -88,7 +88,7 @@ for key in dict: if key[0] != '_' and key not in expected: unexp.append(key) - self.assertTrue(len(unexp) == 0, + self.assertEqual(len(unexp), 0, "unexpected keys: %s" % unexp) @@ -165,7 +165,7 @@ cand = tempfile._candidate_tempdir_list() - self.assertFalse(len(cand) == 0) + self.assertNotEqual(len(cand), 0) for c in cand: self.assertIsInstance(c, str) @@ -213,7 +213,7 @@ a = tempfile._get_candidate_names() b = tempfile._get_candidate_names() - self.assertTrue(a is b) + self.assertIs(a, b) class TestMkstempInner(BaseTestCase): @@ -342,7 +342,7 @@ p = tempfile.gettempprefix() self.assertIsInstance(p, str) - self.assertTrue(len(p) > 0) + self.assertGreater(len(p), 0) def test_usable_template(self): # gettempprefix returns a usable prefix string @@ -388,7 +388,7 @@ a = tempfile.gettempdir() b = tempfile.gettempdir() - self.assertTrue(a is b) + self.assertIs(a, b) class TestMkstemp(BaseTestCase): @@ -710,7 +710,7 @@ # A SpooledTemporaryFile should roll over to a real file on fileno() f = self.do_create(max_size=30) self.assertFalse(f._rolled) - self.assertTrue(f.fileno() > 0) + self.assertGreater(f.fileno(), 0) self.assertTrue(f._rolled) def test_multiple_close_before_rollover(self): diff -r cf606c403f14 Lib/test/test_threading.py --- a/Lib/test/test_threading.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_threading.py Mon Nov 19 12:28:22 2012 +0200 @@ -48,7 +48,7 @@ self.nrunning.inc() if verbose: print(self.nrunning.get(), 'tasks are running') - self.testcase.assertTrue(self.nrunning.get() <= 3) + self.testcase.assertLessEqual(self.nrunning.get(), 3) time.sleep(delay) if verbose: @@ -56,7 +56,7 @@ with self.mutex: self.nrunning.dec() - self.testcase.assertTrue(self.nrunning.get() >= 0) + self.testcase.assertGreaterEqual(self.nrunning.get(), 0) if verbose: print('%s is finished. %d tasks are running' % (self.name, self.nrunning.get())) @@ -98,9 +98,9 @@ print('waiting for all tasks to complete') for t in threads: t.join(NUMTASKS) - self.assertTrue(not t.is_alive()) + self.assertFalse(t.is_alive()) self.assertNotEqual(t.ident, 0) - self.assertFalse(t.ident is None) + self.assertIsNotNone(t.ident) self.assertTrue(re.match('', repr(t))) if verbose: @@ -109,7 +109,7 @@ def test_ident_of_no_threading_threads(self): # The ident still must work for the main thread and dummy threads. - self.assertFalse(threading.currentThread().ident is None) + self.assertIsNotNone(threading.currentThread().ident) def f(): ident.append(threading.currentThread().ident) done.set() @@ -117,7 +117,7 @@ ident = [] _thread.start_new_thread(f, ()) done.wait() - self.assertFalse(ident[0] is None) + self.assertIsNotNone(ident[0]) # Kill the "immortal" _DummyThread del threading._active[ident[0]] @@ -234,7 +234,7 @@ self.assertTrue(ret) if verbose: print(" verifying worker hasn't exited") - self.assertTrue(not t.finished) + self.assertFalse(t.finished) if verbose: print(" attempting to raise asynch exception in worker") result = set_async_exc(ctypes.c_long(t.id), exception) @@ -405,9 +405,9 @@ def test_repr_daemon(self): t = threading.Thread() - self.assertFalse('daemon' in repr(t)) + self.assertNotIn('daemon', repr(t)) t.daemon = True - self.assertTrue('daemon' in repr(t)) + self.assertIn('daemon', repr(t)) def test_deamon_param(self): t = threading.Thread() diff -r cf606c403f14 Lib/test/test_threading_local.py --- a/Lib/test/test_threading_local.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_threading_local.py Mon Nov 19 12:28:22 2012 +0200 @@ -194,7 +194,7 @@ wr = weakref.ref(x) del x gc.collect() - self.assertIs(wr(), None) + self.assertIsNone(wr()) class ThreadLocalTest(unittest.TestCase, BaseLocalTest): diff -r cf606c403f14 Lib/test/test_time.py --- a/Lib/test/test_time.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_time.py Mon Nov 19 12:28:22 2012 +0200 @@ -285,7 +285,7 @@ # example this bug: # http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=93810 self.assertIn(time.tzname[0], ('AEST' 'EST'), time.tzname[0]) - self.assertTrue(time.tzname[1] in ('AEDT', 'EDT'), str(time.tzname[1])) + self.assertIn(time.tzname[1], ('AEDT', 'EDT'), str(time.tzname[1])) self.assertEqual(len(time.tzname), 2) self.assertEqual(time.daylight, 1) self.assertEqual(time.timezone, -36000) @@ -631,11 +631,11 @@ # See if the offset and zone are similar to the module # attributes. if lt.tm_gmtoff is None: - self.assertTrue(not hasattr(time, "timezone")) + self.assertFalse(hasattr(time, "timezone")) else: self.assertEqual(lt.tm_gmtoff, -[time.timezone, time.altzone][lt.tm_isdst]) if lt.tm_zone is None: - self.assertTrue(not hasattr(time, "tzname")) + self.assertFalse(hasattr(time, "tzname")) else: self.assertEqual(lt.tm_zone, time.tzname[lt.tm_isdst]) @@ -670,8 +670,8 @@ # Load a short time structure using pickle. st = b"ctime\nstruct_time\np0\n((I2007\nI8\nI11\nI1\nI24\nI49\nI5\nI223\nI1\ntp1\n(dp2\ntp3\nRp4\n." lt = pickle.loads(st) - self.assertIs(lt.tm_gmtoff, None) - self.assertIs(lt.tm_zone, None) + self.assertIsNone(lt.tm_gmtoff) + self.assertIsNone(lt.tm_zone) def test_main(): support.run_unittest( diff -r cf606c403f14 Lib/test/test_trace.py --- a/Lib/test/test_trace.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_trace.py Mon Nov 19 12:28:22 2012 +0200 @@ -306,11 +306,11 @@ with captured_stdout() as stdout: self._coverage(tracer) stdout = stdout.getvalue() - self.assertTrue("pprint.py" in stdout) - self.assertTrue("case.py" in stdout) # from unittest + self.assertIn("pprint.py", stdout) + self.assertIn("case.py", stdout) # from unittest files = os.listdir(TESTFN) - self.assertTrue("pprint.cover" in files) - self.assertTrue("unittest.case.cover" in files) + self.assertIn("pprint.cover", files) + self.assertIn("unittest.case.cover", files) def test_coverage_ignore(self): # Ignore all files, nothing should be traced nor printed diff -r cf606c403f14 Lib/test/test_traceback.py --- a/Lib/test/test_traceback.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_traceback.py Mon Nov 19 12:28:22 2012 +0200 @@ -36,15 +36,15 @@ err = self.get_exception_format(self.syntax_error_with_caret, SyntaxError) self.assertEqual(len(err), 4) - self.assertTrue(err[1].strip() == "return x!") + self.assertEqual(err[1].strip(), "return x!") self.assertIn("^", err[2]) # third line has caret self.assertEqual(err[1].find("!"), err[2].find("^")) # in the right place err = self.get_exception_format(self.syntax_error_with_caret_2, SyntaxError) self.assertIn("^", err[2]) # third line has caret - self.assertTrue(err[2].count('\n') == 1) # and no additional newline - self.assertTrue(err[1].find("+") == err[2].find("^")) # in the right place + self.assertEqual(err[2].count('\n'), 1) # and no additional newline + self.assertEqual(err[1].find("+"), err[2].find("^")) # in the right place def test_nocaret(self): exc = SyntaxError("error", ("x.py", 23, None, "bad syntax")) @@ -130,7 +130,7 @@ self.assertTrue(stdout[2].endswith(err_line), "Invalid traceback line: {0!r} instead of {1!r}".format( stdout[2], err_line)) - self.assertTrue(stdout[3] == err_msg, + self.assertEqual(stdout[3], err_msg, "Invalid error message: {0!r} instead of {1!r}".format( stdout[3], err_msg)) diff -r cf606c403f14 Lib/test/test_tuple.py --- a/Lib/test/test_tuple.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_tuple.py Mon Nov 19 12:28:22 2012 +0200 @@ -12,7 +12,7 @@ self.assertEqual(tuple(), ()) t0_3 = (0, 1, 2, 3) t0_3_bis = tuple(t0_3) - self.assertTrue(t0_3 is t0_3_bis) + self.assertIs(t0_3, t0_3_bis) self.assertEqual(tuple([]), ()) self.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3)) self.assertEqual(tuple(''), ()) @@ -20,7 +20,7 @@ def test_truth(self): super().test_truth() - self.assertTrue(not ()) + self.assertFalse(()) self.assertTrue((42, )) def test_len(self): @@ -34,14 +34,14 @@ u = (0, 1) u2 = u u += (2, 3) - self.assertTrue(u is not u2) + self.assertIsNot(u, u2) def test_imul(self): super().test_imul() u = (0, 1) u2 = u u *= 3 - self.assertTrue(u is not u2) + self.assertIsNot(u, u2) def test_tupleresizebug(self): # Check that a specific bug in _PyTuple_Resize() is squashed. @@ -72,7 +72,7 @@ inps = base + [(i, j) for i in base for j in xp] + \ [(i, j) for i in xp for j in base] + xp + list(zip(base)) collisions = len(inps) - len(set(map(hash, inps))) - self.assertTrue(collisions <= 15) + self.assertLessEqual(collisions, 15) def test_repr(self): l0 = tuple() diff -r cf606c403f14 Lib/test/test_types.py --- a/Lib/test/test_types.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_types.py Mon Nov 19 12:28:22 2012 +0200 @@ -623,8 +623,8 @@ self.assertEqual(view.get('x'), 1) self.assertEqual(view.get('y'), None) self.assertEqual(view.get('y', 42), 42) - self.assertTrue('x' in view) - self.assertFalse('y' in view) + self.assertIn('x', view) + self.assertNotIn('y', view) def test_customdict(self): class customdict(dict): @@ -660,9 +660,9 @@ custom = customdict({'key': 'value'}) view = self.mappingproxy(custom) - self.assertTrue('key' in view) - self.assertTrue('magic' in view) - self.assertFalse('xxx' in view) + self.assertIn('key', view) + self.assertIn('magic', view) + self.assertNotIn('xxx', view) self.assertEqual(view['key'], 'getitem=value') self.assertRaises(KeyError, view.__getitem__, 'xxx') self.assertEqual(tuple(view), ('iter',)) @@ -679,9 +679,9 @@ d2 = {'y': 2} mapping = collections.ChainMap(d1, d2) view = self.mappingproxy(mapping) - self.assertTrue('x' in view) - self.assertTrue('y' in view) - self.assertFalse('z' in view) + self.assertIn('x', view) + self.assertIn('y', view) + self.assertNotIn('z', view) self.assertEqual(view['x'], 1) self.assertEqual(view['y'], 2) self.assertRaises(KeyError, view.__getitem__, 'z') @@ -700,10 +700,10 @@ def test_contains(self): view = self.mappingproxy(dict.fromkeys('abc')) - self.assertTrue('a' in view) - self.assertTrue('b' in view) - self.assertTrue('c' in view) - self.assertFalse('xxx' in view) + self.assertIn('a', view) + self.assertIn('b', view) + self.assertIn('c', view) + self.assertNotIn('xxx', view) def test_views(self): mapping = {} diff -r cf606c403f14 Lib/test/test_unicode.py --- a/Lib/test/test_unicode.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_unicode.py Mon Nov 19 12:28:22 2012 +0200 @@ -41,7 +41,7 @@ method = getattr(object, methodname) realresult = method(*args) self.assertEqual(realresult, result) - self.assertTrue(type(realresult) is type(result)) + self.assertIs(type(realresult), type(result)) # if the original is returned make sure that # this doesn't happen with subclasses @@ -53,7 +53,7 @@ method = getattr(object, methodname) realresult = method(*args) self.assertEqual(realresult, result) - self.assertTrue(object is not realresult) + self.assertIsNot(object, realresult) def test_literals(self): self.assertEqual('\xff', '\u00ff') diff -r cf606c403f14 Lib/test/test_unicode_file.py --- a/Lib/test/test_unicode_file.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_unicode_file.py Mon Nov 19 12:28:22 2012 +0200 @@ -110,7 +110,7 @@ self._do_single(filename) finally: os.unlink(filename) - self.assertTrue(not os.path.exists(filename)) + self.assertFalse(os.path.exists(filename)) # and again with os.open. f = os.open(filename, os.O_CREAT) os.close(f) diff -r cf606c403f14 Lib/test/test_unicodedata.py --- a/Lib/test/test_unicodedata.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_unicodedata.py Mon Nov 19 12:28:22 2012 +0200 @@ -255,7 +255,7 @@ if dec != -1: self.assertEqual(dec, self.db.numeric(c)) count += 1 - self.assertTrue(count >= 10) # should have tested at least the ASCII digits + self.assertGreaterEqual(count, 10) # should have tested at least the ASCII digits def test_digit_numeric_consistent(self): # Test that digit and numeric are consistent, @@ -268,7 +268,7 @@ if dec != -1: self.assertEqual(dec, self.db.numeric(c)) count += 1 - self.assertTrue(count >= 10) # should have tested at least the ASCII digits + self.assertGreaterEqual(count, 10) # should have tested at least the ASCII digits def test_bug_1704793(self): self.assertEqual(self.db.lookup("GOTHIC LETTER FAIHU"), '\U00010346') @@ -277,7 +277,7 @@ import unicodedata # In UCD 5.1.0, a mirrored property changed wrt. UCD 3.2.0 self.assertTrue(unicodedata.mirrored("\u0f3a")) - self.assertTrue(not unicodedata.ucd_3_2_0.mirrored("\u0f3a")) + self.assertFalse(unicodedata.ucd_3_2_0.mirrored("\u0f3a")) # Also, we now have two ways of representing # the upper-case mapping: as delta, or as absolute value self.assertTrue("a".upper()=='A') diff -r cf606c403f14 Lib/test/test_urllib.py --- a/Lib/test/test_urllib.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_urllib.py Mon Nov 19 12:28:22 2012 +0200 @@ -1258,7 +1258,7 @@ # def testTimeoutNone(self): # # global default timeout is ignored # import socket -# self.assertTrue(socket.getdefaulttimeout() is None) +# self.assertIsNone(socket.getdefaulttimeout()) # socket.setdefaulttimeout(30) # try: # ftp = urllib.ftpwrapper("myuser", "mypass", "localhost", 9093, []) @@ -1270,7 +1270,7 @@ # def testTimeoutDefault(self): # # global default timeout is used # import socket -# self.assertTrue(socket.getdefaulttimeout() is None) +# self.assertIsNone(socket.getdefaulttimeout()) # socket.setdefaulttimeout(30) # try: # ftp = urllib.ftpwrapper("myuser", "mypass", "localhost", 9093, []) diff -r cf606c403f14 Lib/test/test_urllib2net.py --- a/Lib/test/test_urllib2net.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_urllib2net.py Mon Nov 19 12:28:22 2012 +0200 @@ -87,7 +87,7 @@ with support.transient_internet(url): response = _urlopen_with_retry(url) sock = response.fp - self.assertTrue(not sock.closed) + self.assertFalse(sock.closed) response.close() self.assertTrue(sock.closed) @@ -254,15 +254,15 @@ class TimeoutTest(unittest.TestCase): def test_http_basic(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) url = "http://www.python.org" with support.transient_internet(url, timeout=None): u = _urlopen_with_retry(url) self.addCleanup(u.close) - self.assertTrue(u.fp.raw._sock.gettimeout() is None) + self.assertIsNone(u.fp.raw._sock.gettimeout()) def test_http_default_timeout(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) url = "http://www.python.org" with support.transient_internet(url): socket.setdefaulttimeout(60) @@ -274,7 +274,7 @@ self.assertEqual(u.fp.raw._sock.gettimeout(), 60) def test_http_no_timeout(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) url = "http://www.python.org" with support.transient_internet(url): socket.setdefaulttimeout(60) @@ -283,7 +283,7 @@ self.addCleanup(u.close) finally: socket.setdefaulttimeout(None) - self.assertTrue(u.fp.raw._sock.gettimeout() is None) + self.assertIsNone(u.fp.raw._sock.gettimeout()) def test_http_timeout(self): url = "http://www.python.org" @@ -295,14 +295,14 @@ FTP_HOST = "ftp://ftp.mirror.nl/pub/gnu/" def test_ftp_basic(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) with support.transient_internet(self.FTP_HOST, timeout=None): u = _urlopen_with_retry(self.FTP_HOST) self.addCleanup(u.close) - self.assertTrue(u.fp.fp.raw._sock.gettimeout() is None) + self.assertIsNone(u.fp.fp.raw._sock.gettimeout()) def test_ftp_default_timeout(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) with support.transient_internet(self.FTP_HOST): socket.setdefaulttimeout(60) try: @@ -313,7 +313,7 @@ self.assertEqual(u.fp.fp.raw._sock.gettimeout(), 60) def test_ftp_no_timeout(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) with support.transient_internet(self.FTP_HOST): socket.setdefaulttimeout(60) try: @@ -321,7 +321,7 @@ self.addCleanup(u.close) finally: socket.setdefaulttimeout(None) - self.assertTrue(u.fp.fp.raw._sock.gettimeout() is None) + self.assertIsNone(u.fp.fp.raw._sock.gettimeout()) def test_ftp_timeout(self): with support.transient_internet(self.FTP_HOST): diff -r cf606c403f14 Lib/test/test_userdict.py --- a/Lib/test/test_userdict.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_userdict.py Mon Nov 19 12:28:22 2012 +0200 @@ -38,7 +38,7 @@ self.assertEqual(collections.UserDict().fromkeys('one two'.split()), d4) self.assertEqual(collections.UserDict.fromkeys('one two'.split(), 1), d5) self.assertEqual(collections.UserDict().fromkeys('one two'.split(), 1), d5) - self.assertTrue(u1.fromkeys('one two'.split()) is not u1) + self.assertIsNot(u1.fromkeys('one two'.split()), u1) self.assertIsInstance(u1.fromkeys('one two'.split()), collections.UserDict) self.assertIsInstance(u2.fromkeys('one two'.split()), collections.UserDict) diff -r cf606c403f14 Lib/test/test_uuid.py --- a/Lib/test/test_uuid.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_uuid.py Mon Nov 19 12:28:22 2012 +0200 @@ -293,8 +293,8 @@ def check_node(self, node, source): message = "%012x is not an RFC 4122 node ID" % node - self.assertTrue(0 < node, message) - self.assertTrue(node < (1 << 48), message) + self.assertGreater(node, 0, message) + self.assertLess(node, 1 << 48, message) TestUUID.source2node[source] = node if TestUUID.last_node: @@ -333,7 +333,7 @@ node = uuid._random_getnode() # Least significant bit of first octet must be set. self.assertTrue(node & 0x010000000000) - self.assertTrue(node < (1 << 48)) + self.assertLess(node, 1 << 48) def test_unixdll_getnode(self): import sys diff -r cf606c403f14 Lib/test/test_warnings.py --- a/Lib/test/test_warnings.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_warnings.py Mon Nov 19 12:28:22 2012 +0200 @@ -171,7 +171,7 @@ text = 'handle normally' self.module.warn(text) self.assertEqual(str(w[-1].message), text) - self.assertTrue(w[-1].category is UserWarning) + self.assertIs(w[-1].category, UserWarning) self.module.filterwarnings("ignore", "", Warning, "", 0) text = 'filtered out' @@ -184,7 +184,7 @@ text = 'nonmatching text' self.module.warn(text) self.assertEqual(str(w[-1].message), text) - self.assertTrue(w[-1].category is UserWarning) + self.assertIs(w[-1].category, UserWarning) class CFilterTests(BaseTest, FilterTests): module = c_warnings @@ -205,7 +205,7 @@ text = 'multi %d' %i # Different text on each call. self.module.warn(text) self.assertEqual(str(w[-1].message), text) - self.assertTrue(w[-1].category is UserWarning) + self.assertIs(w[-1].category, UserWarning) # Issue 3639 def test_warn_nonstandard_types(self): @@ -366,7 +366,7 @@ # As an early adopter, we sanity check the # test.support.import_fresh_module utility function def test_accelerated(self): - self.assertFalse(original_warnings is self.module) + self.assertIsNot(original_warnings, self.module) self.assertFalse(hasattr(self.module.warn, '__code__')) class PyWarnTests(BaseTest, WarnTests): @@ -375,7 +375,7 @@ # As an early adopter, we sanity check the # test.support.import_fresh_module utility function def test_pure_python(self): - self.assertFalse(original_warnings is self.module) + self.assertIsNot(original_warnings, self.module) self.assertTrue(hasattr(self.module.warn, '__code__')) @@ -619,20 +619,20 @@ # Ensure both showwarning and filters are restored when recording with wmod.catch_warnings(module=wmod, record=True): wmod.filters = wmod.showwarning = object() - self.assertTrue(wmod.filters is orig_filters) - self.assertTrue(wmod.showwarning is orig_showwarning) + self.assertIs(wmod.filters, orig_filters) + self.assertIs(wmod.showwarning, orig_showwarning) # Same test, but with recording disabled with wmod.catch_warnings(module=wmod, record=False): wmod.filters = wmod.showwarning = object() - self.assertTrue(wmod.filters is orig_filters) - self.assertTrue(wmod.showwarning is orig_showwarning) + self.assertIs(wmod.filters, orig_filters) + self.assertIs(wmod.showwarning, orig_showwarning) def test_catch_warnings_recording(self): wmod = self.module # Ensure warnings are recorded when requested with wmod.catch_warnings(module=wmod, record=True) as w: self.assertEqual(w, []) - self.assertTrue(type(w) is list) + self.assertIs(type(w), list) wmod.simplefilter("always") wmod.warn("foo") self.assertEqual(str(w[-1].message), "foo") @@ -645,8 +645,8 @@ # Ensure warnings are not recorded when not requested orig_showwarning = wmod.showwarning with wmod.catch_warnings(module=wmod, record=False) as w: - self.assertTrue(w is None) - self.assertTrue(wmod.showwarning is orig_showwarning) + self.assertIsNone(w) + self.assertIs(wmod.showwarning, orig_showwarning) def test_catch_warnings_reentry_guard(self): wmod = self.module @@ -667,17 +667,17 @@ orig_showwarning = wmod.showwarning # Ensure default behaviour is not to record warnings with wmod.catch_warnings(module=wmod) as w: - self.assertTrue(w is None) - self.assertTrue(wmod.showwarning is orig_showwarning) - self.assertTrue(wmod.filters is not orig_filters) - self.assertTrue(wmod.filters is orig_filters) + self.assertIsNone(w) + self.assertIs(wmod.showwarning, orig_showwarning) + self.assertIsNot(wmod.filters, orig_filters) + self.assertIs(wmod.filters, orig_filters) if wmod is sys.modules['warnings']: # Ensure the default module is this one with wmod.catch_warnings() as w: - self.assertTrue(w is None) - self.assertTrue(wmod.showwarning is orig_showwarning) - self.assertTrue(wmod.filters is not orig_filters) - self.assertTrue(wmod.filters is orig_filters) + self.assertIsNone(w) + self.assertIs(wmod.showwarning, orig_showwarning) + self.assertIsNot(wmod.filters, orig_filters) + self.assertIs(wmod.filters, orig_filters) def test_check_warnings(self): # Explicit tests for the test.support convenience wrapper diff -r cf606c403f14 Lib/test/test_weakref.py --- a/Lib/test/test_weakref.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_weakref.py Mon Nov 19 12:28:22 2012 +0200 @@ -93,11 +93,11 @@ ref1 = weakref.ref(o, self.callback) ref2 = weakref.ref(o, self.callback) del o - self.assertTrue(ref1() is None, + self.assertIsNone(ref1(), "expected reference to be invalidated") - self.assertTrue(ref2() is None, + self.assertIsNone(ref2(), "expected reference to be invalidated") - self.assertTrue(self.cbcalled == 2, + self.assertEqual(self.cbcalled, 2, "callback not called the right number of times") def test_multiple_selfref_callbacks(self): @@ -136,10 +136,10 @@ def check_basic_ref(self, factory): o = factory() ref = weakref.ref(o) - self.assertTrue(ref() is not None, + self.assertIsNotNone(ref(), "weak reference to live object should be live") o2 = ref() - self.assertTrue(o is o2, + self.assertIs(o, o2, "() should return original object if live") def check_basic_callback(self, factory): @@ -147,9 +147,9 @@ o = factory() ref = weakref.ref(o, self.callback) del o - self.assertTrue(self.cbcalled == 1, + self.assertEqual(self.cbcalled, 1, "callback did not properly set 'cbcalled'") - self.assertTrue(ref() is None, + self.assertIsNone(ref(), "ref2 should be dead after deleting object reference") def test_ref_reuse(self): @@ -159,19 +159,19 @@ # between these two; it should make no difference proxy = weakref.proxy(o) ref2 = weakref.ref(o) - self.assertTrue(ref1 is ref2, + self.assertIs(ref1, ref2, "reference object w/out callback should be re-used") o = C() proxy = weakref.proxy(o) ref1 = weakref.ref(o) ref2 = weakref.ref(o) - self.assertTrue(ref1 is ref2, + self.assertIs(ref1, ref2, "reference object w/out callback should be re-used") - self.assertTrue(weakref.getweakrefcount(o) == 2, + self.assertEqual(weakref.getweakrefcount(o), 2, "wrong weak ref count for object") del proxy - self.assertTrue(weakref.getweakrefcount(o) == 1, + self.assertEqual(weakref.getweakrefcount(o), 1, "wrong weak ref count for object after deleting proxy") def test_proxy_reuse(self): @@ -179,7 +179,7 @@ proxy1 = weakref.proxy(o) ref = weakref.ref(o) proxy2 = weakref.proxy(o) - self.assertTrue(proxy1 is proxy2, + self.assertIs(proxy1, proxy2, "proxy object w/out callback should have been re-used") def test_basic_proxy(self): @@ -259,19 +259,19 @@ o = Object(1) p1 = makeref(o, None) p2 = makeref(o, None) - self.assertTrue(p1 is p2, "both callbacks were None in the C API") + self.assertIs(p1, p2, "both callbacks were None in the C API") del p1, p2 p1 = makeref(o) p2 = makeref(o, None) - self.assertTrue(p1 is p2, "callbacks were NULL, None in the C API") + self.assertIs(p1, p2, "callbacks were NULL, None in the C API") del p1, p2 p1 = makeref(o) p2 = makeref(o) - self.assertTrue(p1 is p2, "both callbacks were NULL in the C API") + self.assertIs(p1, p2, "both callbacks were NULL in the C API") del p1, p2 p1 = makeref(o, None) p2 = makeref(o) - self.assertTrue(p1 is p2, "callbacks were None, NULL in the C API") + self.assertIs(p1, p2, "callbacks were None, NULL in the C API") def test_callable_proxy(self): o = Callable() @@ -279,13 +279,13 @@ self.check_proxy(o, ref1) - self.assertTrue(type(ref1) is weakref.CallableProxyType, + self.assertIs(type(ref1), weakref.CallableProxyType, "proxy is not of callable type") ref1('twinkies!') - self.assertTrue(o.bar == 'twinkies!', + self.assertEqual(o.bar, 'twinkies!', "call through proxy not passed through to original") ref1(x='Splat.') - self.assertTrue(o.bar == 'Splat.', + self.assertEqual(o.bar, 'Splat.', "call through proxy not passed through to original") # expect due to too few args @@ -296,24 +296,24 @@ def check_proxy(self, o, proxy): o.foo = 1 - self.assertTrue(proxy.foo == 1, + self.assertEqual(proxy.foo, 1, "proxy does not reflect attribute addition") o.foo = 2 - self.assertTrue(proxy.foo == 2, + self.assertEqual(proxy.foo, 2, "proxy does not reflect attribute modification") del o.foo - self.assertTrue(not hasattr(proxy, 'foo'), + self.assertFalse(hasattr(proxy, 'foo'), "proxy does not reflect attribute removal") proxy.foo = 1 - self.assertTrue(o.foo == 1, + self.assertEqual(o.foo, 1, "object does not reflect attribute addition via proxy") proxy.foo = 2 self.assertTrue( o.foo == 2, "object does not reflect attribute modification via proxy") del proxy.foo - self.assertTrue(not hasattr(o, 'foo'), + self.assertFalse(hasattr(o, 'foo'), "object does not reflect attribute removal via proxy") def test_proxy_deletion(self): @@ -337,21 +337,21 @@ o = C() ref1 = weakref.ref(o) ref2 = weakref.ref(o, self.callback) - self.assertTrue(weakref.getweakrefcount(o) == 2, + self.assertEqual(weakref.getweakrefcount(o), 2, "got wrong number of weak reference objects") proxy1 = weakref.proxy(o) proxy2 = weakref.proxy(o, self.callback) - self.assertTrue(weakref.getweakrefcount(o) == 4, + self.assertEqual(weakref.getweakrefcount(o), 4, "got wrong number of weak reference objects") del ref1, ref2, proxy1, proxy2 - self.assertTrue(weakref.getweakrefcount(o) == 0, + self.assertEqual(weakref.getweakrefcount(o), 0, "weak reference objects not unlinked from" " referent when discarded.") # assumes ints do not support weakrefs - self.assertTrue(weakref.getweakrefcount(1) == 0, + self.assertEqual(weakref.getweakrefcount(1), 0, "got wrong number of weak reference objects for int") def test_getweakrefs(self): @@ -359,22 +359,22 @@ ref1 = weakref.ref(o, self.callback) ref2 = weakref.ref(o, self.callback) del ref1 - self.assertTrue(weakref.getweakrefs(o) == [ref2], + self.assertEqual(weakref.getweakrefs(o), [ref2], "list of refs does not match") o = C() ref1 = weakref.ref(o, self.callback) ref2 = weakref.ref(o, self.callback) del ref2 - self.assertTrue(weakref.getweakrefs(o) == [ref1], + self.assertEqual(weakref.getweakrefs(o), [ref1], "list of refs does not match") del ref1 - self.assertTrue(weakref.getweakrefs(o) == [], + self.assertEqual(weakref.getweakrefs(o), [], "list of refs not cleared") # assumes ints do not support weakrefs - self.assertTrue(weakref.getweakrefs(1) == [], + self.assertEqual(weakref.getweakrefs(1), [], "list of refs does not match for int") def test_newstyle_number_ops(self): @@ -382,8 +382,8 @@ pass f = F(2.0) p = weakref.proxy(f) - self.assertTrue(p + 1.0 == 3.0) - self.assertTrue(1.0 + p == 3.0) # this used to SEGV + self.assertEqual(p + 1.0, 3.0) + self.assertEqual(1.0 + p, 3.0) # this used to SEGV def test_callbacks_protected(self): # Callbacks protected from already-set exceptions? @@ -636,7 +636,7 @@ c.wr = weakref.ref(d, callback) # this won't trigger d.wr = weakref.ref(callback, d.cb) # ditto external_wr = weakref.ref(callback, safe_callback) # but this will - self.assertTrue(external_wr() is callback) + self.assertIs(external_wr(), callback) # The weakrefs attached to c and d should get cleared, so that # C.cb is never called. But external_wr isn't part of the cyclic @@ -794,11 +794,11 @@ return super().__call__() o = Object("foo") mr = MyRef(o, value=24) - self.assertTrue(mr() is o) + self.assertIs(mr(), o) self.assertTrue(mr.called) self.assertEqual(mr.value, 24) del o - self.assertTrue(mr() is None) + self.assertIsNone(mr()) self.assertTrue(mr.called) def test_subclass_refs_dont_replace_standard_refs(self): @@ -807,14 +807,14 @@ o = Object(42) r1 = MyRef(o) r2 = weakref.ref(o) - self.assertTrue(r1 is not r2) + self.assertIsNot(r1, r2) self.assertEqual(weakref.getweakrefs(o), [r2, r1]) self.assertEqual(weakref.getweakrefcount(o), 2) r3 = MyRef(o) self.assertEqual(weakref.getweakrefcount(o), 3) refs = weakref.getweakrefs(o) self.assertEqual(len(refs), 3) - self.assertTrue(r2 is refs[0]) + self.assertIs(r2, refs[0]) self.assertIn(r1, refs[1:]) self.assertIn(r3, refs[1:]) @@ -824,7 +824,7 @@ o = Object(42) r1 = MyRef(o, id) r2 = MyRef(o, str) - self.assertTrue(r1 is not r2) + self.assertIsNot(r1, r2) refs = weakref.getweakrefs(o) self.assertIn(r1, refs) self.assertIn(r2, refs) @@ -1086,7 +1086,7 @@ dict, objects = self.make_weak_valued_dict() for o in objects: self.assertEqual(weakref.getweakrefcount(o), 1) - self.assertTrue(o is dict[o.arg], + self.assertIs(o, dict[o.arg], "wrong object returned by weak dict!") items1 = list(dict.items()) items2 = list(dict.copy().items()) @@ -1115,9 +1115,9 @@ # dict, objects = self.make_weak_keyed_dict() for o in objects: - self.assertTrue(weakref.getweakrefcount(o) == 1, + self.assertEqual(weakref.getweakrefcount(o), 1, "wrong number of weak references to %r!" % o) - self.assertTrue(o.arg is dict[o], + self.assertIs(o.arg, dict[o], "wrong object returned by weak dict!") items1 = dict.items() items2 = dict.copy().items() @@ -1126,10 +1126,10 @@ del items1, items2 self.assertEqual(len(dict), self.COUNT) del objects[0] - self.assertTrue(len(dict) == (self.COUNT - 1), + self.assertEqual(len(dict), (self.COUNT - 1), "deleting object did not cause dictionary update") del objects, o - self.assertTrue(len(dict) == 0, + self.assertEqual(len(dict), 0, "deleting the keys did not clear the dictionary") o = Object(42) dict[o] = "What is the meaning of the universe?" @@ -1339,15 +1339,15 @@ k, v = weakdict.popitem() self.assertEqual(len(weakdict), 1) if k is key1: - self.assertTrue(v is value1) + self.assertIs(v, value1) else: - self.assertTrue(v is value2) + self.assertIs(v, value2) k, v = weakdict.popitem() self.assertEqual(len(weakdict), 0) if k is key1: - self.assertTrue(v is value1) + self.assertIs(v, value1) else: - self.assertTrue(v is value2) + self.assertIs(v, value2) def test_weak_valued_dict_popitem(self): self.check_popitem(weakref.WeakValueDictionary, @@ -1358,21 +1358,21 @@ C(), "value 1", C(), "value 2") def check_setdefault(self, klass, key, value1, value2): - self.assertTrue(value1 is not value2, + self.assertIsNot(value1, value2, "invalid test" " -- value parameters must be distinct objects") weakdict = klass() o = weakdict.setdefault(key, value1) - self.assertTrue(o is value1) + self.assertIs(o, value1) self.assertIn(key, weakdict) - self.assertTrue(weakdict.get(key) is value1) - self.assertTrue(weakdict[key] is value1) + self.assertIs(weakdict.get(key), value1) + self.assertIs(weakdict[key], value1) o = weakdict.setdefault(key, value2) - self.assertTrue(o is value1) + self.assertIs(o, value1) self.assertIn(key, weakdict) - self.assertTrue(weakdict.get(key) is value1) - self.assertTrue(weakdict[key] is value1) + self.assertIs(weakdict.get(key), value1) + self.assertIs(weakdict[key], value1) def test_weak_valued_dict_setdefault(self): self.check_setdefault(weakref.WeakValueDictionary, @@ -1393,13 +1393,13 @@ for k in weakdict.keys(): self.assertIn(k, dict, "mysterious new key appeared in weak dict") v = dict.get(k) - self.assertTrue(v is weakdict[k]) - self.assertTrue(v is weakdict.get(k)) + self.assertIs(v, weakdict[k]) + self.assertIs(v, weakdict.get(k)) for k in dict.keys(): self.assertIn(k, weakdict, "original key disappeared in weak dict") v = dict[k] - self.assertTrue(v is weakdict[k]) - self.assertTrue(v is weakdict.get(k)) + self.assertIs(v, weakdict[k]) + self.assertIs(v, weakdict.get(k)) def test_weak_valued_dict_update(self): self.check_update(weakref.WeakValueDictionary, @@ -1429,7 +1429,7 @@ self.assertEqual(len(d), 2) del d['something'] self.assertEqual(len(d), 1) - self.assertTrue(list(d.items()) == [('something else', o2)]) + self.assertEqual(list(d.items()), [('something else', o2)]) def test_weak_keyed_bad_delitem(self): d = weakref.WeakKeyDictionary() diff -r cf606c403f14 Lib/test/test_weakset.py --- a/Lib/test/test_weakset.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_weakset.py Mon Nov 19 12:28:22 2012 +0200 @@ -105,7 +105,7 @@ def test_isdisjoint(self): self.assertTrue(self.s.isdisjoint(WeakSet(self.items2))) - self.assertTrue(not self.s.isdisjoint(WeakSet(self.letters))) + self.assertFalse(self.s.isdisjoint(WeakSet(self.letters))) def test_and(self): i = self.s.intersection(self.items2) @@ -222,9 +222,9 @@ self.assertEqual(self.s, dup) self.assertRaises(TypeError, self.s.add, []) self.fs.add(Foo()) - self.assertTrue(len(self.fs) == 1) + self.assertEqual(len(self.fs), 1) self.fs.add(self.obj) - self.assertTrue(len(self.fs) == 1) + self.assertEqual(len(self.fs), 1) def test_remove(self): x = ustr('a') diff -r cf606c403f14 Lib/test/test_winreg.py --- a/Lib/test/test_winreg.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_winreg.py Mon Nov 19 12:28:22 2012 +0200 @@ -72,7 +72,7 @@ # Set the default value for this key. SetValue(root_key, test_key_name, REG_SZ, "Default value") key = CreateKey(root_key, test_key_name) - self.assertTrue(key.handle != 0) + self.assertNotEqual(key.handle, 0) # Create a sub-key sub_key = CreateKey(key, subkeystr) # Give the sub-key some named values @@ -187,11 +187,11 @@ def _test_named_args(self, key, sub_key): with CreateKeyEx(key=key, sub_key=sub_key, reserved=0, access=KEY_ALL_ACCESS) as ckey: - self.assertTrue(ckey.handle != 0) + self.assertNotEqual(ckey.handle, 0) with OpenKeyEx(key=key, sub_key=sub_key, reserved=0, access=KEY_ALL_ACCESS) as okey: - self.assertTrue(okey.handle != 0) + self.assertNotEqual(okey.handle, 0) class LocalWinregTests(BaseWinregTests): diff -r cf606c403f14 Lib/test/test_with.py --- a/Lib/test/test_with.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_with.py Mon Nov 19 12:28:22 2012 +0200 @@ -225,7 +225,7 @@ self.assertEqual(mock_manager.exit_args[0], exc_type) # Test the __exit__ arguments. Issue #7853 self.assertIsInstance(mock_manager.exit_args[1], exc_type) - self.assertIsNot(mock_manager.exit_args[2], None) + self.assertIsNotNone(mock_manager.exit_args[2]) def assertAfterWithGeneratorInvariantsWithError(self, mock_generator): self.assertTrue(mock_generator.yielded) diff -r cf606c403f14 Lib/test/test_wsgiref.py --- a/Lib/test/test_wsgiref.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_wsgiref.py Mon Nov 19 12:28:22 2012 +0200 @@ -196,7 +196,7 @@ # Check existing value env = {key:alt} util.setup_testing_defaults(env) - self.assertTrue(env[key] is alt) + self.assertIs(env[key], alt) def checkCrossDefault(self,key,value,**kw): util.setup_testing_defaults(kw) @@ -339,7 +339,7 @@ self.assertEqual(Headers(test[:]).keys(), ['x']) self.assertEqual(Headers(test[:]).values(), ['y']) self.assertEqual(Headers(test[:]).items(), test) - self.assertFalse(Headers(test).items() is test) # must be copy! + self.assertIsNot(Headers(test).items(), test) # must be copy! h=Headers([]) del h['foo'] # should not raise an error diff -r cf606c403f14 Lib/test/test_xdrlib.py --- a/Lib/test/test_xdrlib.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_xdrlib.py Mon Nov 19 12:28:22 2012 +0200 @@ -32,15 +32,15 @@ self.assertEqual(up.unpack_int(), 42) self.assertEqual(up.unpack_int(), -17) self.assertEqual(up.unpack_uint(), 9) - self.assertTrue(up.unpack_bool() is True) + self.assertIs(up.unpack_bool(), True) # remember position pos = up.get_position() - self.assertTrue(up.unpack_bool() is False) + self.assertIs(up.unpack_bool(), False) # rewind and unpack again up.set_position(pos) - self.assertTrue(up.unpack_bool() is False) + self.assertIs(up.unpack_bool(), False) self.assertEqual(up.unpack_uhyper(), 45) self.assertAlmostEqual(up.unpack_float(), 1.9) diff -r cf606c403f14 Lib/test/test_xmlrpc.py --- a/Lib/test/test_xmlrpc.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_xmlrpc.py Mon Nov 19 12:28:22 2012 +0200 @@ -932,8 +932,8 @@ # ignore failures due to non-blocking socket 'unavailable' errors if not is_unavailable_exception(e) and hasattr(e, "headers"): # The two server-side error headers shouldn't be sent back in this case - self.assertTrue(e.headers.get("X-exception") is None) - self.assertTrue(e.headers.get("X-traceback") is None) + self.assertIsNone(e.headers.get("X-exception")) + self.assertIsNone(e.headers.get("X-traceback")) else: self.fail('ProtocolError not raised') @@ -954,7 +954,7 @@ # We should get error info in the response expected_err = "invalid literal for int() with base 10: 'I am broken'" self.assertEqual(e.headers.get("X-exception"), expected_err) - self.assertTrue(e.headers.get("X-traceback") is not None) + self.assertIsNotNone(e.headers.get("X-traceback")) else: self.fail('ProtocolError not raised') diff -r cf606c403f14 Lib/test/test_xmlrpc_net.py --- a/Lib/test/test_xmlrpc_net.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_xmlrpc_net.py Mon Nov 19 12:28:22 2012 +0200 @@ -34,7 +34,7 @@ delta = dt1 - dt0 # The difference between the system time here and the system # time on the server should not be too big. - self.assertTrue(delta.days <= 1) + self.assertLessEqual(delta.days, 1) def test_python_builders(self): # Get the list of builders from the XMLRPC buildbot interface at diff -r cf606c403f14 Lib/test/test_zipfile.py --- a/Lib/test/test_zipfile.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/test/test_zipfile.py Mon Nov 19 12:28:22 2012 +0200 @@ -591,12 +591,12 @@ with zipfile.ZipFile(TESTFN2, "w") as zipfp: for fpath, fdata in SMALL_TEST_DATA: zipfp.writestr(fpath, fdata) - self.assertTrue(zipfp.fp is not None, 'zipfp is not open') - self.assertTrue(zipfp.fp is None, 'zipfp is not closed') + self.assertIsNotNone(zipfp.fp, 'zipfp is not open') + self.assertIsNone(zipfp.fp, 'zipfp is not closed') with zipfile.ZipFile(TESTFN2, "r") as zipfp: - self.assertTrue(zipfp.fp is not None, 'zipfp is not open') - self.assertTrue(zipfp.fp is None, 'zipfp is not closed') + self.assertIsNotNone(zipfp.fp, 'zipfp is not open') + self.assertIsNone(zipfp.fp, 'zipfp is not closed') def test_close_on_exception(self): """Check that the zipfile is closed if an exception is raised in the @@ -609,7 +609,7 @@ with zipfile.ZipFile(TESTFN2, "r") as zipfp2: raise zipfile.BadZipFile() except zipfile.BadZipFile: - self.assertTrue(zipfp2.fp is None, 'zipfp is not closed') + self.assertIsNone(zipfp2.fp, 'zipfp is not closed') def test_add_file_before_1980(self): # Set atime and mtime to 1970-01-01 @@ -962,15 +962,15 @@ # - passing a file object with open(TESTFN, "rb") as fp: chk = zipfile.is_zipfile(fp) - self.assertTrue(not chk) + self.assertFalse(chk) # - passing a file-like object fp = io.BytesIO() fp.write(b"this is not a legal zip file\n") chk = zipfile.is_zipfile(fp) - self.assertTrue(not chk) + self.assertFalse(chk) fp.seek(0, 0) chk = zipfile.is_zipfile(fp) - self.assertTrue(not chk) + self.assertFalse(chk) def test_is_zip_valid_file(self): """Check that is_zipfile() correctly identifies zip files.""" diff -r cf606c403f14 Lib/tkinter/test/test_ttk/test_extensions.py --- a/Lib/tkinter/test/test_ttk/test_extensions.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/tkinter/test/test_ttk/test_extensions.py Mon Nov 19 12:28:22 2012 +0200 @@ -45,7 +45,7 @@ # it tries calling instance attributes not yet defined. ttk.LabeledScale(variable=myvar) if hasattr(sys, 'last_type'): - self.assertFalse(sys.last_type == tkinter.TclError) + self.assertNotEqual(sys.last_type, tkinter.TclError) def test_initialization(self): @@ -120,14 +120,14 @@ # at the same time this shouldn't affect test outcome lscale.update() curr_xcoord = lscale.scale.coords()[0] - self.assertTrue(prev_xcoord != curr_xcoord) + self.assertNotEqual(prev_xcoord, curr_xcoord) # the label widget should have been repositioned too linfo_2 = lscale.label.place_info() self.assertEqual(lscale.label['text'], 0) self.assertEqual(curr_xcoord, int(linfo_2['x'])) # change the range back lscale.scale.configure(from_=0, to=10) - self.assertTrue(prev_xcoord != curr_xcoord) + self.assertNotEqual(prev_xcoord, curr_xcoord) self.assertEqual(prev_xcoord, int(linfo_1['x'])) lscale.destroy() @@ -146,7 +146,7 @@ # at the same time this shouldn't affect test outcome x.update() self.assertEqual(x.label['text'], newval) - self.assertTrue(x.scale.coords()[0] > curr_xcoord) + self.assertGreater(x.scale.coords()[0], curr_xcoord) self.assertEqual(x.scale.coords()[0], int(x.label.place_info()['x'])) @@ -238,7 +238,7 @@ if last == curr: # no more menu entries break - self.assertFalse(curr == default) + self.assertNotEqual(curr, default) i += 1 self.assertEqual(i, len(items)) diff -r cf606c403f14 Lib/tkinter/test/test_ttk/test_style.py --- a/Lib/tkinter/test/test_ttk/test_style.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/tkinter/test/test_ttk/test_style.py Mon Nov 19 12:28:22 2012 +0200 @@ -18,7 +18,7 @@ style.configure('TButton', background='yellow') self.assertEqual(style.configure('TButton', 'background'), 'yellow') - self.assertTrue(isinstance(style.configure('TButton'), dict)) + self.assertIsInstance(style.configure('TButton'), dict) def test_map(self): @@ -26,7 +26,7 @@ style.map('TButton', background=[('active', 'background', 'blue')]) self.assertEqual(style.map('TButton', 'background'), [('active', 'background', 'blue')]) - self.assertTrue(isinstance(style.map('TButton'), dict)) + self.assertIsInstance(style.map('TButton'), dict) def test_lookup(self): @@ -57,7 +57,7 @@ self.assertEqual(style.layout('Treeview'), tv_style) # should return a list - self.assertTrue(isinstance(style.layout('TButton'), list)) + self.assertIsInstance(style.layout('TButton'), list) # correct layout, but "option" doesn't exist as option self.assertRaises(tkinter.TclError, style.layout, 'Treeview', diff -r cf606c403f14 Lib/tkinter/test/test_ttk/test_widgets.py --- a/Lib/tkinter/test/test_ttk/test_widgets.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/tkinter/test/test_ttk/test_widgets.py Mon Nov 19 12:28:22 2012 +0200 @@ -215,7 +215,7 @@ def test_bbox(self): self.assertEqual(len(self.entry.bbox(0)), 4) for item in self.entry.bbox(0): - self.assertTrue(isinstance(item, int)) + self.assertIsInstance(item, int) self.assertRaises(tkinter.TclError, self.entry.bbox, 'noindex') self.assertRaises(tkinter.TclError, self.entry.bbox, None) @@ -393,7 +393,7 @@ child = ttk.Label() self.paned.add(child) - self.assertTrue(isinstance(self.paned.pane(0), dict)) + self.assertIsInstance(self.paned.pane(0), dict) self.assertEqual(self.paned.pane(0, weight=None), 0) # newer form for querying a single option self.assertEqual(self.paned.pane(0, 'weight'), 0) @@ -420,8 +420,8 @@ curr_pos = self.paned.sashpos(0) self.paned.sashpos(0, 1000) - self.assertTrue(curr_pos != self.paned.sashpos(0)) - self.assertTrue(isinstance(self.paned.sashpos(0), int)) + self.assertNotEqual(curr_pos, self.paned.sashpos(0)) + self.assertIsInstance(self.paned.sashpos(0), int) class RadiobuttonTest(unittest.TestCase): @@ -603,7 +603,7 @@ self.nb.add(self.child2) self.assertEqual(self.nb.tabs(), tabs) self.assertEqual(self.nb.index(self.child2), child2_index) - self.assertTrue(str(self.child2) == self.nb.tabs()[child2_index]) + self.assertEqual(str(self.child2), self.nb.tabs()[child2_index]) # but the tab next to it (not hidden) is the one selected now self.assertEqual(self.nb.index('current'), curr + 1) @@ -616,19 +616,19 @@ tabs = self.nb.tabs() child1_index = self.nb.index(self.child1) self.nb.forget(self.child1) - self.assertFalse(str(self.child1) in self.nb.tabs()) + self.assertNotIn(str(self.child1), self.nb.tabs()) self.assertEqual(len(tabs) - 1, len(self.nb.tabs())) self.nb.add(self.child1) self.assertEqual(self.nb.index(self.child1), 1) - self.assertFalse(child1_index == self.nb.index(self.child1)) + self.assertNotEqual(child1_index, self.nb.index(self.child1)) def test_index(self): self.assertRaises(tkinter.TclError, self.nb.index, -1) self.assertRaises(tkinter.TclError, self.nb.index, None) - self.assertTrue(isinstance(self.nb.index('end'), int)) + self.assertIsInstance(self.nb.index('end'), int) self.assertEqual(self.nb.index(self.child1), 0) self.assertEqual(self.nb.index(self.child2), 1) self.assertEqual(self.nb.index('end'), 2) @@ -692,7 +692,7 @@ self.assertRaises(tkinter.TclError, self.nb.tab, 'notab') self.assertRaises(tkinter.TclError, self.nb.tab, None) - self.assertTrue(isinstance(self.nb.tab(self.child1), dict)) + self.assertIsInstance(self.nb.tab(self.child1), dict) self.assertEqual(self.nb.tab(self.child1, text=None), 'a') # newer form for querying a single option self.assertEqual(self.nb.tab(self.child1, 'text'), 'a') @@ -761,7 +761,7 @@ bbox = self.tv.bbox(children[0]) self.assertEqual(len(bbox), 4) - self.assertTrue(isinstance(bbox, tuple)) + self.assertIsInstance(bbox, tuple) for item in bbox: if not isinstance(item, int): self.fail("Invalid bounding box: %s" % bbox) @@ -784,7 +784,7 @@ self.assertEqual(self.tv.get_children(), ()) item_id = self.tv.insert('', 'end') - self.assertTrue(isinstance(self.tv.get_children(), tuple)) + self.assertIsInstance(self.tv.get_children(), tuple) self.assertEqual(self.tv.get_children()[0], item_id) # add item_id and child3 as children of child2 @@ -809,9 +809,9 @@ def test_column(self): # return a dict with all options/values - self.assertTrue(isinstance(self.tv.column('#0'), dict)) + self.assertIsInstance(self.tv.column('#0'), dict) # return a single value of the given option - self.assertTrue(isinstance(self.tv.column('#0', width=None), int)) + self.assertIsInstance(self.tv.column('#0', width=None), int) # set a new value for an option self.tv.column('#0', width=10) # testing new way to get option value @@ -924,7 +924,7 @@ def test_heading(self): # check a dict is returned - self.assertTrue(isinstance(self.tv.heading('#0'), dict)) + self.assertIsInstance(self.tv.heading('#0'), dict) # check a value is returned self.tv.heading('#0', text='hi') @@ -1037,7 +1037,7 @@ self.tv.item(item, values=list(self.tv.item(item, values=None))) self.assertEqual(self.tv.item(item, values=None), (value, )) - self.assertTrue(isinstance(self.tv.item(item), dict)) + self.assertIsInstance(self.tv.item(item), dict) # erase item values self.tv.item(item, values='') @@ -1138,7 +1138,7 @@ 'blue') self.assertEqual(str(self.tv.tag_configure('test', foreground=None)), 'blue') - self.assertTrue(isinstance(self.tv.tag_configure('test'), dict)) + self.assertIsInstance(self.tv.tag_configure('test'), dict) tests_gui = ( diff -r cf606c403f14 Lib/unittest/test/test_case.py --- a/Lib/unittest/test/test_case.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/unittest/test/test_case.py Mon Nov 19 12:28:22 2012 +0200 @@ -307,7 +307,7 @@ def test(self): pass - self.assertTrue(Foo('test').failureException is AssertionError) + self.assertIs(Foo('test').failureException, AssertionError) # "This class attribute gives the exception raised by the test() method. # If a test framework needs to use a specialized exception, possibly to @@ -325,7 +325,7 @@ failureException = RuntimeError - self.assertTrue(Foo('test').failureException is RuntimeError) + self.assertIs(Foo('test').failureException, RuntimeError) Foo('test').run(result) @@ -348,7 +348,7 @@ failureException = RuntimeError - self.assertTrue(Foo('test').failureException is RuntimeError) + self.assertIs(Foo('test').failureException, RuntimeError) Foo('test').run(result) @@ -660,7 +660,7 @@ msg = e.args[0] else: self.fail('assertSequenceEqual did not fail.') - self.assertTrue(len(msg) < len(diff)) + self.assertLess(len(msg), len(diff)) self.assertIn(omitted, msg) self.maxDiff = len(diff) * 2 @@ -670,7 +670,7 @@ msg = e.args[0] else: self.fail('assertSequenceEqual did not fail.') - self.assertTrue(len(msg) > len(diff)) + self.assertGreater(len(msg), len(diff)) self.assertNotIn(omitted, msg) self.maxDiff = None @@ -680,7 +680,7 @@ msg = e.args[0] else: self.fail('assertSequenceEqual did not fail.') - self.assertTrue(len(msg) > len(diff)) + self.assertGreater(len(msg), len(diff)) self.assertNotIn(omitted, msg) def testTruncateMessage(self): diff -r cf606c403f14 Lib/unittest/test/test_loader.py --- a/Lib/unittest/test/test_loader.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/unittest/test/test_loader.py Mon Nov 19 12:28:22 2012 +0200 @@ -1289,4 +1289,4 @@ # "The default value is the TestSuite class" def test_suiteClass__default_value(self): loader = unittest.TestLoader() - self.assertTrue(loader.suiteClass is unittest.TestSuite) + self.assertIs(loader.suiteClass, unittest.TestSuite) diff -r cf606c403f14 Lib/unittest/test/test_result.py --- a/Lib/unittest/test/test_result.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/unittest/test/test_result.py Mon Nov 19 12:28:22 2012 +0200 @@ -176,7 +176,7 @@ self.assertEqual(result.shouldStop, False) test_case, formatted_exc = result.failures[0] - self.assertTrue(test_case is test) + self.assertIs(test_case, test) self.assertIsInstance(formatted_exc, str) # "addError(test, err)" @@ -224,7 +224,7 @@ self.assertEqual(result.shouldStop, False) test_case, formatted_exc = result.errors[0] - self.assertTrue(test_case is test) + self.assertIs(test_case, test) self.assertIsInstance(formatted_exc, str) def testGetDescriptionWithoutDocstring(self): diff -r cf606c403f14 Lib/unittest/test/testmock/testhelpers.py --- a/Lib/unittest/test/testmock/testhelpers.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/unittest/test/testmock/testhelpers.py Mon Nov 19 12:28:22 2012 +0200 @@ -177,7 +177,7 @@ args = _Call(((1, 2, 3), {})) self.assertEqual(args, call(1, 2, 3)) self.assertEqual(call(1, 2, 3), args) - self.assertTrue(call(1, 2, 3) in [args]) + self.assertIn(call(1, 2, 3), [args]) def test_call_ne(self): @@ -793,7 +793,7 @@ mock_property = foo.foo # no spec on properties - self.assertTrue(isinstance(mock_property, MagicMock)) + self.assertIsInstance(mock_property, MagicMock) mock_property(1, 2, 3) mock_property.abc(4, 5, 6) mock_property.assert_called_once_with(1, 2, 3) @@ -826,19 +826,19 @@ mock(b=6) for kall in call(1, 2), call(a=3), call(3, 4), call(b=6): - self.assertTrue(kall in mock.call_args_list) + self.assertIn(kall, mock.call_args_list) calls = [call(a=3), call(3, 4)] - self.assertTrue(calls in mock.call_args_list) + self.assertIn(calls, mock.call_args_list) calls = [call(1, 2), call(a=3)] - self.assertTrue(calls in mock.call_args_list) + self.assertIn(calls, mock.call_args_list) calls = [call(3, 4), call(b=6)] - self.assertTrue(calls in mock.call_args_list) + self.assertIn(calls, mock.call_args_list) calls = [call(3, 4)] - self.assertTrue(calls in mock.call_args_list) + self.assertIn(calls, mock.call_args_list) - self.assertFalse(call('fish') in mock.call_args_list) - self.assertFalse([call('fish')] in mock.call_args_list) + self.assertNotIn(call('fish'), mock.call_args_list) + self.assertNotIn([call('fish')], mock.call_args_list) def test_call_list_str(self): diff -r cf606c403f14 Lib/unittest/test/testmock/testmagicmethods.py --- a/Lib/unittest/test/testmock/testmagicmethods.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/unittest/test/testmock/testmagicmethods.py Mon Nov 19 12:28:22 2012 +0200 @@ -37,12 +37,12 @@ return self, 'fish' mock.__getitem__ = f - self.assertFalse(mock.__getitem__ is f) + self.assertIsNot(mock.__getitem__, f) self.assertEqual(mock['foo'], (mock, 'fish')) self.assertEqual(mock.__getitem__('foo'), (mock, 'fish')) mock.__getitem__ = mock - self.assertTrue(mock.__getitem__ is mock) + self.assertIs(mock.__getitem__, mock) def test_magic_methods_isolated_between_mocks(self): @@ -212,8 +212,8 @@ self.assertEqual(len(mock), 6) mock.__contains__ = lambda s, o: o == 3 - self.assertTrue(3 in mock) - self.assertFalse(6 in mock) + self.assertIn(3, mock) + self.assertNotIn(6, mock) mock.__iter__ = lambda s: iter('foobarbaz') self.assertEqual(list(mock), list('foobarbaz')) diff -r cf606c403f14 Lib/unittest/test/testmock/testmock.py --- a/Lib/unittest/test/testmock/testmock.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/unittest/test/testmock/testmock.py Mon Nov 19 12:28:22 2012 +0200 @@ -52,7 +52,7 @@ "method_calls not initialised correctly") # Can't use hasattr for this test as it always returns True on a mock - self.assertFalse('_items' in mock.__dict__, + self.assertNotIn('_items', mock.__dict__, "default mock should not have '_items' attribute") self.assertIsNone(mock._mock_parent, @@ -493,19 +493,19 @@ pass mock = Mock(spec=X) - self.assertTrue(isinstance(mock, X)) + self.assertIsInstance(mock, X) mock = Mock(spec=X()) - self.assertTrue(isinstance(mock, X)) + self.assertIsInstance(mock, X) self.assertIs(mock.__class__, X) self.assertEqual(Mock().__class__.__name__, 'Mock') mock = Mock(spec_set=X) - self.assertTrue(isinstance(mock, X)) + self.assertIsInstance(mock, X) mock = Mock(spec_set=X()) - self.assertTrue(isinstance(mock, X)) + self.assertIsInstance(mock, X) def test_setting_attribute_with_spec_set(self): diff -r cf606c403f14 Lib/unittest/test/testmock/testsentinel.py --- a/Lib/unittest/test/testmock/testsentinel.py Sun Nov 18 20:49:39 2012 -0600 +++ b/Lib/unittest/test/testmock/testsentinel.py Mon Nov 19 12:28:22 2012 +0200 @@ -17,7 +17,7 @@ def testDEFAULT(self): - self.assertTrue(DEFAULT is sentinel.DEFAULT) + self.assertIs(DEFAULT, sentinel.DEFAULT) def testBases(self): # If this doesn't raise an AttributeError then help(mock) is broken