python · serhiy-storchaka · Mar 23, 2017
diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
@@ -202,9 +202,9 @@ def test_current(self):
         authkey = current.authkey
 
         self.assertTrue(current.is_alive())
-        self.assertTrue(not current.daemon)
+        self.assertFalse(current.daemon)
         self.assertIsInstance(authkey, bytes)
-        self.assertTrue(len(authkey) > 0)
+        self.assertGreater(len(authkey), 0)
         self.assertEqual(current.ident, os.getpid())
         self.assertEqual(current.exitcode, None)
 
@@ -247,7 +247,7 @@ def test_process(self):
         self.assertEqual(p.is_alive(), False)
         self.assertEqual(p.daemon, True)
         self.assertNotIn(p, self.active_children())
-        self.assertTrue(type(self.active_children()) is list)
+        self.assertIs(type(self.active_children()), list)
         self.assertEqual(p.exitcode, None)
 
         p.start()
@@ -330,8 +330,8 @@ def test_cpu_count(self):
             cpus = multiprocessing.cpu_count()
         except NotImplementedError:
             cpus = 1
-        self.assertTrue(type(cpus) is int)
-        self.assertTrue(cpus >= 1)
+        self.assertIs(type(cpus), int)
+        self.assertGreaterEqual(cpus, 1)
 
     def test_active_children(self):
         self.assertEqual(type(self.active_children()), list)
@@ -1721,7 +1721,7 @@ def test_namespace(self):
         del n.job
         self.assertEqual(str(n), "Namespace(name='Bob')")
         self.assertTrue(hasattr(n, 'name'))
-        self.assertTrue(not hasattr(n, 'job'))
+        self.assertFalse(hasattr(n, 'job'))
 
 #
 #
@@ -3078,7 +3078,7 @@ class _TestLogging(BaseTestCase):
     def test_enable_logging(self):
         logger = multiprocessing.get_logger()
         logger.setLevel(util.SUBWARNING)
-        self.assertTrue(logger is not None)
+        self.assertIsNotNone(logger)
         logger.debug('this will not be printed')
         logger.info('nor will this')
         logger.setLevel(LOG_LEVEL)
@@ -3815,8 +3815,8 @@ def test_get_all(self):
         if sys.platform == 'win32':
             self.assertEqual(methods, ['spawn'])
         else:
-            self.assertTrue(methods == ['fork', 'spawn'] or
-                            methods == ['fork', 'spawn', 'forkserver'])
+            self.assertIn(methods, (['fork', 'spawn'],
+                                    ['fork', 'spawn', 'forkserver']))
 
     def test_preload_resources(self):
         if multiprocessing.get_start_method() != 'forkserver':

diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py
@@ -1342,7 +1342,7 @@ def test_recursive_multi(self):
             self.assertEqual(len(x), 1)
             self.assertEqual(dir(x[0]), dir(i))
             self.assertEqual(list(x[0].attr.keys()), [1])
-            self.assertTrue(x[0].attr[1] is x)
+            self.assertIs(x[0].attr[1], x)
 
     def check_recursive_collection_and_inst(self, factory):
         h = H()
@@ -1632,7 +1632,7 @@ def test_singletons(self):
             for x in None, False, True:
                 s = self.dumps(x, proto)
                 y = self.loads(s)
-                self.assertTrue(x is y, (proto, x, s, y))
+                self.assertIs(x, y, (proto, x, s, y))
                 expected = expected_opcode[min(proto, 3), x]
                 self.assertTrue(opcode_in_pickle(expected, s))
 
@@ -1764,7 +1764,7 @@ def test_list_chunking(self):
             if proto == 0:
                 self.assertEqual(num_appends, 0)
             else:
-                self.assertTrue(num_appends >= 2)
+                self.assertGreaterEqual(num_appends, 2)
 
     def test_dict_chunking(self):
         n = 10  # too small to chunk
@@ -1787,7 +1787,7 @@ def test_dict_chunking(self):
             if proto == 0:
                 self.assertEqual(num_setitems, 0)
             else:
-                self.assertTrue(num_setitems >= 2)
+                self.assertGreaterEqual(num_setitems, 2)
 
     def test_set_chunking(self):
         n = 10  # too small to chunk
@@ -2737,7 +2737,7 @@ def test_priming_unpickler_memo(self):
         primed.memo.clear()
 
         self.assertEqual(unpickled_data2, data)
-        self.assertTrue(unpickled_data2 is unpickled_data1)
+        self.assertIs(unpickled_data2, unpickled_data1)
 
     def test_reusing_unpickler_objects(self):
         data1 = ["abcdefg", "abcdefg", 44]

diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
@@ -299,14 +299,14 @@ class A(metaclass=abc.ABCMeta):
         class B:
             pass
         b = B()
-        self.assertFalse(isinstance(b, A))
-        self.assertFalse(isinstance(b, (A,)))
+        self.assertNotIsInstance(b, A)
+        self.assertNotIsInstance(b, (A,))
         token_old = abc.get_cache_token()
         A.register(B)
         token_new = abc.get_cache_token()
         self.assertNotEqual(token_old, token_new)
-        self.assertTrue(isinstance(b, A))
-        self.assertTrue(isinstance(b, (A,)))
+        self.assertIsInstance(b, A)
+        self.assertIsInstance(b, (A,))
 
     def test_registration_builtins(self):
         class A(metaclass=abc.ABCMeta):

diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py
@@ -203,7 +203,7 @@ def _assertTrueorder(self, ast_node, parent_pos):
             return
         if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)):
             node_pos = (ast_node.lineno, ast_node.col_offset)
-            self.assertTrue(node_pos >= parent_pos)
+            self.assertGreaterEqual(node_pos, parent_pos)
             parent_pos = (ast_node.lineno, ast_node.col_offset)
         for name in ast_node._fields:
             value = getattr(ast_node, name)

diff --git a/Lib/test/test_asyncore.py b/Lib/test/test_asyncore.py
@@ -308,7 +308,7 @@ def test_strerror(self):
         if hasattr(os, 'strerror'):
             self.assertEqual(err, os.strerror(errno.EPERM))
         err = asyncore._strerror(-1)
-        self.assertTrue(err != "")
+        self.assertNotEqual(err, "")
 
 
 class dispatcherwithsend_noread(asyncore.dispatcher_with_send):

diff --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py
@@ -62,7 +62,7 @@ def testSequences(self):
         y[1:2] += [1]
 
         self.assertEqual(x, [1, 2, 1, 2, 3])
-        self.assertTrue(x is y)
+        self.assertIs(x, y)
 
     def testCustomMethods1(self):
 
@@ -92,22 +92,22 @@ class aug_test4(aug_test3):
         x += 10
 
         self.assertIsInstance(x, aug_test)
-        self.assertTrue(y is not x)
+        self.assertIsNot(y, x)
         self.assertEqual(x.val, 11)
 
         x = aug_test2(2)
         y = x
         x += 10
 
-        self.assertTrue(y is x)
+        self.assertIs(y, x)
         self.assertEqual(x.val, 12)
 
         x = aug_test3(3)
         y = x
         x += 10
 
         self.assertIsInstance(x, aug_test3)
-        self.assertTrue(y is not x)
+        self.assertIsNot(y, x)
         self.assertEqual(x.val, 13)
 
         x = aug_test4(4)

diff --git a/Lib/test/test_binop.py b/Lib/test/test_binop.py
@@ -208,10 +208,10 @@ def test_gcd(self):
         self.assertEqual(gcd(-10, -2), -2)
         for i in range(1, 20):
             for j in range(1, 20):
-                self.assertTrue(gcd(i, j) > 0)
-                self.assertTrue(gcd(-i, j) < 0)
-                self.assertTrue(gcd(i, -j) > 0)
-                self.assertTrue(gcd(-i, -j) < 0)
+                self.assertGreater(gcd(i, j), 0)
+                self.assertLess(gcd(-i, j), 0)
+                self.assertGreater(gcd(i, -j), 0)
+                self.assertLess(gcd(-i, -j), 0)
 
     def test_constructor(self):
         a = Rat(10, 15)

diff --git a/Lib/test/test_bisect.py b/Lib/test/test_bisect.py
@@ -159,14 +159,14 @@ def test_random(self, n=25):
             elem = randrange(-1, n+1)
             ip = self.module.bisect_left(data, elem)
             if ip < len(data):
-                self.assertTrue(elem <= data[ip])
+                self.assertLessEqual(elem, data[ip])
             if ip > 0:
-                self.assertTrue(data[ip-1] < elem)
+                self.assertLess(data[ip-1], elem)
             ip = self.module.bisect_right(data, elem)
             if ip < len(data):
-                self.assertTrue(elem < data[ip])
+                self.assertLess(elem, data[ip])
             if ip > 0:
-                self.assertTrue(data[ip-1] <= elem)
+                self.assertLessEqual(data[ip-1], elem)
 
     def test_optionalSlicing(self):
         for func, data, elem, expected in self.precomputedCases:
@@ -177,13 +177,13 @@ def test_optionalSlicing(self):
                     ip = func(data, elem, lo, hi)
                     self.assertTrue(lo <= ip <= hi)
                     if func is self.module.bisect_left and ip < hi:
-                        self.assertTrue(elem <= data[ip])
+                        self.assertLessEqual(elem, data[ip])
                     if func is self.module.bisect_left and ip > lo:
-                        self.assertTrue(data[ip-1] < elem)
+                        self.assertLess(data[ip-1], elem)
                     if func is self.module.bisect_right and ip < hi:
-                        self.assertTrue(elem < data[ip])
+                        self.assertLess(elem, data[ip])
                     if func is self.module.bisect_right and ip > lo:
-                        self.assertTrue(data[ip-1] <= elem)
+                        self.assertLessEqual(data[ip-1], elem)
                     self.assertEqual(ip, max(lo, min(hi, expected)))
 
     def test_backcompatibility(self):

diff --git a/Lib/test/test_buffer.py b/Lib/test/test_buffer.py
@@ -1346,7 +1346,7 @@ def test_ndarray_multidim(self):
                         # memoryview: reconstruct strides
                         ex = ndarray(items, shape=shape, format=fmt)
                         nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT)
-                        self.assertTrue(nd.strides == ())
+                        self.assertEqual(nd.strides, ())
                         mv = nd.memoryview_from_buffer()
                         self.verify(mv, obj=None,
                                     itemsize=itemsize, fmt=fmt, readonly=1,
@@ -1574,13 +1574,13 @@ def test_ndarray_sequence(self):
             nd = ndarray(items, shape=[5], format=fmt)
             for i, v in enumerate(nd):
                 self.assertEqual(v, items[i])
-                self.assertTrue(v in nd)
+                self.assertIn(v, nd)
 
             if is_memoryview_format(fmt):
                 mv = memoryview(nd)
                 for i, v in enumerate(mv):
                     self.assertEqual(v, items[i])
-                    self.assertTrue(v in mv)
+                    self.assertIn(v, mv)
 
     def test_ndarray_slice_invalid(self):
         items = [1,2,3,4,5,6,7,8]
@@ -2533,8 +2533,8 @@ def f(): return 7
                     mv_err = e.__class__
 
                 if struct_err or mv_err:
-                    self.assertIsNot(struct_err, None)
-                    self.assertIsNot(mv_err, None)
+                    self.assertIsNotNone(struct_err)
+                    self.assertIsNotNone(mv_err)
                 else:
                     self.assertEqual(m[1], nd[1])
 
@@ -4357,7 +4357,7 @@ def test_memoryview_from_static_exporter(self):
         y = ndarray(x, getbuf=PyBUF_FULL_RO)
         z = ndarray(y, getbuf=PyBUF_FULL_RO)
         m = memoryview(z)
-        self.assertIs(y.obj, None)
+        self.assertIsNone(y.obj)
         self.assertIs(m.obj, z)
         self.verify(m, obj=z,
                     itemsize=1, fmt=fmt, readonly=1,
@@ -4371,7 +4371,7 @@ def test_memoryview_from_static_exporter(self):
         m = memoryview(z)
         # Clearly setting view.obj==NULL is inferior, since it
         # messes up the redirection chain:
-        self.assertIs(y.obj, None)
+        self.assertIsNone(y.obj)
         self.assertIs(z.obj, y)
         self.assertIs(m.obj, y)
         self.verify(m, obj=y,

diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
@@ -157,7 +157,7 @@ def test_abs(self):
         self.assertEqual(abs(0), 0)
         self.assertEqual(abs(1234), 1234)
         self.assertEqual(abs(-1234), 1234)
-        self.assertTrue(abs(-sys.maxsize-1) > 0)
+        self.assertGreater(abs(-sys.maxsize-1), 0)
         # float
         self.assertEqual(abs(0.0), 0.0)
         self.assertEqual(abs(3.14), 3.14)
@@ -242,7 +242,7 @@ def _check_uni(s):
 
     def test_neg(self):
         x = -sys.maxsize-1
-        self.assertTrue(isinstance(x, int))
+        self.assertIsInstance(x, int)
         self.assertEqual(-x, sys.maxsize+1)
 
     def test_callable(self):
@@ -302,7 +302,7 @@ def test_chr(self):
         self.assertRaises((OverflowError, ValueError), chr, 2**32)
 
     def test_cmp(self):
-        self.assertTrue(not hasattr(builtins, "cmp"))
+        self.assertFalse(hasattr(builtins, "cmp"))
 
     def test_compile(self):
         compile('print(1)\n', '', 'exec')
@@ -406,15 +406,15 @@ class Foo(object):
             def __dir__(self):
                 return ["kan", "ga", "roo"]
         f = Foo()
-        self.assertTrue(dir(f) == ["ga", "kan", "roo"])
+        self.assertEqual(dir(f), ["ga", "kan", "roo"])
 
         # dir(obj__dir__tuple)
         class Foo(object):
             def __dir__(self):
                 return ("b", "c", "a")
         res = dir(Foo())
         self.assertIsInstance(res, list)
-        self.assertTrue(res == ["a", "b", "c"])
+        self.assertEqual(res, ["a", "b", "c"])
 
         # dir(obj__dir__not_sequence)
         class Foo(object):
@@ -645,7 +645,7 @@ def test_filter_pickle(self):
             self.check_iter_pickle(f1, list(f2), proto)
 
     def test_getattr(self):
-        self.assertTrue(getattr(sys, 'stdout') is sys.stdout)
+        self.assertIs(getattr(sys, 'stdout'), sys.stdout)
         self.assertRaises(TypeError, getattr, sys, 1)
         self.assertRaises(TypeError, getattr, sys, 1, "foo")
         self.assertRaises(TypeError, getattr)
@@ -726,11 +726,11 @@ class E:
         c = C()
         d = D()
         e = E()
-        self.assertTrue(isinstance(c, C))
-        self.assertTrue(isinstance(d, C))
-        self.assertTrue(not isinstance(e, C))
-        self.assertTrue(not isinstance(c, D))
-        self.assertTrue(not isinstance('foo', E))
+        self.assertIsInstance(c, C)
+        self.assertIsInstance(d, C)
+        self.assertNotIsInstance(e, C)
+        self.assertNotIsInstance(c, D)
+        self.assertNotIsInstance('foo', E)
         self.assertRaises(TypeError, isinstance, E, 'foo')
         self.assertRaises(TypeError, isinstance)
 
@@ -746,7 +746,7 @@ class E:
         e = E()
         self.assertTrue(issubclass(D, C))
         self.assertTrue(issubclass(C, C))
-        self.assertTrue(not issubclass(C, D))
+        self.assertFalse(issubclass(C, D))
         self.assertRaises(TypeError, issubclass, 'foo', E)
         self.assertRaises(TypeError, issubclass, E, 'foo')
         self.assertRaises(TypeError, issubclass)

diff --git a/Lib/test/test_bz2.py b/Lib/test/test_bz2.py
@@ -720,7 +720,7 @@ def testDecompress4G(self, size):
             compressed = bz2.compress(data)
             bz2d = BZ2Decompressor()
             decompressed = bz2d.decompress(compressed)
-            self.assertTrue(decompressed == data)
+            self.assertEqual(decompressed, data)
         finally:
             data = None
             compressed = None

diff --git a/Lib/test/test_capi.py b/Lib/test/test_capi.py
@@ -42,7 +42,7 @@ class CAPITest(unittest.TestCase):
     def test_instancemethod(self):
         inst = InstanceMethod()
         self.assertEqual(id(inst), inst.id())
-        self.assertTrue(inst.testfunction() is inst)
+        self.assertIs(inst.testfunction(), inst)
         self.assertEqual(inst.testfunction.__doc__, testfunction.__doc__)
         self.assertEqual(InstanceMethod.testfunction.__doc__, testfunction.__doc__)
 
@@ -274,7 +274,7 @@ def pendingcalls_wait(self, l, n, context = None):
             if context and not context.event.is_set():
                 continue
             count += 1
-            self.assertTrue(count < 10000,
+            self.assertLess(count, 10000,
                 "timeout waiting for %i callbacks, got %i"%(n, len(l)))
         if False and support.verbose:
             print("(%i)"%(len(l),))