# Python test set -- built-in functions | |
import test.test_support, unittest | |
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: | |
# replace stop with next element in the sequence of integers | |
# that are congruent to start modulo step. | |
stop += (start - stop) % step | |
while start != stop: | |
yield start | |
start += step | |
def pyrange_reversed(start, stop, step): | |
stop += (start - stop) % step | |
return pyrange(stop - step, start - step, -step) | |
class XrangeTest(unittest.TestCase): | |
def assert_iterators_equal(self, xs, ys, test_id, limit=None): | |
# check that an iterator xs matches the expected results ys, | |
# up to a given limit. | |
if limit is not None: | |
xs = itertools.islice(xs, limit) | |
ys = itertools.islice(ys, limit) | |
sentinel = object() | |
pairs = itertools.izip_longest(xs, ys, fillvalue=sentinel) | |
for i, (x, y) in enumerate(pairs): | |
if x == y: | |
continue | |
elif x == sentinel: | |
self.fail('{}: iterator ended unexpectedly ' | |
'at position {}; expected {}'.format(test_id, i, y)) | |
elif y == sentinel: | |
self.fail('{}: unexpected excess element {} at ' | |
'position {}'.format(test_id, x, i)) | |
else: | |
self.fail('{}: wrong element at position {};' | |
'expected {}, got {}'.format(test_id, i, y, x)) | |
def test_xrange(self): | |
self.assertEqual(list(xrange(3)), [0, 1, 2]) | |
self.assertEqual(list(xrange(1, 5)), [1, 2, 3, 4]) | |
self.assertEqual(list(xrange(0)), []) | |
self.assertEqual(list(xrange(-3)), []) | |
self.assertEqual(list(xrange(1, 10, 3)), [1, 4, 7]) | |
self.assertEqual(list(xrange(5, -5, -3)), [5, 2, -1, -4]) | |
a = 10 | |
b = 100 | |
c = 50 | |
self.assertEqual(list(xrange(a, a+2)), [a, a+1]) | |
self.assertEqual(list(xrange(a+2, a, -1L)), [a+2, a+1]) | |
self.assertEqual(list(xrange(a+4, a, -2)), [a+4, a+2]) | |
seq = list(xrange(a, b, c)) | |
self.assertIn(a, seq) | |
self.assertNotIn(b, seq) | |
self.assertEqual(len(seq), 2) | |
seq = list(xrange(b, a, -c)) | |
self.assertIn(b, seq) | |
self.assertNotIn(a, seq) | |
self.assertEqual(len(seq), 2) | |
seq = list(xrange(-a, -b, -c)) | |
self.assertIn(-a, seq) | |
self.assertNotIn(-b, seq) | |
self.assertEqual(len(seq), 2) | |
self.assertRaises(TypeError, xrange) | |
self.assertRaises(TypeError, xrange, 1, 2, 3, 4) | |
self.assertRaises(ValueError, xrange, 1, 2, 0) | |
self.assertRaises(OverflowError, xrange, 10**100, 10**101, 10**101) | |
self.assertRaises(TypeError, xrange, 0, "spam") | |
self.assertRaises(TypeError, xrange, 0, 42, "spam") | |
self.assertEqual(len(xrange(0, sys.maxint, sys.maxint-1)), 2) | |
self.assertRaises(OverflowError, xrange, -sys.maxint, sys.maxint) | |
self.assertRaises(OverflowError, xrange, 0, 2*sys.maxint) | |
r = xrange(-sys.maxint, sys.maxint, 2) | |
self.assertEqual(len(r), sys.maxint) | |
self.assertRaises(OverflowError, xrange, -sys.maxint-1, sys.maxint, 2) | |
def test_pickling(self): | |
testcases = [(13,), (0, 11), (-22, 10), (20, 3, -1), | |
(13, 21, 3), (-2, 2, 2)] | |
for proto in range(pickle.HIGHEST_PROTOCOL + 1): | |
for t in testcases: | |
r = xrange(*t) | |
self.assertEqual(list(pickle.loads(pickle.dumps(r, proto))), | |
list(r)) | |
def test_range_iterators(self): | |
# see issue 7298 | |
limits = [base + jiggle | |
for M in (2**32, 2**64) | |
for base in (-M, -M//2, 0, M//2, M) | |
for jiggle in (-2, -1, 0, 1, 2)] | |
test_ranges = [(start, end, step) | |
for start in limits | |
for end in limits | |
for step in (-2**63, -2**31, -2, -1, 1, 2)] | |
for start, end, step in test_ranges: | |
try: | |
iter1 = xrange(start, end, step) | |
except OverflowError: | |
pass | |
else: | |
iter2 = pyrange(start, end, step) | |
test_id = "xrange({}, {}, {})".format(start, end, step) | |
# check first 100 entries | |
self.assert_iterators_equal(iter1, iter2, test_id, limit=100) | |
try: | |
iter1 = reversed(xrange(start, end, step)) | |
except OverflowError: | |
pass | |
else: | |
iter2 = pyrange_reversed(start, end, step) | |
test_id = "reversed(xrange({}, {}, {}))".format(start, end, step) | |
self.assert_iterators_equal(iter1, iter2, test_id, limit=100) | |
def test_main(): | |
test.test_support.run_unittest(XrangeTest) | |
if __name__ == "__main__": | |
test_main() |