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
 import pickle
 from functools import reduce
+import sys
+import struct
 maxsize = support.MAX_Py_ssize_t
 minsize = -maxsize-1
 
 def lzip(*args):
     return list(zip(*args))
 
 def onearg(x):
     'Test function of one argument'
     return 2*x
 
@@ skipping 475 matching lines @@
         c = count(3)
         self.assertEqual(repr(c), 'count(3)')
         next(c)
         self.assertEqual(repr(c), 'count(4)')
         c = count(-9)
         self.assertEqual(repr(c), 'count(-9)')
         next(c)
         self.assertEqual(repr(count(10.25)), 'count(10.25)')
         self.assertEqual(next(c), -8)
         for i in (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 10, sys.maxsize-5, sys.maxsize+5):
-            # Test repr (ignoring the L in longs)
-            r1 = repr(count(i)).replace('L', '')
-            r2 = 'count(%r)'.__mod__(i).replace('L', '')
+            # Test repr
+            r1 = repr(count(i))
+            r2 = 'count(%r)'.__mod__(i)
             self.assertEqual(r1, r2)
 
         # check copy, deepcopy, pickle
         for value in -3, 3, maxsize-5, maxsize+5:
             c = count(value)
             self.assertEqual(next(copy.copy(c)), value)
             self.assertEqual(next(copy.deepcopy(c)), value)
             self.pickletest(count(value))
 
         #check proper internal error handling for large "step' sizes
@@ skipping 27 matching lines @@
         c = count(-9, -3)
         self.assertEqual(repr(c), 'count(-9, -3)')
         next(c)
         self.assertEqual(repr(c), 'count(-12, -3)')
         self.assertEqual(repr(c), 'count(-12, -3)')
         self.assertEqual(repr(count(10.5, 1.25)), 'count(10.5, 1.25)')
         self.assertEqual(repr(count(10.5, 1)), 'count(10.5)')           # suppress step=1 when it's an int
         self.assertEqual(repr(count(10.5, 1.00)), 'count(10.5, 1.0)')   # do show float values lilke 1.0
         for i in (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 10, sys.maxsize-5, sys.maxsize+5):
             for j in  (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 1, 10, sys.maxsize-5, sys.maxsize+5):
-                # Test repr (ignoring the L in longs)
-                r1 = repr(count(i, j)).replace('L', '')
+                # Test repr
+                r1 = repr(count(i, j))
                 if j == 1:
-                    r2 = ('count(%r)' % i).replace('L', '')
+                    r2 = ('count(%r)' % i)
                 else:
-                    r2 = ('count(%r, %r)' % (i, j)).replace('L', '')
+                    r2 = ('count(%r, %r)' % (i, j))
                 self.assertEqual(r1, r2)
                 self.pickletest(count(i, j))
 
     def test_cycle(self):
         self.assertEqual(take(10, cycle('abc')), list('abcabcabca'))
         self.assertEqual(list(cycle('')), [])
         self.assertRaises(TypeError, cycle)
         self.assertRaises(TypeError, cycle, 5)
         self.assertEqual(list(islice(cycle(gen3()),10)), [0,1,2,0,1,2,0,1,2,0])
 
@@ skipping 616 matching lines @@
         a, b = tee('abc')
         c, d = tee(a)
         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 49 matching lines @@
         self.assertEqual(list(copy.deepcopy(b)), long_ans[60:])
         self.assertEqual(list(a), long_ans[100:])
         self.assertEqual(list(b), long_ans[60:])
 
         # check pickle
         self.pickletest(iter(tee('abc')))
         a, b = tee('abc')
         self.pickletest(a, compare=ans)
         self.pickletest(b, compare=ans)
 
+    # Issue 13454: Crash when deleting backward iterator from tee()
+    def test_tee_del_backward(self):
+        forward, backward = tee(repeat(None, 20000000))
+        any(forward)  # exhaust the iterator
+        del backward
+
     def test_StopIteration(self):
         self.assertRaises(StopIteration, next, zip())
 
         for f in (chain, cycle, zip, groupby):
             self.assertRaises(StopIteration, next, f([]))
             self.assertRaises(StopIteration, next, f(StopNow()))
 
         self.assertRaises(StopIteration, next, islice([], None))
         self.assertRaises(StopIteration, next, islice(StopNow(), None))
 
@@ skipping 513 matching lines @@
         for cls in (repeat, zip, filter, filterfalse, chain, map,
                     starmap, islice, takewhile, dropwhile, cycle, compress):
             class Subclass(cls):
                 def __init__(self, newarg=None, *args):
                     cls.__init__(self, *args)
             try:
                 Subclass(newarg=1)
             except TypeError as err:
                 # we expect type errors because of wrong argument count
                 self.assertNotIn("does not take keyword arguments", err.args[0])
+
+@support.cpython_only
+class SizeofTest(unittest.TestCase):
+    def setUp(self):
+        self.ssize_t = struct.calcsize('n')
+
+    check_sizeof = support.check_sizeof
+
+    def test_product_sizeof(self):
+        basesize = support.calcobjsize('3Pi')
+        check = self.check_sizeof
+        check(product('ab', '12'), basesize + 2 * self.ssize_t)
+        check(product(*(('abc',) * 10)), basesize + 10 * self.ssize_t)
+
+    def test_combinations_sizeof(self):
+        basesize = support.calcobjsize('3Pni')
+        check = self.check_sizeof
+        check(combinations('abcd', 3), basesize + 3 * self.ssize_t)
+        check(combinations(range(10), 4), basesize + 4 * self.ssize_t)
+
+    def test_combinations_with_replacement_sizeof(self):
+        cwr = combinations_with_replacement
+        basesize = support.calcobjsize('3Pni')
+        check = self.check_sizeof
+        check(cwr('abcd', 3), basesize + 3 * self.ssize_t)
+        check(cwr(range(10), 4), basesize + 4 * self.ssize_t)
+
+    def test_permutations_sizeof(self):
+        basesize = support.calcobjsize('4Pni')
+        check = self.check_sizeof
+        check(permutations('abcd'),
+              basesize + 4 * self.ssize_t + 4 * self.ssize_t)
+        check(permutations('abcd', 3),
+              basesize + 4 * self.ssize_t + 3 * self.ssize_t)
+        check(permutations('abcde', 3),
+              basesize + 5 * self.ssize_t + 3 * self.ssize_t)
+        check(permutations(range(10), 4),
+              basesize + 10 * self.ssize_t + 4 * self.ssize_t)
 
 
 libreftest = """ Doctest for examples in the library reference: libitertools.tex
 
 
 >>> amounts = [120.15, 764.05, 823.14]
 >>> for checknum, amount in zip(count(1200), amounts):
 ...     print('Check %d is for $%.2f' % (checknum, amount))
 ...
 Check 1200 is for $120.15
@@ skipping 216 matching lines @@
 >>> list(unique_justseen('ABBCcAD', str.lower))
 ['A', 'B', 'C', 'A', 'D']
 
 """
 
 __test__ = {'libreftest' : libreftest}
 
 def test_main(verbose=None):
     test_classes = (TestBasicOps, TestVariousIteratorArgs, TestGC,
                     RegressionTests, LengthTransparency,
-                    SubclassWithKwargsTest, TestExamples)
+                    SubclassWithKwargsTest, TestExamples,
+                    SizeofTest)
     support.run_unittest(*test_classes)
 
     # verify reference counting
     if verbose and hasattr(sys, "gettotalrefcount"):
         import gc
         counts = [None] * 5
         for i in range(len(counts)):
             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)