Lines Matching refs:self
16 def __init__(self):
17 self.cycle = self
28 def setUp(self):
30 self.items = [ustr(c) for c in ('a', 'b', 'c')]
31 self.items2 = [ustr(c) for c in ('x', 'y', 'z')]
32 self.ab_items = [ustr(c) for c in 'ab']
33 self.abcde_items = [ustr(c) for c in 'abcde']
34 self.def_items = [ustr(c) for c in 'def']
35 self.ab_weakset = WeakSet(self.ab_items)
36 self.abcde_weakset = WeakSet(self.abcde_items)
37 self.def_weakset = WeakSet(self.def_items)
38 self.letters = [ustr(c) for c in string.ascii_letters]
39 self.s = WeakSet(self.items)
40 self.d = dict.fromkeys(self.items)
41 self.obj = ustr('F')
42 self.fs = WeakSet([self.obj])
44 def test_methods(self):
49 self.assertIn(method, weaksetmethods,
52 def test_new_or_init(self):
53 self.assertRaises(TypeError, WeakSet, [], 2)
55 def test_len(self):
56 self.assertEqual(len(self.s), len(self.d))
57 self.assertEqual(len(self.fs), 1)
58 del self.obj
60 self.assertEqual(len(self.fs), 0)
62 def test_contains(self):
63 for c in self.letters:
64 self.assertEqual(c in self.s, c in self.d)
66 self.assertNotIn(1, self.s)
67 self.assertIn(self.obj, self.fs)
68 del self.obj
70 self.assertNotIn(ustr('F'), self.fs)
72 def test_union(self):
73 u = self.s.union(self.items2)
74 for c in self.letters:
75 self.assertEqual(c in u, c in self.d or c in self.items2)
76 self.assertEqual(self.s, WeakSet(self.items))
77 self.assertEqual(type(u), WeakSet)
78 self.assertRaises(TypeError, self.s.union, [[]])
80 x = WeakSet(self.items + self.items2)
81 c = C(self.items2)
82 self.assertEqual(self.s.union(c), x)
84 self.assertEqual(len(u), len(self.items) + len(self.items2))
85 self.items2.pop()
87 self.assertEqual(len(u), len(self.items) + len(self.items2))
89 def test_or(self):
90 i = self.s.union(self.items2)
91 self.assertEqual(self.s | set(self.items2), i)
92 self.assertEqual(self.s | frozenset(self.items2), i)
94 def test_intersection(self):
95 s = WeakSet(self.letters)
96 i = s.intersection(self.items2)
97 for c in self.letters:
98 self.assertEqual(c in i, c in self.items2 and c in self.letters)
99 self.assertEqual(s, WeakSet(self.letters))
100 self.assertEqual(type(i), WeakSet)
103 self.assertEqual(i.intersection(C(self.items)), x)
104 self.assertEqual(len(i), len(self.items2))
105 self.items2.pop()
107 self.assertEqual(len(i), len(self.items2))
109 def test_isdisjoint(self):
110 self.assertTrue(self.s.isdisjoint(WeakSet(self.items2)))
111 self.assertTrue(not self.s.isdisjoint(WeakSet(self.letters)))
113 def test_and(self):
114 i = self.s.intersection(self.items2)
115 self.assertEqual(self.s & set(self.items2), i)
116 self.assertEqual(self.s & frozenset(self.items2), i)
118 def test_difference(self):
119 i = self.s.difference(self.items2)
120 for c in self.letters:
121 self.assertEqual(c in i, c in self.d and c not in self.items2)
122 self.assertEqual(self.s, WeakSet(self.items))
123 self.assertEqual(type(i), WeakSet)
124 self.assertRaises(TypeError, self.s.difference, [[]])
126 def test_sub(self):
127 i = self.s.difference(self.items2)
128 self.assertEqual(self.s - set(self.items2), i)
129 self.assertEqual(self.s - frozenset(self.items2), i)
131 def test_symmetric_difference(self):
132 i = self.s.symmetric_difference(self.items2)
133 for c in self.letters:
134 self.assertEqual(c in i, (c in self.d) ^ (c in self.items2))
135 self.assertEqual(self.s, WeakSet(self.items))
136 self.assertEqual(type(i), WeakSet)
137 self.assertRaises(TypeError, self.s.symmetric_difference, [[]])
138 self.assertEqual(len(i), len(self.items) + len(self.items2))
139 self.items2.pop()
141 self.assertEqual(len(i), len(self.items) + len(self.items2))
143 def test_xor(self):
144 i = self.s.symmetric_difference(self.items2)
145 self.assertEqual(self.s ^ set(self.items2), i)
146 self.assertEqual(self.s ^ frozenset(self.items2), i)
148 def test_sub_and_super(self):
149 self.assertTrue(self.ab_weakset <= self.abcde_weakset)
150 self.assertTrue(self.abcde_weakset <= self.abcde_weakset)
151 self.assertTrue(self.abcde_weakset >= self.ab_weakset)
152 self.assertFalse(self.abcde_weakset <= self.def_weakset)
153 self.assertFalse(self.abcde_weakset >= self.def_weakset)
154 self.assertTrue(set('a').issubset('abc'))
155 self.assertTrue(set('abc').issuperset('a'))
156 self.assertFalse(set('a').issubset('cbs'))
157 self.assertFalse(set('cbs').issuperset('a'))
159 def test_lt(self):
160 self.assertTrue(self.ab_weakset < self.abcde_weakset)
161 self.assertFalse(self.abcde_weakset < self.def_weakset)
162 self.assertFalse(self.ab_weakset < self.ab_weakset)
163 self.assertFalse(WeakSet() < WeakSet())
165 def test_gt(self):
166 self.assertTrue(self.abcde_weakset > self.ab_weakset)
167 self.assertFalse(self.abcde_weakset > self.def_weakset)
168 self.assertFalse(self.ab_weakset > self.ab_weakset)
169 self.assertFalse(WeakSet() > WeakSet())
171 def test_gc(self):
179 def test_subclass_with_custom_hash(self):
182 def __hash__(self):
183 return int(id(self) & 0x7fffffff)
187 self.assertIn(s, f)
192 def test_init(self):
194 s.__init__(self.items)
195 self.assertEqual(s, self.s)
196 s.__init__(self.items2)
197 self.assertEqual(s, WeakSet(self.items2))
198 self.assertRaises(TypeError, s.__init__, s, 2);
199 self.assertRaises(TypeError, s.__init__, 1);
201 def test_constructor_identity(self):
202 s = WeakSet(self.items)
204 self.assertNotEqual(id(s), id(t))
206 def test_hash(self):
207 self.assertRaises(TypeError, hash, self.s)
209 def test_clear(self):
210 self.s.clear()
211 self.assertEqual(self.s, WeakSet([]))
212 self.assertEqual(len(self.s), 0)
214 def test_copy(self):
215 dup = self.s.copy()
216 self.assertEqual(self.s, dup)
217 self.assertNotEqual(id(self.s), id(dup))
219 def test_add(self):
221 self.s.add(x)
222 self.assertIn(x, self.s)
223 dup = self.s.copy()
224 self.s.add(x)
225 self.assertEqual(self.s, dup)
226 self.assertRaises(TypeError, self.s.add, [])
227 self.fs.add(Foo())
229 self.assertTrue(len(self.fs) == 1)
230 self.fs.add(self.obj)
231 self.assertTrue(len(self.fs) == 1)
233 def test_remove(self):
235 self.s.remove(x)
236 self.assertNotIn(x, self.s)
237 self.assertRaises(KeyError, self.s.remove, x)
238 self.assertRaises(TypeError, self.s.remove, [])
240 def test_discard(self):
242 self.s.discard(a)
243 self.assertNotIn(a, self.s)
244 self.s.discard(q)
245 self.assertRaises(TypeError, self.s.discard, [])
247 def test_pop(self):
248 for i in range(len(self.s)):
249 elem = self.s.pop()
250 self.assertNotIn(elem, self.s)
251 self.assertRaises(KeyError, self.s.pop)
253 def test_update(self):
254 retval = self.s.update(self.items2)
255 self.assertEqual(retval, None)
256 for c in (self.items + self.items2):
257 self.assertIn(c, self.s)
258 self.assertRaises(TypeError, self.s.update, [[]])
260 def test_update_set(self):
261 self.s.update(set(self.items2))
262 for c in (self.items + self.items2):
263 self.assertIn(c, self.s)
265 def test_ior(self):
266 self.s |= set(self.items2)
267 for c in (self.items + self.items2):
268 self.assertIn(c, self.s)
270 def test_intersection_update(self):
271 retval = self.s.intersection_update(self.items2)
272 self.assertEqual(retval, None)
273 for c in (self.items + self.items2):
274 if c in self.items2 and c in self.items:
275 self.assertIn(c, self.s)
277 self.assertNotIn(c, self.s)
278 self.assertRaises(TypeError, self.s.intersection_update, [[]])
280 def test_iand(self):
281 self.s &= set(self.items2)
282 for c in (self.items + self.items2):
283 if c in self.items2 and c in self.items:
284 self.assertIn(c, self.s)
286 self.assertNotIn(c, self.s)
288 def test_difference_update(self):
289 retval = self.s.difference_update(self.items2)
290 self.assertEqual(retval, None)
291 for c in (self.items + self.items2):
292 if c in self.items and c not in self.items2:
293 self.assertIn(c, self.s)
295 self.assertNotIn(c, self.s)
296 self.assertRaises(TypeError, self.s.difference_update, [[]])
297 self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
299 def test_isub(self):
300 self.s -= set(self.items2)
301 for c in (self.items + self.items2):
302 if c in self.items and c not in self.items2:
303 self.assertIn(c, self.s)
305 self.assertNotIn(c, self.s)
307 def test_symmetric_difference_update(self):
308 retval = self.s.symmetric_difference_update(self.items2)
309 self.assertEqual(retval, None)
310 for c in (self.items + self.items2):
311 if (c in self.items) ^ (c in self.items2):
312 self.assertIn(c, self.s)
314 self.assertNotIn(c, self.s)
315 self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
317 def test_ixor(self):
318 self.s ^= set(self.items2)
319 for c in (self.items + self.items2):
320 if (c in self.items) ^ (c in self.items2):
321 self.assertIn(c, self.s)
323 self.assertNotIn(c, self.s)
325 def test_inplace_on_self(self):
326 t = self.s.copy()
328 self.assertEqual(t, self.s)
330 self.assertEqual(t, self.s)
332 self.assertEqual(t, WeakSet())
333 t = self.s.copy()
335 self.assertEqual(t, WeakSet())
337 def test_eq(self):
339 self.assertTrue(self.s == self.s)
340 self.assertTrue(self.s == WeakSet(self.items))
341 self.assertFalse(self.s == set(self.items))
342 self.assertFalse(self.s == list(self.items))
343 self.assertFalse(self.s == tuple(self.items))
344 self.assertFalse(self.s == WeakSet([Foo]))
345 self.assertFalse(self.s == 1)
347 def test_ne(self):
348 self.assertTrue(self.s != set(self.items))
351 self.assertFalse(s1 != s2)
353 def test_weak_destroy_while_iterating(self):
364 self.assertIn(len(list(it)), [len(items), len(items) - 1])
367 self.assertEqual(len(s), len(items))
369 def test_weak_destroy_and_mutate_while_iterating(self):
391 self.assertNotIn(u, s)
393 self.assertRaises(KeyError, s.remove, u)
394 self.assertNotIn(u, s)
397 self.assertIn(u, s)
401 self.assertEqual(len(s), len(t))
404 self.assertEqual(len(s), 0)
406 def test_len_cycles(self):
423 self.assertIn(n1, (0, 1))
424 self.assertEqual(n2, 0)
426 def test_len_race(self):
428 self.addCleanup(gc.set_threshold, *gc.get_threshold())
445 self.assertGreaterEqual(n1, 0)
446 self.assertLessEqual(n1, N)
447 self.assertGreaterEqual(n2, 0)
448 self.assertLessEqual(n2, n1)
450 def test_repr(self):
451 assert repr(self.s) == repr(self.s.data)
453 def test_abc(self):
454 self.assertIsInstance(self.s, Set)
455 self.assertIsInstance(self.s, MutableSet)
457 def test_copying(self):
459 s = cls(self.items)
464 self.assertIsInstance(dup, cls)
465 self.assertEqual(dup, s)
466 self.assertIsNot(dup, s)
467 self.assertIs(dup.x, s.x)
468 self.assertIs(dup.z, s.z)
469 self.assertFalse(hasattr(dup, 'y'))
472 self.assertIsInstance(dup, cls)
473 self.assertEqual(dup, s)
474 self.assertIsNot(dup, s)
475 self.assertEqual(dup.x, s.x)
476 self.assertIsNot(dup.x, s.x)
477 self.assertEqual(dup.z, s.z)
478 self.assertIsNot(dup.z, s.z)
479 self.assertFalse(hasattr(dup, 'y'))