Using appropriate checks in tests

Lib/test/test_itertools.py

 import unittest
 from test import support
 from itertools import *
 from weakref import proxy
 from decimal import Decimal
 from fractions import Fraction
 import sys
 import operator
 import random
 import copy
@@ skipping 308 matching lines @@
                 result = list(cwr(values, r))
 
                 self.assertEqual(len(result), numcombs(n, r))           # right number of combs
                 self.assertEqual(len(result), len(set(result)))         # no repeats
                 self.assertEqual(result, sorted(result))                # lexicographic order
 
                 regular_combs = list(combinations(values, r))           # compare to combs without replacement
                 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
                     noruns = [k for k,v in groupby(c)]                  # combo without consecutive repeats
                     self.assertEqual(len(noruns), len(set(noruns)))     # no repeats other than consecutive
                     self.assertEqual(list(c), sorted(c))                # keep original ordering
                     self.assertTrue(all(e in values for e in c))           # elements taken from input iterable
                     self.assertEqual(noruns,
                                      [e for e in values if e in c])     # comb is a subsequence of the input iterable
                 self.assertEqual(result, list(cwr1(values, r)))         # matches first pure python version
@@ skipping 844 matching lines @@
         self.assertRaises(ValueError, tee, [], -1)
         for n in range(5):
             result = tee('abc', n)
             self.assertEqual(type(result), tuple)
             self.assertEqual(len(result), n)
             self.assertEqual([list(x) for x in result], [list('abc')]*n)
 
         # 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')
         tnew = type(t1)
         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))
         p = proxy(a)
         self.assertEqual(getattr(p, '__class__'), type(b))
         del a
         self.assertRaises(ReferenceError, getattr, p, '__class__')
 
         ans = list('abc')
         long_ans = list(range(10000))
@@ skipping 881 matching lines @@
             support.run_unittest(*test_classes)
             gc.collect()
             counts[i] = sys.gettotalrefcount()
         print(counts)
 
     # doctest the examples in the library reference
     support.run_doctest(sys.modules[__name__], verbose)
 
 if __name__ == "__main__":
     test_main(verbose=True)