Lines Matching refs:self
23 def __hash__(self):
25 def __eq__(self, other):
29 'Used to test self-referential repr() calls'
30 def __repr__(self):
31 return repr(self.value)
35 def __init__(self, *args):
36 self.hash_count = 0
37 def __hash__(self):
38 self.hash_count += 1
39 return int.__hash__(self)
44 def setUp(self):
45 self.word = word = 'simsalabim'
46 self.otherword = 'madagascar'
47 self.letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
48 self.s = self.thetype(word)
49 self.d = dict.fromkeys(word)
51 def test_new_or_init(self):
52 self.assertRaises(TypeError, self.thetype, [], 2)
53 self.assertRaises(TypeError, set().__init__, a=1)
55 def test_uniquification(self):
56 actual = sorted(self.s)
57 expected = sorted(self.d)
58 self.assertEqual(actual, expected)
59 self.assertRaises(PassThru, self.thetype, check_pass_thru())
60 self.assertRaises(TypeError, self.thetype, [[]])
62 def test_len(self):
63 self.assertEqual(len(self.s), len(self.d))
65 def test_contains(self):
66 for c in self.letters:
67 self.assertEqual(c in self.s, c in self.d)
68 self.assertRaises(TypeError, self.s.__contains__, [[]])
69 s = self.thetype([frozenset(self.letters)])
70 self.assertIn(self.thetype(self.letters), s)
72 def test_union(self):
73 u = self.s.union(self.otherword)
74 for c in self.letters:
75 self.assertEqual(c in u, c in self.d or c in self.otherword)
76 self.assertEqual(self.s, self.thetype(self.word))
77 self.assertEqual(type(u), self.basetype)
78 self.assertRaises(PassThru, self.s.union, check_pass_thru())
79 self.assertRaises(TypeError, self.s.union, [[]])
81 self.assertEqual(self.thetype('abcba').union(C('cdc')), set('abcd'))
82 self.assertEqual(self.thetype('abcba').union(C('efgfe')), set('abcefg'))
83 self.assertEqual(self.thetype('abcba').union(C('ccb')), set('abc'))
84 self.assertEqual(self.thetype('abcba').union(C('ef')), set('abcef'))
85 self.assertEqual(self.thetype('abcba').union(C('ef'), C('fg')), set('abcefg'))
88 x = self.thetype()
89 self.assertEqual(x.union(set([1]), x, set([2])), self.thetype([1, 2]))
91 def test_or(self):
92 i = self.s.union(self.otherword)
93 self.assertEqual(self.s | set(self.otherword), i)
94 self.assertEqual(self.s | frozenset(self.otherword), i)
96 self.s | self.otherword
100 self.fail("s|t did not screen-out general iterables")
102 def test_intersection(self):
103 i = self.s.intersection(self.otherword)
104 for c in self.letters:
105 self.assertEqual(c in i, c in self.d and c in self.otherword)
106 self.assertEqual(self.s, self.thetype(self.word))
107 self.assertEqual(type(i), self.basetype)
108 self.assertRaises(PassThru, self.s.intersection, check_pass_thru())
110 self.assertEqual(self.thetype('abcba').intersection(C('cdc')), set('cc'))
111 self.assertEqual(self.thetype('abcba').intersection(C('efgfe')), set(''))
112 self.assertEqual(self.thetype('abcba').intersection(C('ccb')), set('bc'))
113 self.assertEqual(self.thetype('abcba').intersection(C('ef')), set(''))
114 self.assertEqual(self.thetype('abcba').intersection(C('cbcf'), C('bag')), set('b'))
115 s = self.thetype('abcba')
117 if self.thetype == frozenset():
118 self.assertEqual(id(s), id(z))
120 self.assertNotEqual(id(s), id(z))
122 def test_isdisjoint(self):
127 s1 = self.thetype(larg)
133 self.assertEqual(actual, expected)
134 self.assertTrue(actual is True or actual is False)
136 def test_and(self):
137 i = self.s.intersection(self.otherword)
138 self.assertEqual(self.s & set(self.otherword), i)
139 self.assertEqual(self.s & frozenset(self.otherword), i)
141 self.s & self.otherword
145 self.fail("s&t did not screen-out general iterables")
147 def test_difference(self):
148 i = self.s.difference(self.otherword)
149 for c in self.letters:
150 self.assertEqual(c in i, c in self.d and c not in self.otherword)
151 self.assertEqual(self.s, self.thetype(self.word))
152 self.assertEqual(type(i), self.basetype)
153 self.assertRaises(PassThru, self.s.difference, check_pass_thru())
154 self.assertRaises(TypeError, self.s.difference, [[]])
156 self.assertEqual(self.thetype('abcba').difference(C('cdc')), set('ab'))
157 self.assertEqual(self.thetype('abcba').difference(C('efgfe')), set('abc'))
158 self.assertEqual(self.thetype('abcba').difference(C('ccb')), set('a'))
159 self.assertEqual(self.thetype('abcba').difference(C('ef')), set('abc'))
160 self.assertEqual(self.thetype('abcba').difference(), set('abc'))
161 self.assertEqual(self.thetype('abcba').difference(C('a'), C('b')), set('c'))
163 def test_sub(self):
164 i = self.s.difference(self.otherword)
165 self.assertEqual(self.s - set(self.otherword), i)
166 self.assertEqual(self.s - frozenset(self.otherword), i)
168 self.s - self.otherword
172 self.fail("s-t did not screen-out general iterables")
174 def test_symmetric_difference(self):
175 i = self.s.symmetric_difference(self.otherword)
176 for c in self.letters:
177 self.assertEqual(c in i, (c in self.d) ^ (c in self.otherword))
178 self.assertEqual(self.s, self.thetype(self.word))
179 self.assertEqual(type(i), self.basetype)
180 self.assertRaises(PassThru, self.s.symmetric_difference, check_pass_thru())
181 self.assertRaises(TypeError, self.s.symmetric_difference, [[]])
183 self.assertEqual(self.thetype('abcba').symmetric_difference(C('cdc')), set('abd'))
184 self.assertEqual(self.thetype('abcba').symmetric_difference(C('efgfe')), set('abcefg'))
185 self.assertEqual(self.thetype('abcba').symmetric_difference(C('ccb')), set('a'))
186 self.assertEqual(self.thetype('abcba').symmetric_difference(C('ef')), set('abcef'))
188 def test_xor(self):
189 i = self.s.symmetric_difference(self.otherword)
190 self.assertEqual(self.s ^ set(self.otherword), i)
191 self.assertEqual(self.s ^ frozenset(self.otherword), i)
193 self.s ^ self.otherword
197 self.fail("s^t did not screen-out general iterables")
199 def test_equality(self):
200 self.assertEqual(self.s, set(self.word))
201 self.assertEqual(self.s, frozenset(self.word))
202 self.assertEqual(self.s == self.word, False)
203 self.assertNotEqual(self.s, set(self.otherword))
204 self.assertNotEqual(self.s, frozenset(self.otherword))
205 self.assertEqual(self.s != self.word, True)
207 def test_setOfFrozensets(self):
209 s = self.thetype(t)
210 self.assertEqual(len(s), 3)
212 def test_sub_and_super(self):
213 p, q, r = map(self.thetype, ['ab', 'abcde', 'def'])
214 self.assertTrue(p < q)
215 self.assertTrue(p <= q)
216 self.assertTrue(q <= q)
217 self.assertTrue(q > p)
218 self.assertTrue(q >= p)
219 self.assertFalse(q < r)
220 self.assertFalse(q <= r)
221 self.assertFalse(q > r)
222 self.assertFalse(q >= r)
223 self.assertTrue(set('a').issubset('abc'))
224 self.assertTrue(set('abc').issuperset('a'))
225 self.assertFalse(set('a').issubset('cbs'))
226 self.assertFalse(set('cbs').issuperset('a'))
228 def test_pickling(self):
230 if type(self.s) not in (set, frozenset):
231 self.s.x = ['x']
232 self.s.z = ['z']
233 p = pickle.dumps(self.s, i)
235 self.assertEqual(self.s, dup, "%s != %s" % (self.s, dup))
236 if type(self.s) not in (set, frozenset):
237 self.assertEqual(self.s.x, dup.x)
238 self.assertEqual(self.s.z, dup.z)
239 self.assertFalse(hasattr(self.s, 'y'))
240 del self.s.x, self.s.z
242 def test_iterator_pickling(self):
244 itorg = iter(self.s)
245 data = self.thetype(self.s)
250 # self.assertEqual(type(itorg), type(it))
251 self.assertIsInstance(it, collections.abc.Iterator)
252 self.assertEqual(self.thetype(it), data)
261 self.assertEqual(self.thetype(it), data - self.thetype((drop,)))
263 def test_deepcopy(self):
265 def __init__(self, value):
266 self.value = value
267 def __hash__(self):
268 return self.value
269 def __deepcopy__(self, memo=None):
270 return Tracer(self.value + 1)
272 s = self.thetype([t])
274 self.assertNotEqual(id(s), id(dup))
277 self.assertNotEqual(id(t), id(newt))
278 self.assertEqual(t.value + 1, newt.value)
280 def test_gc(self):
290 def test_subclass_with_custom_hash(self):
292 class H(self.thetype):
293 def __hash__(self):
294 return int(id(self) & 0x7fffffff)
298 self.assertIn(s, f)
303 def test_badcmp(self):
304 s = self.thetype([BadCmp()])
306 self.assertRaises(RuntimeError, self.thetype, [BadCmp(), BadCmp()])
307 self.assertRaises(RuntimeError, s.__contains__, BadCmp())
310 self.assertRaises(RuntimeError, s.add, BadCmp())
311 self.assertRaises(RuntimeError, s.discard, BadCmp())
312 self.assertRaises(RuntimeError, s.remove, BadCmp())
314 def test_cyclical_repr(self):
316 s = self.thetype([w])
318 if self.thetype == set:
319 self.assertEqual(repr(s), '{set(...)}')
322 self.assertEqual(repr(s), '%s({%s(...)})' % (name, name))
324 def test_do_not_rehash_dict_keys(self):
327 self.assertEqual(sum(elem.hash_count for elem in d), n)
328 s = self.thetype(d)
329 self.assertEqual(sum(elem.hash_count for elem in d), n)
331 self.assertEqual(sum(elem.hash_count for elem in d), n)
334 self.assertEqual(sum(elem.hash_count for elem in d), n)
336 self.assertEqual(sum(elem.hash_count for elem in d), n)
338 self.assertEqual(sum(elem.hash_count for elem in d), n)
340 self.assertEqual(sum(elem.hash_count for elem in d), n)
341 self.assertEqual(d3, dict.fromkeys(d, 123))
343 def test_container_iterator(self):
353 self.assertTrue(ref() is None, "Cycle was not collected")
355 def test_free_after_iterating(self):
356 support.check_free_after_iterating(self, iter, self.thetype)
362 def test_init(self):
363 s = self.thetype()
364 s.__init__(self.word)
365 self.assertEqual(s, set(self.word))
366 s.__init__(self.otherword)
367 self.assertEqual(s, set(self.otherword))
368 self.assertRaises(TypeError, s.__init__, s, 2)
369 self.assertRaises(TypeError, s.__init__, 1)
371 def test_constructor_identity(self):
372 s = self.thetype(range(3))
373 t = self.thetype(s)
374 self.assertNotEqual(id(s), id(t))
376 def test_set_literal(self):
379 self.assertEqual(s, t)
381 def test_set_literal_insertion_order(self):
384 self.assertEqual(len(s), 1)
386 self.assertEqual(type(stored_value), int)
388 def test_set_literal_evaluation_order(self):
394 self.assertEqual(events, [1, 2, 3])
396 def test_hash(self):
397 self.assertRaises(TypeError, hash, self.s)
399 def test_clear(self):
400 self.s.clear()
401 self.assertEqual(self.s, set())
402 self.assertEqual(len(self.s), 0)
404 def test_copy(self):
405 dup = self.s.copy()
406 self.assertEqual(self.s, dup)
407 self.assertNotEqual(id(self.s), id(dup))
408 self.assertEqual(type(dup), self.basetype)
410 def test_add(self):
411 self.s.add('Q')
412 self.assertIn('Q', self.s)
413 dup = self.s.copy()
414 self.s.add('Q')
415 self.assertEqual(self.s, dup)
416 self.assertRaises(TypeError, self.s.add, [])
418 def test_remove(self):
419 self.s.remove('a')
420 self.assertNotIn('a', self.s)
421 self.assertRaises(KeyError, self.s.remove, 'Q')
422 self.assertRaises(TypeError, self.s.remove, [])
423 s = self.thetype([frozenset(self.word)])
424 self.assertIn(self.thetype(self.word), s)
425 s.remove(self.thetype(self.word))
426 self.assertNotIn(self.thetype(self.word), s)
427 self.assertRaises(KeyError, self.s.remove, self.thetype(self.word))
429 def test_remove_keyerror_unpacking(self):
433 self.s.remove(v1)
436 self.assertEqual(v1, v2)
438 self.fail()
440 def test_remove_keyerror_set(self):
441 key = self.thetype([3, 4])
443 self.s.remove(key)
445 self.assertTrue(e.args[0] is key,
449 self.fail()
451 def test_discard(self):
452 self.s.discard('a')
453 self.assertNotIn('a', self.s)
454 self.s.discard('Q')
455 self.assertRaises(TypeError, self.s.discard, [])
456 s = self.thetype([frozenset(self.word)])
457 self.assertIn(self.thetype(self.word), s)
458 s.discard(self.thetype(self.word))
459 self.assertNotIn(self.thetype(self.word), s)
460 s.discard(self.thetype(self.word))
462 def test_pop(self):
463 for i in range(len(self.s)):
464 elem = self.s.pop()
465 self.assertNotIn(elem, self.s)
466 self.assertRaises(KeyError, self.s.pop)
468 def test_update(self):
469 retval = self.s.update(self.otherword)
470 self.assertEqual(retval, None)
471 for c in (self.word + self.otherword):
472 self.assertIn(c, self.s)
473 self.assertRaises(PassThru, self.s.update, check_pass_thru())
474 self.assertRaises(TypeError, self.s.update, [[]])
477 s = self.thetype('abcba')
478 self.assertEqual(s.update(C(p)), None)
479 self.assertEqual(s, set(q))
483 s = self.thetype('abcba')
484 self.assertEqual(s.update(C(p), C(q)), None)
485 self.assertEqual(s, set(s) | set(p) | set(q))
487 def test_ior(self):
488 self.s |= set(self.otherword)
489 for c in (self.word + self.otherword):
490 self.assertIn(c, self.s)
492 def test_intersection_update(self):
493 retval = self.s.intersection_update(self.otherword)
494 self.assertEqual(retval, None)
495 for c in (self.word + self.otherword):
496 if c in self.otherword and c in self.word:
497 self.assertIn(c, self.s)
499 self.assertNotIn(c, self.s)
500 self.assertRaises(PassThru, self.s.intersection_update, check_pass_thru())
501 self.assertRaises(TypeError, self.s.intersection_update, [[]])
504 s = self.thetype('abcba')
505 self.assertEqual(s.intersection_update(C(p)), None)
506 self.assertEqual(s, set(q))
508 s = self.thetype(ss)
510 self.assertEqual(s.intersection_update(C(p), C(t)), None)
511 self.assertEqual(s, set('abcba')&set(p)&set(t))
513 def test_iand(self):
514 self.s &= set(self.otherword)
515 for c in (self.word + self.otherword):
516 if c in self.otherword and c in self.word:
517 self.assertIn(c, self.s)
519 self.assertNotIn(c, self.s)
521 def test_difference_update(self):
522 retval = self.s.difference_update(self.otherword)
523 self.assertEqual(retval, None)
524 for c in (self.word + self.otherword):
525 if c in self.word and c not in self.otherword:
526 self.assertIn(c, self.s)
528 self.assertNotIn(c, self.s)
529 self.assertRaises(PassThru, self.s.difference_update, check_pass_thru())
530 self.assertRaises(TypeError, self.s.difference_update, [[]])
531 self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
534 s = self.thetype('abcba')
535 self.assertEqual(s.difference_update(C(p)), None)
536 self.assertEqual(s, set(q))
538 s = self.thetype('abcdefghih')
540 self.assertEqual(s, self.thetype('abcdefghih'))
542 s = self.thetype('abcdefghih')
544 self.assertEqual(s, self.thetype('cdefghih'))
546 s = self.thetype('abcdefghih')
548 self.assertEqual(s, self.thetype('efghih'))
550 def test_isub(self):
551 self.s -= set(self.otherword)
552 for c in (self.word + self.otherword):
553 if c in self.word and c not in self.otherword:
554 self.assertIn(c, self.s)
556 self.assertNotIn(c, self.s)
558 def test_symmetric_difference_update(self):
559 retval = self.s.symmetric_difference_update(self.otherword)
560 self.assertEqual(retval, None)
561 for c in (self.word + self.otherword):
562 if (c in self.word) ^ (c in self.otherword):
563 self.assertIn(c, self.s)
565 self.assertNotIn(c, self.s)
566 self.assertRaises(PassThru, self.s.symmetric_difference_update, check_pass_thru())
567 self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
570 s = self.thetype('abcba')
571 self.assertEqual(s.symmetric_difference_update(C(p)), None)
572 self.assertEqual(s, set(q))
574 def test_ixor(self):
575 self.s ^= set(self.otherword)
576 for c in (self.word + self.otherword):
577 if (c in self.word) ^ (c in self.otherword):
578 self.assertIn(c, self.s)
580 self.assertNotIn(c, self.s)
582 def test_inplace_on_self(self):
583 t = self.s.copy()
585 self.assertEqual(t, self.s)
587 self.assertEqual(t, self.s)
589 self.assertEqual(t, self.thetype())
590 t = self.s.copy()
592 self.assertEqual(t, self.thetype())
594 def test_weakref(self):
595 s = self.thetype('gallahad')
597 self.assertEqual(str(p), str(s))
600 self.assertRaises(ReferenceError, str, p)
602 def test_rich_compare(self):
604 def __gt__(self, some_set):
605 self.gt_called = True
607 def __lt__(self, some_set):
608 self.lt_called = True
610 def __ge__(self, some_set):
611 self.ge_called = True
613 def __le__(self, some_set):
614 self.le_called = True
624 self.assertTrue(myobj.gt_called)
628 self.assertTrue(myobj.lt_called)
632 self.assertTrue(myobj.ge_called)
636 self.assertTrue(myobj.le_called)
640 def test_c_api(self):
641 self.assertEqual(set().test_c_api(), True)
650 def test_keywords_in_subclass(self):
654 self.assertIs(type(u), subclass)
655 self.assertEqual(set(u), {1, 2})
656 with self.assertRaises(TypeError):
660 def __init__(self, arg, newarg=None):
662 self.newarg = newarg
664 self.assertIs(type(u), subclass_with_init)
665 self.assertEqual(set(u), {1, 2})
666 self.assertEqual(u.newarg, 3)
670 self = super().__new__(cls, arg)
671 self.newarg = newarg
672 return self
674 self.assertIs(type(u), subclass_with_new)
675 self.assertEqual(set(u), {1, 2})
676 self.assertIsNone(u.newarg)
678 with self.assertRaises(TypeError):
686 def test_init(self):
687 s = self.thetype(self.word)
688 s.__init__(self.otherword)
689 self.assertEqual(s, set(self.word))
691 def test_constructor_identity(self):
692 s = self.thetype(range(3))
693 t = self.thetype(s)
694 self.assertEqual(id(s), id(t))
696 def test_hash(self):
697 self.assertEqual(hash(self.thetype('abcdeb')),
698 hash(self.thetype('ebecda')))
706 results.add(hash(self.thetype(seq)))
707 self.assertEqual(len(results), 1)
709 def test_copy(self):
710 dup = self.s.copy()
711 self.assertEqual(id(self.s), id(dup))
713 def test_frozen_as_dictkey(self):
715 key1 = self.thetype(seq)
716 key2 = self.thetype(reversed(seq))
717 self.assertEqual(key1, key2)
718 self.assertNotEqual(id(key1), id(key2))
721 self.assertEqual(d[key2], 42)
723 def test_hash_caching(self):
724 f = self.thetype('abcdcda')
725 self.assertEqual(hash(f), hash(f))
727 def test_hash_effectiveness(self):
734 self.assertEqual(len(hashvalues), 2**n)
753 self.assertGreater(4*u, t)
762 def test_keywords_in_subclass(self):
766 self.assertIs(type(u), subclass)
767 self.assertEqual(set(u), {1, 2})
768 with self.assertRaises(TypeError):
772 def __init__(self, arg, newarg=None):
773 self.newarg = newarg
775 self.assertIs(type(u), subclass_with_init)
776 self.assertEqual(set(u), {1, 2})
777 self.assertEqual(u.newarg, 3)
781 self = super().__new__(cls, arg)
782 self.newarg = newarg
783 return self
785 self.assertIs(type(u), subclass_with_new)
786 self.assertEqual(set(u), {1, 2})
787 self.assertEqual(u.newarg, 3)
789 def test_constructor_identity(self):
790 s = self.thetype(range(3))
791 t = self.thetype(s)
792 self.assertNotEqual(id(s), id(t))
794 def test_copy(self):
795 dup = self.s.copy()
796 self.assertNotEqual(id(self.s), id(dup))
798 def test_nested_empty_constructor(self):
799 s = self.thetype()
800 t = self.thetype(s)
801 self.assertEqual(s, t)
803 def test_singleton_empty_frozenset(self):
804 Frozenset = self.thetype
812 self.assertEqual(len(set(map(id, efs))), len(efs))
837 def test_repr(self):
838 if self.repr is not None:
839 self.assertEqual(repr(self.set), self.repr)
841 def check_repr_against_values(self):
842 text = repr(self.set)
843 self.assertTrue(text.startswith('{'))
844 self.assertTrue(text.endswith('}'))
848 sorted_repr_values = [repr(value) for value in self.values]
850 self.assertEqual(result, sorted_repr_values)
852 def test_length(self):
853 self.assertEqual(len(self.set), self.length)
855 def test_self_equality(self):
856 self.assertEqual(self.set, self.set)
858 def test_equivalent_equality(self):
859 self.assertEqual(self.set, self.dup)
861 def test_copy(self):
862 self.assertEqual(self.set.copy(), self.dup)
864 def test_self_union(self):
865 result = self.set | self.set
866 self.assertEqual(result, self.dup)
868 def test_empty_union(self):
869 result = self.set | empty_set
870 self.assertEqual(result, self.dup)
872 def test_union_empty(self):
873 result = empty_set | self.set
874 self.assertEqual(result, self.dup)
876 def test_self_intersection(self):
877 result = self.set & self.set
878 self.assertEqual(result, self.dup)
880 def test_empty_intersection(self):
881 result = self.set & empty_set
882 self.assertEqual(result, empty_set)
884 def test_intersection_empty(self):
885 result = empty_set & self.set
886 self.assertEqual(result, empty_set)
888 def test_self_isdisjoint(self):
889 result = self.set.isdisjoint(self.set)
890 self.assertEqual(result, not self.set)
892 def test_empty_isdisjoint(self):
893 result = self.set.isdisjoint(empty_set)
894 self.assertEqual(result, True)
896 def test_isdisjoint_empty(self):
897 result = empty_set.isdisjoint(self.set)
898 self.assertEqual(result, True)
900 def test_self_symmetric_difference(self):
901 result = self.set ^ self.set
902 self.assertEqual(result, empty_set)
904 def test_empty_symmetric_difference(self):
905 result = self.set ^ empty_set
906 self.assertEqual(result, self.set)
908 def test_self_difference(self):
909 result = self.set - self.set
910 self.assertEqual(result, empty_set)
912 def test_empty_difference(self):
913 result = self.set - empty_set
914 self.assertEqual(result, self.dup)
916 def test_empty_difference_rev(self):
917 result = empty_set - self.set
918 self.assertEqual(result, empty_set)
920 def test_iteration(self):
921 for v in self.set:
922 self.assertIn(v, self.values)
923 setiter = iter(self.set)
924 self.assertEqual(setiter.__length_hint__(), len(self.set))
926 def test_pickling(self):
928 p = pickle.dumps(self.set, proto)
930 self.assertEqual(self.set, copy,
931 "%s != %s" % (self.set, copy))
933 def test_issue_37219(self):
934 with self.assertRaises(TypeError):
936 with self.assertRaises(TypeError):
942 def setUp(self):
943 self.case = "empty set"
944 self.values = []
945 self.set = set(self.values)
946 self.dup = set(self.values)
947 self.length = 0
948 self.repr = "set()"
953 def setUp(self):
954 self.case = "unit set (number)"
955 self.values = [3]
956 self.set = set(self.values)
957 self.dup = set(self.values)
958 self.length = 1
959 self.repr = "{3}"
961 def test_in(self):
962 self.assertIn(3, self.set)
964 def test_not_in(self):
965 self.assertNotIn(2, self.set)
970 def setUp(self):
971 self.case = "unit set (tuple)"
972 self.values = [(0, "zero")]
973 self.set = set(self.values)
974 self.dup = set(self.values)
975 self.length = 1
976 self.repr = "{(0, 'zero')}"
978 def test_in(self):
979 self.assertIn((0, "zero"), self.set)
981 def test_not_in(self):
982 self.assertNotIn(9, self.set)
987 def setUp(self):
988 self.case = "triple set"
989 self.values = [0, "zero", operator.add]
990 self.set = set(self.values)
991 self.dup = set(self.values)
992 self.length = 3
993 self.repr = None
998 def setUp(self):
999 self.case = "string set"
1000 self.values = ["a", "b", "c"]
1001 self.set = set(self.values)
1002 self.dup = set(self.values)
1003 self.length = 3
1005 def test_repr(self):
1006 self.check_repr_against_values()
1011 def setUp(self):
1012 self.case = "bytes set"
1013 self.values = [b"a", b"b", b"c"]
1014 self.set = set(self.values)
1015 self.dup = set(self.values)
1016 self.length = 3
1018 def test_repr(self):
1019 self.check_repr_against_values()
1024 def setUp(self):
1025 self.enterContext(warnings_helper.check_warnings())
1027 self.case = "string and bytes set"
1028 self.values = ["a", "b", b"a", b"b"]
1029 self.set = set(self.values)
1030 self.dup = set(self.values)
1031 self.length = 4
1033 def test_repr(self):
1034 self.check_repr_against_values()
1048 def test_instanceWithException(self):
1049 self.assertRaises(TypeError, set, baditer())
1051 def test_instancesWithoutException(self):
1060 def test_changingSizeWhileIterating(self):
1068 self.fail("no exception when changing size during iteration")
1073 def test_constructor(self):
1077 self.assertEqual(type(element), frozenset)
1080 self.assertEqual(outer, set()) # Verify that remove worked
1086 def setUp(self):
1087 self.set = set((2, 4, 6))
1089 def test_eq(self): # SF bug 643115
1090 self.assertEqual(self.set, set({2:1,4:3,6:5}))
1092 def test_union_subset(self):
1093 result = self.set | set([2])
1094 self.assertEqual(result, set((2, 4, 6)))
1096 def test_union_superset(self):
1097 result = self.set | set([2, 4, 6, 8])
1098 self.assertEqual(result, set([2, 4, 6, 8]))
1100 def test_union_overlap(self):
1101 result = self.set | set([3, 4, 5])
1102 self.assertEqual(result, set([2, 3, 4, 5, 6]))
1104 def test_union_non_overlap(self):
1105 result = self.set | set([8])
1106 self.assertEqual(result, set([2, 4, 6, 8]))
1108 def test_intersection_subset(self):
1109 result = self.set & set((2, 4))
1110 self.assertEqual(result, set((2, 4)))
1112 def test_intersection_superset(self):
1113 result = self.set & set([2, 4, 6, 8])
1114 self.assertEqual(result, set([2, 4, 6]))
1116 def test_intersection_overlap(self):
1117 result = self.set & set([3, 4, 5])
1118 self.assertEqual(result, set([4]))
1120 def test_intersection_non_overlap(self):
1121 result = self.set & set([8])
1122 self.assertEqual(result, empty_set)
1124 def test_isdisjoint_subset(self):
1125 result = self.set.isdisjoint(set((2, 4)))
1126 self.assertEqual(result, False)
1128 def test_isdisjoint_superset(self):
1129 result = self.set.isdisjoint(set([2, 4, 6, 8]))
1130 self.assertEqual(result, False)
1132 def test_isdisjoint_overlap(self):
1133 result = self.set.isdisjoint(set([3, 4, 5]))
1134 self.assertEqual(result, False)
1136 def test_isdisjoint_non_overlap(self):
1137 result = self.set.isdisjoint(set([8]))
1138 self.assertEqual(result, True)
1140 def test_sym_difference_subset(self):
1141 result = self.set ^ set((2, 4))
1142 self.assertEqual(result, set([6]))
1144 def test_sym_difference_superset(self):
1145 result = self.set ^ set((2, 4, 6, 8))
1146 self.assertEqual(result, set([8]))
1148 def test_sym_difference_overlap(self):
1149 result = self.set ^ set((3, 4, 5))
1150 self.assertEqual(result, set([2, 3, 5, 6]))
1152 def test_sym_difference_non_overlap(self):
1153 result = self.set ^ set([8])
1154 self.assertEqual(result, set([2, 4, 6, 8]))
1159 def setUp(self):
1160 self.set = set((2, 4, 6))
1162 def test_union_subset(self):
1163 self.set |= set([2])
1164 self.assertEqual(self.set, set((2, 4, 6)))
1166 def test_union_superset(self):
1167 self.set |= set([2, 4, 6, 8])
1168 self.assertEqual(self.set, set([2, 4, 6, 8]))
1170 def test_union_overlap(self):
1171 self.set |= set([3, 4, 5])
1172 self.assertEqual(self.set, set([2, 3, 4, 5, 6]))
1174 def test_union_non_overlap(self):
1175 self.set |= set([8])
1176 self.assertEqual(self.set, set([2, 4, 6, 8]))
1178 def test_union_method_call(self):
1179 self.set.update(set([3, 4, 5]))
1180 self.assertEqual(self.set, set([2, 3, 4, 5, 6]))
1182 def test_intersection_subset(self):
1183 self.set &= set((2, 4))
1184 self.assertEqual(self.set, set((2, 4)))
1186 def test_intersection_superset(self):
1187 self.set &= set([2, 4, 6, 8])
1188 self.assertEqual(self.set, set([2, 4, 6]))
1190 def test_intersection_overlap(self):
1191 self.set &= set([3, 4, 5])
1192 self.assertEqual(self.set, set([4]))
1194 def test_intersection_non_overlap(self):
1195 self.set &= set([8])
1196 self.assertEqual(self.set, empty_set)
1198 def test_intersection_method_call(self):
1199 self.set.intersection_update(set([3, 4, 5]))
1200 self.assertEqual(self.set, set([4]))
1202 def test_sym_difference_subset(self):
1203 self.set ^= set((2, 4))
1204 self.assertEqual(self.set, set([6]))
1206 def test_sym_difference_superset(self):
1207 self.set ^= set((2, 4, 6, 8))
1208 self.assertEqual(self.set, set([8]))
1210 def test_sym_difference_overlap(self):
1211 self.set ^= set((3, 4, 5))
1212 self.assertEqual(self.set, set([2, 3, 5, 6]))
1214 def test_sym_difference_non_overlap(self):
1215 self.set ^= set([8])
1216 self.assertEqual(self.set, set([2, 4, 6, 8]))
1218 def test_sym_difference_method_call(self):
1219 self.set.symmetric_difference_update(set([3, 4, 5]))
1220 self.assertEqual(self.set, set([2, 3, 5, 6]))
1222 def test_difference_subset(self):
1223 self.set -= set((2, 4))
1224 self.assertEqual(self.set, set([6]))
1226 def test_difference_superset(self):
1227 self.set -= set((2, 4, 6, 8))
1228 self.assertEqual(self.set, set([]))
1230 def test_difference_overlap(self):
1231 self.set -= set((3, 4, 5))
1232 self.assertEqual(self.set, set([2, 6]))
1234 def test_difference_non_overlap(self):
1235 self.set -= set([8])
1236 self.assertEqual(self.set, set([2, 4, 6]))
1238 def test_difference_method_call(self):
1239 self.set.difference_update(set([3, 4, 5]))
1240 self.assertEqual(self.set, set([2, 6]))
1245 def setUp(self):
1246 self.values = ["a", "b", "c"]
1247 self.set = set(self.values)
1249 def test_add_present(self):
1250 self.set.add("c")
1251 self.assertEqual(self.set, set("abc"))
1253 def test_add_absent(self):
1254 self.set.add("d")
1255 self.assertEqual(self.set, set("abcd"))
1257 def test_add_until_full(self):
1260 for v in self.values:
1263 self.assertEqual(len(tmp), expected_len)
1264 self.assertEqual(tmp, self.set)
1266 def test_remove_present(self):
1267 self.set.remove("b")
1268 self.assertEqual(self.set, set("ac"))
1270 def test_remove_absent(self):
1272 self.set.remove("d")
1273 self.fail("Removing missing element should have raised LookupError")
1277 def test_remove_until_empty(self):
1278 expected_len = len(self.set)
1279 for v in self.values:
1280 self.set.remove(v)
1282 self.assertEqual(len(self.set), expected_len)
1284 def test_discard_present(self):
1285 self.set.discard("c")
1286 self.assertEqual(self.set, set("ab"))
1288 def test_discard_absent(self):
1289 self.set.discard("d")
1290 self.assertEqual(self.set, set("abc"))
1292 def test_clear(self):
1293 self.set.clear()
1294 self.assertEqual(len(self.set), 0)
1296 def test_pop(self):
1298 while self.set:
1299 popped[self.set.pop()] = None
1300 self.assertEqual(len(popped), len(self.values))
1301 for v in self.values:
1302 self.assertIn(v, popped)
1304 def test_update_empty_tuple(self):
1305 self.set.update(())
1306 self.assertEqual(self.set, set(self.values))
1308 def test_update_unit_tuple_overlap(self):
1309 self.set.update(("a",))
1310 self.assertEqual(self.set, set(self.values))
1312 def test_update_unit_tuple_non_overlap(self):
1313 self.set.update(("a", "z"))
1314 self.assertEqual(self.set, set(self.values + ["z"]))
1332 def test_issubset(self):
1333 x = self.left
1334 y = self.right
1336 expected = case in self.cases
1339 self.assertEqual(result, expected)
1344 self.assertEqual(result, expected)
1349 self.assertEqual(result, expected)
1353 self.assertEqual(result, expected)
1398 def test_eq_ne(self):
1400 self.assertEqual(self.other == self.set, False)
1401 self.assertEqual(self.set == self.other, False)
1402 self.assertEqual(self.other != self.set, True)
1403 self.assertEqual(self.set != self.other, True)
1405 def test_ge_gt_le_lt(self):
1406 self.assertRaises(TypeError, lambda: self.set < self.other)
1407 self.assertRaises(TypeError, lambda: self.set <= self.other)
1408 self.assertRaises(TypeError, lambda: self.set > self.other)
1409 self.assertRaises(TypeError, lambda: self.set >= self.other)
1411 self.assertRaises(TypeError, lambda: self.other < self.set)
1412 self.assertRaises(TypeError, lambda: self.other <= self.set)
1413 self.assertRaises(TypeError, lambda: self.other > self.set)
1414 self.assertRaises(TypeError, lambda: self.other >= self.set)
1416 def test_update_operator(self):
1418 self.set |= self.other
1422 self.fail("expected TypeError")
1424 def test_update(self):
1425 if self.otherIsIterable:
1426 self.set.update(self.other)
1428 self.assertRaises(TypeError, self.set.update, self.other)
1430 def test_union(self):
1431 self.assertRaises(TypeError, lambda: self.set | self.other)
1432 self.assertRaises(TypeError, lambda: self.other | self.set)
1433 if self.otherIsIterable:
1434 self.set.union(self.other)
1436 self.assertRaises(TypeError, self.set.union, self.other)
1438 def test_intersection_update_operator(self):
1440 self.set &= self.other
1444 self.fail("expected TypeError")
1446 def test_intersection_update(self):
1447 if self.otherIsIterable:
1448 self.set.intersection_update(self.other)
1450 self.assertRaises(TypeError,
1451 self.set.intersection_update,
1452 self.other)
1454 def test_intersection(self):
1455 self.assertRaises(TypeError, lambda: self.set & self.other)
1456 self.assertRaises(TypeError, lambda: self.other & self.set)
1457 if self.otherIsIterable:
1458 self.set.intersection(self.other)
1460 self.assertRaises(TypeError, self.set.intersection, self.other)
1462 def test_sym_difference_update_operator(self):
1464 self.set ^= self.other
1468 self.fail("expected TypeError")
1470 def test_sym_difference_update(self):
1471 if self.otherIsIterable:
1472 self.set.symmetric_difference_update(self.other)
1474 self.assertRaises(TypeError,
1475 self.set.symmetric_difference_update,
1476 self.other)
1478 def test_sym_difference(self):
1479 self.assertRaises(TypeError, lambda: self.set ^ self.other)
1480 self.assertRaises(TypeError, lambda: self.other ^ self.set)
1481 if self.otherIsIterable:
1482 self.set.symmetric_difference(self.other)
1484 self.assertRaises(TypeError, self.set.symmetric_difference, self.other)
1486 def test_difference_update_operator(self):
1488 self.set -= self.other
1492 self.fail("expected TypeError")
1494 def test_difference_update(self):
1495 if self.otherIsIterable:
1496 self.set.difference_update(self.other)
1498 self.assertRaises(TypeError,
1499 self.set.difference_update,
1500 self.other)
1502 def test_difference(self):
1503 self.assertRaises(TypeError, lambda: self.set - self.other)
1504 self.assertRaises(TypeError, lambda: self.other - self.set)
1505 if self.otherIsIterable:
1506 self.set.difference(self.other)
1508 self.assertRaises(TypeError, self.set.difference, self.other)
1513 def setUp(self):
1514 self.set = set((1, 2, 3))
1515 self.other = 19
1516 self.otherIsIterable = False
1521 def setUp(self):
1522 self.set = set((1, 2, 3))
1523 self.other = {1:2, 3:4}
1524 self.otherIsIterable = True
1529 def setUp(self):
1530 self.set = set((1, 2, 3))
1531 self.other = operator.add
1532 self.otherIsIterable = False
1537 def setUp(self):
1538 self.set = set((1, 2, 3))
1539 self.other = (2, 4, 6)
1540 self.otherIsIterable = True
1545 def setUp(self):
1546 self.set = set((1, 2, 3))
1547 self.other = 'abc'
1548 self.otherIsIterable = True
1553 def setUp(self):
1557 self.set = set((1, 2, 3))
1558 self.other = gen()
1559 self.otherIsIterable = True
1565 def test_copy(self):
1566 dup = self.set.copy()
1568 set_list = sorted(self.set, key=repr)
1569 self.assertEqual(len(dup_list), len(set_list))
1571 self.assertTrue(dup_list[i] is set_list[i])
1573 def test_deep_copy(self):
1574 dup = copy.deepcopy(self.set)
1577 set_list = sorted(self.set, key=repr)
1578 self.assertEqual(len(dup_list), len(set_list))
1580 self.assertEqual(dup_list[i], set_list[i])
1585 def setUp(self):
1586 self.set = set()
1591 def setUp(self):
1592 self.set = set(["hello"])
1597 def setUp(self):
1598 self.set = set(["zero", 0, None])
1603 def setUp(self):
1604 self.set = set([(1, 2)])
1609 def setUp(self):
1610 self.set = set([((1, 2), (3, 4))])
1615 def setUp(self):
1616 self.a = set('abracadabra')
1617 self.b = set('alacazam')
1619 def test_binopsVsSubsets(self):
1620 a, b = self.a, self.b
1621 self.assertTrue(a - b < a)
1622 self.assertTrue(b - a < b)
1623 self.assertTrue(a & b < a)
1624 self.assertTrue(a & b < b)
1625 self.assertTrue(a | b > a)
1626 self.assertTrue(a | b > b)
1627 self.assertTrue(a ^ b < a | b)
1629 def test_commutativity(self):
1630 a, b = self.a, self.b
1631 self.assertEqual(a&b, b&a)
1632 self.assertEqual(a|b, b|a)
1633 self.assertEqual(a^b, b^a)
1635 self.assertNotEqual(a-b, b-a)
1637 def test_summations(self):
1639 a, b = self.a, self.b
1640 self.assertEqual((a-b)|(a&b)|(b-a), a|b)
1641 self.assertEqual((a&b)|(a^b), a|b)
1642 self.assertEqual(a|(b-a), a|b)
1643 self.assertEqual((a-b)|b, a|b)
1644 self.assertEqual((a-b)|(a&b), a)
1645 self.assertEqual((b-a)|(a&b), b)
1646 self.assertEqual((a-b)|(b-a), a^b)
1648 def test_exclusion(self):
1650 a, b, zero = self.a, self.b, set()
1651 self.assertEqual((a-b)&b, zero)
1652 self.assertEqual((b-a)&a, zero)
1653 self.assertEqual((a&b)&(a^b), zero)
1664 def __init__(self, seqn):
1665 self.seqn = seqn
1666 def __getitem__(self, i):
1667 return self.seqn[i]
1671 def __init__(self, seqn):
1672 self.seqn = seqn
1673 self.i = 0
1674 def __iter__(self):
1675 return self
1676 def __next__(self):
1677 if self.i >= len(self.seqn): raise StopIteration
1678 v = self.seqn[self.i]
1679 self.i += 1
1684 def __init__(self, seqn):
1685 self.seqn = seqn
1686 self.i = 0
1687 def __iter__(self):
1688 for val in self.seqn:
1693 def __init__(self, seqn):
1694 self.seqn = seqn
1695 self.i = 0
1696 def __next__(self):
1697 if self.i >= len(self.seqn): raise StopIteration
1698 v = self.seqn[self.i]
1699 self.i += 1
1704 def __init__(self, seqn):
1705 self.seqn = seqn
1706 self.i = 0
1707 def __iter__(self):
1708 return self
1712 def __init__(self, seqn):
1713 self.seqn = seqn
1714 self.i = 0
1715 def __iter__(self):
1716 return self
1717 def __next__(self):
1722 def __init__(self, seqn):
1724 def __iter__(self):
1725 return self
1726 def __next__(self):
1736 def test_constructor(self):
1740 self.assertEqual(sorted(cons(g(s)), key=repr), sorted(g(s), key=repr))
1741 self.assertRaises(TypeError, cons , X(s))
1742 self.assertRaises(TypeError, cons , N(s))
1743 self.assertRaises(ZeroDivisionError, cons , E(s))
1745 def test_inline_methods(self):
1753 self.assertEqual(actual, expected)
1755 self.assertEqual(sorted(actual, key=repr), sorted(expected, key=repr))
1756 self.assertRaises(TypeError, meth, X(s))
1757 self.assertRaises(TypeError, meth, N(s))
1758 self.assertRaises(ZeroDivisionError, meth, E(s))
1760 def test_inplace_methods(self):
1769 self.assertEqual(sorted(s, key=repr), sorted(t, key=repr))
1771 self.assertRaises(TypeError, getattr(set('january'), methname), X(data))
1772 self.assertRaises(TypeError, getattr(set('january'), methname), N(data))
1773 self.assertRaises(ZeroDivisionError, getattr(set('january'), methname), E(data))
1776 def __eq__(self, other):
1780 return self is other
1781 def __hash__(self):
1785 def __eq__(self, other):
1788 return self is other
1789 def __hash__(self):
1793 def test_8420_set_merge(self):
1800 self.assertRaises(ZeroDivisionError, set1.update, set2)
1808 def test_iter_and_mutate(self):
1819 def test_merge_and_mutate(self):
1821 def __hash__(self):
1823 def __eq__(self, o):
1839 def make_sets_of_bad_objects(self):
1841 def __eq__(self, other):
1849 def __hash__(self):
1853 set1 = self.constructor1(Bad() for _ in range(randrange(50)))
1854 set2 = self.constructor2(Bad() for _ in range(randrange(50)))
1859 def check_set_op_does_not_crash(self, function):
1861 set1, set2 = self.make_sets_of_bad_objects()
1866 self.assertIn("changed size during iteration", str(e))
1871 def test_eq_with_mutation(self):
1872 self.check_set_op_does_not_crash(lambda a, b: a == b)
1874 def test_ne_with_mutation(self):
1875 self.check_set_op_does_not_crash(lambda a, b: a != b)
1877 def test_lt_with_mutation(self):
1878 self.check_set_op_does_not_crash(lambda a, b: a < b)
1880 def test_le_with_mutation(self):
1881 self.check_set_op_does_not_crash(lambda a, b: a <= b)
1883 def test_gt_with_mutation(self):
1884 self.check_set_op_does_not_crash(lambda a, b: a > b)
1886 def test_ge_with_mutation(self):
1887 self.check_set_op_does_not_crash(lambda a, b: a >= b)
1889 def test_and_with_mutation(self):
1890 self.check_set_op_does_not_crash(lambda a, b: a & b)
1892 def test_or_with_mutation(self):
1893 self.check_set_op_does_not_crash(lambda a, b: a | b)
1895 def test_sub_with_mutation(self):
1896 self.check_set_op_does_not_crash(lambda a, b: a - b)
1898 def test_xor_with_mutation(self):
1899 self.check_set_op_does_not_crash(lambda a, b: a ^ b)
1901 def test_iadd_with_mutation(self):
1904 self.check_set_op_does_not_crash(f)
1906 def test_ior_with_mutation(self):
1909 self.check_set_op_does_not_crash(f)
1911 def test_isub_with_mutation(self):
1914 self.check_set_op_does_not_crash(f)
1916 def test_ixor_with_mutation(self):
1919 self.check_set_op_does_not_crash(f)
1921 def test_iteration_with_mutation(self):
1935 self.check_set_op_does_not_crash(f1)
1936 self.check_set_op_does_not_crash(f2)
1937 self.check_set_op_does_not_crash(f3)
1959 def test_issubset_with_mutation(self):
1960 self.check_set_op_does_not_crash(set.issubset)
1962 def test_issuperset_with_mutation(self):
1963 self.check_set_op_does_not_crash(set.issuperset)
1965 def test_intersection_with_mutation(self):
1966 self.check_set_op_does_not_crash(set.intersection)
1968 def test_union_with_mutation(self):
1969 self.check_set_op_does_not_crash(set.union)
1971 def test_difference_with_mutation(self):
1972 self.check_set_op_does_not_crash(set.difference)
1974 def test_symmetric_difference_with_mutation(self):
1975 self.check_set_op_does_not_crash(set.symmetric_difference)
1977 def test_isdisjoint_with_mutation(self):
1978 self.check_set_op_does_not_crash(set.isdisjoint)
1980 def test_difference_update_with_mutation(self):
1981 self.check_set_op_does_not_crash(set.difference_update)
1983 def test_intersection_update_with_mutation(self):
1984 self.check_set_op_does_not_crash(set.intersection_update)
1986 def test_symmetric_difference_update_with_mutation(self):
1987 self.check_set_op_does_not_crash(set.symmetric_difference_update)
1989 def test_update_with_mutation(self):
1990 self.check_set_op_does_not_crash(set.update)
2077 def test_cube(self):
2081 self.assertEqual(len(vertices1), 8) # eight vertices
2083 self.assertEqual(len(edge), 3) # each vertex connects to three edges
2085 self.assertEqual(vertices1, vertices2) # edge vertices in original set
2088 self.assertEqual(len(cubefaces), 6) # six faces
2090 self.assertEqual(len(face), 4) # each face is a square
2092 def test_cuboctahedron(self):
2100 self.assertEqual(len(cuboctahedron), 12)# twelve vertices
2104 self.assertEqual(len(edges), 4) # each vertex connects to four other vertices
2106 self.assertEqual(vertices, othervertices) # edge vertices in original set
2112 self.assertEqual(facesizes[3], 8) # eight triangular faces
2113 self.assertEqual(facesizes[4], 6) # six square faces
2117 self.assertEqual(len(edge), 2) # Two cube vertices define an edge
2119 self.assertIn(cubevert, g)