diff -r 3b94a4ef244e Lib/test/_test_multiprocessing.py --- a/Lib/test/_test_multiprocessing.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/_test_multiprocessing.py Fri Feb 07 23:40:05 2014 +0200 @@ -202,9 +202,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) @@ -247,7 +247,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() @@ -330,8 +330,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) @@ -1624,7 +1624,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')) # # @@ -2881,7 +2881,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) @@ -3618,8 +3618,8 @@ 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'])) # # Check that killing process does not leak named semaphores diff -r 3b94a4ef244e Lib/test/pickletester.py --- a/Lib/test/pickletester.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/pickletester.py Fri Feb 07 23:40:05 2014 +0200 @@ -645,7 +645,7 @@ x = self.loads(s) self.assertIsInstance(x, list) self.assertEqual(len(x), 1) - self.assertTrue(x is x[0]) + self.assertIs(x, x[0]) def test_recursive_tuple(self): t = ([],) @@ -656,7 +656,7 @@ self.assertIsInstance(x, tuple) 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 = {} @@ -666,7 +666,7 @@ x = self.loads(s) self.assertIsInstance(x, dict) self.assertEqual(list(x.keys()), [1]) - self.assertTrue(x[1] is x) + self.assertIs(x[1], x) def test_recursive_set(self): h = H() @@ -713,7 +713,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') @@ -982,9 +982,9 @@ 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)) + self.assertEqual(opcode_in_pickle(expected, s), True) def test_newobj_tuple(self): x = MyTuple([1, 2, 3]) @@ -1102,7 +1102,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 @@ -1125,7 +1125,7 @@ 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 @@ -2068,7 +2068,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 3b94a4ef244e Lib/test/test_abc.py --- a/Lib/test/test_abc.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_abc.py Fri Feb 07 23:40:05 2014 +0200 @@ -299,14 +299,14 @@ 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 -r 3b94a4ef244e Lib/test/test_ast.py --- a/Lib/test/test_ast.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_ast.py Fri Feb 07 23:40:05 2014 +0200 @@ -197,9 +197,9 @@ if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)): node_pos = (ast_node.lineno, ast_node.col_offset) if reverse_check: - self.assertTrue(node_pos <= parent_pos) + self.assertLessEqual(node_pos, parent_pos) else: - 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 3b94a4ef244e Lib/test/test_asyncore.py --- a/Lib/test/test_asyncore.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_asyncore.py Fri Feb 07 23:40:05 2014 +0200 @@ -339,7 +339,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 3b94a4ef244e Lib/test/test_augassign.py --- a/Lib/test/test_augassign.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_augassign.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_binop.py --- a/Lib/test/test_binop.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_binop.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_bisect.py --- a/Lib/test/test_bisect.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_bisect.py Fri Feb 07 23:40:05 2014 +0200 @@ -159,14 +159,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: @@ -177,13 +177,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 3b94a4ef244e Lib/test/test_buffer.py --- a/Lib/test/test_buffer.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_buffer.py Fri Feb 07 23:40:05 2014 +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] @@ -2500,8 +2500,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]) @@ -4256,7 +4256,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, @@ -4270,7 +4270,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 3b94a4ef244e Lib/test/test_builtin.py --- a/Lib/test/test_builtin.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_builtin.py Fri Feb 07 23:40:05 2014 +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) @@ -238,7 +238,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): @@ -298,7 +298,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') @@ -402,7 +402,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): @@ -410,7 +410,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): @@ -640,7 +640,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) @@ -721,11 +721,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) @@ -741,7 +741,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 3b94a4ef244e Lib/test/test_bz2.py --- a/Lib/test/test_bz2.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_bz2.py Fri Feb 07 23:40:05 2014 +0200 @@ -695,7 +695,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 3b94a4ef244e Lib/test/test_capi.py --- a/Lib/test/test_capi.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_capi.py Fri Feb 07 23:40:05 2014 +0200 @@ -35,7 +35,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__) @@ -174,7 +174,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 3b94a4ef244e Lib/test/test_cmd_line.py --- a/Lib/test/test_cmd_line.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_cmd_line.py Fri Feb 07 23:40:05 2014 +0200 @@ -120,8 +120,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 3b94a4ef244e Lib/test/test_codeop.py --- a/Lib/test/test_codeop.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_codeop.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_compile.py --- a/Lib/test/test_compile.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_compile.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_compileall.py --- a/Lib/test/test_compileall.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_compileall.py Fri Feb 07 23:40:05 2014 +0200 @@ -70,12 +70,12 @@ except: pass 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) 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) diff -r 3b94a4ef244e Lib/test/test_complex.py --- a/Lib/test/test_complex.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_complex.py Fri Feb 07 23:40:05 2014 +0200 @@ -203,7 +203,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) @@ -288,7 +288,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 3b94a4ef244e Lib/test/test_concurrent_futures.py --- a/Lib/test/test_concurrent_futures.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_concurrent_futures.py Fri Feb 07 23:40:05 2014 +0200 @@ -655,8 +655,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): @@ -672,7 +671,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 3b94a4ef244e Lib/test/test_configparser.py --- a/Lib/test/test_configparser.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_configparser.py Fri Feb 07 23:40:05 2014 +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"}) @@ -1536,7 +1536,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() @@ -1565,7 +1565,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') @@ -1574,7 +1574,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 3b94a4ef244e Lib/test/test_copyreg.py --- a/Lib/test/test_copyreg.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_copyreg.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_crypt.py --- a/Lib/test/test_crypt.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_crypt.py Fri Feb 07 23:40:05 2014 +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]) if __name__ == "__main__": diff -r 3b94a4ef244e Lib/test/test_dbm.py --- a/Lib/test/test_dbm.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_dbm.py Fri Feb 07 23:40:05 2014 +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, self.dbm.whichdb(_fname)) diff -r 3b94a4ef244e Lib/test/test_dbm_gnu.py --- a/Lib/test/test_dbm_gnu.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_dbm_gnu.py Fri Feb 07 23:40:05 2014 +0200 @@ -71,7 +71,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 3b94a4ef244e Lib/test/test_epoll.py --- a/Lib/test/test_epoll.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_epoll.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_faulthandler.py --- a/Lib/test/test_faulthandler.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_faulthandler.py Fri Feb 07 23:40:05 2014 +0200 @@ -219,7 +219,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 3b94a4ef244e Lib/test/test_filecmp.py --- a/Lib/test/test_filecmp.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_filecmp.py Fri Feb 07 23:40:05 2014 +0200 @@ -82,10 +82,10 @@ 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") @@ -120,7 +120,8 @@ else: self.assertEqual([d.left_list, d.right_list],[['file'], ['file']]) self.assertEqual(d.common, ['file']) - self.assertTrue(d.left_only == d.right_only == []) + self.assertEqual(d.left_only, []) + self.assertEqual(d.left_only, []) self.assertEqual(d.same_files, ['file']) self.assertEqual(d.diff_files, []) diff -r 3b94a4ef244e Lib/test/test_fnmatch.py --- a/Lib/test/test_fnmatch.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_fnmatch.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_funcattrs.py --- a/Lib/test/test_funcattrs.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_funcattrs.py Fri Feb 07 23:40:05 2014 +0200 @@ -343,10 +343,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 3b94a4ef244e Lib/test/test_functools.py --- a/Lib/test/test_functools.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_functools.py Fri Feb 07 23:40:05 2014 +0200 @@ -91,7 +91,8 @@ 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 @@ -99,15 +100,18 @@ 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): @@ -898,7 +902,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 3b94a4ef244e Lib/test/test_gc.py --- a/Lib/test/test_gc.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_gc.py Fri Feb 07 23:40:05 2014 +0200 @@ -764,9 +764,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 3b94a4ef244e Lib/test/test_gdb.py --- a/Lib/test/test_gdb.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_gdb.py Fri Feb 07 23:40:05 2014 +0200 @@ -227,7 +227,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): # Ensure that gdb's rendering of the value in a debugged process diff -r 3b94a4ef244e Lib/test/test_grammar.py --- a/Lib/test/test_grammar.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_grammar.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_gzip.py --- a/Lib/test/test_gzip.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_gzip.py Fri Feb 07 23:40:05 2014 +0200 @@ -158,7 +158,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 3b94a4ef244e Lib/test/test_hmac.py --- a/Lib/test/test_hmac.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_hmac.py Fri Feb 07 23:40:05 2014 +0200 @@ -357,7 +357,7 @@ # 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.") @@ -368,11 +368,11 @@ # 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 -r 3b94a4ef244e Lib/test/test_inspect.py --- a/Lib/test/test_inspect.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_inspect.py Fri Feb 07 23:40:05 2014 +0200 @@ -169,7 +169,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:]), @@ -2381,7 +2381,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) @@ -2396,7 +2396,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, @@ -2472,7 +2472,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 3b94a4ef244e Lib/test/test_iter.py --- a/Lib/test/test_iter.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_iter.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_itertools.py --- a/Lib/test/test_itertools.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_itertools.py Fri Feb 07 23:40:05 2014 +0200 @@ -326,7 +326,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 @@ -1191,7 +1191,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') @@ -1199,7 +1199,9 @@ 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 -r 3b94a4ef244e Lib/test/test_json/test_decode.py --- a/Lib/test/test_json/test_decode.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_json/test_decode.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_kqueue.py --- a/Lib/test/test_kqueue.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_kqueue.py Fri Feb 07 23:40:05 2014 +0200 @@ -16,8 +16,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 -r 3b94a4ef244e Lib/test/test_logging.py --- a/Lib/test/test_logging.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_logging.py Fri Feb 07 23:40:05 2014 +0200 @@ -3013,7 +3013,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 3b94a4ef244e Lib/test/test_memoryview.py --- a/Lib/test/test_memoryview.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_memoryview.py Fri Feb 07 23:40:05 2014 +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) def test_reversed(self): diff -r 3b94a4ef244e Lib/test/test_minidom.py --- a/Lib/test/test_minidom.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_minidom.py Fri Feb 07 23:40:05 2014 +0200 @@ -1525,7 +1525,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 3b94a4ef244e Lib/test/test_module.py --- a/Lib/test/test_module.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_module.py Fri Feb 07 23:40:05 2014 +0200 @@ -21,7 +21,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__ @@ -74,7 +74,7 @@ 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 -r 3b94a4ef244e Lib/test/test_os.py --- a/Lib/test/test_os.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_os.py Fri Feb 07 23:40:05 2014 +0200 @@ -1994,7 +1994,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)) @@ -2017,7 +2017,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 3b94a4ef244e Lib/test/test_ossaudiodev.py --- a/Lib/test/test_ossaudiodev.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_ossaudiodev.py Fri Feb 07 23:40:05 2014 +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.assertAlmostEqual(expected_time, 3.51, delta=1e-2) 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 3b94a4ef244e Lib/test/test_peepholer.py --- a/Lib/test/test_peepholer.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_peepholer.py Fri Feb 07 23:40:05 2014 +0200 @@ -141,9 +141,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)) diff -r 3b94a4ef244e Lib/test/test_pep247.py --- a/Lib/test/test_pep247.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_pep247.py Fri Feb 07 23:40:05 2014 +0200 @@ -12,7 +12,8 @@ def check_module(self, module, key=None): self.assertTrue(hasattr(module, 'digest_size')) - self.assertTrue(module.digest_size is None or module.digest_size > 0) + if module.digest_size is not None: + self.assertGreater(module.digest_size, 0) self.check_object(module.new, module.digest_size, key) def check_object(self, cls, digest_size, key, digestmod=None): diff -r 3b94a4ef244e Lib/test/test_pep3120.py --- a/Lib/test/test_pep3120.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_pep3120.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_pep380.py --- a/Lib/test/test_pep380.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_pep380.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_platform.py --- a/Lib/test/test_platform.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_platform.py Fri Feb 07 23:40:05 2014 +0200 @@ -197,7 +197,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 3b94a4ef244e Lib/test/test_posix.py --- a/Lib/test/test_posix.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_posix.py Fri Feb 07 23:40:05 2014 +0200 @@ -540,17 +540,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 3b94a4ef244e Lib/test/test_property.py --- a/Lib/test/test_property.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_property.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_pulldom.py --- a/Lib/test/test_pulldom.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_pulldom.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_pyexpat.py --- a/Lib/test/test_pyexpat.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_pyexpat.py Fri Feb 07 23:40:05 2014 +0200 @@ -285,7 +285,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 @@ -432,7 +432,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 3b94a4ef244e Lib/test/test_re.py --- a/Lib/test/test_re.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_re.py Fri Feb 07 23:40:05 2014 +0200 @@ -897,7 +897,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 3b94a4ef244e Lib/test/test_richcmp.py --- a/Lib/test/test_richcmp.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_richcmp.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_sax.py --- a/Lib/test/test_sax.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_sax.py Fri Feb 07 23:40:05 2014 +0200 @@ -754,8 +754,7 @@ 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 -r 3b94a4ef244e Lib/test/test_selectors.py --- a/Lib/test/test_selectors.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_selectors.py Fri Feb 07 23:40:05 2014 +0200 @@ -237,7 +237,7 @@ 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)) @@ -263,7 +263,7 @@ 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 -r 3b94a4ef244e Lib/test/test_shutil.py --- a/Lib/test/test_shutil.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_shutil.py Fri Feb 07 23:40:05 2014 +0200 @@ -385,8 +385,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 @@ -1639,7 +1639,7 @@ 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"',)) @@ -1661,7 +1661,7 @@ 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',)) @@ -1684,7 +1684,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 3b94a4ef244e Lib/test/test_slice.py --- a/Lib/test/test_slice.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_slice.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_socket.py --- a/Lib/test/test_socket.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_socket.py Fri Feb 07 23:40:05 2014 +0200 @@ -743,7 +743,7 @@ 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: @@ -1113,7 +1113,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() @@ -1121,7 +1121,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 @@ -3745,7 +3745,7 @@ 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 @@ -3780,7 +3780,7 @@ 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 @@ -4386,7 +4386,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)) @@ -4398,7 +4398,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 3b94a4ef244e Lib/test/test_ssl.py --- a/Lib/test/test_ssl.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_ssl.py Fri Feb 07 23:40:05 2014 +0200 @@ -2639,7 +2639,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 @@ -2660,7 +2660,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 3b94a4ef244e Lib/test/test_strptime.py --- a/Lib/test/test_strptime.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_strptime.py Fri Feb 07 23:40:05 2014 +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) @@ -250,7 +250,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])) @@ -268,7 +268,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])) @@ -310,11 +310,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") @@ -375,7 +375,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)) @@ -427,7 +427,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)) @@ -450,7 +450,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)) @@ -463,7 +463,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 3b94a4ef244e Lib/test/test_symtable.py --- a/Lib/test/test_symtable.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_symtable.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_sys.py --- a/Lib/test/test_sys.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_sys.py Fri Feb 07 23:40:05 2014 +0200 @@ -45,7 +45,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) @@ -201,7 +201,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) @@ -381,7 +381,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 @@ -412,7 +412,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) @@ -426,8 +426,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) @@ -489,7 +489,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'): @@ -513,9 +513,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 3b94a4ef244e Lib/test/test_sysconfig.py --- a/Lib/test/test_sysconfig.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_sysconfig.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_telnetlib.py --- a/Lib/test/test_telnetlib.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_telnetlib.py Fri Feb 07 23:40:05 2014 +0200 @@ -43,7 +43,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) @@ -54,13 +54,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): @@ -210,7 +210,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() @@ -312,7 +312,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 3b94a4ef244e Lib/test/test_tempfile.py --- a/Lib/test/test_tempfile.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_tempfile.py Fri Feb 07 23:40:05 2014 +0200 @@ -92,7 +92,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) @@ -169,7 +169,7 @@ cand = tempfile._candidate_tempdir_list() - self.assertFalse(len(cand) == 0) + self.assertNotEqual(len(cand), 0) for c in cand: self.assertIsInstance(c, str) @@ -254,7 +254,7 @@ a = tempfile._get_candidate_names() b = tempfile._get_candidate_names() - self.assertTrue(a is b) + self.assertIs(a, b) @contextlib.contextmanager @@ -428,7 +428,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 @@ -454,8 +454,9 @@ # gettempdir returns a directory which exists dir = tempfile.gettempdir() - self.assertTrue(os.path.isabs(dir) or dir == os.curdir, - "%s is not an absolute path" % dir) + if dir != os.curdir: + self.assertTrue(os.path.isabs(dir), + "%s is not an absolute path" % dir) self.assertTrue(os.path.isdir(dir), "%s is not a directory" % dir) @@ -474,7 +475,7 @@ a = tempfile.gettempdir() b = tempfile.gettempdir() - self.assertTrue(a is b) + self.assertIs(a, b) def test_case_sensitive(self): # gettempdir should not flatten its case @@ -846,7 +847,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 3b94a4ef244e Lib/test/test_time.py --- a/Lib/test/test_time.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_time.py Fri Feb 07 23:40:05 2014 +0200 @@ -294,8 +294,8 @@ # 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) @@ -649,11 +649,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]) @@ -688,8 +688,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) if __name__ == "__main__": diff -r 3b94a4ef244e Lib/test/test_trace.py --- a/Lib/test/test_trace.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_trace.py Fri Feb 07 23:40:05 2014 +0200 @@ -307,11 +307,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 3b94a4ef244e Lib/test/test_traceback.py --- a/Lib/test/test_traceback.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_traceback.py Fri Feb 07 23:40:05 2014 +0200 @@ -41,7 +41,7 @@ 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 @@ -148,7 +148,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 3b94a4ef244e Lib/test/test_types.py --- a/Lib/test/test_types.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_types.py Fri Feb 07 23:40:05 2014 +0200 @@ -624,8 +624,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): @@ -661,9 +661,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',)) @@ -680,9 +680,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') @@ -701,10 +701,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 3b94a4ef244e Lib/test/test_unicode_file.py --- a/Lib/test/test_unicode_file.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_unicode_file.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_uuid.py --- a/Lib/test/test_uuid.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_uuid.py Fri Feb 07 23:40:05 2014 +0200 @@ -296,8 +296,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: @@ -334,7 +334,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) @unittest.skipUnless(os.name == 'posix', 'requires Posix') @unittest.skipUnless(importable('ctypes'), 'requires ctypes') diff -r 3b94a4ef244e Lib/test/test_weakset.py --- a/Lib/test/test_weakset.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_weakset.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_winreg.py --- a/Lib/test/test_winreg.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_winreg.py Fri Feb 07 23:40:05 2014 +0200 @@ -75,7 +75,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 @@ -190,11 +190,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 3b94a4ef244e Lib/test/test_with.py --- a/Lib/test/test_with.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_with.py Fri Feb 07 23:40:05 2014 +0200 @@ -223,7 +223,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 3b94a4ef244e Lib/test/test_xdrlib.py --- a/Lib/test/test_xdrlib.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_xdrlib.py Fri Feb 07 23:40:05 2014 +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 3b94a4ef244e Lib/test/test_xmlrpc.py --- a/Lib/test/test_xmlrpc.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_xmlrpc.py Fri Feb 07 23:40:05 2014 +0200 @@ -958,8 +958,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') @@ -980,7 +980,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 3b94a4ef244e Lib/test/test_zlib.py --- a/Lib/test/test_zlib.py Fri Feb 07 17:53:13 2014 +0100 +++ b/Lib/test/test_zlib.py Fri Feb 07 23:40:05 2014 +0200 @@ -311,8 +311,7 @@ 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()) @@ -336,8 +335,7 @@ 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: @@ -345,8 +343,7 @@ 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')