bpo-20550: Use specific asserts in collections tests

Lib/test/mapping_tests.py

@@ -72,7 +72,8 @@ def check_iterandlist(iter, lst, ref):
             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 @@ def test_constructor(self):
         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 __next__(self):
 
     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 @@ def test_pop(self):
 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_items(self):
     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 __getitem__(self, i):
     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 @@ def g():
         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,20 +478,20 @@ def test_copy(self):
     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)
 
     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 @@ def test_popitem(self):
                     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)

Lib/test/test_collections.py

@@ -1164,7 +1164,7 @@ def __iter__(self):
             def __hash__(self):
                 return self._hash()
         a, b = OneTwoThreeSet(), OneTwoThreeSet()
-        self.assertTrue(hash(a) == hash(b))
+        self.assertEqual(hash(a), hash(b))
 
     def test_isdisjoint_Set(self):
         class MySet(Set):
@@ -1790,7 +1790,7 @@ def test_conversions(self):
     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):

Lib/test/test_defaultdict.py

@@ -68,7 +68,7 @@ def test_repr(self):
         self.assertEqual(repr(d2), "defaultdict(<class 'int'>, {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))
 
@@ -133,7 +133,7 @@ def test_deep_copy(self):
         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)

Lib/test/test_deque.py

@@ -409,7 +409,7 @@ def test_reverse(self):
             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
@@ -512,7 +512,7 @@ def test_remove(self):
         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):
@@ -748,7 +748,7 @@ class C(object):
             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
 

Lib/test/test_dict.py

@@ -278,10 +278,10 @@ def test_copy(self):
 
     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)
@@ -291,9 +291,9 @@ def test_get(self):
     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)
@@ -736,7 +736,7 @@ class C(object):
             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

Lib/test/test_dictviews.py

@@ -76,16 +76,16 @@ def test_dict_repr(self):
         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}

Lib/test/test_heapq.py

@@ -61,7 +61,7 @@ def check_invariant(self, heap):
         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 list(range(30)) + [20000]:

Lib/test/test_list.py

@@ -11,7 +11,7 @@ def test_basic(self):
         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(''), [])
@@ -47,11 +47,11 @@ def test_keyword_args(self):
 
     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()

Lib/test/test_queue.py

@@ -108,7 +108,7 @@ def simple_queue_test(self, q):
         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 @@ def simple_queue_test(self, q):
         # 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,15 +308,15 @@ def failing_queue_test(self, q):
         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
         self.do_blocking_test(q.put, ("full",), q.get, ())
         # 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 @@ def failing_queue_test(self, q):
             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 @@ def failing_queue_test(self, q):
         # 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.

Lib/test/test_set.py

@@ -360,7 +360,7 @@ class C(object):
         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")
 
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, self.thetype)
@@ -452,7 +452,7 @@ def test_remove_keyerror_set(self):
         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:
@@ -1531,7 +1531,7 @@ def test_copy(self):
         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)

Lib/test/test_structseq.py

@@ -69,11 +69,11 @@ def test_cmp(self):
         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()