bernsteinbear.com
this repo has no description
1#!/usr/bin/env python3
2# Copyright (c) Facebook, Inc. and its affiliates. (http://www.facebook.com)
3import unittest
4from _collections import _deque_iterator, _deque_reverse_iterator, deque
5
6
7class DequeIteratorTests(unittest.TestCase):
8 def test_dunder_length_hint_returns_remaining(self):
9 d = deque(range(10))
10
11 it = _deque_iterator(d)
12 self.assertEqual(it.__length_hint__(), 10)
13 next(it)
14 self.assertEqual(it.__length_hint__(), 9)
15
16 it = _deque_iterator(d, 6)
17 self.assertEqual(it.__length_hint__(), 4)
18
19 def test_dunder_new_with_bad_args_raises_type_error(self):
20 d = deque()
21 self.assertRaises(TypeError, _deque_iterator.__new__, 1)
22 self.assertRaises(TypeError, _deque_iterator.__new__, int)
23 self.assertRaises(TypeError, _deque_iterator.__new__, _deque_iterator, [])
24 self.assertRaises(TypeError, _deque_iterator.__new__, _deque_iterator, d, "")
25
26 def test_dunder_new_without_index_sets_index_zero(self):
27 d = deque(range(10))
28 it = _deque_iterator(d)
29 self.assertEqual(list(it), list(d))
30
31 def test_dunder_new_with_index_truncates_to_deque_len(self):
32 d = deque(range(10))
33
34 it = _deque_iterator(d, -(2 ** 63))
35 self.assertEqual(list(it), list(d))
36
37 it = _deque_iterator(d, -1)
38 self.assertEqual(list(it), list(d))
39
40 it = _deque_iterator(d, 0)
41 self.assertEqual(list(it), list(d))
42
43 it = _deque_iterator(d, 3)
44 self.assertEqual(list(it), list(range(3, 10)))
45
46 it = _deque_iterator(d, 10)
47 self.assertEqual(list(it), [])
48
49 it = _deque_iterator(d, 12)
50 self.assertEqual(list(it), [])
51
52 it = _deque_iterator(d, 2 ** 63 - 1)
53 self.assertEqual(list(it), [])
54
55 def test_dunder_new_with_large_int_index_raises_overflow_error(self):
56 d = deque(range(10))
57 self.assertRaises(OverflowError, _deque_iterator, d, 2 ** 63)
58 self.assertRaises(OverflowError, _deque_iterator, d, -(2 ** 63) - 1)
59
60 def test_iter_returns_self(self):
61 d = deque(range(10))
62 it = _deque_iterator(d)
63 self.assertIs(iter(it), it)
64
65 def test_next_after_deque_append_raises_runtime_error(self):
66 d = deque(range(10))
67 it = _deque_iterator(d)
68 d.append(10)
69 self.assertRaises(RuntimeError, next, it)
70
71 def test_next_after_deque_pop_raises_runtime_error(self):
72 d = deque(range(10))
73 it = _deque_iterator(d)
74 d.pop()
75 self.assertRaises(RuntimeError, next, it)
76
77
78class DequeReverseIteratorTests(unittest.TestCase):
79 def test_dunder_length_hint_returns_remaining(self):
80 d = deque(range(10))
81
82 it = _deque_reverse_iterator(d)
83 self.assertEqual(it.__length_hint__(), 10)
84 next(it)
85 self.assertEqual(it.__length_hint__(), 9)
86
87 it = _deque_reverse_iterator(d, 6)
88 self.assertEqual(it.__length_hint__(), 4)
89
90 def test_dunder_new_with_bad_args_raises_type_error(self):
91 d = deque()
92 self.assertRaises(TypeError, _deque_reverse_iterator.__new__, 1)
93 self.assertRaises(TypeError, _deque_reverse_iterator.__new__, int)
94 self.assertRaises(
95 TypeError, _deque_reverse_iterator.__new__, _deque_reverse_iterator, []
96 )
97 self.assertRaises(
98 TypeError, _deque_reverse_iterator.__new__, _deque_reverse_iterator, d, ""
99 )
100
101 def test_dunder_new_without_index_sets_index_zero(self):
102 d = deque(range(10))
103 it = _deque_reverse_iterator(d)
104 self.assertEqual(list(it), list(range(9, -1, -1)))
105
106 def test_dunder_new_with_index_truncates_to_deque_len(self):
107 d = deque(range(10))
108 rev = list(range(9, -1, -1))
109
110 it = _deque_reverse_iterator(d, -(2 ** 63))
111 self.assertEqual(list(it), rev)
112
113 it = _deque_reverse_iterator(d, -1)
114 self.assertEqual(list(it), rev)
115
116 it = _deque_reverse_iterator(d, 0)
117 self.assertEqual(list(it), rev)
118
119 it = _deque_reverse_iterator(d, 3)
120 self.assertEqual(list(it), rev[3:])
121
122 it = _deque_reverse_iterator(d, 10)
123 self.assertEqual(list(it), [])
124
125 it = _deque_reverse_iterator(d, 12)
126 self.assertEqual(list(it), [])
127
128 it = _deque_reverse_iterator(d, 2 ** 63 - 1)
129 self.assertEqual(list(it), [])
130
131 def test_dunder_new_with_large_int_index_raises_overflow_error(self):
132 d = deque(range(10))
133 self.assertRaises(OverflowError, _deque_reverse_iterator, d, 2 ** 63)
134 self.assertRaises(OverflowError, _deque_reverse_iterator, d, -(2 ** 63) - 1)
135
136 def test_iter_returns_self(self):
137 d = deque(range(10))
138 it = _deque_reverse_iterator(d)
139 self.assertIs(iter(it), it)
140
141 def test_next_after_deque_append_raises_runtime_error(self):
142 d = deque(range(10))
143 it = _deque_reverse_iterator(d)
144 d.append(10)
145 self.assertRaises(RuntimeError, next, it)
146
147 def test_next_after_deque_pop_raises_runtime_error(self):
148 d = deque(range(10))
149 it = _deque_reverse_iterator(d)
150 d.pop()
151 self.assertRaises(RuntimeError, next, it)
152
153
154class DequeTests(unittest.TestCase):
155 def test_dunder_delitem_sets_item_at_index(self):
156 result = deque([1, 2, 3])
157 self.assertIsNone(result.__delitem__(1))
158 self.assertEqual(list(result), [1, 3])
159
160 def test_dunder_delitem_with_index_too_small_raises_index_error(self):
161 result = deque()
162 with self.assertRaises(IndexError) as context:
163 result.__delitem__(-1)
164 self.assertEqual(str(context.exception), "deque index out of range")
165
166 def test_dunder_delitem_with_index_too_large_raises_index_error(self):
167 result = deque([1, 2, 3])
168 with self.assertRaises(IndexError) as context:
169 result.__delitem__(3)
170 self.assertEqual(str(context.exception), "deque index out of range")
171
172 def test_dunder_delitem_with_negative_index_indexes_from_end(self):
173 result = deque([1, 2, 3])
174 self.assertIsNone(result.__delitem__(-1))
175 self.assertEqual(list(result), [1, 2])
176
177 def test_dunder_delitem_with_non_int_raises_type_error(self):
178 result = deque([1, 2, 3])
179 with self.assertRaises(TypeError):
180 result.__delitem__("3")
181
182 def test_dunder_delitem_with_slice_raises_type_error(self):
183 result = deque([1, 2, 3])
184 with self.assertRaises(TypeError):
185 result.__delitem__(slice(0, 2))
186
187 def test_dunder_getitem_returns_item_at_index(self):
188 result = deque()
189 result.append(1)
190 result.appendleft(0)
191 result.append(2)
192 result.appendleft(-1)
193 self.assertEqual(result.__getitem__(0), -1)
194 self.assertEqual(result.__getitem__(1), 0)
195 self.assertEqual(result.__getitem__(2), 1)
196 self.assertEqual(result.__getitem__(3), 2)
197
198 def test_dunder_getitem_with_index_too_small_raises_index_error(self):
199 result = deque()
200 with self.assertRaises(IndexError) as context:
201 result.__getitem__(-1)
202 self.assertEqual(str(context.exception), "deque index out of range")
203
204 def test_dunder_getitem_with_index_too_large_raises_index_error(self):
205 result = deque()
206 result.append(1)
207 result.append(2)
208 result.append(3)
209 with self.assertRaises(IndexError) as context:
210 result.__getitem__(3)
211 self.assertEqual(str(context.exception), "deque index out of range")
212
213 def test_dunder_getitem_with_negative_index_indexes_from_end(self):
214 result = deque()
215 result.append(1)
216 result.appendleft(0)
217 result.append(2)
218 result.appendleft(-1)
219 self.assertEqual(result.__getitem__(-1), 2)
220
221 def test_dunder_getitem_with_non_int_raises_type_error(self):
222 result = deque([1, 2, 3])
223 with self.assertRaises(TypeError):
224 result.__getitem__("3")
225
226 def test_dunder_getitem_with_slice_raises_type_error(self):
227 result = deque()
228 result.append(1)
229 result.append(2)
230 result.append(3)
231 self.assertRaises(TypeError, result.__getitem__, slice(0, 2))
232
233 def test_dunder_init_adds_elements_from_iterable(self):
234 result = deque([1, 2, 3])
235 self.assertEqual(len(result), 3)
236 self.assertEqual(1, result[0])
237 self.assertEqual(2, result[1])
238 self.assertEqual(3, result[2])
239
240 def test_dunder_init_clears_existing_deque(self):
241 d = deque([1, 2, 3])
242 self.assertEqual(len(d), 3)
243
244 d.__init__(d)
245 self.assertEqual(len(d), 0)
246
247 def test_dunder_init_with_large_int_raises_overflow_error(self):
248 with self.assertRaises(OverflowError):
249 deque(maxlen=2 ** 63 + 1)
250
251 def test_dunder_init_with_large_negative_int_raises_overflow_error(self):
252 with self.assertRaises(OverflowError):
253 deque(maxlen=-(2 ** 63) - 1)
254
255 def test_dunder_init_with_no_maxlen_returns_none(self):
256 result = deque()
257 self.assertEqual(result.maxlen, None)
258
259 def test_dunder_init_with_negative_maxlen_raises_value_error(self):
260 with self.assertRaises(ValueError):
261 deque(maxlen=(-1))
262
263 def test_dunder_init_with_non_int_raises_type_error(self):
264 with self.assertRaises(TypeError):
265 deque(maxlen="string")
266
267 def test_dunder_init_sets_maxlen(self):
268 result = deque(maxlen=5)
269 self.assertEqual(result.maxlen, 5)
270
271 def test_dunder_iter_returns_deque_iterator(self):
272 d = deque(range(10))
273 self.assertIsInstance(d.__iter__(), _deque_iterator)
274
275 def test_dunder_new(self):
276 result = deque.__new__(deque)
277 self.assertTrue(isinstance(result, deque))
278 self.assertEqual(result.maxlen, None)
279
280 def test_dunder_reversed_returns_deque__reverse_iterator(self):
281 d = deque(range(10))
282 self.assertIsInstance(d.__reversed__(), _deque_reverse_iterator)
283
284 def test_dunder_setitem_sets_item_at_index(self):
285 result = deque([1, 2, 3])
286 self.assertIsNone(result.__setitem__(0, 4))
287 self.assertIsNone(result.__setitem__(1, 5))
288 self.assertIsNone(result.__setitem__(2, 6))
289 self.assertEqual(list(result), [4, 5, 6])
290
291 def test_dunder_setitem_with_index_too_small_raises_index_error(self):
292 result = deque()
293 with self.assertRaises(IndexError) as context:
294 result.__setitem__(-1, None)
295 self.assertEqual(str(context.exception), "deque index out of range")
296
297 def test_dunder_setitem_with_index_too_large_raises_index_error(self):
298 result = deque([1, 2, 3])
299 with self.assertRaises(IndexError) as context:
300 result.__setitem__(3, None)
301 self.assertEqual(str(context.exception), "deque index out of range")
302
303 def test_dunder_setitem_with_negative_index_indexes_from_end(self):
304 result = deque([1, 2, 3])
305 self.assertIsNone(result.__setitem__(-1, 0))
306 self.assertEqual(list(result), [1, 2, 0])
307
308 def test_dunder_setitem_with_non_int_raises_type_error(self):
309 result = deque([1, 2, 3])
310 with self.assertRaises(TypeError):
311 result.__setitem__("3", None)
312
313 def test_dunder_setitem_with_slice_raises_type_error(self):
314 result = deque([1, 2, 3])
315 with self.assertRaises(TypeError):
316 result.__setitem__(slice(0, 2), None)
317
318 def test_append_adds_elements(self):
319 result = deque()
320 self.assertEqual(len(result), 0)
321 result.append(1)
322 result.append(2)
323 result.append(3)
324 self.assertEqual(len(result), 3)
325
326 def test_append_over_maxlen_removes_element_from_left(self):
327 result = deque(maxlen=3)
328 result.append(1)
329 result.append(2)
330 result.append(3)
331 result.append("foo")
332 self.assertEqual(len(result), 3)
333 self.assertEqual(result[0], 2)
334 self.assertEqual(result[1], 3)
335 self.assertEqual(result[2], "foo")
336
337 def test_append_over_zero_maxlen_does_nothing(self):
338 result = deque(maxlen=0)
339 result.append(1)
340 self.assertEqual(len(result), 0)
341
342 def test_appendleft_adds_elements_to_left(self):
343 result = deque()
344 self.assertEqual(len(result), 0)
345 result.appendleft(1)
346 result.appendleft(2)
347 result.appendleft(3)
348 self.assertEqual(len(result), 3)
349
350 def test_appendleft_over_maxlen_removes_element_from_right(self):
351 result = deque(maxlen=3)
352 result.appendleft(1)
353 result.appendleft(2)
354 result.appendleft(3)
355 result.appendleft("foo")
356 self.assertEqual(len(result), 3)
357 self.assertEqual(result[0], "foo")
358 self.assertEqual(result[1], 3)
359 self.assertEqual(result[2], 2)
360
361 def test_appendleft_over_zero_maxlen_does_nothing(self):
362 result = deque(maxlen=0)
363 result.appendleft(1)
364 self.assertEqual(len(result), 0)
365
366 def test_clear_removes_elements(self):
367 result = deque()
368 result.append(1)
369 result.append(2)
370 result.append(3)
371 self.assertEqual(len(result), 3)
372 result.clear()
373 self.assertEqual(len(result), 0)
374
375 def test_pop_from_empty_deque_raises_index_error(self):
376 result = deque()
377 self.assertRaises(IndexError, result.pop)
378
379 def test_pop_removes_element_from_right(self):
380 result = deque()
381 result.append(1)
382 result.append(2)
383 result.append(3)
384 result.pop()
385 self.assertEqual(len(result), 2)
386
387 def test_popleft_from_empty_deque_raises_index_error(self):
388 result = deque()
389 self.assertRaises(IndexError, result.popleft)
390
391 def test_popleft_removes_element_from_left(self):
392 result = deque()
393 result.append(1)
394 result.append(2)
395 result.append(3)
396 result.popleft()
397 self.assertEqual(len(result), 2)
398
399 def test_reverse_with_empty_deque_is_noop(self):
400 d = deque()
401 self.assertIsNone(d.reverse())
402 self.assertEqual(list(d), [])
403
404 def test_reverse_from_range_reverses_deque(self):
405 d = deque(range(5))
406 self.assertIsNone(d.reverse())
407 self.assertEqual(list(d), list(range(4, -1, -1)))
408
409 def test_reverse_with_longer_left_reverses_deque(self):
410 d = deque()
411 d.append(2)
412 d.append(1)
413 d.appendleft(3)
414 d.appendleft(4)
415 d.appendleft(5)
416 self.assertIsNone(d.reverse())
417 self.assertEqual(list(d), list(range(1, 6)))
418
419 def test_reverse_with_longer_right_reverses_deque(self):
420 d = deque()
421 d.append(3)
422 d.append(2)
423 d.append(1)
424 d.appendleft(4)
425 d.appendleft(5)
426 self.assertIsNone(d.reverse())
427 self.assertEqual(list(d), list(range(1, 6)))
428
429
430if __name__ == "__main__":
431 unittest.main()