Lines Matching full:self
15 def __init__(self): argument
16 self.cycle = self
21 def setUp(self): argument
23 self.items = [ustr(c) for c in ('a', 'b', 'c')]
24 self.items2 = [ustr(c) for c in ('x', 'y', 'z')]
25 self.ab_items = [ustr(c) for c in 'ab']
26 self.abcde_items = [ustr(c) for c in 'abcde']
27 self.def_items = [ustr(c) for c in 'def']
28 self.ab_weakset = WeakSet(self.ab_items)
29 self.abcde_weakset = WeakSet(self.abcde_items)
30 self.def_weakset = WeakSet(self.def_items)
31 self.letters = [ustr(c) for c in string.ascii_letters]
32 self.s = WeakSet(self.items)
33 self.d = dict.fromkeys(self.items)
34 self.obj = ustr('F')
35 self.fs = WeakSet([self.obj])
37 def test_methods(self): argument
42 self.assertIn(method, weaksetmethods,
45 def test_new_or_init(self): argument
46 self.assertRaises(TypeError, WeakSet, [], 2)
48 def test_len(self): argument
49 self.assertEqual(len(self.s), len(self.d))
50 self.assertEqual(len(self.fs), 1)
51 del self.obj
53 self.assertEqual(len(self.fs), 0)
55 def test_contains(self): argument
56 for c in self.letters:
57 self.assertEqual(c in self.s, c in self.d)
59 self.assertNotIn(1, self.s)
60 self.assertIn(self.obj, self.fs)
61 del self.obj
63 self.assertNotIn(ustr('F'), self.fs)
65 def test_union(self): argument
66 u = self.s.union(self.items2)
67 for c in self.letters:
68 self.assertEqual(c in u, c in self.d or c in self.items2)
69 self.assertEqual(self.s, WeakSet(self.items))
70 self.assertEqual(type(u), WeakSet)
71 self.assertRaises(TypeError, self.s.union, [[]])
73 x = WeakSet(self.items + self.items2)
74 c = C(self.items2)
75 self.assertEqual(self.s.union(c), x)
77 self.assertEqual(len(u), len(self.items) + len(self.items2))
78 self.items2.pop()
80 self.assertEqual(len(u), len(self.items) + len(self.items2))
82 def test_or(self): argument
83 i = self.s.union(self.items2)
84 self.assertEqual(self.s | set(self.items2), i)
85 self.assertEqual(self.s | frozenset(self.items2), i)
87 def test_intersection(self): argument
88 s = WeakSet(self.letters)
89 i = s.intersection(self.items2)
90 for c in self.letters:
91 self.assertEqual(c in i, c in self.items2 and c in self.letters)
92 self.assertEqual(s, WeakSet(self.letters))
93 self.assertEqual(type(i), WeakSet)
96 self.assertEqual(i.intersection(C(self.items)), x)
97 self.assertEqual(len(i), len(self.items2))
98 self.items2.pop()
100 self.assertEqual(len(i), len(self.items2))
102 def test_isdisjoint(self): argument
103 self.assertTrue(self.s.isdisjoint(WeakSet(self.items2)))
104 self.assertTrue(not self.s.isdisjoint(WeakSet(self.letters)))
106 def test_and(self): argument
107 i = self.s.intersection(self.items2)
108 self.assertEqual(self.s & set(self.items2), i)
109 self.assertEqual(self.s & frozenset(self.items2), i)
111 def test_difference(self): argument
112 i = self.s.difference(self.items2)
113 for c in self.letters:
114 self.assertEqual(c in i, c in self.d and c not in self.items2)
115 self.assertEqual(self.s, WeakSet(self.items))
116 self.assertEqual(type(i), WeakSet)
117 self.assertRaises(TypeError, self.s.difference, [[]])
119 def test_sub(self): argument
120 i = self.s.difference(self.items2)
121 self.assertEqual(self.s - set(self.items2), i)
122 self.assertEqual(self.s - frozenset(self.items2), i)
124 def test_symmetric_difference(self): argument
125 i = self.s.symmetric_difference(self.items2)
126 for c in self.letters:
127 self.assertEqual(c in i, (c in self.d) ^ (c in self.items2))
128 self.assertEqual(self.s, WeakSet(self.items))
129 self.assertEqual(type(i), WeakSet)
130 self.assertRaises(TypeError, self.s.symmetric_difference, [[]])
131 self.assertEqual(len(i), len(self.items) + len(self.items2))
132 self.items2.pop()
134 self.assertEqual(len(i), len(self.items) + len(self.items2))
136 def test_xor(self): argument
137 i = self.s.symmetric_difference(self.items2)
138 self.assertEqual(self.s ^ set(self.items2), i)
139 self.assertEqual(self.s ^ frozenset(self.items2), i)
141 def test_sub_and_super(self): argument
142 self.assertTrue(self.ab_weakset <= self.abcde_weakset)
143 self.assertTrue(self.abcde_weakset <= self.abcde_weakset)
144 self.assertTrue(self.abcde_weakset >= self.ab_weakset)
145 self.assertFalse(self.abcde_weakset <= self.def_weakset)
146 self.assertFalse(self.abcde_weakset >= self.def_weakset)
147 self.assertTrue(set('a').issubset('abc'))
148 self.assertTrue(set('abc').issuperset('a'))
149 self.assertFalse(set('a').issubset('cbs'))
150 self.assertFalse(set('cbs').issuperset('a'))
152 def test_lt(self): argument
153 self.assertTrue(self.ab_weakset < self.abcde_weakset)
154 self.assertFalse(self.abcde_weakset < self.def_weakset)
155 self.assertFalse(self.ab_weakset < self.ab_weakset)
156 self.assertFalse(WeakSet() < WeakSet())
158 def test_gt(self): argument
159 self.assertTrue(self.abcde_weakset > self.ab_weakset)
160 self.assertFalse(self.abcde_weakset > self.def_weakset)
161 self.assertFalse(self.ab_weakset > self.ab_weakset)
162 self.assertFalse(WeakSet() > WeakSet())
164 def test_gc(self): argument
172 def test_subclass_with_custom_hash(self): argument
175 def __hash__(self): argument
176 return int(id(self) & 0x7fffffff)
180 self.assertIn(s, f)
185 def test_init(self): argument
187 s.__init__(self.items)
188 self.assertEqual(s, self.s)
189 s.__init__(self.items2)
190 self.assertEqual(s, WeakSet(self.items2))
191 self.assertRaises(TypeError, s.__init__, s, 2);
192 self.assertRaises(TypeError, s.__init__, 1);
194 def test_constructor_identity(self): argument
195 s = WeakSet(self.items)
197 self.assertNotEqual(id(s), id(t))
199 def test_hash(self): argument
200 self.assertRaises(TypeError, hash, self.s)
202 def test_clear(self): argument
203 self.s.clear()
204 self.assertEqual(self.s, WeakSet([]))
205 self.assertEqual(len(self.s), 0)
207 def test_copy(self): argument
208 dup = self.s.copy()
209 self.assertEqual(self.s, dup)
210 self.assertNotEqual(id(self.s), id(dup))
212 def test_add(self): argument
214 self.s.add(x)
215 self.assertIn(x, self.s)
216 dup = self.s.copy()
217 self.s.add(x)
218 self.assertEqual(self.s, dup)
219 self.assertRaises(TypeError, self.s.add, [])
220 self.fs.add(Foo())
222 self.assertTrue(len(self.fs) == 1)
223 self.fs.add(self.obj)
224 self.assertTrue(len(self.fs) == 1)
226 def test_remove(self): argument
228 self.s.remove(x)
229 self.assertNotIn(x, self.s)
230 self.assertRaises(KeyError, self.s.remove, x)
231 self.assertRaises(TypeError, self.s.remove, [])
233 def test_discard(self): argument
235 self.s.discard(a)
236 self.assertNotIn(a, self.s)
237 self.s.discard(q)
238 self.assertRaises(TypeError, self.s.discard, [])
240 def test_pop(self): argument
241 for i in range(len(self.s)):
242 elem = self.s.pop()
243 self.assertNotIn(elem, self.s)
244 self.assertRaises(KeyError, self.s.pop)
246 def test_update(self): argument
247 retval = self.s.update(self.items2)
248 self.assertEqual(retval, None)
249 for c in (self.items + self.items2):
250 self.assertIn(c, self.s)
251 self.assertRaises(TypeError, self.s.update, [[]])
253 def test_update_set(self): argument
254 self.s.update(set(self.items2))
255 for c in (self.items + self.items2):
256 self.assertIn(c, self.s)
258 def test_ior(self): argument
259 self.s |= set(self.items2)
260 for c in (self.items + self.items2):
261 self.assertIn(c, self.s)
263 def test_intersection_update(self): argument
264 retval = self.s.intersection_update(self.items2)
265 self.assertEqual(retval, None)
266 for c in (self.items + self.items2):
267 if c in self.items2 and c in self.items:
268 self.assertIn(c, self.s)
270 self.assertNotIn(c, self.s)
271 self.assertRaises(TypeError, self.s.intersection_update, [[]])
273 def test_iand(self): argument
274 self.s &= set(self.items2)
275 for c in (self.items + self.items2):
276 if c in self.items2 and c in self.items:
277 self.assertIn(c, self.s)
279 self.assertNotIn(c, self.s)
281 def test_difference_update(self): argument
282 retval = self.s.difference_update(self.items2)
283 self.assertEqual(retval, None)
284 for c in (self.items + self.items2):
285 if c in self.items and c not in self.items2:
286 self.assertIn(c, self.s)
288 self.assertNotIn(c, self.s)
289 self.assertRaises(TypeError, self.s.difference_update, [[]])
290 self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
292 def test_isub(self): argument
293 self.s -= set(self.items2)
294 for c in (self.items + self.items2):
295 if c in self.items and c not in self.items2:
296 self.assertIn(c, self.s)
298 self.assertNotIn(c, self.s)
300 def test_symmetric_difference_update(self): argument
301 retval = self.s.symmetric_difference_update(self.items2)
302 self.assertEqual(retval, None)
303 for c in (self.items + self.items2):
304 if (c in self.items) ^ (c in self.items2):
305 self.assertIn(c, self.s)
307 self.assertNotIn(c, self.s)
308 self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])
310 def test_ixor(self): argument
311 self.s ^= set(self.items2)
312 for c in (self.items + self.items2):
313 if (c in self.items) ^ (c in self.items2):
314 self.assertIn(c, self.s)
316 self.assertNotIn(c, self.s)
318 def test_inplace_on_self(self): argument
319 t = self.s.copy()
321 self.assertEqual(t, self.s)
323 self.assertEqual(t, self.s)
325 self.assertEqual(t, WeakSet())
326 t = self.s.copy()
328 self.assertEqual(t, WeakSet())
330 def test_eq(self): argument
332 self.assertTrue(self.s == self.s)
333 self.assertTrue(self.s == WeakSet(self.items))
334 self.assertFalse(self.s == set(self.items))
335 self.assertFalse(self.s == list(self.items))
336 self.assertFalse(self.s == tuple(self.items))
337 self.assertFalse(self.s == WeakSet([Foo]))
338 self.assertFalse(self.s == 1)
340 def test_ne(self): argument
341 self.assertTrue(self.s != set(self.items))
344 self.assertFalse(s1 != s2)
346 def test_weak_destroy_while_iterating(self): argument
357 self.assertIn(len(list(it)), [len(items), len(items) - 1])
360 self.assertEqual(len(s), len(items))
362 def test_weak_destroy_and_mutate_while_iterating(self): argument
384 self.assertNotIn(u, s)
386 self.assertRaises(KeyError, s.remove, u)
387 self.assertNotIn(u, s)
390 self.assertIn(u, s)
394 self.assertEqual(len(s), len(t))
397 self.assertEqual(len(s), 0)
399 def test_len_cycles(self): argument
416 self.assertIn(n1, (0, 1))
417 self.assertEqual(n2, 0)
419 def test_len_race(self): argument
421 self.addCleanup(gc.set_threshold, *gc.get_threshold())
438 self.assertGreaterEqual(n1, 0)
439 self.assertLessEqual(n1, N)
440 self.assertGreaterEqual(n2, 0)
441 self.assertLessEqual(n2, n1)
443 def test_repr(self): argument
444 assert repr(self.s) == repr(self.s.data)
446 def test_abc(self): argument
447 self.assertIsInstance(self.s, Set)
448 self.assertIsInstance(self.s, MutableSet)