1 import unittest
2 from test import test_support
3 from weakref import proxy, ref, WeakSet
4 import operator
5 import copy
6 import string
7 import os
8 from random import randrange, shuffle
9 import sys
10 import warnings
11 import collections
12 import gc
13 import contextlib
14 
15 
16 class Foo:
17     pass
18 
19 class SomeClass(object):
20     def __init__(self, value):
21         self.value = value
22     def __eq__(self, other):
23         if type(other) != type(self):
24             return False
25         return other.value == self.value
26 
27     def __ne__(self, other):
28         return not self.__eq__(other)
29 
30     def __hash__(self):
31         return hash((SomeClass, self.value))
32 
33 class RefCycle(object):
34     def __init__(self):
35         self.cycle = self
36 
37 class TestWeakSet(unittest.TestCase):
38 
39     def setUp(self):
40         # need to keep references to them
41         self.items = [SomeClass(c) for c in ('a', 'b', 'c')]
42         self.items2 = [SomeClass(c) for c in ('x', 'y', 'z')]
43         self.letters = [SomeClass(c) for c in string.ascii_letters]
44         self.ab_items = [SomeClass(c) for c in 'ab']
45         self.abcde_items = [SomeClass(c) for c in 'abcde']
46         self.def_items = [SomeClass(c) for c in 'def']
47         self.ab_weakset = WeakSet(self.ab_items)
48         self.abcde_weakset = WeakSet(self.abcde_items)
49         self.def_weakset = WeakSet(self.def_items)
50         self.s = WeakSet(self.items)
51         self.d = dict.fromkeys(self.items)
52         self.obj = SomeClass('F')
53         self.fs = WeakSet([self.obj])
54 
55     def test_methods(self):
56         weaksetmethods = dir(WeakSet)
57         for method in dir(set):
58             if method == 'test_c_api' or method.startswith('_'):
59                 continue
60             self.assertIn(method, weaksetmethods,
61                          "WeakSet missing method " + method)
62 
63     def test_new_or_init(self):
64         self.assertRaises(TypeError, WeakSet, [], 2)
65 
66     def test_len(self):
67         self.assertEqual(len(self.s), len(self.d))
68         self.assertEqual(len(self.fs), 1)
69         del self.obj
70         self.assertEqual(len(self.fs), 0)
71 
72     def test_contains(self):
73         for c in self.letters:
74             self.assertEqual(c in self.s, c in self.d)
75         # 1 is not weakref'able, but that TypeError is caught by __contains__
76         self.assertNotIn(1, self.s)
77         self.assertIn(self.obj, self.fs)
78         del self.obj
79         self.assertNotIn(SomeClass('F'), self.fs)
80 
81     def test_union(self):
82         u = self.s.union(self.items2)
83         for c in self.letters:
84             self.assertEqual(c in u, c in self.d or c in self.items2)
85         self.assertEqual(self.s, WeakSet(self.items))
86         self.assertEqual(type(u), WeakSet)
87         self.assertRaises(TypeError, self.s.union, [[]])
88         for C in set, frozenset, dict.fromkeys, list, tuple:
89             x = WeakSet(self.items + self.items2)
90             c = C(self.items2)
91             self.assertEqual(self.s.union(c), x)
92             del c
93         self.assertEqual(len(u), len(self.items) + len(self.items2))
94         self.items2.pop()
95         gc.collect()
96         self.assertEqual(len(u), len(self.items) + len(self.items2))
97 
98     def test_or(self):
99         i = self.s.union(self.items2)
100         self.assertEqual(self.s | set(self.items2), i)
101         self.assertEqual(self.s | frozenset(self.items2), i)
102 
103     def test_intersection(self):
104         s = WeakSet(self.letters)
105         i = s.intersection(self.items2)
106         for c in self.letters:
107             self.assertEqual(c in i, c in self.items2 and c in self.letters)
108         self.assertEqual(s, WeakSet(self.letters))
109         self.assertEqual(type(i), WeakSet)
110         for C in set, frozenset, dict.fromkeys, list, tuple:
111             x = WeakSet([])
112             self.assertEqual(i.intersection(C(self.items)), x)
113         self.assertEqual(len(i), len(self.items2))
114         self.items2.pop()
115         gc.collect()
116         self.assertEqual(len(i), len(self.items2))
117 
118     def test_isdisjoint(self):
119         self.assertTrue(self.s.isdisjoint(WeakSet(self.items2)))
120         self.assertTrue(not self.s.isdisjoint(WeakSet(self.letters)))
121 
122     def test_and(self):
123         i = self.s.intersection(self.items2)
124         self.assertEqual(self.s & set(self.items2), i)
125         self.assertEqual(self.s & frozenset(self.items2), i)
126 
127     def test_difference(self):
128         i = self.s.difference(self.items2)
129         for c in self.letters:
130             self.assertEqual(c in i, c in self.d and c not in self.items2)
131         self.assertEqual(self.s, WeakSet(self.items))
132         self.assertEqual(type(i), WeakSet)
133         self.assertRaises(TypeError, self.s.difference, [[]])
134 
135     def test_sub(self):
136         i = self.s.difference(self.items2)
137         self.assertEqual(self.s - set(self.items2), i)
138         self.assertEqual(self.s - frozenset(self.items2), i)
139 
140     def test_symmetric_difference(self):
141         i = self.s.symmetric_difference(self.items2)
142         for c in self.letters:
143             self.assertEqual(c in i, (c in self.d) ^ (c in self.items2))
144         self.assertEqual(self.s, WeakSet(self.items))
145         self.assertEqual(type(i), WeakSet)
146         self.assertRaises(TypeError, self.s.symmetric_difference, [[]])
147         self.assertEqual(len(i), len(self.items) + len(self.items2))
148         self.items2.pop()
149         gc.collect()
150         self.assertEqual(len(i), len(self.items) + len(self.items2))
151 
152     def test_xor(self):
153         i = self.s.symmetric_difference(self.items2)
154         self.assertEqual(self.s ^ set(self.items2), i)
155         self.assertEqual(self.s ^ frozenset(self.items2), i)
156 
157     def test_sub_and_super(self):
158         self.assertTrue(self.ab_weakset <= self.abcde_weakset)
159         self.assertTrue(self.abcde_weakset <= self.abcde_weakset)
160         self.assertTrue(self.abcde_weakset >= self.ab_weakset)
161         self.assertFalse(self.abcde_weakset <= self.def_weakset)
162         self.assertFalse(self.abcde_weakset >= self.def_weakset)
163         self.assertTrue(set('a').issubset('abc'))
164         self.assertTrue(set('abc').issuperset('a'))
165         self.assertFalse(set('a').issubset('cbs'))
166         self.assertFalse(set('cbs').issuperset('a'))
167 
168     def test_lt(self):
169         self.assertTrue(self.ab_weakset < self.abcde_weakset)
170         self.assertFalse(self.abcde_weakset < self.def_weakset)
171         self.assertFalse(self.ab_weakset < self.ab_weakset)
172         self.assertFalse(WeakSet() < WeakSet())
173 
174     def test_gt(self):
175         self.assertTrue(self.abcde_weakset > self.ab_weakset)
176         self.assertFalse(self.abcde_weakset > self.def_weakset)
177         self.assertFalse(self.ab_weakset > self.ab_weakset)
178         self.assertFalse(WeakSet() > WeakSet())
179 
180     def test_gc(self):
181         # Create a nest of cycles to exercise overall ref count check
182         s = WeakSet(Foo() for i in range(1000))
183         for elem in s:
184             elem.cycle = s
185             elem.sub = elem
186             elem.set = WeakSet([elem])
187 
188     def test_subclass_with_custom_hash(self):
189         # Bug #1257731
190         class H(WeakSet):
191             def __hash__(self):
192                 return int(id(self) & 0x7fffffff)
193         s=H()
194         f=set()
195         f.add(s)
196         self.assertIn(s, f)
197         f.remove(s)
198         f.add(s)
199         f.discard(s)
200 
201     def test_init(self):
202         s = WeakSet()
203         s.__init__(self.items)
204         self.assertEqual(s, self.s)
205         s.__init__(self.items2)
206         self.assertEqual(s, WeakSet(self.items2))
207         self.assertRaises(TypeError, s.__init__, s, 2);
208         self.assertRaises(TypeError, s.__init__, 1);
209 
210     def test_constructor_identity(self):
211         s = WeakSet(self.items)
212         t = WeakSet(s)
213         self.assertNotEqual(id(s), id(t))
214 
215     def test_hash(self):
216         self.assertRaises(TypeError, hash, self.s)
217 
218     def test_clear(self):
219         self.s.clear()
220         self.assertEqual(self.s, WeakSet([]))
221         self.assertEqual(len(self.s), 0)
222 
223     def test_copy(self):
224         dup = self.s.copy()
225         self.assertEqual(self.s, dup)
226         self.assertNotEqual(id(self.s), id(dup))
227 
228     def test_add(self):
229         x = SomeClass('Q')
230         self.s.add(x)
231         self.assertIn(x, self.s)
232         dup = self.s.copy()
233         self.s.add(x)
234         self.assertEqual(self.s, dup)
235         self.assertRaises(TypeError, self.s.add, [])
236         self.fs.add(Foo())
237         self.assertTrue(len(self.fs) == 1)
238         self.fs.add(self.obj)
239         self.assertTrue(len(self.fs) == 1)
240 
241     def test_remove(self):
242         x = SomeClass('a')
243         self.s.remove(x)
244         self.assertNotIn(x, self.s)
245         self.assertRaises(KeyError, self.s.remove, x)
246         self.assertRaises(TypeError, self.s.remove, [])
247 
248     def test_discard(self):
249         a, q = SomeClass('a'), SomeClass('Q')
250         self.s.discard(a)
251         self.assertNotIn(a, self.s)
252         self.s.discard(q)
253         self.assertRaises(TypeError, self.s.discard, [])
254 
255     def test_pop(self):
256         for i in range(len(self.s)):
257             elem = self.s.pop()
258             self.assertNotIn(elem, self.s)
259         self.assertRaises(KeyError, self.s.pop)
260 
261     def test_update(self):
262         retval = self.s.update(self.items2)
263         self.assertEqual(retval, None)
264         for c in (self.items + self.items2):
265             self.assertIn(c, self.s)
266         self.assertRaises(TypeError, self.s.update, [[]])
267 
268     def test_update_set(self):
269         self.s.update(set(self.items2))
270         for c in (self.items + self.items2):
271             self.assertIn(c, self.s)
272 
273     def test_ior(self):
274         self.s |= set(self.items2)
275         for c in (self.items + self.items2):
276             self.assertIn(c, self.s)
277 
278     def test_intersection_update(self):
279         retval = self.s.intersection_update(self.items2)
280         self.assertEqual(retval, None)
281         for c in (self.items + self.items2):
282             if c in self.items2 and c in self.items:
283                 self.assertIn(c, self.s)
284             else:
285                 self.assertNotIn(c, self.s)
286         self.assertRaises(TypeError, self.s.intersection_update, [[]])
287 
288     def test_iand(self):
289         self.s &= set(self.items2)
290         for c in (self.items + self.items2):
291             if c in self.items2 and c in self.items:
292                 self.assertIn(c, self.s)
293             else:
294                 self.assertNotIn(c, self.s)
295 
296     def test_difference_update(self):
297         retval = self.s.difference_update(self.items2)
298         self.assertEqual(retval, None)
299         for c in (self.items + self.items2):
300             if c in self.items and c not in self.items2:
301                 self.assertIn(c, self.s)
302             else:
303                 self.assertNotIn(c, self.s)
304         self.assertRaises(TypeError, self.s.difference_update, [[]])
305         self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
306 
307     def test_isub(self):
308         self.s -= set(self.items2)
309         for c in (self.items + self.items2):
310             if c in self.items and c not in self.items2:
311                 self.assertIn(c, self.s)
312             else:
313                 self.assertNotIn(c, self.s)
314 
315     def test_symmetric_difference_update(self):
316         retval = self.s.symmetric_difference_update(self.items2)
317         self.assertEqual(retval, None)
318         for c in (self.items + self.items2):
319             if (c in self.items) ^ (c in self.items2):
320                 self.assertIn(c, self.s)
321             else:
322                 self.assertNotIn(c, self.s)
323         self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
324 
325     def test_ixor(self):
326         self.s ^= set(self.items2)
327         for c in (self.items + self.items2):
328             if (c in self.items) ^ (c in self.items2):
329                 self.assertIn(c, self.s)
330             else:
331                 self.assertNotIn(c, self.s)
332 
333     def test_inplace_on_self(self):
334         t = self.s.copy()
335         t |= t
336         self.assertEqual(t, self.s)
337         t &= t
338         self.assertEqual(t, self.s)
339         t -= t
340         self.assertEqual(t, WeakSet())
341         t = self.s.copy()
342         t ^= t
343         self.assertEqual(t, WeakSet())
344 
345     def test_eq(self):
346         # issue 5964
347         self.assertTrue(self.s == self.s)
348         self.assertTrue(self.s == WeakSet(self.items))
349         self.assertFalse(self.s == set(self.items))
350         self.assertFalse(self.s == list(self.items))
351         self.assertFalse(self.s == tuple(self.items))
352         self.assertFalse(self.s == 1)
353 
354     def test_ne(self):
355         self.assertTrue(self.s != set(self.items))
356         s1 = WeakSet()
357         s2 = WeakSet()
358         self.assertFalse(s1 != s2)
359 
360     def test_weak_destroy_while_iterating(self):
361         # Issue #7105: iterators shouldn't crash when a key is implicitly removed
362         # Create new items to be sure no-one else holds a reference
363         items = [SomeClass(c) for c in ('a', 'b', 'c')]
364         s = WeakSet(items)
365         it = iter(s)
366         next(it)             # Trigger internal iteration
367         # Destroy an item
368         del items[-1]
369         gc.collect()    # just in case
370         # We have removed either the first consumed items, or another one
371         self.assertIn(len(list(it)), [len(items), len(items) - 1])
372         del it
373         # The removal has been committed
374         self.assertEqual(len(s), len(items))
375 
376     def test_weak_destroy_and_mutate_while_iterating(self):
377         # Issue #7105: iterators shouldn't crash when a key is implicitly removed
378         items = [SomeClass(c) for c in string.ascii_letters]
379         s = WeakSet(items)
380         @contextlib.contextmanager
381         def testcontext():
382             try:
383                 it = iter(s)
384                 next(it)
385                 # Schedule an item for removal and recreate it
386                 u = SomeClass(str(items.pop()))
387                 gc.collect()      # just in case
388                 yield u
389             finally:
390                 it = None           # should commit all removals
391 
392         with testcontext() as u:
393             self.assertNotIn(u, s)
394         with testcontext() as u:
395             self.assertRaises(KeyError, s.remove, u)
396         self.assertNotIn(u, s)
397         with testcontext() as u:
398             s.add(u)
399         self.assertIn(u, s)
400         t = s.copy()
401         with testcontext() as u:
402             s.update(t)
403         self.assertEqual(len(s), len(t))
404         with testcontext() as u:
405             s.clear()
406         self.assertEqual(len(s), 0)
407 
408     def test_len_cycles(self):
409         N = 20
410         items = [RefCycle() for i in range(N)]
411         s = WeakSet(items)
412         del items
413         it = iter(s)
414         try:
415             next(it)
416         except StopIteration:
417             pass
418         gc.collect()
419         n1 = len(s)
420         del it
421         gc.collect()
422         n2 = len(s)
423         # one item may be kept alive inside the iterator
424         self.assertIn(n1, (0, 1))
425         self.assertEqual(n2, 0)
426 
427     def test_len_race(self):
428         # Extended sanity checks for len() in the face of cyclic collection
429         self.addCleanup(gc.set_threshold, *gc.get_threshold())
430         for th in range(1, 100):
431             N = 20
432             gc.collect(0)
433             gc.set_threshold(th, th, th)
434             items = [RefCycle() for i in range(N)]
435             s = WeakSet(items)
436             del items
437             # All items will be collected at next garbage collection pass
438             it = iter(s)
439             try:
440                 next(it)
441             except StopIteration:
442                 pass
443             n1 = len(s)
444             del it
445             n2 = len(s)
446             self.assertGreaterEqual(n1, 0)
447             self.assertLessEqual(n1, N)
448             self.assertGreaterEqual(n2, 0)
449             self.assertLessEqual(n2, n1)
450 
451 
452 def test_main(verbose=None):
453     test_support.run_unittest(TestWeakSet)
454 
455 if __name__ == "__main__":
456     test_main(verbose=True)
457