diff -r ff471d8526a8 Lib/test/_test_multiprocessing.py --- a/Lib/test/_test_multiprocessing.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/_test_multiprocessing.py Sat Nov 16 17:58:58 2013 +0200 @@ -204,9 +204,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) @@ -249,7 +249,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() @@ -332,8 +332,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) @@ -1629,7 +1629,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')) # # @@ -2886,7 +2886,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) @@ -3623,8 +3623,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 ff471d8526a8 Lib/test/mapping_tests.py --- a/Lib/test/mapping_tests.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/mapping_tests.py Sat Nov 16 17:58:58 2013 +0200 @@ -72,7 +72,8 @@ self.assertTrue(hasattr(iter, '__next__')) self.assertTrue(hasattr(iter, '__iter__')) x = list(iter) - self.assertTrue(set(x)==set(lst)==set(ref)) + self.assertEqual(set(x), set(lst)) + self.assertEqual(set(ref), set(lst)) check_iterandlist(iter(d.keys()), list(d.keys()), self.reference.keys()) check_iterandlist(iter(d), list(d.keys()), self.reference.keys()) @@ -133,10 +134,10 @@ self.assertEqual(self._empty_mapping(), self._empty_mapping()) def test_bool(self): - self.assertTrue(not self._empty_mapping()) + self.assertFalse(self._empty_mapping()) self.assertTrue(self.reference) - self.assertTrue(bool(self._empty_mapping()) is False) - self.assertTrue(bool(self.reference) is True) + self.assertIs(bool(self._empty_mapping()), False) + self.assertIs(bool(self.reference), True) def test_keys(self): d = self._empty_mapping() @@ -268,10 +269,10 @@ def test_get(self): d = self._empty_mapping() - self.assertTrue(d.get(list(self.other.keys())[0]) is None) + self.assertIsNone(d.get(list(self.other.keys())[0])) self.assertEqual(d.get(list(self.other.keys())[0], 3), 3) d = self.reference - self.assertTrue(d.get(list(self.other.keys())[0]) is None) + self.assertIsNone(d.get(list(self.other.keys())[0])) self.assertEqual(d.get(list(self.other.keys())[0], 3), 3) self.assertEqual(d.get(list(self.inmapping.keys())[0]), list(self.inmapping.values())[0]) @@ -304,15 +305,15 @@ class TestMappingProtocol(BasicTestMappingProtocol): def test_constructor(self): BasicTestMappingProtocol.test_constructor(self) - self.assertTrue(self._empty_mapping() is not self._empty_mapping()) + self.assertIsNot(self._empty_mapping(), self._empty_mapping()) self.assertEqual(self.type2test(x=1, y=2), {"x": 1, "y": 2}) def test_bool(self): BasicTestMappingProtocol.test_bool(self) - self.assertTrue(not self._empty_mapping()) + self.assertFalse(self._empty_mapping()) self.assertTrue(self._full_mapping({"x": "y"})) - self.assertTrue(bool(self._empty_mapping()) is False) - self.assertTrue(bool(self._full_mapping({"x": "y"})) is True) + self.assertIs(bool(self._empty_mapping()), False) + self.assertIs(bool(self._full_mapping({"x": "y"})), True) def test_keys(self): BasicTestMappingProtocol.test_keys(self) @@ -338,7 +339,7 @@ def test_contains(self): d = self._empty_mapping() self.assertNotIn('a', d) - self.assertTrue(not ('a' in d)) + self.assertFalse('a' in d) self.assertTrue('a' not in d) d = self._full_mapping({'a': 1, 'b': 2}) self.assertIn('a', d) @@ -422,7 +423,7 @@ def test_fromkeys(self): self.assertEqual(self.type2test.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) d = self._empty_mapping() - self.assertTrue(not(d.fromkeys('abc') is d)) + self.assertIsNot(d.fromkeys('abc'), d) self.assertEqual(d.fromkeys('abc'), {'a':None, 'b':None, 'c':None}) self.assertEqual(d.fromkeys((4,5),0), {4:0, 5:0}) self.assertEqual(d.fromkeys([]), {}) @@ -433,9 +434,9 @@ class dictlike(self.type2test): pass self.assertEqual(dictlike.fromkeys('a'), {'a':None}) self.assertEqual(dictlike().fromkeys('a'), {'a':None}) - self.assertTrue(dictlike.fromkeys('a').__class__ is dictlike) - self.assertTrue(dictlike().fromkeys('a').__class__ is dictlike) - self.assertTrue(type(dictlike.fromkeys('a')) is dictlike) + self.assertIs(dictlike.fromkeys('a').__class__, dictlike) + self.assertIs(dictlike().fromkeys('a').__class__, dictlike) + self.assertIs(type(dictlike.fromkeys('a')), dictlike) class mydict(self.type2test): def __new__(cls): return collections.UserDict() @@ -477,10 +478,10 @@ def test_get(self): BasicTestMappingProtocol.test_get(self) d = self._empty_mapping() - self.assertTrue(d.get('c') is None) + self.assertIsNone(d.get('c')) self.assertEqual(d.get('c', 3), 3) d = self._full_mapping({'a' : 1, 'b' : 2}) - self.assertTrue(d.get('c') is None) + self.assertIsNone(d.get('c')) self.assertEqual(d.get('c', 3), 3) self.assertEqual(d.get('a'), 1) self.assertEqual(d.get('a', 3), 1) @@ -488,9 +489,9 @@ def test_setdefault(self): BasicTestMappingProtocol.test_setdefault(self) d = self._empty_mapping() - self.assertTrue(d.setdefault('key0') is None) + self.assertIsNone(d.setdefault('key0')) d.setdefault('key0', []) - self.assertTrue(d.setdefault('key0') is None) + self.assertIsNone(d.setdefault('key0')) d.setdefault('key', []).append(3) self.assertEqual(d['key'][0], 3) d.setdefault('key', []).append(4) @@ -516,9 +517,10 @@ self.assertEqual(va, int(ka)) kb, vb = tb = b.popitem() self.assertEqual(vb, int(kb)) - self.assertTrue(not(copymode < 0 and ta != tb)) - self.assertTrue(not a) - self.assertTrue(not b) + if copymode < 0: + self.assertEqual(ta, tb) + self.assertFalse(a) + self.assertFalse(b) def test_pop(self): BasicTestMappingProtocol.test_pop(self) diff -r ff471d8526a8 Lib/test/multibytecodec_support.py --- a/Lib/test/multibytecodec_support.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/multibytecodec_support.py Sat Nov 16 17:58:58 2013 +0200 @@ -57,13 +57,13 @@ if expected: result = func(source, scheme)[0] if func is self.decode: - self.assertTrue(type(result) is str, type(result)) + self.assertIs(type(result), str, type(result)) self.assertEqual(result, expected, '%a.decode(%r, %r)=%a != %a' % (source, self.encoding, scheme, result, expected)) else: - self.assertTrue(type(result) is bytes, type(result)) + self.assertIs(type(result), bytes, type(result)) self.assertEqual(result, expected, '%a.encode(%r, %r)=%a != %a' % (source, self.encoding, scheme, result, @@ -355,14 +355,14 @@ if expected: if isinstance(source, bytes): result = func(self.encoding, scheme) - self.assertTrue(type(result) is str, type(result)) + self.assertIs(type(result), str, type(result)) self.assertEqual(result, expected, '%a.decode(%r, %r)=%a != %a' % (source, self.encoding, scheme, result, expected)) else: result = func(self.encoding, scheme) - self.assertTrue(type(result) is bytes, type(result)) + self.assertIs(type(result), bytes, type(result)) self.assertEqual(result, expected, '%a.encode(%r, %r)=%a != %a' % (source, self.encoding, scheme, result, diff -r ff471d8526a8 Lib/test/pickletester.py --- a/Lib/test/pickletester.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/pickletester.py Sat Nov 16 17:58:58 2013 +0200 @@ -553,7 +553,7 @@ s = self.dumps(l, proto) x = self.loads(s) self.assertEqual(len(x), 1) - self.assertTrue(x is x[0]) + self.assertIs(x, x[0]) def test_recursive_tuple(self): t = ([],) @@ -563,7 +563,7 @@ x = self.loads(s) self.assertEqual(len(x), 1) self.assertEqual(len(x[0]), 1) - self.assertTrue(x is x[0][0]) + self.assertIs(x, x[0][0]) def test_recursive_dict(self): d = {} @@ -572,7 +572,7 @@ s = self.dumps(d, proto) x = self.loads(s) self.assertEqual(list(x.keys()), [1]) - self.assertTrue(x[1] is x) + self.assertIs(x[1], x) def test_recursive_inst(self): i = C() @@ -595,7 +595,7 @@ self.assertEqual(len(x), 1) self.assertEqual(dir(x[0]), dir(i)) self.assertEqual(list(x[0].attr.keys()), [1]) - self.assertTrue(x[0].attr[1] is x) + self.assertIs(x[0].attr[1], x) def test_get(self): self.assertRaises(KeyError, self.loads, b'g0\np0') @@ -841,7 +841,7 @@ for x in None, False, True: s = self.dumps(x, proto) y = self.loads(s) - self.assertTrue(x is y, (proto, x, s, y)) + self.assertIs(x, y, (proto, x, s, y)) expected = expected_opcode[proto, x] self.assertEqual(opcode_in_pickle(expected, s), True) @@ -965,7 +965,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 @@ -988,7 +988,7 @@ if proto == 0: self.assertEqual(num_setitems, 0) else: - self.assertTrue(num_setitems >= 2) + self.assertGreaterEqual(num_setitems, 2) def test_simple_newobj(self): x = object.__new__(SimpleNewObj) # avoid __init__ @@ -1272,8 +1272,8 @@ continue try: pickled = self.dumps(data, protocol=proto) - self.assertTrue(b"abcd" in pickled[:15]) - self.assertTrue(b"abcd" in pickled[-15:]) + self.assertIn(b"abcd", pickled[:15]) + self.assertIn(b"abcd", pickled[-15:]) finally: pickled = None finally: @@ -1301,8 +1301,8 @@ for proto in protocols: try: pickled = self.dumps(data, protocol=proto) - self.assertTrue(b"abcd" in pickled[:15]) - self.assertTrue(b"abcd" in pickled[-15:]) + self.assertIn(b"abcd", pickled[:15]) + self.assertIn(b"abcd", pickled[-15:]) finally: pickled = None finally: @@ -1616,7 +1616,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 ff471d8526a8 Lib/test/test_abc.py --- a/Lib/test/test_abc.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_abc.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_argparse.py --- a/Lib/test/test_argparse.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_argparse.py Sat Nov 16 17:58:58 2013 +0200 @@ -4165,7 +4165,7 @@ e = sys.exc_info()[1] expected = 'unknown action' msg = 'expected %r, found %r' % (expected, e) - self.assertTrue(expected in str(e), msg) + self.assertIn(expected, str(e), msg) def test_multiple_dest(self): parser = argparse.ArgumentParser() @@ -4176,7 +4176,7 @@ e = sys.exc_info()[1] expected = 'dest supplied twice for positional argument' msg = 'expected %r, found %r' % (expected, e) - self.assertTrue(expected in str(e), msg) + self.assertIn(expected, str(e), msg) def test_no_argument_actions(self): for action in ['store_const', 'store_true', 'store_false', diff -r ff471d8526a8 Lib/test/test_ast.py --- a/Lib/test/test_ast.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_ast.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_asyncore.py --- a/Lib/test/test_asyncore.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_asyncore.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_augassign.py --- a/Lib/test/test_augassign.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_augassign.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_bigmem.py --- a/Lib/test/test_bigmem.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_bigmem.py Sat Nov 16 17:58:58 2013 +0200 @@ -118,7 +118,7 @@ _ = self.from_latin1 s = _('-') * size tabsize = 8 - self.assertTrue(s.expandtabs() == s) + self.assertEqual(s.expandtabs(), s) del s slen, remainder = divmod(size, tabsize) s = _(' \t') * slen @@ -270,7 +270,7 @@ # Type-specific optimization if isinstance(s, (str, bytes)): stripped = s.lstrip() - self.assertTrue(stripped is s) + self.assertIs(stripped, s) @bigmemtest(size=_2G + 10, memuse=2) def test_replace(self, size): @@ -342,7 +342,7 @@ # Type-specific optimization if isinstance(s, (str, bytes)): stripped = s.rstrip() - self.assertTrue(stripped is s) + self.assertIs(stripped, s) # The test takes about size bytes to build a string, and then about # sqrt(size) substrings of sqrt(size) in size and a list to @@ -536,12 +536,12 @@ edge = _('-') * (size // 2) s = _('').join([edge, SUBSTR, edge]) del edge - self.assertTrue(SUBSTR in s) - self.assertFalse(SUBSTR * 2 in s) - self.assertTrue(_('-') in s) - self.assertFalse(_('a') in s) + self.assertIn(SUBSTR, s) + self.assertNotIn(SUBSTR * 2, s) + self.assertIn(_('-'), s) + self.assertNotIn(_('a'), s) s += _('a') - self.assertTrue(_('a') in s) + self.assertIn(_('a'), s) @bigmemtest(size=_2G + 10, memuse=2) def test_compare(self, size): @@ -655,7 +655,7 @@ def test_format(self, size): s = '-' * size sf = '%s' % (s,) - self.assertTrue(s == sf) + self.assertEqual(s, sf) del sf sf = '..%s..' % (s,) self.assertEqual(len(sf), len(s) + 4) @@ -856,9 +856,9 @@ def test_contains(self, size): t = (1, 2, 3, 4, 5) * size self.assertEqual(len(t), size * 5) - self.assertTrue(5 in t) - self.assertFalse((1, 2, 3, 4, 5) in t) - self.assertFalse(0 in t) + self.assertIn(5, t) + self.assertNotIn((1, 2, 3, 4, 5), t) + self.assertNotIn(0, t) @bigmemtest(size=_2G + 10, memuse=8) def test_hash(self, size): @@ -866,7 +866,7 @@ h1 = hash(t1) del t1 t2 = (0,) * (size + 1) - self.assertFalse(h1 == hash(t2)) + self.assertNotEqual(h1, hash(t2)) @bigmemtest(size=_2G + 10, memuse=8) def test_index_and_slice(self, size): @@ -992,8 +992,8 @@ l = [sys.stdout] * size l += l self.assertEqual(len(l), size * 2) - self.assertTrue(l[0] is l[-1]) - self.assertTrue(l[size - 1] is l[size + 1]) + self.assertIs(l[0], l[-1]) + self.assertIs(l[size - 1], l[size + 1]) @bigmemtest(size=_2G // 2 + 2, memuse=24) def test_inplace_concat_small(self, size): @@ -1007,9 +1007,9 @@ def test_contains(self, size): l = [1, 2, 3, 4, 5] * size self.assertEqual(len(l), size * 5) - self.assertTrue(5 in l) - self.assertFalse([1, 2, 3, 4, 5] in l) - self.assertFalse(0 in l) + self.assertIn(5, l) + self.assertNotIn([1, 2, 3, 4, 5], l) + self.assertNotIn(0, l) @bigmemtest(size=_2G + 10, memuse=8) def test_hash(self, size): @@ -1092,13 +1092,13 @@ l = [''] l *= size self.assertEqual(len(l), size) - self.assertTrue(l[0] is l[-1]) + self.assertIs(l[0], l[-1]) del l l = [''] * size l *= 2 self.assertEqual(len(l), size * 2) - self.assertTrue(l[size - 1] is l[-1]) + self.assertIs(l[size - 1], l[-1]) @bigmemtest(size=_2G // 2 + 2, memuse=16) def test_inplace_repeat_small(self, size): @@ -1132,8 +1132,8 @@ l = [object()] * size l.append(object()) self.assertEqual(len(l), size+1) - self.assertTrue(l[-3] is l[-2]) - self.assertFalse(l[-2] is l[-1]) + self.assertIs(l[-3], l[-2]) + self.assertIsNot(l[-2], l[-1]) @bigmemtest(size=_2G // 5 + 2, memuse=8 * 5) def test_count(self, size): @@ -1145,8 +1145,8 @@ l = [object] * size l.extend(l) self.assertEqual(len(l), size * 2) - self.assertTrue(l[0] is l[-1]) - self.assertTrue(l[size - 1] is l[size + 1]) + self.assertIs(l[0], l[-1]) + self.assertIs(l[size - 1], l[size + 1]) @bigmemtest(size=_2G // 2 + 2, memuse=16) def test_extend_small(self, size): diff -r ff471d8526a8 Lib/test/test_binop.py --- a/Lib/test/test_binop.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_binop.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_bisect.py --- a/Lib/test/test_bisect.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_bisect.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_buffer.py --- a/Lib/test/test_buffer.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_buffer.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_bufio.py --- a/Lib/test/test_bufio.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_bufio.py Sat Nov 16 17:58:58 2013 +0200 @@ -34,7 +34,7 @@ line = f.readline() self.assertEqual(line, s) line = f.readline() - self.assertTrue(not line) # Must be at EOF + self.assertFalse(line) # Must be at EOF f.close() finally: support.unlink(support.TESTFN) diff -r ff471d8526a8 Lib/test/test_builtin.py --- a/Lib/test/test_builtin.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_builtin.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_bytes.py --- a/Lib/test/test_bytes.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_bytes.py Sat Nov 16 17:58:58 2013 +0200 @@ -951,7 +951,7 @@ b += b"def" self.assertEqual(b, b"abcdef") self.assertEqual(b, b1) - self.assertTrue(b is b1) + self.assertIs(b, b1) b += b"xyz" self.assertEqual(b, b"abcdefxyz") try: @@ -967,7 +967,7 @@ b *= 3 self.assertEqual(b, b"abcabcabc") self.assertEqual(b, b1) - self.assertTrue(b is b1) + self.assertIs(b, b1) def test_irepeat_1char(self): b = bytearray(b"x") @@ -975,17 +975,17 @@ b *= 100 self.assertEqual(b, b"x"*100) self.assertEqual(b, b1) - self.assertTrue(b is b1) + self.assertIs(b, b1) def test_alloc(self): b = bytearray() alloc = b.__alloc__() - self.assertTrue(alloc >= 0) + self.assertGreaterEqual(alloc, 0) seq = [alloc] for i in range(100): b += b"x" alloc = b.__alloc__() - self.assertTrue(alloc >= len(b)) + self.assertGreaterEqual(alloc, len(b)) if alloc not in seq: seq.append(alloc) @@ -1076,17 +1076,17 @@ # Issue 4348. Make sure that operations that don't mutate the array # copy the bytes. b = bytearray(b'abc') - self.assertFalse(b is b.replace(b'abc', b'cde', 0)) + self.assertIsNot(b, b.replace(b'abc', b'cde', 0)) t = bytearray([i for i in range(256)]) x = bytearray(b'') - self.assertFalse(x is x.translate(t)) + self.assertIsNot(x, x.translate(t)) def test_partition_bytearray_doesnt_share_nullstring(self): a, b, c = bytearray(b"x").partition(b"y") self.assertEqual(b, b"") self.assertEqual(c, b"") - self.assertTrue(b is not c) + self.assertIsNot(b, c) b += b"!" self.assertEqual(c, b"") a, b, c = bytearray(b"x").partition(b"y") @@ -1096,7 +1096,7 @@ b, c, a = bytearray(b"x").rpartition(b"y") self.assertEqual(b, b"") self.assertEqual(c, b"") - self.assertTrue(b is not c) + self.assertIsNot(b, c) b += b"!" self.assertEqual(c, b"") c, b, a = bytearray(b"x").rpartition(b"y") @@ -1243,7 +1243,7 @@ def test_return_self(self): # bytearray.replace must always return a new bytearray b = bytearray() - self.assertFalse(b.replace(b'', b'') is b) + self.assertIsNot(b.replace(b'', b''), b) def test_compare(self): if sys.flags.bytes_warning: @@ -1288,14 +1288,14 @@ method = getattr(val, methname) newval = method(3) self.assertEqual(val, newval) - self.assertTrue(val is not newval, + self.assertIsNot(val, newval, methname+' returned self on a mutable object') for expr in ('val.split()[0]', 'val.rsplit()[0]', 'val.partition(b".")[0]', 'val.rpartition(b".")[2]', 'val.splitlines()[0]', 'val.replace(b"", b"")'): newval = eval(expr) self.assertEqual(val, newval) - self.assertTrue(val is not newval, + self.assertIsNot(val, newval, expr+' returned val on a mutable object') sep = self.marshal(b'') newval = sep.join([val]) @@ -1347,7 +1347,7 @@ self.assertTrue(_a <= _b) self.assertTrue(_b >= _a) self.assertTrue(_b > _a) - self.assertTrue(_a is not a) + self.assertIsNot(_a, a) # test concat of subclass instances self.assertEqual(a + b, _a + _b) @@ -1363,12 +1363,12 @@ # Make sure that it is of the appropriate type. s1 = self.subclass2test(b"abcd") s2 = self.type2test().join([s1]) - self.assertTrue(s1 is not s2) - self.assertTrue(type(s2) is self.type2test, type(s2)) + self.assertIsNot(s1, s2) + self.assertIs(type(s2), self.type2test) # Test reverse, calling join on subclass s3 = s1.join([b"abcd"]) - self.assertTrue(type(s3) is self.type2test) + self.assertIs(type(s3), self.type2test) def test_pickle(self): a = self.subclass2test(b"abcd") diff -r ff471d8526a8 Lib/test/test_bz2.py --- a/Lib/test/test_bz2.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_bz2.py Sat Nov 16 17:58:58 2013 +0200 @@ -679,7 +679,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 ff471d8526a8 Lib/test/test_capi.py --- a/Lib/test/test_capi.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_capi.py Sat Nov 16 17:58:58 2013 +0200 @@ -33,7 +33,7 @@ def test_instancemethod(self): inst = InstanceMethod() self.assertEqual(id(inst), inst.id()) - self.assertTrue(inst.testfunction() is inst) + self.assertIs(inst.testfunction(), inst) self.assertEqual(inst.testfunction.__doc__, testfunction.__doc__) self.assertEqual(InstanceMethod.testfunction.__doc__, testfunction.__doc__) @@ -141,7 +141,7 @@ if context and not context.event.is_set(): continue count += 1 - self.assertTrue(count < 10000, + self.assertLess(count, 10000, "timeout waiting for %i callbacks, got %i"%(n, len(l))) if False and support.verbose: print("(%i)"%(len(l),)) diff -r ff471d8526a8 Lib/test/test_cgi.py --- a/Lib/test/test_cgi.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_cgi.py Sat Nov 16 17:58:58 2013 +0200 @@ -220,7 +220,7 @@ # if we're not chunking properly, readline is only called twice # (by read_binary); if we are chunking properly, it will be called 5 times # as long as the chunksize is 1 << 16. - self.assertTrue(f.numcalls > 2) + self.assertGreater(f.numcalls, 2) f.close() def test_fieldstorage_multipart(self): diff -r ff471d8526a8 Lib/test/test_cmd_line.py --- a/Lib/test/test_cmd_line.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_cmd_line.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_codecs.py --- a/Lib/test/test_codecs.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_codecs.py Sat Nov 16 17:58:58 2013 +0200 @@ -60,7 +60,7 @@ # reset decoder to the default state without anything buffered d.setstate((state[0][:0], 0)) # Feeding the previous input may not produce any output - self.assertTrue(not d.decode(state[0])) + self.assertFalse(d.decode(state[0])) # The decoder must return to the same state self.assertEqual(state, d.getstate()) # Create a new decoder and set it to the state @@ -319,7 +319,7 @@ f.write("spam") d = s.getvalue() # check whether there is exactly one BOM in it - self.assertTrue(d == self.spamle or d == self.spambe) + self.assertIn(d, (self.spamle, self.spambe)) # try to read it back s = io.BytesIO(d) f = reader(s) @@ -495,7 +495,7 @@ f.write("spam") d = s.getvalue() # check whether there is exactly one BOM in it - self.assertTrue(d == self.spamle or d == self.spambe) + self.assertIn(d, (self.spamle, self.spambe)) # try to read it back s = io.BytesIO(d) f = reader(s) @@ -1693,7 +1693,7 @@ for c in s: writer.write(c) chunk = q.read() - self.assertTrue(type(chunk) is bytes, type(chunk)) + self.assertIs(type(chunk), bytes) encodedresult += chunk q = Queue(b"") reader = codecs.getreader(encoding)(q) @@ -2345,8 +2345,7 @@ msg = "^encoding with '{}' codec failed".format(encoding) with self.assertRaisesRegex(TypeError, msg) as failure: bad_input.encode(encoding) - self.assertTrue(isinstance(failure.exception.__cause__, - TypeError)) + self.assertIsInstance(failure.exception.__cause__, TypeError) def test_type_error_for_binary_input(self): # Check str -> str codec gives a good error for binary input @@ -2355,8 +2354,8 @@ msg = "^decoding with 'rot_13' codec failed" with self.assertRaisesRegex(AttributeError, msg) as failure: bad_input.decode("rot_13") - self.assertTrue(isinstance(failure.exception.__cause__, - AttributeError)) + self.assertIsInstance(failure.exception.__cause__, + AttributeError) def test_bad_decoding_output_type(self): # Check bytes.decode and bytearray.decode give a good error diff -r ff471d8526a8 Lib/test/test_codeop.py --- a/Lib/test/test_codeop.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_codeop.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_collections.py --- a/Lib/test/test_collections.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_collections.py Sat Nov 16 17:58:58 2013 +0200 @@ -638,7 +638,7 @@ def __hash__(self): return self._hash() a, b = OneTwoThreeSet(), OneTwoThreeSet() - self.assertTrue(hash(a) == hash(b)) + self.assertEqual(hash(a), hash(b)) def test_MutableSet(self): self.assertIsInstance(set(), MutableSet) @@ -979,7 +979,7 @@ def test_invariant_for_the_in_operator(self): c = Counter(a=10, b=-2, c=0) for elem in c: - self.assertTrue(elem in c) + self.assertIn(elem, c) self.assertIn(elem, c) def test_multiset_operations(self): diff -r ff471d8526a8 Lib/test/test_compile.py --- a/Lib/test/test_compile.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_compile.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_compileall.py --- a/Lib/test/test_compileall.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_compileall.py Sat Nov 16 17:58:58 2013 +0200 @@ -72,12 +72,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 ff471d8526a8 Lib/test/test_complex.py --- a/Lib/test/test_complex.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_complex.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_concurrent_futures.py --- a/Lib/test/test_concurrent_futures.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_concurrent_futures.py Sat Nov 16 17:58:58 2013 +0200 @@ -648,8 +648,7 @@ CANCELLED_FUTURE.exception, timeout=0) self.assertRaises(futures.CancelledError, CANCELLED_AND_NOTIFIED_FUTURE.exception, timeout=0) - self.assertTrue(isinstance(EXCEPTION_FUTURE.exception(timeout=0), - OSError)) + self.assertIsInstance(EXCEPTION_FUTURE.exception(timeout=0), OSError) self.assertEqual(SUCCESSFUL_FUTURE.exception(timeout=0), None) def test_exception_with_success(self): @@ -665,7 +664,7 @@ t = threading.Thread(target=notification) t.start() - self.assertTrue(isinstance(f1.exception(timeout=5), OSError)) + self.assertIsInstance(f1.exception(timeout=5), OSError) @test.support.reap_threads def test_main(): diff -r ff471d8526a8 Lib/test/test_configparser.py --- a/Lib/test/test_configparser.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_configparser.py Sat Nov 16 17:58:58 2013 +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"}) @@ -1537,7 +1537,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() @@ -1566,7 +1566,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') @@ -1575,7 +1575,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 ff471d8526a8 Lib/test/test_copyreg.py --- a/Lib/test/test_copyreg.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_copyreg.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_crypt.py --- a/Lib/test/test_crypt.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_crypt.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_dbm.py --- a/Lib/test/test_dbm.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_dbm.py Sat Nov 16 17:58:58 2013 +0200 @@ -142,7 +142,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 ff471d8526a8 Lib/test/test_dbm_gnu.py --- a/Lib/test/test_dbm_gnu.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_dbm_gnu.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_decimal.py --- a/Lib/test/test_decimal.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_decimal.py Sat Nov 16 17:58:58 2013 +0200 @@ -755,7 +755,7 @@ for v in [-2**63-1, -2**63, -2**31-1, -2**31, 0, 2**31-1, 2**31, 2**63-1, 2**63]: d = nc.create_decimal(v) - self.assertTrue(isinstance(d, Decimal)) + self.assertIsInstance(d, Decimal) self.assertEqual(int(d), v) nc.prec = 3 @@ -4299,34 +4299,40 @@ self.assertEqual(r, Decimal('194')) q, r = divmod(Decimal("NaN"), 7) - self.assertTrue(q.is_nan() and r.is_nan()) + self.assertTrue(q.is_nan()) + self.assertTrue(r.is_nan()) c.traps[InvalidOperation] = False q, r = divmod(Decimal("NaN"), 7) - self.assertTrue(q.is_nan() and r.is_nan()) + self.assertTrue(q.is_nan()) + self.assertTrue(r.is_nan()) c.traps[InvalidOperation] = False c.clear_flags() q, r = divmod(Decimal("inf"), Decimal("inf")) - self.assertTrue(q.is_nan() and r.is_nan()) + self.assertTrue(q.is_nan()) + self.assertTrue(r.is_nan()) self.assertTrue(c.flags[InvalidOperation]) c.clear_flags() q, r = divmod(Decimal("inf"), 101) - self.assertTrue(q.is_infinite() and r.is_nan()) + self.assertTrue(q.is_infinite()) + self.assertTrue(r.is_nan()) self.assertTrue(c.flags[InvalidOperation]) c.clear_flags() q, r = divmod(Decimal(0), 0) - self.assertTrue(q.is_nan() and r.is_nan()) + self.assertTrue(q.is_nan()) + self.assertTrue(r.is_nan()) self.assertTrue(c.flags[InvalidOperation]) c.traps[DivisionByZero] = False c.clear_flags() q, r = divmod(Decimal(11), 0) - self.assertTrue(q.is_infinite() and r.is_nan()) - self.assertTrue(c.flags[InvalidOperation] and - c.flags[DivisionByZero]) + self.assertTrue(q.is_infinite()) + self.assertTrue(r.is_nan()) + self.assertTrue(c.flags[InvalidOperation]) + self.assertTrue(c.flags[DivisionByZero]) def test_power(self): Decimal = self.decimal.Decimal @@ -5161,7 +5167,7 @@ c = DefaultContext.copy() # Signal dict methods - self.assertTrue(Overflow in c.traps) + self.assertIn(Overflow, c.traps) c.clear_traps() for k in c.traps.keys(): c.traps[k] = True @@ -5172,7 +5178,7 @@ self.assertFalse(v) self.assertFalse(c.flags.get(Overflow)) - self.assertIs(c.flags.get("x"), None) + self.assertIsNone(c.flags.get("x")) self.assertEqual(c.flags.get("x", "y"), "y") self.assertRaises(TypeError, c.flags.get, "x", "y", "z") diff -r ff471d8526a8 Lib/test/test_defaultdict.py --- a/Lib/test/test_defaultdict.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_defaultdict.py Sat Nov 16 17:58:58 2013 +0200 @@ -69,7 +69,7 @@ self.assertEqual(repr(d2), "defaultdict(, {12: 42})") def foo(): return 43 d3 = defaultdict(foo) - self.assertTrue(d3.default_factory is foo) + self.assertIs(d3.default_factory, foo) d3[13] self.assertEqual(repr(d3), "defaultdict(%s, {13: 43})" % repr(foo)) @@ -134,7 +134,7 @@ d2 = copy.deepcopy(d1) self.assertEqual(d2.default_factory, foobar) self.assertEqual(d2, d1) - self.assertTrue(d1[1] is not d2[1]) + self.assertIsNot(d1[1], d2[1]) d1.default_factory = list d2 = copy.deepcopy(d1) self.assertEqual(d2.default_factory, list) diff -r ff471d8526a8 Lib/test/test_deque.py --- a/Lib/test/test_deque.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_deque.py Sat Nov 16 17:58:58 2013 +0200 @@ -244,7 +244,7 @@ d = deque(data[:i]) r = d.reverse() self.assertEqual(list(d), list(reversed(data[:i]))) - self.assertIs(r, None) + self.assertIsNone(r) d.reverse() self.assertEqual(list(d), data[:i]) self.assertRaises(TypeError, d.reverse, 1) # Arity is zero @@ -347,7 +347,7 @@ self.assertRaises(RuntimeError, d.remove, 'c') for x, y in zip(d, e): # verify that original order and values are retained. - self.assertTrue(x is y) + self.assertIs(x, y) # Handle evil mutator for match in (True, False): @@ -530,7 +530,7 @@ obj.x = iter(container) del obj, container gc.collect() - self.assertTrue(ref() is None, "Cycle was not collected") + self.assertIsNone(ref(), "Cycle was not collected") check_sizeof = support.check_sizeof diff -r ff471d8526a8 Lib/test/test_dict.py --- a/Lib/test/test_dict.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_dict.py Sat Nov 16 17:58:58 2013 +0200 @@ -275,10 +275,10 @@ def test_get(self): d = {} - self.assertIs(d.get('c'), None) + self.assertIsNone(d.get('c')) self.assertEqual(d.get('c', 3), 3) d = {'a': 1, 'b': 2} - self.assertIs(d.get('c'), None) + self.assertIsNone(d.get('c')) self.assertEqual(d.get('c', 3), 3) self.assertEqual(d.get('a'), 1) self.assertEqual(d.get('a', 3), 1) @@ -288,9 +288,9 @@ def test_setdefault(self): # dict.setdefault() d = {} - self.assertIs(d.setdefault('key0'), None) + self.assertIsNone(d.setdefault('key0')) d.setdefault('key0', []) - self.assertIs(d.setdefault('key0'), None) + self.assertIsNone(d.setdefault('key0')) d.setdefault('key', []).append(3) self.assertEqual(d['key'][0], 3) d.setdefault('key', []).append(4) @@ -733,7 +733,7 @@ obj.x = iter(obj.v) del obj, container gc.collect() - self.assertIs(ref(), None, "Cycle was not collected") + self.assertIsNone(ref(), "Cycle was not collected") def _not_tracked(self, t): # Nested containers can take several collections to untrack @@ -864,7 +864,7 @@ # merely an object supporting the iterator protocol, yielding # the same objects as the original one. # self.assertEqual(type(itorg), type(it)) - self.assertTrue(isinstance(it, collections.abc.Iterator)) + self.assertIsInstance(it, collections.abc.Iterator) self.assertEqual(dict(it), data) it = pickle.loads(d) diff -r ff471d8526a8 Lib/test/test_dictviews.py --- a/Lib/test/test_dictviews.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_dictviews.py Sat Nov 16 17:58:58 2013 +0200 @@ -74,16 +74,16 @@ self.assertIsInstance(repr(d), str) r = repr(d.items()) self.assertIsInstance(r, str) - self.assertTrue(r == "dict_items([('a', 'ABC'), (1, 10)])" or - r == "dict_items([(1, 10), ('a', 'ABC')])") + self.assertIn(r, ("dict_items([('a', 'ABC'), (1, 10)])", + "dict_items([(1, 10), ('a', 'ABC')])")) r = repr(d.keys()) self.assertIsInstance(r, str) - self.assertTrue(r == "dict_keys(['a', 1])" or - r == "dict_keys([1, 'a'])") + self.assertIn(r, ("dict_keys(['a', 1])", + "dict_keys([1, 'a'])")) r = repr(d.values()) self.assertIsInstance(r, str) - self.assertTrue(r == "dict_values(['ABC', 10])" or - r == "dict_values([10, 'ABC'])") + self.assertIn(r, ("dict_values(['ABC', 10])", + "dict_values([10, 'ABC'])")) def test_keys_set_operations(self): d1 = {'a': 1, 'b': 2} diff -r ff471d8526a8 Lib/test/test_dummy_thread.py --- a/Lib/test/test_dummy_thread.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_dummy_thread.py Sat Nov 16 17:58:58 2013 +0200 @@ -24,14 +24,14 @@ def test_initlock(self): #Make sure locks start locked - self.assertTrue(not self.lock.locked(), + self.assertFalse(self.lock.locked(), "Lock object is not initialized unlocked.") def test_release(self): # Test self.lock.release() self.lock.acquire() self.lock.release() - self.assertTrue(not self.lock.locked(), + self.assertFalse(self.lock.locked(), "Lock object did not release properly.") def test_improper_release(self): @@ -46,7 +46,7 @@ def test_cond_acquire_fail(self): #Test acquiring locked lock returns False self.lock.acquire(0) - self.assertTrue(not self.lock.acquire(0), + self.assertFalse(self.lock.acquire(0), "Conditional acquiring of a locked lock incorrectly " "succeeded.") @@ -58,9 +58,9 @@ def test_uncond_acquire_return_val(self): #Make sure that an unconditional locking returns True. - self.assertTrue(self.lock.acquire(1) is True, + self.assertIs(self.lock.acquire(1), True, "Unconditional locking did not return True.") - self.assertTrue(self.lock.acquire() is True) + self.assertIs(self.lock.acquire(), True) def test_uncond_acquire_blocking(self): #Make sure that unconditional acquiring of a locked lock blocks. @@ -80,7 +80,7 @@ end_time = int(time.time()) if support.verbose: print("done") - self.assertTrue((end_time - start_time) >= DELAY, + self.assertGreaterEqual(end_time - start_time, DELAY, "Blocking by unconditional acquiring failed.") class MiscTests(unittest.TestCase): @@ -94,7 +94,7 @@ #Test sanity of _thread.get_ident() self.assertIsInstance(_thread.get_ident(), int, "_thread.get_ident() returned a non-integer") - self.assertTrue(_thread.get_ident() != 0, + self.assertNotEqual(_thread.get_ident(), 0, "_thread.get_ident() returned 0") def test_LockType(self): @@ -164,7 +164,7 @@ time.sleep(DELAY) if support.verbose: print('done') - self.assertTrue(testing_queue.qsize() == thread_count, + self.assertEqual(testing_queue.qsize(), thread_count, "Not all %s threads executed properly after %s sec." % (thread_count, DELAY)) diff -r ff471d8526a8 Lib/test/test_epoll.py --- a/Lib/test/test_epoll.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_epoll.py Sat Nov 16 17:58:58 2013 +0200 @@ -71,8 +71,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 ff471d8526a8 Lib/test/test_exceptions.py --- a/Lib/test/test_exceptions.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_exceptions.py Sat Nov 16 17:58:58 2013 +0200 @@ -500,7 +500,7 @@ pass obj = None obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # Qualified "except" without "as" obj = MyObj() @@ -511,7 +511,7 @@ pass obj = None obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # Bare "except" obj = MyObj() @@ -522,7 +522,7 @@ pass obj = None obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # "except" with premature block leave obj = MyObj() @@ -534,7 +534,7 @@ break obj = None obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # "except" block raising another exception obj = MyObj() @@ -555,7 +555,7 @@ # guarantee no ref cycles on CPython (don't gc_collect) if check_impl_detail(cpython=False): gc_collect() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # Some complicated construct obj = MyObj() @@ -574,7 +574,7 @@ if check_impl_detail(cpython=False): gc_collect() obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) # Inside an exception-silencing "with" block class Context: @@ -590,7 +590,7 @@ if check_impl_detail(cpython=False): gc_collect() obj = wr() - self.assertTrue(obj is None, "%s" % obj) + self.assertIsNone(obj, "%s" % obj) def test_exception_target_in_nested_scope(self): # issue 4617: This used to raise a SyntaxError @@ -696,7 +696,7 @@ testfunc(g) g = obj = None obj = wr() - self.assertIs(obj, None) + self.assertIsNone(obj) def test_generator_throw_cleanup_exc_state(self): def do_throw(g): @@ -815,7 +815,7 @@ except RuntimeError: return sys.exc_info() e, v, tb = g() - self.assertTrue(isinstance(v, RuntimeError), type(v)) + self.assertIsInstance(v, RuntimeError, type(v)) self.assertIn("maximum recursion depth exceeded", str(v)) diff -r ff471d8526a8 Lib/test/test_faulthandler.py --- a/Lib/test/test_faulthandler.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_faulthandler.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_file.py --- a/Lib/test/test_file.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_file.py Sat Nov 16 17:58:58 2013 +0200 @@ -83,8 +83,8 @@ def testErrors(self): f = self.f self.assertEqual(f.name, TESTFN) - self.assertTrue(not f.isatty()) - self.assertTrue(not f.closed) + self.assertFalse(f.isatty()) + self.assertFalse(f.closed) if hasattr(f, "readinto"): self.assertRaises((OSError, TypeError), f.readinto, "") diff -r ff471d8526a8 Lib/test/test_filecmp.py --- a/Lib/test/test_filecmp.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_filecmp.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_fileio.py --- a/Lib/test/test_fileio.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_fileio.py Sat Nov 16 17:58:58 2013 +0200 @@ -114,15 +114,15 @@ def testErrors(self): f = self.f - self.assertTrue(not f.isatty()) - self.assertTrue(not f.closed) + self.assertFalse(f.isatty()) + self.assertFalse(f.closed) #self.assertEqual(f.name, TESTFN) self.assertRaises(ValueError, f.read, 10) # Open for reading f.close() self.assertTrue(f.closed) f = _FileIO(TESTFN, 'r') self.assertRaises(TypeError, f.readinto, "") - self.assertTrue(not f.closed) + self.assertFalse(f.closed) f.close() self.assertTrue(f.closed) diff -r ff471d8526a8 Lib/test/test_fnmatch.py --- a/Lib/test/test_fnmatch.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_fnmatch.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_ftplib.py --- a/Lib/test/test_ftplib.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_ftplib.py Sat Nov 16 17:58:58 2013 +0200 @@ -966,7 +966,7 @@ def testTimeoutDefault(self): # default -- use global socket timeout - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: ftp = ftplib.FTP(HOST) @@ -978,13 +978,13 @@ def testTimeoutNone(self): # no timeout -- do not use global socket timeout - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: ftp = ftplib.FTP(HOST, timeout=None) finally: socket.setdefaulttimeout(None) - self.assertTrue(ftp.sock.gettimeout() is None) + self.assertIsNone(ftp.sock.gettimeout()) self.evt.wait() ftp.close() diff -r ff471d8526a8 Lib/test/test_funcattrs.py --- a/Lib/test/test_funcattrs.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_funcattrs.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_functools.py --- a/Lib/test/test_functools.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_functools.py Sat Nov 16 17:58:58 2013 +0200 @@ -105,7 +105,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 @@ -113,15 +114,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): @@ -896,7 +900,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 ff471d8526a8 Lib/test/test_gc.py --- a/Lib/test/test_gc.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_gc.py Sat Nov 16 17:58:58 2013 +0200 @@ -753,9 +753,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 ff471d8526a8 Lib/test/test_gdb.py --- a/Lib/test/test_gdb.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_gdb.py Sat Nov 16 17:58:58 2013 +0200 @@ -217,7 +217,7 @@ class PrettyPrintTests(DebuggerTests): def test_getting_backtrace(self): gdb_output = self.get_stack_trace('id(42)') - self.assertTrue(BREAKPOINT_FN in gdb_output) + self.assertIn(BREAKPOINT_FN, gdb_output) def assertGdbRepr(self, val, exp_repr=None, cmds_after_breakpoint=None): # Ensure that gdb's rendering of the value in a debugged process diff -r ff471d8526a8 Lib/test/test_grammar.py --- a/Lib/test/test_grammar.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_grammar.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_gzip.py --- a/Lib/test/test_gzip.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_gzip.py Sat Nov 16 17:58:58 2013 +0200 @@ -159,7 +159,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 ff471d8526a8 Lib/test/test_heapq.py --- a/Lib/test/test_heapq.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_heapq.py Sat Nov 16 17:58:58 2013 +0200 @@ -61,7 +61,7 @@ for pos, item in enumerate(heap): if pos: # pos 0 has no parent parentpos = (pos-1) >> 1 - self.assertTrue(heap[parentpos] <= item) + self.assertLessEqual(heap[parentpos], item) def test_heapify(self): for size in range(30): diff -r ff471d8526a8 Lib/test/test_hmac.py --- a/Lib/test/test_hmac.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_hmac.py Sat Nov 16 17:58:58 2013 +0200 @@ -300,7 +300,7 @@ # Testing if attributes are of same type. h1 = hmac.HMAC(b"key") h2 = h1.copy() - self.assertTrue(h1.digest_cons == h2.digest_cons, + self.assertEqual(h1.digest_cons, h2.digest_cons, "digest constructors don't match.") self.assertEqual(type(h1.inner), type(h2.inner), "Types of inner don't match.") @@ -311,11 +311,11 @@ # Testing if the copy method created a real copy. h1 = hmac.HMAC(b"key") h2 = h1.copy() - # Using id() in case somebody has overridden __eq__/__ne__. - self.assertTrue(id(h1) != id(h2), "No real copy of the HMAC instance.") - self.assertTrue(id(h1.inner) != id(h2.inner), + # Using "is" in case somebody has overridden __eq__/__ne__. + self.assertIsNot(h1, h2, "No real copy of the HMAC instance.") + self.assertIsNot(h1.inner, h2.inner, "No real copy of the attribute 'inner'.") - self.assertTrue(id(h1.outer) != id(h2.outer), + self.assertIsNot(h1.outer, h2.outer, "No real copy of the attribute 'outer'.") def test_equality(self): diff -r ff471d8526a8 Lib/test/test_httplib.py --- a/Lib/test/test_httplib.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_httplib.py Sat Nov 16 17:58:58 2013 +0200 @@ -134,7 +134,7 @@ conn.sock = FakeSocket(None) conn.putrequest('GET','/') conn.putheader('Content-length', 42) - self.assertTrue(b'Content-length: 42' in conn._buffer) + self.assertIn(b'Content-length: 42', conn._buffer) def test_ipv6host_header(self): # Default host header on IPv6 transaction should wrapped by [] if @@ -720,7 +720,7 @@ # and into the socket. # default -- use global socket timeout - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: httpConn = client.HTTPConnection(HOST, TimeoutTest.PORT) @@ -731,7 +731,7 @@ httpConn.close() # no timeout -- do not use global socket default - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: httpConn = client.HTTPConnection(HOST, TimeoutTest.PORT, diff -r ff471d8526a8 Lib/test/test_httpservers.py --- a/Lib/test/test_httpservers.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_httpservers.py Sat Nov 16 17:58:58 2013 +0200 @@ -552,7 +552,7 @@ def verify_http_server_response(self, response): match = self.HTTPResponseMatch.search(response) - self.assertTrue(match is not None) + self.assertIsNotNone(match) def test_http_1_1(self): result = self.send_typical_request(b'GET / HTTP/1.1\r\n\r\n') diff -r ff471d8526a8 Lib/test/test_inspect.py --- a/Lib/test/test_inspect.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_inspect.py Sat Nov 16 17:58:58 2013 +0200 @@ -166,7 +166,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:]), @@ -2081,7 +2081,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) @@ -2096,7 +2096,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, @@ -2168,7 +2168,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 ff471d8526a8 Lib/test/test_io.py --- a/Lib/test/test_io.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_io.py Sat Nov 16 17:58:58 2013 +0200 @@ -458,7 +458,7 @@ with self.open(support.TESTFN, "ab") as f: self.assertEqual(f.tell(), 3) with self.open(support.TESTFN, "a") as f: - self.assertTrue(f.tell() > 0) + self.assertGreater(f.tell(), 0) def test_destructor(self): record = [] @@ -578,7 +578,7 @@ wr = weakref.ref(f) del f support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) with self.open(support.TESTFN, "rb") as f: self.assertEqual(f.read(), b"abcxxx") @@ -677,7 +677,7 @@ del MyIO del obj support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) class PyIOTest(IOTest): pass @@ -1079,7 +1079,7 @@ wr = weakref.ref(f) del f support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) def test_args_error(self): # Issue #17275 @@ -1375,7 +1375,7 @@ wr = weakref.ref(f) del f support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) with self.open(support.TESTFN, "rb") as f: self.assertEqual(f.read(), b"123xxx") @@ -2005,7 +2005,7 @@ t = self.TextIOWrapper(b, encoding="utf-8") self.assertEqual(t.encoding, "utf-8") t = self.TextIOWrapper(b) - self.assertTrue(t.encoding is not None) + self.assertIsNotNone(t.encoding) codecs.lookup(t.encoding) def test_encoding_errors_reading(self): @@ -2618,7 +2618,7 @@ wr = weakref.ref(t) del t support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) with self.open(support.TESTFN, "rb") as f: self.assertEqual(f.read(), b"456def") @@ -2764,7 +2764,7 @@ def test___all__(self): for name in self.io.__all__: obj = getattr(self.io, name, None) - self.assertTrue(obj is not None, name) + self.assertIsNotNone(obj, name) if name == "open": continue elif "error" in name.lower() or name == "UnsupportedOperation": @@ -2853,7 +2853,7 @@ wr = weakref.ref(c) del c, b support.gc_collect() - self.assertTrue(wr() is None, wr) + self.assertIsNone(wr(), wr) def test_abcs(self): # Test the visible base classes are ABCs. @@ -3005,7 +3005,7 @@ received += iter(rf.read, None) sent, received = b''.join(sent), b''.join(received) - self.assertTrue(sent == received) + self.assertEqual(sent, received) self.assertTrue(wf.closed) self.assertTrue(rf.closed) diff -r ff471d8526a8 Lib/test/test_ipaddress.py --- a/Lib/test/test_ipaddress.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_ipaddress.py Sat Nov 16 17:58:58 2013 +0200 @@ -877,13 +877,13 @@ 36893488147419103232) def testContains(self): - self.assertTrue(ipaddress.IPv4Interface('1.2.3.128/25') in + self.assertIn(ipaddress.IPv4Interface('1.2.3.128/25'), self.ipv4_network) - self.assertFalse(ipaddress.IPv4Interface('1.2.4.1/24') in + self.assertNotIn(ipaddress.IPv4Interface('1.2.4.1/24'), self.ipv4_network) # We can test addresses and string as well. addr1 = ipaddress.IPv4Address('1.2.3.37') - self.assertTrue(addr1 in self.ipv4_network) + self.assertIn(addr1, self.ipv4_network) # issue 61, bad network comparison on like-ip'd network objects # with identical broadcast addresses. self.assertFalse(ipaddress.IPv4Network('1.1.0.0/16').__contains__( @@ -1473,8 +1473,8 @@ dummy[self.ipv6_address] = None dummy[ip1] = None dummy[ip2] = None - self.assertTrue(self.ipv4_address in dummy) - self.assertTrue(ip2 in dummy) + self.assertIn(self.ipv4_address, dummy) + self.assertIn(ip2, dummy) def testIPBases(self): net = self.ipv4_network @@ -1587,9 +1587,9 @@ def testNetworkElementCaching(self): # V4 - make sure we're empty - self.assertFalse('network_address' in self.ipv4_network._cache) - self.assertFalse('broadcast_address' in self.ipv4_network._cache) - self.assertFalse('hostmask' in self.ipv4_network._cache) + self.assertNotIn('network_address', self.ipv4_network._cache) + self.assertNotIn('broadcast_address', self.ipv4_network._cache) + self.assertNotIn('hostmask', self.ipv4_network._cache) # V4 - populate and test self.assertEqual(self.ipv4_network.network_address, @@ -1600,12 +1600,12 @@ ipaddress.IPv4Address('0.0.0.255')) # V4 - check we're cached - self.assertTrue('broadcast_address' in self.ipv4_network._cache) - self.assertTrue('hostmask' in self.ipv4_network._cache) + self.assertIn('broadcast_address', self.ipv4_network._cache) + self.assertIn('hostmask', self.ipv4_network._cache) # V6 - make sure we're empty - self.assertFalse('broadcast_address' in self.ipv6_network._cache) - self.assertFalse('hostmask' in self.ipv6_network._cache) + self.assertNotIn('broadcast_address', self.ipv6_network._cache) + self.assertNotIn('hostmask', self.ipv6_network._cache) # V6 - populate and test self.assertEqual(self.ipv6_network.network_address, @@ -1625,11 +1625,11 @@ ipaddress.IPv6Address('::ffff:ffff:ffff:ffff')) # V6 - check we're cached - self.assertTrue('broadcast_address' in self.ipv6_network._cache) - self.assertTrue('hostmask' in self.ipv6_network._cache) + self.assertIn('broadcast_address', self.ipv6_network._cache) + self.assertIn('hostmask', self.ipv6_network._cache) self.assertTrue( 'broadcast_address' in self.ipv6_interface.network._cache) - self.assertTrue('hostmask' in self.ipv6_interface.network._cache) + self.assertIn('hostmask', self.ipv6_interface.network._cache) def testTeredo(self): # stolen from wikipedia diff -r ff471d8526a8 Lib/test/test_iter.py --- a/Lib/test/test_iter.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_iter.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_itertools.py --- a/Lib/test/test_itertools.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_itertools.py Sat Nov 16 17:58:58 2013 +0200 @@ -324,7 +324,7 @@ if n == 0 or r <= 1: self.assertEqual(result, regular_combs) # cases that should be identical else: - self.assertTrue(set(result) >= set(regular_combs)) # rest should be supersets of regular combs + self.assertGreaterEqual(set(result), set(regular_combs)) # rest should be supersets of regular combs for c in result: self.assertEqual(len(c), r) # r-length combinations @@ -1189,7 +1189,7 @@ # tee pass-through to copyable iterator a, b = tee('abc') c, d = tee(a) - self.assertTrue(a is c) + self.assertIs(a, c) # test tee_new t1, t2 = tee('abc') @@ -1197,7 +1197,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 ff471d8526a8 Lib/test/test_json/test_decode.py --- a/Lib/test/test_json/test_decode.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_json/test_decode.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_kqueue.py --- a/Lib/test/test_kqueue.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_kqueue.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_list.py --- a/Lib/test/test_list.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_list.py Sat Nov 16 17:58:58 2013 +0200 @@ -10,7 +10,7 @@ l0_3 = [0, 1, 2, 3] l0_3_bis = list(l0_3) self.assertEqual(l0_3, l0_3_bis) - self.assertTrue(l0_3 is not l0_3_bis) + self.assertIsNot(l0_3, l0_3_bis) self.assertEqual(list(()), []) self.assertEqual(list((0, 1, 2, 3)), [0, 1, 2, 3]) self.assertEqual(list(''), []) @@ -40,11 +40,11 @@ def test_truth(self): super().test_truth() - self.assertTrue(not []) + self.assertFalse([]) self.assertTrue([42]) def test_identity(self): - self.assertTrue([] is not []) + self.assertIsNot([], []) def test_len(self): super().test_len() diff -r ff471d8526a8 Lib/test/test_logging.py --- a/Lib/test/test_logging.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_logging.py Sat Nov 16 17:58:58 2013 +0200 @@ -3001,7 +3001,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 ff471d8526a8 Lib/test/test_long.py --- a/Lib/test/test_long.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_long.py Sat Nov 16 17:58:58 2013 +0200 @@ -130,7 +130,7 @@ # The sign of the number is also random. def getran(self, ndigits): - self.assertTrue(ndigits > 0) + self.assertGreater(ndigits, 0) nbits_hi = ndigits * SHIFT nbits_lo = nbits_hi - SHIFT + 1 answer = 0 @@ -865,21 +865,21 @@ def test_small_ints(self): for i in range(-5, 257): - self.assertTrue(i is i + 0) - self.assertTrue(i is i * 1) - self.assertTrue(i is i - 0) - self.assertTrue(i is i // 1) - self.assertTrue(i is i & -1) - self.assertTrue(i is i | 0) - self.assertTrue(i is i ^ 0) - self.assertTrue(i is ~~i) - self.assertTrue(i is i**1) - self.assertTrue(i is int(str(i))) - self.assertTrue(i is i<<2>>2, str(i)) + self.assertIs(i, i + 0) + self.assertIs(i, i * 1) + self.assertIs(i, i - 0) + self.assertIs(i, i // 1) + self.assertIs(i, i & -1) + self.assertIs(i, i | 0) + self.assertIs(i, i ^ 0) + self.assertIs(i, ~~i) + self.assertIs(i, i**1) + self.assertIs(i, int(str(i))) + self.assertIs(i, i<<2>>2, str(i)) # corner cases i = 1 << 70 - self.assertTrue(i - i is 0) - self.assertTrue(0 * i is 0) + self.assertIs(i - i, 0) + self.assertIs(0 * i, 0) def test_bit_length(self): tiny = 1e-10 @@ -926,7 +926,7 @@ got = round(k+offset, -1) expected = v+offset self.assertEqual(got, expected) - self.assertTrue(type(got) is int) + self.assertIs(type(got), int) # larger second argument self.assertEqual(round(-150, -2), -200) @@ -965,7 +965,7 @@ got = round(10**k + 324678, -3) expect = 10**k + 325000 self.assertEqual(got, expect) - self.assertTrue(type(got) is int) + self.assertIs(type(got), int) # nonnegative second argument: round(x, n) should just return x for n in range(5): @@ -973,7 +973,7 @@ x = random.randrange(-10000, 10000) got = round(x, n) self.assertEqual(got, x) - self.assertTrue(type(got) is int) + self.assertIs(type(got), int) for huge_n in 2**31-1, 2**31, 2**63-1, 2**63, 2**100, 10**100: self.assertEqual(round(8979323, huge_n), 8979323) @@ -982,7 +982,7 @@ x = random.randrange(-10000, 10000) got = round(x) self.assertEqual(got, x) - self.assertTrue(type(got) is int) + self.assertIs(type(got), int) # bad second argument bad_exponents = ('brian', 2.0, 0j, None) @@ -1187,15 +1187,15 @@ class myint(int): pass - self.assertTrue(type(myint.from_bytes(b'\x00', 'big')) is myint) + self.assertIs(type(myint.from_bytes(b'\x00', 'big')), myint) self.assertEqual(myint.from_bytes(b'\x01', 'big'), 1) - self.assertTrue( - type(myint.from_bytes(b'\x00', 'big', signed=False)) is myint) + self.assertIs( + type(myint.from_bytes(b'\x00', 'big', signed=False)), myint) self.assertEqual(myint.from_bytes(b'\x01', 'big', signed=False), 1) - self.assertTrue(type(myint.from_bytes(b'\x00', 'little')) is myint) + self.assertIs(type(myint.from_bytes(b'\x00', 'little')), myint) self.assertEqual(myint.from_bytes(b'\x01', 'little'), 1) - self.assertTrue(type(myint.from_bytes( - b'\x00', 'little', signed=False)) is myint) + self.assertIs(type(myint.from_bytes( + b'\x00', 'little', signed=False)), myint) self.assertEqual(myint.from_bytes(b'\x01', 'little', signed=False), 1) self.assertEqual( int.from_bytes([255, 0, 0], 'big', signed=True), -65536) diff -r ff471d8526a8 Lib/test/test_mailbox.py --- a/Lib/test/test_mailbox.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_mailbox.py Sat Nov 16 17:58:58 2013 +0200 @@ -233,7 +233,7 @@ msg = self._box.get(key0) self.assertEqual(msg['from'], 'foo') self.assertEqual(msg.get_payload(), '0\n') - self.assertIs(self._box.get('foo'), None) + self.assertIsNone(self._box.get('foo')) self.assertIs(self._box.get('foo', False), False) self._box.close() self._box = self._factory(self._path) @@ -760,7 +760,7 @@ "tmp")), "File in wrong location: '%s'" % head) match = pattern.match(tail) - self.assertIsNot(match, None, "Invalid file name: '%s'" % tail) + self.assertIsNotNone(match, "Invalid file name: '%s'" % tail) groups = match.groups() if previous_groups is not None: self.assertGreaterEqual(int(groups[0]), int(previous_groups[0]), @@ -1405,7 +1405,7 @@ eMM = email.message_from_string(_sample_message) msg = self._factory(_sample_message) for attr in eMM.__dict__: - self.assertTrue(attr in msg.__dict__, + self.assertIn(attr, msg.__dict__, '{} attribute does not exist'.format(attr)) def test_become_message(self): @@ -1622,19 +1622,19 @@ msg = mailbox.BabylMessage(_sample_message) visible = msg.get_visible() self.assertEqual(visible.keys(), []) - self.assertIs(visible.get_payload(), None) + self.assertIsNone(visible.get_payload()) visible['User-Agent'] = 'FooBar 1.0' visible['X-Whatever'] = 'Blah' self.assertEqual(msg.get_visible().keys(), []) msg.set_visible(visible) visible = msg.get_visible() - self.assertTrue(visible.keys() == ['User-Agent', 'X-Whatever']) - self.assertTrue(visible['User-Agent'] == 'FooBar 1.0') + self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever']) + self.assertEqual(visible['User-Agent'], 'FooBar 1.0') self.assertEqual(visible['X-Whatever'], 'Blah') - self.assertIs(visible.get_payload(), None) + self.assertIsNone(visible.get_payload()) msg.update_visible() self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever']) - self.assertIs(visible.get_payload(), None) + self.assertIsNone(visible.get_payload()) visible = msg.get_visible() self.assertEqual(visible.keys(), ['User-Agent', 'Date', 'From', 'To', 'Subject']) @@ -2156,34 +2156,34 @@ self.mbox = mailbox.Maildir(support.TESTFN) #self.assertTrue(hasattr(self.mbox, "boxes")) #self.assertEqual(len(self.mbox.boxes), 0) - self.assertIs(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) + self.assertIsNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) def test_nonempty_maildir_cur(self): self.createMessage("cur") self.mbox = mailbox.Maildir(support.TESTFN) #self.assertEqual(len(self.mbox.boxes), 1) - self.assertIsNot(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) + self.assertIsNotNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) def test_nonempty_maildir_new(self): self.createMessage("new") self.mbox = mailbox.Maildir(support.TESTFN) #self.assertEqual(len(self.mbox.boxes), 1) - self.assertIsNot(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) + self.assertIsNotNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) def test_nonempty_maildir_both(self): self.createMessage("cur") self.createMessage("new") self.mbox = mailbox.Maildir(support.TESTFN) #self.assertEqual(len(self.mbox.boxes), 2) - self.assertIsNot(self.mbox.next(), None) - self.assertIsNot(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) - self.assertIs(self.mbox.next(), None) + self.assertIsNotNone(self.mbox.next()) + self.assertIsNotNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) + self.assertIsNone(self.mbox.next()) ## End: tests from the original module (for backward compatibility). diff -r ff471d8526a8 Lib/test/test_memoryio.py --- a/Lib/test/test_memoryio.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_memoryio.py Sat Nov 16 17:58:58 2013 +0200 @@ -634,7 +634,8 @@ self.assertEqual(len(state), 3) bytearray(state[0]) # Check if state[0] supports the buffer interface. self.assertIsInstance(state[1], int) - self.assertTrue(isinstance(state[2], dict) or state[2] is None) + if state[2] is not None: + self.assertIsInstance(state[2], dict) memio.close() self.assertRaises(ValueError, memio.__getstate__) @@ -690,7 +691,8 @@ self.assertIsInstance(state[0], str) self.assertIsInstance(state[1], str) self.assertIsInstance(state[2], int) - self.assertTrue(isinstance(state[3], dict) or state[3] is None) + if state[3] is not None: + self.assertIsInstance(state[3], dict) memio.close() self.assertRaises(ValueError, memio.__getstate__) diff -r ff471d8526a8 Lib/test/test_memoryview.py --- a/Lib/test/test_memoryview.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_memoryview.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_minidom.py --- a/Lib/test/test_minidom.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_minidom.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_module.py --- a/Lib/test/test_module.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_module.py Sat Nov 16 17:58:58 2013 +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__ @@ -70,7 +70,7 @@ self.assertEqual(foo.__dict__, {"__name__": "foo", "__doc__": "foodoc", "bar": 42, "__loader__": None, "__package__": None}) - self.assertTrue(foo.__dict__ is d) + self.assertIs(foo.__dict__, d) def test_dont_clear_dict(self): # See issue 7140. diff -r ff471d8526a8 Lib/test/test_namespace_pkgs.py --- a/Lib/test/test_namespace_pkgs.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_namespace_pkgs.py Sat Nov 16 17:58:58 2013 +0200 @@ -300,7 +300,7 @@ self.assertTrue(self.loader.is_package('foo')) def test_get_code(self): - self.assertTrue(isinstance(self.loader.get_code('foo'), types.CodeType)) + self.assertIsInstance(self.loader.get_code('foo'), types.CodeType) def test_get_source(self): self.assertEqual(self.loader.get_source('foo'), '') diff -r ff471d8526a8 Lib/test/test_normalization.py --- a/Lib/test/test_normalization.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_normalization.py Sat Nov 16 17:58:58 2013 +0200 @@ -70,16 +70,26 @@ continue # Perform tests - self.assertTrue(c2 == NFC(c1) == NFC(c2) == NFC(c3), line) - self.assertTrue(c4 == NFC(c4) == NFC(c5), line) - self.assertTrue(c3 == NFD(c1) == NFD(c2) == NFD(c3), line) - self.assertTrue(c5 == NFD(c4) == NFD(c5), line) - self.assertTrue(c4 == NFKC(c1) == NFKC(c2) == \ - NFKC(c3) == NFKC(c4) == NFKC(c5), - line) - self.assertTrue(c5 == NFKD(c1) == NFKD(c2) == \ - NFKD(c3) == NFKD(c4) == NFKD(c5), - line) + self.assertEqual(NFC(c1), c2, line) + self.assertEqual(NFC(c2), c2, line) + self.assertEqual(NFC(c3), c2, line) + self.assertEqual(NFC(c4), c4, line) + self.assertEqual(NFC(c5), c4, line) + self.assertEqual(NFD(c1), c3, line) + self.assertEqual(NFD(c2), c3, line) + self.assertEqual(NFD(c3), c3, line) + self.assertEqual(NFD(c4), c5, line) + self.assertEqual(NFD(c5), c5, line) + self.assertEqual(NFKC(c1), c4, line) + self.assertEqual(NFKC(c2), c4, line) + self.assertEqual(NFKC(c3), c4, line) + self.assertEqual(NFKC(c4), c4, line) + self.assertEqual(NFKC(c5), c4, line) + self.assertEqual(NFKD(c1), c5, line) + self.assertEqual(NFKD(c2), c5, line) + self.assertEqual(NFKD(c3), c5, line) + self.assertEqual(NFKD(c4), c5, line) + self.assertEqual(NFKD(c5), c5, line) # Record part 1 data if part == "@Part1": @@ -90,7 +100,10 @@ X = chr(c) if X in part1_data: continue - self.assertTrue(X == NFC(X) == NFD(X) == NFKC(X) == NFKD(X), c) + self.assertEqual(NFC(X), X, c) + self.assertEqual(NFD(X), X, c) + self.assertEqual(NFKC(X), X, c) + self.assertEqual(NFKD(X), X, c) def test_bug_834676(self): # Check for bug 834676 diff -r ff471d8526a8 Lib/test/test_operator.py --- a/Lib/test/test_operator.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_operator.py Sat Nov 16 17:58:58 2013 +0200 @@ -118,63 +118,63 @@ operator = self.module self.assertRaises(TypeError, operator.add) self.assertRaises(TypeError, operator.add, None, None) - self.assertTrue(operator.add(3, 4) == 7) + self.assertEqual(operator.add(3, 4), 7) def test_bitwise_and(self): operator = self.module self.assertRaises(TypeError, operator.and_) self.assertRaises(TypeError, operator.and_, None, None) - self.assertTrue(operator.and_(0xf, 0xa) == 0xa) + self.assertEqual(operator.and_(0xf, 0xa), 0xa) def test_concat(self): operator = self.module self.assertRaises(TypeError, operator.concat) self.assertRaises(TypeError, operator.concat, None, None) - self.assertTrue(operator.concat('py', 'thon') == 'python') - self.assertTrue(operator.concat([1, 2], [3, 4]) == [1, 2, 3, 4]) - self.assertTrue(operator.concat(Seq1([5, 6]), Seq1([7])) == [5, 6, 7]) - self.assertTrue(operator.concat(Seq2([5, 6]), Seq2([7])) == [5, 6, 7]) + self.assertEqual(operator.concat('py', 'thon'), 'python') + self.assertEqual(operator.concat([1, 2], [3, 4]), [1, 2, 3, 4]) + self.assertEqual(operator.concat(Seq1([5, 6]), Seq1([7])), [5, 6, 7]) + self.assertEqual(operator.concat(Seq2([5, 6]), Seq2([7])), [5, 6, 7]) self.assertRaises(TypeError, operator.concat, 13, 29) def test_countOf(self): operator = self.module self.assertRaises(TypeError, operator.countOf) self.assertRaises(TypeError, operator.countOf, None, None) - self.assertTrue(operator.countOf([1, 2, 1, 3, 1, 4], 3) == 1) - self.assertTrue(operator.countOf([1, 2, 1, 3, 1, 4], 5) == 0) + self.assertEqual(operator.countOf([1, 2, 1, 3, 1, 4], 3), 1) + self.assertEqual(operator.countOf([1, 2, 1, 3, 1, 4], 5), 0) def test_delitem(self): operator = self.module a = [4, 3, 2, 1] self.assertRaises(TypeError, operator.delitem, a) self.assertRaises(TypeError, operator.delitem, a, None) - self.assertTrue(operator.delitem(a, 1) is None) - self.assertTrue(a == [4, 2, 1]) + self.assertIsNone(operator.delitem(a, 1)) + self.assertEqual(a, [4, 2, 1]) def test_floordiv(self): operator = self.module self.assertRaises(TypeError, operator.floordiv, 5) self.assertRaises(TypeError, operator.floordiv, None, None) - self.assertTrue(operator.floordiv(5, 2) == 2) + self.assertEqual(operator.floordiv(5, 2), 2) def test_truediv(self): operator = self.module self.assertRaises(TypeError, operator.truediv, 5) self.assertRaises(TypeError, operator.truediv, None, None) - self.assertTrue(operator.truediv(5, 2) == 2.5) + self.assertEqual(operator.truediv(5, 2), 2.5) def test_getitem(self): operator = self.module a = range(10) self.assertRaises(TypeError, operator.getitem) self.assertRaises(TypeError, operator.getitem, a, None) - self.assertTrue(operator.getitem(a, 2) == 2) + self.assertEqual(operator.getitem(a, 2), 2) def test_indexOf(self): operator = self.module self.assertRaises(TypeError, operator.indexOf) self.assertRaises(TypeError, operator.indexOf, None, None) - self.assertTrue(operator.indexOf([4, 3, 2, 1], 3) == 1) + self.assertEqual(operator.indexOf([4, 3, 2, 1], 3), 1) self.assertRaises(ValueError, operator.indexOf, [4, 3, 2, 1], 0) def test_invert(self): @@ -187,21 +187,21 @@ operator = self.module self.assertRaises(TypeError, operator.lshift) self.assertRaises(TypeError, operator.lshift, None, 42) - self.assertTrue(operator.lshift(5, 1) == 10) - self.assertTrue(operator.lshift(5, 0) == 5) + self.assertEqual(operator.lshift(5, 1), 10) + self.assertEqual(operator.lshift(5, 0), 5) self.assertRaises(ValueError, operator.lshift, 2, -1) def test_mod(self): operator = self.module self.assertRaises(TypeError, operator.mod) self.assertRaises(TypeError, operator.mod, None, 42) - self.assertTrue(operator.mod(5, 2) == 1) + self.assertEqual(operator.mod(5, 2), 1) def test_mul(self): operator = self.module self.assertRaises(TypeError, operator.mul) self.assertRaises(TypeError, operator.mul, None, None) - self.assertTrue(operator.mul(5, 2) == 10) + self.assertEqual(operator.mul(5, 2), 10) def test_neg(self): operator = self.module @@ -216,7 +216,7 @@ operator = self.module self.assertRaises(TypeError, operator.or_) self.assertRaises(TypeError, operator.or_, None, None) - self.assertTrue(operator.or_(0xa, 0x5) == 0xf) + self.assertEqual(operator.or_(0xa, 0x5), 0xf) def test_pos(self): operator = self.module @@ -239,8 +239,8 @@ operator = self.module self.assertRaises(TypeError, operator.rshift) self.assertRaises(TypeError, operator.rshift, None, 42) - self.assertTrue(operator.rshift(5, 1) == 2) - self.assertTrue(operator.rshift(5, 0) == 5) + self.assertEqual(operator.rshift(5, 1), 2) + self.assertEqual(operator.rshift(5, 0), 5) self.assertRaises(ValueError, operator.rshift, 2, -1) def test_contains(self): @@ -255,15 +255,15 @@ a = list(range(3)) self.assertRaises(TypeError, operator.setitem, a) self.assertRaises(TypeError, operator.setitem, a, None, None) - self.assertTrue(operator.setitem(a, 0, 2) is None) - self.assertTrue(a == [2, 1, 2]) + self.assertIsNone(operator.setitem(a, 0, 2)) + self.assertEqual(a, [2, 1, 2]) self.assertRaises(IndexError, operator.setitem, a, 4, 2) def test_sub(self): operator = self.module self.assertRaises(TypeError, operator.sub) self.assertRaises(TypeError, operator.sub, None, None) - self.assertTrue(operator.sub(5, 2) == 3) + self.assertEqual(operator.sub(5, 2), 3) def test_truth(self): operator = self.module @@ -281,7 +281,7 @@ operator = self.module self.assertRaises(TypeError, operator.xor) self.assertRaises(TypeError, operator.xor, None, None) - self.assertTrue(operator.xor(0xb, 0xc) == 0x7) + self.assertEqual(operator.xor(0xb, 0xc), 0x7) def test_is(self): operator = self.module diff -r ff471d8526a8 Lib/test/test_optparse.py --- a/Lib/test/test_optparse.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_optparse.py Sat Nov 16 17:58:58 2013 +0200 @@ -370,10 +370,10 @@ self.assertTrue(self.parser.has_option("--verbose")) def assertTrueremoved(self): - self.assertTrue(self.parser.get_option("-v") is None) - self.assertTrue(self.parser.get_option("--verbose") is None) - self.assertTrue(self.parser.get_option("-n") is None) - self.assertTrue(self.parser.get_option("--noisy") is None) + self.assertIsNone(self.parser.get_option("-v")) + self.assertIsNone(self.parser.get_option("--verbose")) + self.assertIsNone(self.parser.get_option("-n")) + self.assertIsNone(self.parser.get_option("--noisy")) self.assertFalse(self.parser.has_option("-v")) self.assertFalse(self.parser.has_option("--verbose")) @@ -797,13 +797,13 @@ (options, args) = self.assertParseOK(["-q"], {'verbose': 0}, []) - self.assertTrue(options.verbose is False) + self.assertIs(options.verbose, False) def test_bool_true(self): (options, args) = self.assertParseOK(["-v"], {'verbose': 1}, []) - self.assertTrue(options.verbose is True) + self.assertIs(options.verbose, True) def test_bool_flicker_on_and_off(self): self.assertParseOK(["-qvq", "-q", "-v"], @@ -1105,15 +1105,15 @@ if opt == "-x": self.assertEqual(option._short_opts, ["-x"]) self.assertEqual(option._long_opts, []) - self.assertTrue(parser_ is self.parser) - self.assertTrue(value is None) + self.assertIs(parser_, self.parser) + self.assertIsNone(value) self.assertEqual(vars(parser_.values), {'filename': None}) parser_.values.x = 42 elif opt == "--file": self.assertEqual(option._short_opts, ["-f"]) self.assertEqual(option._long_opts, ["--file"]) - self.assertTrue(parser_ is self.parser) + self.assertIs(parser_, self.parser) self.assertEqual(value, "foo") self.assertEqual(vars(parser_.values), {'filename': None, 'x': 42}) @@ -1151,7 +1151,7 @@ def process_tuple(self, option, opt, value, parser_, len, type): self.assertEqual(len, 3) - self.assertTrue(type is int) + self.assertIs(type, int) if opt == "-p": self.assertEqual(value, "1,2,3") @@ -1242,7 +1242,7 @@ option_list=options) def variable_args(self, option, opt, value, parser): - self.assertTrue(value is None) + self.assertIsNone(value) value = [] rargs = parser.rargs while rargs: @@ -1333,8 +1333,8 @@ verbose_opt = self.parser.get_option("--verbose") version_opt = self.parser.get_option("--version") - self.assertTrue(v_opt is version_opt) - self.assertTrue(v_opt is not verbose_opt) + self.assertIs(v_opt, version_opt) + self.assertIsNot(v_opt, verbose_opt) self.assertEqual(v_opt._long_opts, ["--version"]) self.assertEqual(version_opt._short_opts, ["-v"]) self.assertEqual(version_opt._long_opts, ["--version"]) diff -r ff471d8526a8 Lib/test/test_os.py --- a/Lib/test/test_os.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_os.py Sat Nov 16 17:58:58 2013 +0200 @@ -1985,7 +1985,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)) @@ -2008,7 +2008,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 ff471d8526a8 Lib/test/test_ossaudiodev.py --- a/Lib/test/test_ossaudiodev.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_ossaudiodev.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_peepholer.py --- a/Lib/test/test_peepholer.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_peepholer.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_pep247.py --- a/Lib/test/test_pep247.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_pep247.py Sat Nov 16 17:58:58 2013 +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): diff -r ff471d8526a8 Lib/test/test_pep3120.py --- a/Lib/test/test_pep3120.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_pep3120.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_pep380.py --- a/Lib/test/test_pep380.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_pep380.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_platform.py --- a/Lib/test/test_platform.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_platform.py Sat Nov 16 17:58:58 2013 +0200 @@ -195,7 +195,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 ff471d8526a8 Lib/test/test_poplib.py --- a/Lib/test/test_poplib.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_poplib.py Sat Nov 16 17:58:58 2013 +0200 @@ -456,7 +456,7 @@ serv.close() def testTimeoutDefault(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: pop = poplib.POP3(HOST, self.port) @@ -466,13 +466,13 @@ pop.sock.close() def testTimeoutNone(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: pop = poplib.POP3(HOST, self.port, timeout=None) finally: socket.setdefaulttimeout(None) - self.assertTrue(pop.sock.gettimeout() is None) + self.assertIsNone(pop.sock.gettimeout()) pop.sock.close() def testTimeoutValue(self): diff -r ff471d8526a8 Lib/test/test_posix.py --- a/Lib/test/test_posix.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_posix.py Sat Nov 16 17:58:58 2013 +0200 @@ -519,17 +519,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 ff471d8526a8 Lib/test/test_property.py --- a/Lib/test/test_property.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_property.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_pulldom.py --- a/Lib/test/test_pulldom.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_pulldom.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_pyexpat.py --- a/Lib/test/test_pyexpat.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_pyexpat.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_queue.py --- a/Lib/test/test_queue.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_queue.py Sat Nov 16 17:58:58 2013 +0200 @@ -108,7 +108,7 @@ for i in range(QUEUE_SIZE-1): q.put(i) self.assertTrue(q.qsize(), "Queue should not be empty") - self.assertTrue(not qfull(q), "Queue should not be full") + self.assertFalse(qfull(q), "Queue should not be full") last = 2 * QUEUE_SIZE full = 3 * 2 * QUEUE_SIZE q.put(last) @@ -131,7 +131,7 @@ # Empty it for i in range(QUEUE_SIZE): q.get() - self.assertTrue(not q.qsize(), "Queue should be empty") + self.assertFalse(q.qsize(), "Queue should be empty") try: q.get(block=0) self.fail("Didn't appear to block with an empty queue") @@ -308,7 +308,7 @@ q.put("last") self.assertTrue(qfull(q), "Queue should be full") q.get() - self.assertTrue(not qfull(q), "Queue should not be full") + self.assertFalse(qfull(q), "Queue should not be full") q.put("last") self.assertTrue(qfull(q), "Queue should be full") # Test a blocking put @@ -316,7 +316,7 @@ # Empty it for i in range(QUEUE_SIZE): q.get() - self.assertTrue(not q.qsize(), "Queue should be empty") + self.assertFalse(q.qsize(), "Queue should be empty") q.put("first") q.fail_next_get = True try: @@ -333,7 +333,7 @@ pass self.assertTrue(q.qsize(), "Queue should not be empty") q.get() - self.assertTrue(not q.qsize(), "Queue should be empty") + self.assertFalse(q.qsize(), "Queue should be empty") q.fail_next_get = True try: self.do_exceptional_blocking_test(q.get, (), q.put, ('empty',), @@ -344,7 +344,7 @@ # put succeeded, but get failed. self.assertTrue(q.qsize(), "Queue should not be empty") q.get() - self.assertTrue(not q.qsize(), "Queue should be empty") + self.assertFalse(q.qsize(), "Queue should be empty") def test_failing_queue(self): # Test to make sure a queue is functioning correctly. diff -r ff471d8526a8 Lib/test/test_raise.py --- a/Lib/test/test_raise.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_raise.py Sat Nov 16 17:58:58 2013 +0200 @@ -41,7 +41,7 @@ exc1 = e raise except IndexError as exc2: - self.assertTrue(exc1 is exc2) + self.assertIs(exc1, exc2) else: self.fail("No exception raised") @@ -85,7 +85,7 @@ except: raise ValueError() from None except ValueError as e: - self.assertTrue(isinstance(e.__context__, TypeError)) + self.assertIsInstance(e.__context__, TypeError) self.assertIsNone(e.__cause__) def test_with_reraise1(self): @@ -191,7 +191,7 @@ try: raise IndexError from cause except IndexError as e: - self.assertTrue(e.__cause__ is cause) + self.assertIs(e.__cause__, cause) else: self.fail("No exception raised") @@ -297,7 +297,7 @@ finally: raise OSError except OSError as e: - self.assertTrue(e.__context__ is None) + self.assertIsNone(e.__context__) else: self.fail("No exception raised") @@ -334,7 +334,7 @@ except ZeroDivisionError as e: raise e except ZeroDivisionError as e: - self.assertTrue(e.__context__ is None, e.__context__) + self.assertIsNone(e.__context__) def test_reraise_cycle_broken(self): # Non-trivial context cycles (through re-raising a previous exception) @@ -348,7 +348,7 @@ except ZeroDivisionError: raise a except NameError as e: - self.assertTrue(e.__context__.__context__ is None) + self.assertIsNone(e.__context__.__context__) def test_3118(self): # deleting the generator caused the __context__ to be cleared diff -r ff471d8526a8 Lib/test/test_re.py --- a/Lib/test/test_re.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_re.py Sat Nov 16 17:58:58 2013 +0200 @@ -867,7 +867,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 ff471d8526a8 Lib/test/test_richcmp.py --- a/Lib/test/test_richcmp.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_richcmp.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_sax.py --- a/Lib/test/test_sax.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_sax.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_selectors.py --- a/Lib/test/test_selectors.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_selectors.py Sat Nov 16 17:58:58 2013 +0200 @@ -203,7 +203,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)) @@ -231,7 +231,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 ff471d8526a8 Lib/test/test_set.py --- a/Lib/test/test_set.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_set.py Sat Nov 16 17:58:58 2013 +0200 @@ -243,7 +243,7 @@ # Set iterators unpickle as list iterators due to the # undefined order of set items. # self.assertEqual(type(itorg), type(it)) - self.assertTrue(isinstance(it, collections.abc.Iterator)) + self.assertIsInstance(it, collections.abc.Iterator) self.assertEqual(self.thetype(it), data) it = pickle.loads(d) @@ -359,7 +359,7 @@ obj.x = iter(container) del obj, container gc.collect() - self.assertTrue(ref() is None, "Cycle was not collected") + self.assertIsNone(ref(), "Cycle was not collected") class TestSet(TestJointOps, unittest.TestCase): thetype = set @@ -433,7 +433,7 @@ try: self.s.remove(key) except KeyError as e: - self.assertTrue(e.args[0] is key, + self.assertIs(e.args[0], key, "KeyError should be {0}, not {1}".format(key, e.args[0])) else: @@ -1492,7 +1492,7 @@ set_list = sorted(self.set, key=repr) self.assertEqual(len(dup_list), len(set_list)) for i in range(len(dup_list)): - self.assertTrue(dup_list[i] is set_list[i]) + self.assertIs(dup_list[i], set_list[i]) def test_deep_copy(self): dup = copy.deepcopy(self.set) diff -r ff471d8526a8 Lib/test/test_shutil.py --- a/Lib/test/test_shutil.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_shutil.py Sat Nov 16 17:58:58 2013 +0200 @@ -383,8 +383,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 @@ -1635,7 +1635,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"',)) @@ -1657,7 +1657,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',)) @@ -1680,7 +1680,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 ff471d8526a8 Lib/test/test_slice.py --- a/Lib/test/test_slice.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_slice.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_smtplib.py --- a/Lib/test/test_smtplib.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_smtplib.py Sat Nov 16 17:58:58 2013 +0200 @@ -96,7 +96,7 @@ def testTimeoutDefault(self): mock_socket.reply_with(b"220 Hola mundo") - self.assertTrue(mock_socket.getdefaulttimeout() is None) + self.assertIsNone(mock_socket.getdefaulttimeout()) mock_socket.setdefaulttimeout(30) self.assertEqual(mock_socket.getdefaulttimeout(), 30) try: @@ -108,13 +108,13 @@ def testTimeoutNone(self): mock_socket.reply_with(b"220 Hola mundo") - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) socket.setdefaulttimeout(30) try: smtp = smtplib.SMTP(HOST, self.port, timeout=None) finally: socket.setdefaulttimeout(None) - self.assertTrue(smtp.sock.gettimeout() is None) + self.assertIsNone(smtp.sock.gettimeout()) smtp.close() def testTimeoutValue(self): diff -r ff471d8526a8 Lib/test/test_socket.py --- a/Lib/test/test_socket.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_socket.py Sat Nov 16 17:58:58 2013 +0200 @@ -746,7 +746,7 @@ except OSError: # Probably name lookup wasn't set up right; skip this test return - self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.") + self.assertGreaterEqual(ip.find('.'), 0, "Error resolving host to ip.") try: hname, aliases, ipaddrs = socket.gethostbyaddr(ip) except OSError: @@ -1116,7 +1116,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() @@ -1124,7 +1124,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 @@ -3732,7 +3732,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.") # Issue 15989 if _testcapi.UINT_MAX < _testcapi.ULONG_MAX: self.serv.setblocking(_testcapi.UINT_MAX + 1) @@ -3758,7 +3758,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 @@ -4364,7 +4364,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)) @@ -4376,7 +4376,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 ff471d8526a8 Lib/test/test_ssl.py --- a/Lib/test/test_ssl.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_ssl.py Sat Nov 16 17:58:58 2013 +0200 @@ -2257,7 +2257,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 @@ -2278,7 +2278,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 ff471d8526a8 Lib/test/test_strptime.py --- a/Lib/test/test_strptime.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_strptime.py Sat Nov 16 17:58:58 2013 +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) @@ -246,7 +246,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])) @@ -264,7 +264,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])) @@ -306,11 +306,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") @@ -371,7 +371,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)) @@ -423,7 +423,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)) @@ -446,7 +446,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)) @@ -459,7 +459,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 ff471d8526a8 Lib/test/test_structseq.py --- a/Lib/test/test_structseq.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_structseq.py Sat Nov 16 17:58:58 2013 +0200 @@ -70,11 +70,11 @@ t1 = time.gmtime() t2 = type(t1)(t1) self.assertEqual(t1, t2) - self.assertTrue(not (t1 < t2)) + self.assertFalse(t1 < t2) self.assertTrue(t1 <= t2) - self.assertTrue(not (t1 > t2)) + self.assertFalse(t1 > t2) self.assertTrue(t1 >= t2) - self.assertTrue(not (t1 != t2)) + self.assertFalse(t1 != t2) def test_fields(self): t = time.gmtime() diff -r ff471d8526a8 Lib/test/test_symtable.py --- a/Lib/test/test_symtable.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_symtable.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_sys.py --- a/Lib/test/test_sys.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_sys.py Sat Nov 16 17:58:58 2013 +0200 @@ -44,7 +44,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) @@ -200,7 +200,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) @@ -380,7 +380,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 @@ -411,7 +411,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) @@ -425,8 +425,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) @@ -472,7 +472,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'): @@ -496,9 +496,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 ff471d8526a8 Lib/test/test_sysconfig.py --- a/Lib/test/test_sysconfig.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_sysconfig.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_telnetlib.py --- a/Lib/test/test_telnetlib.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_telnetlib.py Sat Nov 16 17:58:58 2013 +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): @@ -205,7 +205,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() @@ -307,7 +307,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 ff471d8526a8 Lib/test/test_tempfile.py --- a/Lib/test/test_tempfile.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_tempfile.py Sat Nov 16 17:58:58 2013 +0200 @@ -91,7 +91,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) @@ -168,7 +168,7 @@ cand = tempfile._candidate_tempdir_list() - self.assertFalse(len(cand) == 0) + self.assertNotEqual(len(cand), 0) for c in cand: self.assertIsInstance(c, str) @@ -253,7 +253,7 @@ a = tempfile._get_candidate_names() b = tempfile._get_candidate_names() - self.assertTrue(a is b) + self.assertIs(a, b) @contextlib.contextmanager @@ -430,7 +430,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 @@ -456,8 +456,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) @@ -476,7 +477,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 @@ -833,7 +834,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 ff471d8526a8 Lib/test/test_threading.py --- a/Lib/test/test_threading.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_threading.py Sat Nov 16 17:58:58 2013 +0200 @@ -60,7 +60,7 @@ self.nrunning.inc() if verbose: print(self.nrunning.get(), 'tasks are running') - self.testcase.assertTrue(self.nrunning.get() <= 3) + self.testcase.assertLessEqual(self.nrunning.get(), 3) time.sleep(delay) if verbose: @@ -68,7 +68,7 @@ with self.mutex: self.nrunning.dec() - self.testcase.assertTrue(self.nrunning.get() >= 0) + self.testcase.assertGreaterEqual(self.nrunning.get(), 0) if verbose: print('%s is finished. %d tasks are running' % (self.name, self.nrunning.get())) @@ -111,8 +111,9 @@ for t in threads: t.join() self.assertTrue(not t.is_alive()) + self.assertFalse(t.is_alive()) self.assertNotEqual(t.ident, 0) - self.assertFalse(t.ident is None) + self.assertIsNotNone(t.ident) self.assertTrue(re.match('', repr(t))) if verbose: @@ -121,7 +122,7 @@ def test_ident_of_no_threading_threads(self): # The ident still must work for the main thread and dummy threads. - self.assertFalse(threading.currentThread().ident is None) + self.assertIsNotNone(threading.currentThread().ident) def f(): ident.append(threading.currentThread().ident) done.set() @@ -129,7 +130,7 @@ ident = [] _thread.start_new_thread(f, ()) done.wait() - self.assertFalse(ident[0] is None) + self.assertIsNotNone(ident[0]) # Kill the "immortal" _DummyThread del threading._active[ident[0]] @@ -246,7 +247,7 @@ self.assertTrue(ret) if verbose: print(" verifying worker hasn't exited") - self.assertTrue(not t.finished) + self.assertFalse(t.finished) if verbose: print(" attempting to raise asynch exception in worker") result = set_async_exc(ctypes.c_long(t.id), exception) @@ -417,9 +418,9 @@ def test_repr_daemon(self): t = threading.Thread() - self.assertFalse('daemon' in repr(t)) + self.assertNotIn('daemon', repr(t)) t.daemon = True - self.assertTrue('daemon' in repr(t)) + self.assertIn('daemon', repr(t)) def test_deamon_param(self): t = threading.Thread() @@ -571,7 +572,7 @@ tstate_lock.release() self.assertFalse(t.is_alive()) # And verify the thread disposed of _tstate_lock. - self.assertTrue(t._tstate_lock is None) + self.assertIsNone(t._tstate_lock) def test_repr_stopped(self): # Verify that "stopped" shows up in repr(Thread) appropriately. diff -r ff471d8526a8 Lib/test/test_threading_local.py --- a/Lib/test/test_threading_local.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_threading_local.py Sat Nov 16 17:58:58 2013 +0200 @@ -194,7 +194,7 @@ wr = weakref.ref(x) del x gc.collect() - self.assertIs(wr(), None) + self.assertIsNone(wr()) class ThreadLocalTest(unittest.TestCase, BaseLocalTest): diff -r ff471d8526a8 Lib/test/test_time.py --- a/Lib/test/test_time.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_time.py Sat Nov 16 17:58:58 2013 +0200 @@ -290,8 +290,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) @@ -633,11 +633,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]) @@ -672,8 +672,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 ff471d8526a8 Lib/test/test_trace.py --- a/Lib/test/test_trace.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_trace.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_traceback.py --- a/Lib/test/test_traceback.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_traceback.py Sat Nov 16 17:58:58 2013 +0200 @@ -36,15 +36,15 @@ err = self.get_exception_format(self.syntax_error_with_caret, SyntaxError) self.assertEqual(len(err), 4) - self.assertTrue(err[1].strip() == "return x!") + self.assertEqual(err[1].strip(), "return x!") self.assertIn("^", err[2]) # third line has caret self.assertEqual(err[1].find("!"), err[2].find("^")) # in the right place err = self.get_exception_format(self.syntax_error_with_caret_2, SyntaxError) self.assertIn("^", err[2]) # third line has caret - self.assertTrue(err[2].count('\n') == 1) # and no additional newline - self.assertTrue(err[1].find("+") == err[2].find("^")) # in the right place + self.assertEqual(err[2].count('\n'), 1) # and no additional newline + self.assertEqual(err[1].find("+"), err[2].find("^")) # in the right place def test_nocaret(self): exc = SyntaxError("error", ("x.py", 23, None, "bad syntax")) @@ -130,7 +130,7 @@ self.assertTrue(stdout[2].endswith(err_line), "Invalid traceback line: {0!r} instead of {1!r}".format( stdout[2], err_line)) - self.assertTrue(stdout[3] == err_msg, + self.assertEqual(stdout[3], err_msg, "Invalid error message: {0!r} instead of {1!r}".format( stdout[3], err_msg)) diff -r ff471d8526a8 Lib/test/test_tuple.py --- a/Lib/test/test_tuple.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_tuple.py Sat Nov 16 17:58:58 2013 +0200 @@ -12,7 +12,7 @@ self.assertEqual(tuple(), ()) t0_3 = (0, 1, 2, 3) t0_3_bis = tuple(t0_3) - self.assertTrue(t0_3 is t0_3_bis) + self.assertIs(t0_3, t0_3_bis) self.assertEqual(tuple([]), ()) self.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3)) self.assertEqual(tuple(''), ()) @@ -20,7 +20,7 @@ def test_truth(self): super().test_truth() - self.assertTrue(not ()) + self.assertFalse(()) self.assertTrue((42, )) def test_len(self): @@ -34,14 +34,14 @@ u = (0, 1) u2 = u u += (2, 3) - self.assertTrue(u is not u2) + self.assertIsNot(u, u2) def test_imul(self): super().test_imul() u = (0, 1) u2 = u u *= 3 - self.assertTrue(u is not u2) + self.assertIsNot(u, u2) def test_tupleresizebug(self): # Check that a specific bug in _PyTuple_Resize() is squashed. @@ -72,7 +72,7 @@ inps = base + [(i, j) for i in base for j in xp] + \ [(i, j) for i in xp for j in base] + xp + list(zip(base)) collisions = len(inps) - len(set(map(hash, inps))) - self.assertTrue(collisions <= 15) + self.assertLessEqual(collisions, 15) def test_repr(self): l0 = tuple() diff -r ff471d8526a8 Lib/test/test_types.py --- a/Lib/test/test_types.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_types.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_unicode.py --- a/Lib/test/test_unicode.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_unicode.py Sat Nov 16 17:58:58 2013 +0200 @@ -53,7 +53,7 @@ method = getattr(object, methodname) realresult = method(*args) self.assertEqual(realresult, result) - self.assertTrue(type(realresult) is type(result)) + self.assertIs(type(realresult), type(result)) # if the original is returned make sure that # this doesn't happen with subclasses @@ -65,7 +65,7 @@ method = getattr(object, methodname) realresult = method(*args) self.assertEqual(realresult, result) - self.assertTrue(object is not realresult) + self.assertIsNot(object, realresult) def test_literals(self): self.assertEqual('\xff', '\u00ff') diff -r ff471d8526a8 Lib/test/test_unicode_file.py --- a/Lib/test/test_unicode_file.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_unicode_file.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_unicodedata.py --- a/Lib/test/test_unicodedata.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_unicodedata.py Sat Nov 16 17:58:58 2013 +0200 @@ -255,7 +255,7 @@ if dec != -1: self.assertEqual(dec, self.db.numeric(c)) count += 1 - self.assertTrue(count >= 10) # should have tested at least the ASCII digits + self.assertGreaterEqual(count, 10) # should have tested at least the ASCII digits def test_digit_numeric_consistent(self): # Test that digit and numeric are consistent, @@ -268,7 +268,7 @@ if dec != -1: self.assertEqual(dec, self.db.numeric(c)) count += 1 - self.assertTrue(count >= 10) # should have tested at least the ASCII digits + self.assertGreaterEqual(count, 10) # should have tested at least the ASCII digits def test_bug_1704793(self): self.assertEqual(self.db.lookup("GOTHIC LETTER FAIHU"), '\U00010346') @@ -277,12 +277,12 @@ import unicodedata # In UCD 5.1.0, a mirrored property changed wrt. UCD 3.2.0 self.assertTrue(unicodedata.mirrored("\u0f3a")) - self.assertTrue(not unicodedata.ucd_3_2_0.mirrored("\u0f3a")) + self.assertFalse(unicodedata.ucd_3_2_0.mirrored("\u0f3a")) # Also, we now have two ways of representing # the upper-case mapping: as delta, or as absolute value - self.assertTrue("a".upper()=='A') - self.assertTrue("\u1d79".upper()=='\ua77d') - self.assertTrue(".".upper()=='.') + self.assertEqual("a".upper(), 'A') + self.assertEqual("\u1d79".upper(), '\ua77d') + self.assertEqual(".".upper(), '.') def test_bug_5828(self): self.assertEqual("\u1d79".lower(), "\u1d79") diff -r ff471d8526a8 Lib/test/test_urllib.py --- a/Lib/test/test_urllib.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_urllib.py Sat Nov 16 17:58:58 2013 +0200 @@ -1340,7 +1340,7 @@ # def testTimeoutNone(self): # # global default timeout is ignored # import socket -# self.assertTrue(socket.getdefaulttimeout() is None) +# self.assertIsNone(socket.getdefaulttimeout()) # socket.setdefaulttimeout(30) # try: # ftp = urllib.ftpwrapper("myuser", "mypass", "localhost", 9093, []) @@ -1352,7 +1352,7 @@ # def testTimeoutDefault(self): # # global default timeout is used # import socket -# self.assertTrue(socket.getdefaulttimeout() is None) +# self.assertIsNone(socket.getdefaulttimeout()) # socket.setdefaulttimeout(30) # try: # ftp = urllib.ftpwrapper("myuser", "mypass", "localhost", 9093, []) diff -r ff471d8526a8 Lib/test/test_urllib2.py --- a/Lib/test/test_urllib2.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_urllib2.py Sat Nov 16 17:58:58 2013 +0200 @@ -603,8 +603,8 @@ self.assertIsInstance(args[0], Request) # response from opener.open is None, because there's no # handler that defines http_open to handle it - self.assertTrue(args[1] is None or - isinstance(args[1], MockResponse)) + if args[1] is not None: + self.assertIsInstance(args[1], MockResponse) def sanepathname2url(path): try: @@ -1018,7 +1018,8 @@ MockHeaders({"location": to_url})) except urllib.error.HTTPError: # 307 in response to POST requires user OK - self.assertTrue(code == 307 and data is not None) + self.assertEqual(code, 307) + self.assertIsNotNone(data) self.assertEqual(o.req.get_full_url(), to_url) try: self.assertEqual(o.req.get_method(), "GET") diff -r ff471d8526a8 Lib/test/test_urllib2net.py --- a/Lib/test/test_urllib2net.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_urllib2net.py Sat Nov 16 17:58:58 2013 +0200 @@ -87,7 +87,7 @@ with support.transient_internet(url): response = _urlopen_with_retry(url) sock = response.fp - self.assertTrue(not sock.closed) + self.assertFalse(sock.closed) response.close() self.assertTrue(sock.closed) @@ -262,15 +262,15 @@ class TimeoutTest(unittest.TestCase): def test_http_basic(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) url = "http://www.python.org" with support.transient_internet(url, timeout=None): u = _urlopen_with_retry(url) self.addCleanup(u.close) - self.assertTrue(u.fp.raw._sock.gettimeout() is None) + self.assertIsNone(u.fp.raw._sock.gettimeout()) def test_http_default_timeout(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) url = "http://www.python.org" with support.transient_internet(url): socket.setdefaulttimeout(60) @@ -282,7 +282,7 @@ self.assertEqual(u.fp.raw._sock.gettimeout(), 60) def test_http_no_timeout(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) url = "http://www.python.org" with support.transient_internet(url): socket.setdefaulttimeout(60) @@ -291,7 +291,7 @@ self.addCleanup(u.close) finally: socket.setdefaulttimeout(None) - self.assertTrue(u.fp.raw._sock.gettimeout() is None) + self.assertIsNone(u.fp.raw._sock.gettimeout()) def test_http_timeout(self): url = "http://www.python.org" @@ -303,14 +303,14 @@ FTP_HOST = "ftp://ftp.mirror.nl/pub/gnu/" def test_ftp_basic(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) with support.transient_internet(self.FTP_HOST, timeout=None): u = _urlopen_with_retry(self.FTP_HOST) self.addCleanup(u.close) - self.assertTrue(u.fp.fp.raw._sock.gettimeout() is None) + self.assertIsNone(u.fp.fp.raw._sock.gettimeout()) def test_ftp_default_timeout(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) with support.transient_internet(self.FTP_HOST): socket.setdefaulttimeout(60) try: @@ -321,7 +321,7 @@ self.assertEqual(u.fp.fp.raw._sock.gettimeout(), 60) def test_ftp_no_timeout(self): - self.assertTrue(socket.getdefaulttimeout() is None) + self.assertIsNone(socket.getdefaulttimeout()) with support.transient_internet(self.FTP_HOST): socket.setdefaulttimeout(60) try: @@ -329,7 +329,7 @@ self.addCleanup(u.close) finally: socket.setdefaulttimeout(None) - self.assertTrue(u.fp.fp.raw._sock.gettimeout() is None) + self.assertIsNone(u.fp.fp.raw._sock.gettimeout()) def test_ftp_timeout(self): with support.transient_internet(self.FTP_HOST): diff -r ff471d8526a8 Lib/test/test_userdict.py --- a/Lib/test/test_userdict.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_userdict.py Sat Nov 16 17:58:58 2013 +0200 @@ -38,7 +38,7 @@ self.assertEqual(collections.UserDict().fromkeys('one two'.split()), d4) self.assertEqual(collections.UserDict.fromkeys('one two'.split(), 1), d5) self.assertEqual(collections.UserDict().fromkeys('one two'.split(), 1), d5) - self.assertTrue(u1.fromkeys('one two'.split()) is not u1) + self.assertIsNot(u1.fromkeys('one two'.split()), u1) self.assertIsInstance(u1.fromkeys('one two'.split()), collections.UserDict) self.assertIsInstance(u2.fromkeys('one two'.split()), collections.UserDict) diff -r ff471d8526a8 Lib/test/test_uuid.py --- a/Lib/test/test_uuid.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_uuid.py Sat Nov 16 17:58:58 2013 +0200 @@ -293,8 +293,8 @@ def check_node(self, node, source): message = "%012x is not an RFC 4122 node ID" % node - self.assertTrue(0 < node, message) - self.assertTrue(node < (1 << 48), message) + self.assertGreater(node, 0, message) + self.assertLess(node, 1 << 48, message) TestUUID.source2node[source] = node if TestUUID.last_node: @@ -331,7 +331,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 ff471d8526a8 Lib/test/test_warnings.py --- a/Lib/test/test_warnings.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_warnings.py Sat Nov 16 17:58:58 2013 +0200 @@ -171,7 +171,7 @@ text = 'handle normally' self.module.warn(text) self.assertEqual(str(w[-1].message), text) - self.assertTrue(w[-1].category is UserWarning) + self.assertIs(w[-1].category, UserWarning) self.module.filterwarnings("ignore", "", Warning, "", 0) text = 'filtered out' @@ -184,7 +184,7 @@ text = 'nonmatching text' self.module.warn(text) self.assertEqual(str(w[-1].message), text) - self.assertTrue(w[-1].category is UserWarning) + self.assertIs(w[-1].category, UserWarning) class CFilterTests(FilterTests, unittest.TestCase): module = c_warnings @@ -205,7 +205,7 @@ text = 'multi %d' %i # Different text on each call. self.module.warn(text) self.assertEqual(str(w[-1].message), text) - self.assertTrue(w[-1].category is UserWarning) + self.assertIs(w[-1].category, UserWarning) # Issue 3639 def test_warn_nonstandard_types(self): @@ -378,7 +378,7 @@ # As an early adopter, we sanity check the # test.support.import_fresh_module utility function def test_accelerated(self): - self.assertFalse(original_warnings is self.module) + self.assertIsNot(original_warnings, self.module) self.assertFalse(hasattr(self.module.warn, '__code__')) class PyWarnTests(WarnTests, unittest.TestCase): @@ -387,7 +387,7 @@ # As an early adopter, we sanity check the # test.support.import_fresh_module utility function def test_pure_python(self): - self.assertFalse(original_warnings is self.module) + self.assertIsNot(original_warnings, self.module) self.assertTrue(hasattr(self.module.warn, '__code__')) @@ -631,20 +631,20 @@ # Ensure both showwarning and filters are restored when recording with wmod.catch_warnings(module=wmod, record=True): wmod.filters = wmod.showwarning = object() - self.assertTrue(wmod.filters is orig_filters) - self.assertTrue(wmod.showwarning is orig_showwarning) + self.assertIs(wmod.filters, orig_filters) + self.assertIs(wmod.showwarning, orig_showwarning) # Same test, but with recording disabled with wmod.catch_warnings(module=wmod, record=False): wmod.filters = wmod.showwarning = object() - self.assertTrue(wmod.filters is orig_filters) - self.assertTrue(wmod.showwarning is orig_showwarning) + self.assertIs(wmod.filters, orig_filters) + self.assertIs(wmod.showwarning, orig_showwarning) def test_catch_warnings_recording(self): wmod = self.module # Ensure warnings are recorded when requested with wmod.catch_warnings(module=wmod, record=True) as w: self.assertEqual(w, []) - self.assertTrue(type(w) is list) + self.assertIs(type(w), list) wmod.simplefilter("always") wmod.warn("foo") self.assertEqual(str(w[-1].message), "foo") @@ -657,8 +657,8 @@ # Ensure warnings are not recorded when not requested orig_showwarning = wmod.showwarning with wmod.catch_warnings(module=wmod, record=False) as w: - self.assertTrue(w is None) - self.assertTrue(wmod.showwarning is orig_showwarning) + self.assertIsNone(w) + self.assertIs(wmod.showwarning, orig_showwarning) def test_catch_warnings_reentry_guard(self): wmod = self.module @@ -679,17 +679,17 @@ orig_showwarning = wmod.showwarning # Ensure default behaviour is not to record warnings with wmod.catch_warnings(module=wmod) as w: - self.assertTrue(w is None) - self.assertTrue(wmod.showwarning is orig_showwarning) - self.assertTrue(wmod.filters is not orig_filters) - self.assertTrue(wmod.filters is orig_filters) + self.assertIsNone(w) + self.assertIs(wmod.showwarning, orig_showwarning) + self.assertIsNot(wmod.filters, orig_filters) + self.assertIs(wmod.filters, orig_filters) if wmod is sys.modules['warnings']: # Ensure the default module is this one with wmod.catch_warnings() as w: - self.assertTrue(w is None) - self.assertTrue(wmod.showwarning is orig_showwarning) - self.assertTrue(wmod.filters is not orig_filters) - self.assertTrue(wmod.filters is orig_filters) + self.assertIsNone(w) + self.assertIs(wmod.showwarning, orig_showwarning) + self.assertIsNot(wmod.filters, orig_filters) + self.assertIs(wmod.filters, orig_filters) def test_check_warnings(self): # Explicit tests for the test.support convenience wrapper diff -r ff471d8526a8 Lib/test/test_weakset.py --- a/Lib/test/test_weakset.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_weakset.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_winreg.py --- a/Lib/test/test_winreg.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_winreg.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_with.py --- a/Lib/test/test_with.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_with.py Sat Nov 16 17:58:58 2013 +0200 @@ -225,7 +225,7 @@ self.assertEqual(mock_manager.exit_args[0], exc_type) # Test the __exit__ arguments. Issue #7853 self.assertIsInstance(mock_manager.exit_args[1], exc_type) - self.assertIsNot(mock_manager.exit_args[2], None) + self.assertIsNotNone(mock_manager.exit_args[2]) def assertAfterWithGeneratorInvariantsWithError(self, mock_generator): self.assertTrue(mock_generator.yielded) diff -r ff471d8526a8 Lib/test/test_wsgiref.py --- a/Lib/test/test_wsgiref.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_wsgiref.py Sat Nov 16 17:58:58 2013 +0200 @@ -196,7 +196,7 @@ # Check existing value env = {key:alt} util.setup_testing_defaults(env) - self.assertTrue(env[key] is alt) + self.assertIs(env[key], alt) def checkCrossDefault(self,key,value,**kw): util.setup_testing_defaults(kw) @@ -339,7 +339,7 @@ self.assertEqual(Headers(test[:]).keys(), ['x']) self.assertEqual(Headers(test[:]).values(), ['y']) self.assertEqual(Headers(test[:]).items(), test) - self.assertFalse(Headers(test).items() is test) # must be copy! + self.assertIsNot(Headers(test).items(), test) # must be copy! h=Headers([]) del h['foo'] # should not raise an error diff -r ff471d8526a8 Lib/test/test_xdrlib.py --- a/Lib/test/test_xdrlib.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_xdrlib.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_xmlrpc.py --- a/Lib/test/test_xmlrpc.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_xmlrpc.py Sat Nov 16 17:58:58 2013 +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 ff471d8526a8 Lib/test/test_zlib.py --- a/Lib/test/test_zlib.py Sat Nov 16 10:35:46 2013 -0500 +++ b/Lib/test/test_zlib.py Sat Nov 16 17:58:58 2013 +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')