diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py index b5f4782..915ab63 100644 --- a/Lib/test/_test_multiprocessing.py +++ b/Lib/test/_test_multiprocessing.py @@ -202,9 +202,9 @@ def test_current(self): 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) @@ -247,7 +247,7 @@ def test_process(self): 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() @@ -330,8 +330,8 @@ def test_cpu_count(self): 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) @@ -1721,7 +1721,7 @@ def test_namespace(self): 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')) # # @@ -3078,7 +3078,7 @@ class _TestLogging(BaseTestCase): 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) @@ -3815,8 +3815,8 @@ def test_get_all(self): if sys.platform == 'win32': self.assertEqual(methods, ['spawn']) else: - self.assertTrue(methods == ['fork', 'spawn'] or - methods == ['fork', 'spawn', 'forkserver']) + self.assertIn(methods, (['fork', 'spawn'], + ['fork', 'spawn', 'forkserver'])) def test_preload_resources(self): if multiprocessing.get_start_method() != 'forkserver': diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py index 5c83361..9183bbf 100644 --- a/Lib/test/pickletester.py +++ b/Lib/test/pickletester.py @@ -1342,7 +1342,7 @@ def test_recursive_multi(self): 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 check_recursive_collection_and_inst(self, factory): h = H() @@ -1632,7 +1632,7 @@ def test_singletons(self): 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[min(proto, 3), x] self.assertTrue(opcode_in_pickle(expected, s)) @@ -1764,7 +1764,7 @@ def test_list_chunking(self): 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 @@ -1787,7 +1787,7 @@ def test_dict_chunking(self): if proto == 0: self.assertEqual(num_setitems, 0) else: - self.assertTrue(num_setitems >= 2) + self.assertGreaterEqual(num_setitems, 2) def test_set_chunking(self): n = 10 # too small to chunk @@ -2737,7 +2737,7 @@ def test_priming_unpickler_memo(self): 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 --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py index 4bc8382..a1a343d 100644 --- a/Lib/test/test_abc.py +++ b/Lib/test/test_abc.py @@ -299,14 +299,14 @@ class A(metaclass=abc.ABCMeta): class B: pass b = B() - self.assertFalse(isinstance(b, A)) - self.assertFalse(isinstance(b, (A,))) + self.assertNotIsInstance(b, A) + self.assertNotIsInstance(b, (A,)) token_old = abc.get_cache_token() A.register(B) token_new = abc.get_cache_token() self.assertNotEqual(token_old, token_new) - 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 --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py index 2f59527..d91ff26 100644 --- a/Lib/test/test_ast.py +++ b/Lib/test/test_ast.py @@ -203,7 +203,7 @@ def _assertTrueorder(self, ast_node, parent_pos): 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 --git a/Lib/test/test_asyncore.py b/Lib/test/test_asyncore.py index d05462b..6628373 100644 --- a/Lib/test/test_asyncore.py +++ b/Lib/test/test_asyncore.py @@ -308,7 +308,7 @@ def test_strerror(self): 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 --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py index 5930d9e..1a0092d 100644 --- a/Lib/test/test_augassign.py +++ b/Lib/test/test_augassign.py @@ -62,7 +62,7 @@ def testSequences(self): y[1:2] += [1] self.assertEqual(x, [1, 2, 1, 2, 3]) - self.assertTrue(x is y) + self.assertIs(x, y) def testCustomMethods1(self): @@ -92,14 +92,14 @@ class aug_test4(aug_test3): 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) @@ -107,7 +107,7 @@ class aug_test4(aug_test3): x += 10 self.assertIsInstance(x, aug_test3) - self.assertTrue(y is not x) + self.assertIsNot(y, x) self.assertEqual(x.val, 13) x = aug_test4(4) diff --git a/Lib/test/test_binop.py b/Lib/test/test_binop.py index 3ed018e..d42be23 100644 --- a/Lib/test/test_binop.py +++ b/Lib/test/test_binop.py @@ -208,10 +208,10 @@ def test_gcd(self): 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 --git a/Lib/test/test_bisect.py b/Lib/test/test_bisect.py index 580a963..9cb6d0f 100644 --- a/Lib/test/test_bisect.py +++ b/Lib/test/test_bisect.py @@ -159,14 +159,14 @@ def test_random(self, n=25): 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: @@ -177,13 +177,13 @@ def test_optionalSlicing(self): 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 --git a/Lib/test/test_buffer.py b/Lib/test/test_buffer.py index b83f2f1..4511b8f 100644 --- a/Lib/test/test_buffer.py +++ b/Lib/test/test_buffer.py @@ -1346,7 +1346,7 @@ def test_ndarray_multidim(self): # 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, @@ -1574,13 +1574,13 @@ def test_ndarray_sequence(self): 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] @@ -2533,8 +2533,8 @@ def f(): return 7 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]) @@ -4357,7 +4357,7 @@ def test_memoryview_from_static_exporter(self): 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, @@ -4371,7 +4371,7 @@ def test_memoryview_from_static_exporter(self): 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 --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py index 416316c..cec52ce 100644 --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -157,7 +157,7 @@ def test_abs(self): 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) @@ -242,7 +242,7 @@ def _check_uni(s): 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): @@ -302,7 +302,7 @@ def test_chr(self): 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') @@ -406,7 +406,7 @@ class Foo(object): 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): @@ -414,7 +414,7 @@ def __dir__(self): 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): @@ -645,7 +645,7 @@ def test_filter_pickle(self): self.check_iter_pickle(f1, list(f2), proto) 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) @@ -726,11 +726,11 @@ class E: 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) @@ -746,7 +746,7 @@ class E: 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 --git a/Lib/test/test_bz2.py b/Lib/test/test_bz2.py index e76b283..8e181d4 100644 --- a/Lib/test/test_bz2.py +++ b/Lib/test/test_bz2.py @@ -720,7 +720,7 @@ def testDecompress4G(self, size): compressed = bz2.compress(data) bz2d = BZ2Decompressor() decompressed = bz2d.decompress(compressed) - self.assertTrue(decompressed == data) + self.assertEqual(decompressed, data) finally: data = None compressed = None diff --git a/Lib/test/test_capi.py b/Lib/test/test_capi.py index 2a53f3d..5fd4ce6 100644 --- a/Lib/test/test_capi.py +++ b/Lib/test/test_capi.py @@ -42,7 +42,7 @@ class CAPITest(unittest.TestCase): 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__) @@ -274,7 +274,7 @@ def pendingcalls_wait(self, l, n, context = None): 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 --git a/Lib/test/test_cmd_line.py b/Lib/test/test_cmd_line.py index 958d282..b0847d6 100644 --- a/Lib/test/test_cmd_line.py +++ b/Lib/test/test_cmd_line.py @@ -120,8 +120,8 @@ def test_run_module_bug1764407(self): 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 --git a/Lib/test/test_codeop.py b/Lib/test/test_codeop.py index 98da26f..b4f5511 100644 --- a/Lib/test/test_codeop.py +++ b/Lib/test/test_codeop.py @@ -54,7 +54,7 @@ def assertInvalid(self, str, symbol='single', is_syntax=1): 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 --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py index b4a52a5..584c464 100644 --- a/Lib/test/test_compile.py +++ b/Lib/test/test_compile.py @@ -436,7 +436,7 @@ def test_compile_ast(self): 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 --git a/Lib/test/test_compileall.py b/Lib/test/test_compileall.py index 2356efc..9583217 100644 --- a/Lib/test/test_compileall.py +++ b/Lib/test/test_compileall.py @@ -86,13 +86,13 @@ def test_compile_files(self): pass self.assertTrue(compileall.compile_file(self.source_path, force=False, quiet=True)) - self.assertTrue(os.path.isfile(self.bc_path) and - not os.path.isfile(self.bc_path2)) + self.assertTrue(os.path.isfile(self.bc_path)) + self.assertFalse(os.path.isfile(self.bc_path2)) os.unlink(self.bc_path) self.assertTrue(compileall.compile_dir(self.directory, force=False, quiet=True)) - self.assertTrue(os.path.isfile(self.bc_path) and - os.path.isfile(self.bc_path2)) + self.assertTrue(os.path.isfile(self.bc_path)) + self.assertTrue(os.path.isfile(self.bc_path2)) os.unlink(self.bc_path) os.unlink(self.bc_path2) # Test against bad files diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py index cee4934..03454f2 100644 --- a/Lib/test/test_complex.py +++ b/Lib/test/test_complex.py @@ -210,7 +210,7 @@ def test_pow(self): 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) @@ -295,7 +295,7 @@ def split_zeros(x): 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 --git a/Lib/test/test_concurrent_futures.py b/Lib/test/test_concurrent_futures.py index 23e95b2..bcf6e5b 100644 --- a/Lib/test/test_concurrent_futures.py +++ b/Lib/test/test_concurrent_futures.py @@ -734,8 +734,7 @@ def test_exception_with_timeout(self): 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): @@ -751,7 +750,7 @@ def notification(): 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 --git a/Lib/test/test_configparser.py b/Lib/test/test_configparser.py index 72c3f19..657af50 100644 --- a/Lib/test/test_configparser.py +++ b/Lib/test/test_configparser.py @@ -268,20 +268,20 @@ def basic_test(self, cf): # 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): @@ -486,7 +486,7 @@ def test_case_sensitivity_mapping_access(self): 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( @@ -508,7 +508,7 @@ def test_case_sensitivity_mapping_access(self): 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"}) @@ -1571,7 +1571,7 @@ def test_parsing_error(self): 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() @@ -1600,7 +1600,7 @@ def test_readfp_deprecation(self): 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') @@ -1609,7 +1609,7 @@ def test_safeconfigparser_deprecation(self): 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 --git a/Lib/test/test_copyreg.py b/Lib/test/test_copyreg.py index 52e887c..34238d2 100644 --- a/Lib/test/test_copyreg.py +++ b/Lib/test/test_copyreg.py @@ -50,8 +50,8 @@ def test_extension_registry(self): 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 --git a/Lib/test/test_crypt.py b/Lib/test/test_crypt.py index e4f5897..7d94967 100644 --- a/Lib/test/test_crypt.py +++ b/Lib/test/test_crypt.py @@ -26,7 +26,7 @@ def test_saltedcrypt(self): def test_methods(self): # Guarantee 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]) if __name__ == "__main__": diff --git a/Lib/test/test_dbm.py b/Lib/test/test_dbm.py index f0a428d..6e515fc 100644 --- a/Lib/test/test_dbm.py +++ b/Lib/test/test_dbm.py @@ -140,7 +140,7 @@ def test_whichdb(self): # 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, self.dbm.whichdb(_fname)) diff --git a/Lib/test/test_dbm_gnu.py b/Lib/test/test_dbm_gnu.py index 304b332..a4dc803 100644 --- a/Lib/test/test_dbm_gnu.py +++ b/Lib/test/test_dbm_gnu.py @@ -71,7 +71,7 @@ def test_reorganize(self): 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 --git a/Lib/test/test_epoll.py b/Lib/test/test_epoll.py index 549e0f7..b6eb118 100644 --- a/Lib/test/test_epoll.py +++ b/Lib/test/test_epoll.py @@ -69,8 +69,8 @@ def test_create(self): 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 --git a/Lib/test/test_faulthandler.py b/Lib/test/test_faulthandler.py index 28dd5f4..d9faedc 100644 --- a/Lib/test/test_faulthandler.py +++ b/Lib/test/test_faulthandler.py @@ -307,7 +307,7 @@ def test_disable(self): not_expected = 'Fatal Python error' stderr, exitcode = self.get_output(code) stderr = '\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 --git a/Lib/test/test_filecmp.py b/Lib/test/test_filecmp.py index b5b24a2..f2f0ae2 100644 --- a/Lib/test/test_filecmp.py +++ b/Lib/test/test_filecmp.py @@ -83,10 +83,10 @@ def test_default_ignores(self): self.assertIn('.hg', filecmp.DEFAULT_IGNORES) 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 --git a/Lib/test/test_fnmatch.py b/Lib/test/test_fnmatch.py index fb74246..ed2c4fe 100644 --- a/Lib/test/test_fnmatch.py +++ b/Lib/test/test_fnmatch.py @@ -12,7 +12,7 @@ def check_match(self, filename, pattern, should_match=1, fn=fnmatch): "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 --git a/Lib/test/test_funcattrs.py b/Lib/test/test_funcattrs.py index 8f481bb..16a5e5d 100644 --- a/Lib/test/test_funcattrs.py +++ b/Lib/test/test_funcattrs.py @@ -342,10 +342,10 @@ def f(): 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 --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py index 29ea493..47fe1f2 100644 --- a/Lib/test/test_functools.py +++ b/Lib/test/test_functools.py @@ -129,7 +129,8 @@ def test_positional(self): p = self.partial(capture, *args) expected = args + ('x',) got, empty = p('x') - self.assertTrue(expected == got and empty == {}) + self.assertEqual(got, expected) + self.assertEqual(empty, {}) def test_keyword(self): # make sure keyword arguments are captured correctly @@ -137,15 +138,18 @@ def test_keyword(self): p = self.partial(capture, a=a) expected = {'a':a,'x':None} empty, got = p(x=None) - self.assertTrue(expected == got and empty == ()) + self.assertEqual(got, expected) + self.assertEqual(empty, ()) def test_no_side_effects(self): # make sure there are no side effects that affect subsequent calls p = self.partial(capture, 0, a=1) args1, kw1 = p(1, b=2) - self.assertTrue(args1 == (0,1) and kw1 == {'a':1,'b':2}) + self.assertEqual(args1, (0,1)) + self.assertEqual(kw1, {'a':1,'b':2}) args2, kw2 = p() - self.assertTrue(args2 == (0,) and kw2 == {'a':1}) + self.assertEqual(args2, (0,)) + self.assertEqual(kw2, {'a':1}) def test_error_propagation(self): def f(x, y): @@ -1155,7 +1159,7 @@ def orig(x, y): 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 --git a/Lib/test/test_gc.py b/Lib/test/test_gc.py index e727499..c841f8a 100644 --- a/Lib/test/test_gc.py +++ b/Lib/test/test_gc.py @@ -814,9 +814,9 @@ def test_collect(self): # 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 --git a/Lib/test/test_gdb.py b/Lib/test/test_gdb.py index 46736f6..89f46e5 100644 --- a/Lib/test/test_gdb.py +++ b/Lib/test/test_gdb.py @@ -264,7 +264,7 @@ def get_sample_script(self): 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): # Ensure that gdb's rendering of the value in a debugged process diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py index 65e26bf..22bdd51 100644 --- a/Lib/test/test_grammar.py +++ b/Lib/test/test_grammar.py @@ -122,9 +122,9 @@ def test_plain_integers(self): 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: @@ -133,9 +133,9 @@ def test_plain_integers(self): 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': @@ -226,7 +226,7 @@ def test_string_literals(self): def test_ellipsis(self): x = ... - self.assertTrue(x is Ellipsis) + self.assertIs(x, Ellipsis) self.assertRaises(SyntaxError, eval, ".. .") def test_eof_error(self): diff --git a/Lib/test/test_gzip.py b/Lib/test/test_gzip.py index b457bd3..18abb6c 100644 --- a/Lib/test/test_gzip.py +++ b/Lib/test/test_gzip.py @@ -223,7 +223,7 @@ def test_readline(self): 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 --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py index 067e13f..6c8ae5d 100644 --- a/Lib/test/test_hmac.py +++ b/Lib/test/test_hmac.py @@ -356,7 +356,7 @@ def test_attributes(self): # Testing if attributes are of same type. h1 = hmac.HMAC(b"key", digestmod="md5") 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.") @@ -367,11 +367,11 @@ def test_realcopy(self): # Testing if the copy method created a real copy. h1 = hmac.HMAC(b"key", digestmod="md5") 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 --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py index 2f12e98..e6b9b5d 100644 --- a/Lib/test/test_inspect.py +++ b/Lib/test/test_inspect.py @@ -241,7 +241,7 @@ def test_abuse_done(self): 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:]), @@ -2853,7 +2853,7 @@ def test() -> 42: 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) @@ -2897,7 +2897,7 @@ def test_signature_parameter_kinds(self): 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, @@ -2986,7 +2986,7 @@ def test_signature_parameter_replace(self): 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 --git a/Lib/test/test_iter.py b/Lib/test/test_iter.py index 542b284..6298e67 100644 --- a/Lib/test/test_iter.py +++ b/Lib/test/test_iter.py @@ -96,7 +96,7 @@ def check_pickle(self, itorg, seq): # 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) @@ -117,7 +117,7 @@ def test_iter_idempotency(self): 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 --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index ea1f57c..97cd871 100644 --- a/Lib/test/test_itertools.py +++ b/Lib/test/test_itertools.py @@ -347,7 +347,7 @@ def numcombs(n, r): 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 @@ -1349,7 +1349,7 @@ def test_tee(self): # 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') @@ -1357,7 +1357,9 @@ def test_tee(self): self.assertRaises(TypeError, tnew) self.assertRaises(TypeError, tnew, 10) t3 = tnew(t1) - self.assertTrue(list(t1) == list(t2) == list(t3) == list('abc')) + self.assertEqual(list(t1), list('abc')) + self.assertEqual(list(t2), list('abc')) + self.assertEqual(list(t3), list('abc')) # test that tee objects are weak referencable a, b = tee(range(10)) diff --git a/Lib/test/test_json/test_decode.py b/Lib/test/test_json/test_decode.py index 7e568be..04c90ba 100644 --- a/Lib/test/test_json/test_decode.py +++ b/Lib/test/test_json/test_decode.py @@ -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 --git a/Lib/test/test_kqueue.py b/Lib/test/test_kqueue.py index 9f49886..2cd4975 100644 --- a/Lib/test/test_kqueue.py +++ b/Lib/test/test_kqueue.py @@ -14,8 +14,8 @@ class TestKQueue(unittest.TestCase): def test_create_queue(self): kq = select.kqueue() - self.assertTrue(kq.fileno() > 0, kq.fileno()) - self.assertTrue(not kq.closed) + self.assertGreater(kq.fileno(), 0) + self.assertFalse(kq.closed) kq.close() self.assertTrue(kq.closed) self.assertRaises(ValueError, kq.fileno) diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py index 9f482e1..a5e39d6 100644 --- a/Lib/test/test_logging.py +++ b/Lib/test/test_logging.py @@ -3094,7 +3094,7 @@ def test_queue_handler(self): 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 --git a/Lib/test/test_memoryview.py b/Lib/test/test_memoryview.py index ddd5b9a..a76de1a 100644 --- a/Lib/test/test_memoryview.py +++ b/Lib/test/test_memoryview.py @@ -239,7 +239,7 @@ class MyObject: 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')) @@ -250,7 +250,7 @@ class MyObject: 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") @@ -351,7 +351,7 @@ def callback(wr, b=b): self.assertIs(wr(), m) del m test.support.gc_collect() - self.assertIs(wr(), None) + self.assertIsNone(wr()) self.assertIs(L[0], b) def test_reversed(self): diff --git a/Lib/test/test_minidom.py b/Lib/test/test_minidom.py index ee8c041..df2ccdc 100644 --- a/Lib/test/test_minidom.py +++ b/Lib/test/test_minidom.py @@ -1561,7 +1561,7 @@ def testDocRemoveChild(self): 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 testProcessingInstructionNameError(self): # wrong variable in .nodeValue property will diff --git a/Lib/test/test_module.py b/Lib/test/test_module.py index 6d0d594..8251269 100644 --- a/Lib/test/test_module.py +++ b/Lib/test/test_module.py @@ -21,7 +21,7 @@ def test_uninitialized(self): # 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__ @@ -90,7 +90,7 @@ def test_reinit(self): self.assertEqual(foo.__dict__, {"__name__": "foo", "__doc__": "foodoc", "bar": 42, "__loader__": None, "__package__": None, "__spec__": None}) - self.assertTrue(foo.__dict__ is d) + self.assertIs(foo.__dict__, d) def test_dont_clear_dict(self): # See issue 7140. diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py index 5f302f6..4633c25 100644 --- a/Lib/test/test_os.py +++ b/Lib/test/test_os.py @@ -2553,7 +2553,7 @@ def test_send_whole_file(self): 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)) @@ -2576,7 +2576,7 @@ def test_send_at_certain_offset(self): break offset += sent total_sent += sent - self.assertTrue(sent <= nbytes) + self.assertLessEqual(sent, nbytes) self.client.shutdown(socket.SHUT_RDWR) self.client.close() diff --git a/Lib/test/test_ossaudiodev.py b/Lib/test/test_ossaudiodev.py index c9e2a24..f360fc7 100644 --- a/Lib/test/test_ossaudiodev.py +++ b/Lib/test/test_ossaudiodev.py @@ -76,7 +76,7 @@ def play_sound_file(self, data, rate, ssize, nchannels): # 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.assertAlmostEqual(expected_time, 3.51, delta=1e-2) t1 = time.time() dsp.write(data) dsp.close() @@ -84,7 +84,7 @@ def play_sound_file(self, data, rate, ssize, nchannels): 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 --git a/Lib/test/test_peepholer.py b/Lib/test/test_peepholer.py index efc0afe..6b4ba92 100644 --- a/Lib/test/test_peepholer.py +++ b/Lib/test/test_peepholer.py @@ -140,9 +140,9 @@ def g(a): 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)) diff --git a/Lib/test/test_platform.py b/Lib/test/test_platform.py index ea6752b..746e956 100644 --- a/Lib/test/test_platform.py +++ b/Lib/test/test_platform.py @@ -221,7 +221,7 @@ def test_mac_ver(self): 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 --git a/Lib/test/test_posix.py b/Lib/test/test_posix.py index 029d081..61a944f 100644 --- a/Lib/test/test_posix.py +++ b/Lib/test/test_posix.py @@ -581,17 +581,17 @@ def test_chdir(self): 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 --git a/Lib/test/test_property.py b/Lib/test/test_property.py index 26b7d52..52e9c9e 100644 --- a/Lib/test/test_property.py +++ b/Lib/test/test_property.py @@ -86,8 +86,8 @@ def test_property_decorator_baseclass(self): 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 --git a/Lib/test/test_pulldom.py b/Lib/test/test_pulldom.py index 3d89e3a..6e2b100 100644 --- a/Lib/test/test_pulldom.py +++ b/Lib/test/test_pulldom.py @@ -69,7 +69,7 @@ def test_parse_semantics(self): 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 --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py index 92fffc4..6e37ae6 100644 --- a/Lib/test/test_pyexpat.py +++ b/Lib/test/test_pyexpat.py @@ -320,7 +320,7 @@ def collector(name, *args): 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 @@ -482,7 +482,7 @@ def check_pos(self, event): 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 --git a/Lib/test/test_richcmp.py b/Lib/test/test_richcmp.py index 58729a9..43eb4f6 100644 --- a/Lib/test/test_richcmp.py +++ b/Lib/test/test_richcmp.py @@ -106,7 +106,7 @@ def checkequal(self, opname, a, b, expres): 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 @@ def checkvalue(self, opname, a, b, expres): 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 @@ def test_recursion(self): 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(RecursionError, operator.lt, a, b) self.assertRaises(RecursionError, operator.le, a, b) @@ -249,7 +249,7 @@ def test_recursion(self): self.assertRaises(RecursionError, 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 --git a/Lib/test/test_sax.py b/Lib/test/test_sax.py index 2411895..5c93000 100644 --- a/Lib/test/test_sax.py +++ b/Lib/test/test_sax.py @@ -991,8 +991,7 @@ def test_expat_nsattrs_wattr(self): self.assertEqual(attrs.getLength(), 1) self.assertEqual(attrs.getNames(), [(ns_uri, "attr")]) - self.assertTrue((attrs.getQNames() == [] or - attrs.getQNames() == ["ns:attr"])) + self.assertIn(attrs.getQNames(), ([], ["ns:attr"])) self.assertEqual(len(attrs), 1) self.assertIn((ns_uri, "attr"), attrs) self.assertEqual(attrs.get((ns_uri, "attr")), "val") diff --git a/Lib/test/test_selectors.py b/Lib/test/test_selectors.py index 852b2fe..a6c6fb0 100644 --- a/Lib/test/test_selectors.py +++ b/Lib/test/test_selectors.py @@ -239,7 +239,7 @@ def test_select(self): result = s.select() for key, events in result: - self.assertTrue(isinstance(key, selectors.SelectorKey)) + self.assertIsInstance(key, selectors.SelectorKey) self.assertTrue(events) self.assertFalse(events & ~(selectors.EVENT_READ | selectors.EVENT_WRITE)) @@ -265,7 +265,7 @@ def test_fileno(self): if hasattr(s, 'fileno'): fd = s.fileno() - self.assertTrue(isinstance(fd, int)) + self.assertIsInstance(fd, int) self.assertGreaterEqual(fd, 0) def test_selector(self): diff --git a/Lib/test/test_shutil.py b/Lib/test/test_shutil.py index 3688eae..0feac95 100644 --- a/Lib/test/test_shutil.py +++ b/Lib/test/test_shutil.py @@ -384,8 +384,8 @@ def test_copystat_symlinks(self): 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 @@ -1754,7 +1754,7 @@ def _open(filename, mode='r'): shutil.copyfile('srcfile', 'destfile') self.assertTrue(srcfile._entered) - self.assertTrue(srcfile._exited_with[0] is OSError) + self.assertIs(srcfile._exited_with[0], OSError) self.assertEqual(srcfile._exited_with[1].args, ('Cannot open "destfile"',)) @@ -1776,7 +1776,7 @@ def _open(filename, mode='r'): self.assertTrue(srcfile._entered) self.assertTrue(destfile._entered) self.assertTrue(destfile._raised) - self.assertTrue(srcfile._exited_with[0] is OSError) + self.assertIs(srcfile._exited_with[0], OSError) self.assertEqual(srcfile._exited_with[1].args, ('Cannot close',)) @@ -1799,7 +1799,7 @@ def _open(filename, mode='r'): 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 --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py index 4ae4142..f934fa8 100644 --- a/Lib/test/test_slice.py +++ b/Lib/test/test_slice.py @@ -137,7 +137,7 @@ class AnyClass: obj = AnyClass() s = slice(obj) - self.assertTrue(s.stop is obj) + self.assertIs(s.stop, obj) def check_indices(self, slice, length): try: diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py index 7cc2e57..d33c313 100644 --- a/Lib/test/test_socket.py +++ b/Lib/test/test_socket.py @@ -791,7 +791,7 @@ def testHostnameRes(self): except OSError: # Probably name lookup wasn't set up right; skip this test self.skipTest('name lookup failure') - self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.") + self.assertIn('.', ip, "Error resolving host to ip.") try: hname, aliases, ipaddrs = socket.gethostbyaddr(ip) except OSError: @@ -1190,7 +1190,7 @@ def testGetSockOpt(self): 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() @@ -1198,7 +1198,7 @@ def testSetSockOpt(self): 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 @@ -3908,7 +3908,7 @@ def testSetBlocking(self): except OSError: 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 @@ -3943,7 +3943,7 @@ def testInitNonBlocking(self): except OSError: 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 @@ -4439,7 +4439,7 @@ def _testSourceAddress(self): 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)) @@ -4451,7 +4451,7 @@ def _testTimeoutDefault(self): 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 --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py index 69a65d2..bd1d05f 100644 --- a/Lib/test/test_ssl.py +++ b/Lib/test/test_ssl.py @@ -3195,7 +3195,7 @@ def test_compression_disabled(self): 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 @@ -3277,7 +3277,7 @@ def test_selected_npn_protocol(self): 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 --git a/Lib/test/test_strptime.py b/Lib/test/test_strptime.py index 2cf0926..cb320a9 100644 --- a/Lib/test/test_strptime.py +++ b/Lib/test/test_strptime.py @@ -116,13 +116,13 @@ def setUp(self): 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) @@ -270,7 +270,7 @@ def test_year(self): 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])) @@ -288,7 +288,7 @@ def test_hour(self): 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])) @@ -330,11 +330,11 @@ def test_timezone(self): 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") @@ -393,7 +393,7 @@ def test_defaults(self): # 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)) @@ -445,7 +445,7 @@ def test_julian_calculation(self): 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)) @@ -468,7 +468,7 @@ def test_day_of_week_calculation(self): 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)) diff --git a/Lib/test/test_symtable.py b/Lib/test/test_symtable.py index dfaee17..503a811 100644 --- a/Lib/test/test_symtable.py +++ b/Lib/test/test_symtable.py @@ -121,7 +121,7 @@ def test_namespaces(self): 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 --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py index 9aeb28a..aeea96a 100644 --- a/Lib/test/test_sys.py +++ b/Lib/test/test_sys.py @@ -47,7 +47,7 @@ def test_original_displayhook(self): 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) @@ -181,7 +181,7 @@ def test_switchinterval(self): 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) @@ -403,7 +403,7 @@ def g456(): # 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 @@ -434,7 +434,7 @@ def current_frames_without_threads(self): 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) @@ -448,8 +448,8 @@ def test_attributes(self): 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) @@ -511,7 +511,7 @@ def test_attributes(self): 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'): @@ -535,9 +535,9 @@ def test_intern(self): 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 --git a/Lib/test/test_sysconfig.py b/Lib/test/test_sysconfig.py index 694435f..bdd347e 100644 --- a/Lib/test/test_sysconfig.py +++ b/Lib/test/test_sysconfig.py @@ -286,7 +286,7 @@ def test_main(self): # 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 --git a/Lib/test/test_telnetlib.py b/Lib/test/test_telnetlib.py index 51d82e1..7eb0f02 100644 --- a/Lib/test/test_telnetlib.py +++ b/Lib/test/test_telnetlib.py @@ -47,7 +47,7 @@ def testContextManager(self): self.assertIsNone(tn.get_socket()) def testTimeoutDefault(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: telnet = telnetlib.Telnet(HOST, self.port) @@ -58,13 +58,13 @@ def testTimeoutDefault(self): 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): @@ -214,7 +214,7 @@ def test_read_some(self): # 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() @@ -316,7 +316,7 @@ def _test_command(self, data): 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 --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py index 51df1ec..1266d97 100644 --- a/Lib/test/test_tempfile.py +++ b/Lib/test/test_tempfile.py @@ -137,7 +137,7 @@ def test_exports(self): 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) @@ -214,7 +214,7 @@ def test_nonempty_list(self): cand = tempfile._candidate_tempdir_list() - self.assertFalse(len(cand) == 0) + self.assertNotEqual(len(cand), 0) for c in cand: self.assertIsInstance(c, str) @@ -299,7 +299,7 @@ def test_same_thing(self): a = tempfile._get_candidate_names() b = tempfile._get_candidate_names() - self.assertTrue(a is b) + self.assertIs(a, b) @contextlib.contextmanager @@ -563,8 +563,9 @@ def test_directory_exists(self): # gettempdir returns a directory which exists for d in (tempfile.gettempdir(), tempfile.gettempdirb()): - self.assertTrue(os.path.isabs(d) or d == os.curdir, - "%r is not an absolute path" % d) + if dir != os.curdir: + self.assertTrue(os.path.isabs(d), + "%r is not an absolute path" % d) self.assertTrue(os.path.isdir(d), "%r is not a directory" % d) @@ -584,7 +585,7 @@ def test_same_thing(self): b = tempfile.gettempdir() c = tempfile.gettempdirb() - self.assertTrue(a is b) + self.assertIs(a, b) self.assertNotEqual(type(a), type(c)) self.assertEqual(a, os.fsdecode(c)) @@ -1044,7 +1045,7 @@ def test_fileno(self): # 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 --git a/Lib/test/test_time.py b/Lib/test/test_time.py index f224212..8677ba5 100644 --- a/Lib/test/test_time.py +++ b/Lib/test/test_time.py @@ -330,8 +330,8 @@ def test_tzset(self): # on some operating systems (e.g. FreeBSD), which is wrong. See for # 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[0], ('AEST' 'EST')) + self.assertIn(time.tzname[1], ('AEDT', 'EDT')) self.assertEqual(len(time.tzname), 2) self.assertEqual(time.daylight, 1) self.assertEqual(time.timezone, -36000) @@ -630,11 +630,11 @@ def test_localtime_timezone(self): # 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]) @@ -669,8 +669,8 @@ def test_short_times(self): # 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) @unittest.skipIf(_testcapi is None, 'need the _testcapi module') diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py index 7276bc7..1aa2be2 100644 --- a/Lib/test/test_traceback.py +++ b/Lib/test/test_traceback.py @@ -50,7 +50,7 @@ def test_caret(self): 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 @@ -153,7 +153,7 @@ def do_test(firstlines, message, charset, lineno): 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 --git a/Lib/test/test_types.py b/Lib/test/test_types.py index 4a9fcba..9adf01e 100644 --- a/Lib/test/test_types.py +++ b/Lib/test/test_types.py @@ -647,8 +647,8 @@ def __missing__(self, key): 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): @@ -684,9 +684,9 @@ def get(self, key, default=None): 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',)) @@ -703,9 +703,9 @@ def test_chainmap(self): 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') @@ -724,10 +724,10 @@ def test_chainmap(self): 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 --git a/Lib/test/test_unicode_file.py b/Lib/test/test_unicode_file.py index e4709a1..471bd85 100644 --- a/Lib/test/test_unicode_file.py +++ b/Lib/test/test_unicode_file.py @@ -106,7 +106,7 @@ def _test_single(self, filename): 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 --git a/Lib/test/test_utf8source.py b/Lib/test/test_utf8source.py index 97dced8..f256a81 100644 --- a/Lib/test/test_utf8source.py +++ b/Lib/test/test_utf8source.py @@ -19,7 +19,7 @@ def test_badsyntax(self): 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 --git a/Lib/test/test_weakset.py b/Lib/test/test_weakset.py index 691b95e..a29adbf 100644 --- a/Lib/test/test_weakset.py +++ b/Lib/test/test_weakset.py @@ -97,7 +97,7 @@ def test_intersection(self): 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) @@ -214,9 +214,9 @@ def test_add(self): 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 --git a/Lib/test/test_winreg.py b/Lib/test/test_winreg.py index 2be61ae..434bd21 100644 --- a/Lib/test/test_winreg.py +++ b/Lib/test/test_winreg.py @@ -76,7 +76,7 @@ def _write_test_data(self, root_key, subkeystr="sub_key", # 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 @@ -191,11 +191,11 @@ def _test_all(self, root_key, subkeystr="sub_key"): 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 --git a/Lib/test/test_with.py b/Lib/test/test_with.py index c70f685..23a90b3 100644 --- a/Lib/test/test_with.py +++ b/Lib/test/test_with.py @@ -226,7 +226,7 @@ def assertAfterWithManagerInvariantsWithError(self, mock_manager, 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 --git a/Lib/test/test_xdrlib.py b/Lib/test/test_xdrlib.py index 3df5f26..de3f2c6 100644 --- a/Lib/test/test_xdrlib.py +++ b/Lib/test/test_xdrlib.py @@ -31,15 +31,15 @@ def test_xdr(self): 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 --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py index 74a46ba..78c98ae 100644 --- a/Lib/test/test_xmlrpc.py +++ b/Lib/test/test_xmlrpc.py @@ -1252,8 +1252,8 @@ def test_fail_no_info(self): # 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') @@ -1274,7 +1274,7 @@ def test_fail_with_info(self): # 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 --git a/Lib/test/test_yield_from.py b/Lib/test/test_yield_from.py index d1da838a..ad96c6d 100644 --- a/Lib/test/test_yield_from.py +++ b/Lib/test/test_yield_from.py @@ -967,10 +967,11 @@ def eggs(g): 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 --git a/Lib/test/test_zlib.py b/Lib/test/test_zlib.py index 20174d8..cd23e23 100644 --- a/Lib/test/test_zlib.py +++ b/Lib/test/test_zlib.py @@ -359,8 +359,7 @@ def test_decompimax(self, source=None, cx=256, dcx=64): while cb: #max_length = 1 + len(cb)//10 chunk = dco.decompress(cb, dcx) - self.assertFalse(len(chunk) > dcx, - 'chunk too big (%d>%d)' % (len(chunk), dcx)) + self.assertLessEqual(len(chunk), dcx) bufs.append(chunk) cb = dco.unconsumed_tail bufs.append(dco.flush()) @@ -384,8 +383,7 @@ def test_decompressmaxlen(self, flush=False): while cb: max_length = 1 + len(cb)//10 chunk = dco.decompress(cb, max_length) - self.assertFalse(len(chunk) > max_length, - 'chunk too big (%d>%d)' % (len(chunk),max_length)) + self.assertLessEqual(len(chunk), max_length) bufs.append(chunk) cb = dco.unconsumed_tail if flush: @@ -393,8 +391,7 @@ def test_decompressmaxlen(self, flush=False): else: while chunk: chunk = dco.decompress(b'', max_length) - self.assertFalse(len(chunk) > max_length, - 'chunk too big (%d>%d)' % (len(chunk),max_length)) + self.assertLessEqual(len(chunk), max_length) bufs.append(chunk) self.assertEqual(data, b''.join(bufs), 'Wrong data retrieved')