bernsteinbear.com
this repo has no description
1#!/usr/bin/env python3
2# Copyright (c) Facebook, Inc. and its affiliates. (http://www.facebook.com)
3# WARNING: This is a temporary copy of code from the cpython library to
4# facilitate bringup. Please file a task for anything you change!
5# flake8: noqa
6# fmt: off
7
8# Python test set -- built-in functions
9
10import itertools
11import pickle
12import sys
13import unittest
14
15# pure Python implementations (3 args only), for comparison
16def pyrange(start, stop, step):
17 if (start - stop) // step < 0:
18 # replace stop with next element in the sequence of integers
19 # that are congruent to start modulo step.
20 stop += (start - stop) % step
21 while start != stop:
22 yield start
23 start += step
24
25def pyrange_reversed(start, stop, step):
26 stop += (start - stop) % step
27 return pyrange(stop - step, start - step, -step)
28
29
30class RangeTest(unittest.TestCase):
31 def assert_iterators_equal(self, xs, ys, test_id, limit=None):
32 # check that an iterator xs matches the expected results ys,
33 # up to a given limit.
34 if limit is not None:
35 xs = itertools.islice(xs, limit)
36 ys = itertools.islice(ys, limit)
37 sentinel = object()
38 pairs = itertools.zip_longest(xs, ys, fillvalue=sentinel)
39 for i, (x, y) in enumerate(pairs):
40 if x == y:
41 continue
42 elif x == sentinel:
43 self.fail('{}: iterator ended unexpectedly '
44 'at position {}; expected {}'.format(test_id, i, y))
45 elif y == sentinel:
46 self.fail('{}: unexpected excess element {} at '
47 'position {}'.format(test_id, x, i))
48 else:
49 self.fail('{}: wrong element at position {}; '
50 'expected {}, got {}'.format(test_id, i, y, x))
51
52 def test_range(self):
53 self.assertEqual(list(range(3)), [0, 1, 2])
54 self.assertEqual(list(range(1, 5)), [1, 2, 3, 4])
55 self.assertEqual(list(range(0)), [])
56 self.assertEqual(list(range(-3)), [])
57 self.assertEqual(list(range(1, 10, 3)), [1, 4, 7])
58 self.assertEqual(list(range(5, -5, -3)), [5, 2, -1, -4])
59
60 a = 10
61 b = 100
62 c = 50
63
64 self.assertEqual(list(range(a, a+2)), [a, a+1])
65 self.assertEqual(list(range(a+2, a, -1)), [a+2, a+1])
66 self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2])
67
68 seq = list(range(a, b, c))
69 self.assertIn(a, seq)
70 self.assertNotIn(b, seq)
71 self.assertEqual(len(seq), 2)
72
73 seq = list(range(b, a, -c))
74 self.assertIn(b, seq)
75 self.assertNotIn(a, seq)
76 self.assertEqual(len(seq), 2)
77
78 seq = list(range(-a, -b, -c))
79 self.assertIn(-a, seq)
80 self.assertNotIn(-b, seq)
81 self.assertEqual(len(seq), 2)
82
83 self.assertRaises(TypeError, range)
84 self.assertRaises(TypeError, range, 1, 2, 3, 4)
85 self.assertRaises(ValueError, range, 1, 2, 0)
86
87 self.assertRaises(TypeError, range, 0.0, 2, 1)
88 self.assertRaises(TypeError, range, 1, 2.0, 1)
89 self.assertRaises(TypeError, range, 1, 2, 1.0)
90 self.assertRaises(TypeError, range, 1e100, 1e101, 1e101)
91
92 self.assertRaises(TypeError, range, 0, "spam")
93 self.assertRaises(TypeError, range, 0, 42, "spam")
94
95 self.assertEqual(len(range(0, sys.maxsize, sys.maxsize-1)), 2)
96
97 r = range(-sys.maxsize, sys.maxsize, 2)
98 self.assertEqual(len(r), sys.maxsize)
99
100 def test_large_operands(self):
101 x = range(10**20, 10**20+10, 3)
102 self.assertEqual(len(x), 4)
103 self.assertEqual(len(list(x)), 4)
104
105 x = range(10**20+10, 10**20, 3)
106 self.assertEqual(len(x), 0)
107 self.assertEqual(len(list(x)), 0)
108 self.assertFalse(x)
109
110 x = range(10**20, 10**20+10, -3)
111 self.assertEqual(len(x), 0)
112 self.assertEqual(len(list(x)), 0)
113 self.assertFalse(x)
114
115 x = range(10**20+10, 10**20, -3)
116 self.assertEqual(len(x), 4)
117 self.assertEqual(len(list(x)), 4)
118 self.assertTrue(x)
119
120 # Now test range() with longs
121 for x in [range(-2**100),
122 range(0, -2**100),
123 range(0, 2**100, -1)]:
124 self.assertEqual(list(x), [])
125 self.assertFalse(x)
126
127 a = int(10 * sys.maxsize)
128 b = int(100 * sys.maxsize)
129 c = int(50 * sys.maxsize)
130
131 self.assertEqual(list(range(a, a+2)), [a, a+1])
132 self.assertEqual(list(range(a+2, a, -1)), [a+2, a+1])
133 self.assertEqual(list(range(a+4, a, -2)), [a+4, a+2])
134
135 seq = list(range(a, b, c))
136 self.assertIn(a, seq)
137 self.assertNotIn(b, seq)
138 self.assertEqual(len(seq), 2)
139 self.assertEqual(seq[0], a)
140 self.assertEqual(seq[-1], a+c)
141
142 seq = list(range(b, a, -c))
143 self.assertIn(b, seq)
144 self.assertNotIn(a, seq)
145 self.assertEqual(len(seq), 2)
146 self.assertEqual(seq[0], b)
147 self.assertEqual(seq[-1], b-c)
148
149 seq = list(range(-a, -b, -c))
150 self.assertIn(-a, seq)
151 self.assertNotIn(-b, seq)
152 self.assertEqual(len(seq), 2)
153 self.assertEqual(seq[0], -a)
154 self.assertEqual(seq[-1], -a-c)
155
156 def test_large_range(self):
157 # Check long ranges (len > sys.maxsize)
158 # len() is expected to fail due to limitations of the __len__ protocol
159 def _range_len(x):
160 try:
161 length = len(x)
162 except OverflowError:
163 step = x[1] - x[0]
164 length = 1 + ((x[-1] - x[0]) // step)
165 return length
166
167 a = -sys.maxsize
168 b = sys.maxsize
169 expected_len = b - a
170 x = range(a, b)
171 self.assertIn(a, x)
172 self.assertNotIn(b, x)
173 self.assertRaises(OverflowError, len, x)
174 self.assertTrue(x)
175 self.assertEqual(_range_len(x), expected_len)
176 self.assertEqual(x[0], a)
177 idx = sys.maxsize+1
178 self.assertEqual(x[idx], a+idx)
179 self.assertEqual(x[idx:idx+1][0], a+idx)
180 with self.assertRaises(IndexError):
181 x[-expected_len-1]
182 with self.assertRaises(IndexError):
183 x[expected_len]
184
185 a = 0
186 b = 2 * sys.maxsize
187 expected_len = b - a
188 x = range(a, b)
189 self.assertIn(a, x)
190 self.assertNotIn(b, x)
191 self.assertRaises(OverflowError, len, x)
192 self.assertTrue(x)
193 self.assertEqual(_range_len(x), expected_len)
194 self.assertEqual(x[0], a)
195 idx = sys.maxsize+1
196 self.assertEqual(x[idx], a+idx)
197 self.assertEqual(x[idx:idx+1][0], a+idx)
198 with self.assertRaises(IndexError):
199 x[-expected_len-1]
200 with self.assertRaises(IndexError):
201 x[expected_len]
202
203 a = 0
204 b = sys.maxsize**10
205 c = 2*sys.maxsize
206 expected_len = 1 + (b - a) // c
207 x = range(a, b, c)
208 self.assertIn(a, x)
209 self.assertNotIn(b, x)
210 self.assertRaises(OverflowError, len, x)
211 self.assertTrue(x)
212 self.assertEqual(_range_len(x), expected_len)
213 self.assertEqual(x[0], a)
214 idx = sys.maxsize+1
215 self.assertEqual(x[idx], a+(idx*c))
216 self.assertEqual(x[idx:idx+1][0], a+(idx*c))
217 with self.assertRaises(IndexError):
218 x[-expected_len-1]
219 with self.assertRaises(IndexError):
220 x[expected_len]
221
222 a = sys.maxsize**10
223 b = 0
224 c = -2*sys.maxsize
225 expected_len = 1 + (b - a) // c
226 x = range(a, b, c)
227 self.assertIn(a, x)
228 self.assertNotIn(b, x)
229 self.assertRaises(OverflowError, len, x)
230 self.assertTrue(x)
231 self.assertEqual(_range_len(x), expected_len)
232 self.assertEqual(x[0], a)
233 idx = sys.maxsize+1
234 self.assertEqual(x[idx], a+(idx*c))
235 self.assertEqual(x[idx:idx+1][0], a+(idx*c))
236 with self.assertRaises(IndexError):
237 x[-expected_len-1]
238 with self.assertRaises(IndexError):
239 x[expected_len]
240
241 def test_invalid_invocation(self):
242 self.assertRaises(TypeError, range)
243 self.assertRaises(TypeError, range, 1, 2, 3, 4)
244 self.assertRaises(ValueError, range, 1, 2, 0)
245 a = int(10 * sys.maxsize)
246 self.assertRaises(ValueError, range, a, a + 1, int(0))
247 self.assertRaises(TypeError, range, 1., 1., 1.)
248 self.assertRaises(TypeError, range, 1e100, 1e101, 1e101)
249 self.assertRaises(TypeError, range, 0, "spam")
250 self.assertRaises(TypeError, range, 0, 42, "spam")
251 # Exercise various combinations of bad arguments, to check
252 # refcounting logic
253 self.assertRaises(TypeError, range, 0.0)
254 self.assertRaises(TypeError, range, 0, 0.0)
255 self.assertRaises(TypeError, range, 0.0, 0)
256 self.assertRaises(TypeError, range, 0.0, 0.0)
257 self.assertRaises(TypeError, range, 0, 0, 1.0)
258 self.assertRaises(TypeError, range, 0, 0.0, 1)
259 self.assertRaises(TypeError, range, 0, 0.0, 1.0)
260 self.assertRaises(TypeError, range, 0.0, 0, 1)
261 self.assertRaises(TypeError, range, 0.0, 0, 1.0)
262 self.assertRaises(TypeError, range, 0.0, 0.0, 1)
263 self.assertRaises(TypeError, range, 0.0, 0.0, 1.0)
264
265 def test_index(self):
266 u = range(2)
267 self.assertEqual(u.index(0), 0)
268 self.assertEqual(u.index(1), 1)
269 self.assertRaises(ValueError, u.index, 2)
270
271 u = range(-2, 3)
272 self.assertEqual(u.count(0), 1)
273 self.assertEqual(u.index(0), 2)
274 self.assertRaises(TypeError, u.index)
275
276 class BadExc(Exception):
277 pass
278
279 class BadCmp:
280 def __eq__(self, other):
281 if other == 2:
282 raise BadExc()
283 return False
284
285 a = range(4)
286 self.assertRaises(BadExc, a.index, BadCmp())
287
288 a = range(-2, 3)
289 self.assertEqual(a.index(0), 2)
290 self.assertEqual(range(1, 10, 3).index(4), 1)
291 self.assertEqual(range(1, -10, -3).index(-5), 2)
292
293 self.assertEqual(range(10**20).index(1), 1)
294 self.assertEqual(range(10**20).index(10**20 - 1), 10**20 - 1)
295
296 self.assertRaises(ValueError, range(1, 2**100, 2).index, 2**87)
297 self.assertEqual(range(1, 2**100, 2).index(2**87+1), 2**86)
298
299 class AlwaysEqual(object):
300 def __eq__(self, other):
301 return True
302 always_equal = AlwaysEqual()
303 self.assertEqual(range(10).index(always_equal), 0)
304
305 def test_user_index_method(self):
306 bignum = 2*sys.maxsize
307 smallnum = 42
308
309 # User-defined class with an __index__ method
310 class I:
311 def __init__(self, n):
312 self.n = int(n)
313 def __index__(self):
314 return self.n
315 self.assertEqual(list(range(I(bignum), I(bignum + 1))), [bignum])
316 self.assertEqual(list(range(I(smallnum), I(smallnum + 1))), [smallnum])
317
318 # User-defined class with a failing __index__ method
319 class IX:
320 def __index__(self):
321 raise RuntimeError
322 self.assertRaises(RuntimeError, range, IX())
323
324 # User-defined class with an invalid __index__ method
325 class IN:
326 def __index__(self):
327 return "not a number"
328
329 self.assertRaises(TypeError, range, IN())
330
331 # Test use of user-defined classes in slice indices.
332 self.assertEqual(range(10)[:I(5)], range(5))
333
334 with self.assertRaises(RuntimeError):
335 range(0, 10)[:IX()]
336
337 with self.assertRaises(TypeError):
338 range(0, 10)[:IN()]
339
340 def test_count(self):
341 self.assertEqual(range(3).count(-1), 0)
342 self.assertEqual(range(3).count(0), 1)
343 self.assertEqual(range(3).count(1), 1)
344 self.assertEqual(range(3).count(2), 1)
345 self.assertEqual(range(3).count(3), 0)
346 self.assertIs(type(range(3).count(-1)), int)
347 self.assertIs(type(range(3).count(1)), int)
348 self.assertEqual(range(10**20).count(1), 1)
349 self.assertEqual(range(10**20).count(10**20), 0)
350 self.assertEqual(range(3).index(1), 1)
351 self.assertEqual(range(1, 2**100, 2).count(2**87), 0)
352 self.assertEqual(range(1, 2**100, 2).count(2**87+1), 1)
353
354 class AlwaysEqual(object):
355 def __eq__(self, other):
356 return True
357 always_equal = AlwaysEqual()
358 self.assertEqual(range(10).count(always_equal), 10)
359
360 self.assertEqual(len(range(sys.maxsize, sys.maxsize+10)), 10)
361
362 def test_repr(self):
363 self.assertEqual(repr(range(1)), 'range(0, 1)')
364 self.assertEqual(repr(range(1, 2)), 'range(1, 2)')
365 self.assertEqual(repr(range(1, 2, 3)), 'range(1, 2, 3)')
366
367 def test_pickling(self):
368 testcases = [(13,), (0, 11), (-22, 10), (20, 3, -1),
369 (13, 21, 3), (-2, 2, 2), (2**65, 2**65+2)]
370 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
371 for t in testcases:
372 with self.subTest(proto=proto, test=t):
373 r = range(*t)
374 self.assertEqual(list(pickle.loads(pickle.dumps(r, proto))),
375 list(r))
376
377 # TODO(T54077858): Implement range_iterator.__reduce__
378 @unittest.skip("Range iterator pickling needed")
379 def test_iterator_pickling(self):
380 testcases = [(13,), (0, 11), (-22, 10), (20, 3, -1),
381 (13, 21, 3), (-2, 2, 2), (2**65, 2**65+2)]
382 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
383 for t in testcases:
384 it = itorg = iter(range(*t))
385 data = list(range(*t))
386
387 d = pickle.dumps(it, proto)
388 it = pickle.loads(d)
389 self.assertEqual(type(itorg), type(it))
390 self.assertEqual(list(it), data)
391
392 it = pickle.loads(d)
393 try:
394 next(it)
395 except StopIteration:
396 continue
397 d = pickle.dumps(it, proto)
398 it = pickle.loads(d)
399 self.assertEqual(list(it), data[1:])
400
401 # TODO(T54077858): Implement range_iterator.__reduce__
402 @unittest.skip("Range iterator pickling needed")
403 def test_exhausted_iterator_pickling(self):
404 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
405 r = range(2**65, 2**65+2)
406 i = iter(r)
407 while True:
408 r = next(i)
409 if r == 2**65+1:
410 break
411 d = pickle.dumps(i, proto)
412 i2 = pickle.loads(d)
413 self.assertEqual(list(i), [])
414 self.assertEqual(list(i2), [])
415
416 # TODO(T54077858): Implement longrange_iterator.__reduce__
417 @unittest.skip("Long range iterator pickling needed")
418 def test_large_exhausted_iterator_pickling(self):
419 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
420 r = range(20)
421 i = iter(r)
422 while True:
423 r = next(i)
424 if r == 19:
425 break
426 d = pickle.dumps(i, proto)
427 i2 = pickle.loads(d)
428 self.assertEqual(list(i), [])
429 self.assertEqual(list(i2), [])
430
431 def test_odd_bug(self):
432 # This used to raise a "SystemError: NULL result without error"
433 # because the range validation step was eating the exception
434 # before NULL was returned.
435 with self.assertRaises(TypeError):
436 range([], 1, -1)
437
438 def test_types(self):
439 # Non-integer objects *equal* to any of the range's items are supposed
440 # to be contained in the range.
441 self.assertIn(1.0, range(3))
442 self.assertIn(True, range(3))
443 self.assertIn(1+0j, range(3))
444
445 class C1:
446 def __eq__(self, other): return True
447 self.assertIn(C1(), range(3))
448
449 # Objects are never coerced into other types for comparison.
450 class C2:
451 def __int__(self): return 1
452 def __index__(self): return 1
453 self.assertNotIn(C2(), range(3))
454 # ..except if explicitly told so.
455 self.assertIn(int(C2()), range(3))
456
457 # Check that the range.__contains__ optimization is only
458 # used for ints, not for instances of subclasses of int.
459 class C3(int):
460 def __eq__(self, other): return True
461 self.assertIn(C3(11), range(10))
462 self.assertIn(C3(11), list(range(10)))
463
464 def test_strided_limits(self):
465 r = range(0, 101, 2)
466 self.assertIn(0, r)
467 self.assertNotIn(1, r)
468 self.assertIn(2, r)
469 self.assertNotIn(99, r)
470 self.assertIn(100, r)
471 self.assertNotIn(101, r)
472
473 r = range(0, -20, -1)
474 self.assertIn(0, r)
475 self.assertIn(-1, r)
476 self.assertIn(-19, r)
477 self.assertNotIn(-20, r)
478
479 r = range(0, -20, -2)
480 self.assertIn(-18, r)
481 self.assertNotIn(-19, r)
482 self.assertNotIn(-20, r)
483
484 def test_empty(self):
485 r = range(0)
486 self.assertNotIn(0, r)
487 self.assertNotIn(1, r)
488
489 r = range(0, -10)
490 self.assertNotIn(0, r)
491 self.assertNotIn(-1, r)
492 self.assertNotIn(1, r)
493
494 def test_range_iterators(self):
495 # exercise 'fast' iterators, that use a rangeiterobject internally.
496 # see issue 7298
497 limits = [base + jiggle
498 for M in (2**32, 2**64)
499 for base in (-M, -M//2, 0, M//2, M)
500 for jiggle in (-2, -1, 0, 1, 2)]
501 test_ranges = [(start, end, step)
502 for start in limits
503 for end in limits
504 for step in (-2**63, -2**31, -2, -1, 1, 2)]
505
506 for start, end, step in test_ranges:
507 iter1 = range(start, end, step)
508 iter2 = pyrange(start, end, step)
509 test_id = "range({}, {}, {})".format(start, end, step)
510 # check first 100 entries
511 self.assert_iterators_equal(iter1, iter2, test_id, limit=100)
512
513 iter1 = reversed(range(start, end, step))
514 iter2 = pyrange_reversed(start, end, step)
515 test_id = "reversed(range({}, {}, {}))".format(start, end, step)
516 self.assert_iterators_equal(iter1, iter2, test_id, limit=100)
517
518 def test_range_iterators_invocation(self):
519 # verify range iterators instances cannot be created by
520 # calling their type
521 rangeiter_type = type(iter(range(0)))
522 self.assertRaises(TypeError, rangeiter_type, 1, 3, 1)
523 long_rangeiter_type = type(iter(range(1 << 1000)))
524 self.assertRaises(TypeError, long_rangeiter_type, 1, 3, 1)
525
526 def test_slice(self):
527 def check(start, stop, step=None):
528 i = slice(start, stop, step)
529 self.assertEqual(list(r[i]), list(r)[i])
530 self.assertEqual(len(r[i]), len(list(r)[i]))
531 for r in [range(10),
532 range(0),
533 range(1, 9, 3),
534 range(8, 0, -3),
535 range(sys.maxsize+1, sys.maxsize+10),
536 ]:
537 check(0, 2)
538 check(0, 20)
539 check(1, 2)
540 check(20, 30)
541 check(-30, -20)
542 check(-1, 100, 2)
543 check(0, -1)
544 check(-1, -3, -1)
545
546 def test_contains(self):
547 r = range(10)
548 self.assertIn(0, r)
549 self.assertIn(1, r)
550 self.assertIn(5.0, r)
551 self.assertNotIn(5.1, r)
552 self.assertNotIn(-1, r)
553 self.assertNotIn(10, r)
554 self.assertNotIn("", r)
555 r = range(9, -1, -1)
556 self.assertIn(0, r)
557 self.assertIn(1, r)
558 self.assertIn(5.0, r)
559 self.assertNotIn(5.1, r)
560 self.assertNotIn(-1, r)
561 self.assertNotIn(10, r)
562 self.assertNotIn("", r)
563 r = range(0, 10, 2)
564 self.assertIn(0, r)
565 self.assertNotIn(1, r)
566 self.assertNotIn(5.0, r)
567 self.assertNotIn(5.1, r)
568 self.assertNotIn(-1, r)
569 self.assertNotIn(10, r)
570 self.assertNotIn("", r)
571 r = range(9, -1, -2)
572 self.assertNotIn(0, r)
573 self.assertIn(1, r)
574 self.assertIn(5.0, r)
575 self.assertNotIn(5.1, r)
576 self.assertNotIn(-1, r)
577 self.assertNotIn(10, r)
578 self.assertNotIn("", r)
579
580 def test_reverse_iteration(self):
581 for r in [range(10),
582 range(0),
583 range(1, 9, 3),
584 range(8, 0, -3),
585 range(sys.maxsize+1, sys.maxsize+10),
586 ]:
587 self.assertEqual(list(reversed(r)), list(r)[::-1])
588
589 def test_issue11845(self):
590 r = range(*slice(1, 18, 2).indices(20))
591 values = {None, 0, 1, -1, 2, -2, 5, -5, 19, -19,
592 20, -20, 21, -21, 30, -30, 99, -99}
593 for i in values:
594 for j in values:
595 for k in values - {0}:
596 r[i:j:k]
597
598 def test_comparison(self):
599 test_ranges = [range(0), range(0, -1), range(1, 1, 3),
600 range(1), range(5, 6), range(5, 6, 2),
601 range(5, 7, 2), range(2), range(0, 4, 2),
602 range(0, 5, 2), range(0, 6, 2)]
603 test_tuples = list(map(tuple, test_ranges))
604
605 # Check that equality of ranges matches equality of the corresponding
606 # tuples for each pair from the test lists above.
607 ranges_eq = [a == b for a in test_ranges for b in test_ranges]
608 tuples_eq = [a == b for a in test_tuples for b in test_tuples]
609 self.assertEqual(ranges_eq, tuples_eq)
610
611 # Check that != correctly gives the logical negation of ==
612 ranges_ne = [a != b for a in test_ranges for b in test_ranges]
613 self.assertEqual(ranges_ne, [not x for x in ranges_eq])
614
615 # Equal ranges should have equal hashes.
616 for a in test_ranges:
617 for b in test_ranges:
618 if a == b:
619 self.assertEqual(hash(a), hash(b))
620
621 # Ranges are unequal to other types (even sequence types)
622 self.assertIs(range(0) == (), False)
623 self.assertIs(() == range(0), False)
624 self.assertIs(range(2) == [0, 1], False)
625
626 # Huge integers aren't a problem.
627 self.assertEqual(range(0, 2**100 - 1, 2),
628 range(0, 2**100, 2))
629 self.assertEqual(hash(range(0, 2**100 - 1, 2)),
630 hash(range(0, 2**100, 2)))
631 self.assertNotEqual(range(0, 2**100, 2),
632 range(0, 2**100 + 1, 2))
633 self.assertEqual(range(2**200, 2**201 - 2**99, 2**100),
634 range(2**200, 2**201, 2**100))
635 self.assertEqual(hash(range(2**200, 2**201 - 2**99, 2**100)),
636 hash(range(2**200, 2**201, 2**100)))
637 self.assertNotEqual(range(2**200, 2**201, 2**100),
638 range(2**200, 2**201 + 1, 2**100))
639
640 # Order comparisons are not implemented for ranges.
641 with self.assertRaises(TypeError):
642 range(0) < range(0)
643 with self.assertRaises(TypeError):
644 range(0) > range(0)
645 with self.assertRaises(TypeError):
646 range(0) <= range(0)
647 with self.assertRaises(TypeError):
648 range(0) >= range(0)
649
650
651 def test_attributes(self):
652 # test the start, stop and step attributes of range objects
653 self.assert_attrs(range(0), 0, 0, 1)
654 self.assert_attrs(range(10), 0, 10, 1)
655 self.assert_attrs(range(-10), 0, -10, 1)
656 self.assert_attrs(range(0, 10, 1), 0, 10, 1)
657 self.assert_attrs(range(0, 10, 3), 0, 10, 3)
658 self.assert_attrs(range(10, 0, -1), 10, 0, -1)
659 self.assert_attrs(range(10, 0, -3), 10, 0, -3)
660
661 def assert_attrs(self, rangeobj, start, stop, step):
662 self.assertEqual(rangeobj.start, start)
663 self.assertEqual(rangeobj.stop, stop)
664 self.assertEqual(rangeobj.step, step)
665
666 with self.assertRaises(AttributeError):
667 rangeobj.start = 0
668 with self.assertRaises(AttributeError):
669 rangeobj.stop = 10
670 with self.assertRaises(AttributeError):
671 rangeobj.step = 1
672
673 with self.assertRaises(AttributeError):
674 del rangeobj.start
675 with self.assertRaises(AttributeError):
676 del rangeobj.stop
677 with self.assertRaises(AttributeError):
678 del rangeobj.step
679
680if __name__ == "__main__":
681 unittest.main()