move sections
[python/dscho.git] / Lib / test / test_iterlen.py
blobab5466ecf99078202311728650ee6ff5607ae955
1 """ Test Iterator Length Transparency
3 Some functions or methods which accept general iterable arguments have
4 optional, more efficient code paths if they know how many items to expect.
5 For instance, map(func, iterable), will pre-allocate the exact amount of
6 space required whenever the iterable can report its length.
8 The desired invariant is: len(it)==len(list(it)).
10 A complication is that an iterable and iterator can be the same object. To
11 maintain the invariant, an iterator needs to dynamically update its length.
12 For instance, an iterable such as xrange(10) always reports its length as ten,
13 but it=iter(xrange(10)) starts at ten, and then goes to nine after it.next().
14 Having this capability means that map() can ignore the distinction between
15 map(func, iterable) and map(func, iter(iterable)).
17 When the iterable is immutable, the implementation can straight-forwardly
18 report the original length minus the cumulative number of calls to next().
19 This is the case for tuples, xrange objects, and itertools.repeat().
21 Some containers become temporarily immutable during iteration. This includes
22 dicts, sets, and collections.deque. Their implementation is equally simple
23 though they need to permantently set their length to zero whenever there is
24 an attempt to iterate after a length mutation.
26 The situation slightly more involved whenever an object allows length mutation
27 during iteration. Lists and sequence iterators are dynanamically updatable.
28 So, if a list is extended during iteration, the iterator will continue through
29 the new items. If it shrinks to a point before the most recent iteration,
30 then no further items are available and the length is reported at zero.
32 Reversed objects can also be wrapped around mutable objects; however, any
33 appends after the current position are ignored. Any other approach leads
34 to confusion and possibly returning the same item more than once.
36 The iterators not listed above, such as enumerate and the other itertools,
37 are not length transparent because they have no way to distinguish between
38 iterables that report static length and iterators whose length changes with
39 each call (i.e. the difference between enumerate('abc') and
40 enumerate(iter('abc')).
42 """
44 import unittest
45 from test import test_support
46 from itertools import repeat
47 from collections import deque
48 from __builtin__ import len as _len
50 n = 10
52 def len(obj):
53 try:
54 return _len(obj)
55 except TypeError:
56 try:
57 # note: this is an internal undocumented API,
58 # don't rely on it in your own programs
59 return obj.__length_hint__()
60 except AttributeError:
61 raise TypeError
63 class TestInvariantWithoutMutations(unittest.TestCase):
65 def test_invariant(self):
66 it = self.it
67 for i in reversed(xrange(1, n+1)):
68 self.assertEqual(len(it), i)
69 it.next()
70 self.assertEqual(len(it), 0)
71 self.assertRaises(StopIteration, it.next)
72 self.assertEqual(len(it), 0)
74 class TestTemporarilyImmutable(TestInvariantWithoutMutations):
76 def test_immutable_during_iteration(self):
77 # objects such as deques, sets, and dictionaries enforce
78 # length immutability during iteration
80 it = self.it
81 self.assertEqual(len(it), n)
82 it.next()
83 self.assertEqual(len(it), n-1)
84 self.mutate()
85 self.assertRaises(RuntimeError, it.next)
86 self.assertEqual(len(it), 0)
88 ## ------- Concrete Type Tests -------
90 class TestRepeat(TestInvariantWithoutMutations):
92 def setUp(self):
93 self.it = repeat(None, n)
95 def test_no_len_for_infinite_repeat(self):
96 # The repeat() object can also be infinite
97 self.assertRaises(TypeError, len, repeat(None))
99 class TestXrange(TestInvariantWithoutMutations):
101 def setUp(self):
102 self.it = iter(xrange(n))
104 class TestXrangeCustomReversed(TestInvariantWithoutMutations):
106 def setUp(self):
107 self.it = reversed(xrange(n))
109 class TestTuple(TestInvariantWithoutMutations):
111 def setUp(self):
112 self.it = iter(tuple(xrange(n)))
114 ## ------- Types that should not be mutated during iteration -------
116 class TestDeque(TestTemporarilyImmutable):
118 def setUp(self):
119 d = deque(xrange(n))
120 self.it = iter(d)
121 self.mutate = d.pop
123 class TestDequeReversed(TestTemporarilyImmutable):
125 def setUp(self):
126 d = deque(xrange(n))
127 self.it = reversed(d)
128 self.mutate = d.pop
130 class TestDictKeys(TestTemporarilyImmutable):
132 def setUp(self):
133 d = dict.fromkeys(xrange(n))
134 self.it = iter(d)
135 self.mutate = d.popitem
137 class TestDictItems(TestTemporarilyImmutable):
139 def setUp(self):
140 d = dict.fromkeys(xrange(n))
141 self.it = d.iteritems()
142 self.mutate = d.popitem
144 class TestDictValues(TestTemporarilyImmutable):
146 def setUp(self):
147 d = dict.fromkeys(xrange(n))
148 self.it = d.itervalues()
149 self.mutate = d.popitem
151 class TestSet(TestTemporarilyImmutable):
153 def setUp(self):
154 d = set(xrange(n))
155 self.it = iter(d)
156 self.mutate = d.pop
158 ## ------- Types that can mutate during iteration -------
160 class TestList(TestInvariantWithoutMutations):
162 def setUp(self):
163 self.it = iter(range(n))
165 def test_mutation(self):
166 d = range(n)
167 it = iter(d)
168 it.next()
169 it.next()
170 self.assertEqual(len(it), n-2)
171 d.append(n)
172 self.assertEqual(len(it), n-1) # grow with append
173 d[1:] = []
174 self.assertEqual(len(it), 0)
175 self.assertEqual(list(it), [])
176 d.extend(xrange(20))
177 self.assertEqual(len(it), 0)
179 class TestListReversed(TestInvariantWithoutMutations):
181 def setUp(self):
182 self.it = reversed(range(n))
184 def test_mutation(self):
185 d = range(n)
186 it = reversed(d)
187 it.next()
188 it.next()
189 self.assertEqual(len(it), n-2)
190 d.append(n)
191 self.assertEqual(len(it), n-2) # ignore append
192 d[1:] = []
193 self.assertEqual(len(it), 0)
194 self.assertEqual(list(it), []) # confirm invariant
195 d.extend(xrange(20))
196 self.assertEqual(len(it), 0)
198 ## -- Check to make sure exceptions are not suppressed by __length_hint__()
201 class BadLen(object):
202 def __iter__(self): return iter(range(10))
203 def __len__(self):
204 raise RuntimeError('hello')
206 class BadLengthHint(object):
207 def __iter__(self): return iter(range(10))
208 def __length_hint__(self):
209 raise RuntimeError('hello')
211 class NoneLengthHint(object):
212 def __iter__(self): return iter(range(10))
213 def __length_hint__(self):
214 return None
216 class TestLengthHintExceptions(unittest.TestCase):
218 def test_issue1242657(self):
219 self.assertRaises(RuntimeError, list, BadLen())
220 self.assertRaises(RuntimeError, list, BadLengthHint())
221 self.assertRaises(RuntimeError, [].extend, BadLen())
222 self.assertRaises(RuntimeError, [].extend, BadLengthHint())
223 self.assertRaises(RuntimeError, zip, BadLen())
224 self.assertRaises(RuntimeError, zip, BadLengthHint())
225 self.assertRaises(RuntimeError, filter, None, BadLen())
226 self.assertRaises(RuntimeError, filter, None, BadLengthHint())
227 self.assertRaises(RuntimeError, map, chr, BadLen())
228 self.assertRaises(RuntimeError, map, chr, BadLengthHint())
229 b = bytearray(range(10))
230 self.assertRaises(RuntimeError, b.extend, BadLen())
231 self.assertRaises(RuntimeError, b.extend, BadLengthHint())
233 def test_invalid_hint(self):
234 # Make sure an invalid result doesn't muck-up the works
235 self.assertEqual(list(NoneLengthHint()), list(range(10)))
238 def test_main():
239 unittests = [
240 TestRepeat,
241 TestXrange,
242 TestXrangeCustomReversed,
243 TestTuple,
244 TestDeque,
245 TestDequeReversed,
246 TestDictKeys,
247 TestDictItems,
248 TestDictValues,
249 TestSet,
250 TestList,
251 TestListReversed,
252 TestLengthHintExceptions,
254 test_support.run_unittest(*unittests)
256 if __name__ == "__main__":
257 test_main()