diff options
Diffstat (limited to 'Lib/test/test_range.py')
| -rw-r--r-- | Lib/test/test_range.py | 389 |
1 files changed, 379 insertions, 10 deletions
diff --git a/Lib/test/test_range.py b/Lib/test/test_range.py index c082fd1..ede0791 100644 --- a/Lib/test/test_range.py +++ b/Lib/test/test_range.py @@ -5,10 +5,6 @@ import sys import pickle import itertools -import warnings -warnings.filterwarnings("ignore", "integer argument expected", - DeprecationWarning, "unittest") - # pure Python implementations (3 args only), for comparison def pyrange(start, stop, step): if (start - stop) // step < 0: @@ -63,18 +59,18 @@ class RangeTest(unittest.TestCase): self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2]) seq = list(range(a, b, c)) - self.assertTrue(a in seq) - self.assertTrue(b not in seq) + self.assertIn(a, seq) + self.assertNotIn(b, seq) self.assertEqual(len(seq), 2) seq = list(range(b, a, -c)) - self.assertTrue(b in seq) - self.assertTrue(a not in seq) + self.assertIn(b, seq) + self.assertNotIn(a, seq) self.assertEqual(len(seq), 2) seq = list(range(-a, -b, -c)) - self.assertTrue(-a in seq) - self.assertTrue(-b not in seq) + self.assertIn(-a, seq) + self.assertNotIn(-b, seq) self.assertEqual(len(seq), 2) self.assertRaises(TypeError, range) @@ -94,6 +90,250 @@ class RangeTest(unittest.TestCase): r = range(-sys.maxsize, sys.maxsize, 2) self.assertEqual(len(r), sys.maxsize) + def test_large_operands(self): + x = range(10**20, 10**20+10, 3) + self.assertEqual(len(x), 4) + self.assertEqual(len(list(x)), 4) + + x = range(10**20+10, 10**20, 3) + self.assertEqual(len(x), 0) + self.assertEqual(len(list(x)), 0) + + x = range(10**20, 10**20+10, -3) + self.assertEqual(len(x), 0) + self.assertEqual(len(list(x)), 0) + + x = range(10**20+10, 10**20, -3) + self.assertEqual(len(x), 4) + self.assertEqual(len(list(x)), 4) + + # Now test range() with longs + self.assertEqual(list(range(-2**100)), []) + self.assertEqual(list(range(0, -2**100)), []) + self.assertEqual(list(range(0, 2**100, -1)), []) + self.assertEqual(list(range(0, 2**100, -1)), []) + + a = int(10 * sys.maxsize) + b = int(100 * sys.maxsize) + c = int(50 * sys.maxsize) + + self.assertEqual(list(range(a, a+2)), [a, a+1]) + self.assertEqual(list(range(a+2, a, -1)), [a+2, a+1]) + self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2]) + + seq = list(range(a, b, c)) + self.assertIn(a, seq) + self.assertNotIn(b, seq) + self.assertEqual(len(seq), 2) + self.assertEqual(seq[0], a) + self.assertEqual(seq[-1], a+c) + + seq = list(range(b, a, -c)) + self.assertIn(b, seq) + self.assertNotIn(a, seq) + self.assertEqual(len(seq), 2) + self.assertEqual(seq[0], b) + self.assertEqual(seq[-1], b-c) + + seq = list(range(-a, -b, -c)) + self.assertIn(-a, seq) + self.assertNotIn(-b, seq) + self.assertEqual(len(seq), 2) + self.assertEqual(seq[0], -a) + self.assertEqual(seq[-1], -a-c) + + def test_large_range(self): + # Check long ranges (len > sys.maxsize) + # len() is expected to fail due to limitations of the __len__ protocol + def _range_len(x): + try: + length = len(x) + except OverflowError: + step = x[1] - x[0] + length = 1 + ((x[-1] - x[0]) // step) + return length + a = -sys.maxsize + b = sys.maxsize + expected_len = b - a + x = range(a, b) + self.assertIn(a, x) + self.assertNotIn(b, x) + self.assertRaises(OverflowError, len, x) + self.assertEqual(_range_len(x), expected_len) + self.assertEqual(x[0], a) + idx = sys.maxsize+1 + self.assertEqual(x[idx], a+idx) + self.assertEqual(x[idx:idx+1][0], a+idx) + with self.assertRaises(IndexError): + x[-expected_len-1] + with self.assertRaises(IndexError): + x[expected_len] + + a = 0 + b = 2 * sys.maxsize + expected_len = b - a + x = range(a, b) + self.assertIn(a, x) + self.assertNotIn(b, x) + self.assertRaises(OverflowError, len, x) + self.assertEqual(_range_len(x), expected_len) + self.assertEqual(x[0], a) + idx = sys.maxsize+1 + self.assertEqual(x[idx], a+idx) + self.assertEqual(x[idx:idx+1][0], a+idx) + with self.assertRaises(IndexError): + x[-expected_len-1] + with self.assertRaises(IndexError): + x[expected_len] + + a = 0 + b = sys.maxsize**10 + c = 2*sys.maxsize + expected_len = 1 + (b - a) // c + x = range(a, b, c) + self.assertIn(a, x) + self.assertNotIn(b, x) + self.assertRaises(OverflowError, len, x) + self.assertEqual(_range_len(x), expected_len) + self.assertEqual(x[0], a) + idx = sys.maxsize+1 + self.assertEqual(x[idx], a+(idx*c)) + self.assertEqual(x[idx:idx+1][0], a+(idx*c)) + with self.assertRaises(IndexError): + x[-expected_len-1] + with self.assertRaises(IndexError): + x[expected_len] + + a = sys.maxsize**10 + b = 0 + c = -2*sys.maxsize + expected_len = 1 + (b - a) // c + x = range(a, b, c) + self.assertIn(a, x) + self.assertNotIn(b, x) + self.assertRaises(OverflowError, len, x) + self.assertEqual(_range_len(x), expected_len) + self.assertEqual(x[0], a) + idx = sys.maxsize+1 + self.assertEqual(x[idx], a+(idx*c)) + self.assertEqual(x[idx:idx+1][0], a+(idx*c)) + with self.assertRaises(IndexError): + x[-expected_len-1] + with self.assertRaises(IndexError): + x[expected_len] + + def test_invalid_invocation(self): + self.assertRaises(TypeError, range) + self.assertRaises(TypeError, range, 1, 2, 3, 4) + self.assertRaises(ValueError, range, 1, 2, 0) + a = int(10 * sys.maxsize) + self.assertRaises(ValueError, range, a, a + 1, int(0)) + self.assertRaises(TypeError, range, 1., 1., 1.) + self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) + self.assertRaises(TypeError, range, 0, "spam") + self.assertRaises(TypeError, range, 0, 42, "spam") + # Exercise various combinations of bad arguments, to check + # refcounting logic + self.assertRaises(TypeError, range, 0.0) + self.assertRaises(TypeError, range, 0, 0.0) + self.assertRaises(TypeError, range, 0.0, 0) + self.assertRaises(TypeError, range, 0.0, 0.0) + self.assertRaises(TypeError, range, 0, 0, 1.0) + self.assertRaises(TypeError, range, 0, 0.0, 1) + self.assertRaises(TypeError, range, 0, 0.0, 1.0) + self.assertRaises(TypeError, range, 0.0, 0, 1) + self.assertRaises(TypeError, range, 0.0, 0, 1.0) + self.assertRaises(TypeError, range, 0.0, 0.0, 1) + self.assertRaises(TypeError, range, 0.0, 0.0, 1.0) + + def test_index(self): + u = range(2) + self.assertEqual(u.index(0), 0) + self.assertEqual(u.index(1), 1) + self.assertRaises(ValueError, u.index, 2) + + u = range(-2, 3) + self.assertEqual(u.count(0), 1) + self.assertEqual(u.index(0), 2) + self.assertRaises(TypeError, u.index) + + class BadExc(Exception): + pass + + class BadCmp: + def __eq__(self, other): + if other == 2: + raise BadExc() + return False + + a = range(4) + self.assertRaises(BadExc, a.index, BadCmp()) + + a = range(-2, 3) + self.assertEqual(a.index(0), 2) + self.assertEqual(range(1, 10, 3).index(4), 1) + self.assertEqual(range(1, -10, -3).index(-5), 2) + + self.assertEqual(range(10**20).index(1), 1) + self.assertEqual(range(10**20).index(10**20 - 1), 10**20 - 1) + + self.assertRaises(ValueError, range(1, 2**100, 2).index, 2**87) + self.assertEqual(range(1, 2**100, 2).index(2**87+1), 2**86) + + class AlwaysEqual(object): + def __eq__(self, other): + return True + always_equal = AlwaysEqual() + self.assertEqual(range(10).index(always_equal), 0) + + def test_user_index_method(self): + bignum = 2*sys.maxsize + smallnum = 42 + + # User-defined class with an __index__ method + class I: + def __init__(self, n): + self.n = int(n) + def __index__(self): + return self.n + self.assertEqual(list(range(I(bignum), I(bignum + 1))), [bignum]) + self.assertEqual(list(range(I(smallnum), I(smallnum + 1))), [smallnum]) + + # User-defined class with a failing __index__ method + class IX: + def __index__(self): + raise RuntimeError + self.assertRaises(RuntimeError, range, IX()) + + # User-defined class with an invalid __index__ method + class IN: + def __index__(self): + return "not a number" + + self.assertRaises(TypeError, range, IN()) + + def test_count(self): + self.assertEqual(range(3).count(-1), 0) + self.assertEqual(range(3).count(0), 1) + self.assertEqual(range(3).count(1), 1) + self.assertEqual(range(3).count(2), 1) + self.assertEqual(range(3).count(3), 0) + self.assertIs(type(range(3).count(-1)), int) + self.assertIs(type(range(3).count(1)), int) + self.assertEqual(range(10**20).count(1), 1) + self.assertEqual(range(10**20).count(10**20), 0) + self.assertEqual(range(3).index(1), 1) + self.assertEqual(range(1, 2**100, 2).count(2**87), 0) + self.assertEqual(range(1, 2**100, 2).count(2**87+1), 1) + + class AlwaysEqual(object): + def __eq__(self, other): + return True + always_equal = AlwaysEqual() + self.assertEqual(range(10).count(always_equal), 10) + + self.assertEqual(len(range(sys.maxsize, sys.maxsize+10)), 10) + def test_repr(self): self.assertEqual(repr(range(1)), 'range(0, 1)') self.assertEqual(repr(range(1, 2)), 'range(1, 2)') @@ -115,6 +355,62 @@ class RangeTest(unittest.TestCase): with self.assertRaises(TypeError): range([], 1, -1) + def test_types(self): + # Non-integer objects *equal* to any of the range's items are supposed + # to be contained in the range. + self.assertIn(1.0, range(3)) + self.assertIn(True, range(3)) + self.assertIn(1+0j, range(3)) + + class C1: + def __eq__(self, other): return True + self.assertIn(C1(), range(3)) + + # Objects are never coerced into other types for comparison. + class C2: + def __int__(self): return 1 + def __index__(self): return 1 + self.assertNotIn(C2(), range(3)) + # ..except if explicitly told so. + self.assertIn(int(C2()), range(3)) + + # Check that the range.__contains__ optimization is only + # used for ints, not for instances of subclasses of int. + class C3(int): + def __eq__(self, other): return True + self.assertIn(C3(11), range(10)) + self.assertIn(C3(11), list(range(10))) + + def test_strided_limits(self): + r = range(0, 101, 2) + self.assertIn(0, r) + self.assertNotIn(1, r) + self.assertIn(2, r) + self.assertNotIn(99, r) + self.assertIn(100, r) + self.assertNotIn(101, r) + + r = range(0, -20, -1) + self.assertIn(0, r) + self.assertIn(-1, r) + self.assertIn(-19, r) + self.assertNotIn(-20, r) + + r = range(0, -20, -2) + self.assertIn(-18, r) + self.assertNotIn(-19, r) + self.assertNotIn(-20, r) + + def test_empty(self): + r = range(0) + self.assertNotIn(0, r) + self.assertNotIn(1, r) + + r = range(0, -10) + self.assertNotIn(0, r) + self.assertNotIn(-1, r) + self.assertNotIn(1, r) + def test_range_iterators(self): # exercise 'fast' iterators, that use a rangeiterobject internally. # see issue 7298 @@ -139,6 +435,79 @@ class RangeTest(unittest.TestCase): test_id = "reversed(range({}, {}, {}))".format(start, end, step) self.assert_iterators_equal(iter1, iter2, test_id, limit=100) + def test_slice(self): + def check(start, stop, step=None): + i = slice(start, stop, step) + self.assertEqual(list(r[i]), list(r)[i]) + self.assertEqual(len(r[i]), len(list(r)[i])) + for r in [range(10), + range(0), + range(1, 9, 3), + range(8, 0, -3), + range(sys.maxsize+1, sys.maxsize+10), + ]: + check(0, 2) + check(0, 20) + check(1, 2) + check(20, 30) + check(-30, -20) + check(-1, 100, 2) + check(0, -1) + check(-1, -3, -1) + + def test_contains(self): + r = range(10) + self.assertIn(0, r) + self.assertIn(1, r) + self.assertIn(5.0, r) + self.assertNotIn(5.1, r) + self.assertNotIn(-1, r) + self.assertNotIn(10, r) + self.assertNotIn("", r) + r = range(9, -1, -1) + self.assertIn(0, r) + self.assertIn(1, r) + self.assertIn(5.0, r) + self.assertNotIn(5.1, r) + self.assertNotIn(-1, r) + self.assertNotIn(10, r) + self.assertNotIn("", r) + r = range(0, 10, 2) + self.assertIn(0, r) + self.assertNotIn(1, r) + self.assertNotIn(5.0, r) + self.assertNotIn(5.1, r) + self.assertNotIn(-1, r) + self.assertNotIn(10, r) + self.assertNotIn("", r) + r = range(9, -1, -2) + self.assertNotIn(0, r) + self.assertIn(1, r) + self.assertIn(5.0, r) + self.assertNotIn(5.1, r) + self.assertNotIn(-1, r) + self.assertNotIn(10, r) + self.assertNotIn("", r) + + def test_reverse_iteration(self): + for r in [range(10), + range(0), + range(1, 9, 3), + range(8, 0, -3), + range(sys.maxsize+1, sys.maxsize+10), + ]: + self.assertEqual(list(reversed(r)), list(r)[::-1]) + + def test_issue11845(self): + r = range(*slice(1, 18, 2).indices(20)) + values = {None, 0, 1, -1, 2, -2, 5, -5, 19, -19, + 20, -20, 21, -21, 30, -30, 99, -99} + for i in values: + for j in values: + for k in values - {0}: + r[i:j:k] + + def test_main(): test.support.run_unittest(RangeTest) |