]> git.proxmox.com Git - mirror_edk2.git/blame - AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_set.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS
[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_set.py
CommitLineData
4710c53d 1\r
2import unittest\r
3from test import test_support\r
4import gc\r
5import weakref\r
6import operator\r
7import copy\r
8import pickle\r
9from random import randrange, shuffle\r
10import sys\r
11import collections\r
12\r
13class PassThru(Exception):\r
14 pass\r
15\r
16def check_pass_thru():\r
17 raise PassThru\r
18 yield 1\r
19\r
20class BadCmp:\r
21 def __hash__(self):\r
22 return 1\r
23 def __cmp__(self, other):\r
24 raise RuntimeError\r
25\r
26class ReprWrapper:\r
27 'Used to test self-referential repr() calls'\r
28 def __repr__(self):\r
29 return repr(self.value)\r
30\r
31class HashCountingInt(int):\r
32 'int-like object that counts the number of times __hash__ is called'\r
33 def __init__(self, *args):\r
34 self.hash_count = 0\r
35 def __hash__(self):\r
36 self.hash_count += 1\r
37 return int.__hash__(self)\r
38\r
39class TestJointOps(unittest.TestCase):\r
40 # Tests common to both set and frozenset\r
41\r
42 def setUp(self):\r
43 self.word = word = 'simsalabim'\r
44 self.otherword = 'madagascar'\r
45 self.letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'\r
46 self.s = self.thetype(word)\r
47 self.d = dict.fromkeys(word)\r
48\r
49 def test_new_or_init(self):\r
50 self.assertRaises(TypeError, self.thetype, [], 2)\r
51 self.assertRaises(TypeError, set().__init__, a=1)\r
52\r
53 def test_uniquification(self):\r
54 actual = sorted(self.s)\r
55 expected = sorted(self.d)\r
56 self.assertEqual(actual, expected)\r
57 self.assertRaises(PassThru, self.thetype, check_pass_thru())\r
58 self.assertRaises(TypeError, self.thetype, [[]])\r
59\r
60 def test_len(self):\r
61 self.assertEqual(len(self.s), len(self.d))\r
62\r
63 def test_contains(self):\r
64 for c in self.letters:\r
65 self.assertEqual(c in self.s, c in self.d)\r
66 self.assertRaises(TypeError, self.s.__contains__, [[]])\r
67 s = self.thetype([frozenset(self.letters)])\r
68 self.assertIn(self.thetype(self.letters), s)\r
69\r
70 def test_union(self):\r
71 u = self.s.union(self.otherword)\r
72 for c in self.letters:\r
73 self.assertEqual(c in u, c in self.d or c in self.otherword)\r
74 self.assertEqual(self.s, self.thetype(self.word))\r
75 self.assertEqual(type(u), self.thetype)\r
76 self.assertRaises(PassThru, self.s.union, check_pass_thru())\r
77 self.assertRaises(TypeError, self.s.union, [[]])\r
78 for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:\r
79 self.assertEqual(self.thetype('abcba').union(C('cdc')), set('abcd'))\r
80 self.assertEqual(self.thetype('abcba').union(C('efgfe')), set('abcefg'))\r
81 self.assertEqual(self.thetype('abcba').union(C('ccb')), set('abc'))\r
82 self.assertEqual(self.thetype('abcba').union(C('ef')), set('abcef'))\r
83 self.assertEqual(self.thetype('abcba').union(C('ef'), C('fg')), set('abcefg'))\r
84\r
85 # Issue #6573\r
86 x = self.thetype()\r
87 self.assertEqual(x.union(set([1]), x, set([2])), self.thetype([1, 2]))\r
88\r
89 def test_or(self):\r
90 i = self.s.union(self.otherword)\r
91 self.assertEqual(self.s | set(self.otherword), i)\r
92 self.assertEqual(self.s | frozenset(self.otherword), i)\r
93 try:\r
94 self.s | self.otherword\r
95 except TypeError:\r
96 pass\r
97 else:\r
98 self.fail("s|t did not screen-out general iterables")\r
99\r
100 def test_intersection(self):\r
101 i = self.s.intersection(self.otherword)\r
102 for c in self.letters:\r
103 self.assertEqual(c in i, c in self.d and c in self.otherword)\r
104 self.assertEqual(self.s, self.thetype(self.word))\r
105 self.assertEqual(type(i), self.thetype)\r
106 self.assertRaises(PassThru, self.s.intersection, check_pass_thru())\r
107 for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:\r
108 self.assertEqual(self.thetype('abcba').intersection(C('cdc')), set('cc'))\r
109 self.assertEqual(self.thetype('abcba').intersection(C('efgfe')), set(''))\r
110 self.assertEqual(self.thetype('abcba').intersection(C('ccb')), set('bc'))\r
111 self.assertEqual(self.thetype('abcba').intersection(C('ef')), set(''))\r
112 self.assertEqual(self.thetype('abcba').intersection(C('cbcf'), C('bag')), set('b'))\r
113 s = self.thetype('abcba')\r
114 z = s.intersection()\r
115 if self.thetype == frozenset():\r
116 self.assertEqual(id(s), id(z))\r
117 else:\r
118 self.assertNotEqual(id(s), id(z))\r
119\r
120 def test_isdisjoint(self):\r
121 def f(s1, s2):\r
122 'Pure python equivalent of isdisjoint()'\r
123 return not set(s1).intersection(s2)\r
124 for larg in '', 'a', 'ab', 'abc', 'ababac', 'cdc', 'cc', 'efgfe', 'ccb', 'ef':\r
125 s1 = self.thetype(larg)\r
126 for rarg in '', 'a', 'ab', 'abc', 'ababac', 'cdc', 'cc', 'efgfe', 'ccb', 'ef':\r
127 for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:\r
128 s2 = C(rarg)\r
129 actual = s1.isdisjoint(s2)\r
130 expected = f(s1, s2)\r
131 self.assertEqual(actual, expected)\r
132 self.assertTrue(actual is True or actual is False)\r
133\r
134 def test_and(self):\r
135 i = self.s.intersection(self.otherword)\r
136 self.assertEqual(self.s & set(self.otherword), i)\r
137 self.assertEqual(self.s & frozenset(self.otherword), i)\r
138 try:\r
139 self.s & self.otherword\r
140 except TypeError:\r
141 pass\r
142 else:\r
143 self.fail("s&t did not screen-out general iterables")\r
144\r
145 def test_difference(self):\r
146 i = self.s.difference(self.otherword)\r
147 for c in self.letters:\r
148 self.assertEqual(c in i, c in self.d and c not in self.otherword)\r
149 self.assertEqual(self.s, self.thetype(self.word))\r
150 self.assertEqual(type(i), self.thetype)\r
151 self.assertRaises(PassThru, self.s.difference, check_pass_thru())\r
152 self.assertRaises(TypeError, self.s.difference, [[]])\r
153 for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:\r
154 self.assertEqual(self.thetype('abcba').difference(C('cdc')), set('ab'))\r
155 self.assertEqual(self.thetype('abcba').difference(C('efgfe')), set('abc'))\r
156 self.assertEqual(self.thetype('abcba').difference(C('ccb')), set('a'))\r
157 self.assertEqual(self.thetype('abcba').difference(C('ef')), set('abc'))\r
158 self.assertEqual(self.thetype('abcba').difference(), set('abc'))\r
159 self.assertEqual(self.thetype('abcba').difference(C('a'), C('b')), set('c'))\r
160\r
161 def test_sub(self):\r
162 i = self.s.difference(self.otherword)\r
163 self.assertEqual(self.s - set(self.otherword), i)\r
164 self.assertEqual(self.s - frozenset(self.otherword), i)\r
165 try:\r
166 self.s - self.otherword\r
167 except TypeError:\r
168 pass\r
169 else:\r
170 self.fail("s-t did not screen-out general iterables")\r
171\r
172 def test_symmetric_difference(self):\r
173 i = self.s.symmetric_difference(self.otherword)\r
174 for c in self.letters:\r
175 self.assertEqual(c in i, (c in self.d) ^ (c in self.otherword))\r
176 self.assertEqual(self.s, self.thetype(self.word))\r
177 self.assertEqual(type(i), self.thetype)\r
178 self.assertRaises(PassThru, self.s.symmetric_difference, check_pass_thru())\r
179 self.assertRaises(TypeError, self.s.symmetric_difference, [[]])\r
180 for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:\r
181 self.assertEqual(self.thetype('abcba').symmetric_difference(C('cdc')), set('abd'))\r
182 self.assertEqual(self.thetype('abcba').symmetric_difference(C('efgfe')), set('abcefg'))\r
183 self.assertEqual(self.thetype('abcba').symmetric_difference(C('ccb')), set('a'))\r
184 self.assertEqual(self.thetype('abcba').symmetric_difference(C('ef')), set('abcef'))\r
185\r
186 def test_xor(self):\r
187 i = self.s.symmetric_difference(self.otherword)\r
188 self.assertEqual(self.s ^ set(self.otherword), i)\r
189 self.assertEqual(self.s ^ frozenset(self.otherword), i)\r
190 try:\r
191 self.s ^ self.otherword\r
192 except TypeError:\r
193 pass\r
194 else:\r
195 self.fail("s^t did not screen-out general iterables")\r
196\r
197 def test_equality(self):\r
198 self.assertEqual(self.s, set(self.word))\r
199 self.assertEqual(self.s, frozenset(self.word))\r
200 self.assertEqual(self.s == self.word, False)\r
201 self.assertNotEqual(self.s, set(self.otherword))\r
202 self.assertNotEqual(self.s, frozenset(self.otherword))\r
203 self.assertEqual(self.s != self.word, True)\r
204\r
205 def test_setOfFrozensets(self):\r
206 t = map(frozenset, ['abcdef', 'bcd', 'bdcb', 'fed', 'fedccba'])\r
207 s = self.thetype(t)\r
208 self.assertEqual(len(s), 3)\r
209\r
210 def test_compare(self):\r
211 self.assertRaises(TypeError, self.s.__cmp__, self.s)\r
212\r
213 def test_sub_and_super(self):\r
214 p, q, r = map(self.thetype, ['ab', 'abcde', 'def'])\r
215 self.assertTrue(p < q)\r
216 self.assertTrue(p <= q)\r
217 self.assertTrue(q <= q)\r
218 self.assertTrue(q > p)\r
219 self.assertTrue(q >= p)\r
220 self.assertFalse(q < r)\r
221 self.assertFalse(q <= r)\r
222 self.assertFalse(q > r)\r
223 self.assertFalse(q >= r)\r
224 self.assertTrue(set('a').issubset('abc'))\r
225 self.assertTrue(set('abc').issuperset('a'))\r
226 self.assertFalse(set('a').issubset('cbs'))\r
227 self.assertFalse(set('cbs').issuperset('a'))\r
228\r
229 def test_pickling(self):\r
230 for i in range(pickle.HIGHEST_PROTOCOL + 1):\r
231 p = pickle.dumps(self.s, i)\r
232 dup = pickle.loads(p)\r
233 self.assertEqual(self.s, dup, "%s != %s" % (self.s, dup))\r
234 if type(self.s) not in (set, frozenset):\r
235 self.s.x = 10\r
236 p = pickle.dumps(self.s)\r
237 dup = pickle.loads(p)\r
238 self.assertEqual(self.s.x, dup.x)\r
239\r
240 def test_deepcopy(self):\r
241 class Tracer:\r
242 def __init__(self, value):\r
243 self.value = value\r
244 def __hash__(self):\r
245 return self.value\r
246 def __deepcopy__(self, memo=None):\r
247 return Tracer(self.value + 1)\r
248 t = Tracer(10)\r
249 s = self.thetype([t])\r
250 dup = copy.deepcopy(s)\r
251 self.assertNotEqual(id(s), id(dup))\r
252 for elem in dup:\r
253 newt = elem\r
254 self.assertNotEqual(id(t), id(newt))\r
255 self.assertEqual(t.value + 1, newt.value)\r
256\r
257 def test_gc(self):\r
258 # Create a nest of cycles to exercise overall ref count check\r
259 class A:\r
260 pass\r
261 s = set(A() for i in xrange(1000))\r
262 for elem in s:\r
263 elem.cycle = s\r
264 elem.sub = elem\r
265 elem.set = set([elem])\r
266\r
267 def test_subclass_with_custom_hash(self):\r
268 # Bug #1257731\r
269 class H(self.thetype):\r
270 def __hash__(self):\r
271 return int(id(self) & 0x7fffffff)\r
272 s=H()\r
273 f=set()\r
274 f.add(s)\r
275 self.assertIn(s, f)\r
276 f.remove(s)\r
277 f.add(s)\r
278 f.discard(s)\r
279\r
280 def test_badcmp(self):\r
281 s = self.thetype([BadCmp()])\r
282 # Detect comparison errors during insertion and lookup\r
283 self.assertRaises(RuntimeError, self.thetype, [BadCmp(), BadCmp()])\r
284 self.assertRaises(RuntimeError, s.__contains__, BadCmp())\r
285 # Detect errors during mutating operations\r
286 if hasattr(s, 'add'):\r
287 self.assertRaises(RuntimeError, s.add, BadCmp())\r
288 self.assertRaises(RuntimeError, s.discard, BadCmp())\r
289 self.assertRaises(RuntimeError, s.remove, BadCmp())\r
290\r
291 def test_cyclical_repr(self):\r
292 w = ReprWrapper()\r
293 s = self.thetype([w])\r
294 w.value = s\r
295 name = repr(s).partition('(')[0] # strip class name from repr string\r
296 self.assertEqual(repr(s), '%s([%s(...)])' % (name, name))\r
297\r
298 def test_cyclical_print(self):\r
299 w = ReprWrapper()\r
300 s = self.thetype([w])\r
301 w.value = s\r
302 fo = open(test_support.TESTFN, "wb")\r
303 try:\r
304 print >> fo, s,\r
305 fo.close()\r
306 fo = open(test_support.TESTFN, "rb")\r
307 self.assertEqual(fo.read(), repr(s))\r
308 finally:\r
309 fo.close()\r
310 test_support.unlink(test_support.TESTFN)\r
311\r
312 def test_do_not_rehash_dict_keys(self):\r
313 n = 10\r
314 d = dict.fromkeys(map(HashCountingInt, xrange(n)))\r
315 self.assertEqual(sum(elem.hash_count for elem in d), n)\r
316 s = self.thetype(d)\r
317 self.assertEqual(sum(elem.hash_count for elem in d), n)\r
318 s.difference(d)\r
319 self.assertEqual(sum(elem.hash_count for elem in d), n)\r
320 if hasattr(s, 'symmetric_difference_update'):\r
321 s.symmetric_difference_update(d)\r
322 self.assertEqual(sum(elem.hash_count for elem in d), n)\r
323 d2 = dict.fromkeys(set(d))\r
324 self.assertEqual(sum(elem.hash_count for elem in d), n)\r
325 d3 = dict.fromkeys(frozenset(d))\r
326 self.assertEqual(sum(elem.hash_count for elem in d), n)\r
327 d3 = dict.fromkeys(frozenset(d), 123)\r
328 self.assertEqual(sum(elem.hash_count for elem in d), n)\r
329 self.assertEqual(d3, dict.fromkeys(d, 123))\r
330\r
331 def test_container_iterator(self):\r
332 # Bug #3680: tp_traverse was not implemented for set iterator object\r
333 class C(object):\r
334 pass\r
335 obj = C()\r
336 ref = weakref.ref(obj)\r
337 container = set([obj, 1])\r
338 obj.x = iter(container)\r
339 del obj, container\r
340 gc.collect()\r
341 self.assertTrue(ref() is None, "Cycle was not collected")\r
342\r
343class TestSet(TestJointOps):\r
344 thetype = set\r
345\r
346 def test_init(self):\r
347 s = self.thetype()\r
348 s.__init__(self.word)\r
349 self.assertEqual(s, set(self.word))\r
350 s.__init__(self.otherword)\r
351 self.assertEqual(s, set(self.otherword))\r
352 self.assertRaises(TypeError, s.__init__, s, 2);\r
353 self.assertRaises(TypeError, s.__init__, 1);\r
354\r
355 def test_constructor_identity(self):\r
356 s = self.thetype(range(3))\r
357 t = self.thetype(s)\r
358 self.assertNotEqual(id(s), id(t))\r
359\r
360 def test_hash(self):\r
361 self.assertRaises(TypeError, hash, self.s)\r
362\r
363 def test_clear(self):\r
364 self.s.clear()\r
365 self.assertEqual(self.s, set())\r
366 self.assertEqual(len(self.s), 0)\r
367\r
368 def test_copy(self):\r
369 dup = self.s.copy()\r
370 self.assertEqual(self.s, dup)\r
371 self.assertNotEqual(id(self.s), id(dup))\r
372\r
373 def test_add(self):\r
374 self.s.add('Q')\r
375 self.assertIn('Q', self.s)\r
376 dup = self.s.copy()\r
377 self.s.add('Q')\r
378 self.assertEqual(self.s, dup)\r
379 self.assertRaises(TypeError, self.s.add, [])\r
380\r
381 def test_remove(self):\r
382 self.s.remove('a')\r
383 self.assertNotIn('a', self.s)\r
384 self.assertRaises(KeyError, self.s.remove, 'Q')\r
385 self.assertRaises(TypeError, self.s.remove, [])\r
386 s = self.thetype([frozenset(self.word)])\r
387 self.assertIn(self.thetype(self.word), s)\r
388 s.remove(self.thetype(self.word))\r
389 self.assertNotIn(self.thetype(self.word), s)\r
390 self.assertRaises(KeyError, self.s.remove, self.thetype(self.word))\r
391\r
392 def test_remove_keyerror_unpacking(self):\r
393 # bug: www.python.org/sf/1576657\r
394 for v1 in ['Q', (1,)]:\r
395 try:\r
396 self.s.remove(v1)\r
397 except KeyError, e:\r
398 v2 = e.args[0]\r
399 self.assertEqual(v1, v2)\r
400 else:\r
401 self.fail()\r
402\r
403 def test_remove_keyerror_set(self):\r
404 key = self.thetype([3, 4])\r
405 try:\r
406 self.s.remove(key)\r
407 except KeyError as e:\r
408 self.assertTrue(e.args[0] is key,\r
409 "KeyError should be {0}, not {1}".format(key,\r
410 e.args[0]))\r
411 else:\r
412 self.fail()\r
413\r
414 def test_discard(self):\r
415 self.s.discard('a')\r
416 self.assertNotIn('a', self.s)\r
417 self.s.discard('Q')\r
418 self.assertRaises(TypeError, self.s.discard, [])\r
419 s = self.thetype([frozenset(self.word)])\r
420 self.assertIn(self.thetype(self.word), s)\r
421 s.discard(self.thetype(self.word))\r
422 self.assertNotIn(self.thetype(self.word), s)\r
423 s.discard(self.thetype(self.word))\r
424\r
425 def test_pop(self):\r
426 for i in xrange(len(self.s)):\r
427 elem = self.s.pop()\r
428 self.assertNotIn(elem, self.s)\r
429 self.assertRaises(KeyError, self.s.pop)\r
430\r
431 def test_update(self):\r
432 retval = self.s.update(self.otherword)\r
433 self.assertEqual(retval, None)\r
434 for c in (self.word + self.otherword):\r
435 self.assertIn(c, self.s)\r
436 self.assertRaises(PassThru, self.s.update, check_pass_thru())\r
437 self.assertRaises(TypeError, self.s.update, [[]])\r
438 for p, q in (('cdc', 'abcd'), ('efgfe', 'abcefg'), ('ccb', 'abc'), ('ef', 'abcef')):\r
439 for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:\r
440 s = self.thetype('abcba')\r
441 self.assertEqual(s.update(C(p)), None)\r
442 self.assertEqual(s, set(q))\r
443 for p in ('cdc', 'efgfe', 'ccb', 'ef', 'abcda'):\r
444 q = 'ahi'\r
445 for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:\r
446 s = self.thetype('abcba')\r
447 self.assertEqual(s.update(C(p), C(q)), None)\r
448 self.assertEqual(s, set(s) | set(p) | set(q))\r
449\r
450 def test_ior(self):\r
451 self.s |= set(self.otherword)\r
452 for c in (self.word + self.otherword):\r
453 self.assertIn(c, self.s)\r
454\r
455 def test_intersection_update(self):\r
456 retval = self.s.intersection_update(self.otherword)\r
457 self.assertEqual(retval, None)\r
458 for c in (self.word + self.otherword):\r
459 if c in self.otherword and c in self.word:\r
460 self.assertIn(c, self.s)\r
461 else:\r
462 self.assertNotIn(c, self.s)\r
463 self.assertRaises(PassThru, self.s.intersection_update, check_pass_thru())\r
464 self.assertRaises(TypeError, self.s.intersection_update, [[]])\r
465 for p, q in (('cdc', 'c'), ('efgfe', ''), ('ccb', 'bc'), ('ef', '')):\r
466 for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:\r
467 s = self.thetype('abcba')\r
468 self.assertEqual(s.intersection_update(C(p)), None)\r
469 self.assertEqual(s, set(q))\r
470 ss = 'abcba'\r
471 s = self.thetype(ss)\r
472 t = 'cbc'\r
473 self.assertEqual(s.intersection_update(C(p), C(t)), None)\r
474 self.assertEqual(s, set('abcba')&set(p)&set(t))\r
475\r
476 def test_iand(self):\r
477 self.s &= set(self.otherword)\r
478 for c in (self.word + self.otherword):\r
479 if c in self.otherword and c in self.word:\r
480 self.assertIn(c, self.s)\r
481 else:\r
482 self.assertNotIn(c, self.s)\r
483\r
484 def test_difference_update(self):\r
485 retval = self.s.difference_update(self.otherword)\r
486 self.assertEqual(retval, None)\r
487 for c in (self.word + self.otherword):\r
488 if c in self.word and c not in self.otherword:\r
489 self.assertIn(c, self.s)\r
490 else:\r
491 self.assertNotIn(c, self.s)\r
492 self.assertRaises(PassThru, self.s.difference_update, check_pass_thru())\r
493 self.assertRaises(TypeError, self.s.difference_update, [[]])\r
494 self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])\r
495 for p, q in (('cdc', 'ab'), ('efgfe', 'abc'), ('ccb', 'a'), ('ef', 'abc')):\r
496 for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:\r
497 s = self.thetype('abcba')\r
498 self.assertEqual(s.difference_update(C(p)), None)\r
499 self.assertEqual(s, set(q))\r
500\r
501 s = self.thetype('abcdefghih')\r
502 s.difference_update()\r
503 self.assertEqual(s, self.thetype('abcdefghih'))\r
504\r
505 s = self.thetype('abcdefghih')\r
506 s.difference_update(C('aba'))\r
507 self.assertEqual(s, self.thetype('cdefghih'))\r
508\r
509 s = self.thetype('abcdefghih')\r
510 s.difference_update(C('cdc'), C('aba'))\r
511 self.assertEqual(s, self.thetype('efghih'))\r
512\r
513 def test_isub(self):\r
514 self.s -= set(self.otherword)\r
515 for c in (self.word + self.otherword):\r
516 if c in self.word and c not in self.otherword:\r
517 self.assertIn(c, self.s)\r
518 else:\r
519 self.assertNotIn(c, self.s)\r
520\r
521 def test_symmetric_difference_update(self):\r
522 retval = self.s.symmetric_difference_update(self.otherword)\r
523 self.assertEqual(retval, None)\r
524 for c in (self.word + self.otherword):\r
525 if (c in self.word) ^ (c in self.otherword):\r
526 self.assertIn(c, self.s)\r
527 else:\r
528 self.assertNotIn(c, self.s)\r
529 self.assertRaises(PassThru, self.s.symmetric_difference_update, check_pass_thru())\r
530 self.assertRaises(TypeError, self.s.symmetric_difference_update, [[]])\r
531 for p, q in (('cdc', 'abd'), ('efgfe', 'abcefg'), ('ccb', 'a'), ('ef', 'abcef')):\r
532 for C in set, frozenset, dict.fromkeys, str, unicode, list, tuple:\r
533 s = self.thetype('abcba')\r
534 self.assertEqual(s.symmetric_difference_update(C(p)), None)\r
535 self.assertEqual(s, set(q))\r
536\r
537 def test_ixor(self):\r
538 self.s ^= set(self.otherword)\r
539 for c in (self.word + self.otherword):\r
540 if (c in self.word) ^ (c in self.otherword):\r
541 self.assertIn(c, self.s)\r
542 else:\r
543 self.assertNotIn(c, self.s)\r
544\r
545 def test_inplace_on_self(self):\r
546 t = self.s.copy()\r
547 t |= t\r
548 self.assertEqual(t, self.s)\r
549 t &= t\r
550 self.assertEqual(t, self.s)\r
551 t -= t\r
552 self.assertEqual(t, self.thetype())\r
553 t = self.s.copy()\r
554 t ^= t\r
555 self.assertEqual(t, self.thetype())\r
556\r
557 def test_weakref(self):\r
558 s = self.thetype('gallahad')\r
559 p = weakref.proxy(s)\r
560 self.assertEqual(str(p), str(s))\r
561 s = None\r
562 self.assertRaises(ReferenceError, str, p)\r
563\r
564 # C API test only available in a debug build\r
565 if hasattr(set, "test_c_api"):\r
566 def test_c_api(self):\r
567 self.assertEqual(set().test_c_api(), True)\r
568\r
569class SetSubclass(set):\r
570 pass\r
571\r
572class TestSetSubclass(TestSet):\r
573 thetype = SetSubclass\r
574\r
575class SetSubclassWithKeywordArgs(set):\r
576 def __init__(self, iterable=[], newarg=None):\r
577 set.__init__(self, iterable)\r
578\r
579class TestSetSubclassWithKeywordArgs(TestSet):\r
580\r
581 def test_keywords_in_subclass(self):\r
582 'SF bug #1486663 -- this used to erroneously raise a TypeError'\r
583 SetSubclassWithKeywordArgs(newarg=1)\r
584\r
585class TestFrozenSet(TestJointOps):\r
586 thetype = frozenset\r
587\r
588 def test_init(self):\r
589 s = self.thetype(self.word)\r
590 s.__init__(self.otherword)\r
591 self.assertEqual(s, set(self.word))\r
592\r
593 def test_singleton_empty_frozenset(self):\r
594 f = frozenset()\r
595 efs = [frozenset(), frozenset([]), frozenset(()), frozenset(''),\r
596 frozenset(), frozenset([]), frozenset(()), frozenset(''),\r
597 frozenset(xrange(0)), frozenset(frozenset()),\r
598 frozenset(f), f]\r
599 # All of the empty frozensets should have just one id()\r
600 self.assertEqual(len(set(map(id, efs))), 1)\r
601\r
602 def test_constructor_identity(self):\r
603 s = self.thetype(range(3))\r
604 t = self.thetype(s)\r
605 self.assertEqual(id(s), id(t))\r
606\r
607 def test_hash(self):\r
608 self.assertEqual(hash(self.thetype('abcdeb')),\r
609 hash(self.thetype('ebecda')))\r
610\r
611 # make sure that all permutations give the same hash value\r
612 n = 100\r
613 seq = [randrange(n) for i in xrange(n)]\r
614 results = set()\r
615 for i in xrange(200):\r
616 shuffle(seq)\r
617 results.add(hash(self.thetype(seq)))\r
618 self.assertEqual(len(results), 1)\r
619\r
620 def test_copy(self):\r
621 dup = self.s.copy()\r
622 self.assertEqual(id(self.s), id(dup))\r
623\r
624 def test_frozen_as_dictkey(self):\r
625 seq = range(10) + list('abcdefg') + ['apple']\r
626 key1 = self.thetype(seq)\r
627 key2 = self.thetype(reversed(seq))\r
628 self.assertEqual(key1, key2)\r
629 self.assertNotEqual(id(key1), id(key2))\r
630 d = {}\r
631 d[key1] = 42\r
632 self.assertEqual(d[key2], 42)\r
633\r
634 def test_hash_caching(self):\r
635 f = self.thetype('abcdcda')\r
636 self.assertEqual(hash(f), hash(f))\r
637\r
638 def test_hash_effectiveness(self):\r
639 n = 13\r
640 hashvalues = set()\r
641 addhashvalue = hashvalues.add\r
642 elemmasks = [(i+1, 1<<i) for i in range(n)]\r
643 for i in xrange(2**n):\r
644 addhashvalue(hash(frozenset([e for e, m in elemmasks if m&i])))\r
645 self.assertEqual(len(hashvalues), 2**n)\r
646\r
647class FrozenSetSubclass(frozenset):\r
648 pass\r
649\r
650class TestFrozenSetSubclass(TestFrozenSet):\r
651 thetype = FrozenSetSubclass\r
652\r
653 def test_constructor_identity(self):\r
654 s = self.thetype(range(3))\r
655 t = self.thetype(s)\r
656 self.assertNotEqual(id(s), id(t))\r
657\r
658 def test_copy(self):\r
659 dup = self.s.copy()\r
660 self.assertNotEqual(id(self.s), id(dup))\r
661\r
662 def test_nested_empty_constructor(self):\r
663 s = self.thetype()\r
664 t = self.thetype(s)\r
665 self.assertEqual(s, t)\r
666\r
667 def test_singleton_empty_frozenset(self):\r
668 Frozenset = self.thetype\r
669 f = frozenset()\r
670 F = Frozenset()\r
671 efs = [Frozenset(), Frozenset([]), Frozenset(()), Frozenset(''),\r
672 Frozenset(), Frozenset([]), Frozenset(()), Frozenset(''),\r
673 Frozenset(xrange(0)), Frozenset(Frozenset()),\r
674 Frozenset(frozenset()), f, F, Frozenset(f), Frozenset(F)]\r
675 # All empty frozenset subclass instances should have different ids\r
676 self.assertEqual(len(set(map(id, efs))), len(efs))\r
677\r
678# Tests taken from test_sets.py =============================================\r
679\r
680empty_set = set()\r
681\r
682#==============================================================================\r
683\r
684class TestBasicOps(unittest.TestCase):\r
685\r
686 def test_repr(self):\r
687 if self.repr is not None:\r
688 self.assertEqual(repr(self.set), self.repr)\r
689\r
690 def test_print(self):\r
691 fo = open(test_support.TESTFN, "wb")\r
692 try:\r
693 print >> fo, self.set,\r
694 fo.close()\r
695 fo = open(test_support.TESTFN, "rb")\r
696 self.assertEqual(fo.read(), repr(self.set))\r
697 finally:\r
698 fo.close()\r
699 test_support.unlink(test_support.TESTFN)\r
700\r
701 def test_length(self):\r
702 self.assertEqual(len(self.set), self.length)\r
703\r
704 def test_self_equality(self):\r
705 self.assertEqual(self.set, self.set)\r
706\r
707 def test_equivalent_equality(self):\r
708 self.assertEqual(self.set, self.dup)\r
709\r
710 def test_copy(self):\r
711 self.assertEqual(self.set.copy(), self.dup)\r
712\r
713 def test_self_union(self):\r
714 result = self.set | self.set\r
715 self.assertEqual(result, self.dup)\r
716\r
717 def test_empty_union(self):\r
718 result = self.set | empty_set\r
719 self.assertEqual(result, self.dup)\r
720\r
721 def test_union_empty(self):\r
722 result = empty_set | self.set\r
723 self.assertEqual(result, self.dup)\r
724\r
725 def test_self_intersection(self):\r
726 result = self.set & self.set\r
727 self.assertEqual(result, self.dup)\r
728\r
729 def test_empty_intersection(self):\r
730 result = self.set & empty_set\r
731 self.assertEqual(result, empty_set)\r
732\r
733 def test_intersection_empty(self):\r
734 result = empty_set & self.set\r
735 self.assertEqual(result, empty_set)\r
736\r
737 def test_self_isdisjoint(self):\r
738 result = self.set.isdisjoint(self.set)\r
739 self.assertEqual(result, not self.set)\r
740\r
741 def test_empty_isdisjoint(self):\r
742 result = self.set.isdisjoint(empty_set)\r
743 self.assertEqual(result, True)\r
744\r
745 def test_isdisjoint_empty(self):\r
746 result = empty_set.isdisjoint(self.set)\r
747 self.assertEqual(result, True)\r
748\r
749 def test_self_symmetric_difference(self):\r
750 result = self.set ^ self.set\r
751 self.assertEqual(result, empty_set)\r
752\r
753 def test_empty_symmetric_difference(self):\r
754 result = self.set ^ empty_set\r
755 self.assertEqual(result, self.set)\r
756\r
757 def test_self_difference(self):\r
758 result = self.set - self.set\r
759 self.assertEqual(result, empty_set)\r
760\r
761 def test_empty_difference(self):\r
762 result = self.set - empty_set\r
763 self.assertEqual(result, self.dup)\r
764\r
765 def test_empty_difference_rev(self):\r
766 result = empty_set - self.set\r
767 self.assertEqual(result, empty_set)\r
768\r
769 def test_iteration(self):\r
770 for v in self.set:\r
771 self.assertIn(v, self.values)\r
772 setiter = iter(self.set)\r
773 # note: __length_hint__ is an internal undocumented API,\r
774 # don't rely on it in your own programs\r
775 self.assertEqual(setiter.__length_hint__(), len(self.set))\r
776\r
777 def test_pickling(self):\r
778 p = pickle.dumps(self.set)\r
779 copy = pickle.loads(p)\r
780 self.assertEqual(self.set, copy,\r
781 "%s != %s" % (self.set, copy))\r
782\r
783#------------------------------------------------------------------------------\r
784\r
785class TestBasicOpsEmpty(TestBasicOps):\r
786 def setUp(self):\r
787 self.case = "empty set"\r
788 self.values = []\r
789 self.set = set(self.values)\r
790 self.dup = set(self.values)\r
791 self.length = 0\r
792 self.repr = "set([])"\r
793\r
794#------------------------------------------------------------------------------\r
795\r
796class TestBasicOpsSingleton(TestBasicOps):\r
797 def setUp(self):\r
798 self.case = "unit set (number)"\r
799 self.values = [3]\r
800 self.set = set(self.values)\r
801 self.dup = set(self.values)\r
802 self.length = 1\r
803 self.repr = "set([3])"\r
804\r
805 def test_in(self):\r
806 self.assertIn(3, self.set)\r
807\r
808 def test_not_in(self):\r
809 self.assertNotIn(2, self.set)\r
810\r
811#------------------------------------------------------------------------------\r
812\r
813class TestBasicOpsTuple(TestBasicOps):\r
814 def setUp(self):\r
815 self.case = "unit set (tuple)"\r
816 self.values = [(0, "zero")]\r
817 self.set = set(self.values)\r
818 self.dup = set(self.values)\r
819 self.length = 1\r
820 self.repr = "set([(0, 'zero')])"\r
821\r
822 def test_in(self):\r
823 self.assertIn((0, "zero"), self.set)\r
824\r
825 def test_not_in(self):\r
826 self.assertNotIn(9, self.set)\r
827\r
828#------------------------------------------------------------------------------\r
829\r
830class TestBasicOpsTriple(TestBasicOps):\r
831 def setUp(self):\r
832 self.case = "triple set"\r
833 self.values = [0, "zero", operator.add]\r
834 self.set = set(self.values)\r
835 self.dup = set(self.values)\r
836 self.length = 3\r
837 self.repr = None\r
838\r
839#==============================================================================\r
840\r
841def baditer():\r
842 raise TypeError\r
843 yield True\r
844\r
845def gooditer():\r
846 yield True\r
847\r
848class TestExceptionPropagation(unittest.TestCase):\r
849 """SF 628246: Set constructor should not trap iterator TypeErrors"""\r
850\r
851 def test_instanceWithException(self):\r
852 self.assertRaises(TypeError, set, baditer())\r
853\r
854 def test_instancesWithoutException(self):\r
855 # All of these iterables should load without exception.\r
856 set([1,2,3])\r
857 set((1,2,3))\r
858 set({'one':1, 'two':2, 'three':3})\r
859 set(xrange(3))\r
860 set('abc')\r
861 set(gooditer())\r
862\r
863 def test_changingSizeWhileIterating(self):\r
864 s = set([1,2,3])\r
865 try:\r
866 for i in s:\r
867 s.update([4])\r
868 except RuntimeError:\r
869 pass\r
870 else:\r
871 self.fail("no exception when changing size during iteration")\r
872\r
873#==============================================================================\r
874\r
875class TestSetOfSets(unittest.TestCase):\r
876 def test_constructor(self):\r
877 inner = frozenset([1])\r
878 outer = set([inner])\r
879 element = outer.pop()\r
880 self.assertEqual(type(element), frozenset)\r
881 outer.add(inner) # Rebuild set of sets with .add method\r
882 outer.remove(inner)\r
883 self.assertEqual(outer, set()) # Verify that remove worked\r
884 outer.discard(inner) # Absence of KeyError indicates working fine\r
885\r
886#==============================================================================\r
887\r
888class TestBinaryOps(unittest.TestCase):\r
889 def setUp(self):\r
890 self.set = set((2, 4, 6))\r
891\r
892 def test_eq(self): # SF bug 643115\r
893 self.assertEqual(self.set, set({2:1,4:3,6:5}))\r
894\r
895 def test_union_subset(self):\r
896 result = self.set | set([2])\r
897 self.assertEqual(result, set((2, 4, 6)))\r
898\r
899 def test_union_superset(self):\r
900 result = self.set | set([2, 4, 6, 8])\r
901 self.assertEqual(result, set([2, 4, 6, 8]))\r
902\r
903 def test_union_overlap(self):\r
904 result = self.set | set([3, 4, 5])\r
905 self.assertEqual(result, set([2, 3, 4, 5, 6]))\r
906\r
907 def test_union_non_overlap(self):\r
908 result = self.set | set([8])\r
909 self.assertEqual(result, set([2, 4, 6, 8]))\r
910\r
911 def test_intersection_subset(self):\r
912 result = self.set & set((2, 4))\r
913 self.assertEqual(result, set((2, 4)))\r
914\r
915 def test_intersection_superset(self):\r
916 result = self.set & set([2, 4, 6, 8])\r
917 self.assertEqual(result, set([2, 4, 6]))\r
918\r
919 def test_intersection_overlap(self):\r
920 result = self.set & set([3, 4, 5])\r
921 self.assertEqual(result, set([4]))\r
922\r
923 def test_intersection_non_overlap(self):\r
924 result = self.set & set([8])\r
925 self.assertEqual(result, empty_set)\r
926\r
927 def test_isdisjoint_subset(self):\r
928 result = self.set.isdisjoint(set((2, 4)))\r
929 self.assertEqual(result, False)\r
930\r
931 def test_isdisjoint_superset(self):\r
932 result = self.set.isdisjoint(set([2, 4, 6, 8]))\r
933 self.assertEqual(result, False)\r
934\r
935 def test_isdisjoint_overlap(self):\r
936 result = self.set.isdisjoint(set([3, 4, 5]))\r
937 self.assertEqual(result, False)\r
938\r
939 def test_isdisjoint_non_overlap(self):\r
940 result = self.set.isdisjoint(set([8]))\r
941 self.assertEqual(result, True)\r
942\r
943 def test_sym_difference_subset(self):\r
944 result = self.set ^ set((2, 4))\r
945 self.assertEqual(result, set([6]))\r
946\r
947 def test_sym_difference_superset(self):\r
948 result = self.set ^ set((2, 4, 6, 8))\r
949 self.assertEqual(result, set([8]))\r
950\r
951 def test_sym_difference_overlap(self):\r
952 result = self.set ^ set((3, 4, 5))\r
953 self.assertEqual(result, set([2, 3, 5, 6]))\r
954\r
955 def test_sym_difference_non_overlap(self):\r
956 result = self.set ^ set([8])\r
957 self.assertEqual(result, set([2, 4, 6, 8]))\r
958\r
959 def test_cmp(self):\r
960 a, b = set('a'), set('b')\r
961 self.assertRaises(TypeError, cmp, a, b)\r
962\r
963 # You can view this as a buglet: cmp(a, a) does not raise TypeError,\r
964 # because __eq__ is tried before __cmp__, and a.__eq__(a) returns True,\r
965 # which Python thinks is good enough to synthesize a cmp() result\r
966 # without calling __cmp__.\r
967 self.assertEqual(cmp(a, a), 0)\r
968\r
969 self.assertRaises(TypeError, cmp, a, 12)\r
970 self.assertRaises(TypeError, cmp, "abc", a)\r
971\r
972#==============================================================================\r
973\r
974class TestUpdateOps(unittest.TestCase):\r
975 def setUp(self):\r
976 self.set = set((2, 4, 6))\r
977\r
978 def test_union_subset(self):\r
979 self.set |= set([2])\r
980 self.assertEqual(self.set, set((2, 4, 6)))\r
981\r
982 def test_union_superset(self):\r
983 self.set |= set([2, 4, 6, 8])\r
984 self.assertEqual(self.set, set([2, 4, 6, 8]))\r
985\r
986 def test_union_overlap(self):\r
987 self.set |= set([3, 4, 5])\r
988 self.assertEqual(self.set, set([2, 3, 4, 5, 6]))\r
989\r
990 def test_union_non_overlap(self):\r
991 self.set |= set([8])\r
992 self.assertEqual(self.set, set([2, 4, 6, 8]))\r
993\r
994 def test_union_method_call(self):\r
995 self.set.update(set([3, 4, 5]))\r
996 self.assertEqual(self.set, set([2, 3, 4, 5, 6]))\r
997\r
998 def test_intersection_subset(self):\r
999 self.set &= set((2, 4))\r
1000 self.assertEqual(self.set, set((2, 4)))\r
1001\r
1002 def test_intersection_superset(self):\r
1003 self.set &= set([2, 4, 6, 8])\r
1004 self.assertEqual(self.set, set([2, 4, 6]))\r
1005\r
1006 def test_intersection_overlap(self):\r
1007 self.set &= set([3, 4, 5])\r
1008 self.assertEqual(self.set, set([4]))\r
1009\r
1010 def test_intersection_non_overlap(self):\r
1011 self.set &= set([8])\r
1012 self.assertEqual(self.set, empty_set)\r
1013\r
1014 def test_intersection_method_call(self):\r
1015 self.set.intersection_update(set([3, 4, 5]))\r
1016 self.assertEqual(self.set, set([4]))\r
1017\r
1018 def test_sym_difference_subset(self):\r
1019 self.set ^= set((2, 4))\r
1020 self.assertEqual(self.set, set([6]))\r
1021\r
1022 def test_sym_difference_superset(self):\r
1023 self.set ^= set((2, 4, 6, 8))\r
1024 self.assertEqual(self.set, set([8]))\r
1025\r
1026 def test_sym_difference_overlap(self):\r
1027 self.set ^= set((3, 4, 5))\r
1028 self.assertEqual(self.set, set([2, 3, 5, 6]))\r
1029\r
1030 def test_sym_difference_non_overlap(self):\r
1031 self.set ^= set([8])\r
1032 self.assertEqual(self.set, set([2, 4, 6, 8]))\r
1033\r
1034 def test_sym_difference_method_call(self):\r
1035 self.set.symmetric_difference_update(set([3, 4, 5]))\r
1036 self.assertEqual(self.set, set([2, 3, 5, 6]))\r
1037\r
1038 def test_difference_subset(self):\r
1039 self.set -= set((2, 4))\r
1040 self.assertEqual(self.set, set([6]))\r
1041\r
1042 def test_difference_superset(self):\r
1043 self.set -= set((2, 4, 6, 8))\r
1044 self.assertEqual(self.set, set([]))\r
1045\r
1046 def test_difference_overlap(self):\r
1047 self.set -= set((3, 4, 5))\r
1048 self.assertEqual(self.set, set([2, 6]))\r
1049\r
1050 def test_difference_non_overlap(self):\r
1051 self.set -= set([8])\r
1052 self.assertEqual(self.set, set([2, 4, 6]))\r
1053\r
1054 def test_difference_method_call(self):\r
1055 self.set.difference_update(set([3, 4, 5]))\r
1056 self.assertEqual(self.set, set([2, 6]))\r
1057\r
1058#==============================================================================\r
1059\r
1060class TestMutate(unittest.TestCase):\r
1061 def setUp(self):\r
1062 self.values = ["a", "b", "c"]\r
1063 self.set = set(self.values)\r
1064\r
1065 def test_add_present(self):\r
1066 self.set.add("c")\r
1067 self.assertEqual(self.set, set("abc"))\r
1068\r
1069 def test_add_absent(self):\r
1070 self.set.add("d")\r
1071 self.assertEqual(self.set, set("abcd"))\r
1072\r
1073 def test_add_until_full(self):\r
1074 tmp = set()\r
1075 expected_len = 0\r
1076 for v in self.values:\r
1077 tmp.add(v)\r
1078 expected_len += 1\r
1079 self.assertEqual(len(tmp), expected_len)\r
1080 self.assertEqual(tmp, self.set)\r
1081\r
1082 def test_remove_present(self):\r
1083 self.set.remove("b")\r
1084 self.assertEqual(self.set, set("ac"))\r
1085\r
1086 def test_remove_absent(self):\r
1087 try:\r
1088 self.set.remove("d")\r
1089 self.fail("Removing missing element should have raised LookupError")\r
1090 except LookupError:\r
1091 pass\r
1092\r
1093 def test_remove_until_empty(self):\r
1094 expected_len = len(self.set)\r
1095 for v in self.values:\r
1096 self.set.remove(v)\r
1097 expected_len -= 1\r
1098 self.assertEqual(len(self.set), expected_len)\r
1099\r
1100 def test_discard_present(self):\r
1101 self.set.discard("c")\r
1102 self.assertEqual(self.set, set("ab"))\r
1103\r
1104 def test_discard_absent(self):\r
1105 self.set.discard("d")\r
1106 self.assertEqual(self.set, set("abc"))\r
1107\r
1108 def test_clear(self):\r
1109 self.set.clear()\r
1110 self.assertEqual(len(self.set), 0)\r
1111\r
1112 def test_pop(self):\r
1113 popped = {}\r
1114 while self.set:\r
1115 popped[self.set.pop()] = None\r
1116 self.assertEqual(len(popped), len(self.values))\r
1117 for v in self.values:\r
1118 self.assertIn(v, popped)\r
1119\r
1120 def test_update_empty_tuple(self):\r
1121 self.set.update(())\r
1122 self.assertEqual(self.set, set(self.values))\r
1123\r
1124 def test_update_unit_tuple_overlap(self):\r
1125 self.set.update(("a",))\r
1126 self.assertEqual(self.set, set(self.values))\r
1127\r
1128 def test_update_unit_tuple_non_overlap(self):\r
1129 self.set.update(("a", "z"))\r
1130 self.assertEqual(self.set, set(self.values + ["z"]))\r
1131\r
1132#==============================================================================\r
1133\r
1134class TestSubsets(unittest.TestCase):\r
1135\r
1136 case2method = {"<=": "issubset",\r
1137 ">=": "issuperset",\r
1138 }\r
1139\r
1140 reverse = {"==": "==",\r
1141 "!=": "!=",\r
1142 "<": ">",\r
1143 ">": "<",\r
1144 "<=": ">=",\r
1145 ">=": "<=",\r
1146 }\r
1147\r
1148 def test_issubset(self):\r
1149 x = self.left\r
1150 y = self.right\r
1151 for case in "!=", "==", "<", "<=", ">", ">=":\r
1152 expected = case in self.cases\r
1153 # Test the binary infix spelling.\r
1154 result = eval("x" + case + "y", locals())\r
1155 self.assertEqual(result, expected)\r
1156 # Test the "friendly" method-name spelling, if one exists.\r
1157 if case in TestSubsets.case2method:\r
1158 method = getattr(x, TestSubsets.case2method[case])\r
1159 result = method(y)\r
1160 self.assertEqual(result, expected)\r
1161\r
1162 # Now do the same for the operands reversed.\r
1163 rcase = TestSubsets.reverse[case]\r
1164 result = eval("y" + rcase + "x", locals())\r
1165 self.assertEqual(result, expected)\r
1166 if rcase in TestSubsets.case2method:\r
1167 method = getattr(y, TestSubsets.case2method[rcase])\r
1168 result = method(x)\r
1169 self.assertEqual(result, expected)\r
1170#------------------------------------------------------------------------------\r
1171\r
1172class TestSubsetEqualEmpty(TestSubsets):\r
1173 left = set()\r
1174 right = set()\r
1175 name = "both empty"\r
1176 cases = "==", "<=", ">="\r
1177\r
1178#------------------------------------------------------------------------------\r
1179\r
1180class TestSubsetEqualNonEmpty(TestSubsets):\r
1181 left = set([1, 2])\r
1182 right = set([1, 2])\r
1183 name = "equal pair"\r
1184 cases = "==", "<=", ">="\r
1185\r
1186#------------------------------------------------------------------------------\r
1187\r
1188class TestSubsetEmptyNonEmpty(TestSubsets):\r
1189 left = set()\r
1190 right = set([1, 2])\r
1191 name = "one empty, one non-empty"\r
1192 cases = "!=", "<", "<="\r
1193\r
1194#------------------------------------------------------------------------------\r
1195\r
1196class TestSubsetPartial(TestSubsets):\r
1197 left = set([1])\r
1198 right = set([1, 2])\r
1199 name = "one a non-empty proper subset of other"\r
1200 cases = "!=", "<", "<="\r
1201\r
1202#------------------------------------------------------------------------------\r
1203\r
1204class TestSubsetNonOverlap(TestSubsets):\r
1205 left = set([1])\r
1206 right = set([2])\r
1207 name = "neither empty, neither contains"\r
1208 cases = "!="\r
1209\r
1210#==============================================================================\r
1211\r
1212class TestOnlySetsInBinaryOps(unittest.TestCase):\r
1213\r
1214 def test_eq_ne(self):\r
1215 # Unlike the others, this is testing that == and != *are* allowed.\r
1216 self.assertEqual(self.other == self.set, False)\r
1217 self.assertEqual(self.set == self.other, False)\r
1218 self.assertEqual(self.other != self.set, True)\r
1219 self.assertEqual(self.set != self.other, True)\r
1220\r
1221 def test_ge_gt_le_lt(self):\r
1222 self.assertRaises(TypeError, lambda: self.set < self.other)\r
1223 self.assertRaises(TypeError, lambda: self.set <= self.other)\r
1224 self.assertRaises(TypeError, lambda: self.set > self.other)\r
1225 self.assertRaises(TypeError, lambda: self.set >= self.other)\r
1226\r
1227 self.assertRaises(TypeError, lambda: self.other < self.set)\r
1228 self.assertRaises(TypeError, lambda: self.other <= self.set)\r
1229 self.assertRaises(TypeError, lambda: self.other > self.set)\r
1230 self.assertRaises(TypeError, lambda: self.other >= self.set)\r
1231\r
1232 def test_update_operator(self):\r
1233 try:\r
1234 self.set |= self.other\r
1235 except TypeError:\r
1236 pass\r
1237 else:\r
1238 self.fail("expected TypeError")\r
1239\r
1240 def test_update(self):\r
1241 if self.otherIsIterable:\r
1242 self.set.update(self.other)\r
1243 else:\r
1244 self.assertRaises(TypeError, self.set.update, self.other)\r
1245\r
1246 def test_union(self):\r
1247 self.assertRaises(TypeError, lambda: self.set | self.other)\r
1248 self.assertRaises(TypeError, lambda: self.other | self.set)\r
1249 if self.otherIsIterable:\r
1250 self.set.union(self.other)\r
1251 else:\r
1252 self.assertRaises(TypeError, self.set.union, self.other)\r
1253\r
1254 def test_intersection_update_operator(self):\r
1255 try:\r
1256 self.set &= self.other\r
1257 except TypeError:\r
1258 pass\r
1259 else:\r
1260 self.fail("expected TypeError")\r
1261\r
1262 def test_intersection_update(self):\r
1263 if self.otherIsIterable:\r
1264 self.set.intersection_update(self.other)\r
1265 else:\r
1266 self.assertRaises(TypeError,\r
1267 self.set.intersection_update,\r
1268 self.other)\r
1269\r
1270 def test_intersection(self):\r
1271 self.assertRaises(TypeError, lambda: self.set & self.other)\r
1272 self.assertRaises(TypeError, lambda: self.other & self.set)\r
1273 if self.otherIsIterable:\r
1274 self.set.intersection(self.other)\r
1275 else:\r
1276 self.assertRaises(TypeError, self.set.intersection, self.other)\r
1277\r
1278 def test_sym_difference_update_operator(self):\r
1279 try:\r
1280 self.set ^= self.other\r
1281 except TypeError:\r
1282 pass\r
1283 else:\r
1284 self.fail("expected TypeError")\r
1285\r
1286 def test_sym_difference_update(self):\r
1287 if self.otherIsIterable:\r
1288 self.set.symmetric_difference_update(self.other)\r
1289 else:\r
1290 self.assertRaises(TypeError,\r
1291 self.set.symmetric_difference_update,\r
1292 self.other)\r
1293\r
1294 def test_sym_difference(self):\r
1295 self.assertRaises(TypeError, lambda: self.set ^ self.other)\r
1296 self.assertRaises(TypeError, lambda: self.other ^ self.set)\r
1297 if self.otherIsIterable:\r
1298 self.set.symmetric_difference(self.other)\r
1299 else:\r
1300 self.assertRaises(TypeError, self.set.symmetric_difference, self.other)\r
1301\r
1302 def test_difference_update_operator(self):\r
1303 try:\r
1304 self.set -= self.other\r
1305 except TypeError:\r
1306 pass\r
1307 else:\r
1308 self.fail("expected TypeError")\r
1309\r
1310 def test_difference_update(self):\r
1311 if self.otherIsIterable:\r
1312 self.set.difference_update(self.other)\r
1313 else:\r
1314 self.assertRaises(TypeError,\r
1315 self.set.difference_update,\r
1316 self.other)\r
1317\r
1318 def test_difference(self):\r
1319 self.assertRaises(TypeError, lambda: self.set - self.other)\r
1320 self.assertRaises(TypeError, lambda: self.other - self.set)\r
1321 if self.otherIsIterable:\r
1322 self.set.difference(self.other)\r
1323 else:\r
1324 self.assertRaises(TypeError, self.set.difference, self.other)\r
1325\r
1326#------------------------------------------------------------------------------\r
1327\r
1328class TestOnlySetsNumeric(TestOnlySetsInBinaryOps):\r
1329 def setUp(self):\r
1330 self.set = set((1, 2, 3))\r
1331 self.other = 19\r
1332 self.otherIsIterable = False\r
1333\r
1334#------------------------------------------------------------------------------\r
1335\r
1336class TestOnlySetsDict(TestOnlySetsInBinaryOps):\r
1337 def setUp(self):\r
1338 self.set = set((1, 2, 3))\r
1339 self.other = {1:2, 3:4}\r
1340 self.otherIsIterable = True\r
1341\r
1342#------------------------------------------------------------------------------\r
1343\r
1344class TestOnlySetsOperator(TestOnlySetsInBinaryOps):\r
1345 def setUp(self):\r
1346 self.set = set((1, 2, 3))\r
1347 self.other = operator.add\r
1348 self.otherIsIterable = False\r
1349\r
1350 def test_ge_gt_le_lt(self):\r
1351 with test_support.check_py3k_warnings():\r
1352 super(TestOnlySetsOperator, self).test_ge_gt_le_lt()\r
1353\r
1354#------------------------------------------------------------------------------\r
1355\r
1356class TestOnlySetsTuple(TestOnlySetsInBinaryOps):\r
1357 def setUp(self):\r
1358 self.set = set((1, 2, 3))\r
1359 self.other = (2, 4, 6)\r
1360 self.otherIsIterable = True\r
1361\r
1362#------------------------------------------------------------------------------\r
1363\r
1364class TestOnlySetsString(TestOnlySetsInBinaryOps):\r
1365 def setUp(self):\r
1366 self.set = set((1, 2, 3))\r
1367 self.other = 'abc'\r
1368 self.otherIsIterable = True\r
1369\r
1370#------------------------------------------------------------------------------\r
1371\r
1372class TestOnlySetsGenerator(TestOnlySetsInBinaryOps):\r
1373 def setUp(self):\r
1374 def gen():\r
1375 for i in xrange(0, 10, 2):\r
1376 yield i\r
1377 self.set = set((1, 2, 3))\r
1378 self.other = gen()\r
1379 self.otherIsIterable = True\r
1380\r
1381#==============================================================================\r
1382\r
1383class TestCopying(unittest.TestCase):\r
1384\r
1385 def test_copy(self):\r
1386 dup = list(self.set.copy())\r
1387 self.assertEqual(len(dup), len(self.set))\r
1388 for el in self.set:\r
1389 self.assertIn(el, dup)\r
1390 pos = dup.index(el)\r
1391 self.assertIs(el, dup.pop(pos))\r
1392 self.assertFalse(dup)\r
1393\r
1394 def test_deep_copy(self):\r
1395 dup = copy.deepcopy(self.set)\r
1396 self.assertSetEqual(dup, self.set)\r
1397\r
1398#------------------------------------------------------------------------------\r
1399\r
1400class TestCopyingEmpty(TestCopying):\r
1401 def setUp(self):\r
1402 self.set = set()\r
1403\r
1404#------------------------------------------------------------------------------\r
1405\r
1406class TestCopyingSingleton(TestCopying):\r
1407 def setUp(self):\r
1408 self.set = set(["hello"])\r
1409\r
1410#------------------------------------------------------------------------------\r
1411\r
1412class TestCopyingTriple(TestCopying):\r
1413 def setUp(self):\r
1414 self.set = set(["zero", 0, None])\r
1415\r
1416#------------------------------------------------------------------------------\r
1417\r
1418class TestCopyingTuple(TestCopying):\r
1419 def setUp(self):\r
1420 self.set = set([(1, 2)])\r
1421\r
1422#------------------------------------------------------------------------------\r
1423\r
1424class TestCopyingNested(TestCopying):\r
1425 def setUp(self):\r
1426 self.set = set([((1, 2), (3, 4))])\r
1427\r
1428#==============================================================================\r
1429\r
1430class TestIdentities(unittest.TestCase):\r
1431 def setUp(self):\r
1432 self.a = set('abracadabra')\r
1433 self.b = set('alacazam')\r
1434\r
1435 def test_binopsVsSubsets(self):\r
1436 a, b = self.a, self.b\r
1437 self.assertTrue(a - b < a)\r
1438 self.assertTrue(b - a < b)\r
1439 self.assertTrue(a & b < a)\r
1440 self.assertTrue(a & b < b)\r
1441 self.assertTrue(a | b > a)\r
1442 self.assertTrue(a | b > b)\r
1443 self.assertTrue(a ^ b < a | b)\r
1444\r
1445 def test_commutativity(self):\r
1446 a, b = self.a, self.b\r
1447 self.assertEqual(a&b, b&a)\r
1448 self.assertEqual(a|b, b|a)\r
1449 self.assertEqual(a^b, b^a)\r
1450 if a != b:\r
1451 self.assertNotEqual(a-b, b-a)\r
1452\r
1453 def test_summations(self):\r
1454 # check that sums of parts equal the whole\r
1455 a, b = self.a, self.b\r
1456 self.assertEqual((a-b)|(a&b)|(b-a), a|b)\r
1457 self.assertEqual((a&b)|(a^b), a|b)\r
1458 self.assertEqual(a|(b-a), a|b)\r
1459 self.assertEqual((a-b)|b, a|b)\r
1460 self.assertEqual((a-b)|(a&b), a)\r
1461 self.assertEqual((b-a)|(a&b), b)\r
1462 self.assertEqual((a-b)|(b-a), a^b)\r
1463\r
1464 def test_exclusion(self):\r
1465 # check that inverse operations show non-overlap\r
1466 a, b, zero = self.a, self.b, set()\r
1467 self.assertEqual((a-b)&b, zero)\r
1468 self.assertEqual((b-a)&a, zero)\r
1469 self.assertEqual((a&b)&(a^b), zero)\r
1470\r
1471# Tests derived from test_itertools.py =======================================\r
1472\r
1473def R(seqn):\r
1474 'Regular generator'\r
1475 for i in seqn:\r
1476 yield i\r
1477\r
1478class G:\r
1479 'Sequence using __getitem__'\r
1480 def __init__(self, seqn):\r
1481 self.seqn = seqn\r
1482 def __getitem__(self, i):\r
1483 return self.seqn[i]\r
1484\r
1485class I:\r
1486 'Sequence using iterator protocol'\r
1487 def __init__(self, seqn):\r
1488 self.seqn = seqn\r
1489 self.i = 0\r
1490 def __iter__(self):\r
1491 return self\r
1492 def next(self):\r
1493 if self.i >= len(self.seqn): raise StopIteration\r
1494 v = self.seqn[self.i]\r
1495 self.i += 1\r
1496 return v\r
1497\r
1498class Ig:\r
1499 'Sequence using iterator protocol defined with a generator'\r
1500 def __init__(self, seqn):\r
1501 self.seqn = seqn\r
1502 self.i = 0\r
1503 def __iter__(self):\r
1504 for val in self.seqn:\r
1505 yield val\r
1506\r
1507class X:\r
1508 'Missing __getitem__ and __iter__'\r
1509 def __init__(self, seqn):\r
1510 self.seqn = seqn\r
1511 self.i = 0\r
1512 def next(self):\r
1513 if self.i >= len(self.seqn): raise StopIteration\r
1514 v = self.seqn[self.i]\r
1515 self.i += 1\r
1516 return v\r
1517\r
1518class N:\r
1519 'Iterator missing next()'\r
1520 def __init__(self, seqn):\r
1521 self.seqn = seqn\r
1522 self.i = 0\r
1523 def __iter__(self):\r
1524 return self\r
1525\r
1526class E:\r
1527 'Test propagation of exceptions'\r
1528 def __init__(self, seqn):\r
1529 self.seqn = seqn\r
1530 self.i = 0\r
1531 def __iter__(self):\r
1532 return self\r
1533 def next(self):\r
1534 3 // 0\r
1535\r
1536class S:\r
1537 'Test immediate stop'\r
1538 def __init__(self, seqn):\r
1539 pass\r
1540 def __iter__(self):\r
1541 return self\r
1542 def next(self):\r
1543 raise StopIteration\r
1544\r
1545from itertools import chain, imap\r
1546def L(seqn):\r
1547 'Test multiple tiers of iterators'\r
1548 return chain(imap(lambda x:x, R(Ig(G(seqn)))))\r
1549\r
1550class TestVariousIteratorArgs(unittest.TestCase):\r
1551\r
1552 def test_constructor(self):\r
1553 for cons in (set, frozenset):\r
1554 for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):\r
1555 for g in (G, I, Ig, S, L, R):\r
1556 self.assertSetEqual(cons(g(s)), set(g(s)))\r
1557 self.assertRaises(TypeError, cons , X(s))\r
1558 self.assertRaises(TypeError, cons , N(s))\r
1559 self.assertRaises(ZeroDivisionError, cons , E(s))\r
1560\r
1561 def test_inline_methods(self):\r
1562 s = set('november')\r
1563 for data in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5), 'december'):\r
1564 for meth in (s.union, s.intersection, s.difference, s.symmetric_difference, s.isdisjoint):\r
1565 for g in (G, I, Ig, L, R):\r
1566 expected = meth(data)\r
1567 actual = meth(G(data))\r
1568 if isinstance(expected, bool):\r
1569 self.assertEqual(actual, expected)\r
1570 else:\r
1571 self.assertSetEqual(actual, expected)\r
1572 self.assertRaises(TypeError, meth, X(s))\r
1573 self.assertRaises(TypeError, meth, N(s))\r
1574 self.assertRaises(ZeroDivisionError, meth, E(s))\r
1575\r
1576 def test_inplace_methods(self):\r
1577 for data in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5), 'december'):\r
1578 for methname in ('update', 'intersection_update',\r
1579 'difference_update', 'symmetric_difference_update'):\r
1580 for g in (G, I, Ig, S, L, R):\r
1581 s = set('january')\r
1582 t = s.copy()\r
1583 getattr(s, methname)(list(g(data)))\r
1584 getattr(t, methname)(g(data))\r
1585 self.assertSetEqual(s, t)\r
1586\r
1587 self.assertRaises(TypeError, getattr(set('january'), methname), X(data))\r
1588 self.assertRaises(TypeError, getattr(set('january'), methname), N(data))\r
1589 self.assertRaises(ZeroDivisionError, getattr(set('january'), methname), E(data))\r
1590\r
1591class bad_eq:\r
1592 def __eq__(self, other):\r
1593 if be_bad:\r
1594 set2.clear()\r
1595 raise ZeroDivisionError\r
1596 return self is other\r
1597 def __hash__(self):\r
1598 return 0\r
1599\r
1600class bad_dict_clear:\r
1601 def __eq__(self, other):\r
1602 if be_bad:\r
1603 dict2.clear()\r
1604 return self is other\r
1605 def __hash__(self):\r
1606 return 0\r
1607\r
1608class TestWeirdBugs(unittest.TestCase):\r
1609 def test_8420_set_merge(self):\r
1610 # This used to segfault\r
1611 global be_bad, set2, dict2\r
1612 be_bad = False\r
1613 set1 = {bad_eq()}\r
1614 set2 = {bad_eq() for i in range(75)}\r
1615 be_bad = True\r
1616 self.assertRaises(ZeroDivisionError, set1.update, set2)\r
1617\r
1618 be_bad = False\r
1619 set1 = {bad_dict_clear()}\r
1620 dict2 = {bad_dict_clear(): None}\r
1621 be_bad = True\r
1622 set1.symmetric_difference_update(dict2)\r
1623\r
1624# Application tests (based on David Eppstein's graph recipes ====================================\r
1625\r
1626def powerset(U):\r
1627 """Generates all subsets of a set or sequence U."""\r
1628 U = iter(U)\r
1629 try:\r
1630 x = frozenset([U.next()])\r
1631 for S in powerset(U):\r
1632 yield S\r
1633 yield S | x\r
1634 except StopIteration:\r
1635 yield frozenset()\r
1636\r
1637def cube(n):\r
1638 """Graph of n-dimensional hypercube."""\r
1639 singletons = [frozenset([x]) for x in range(n)]\r
1640 return dict([(x, frozenset([x^s for s in singletons]))\r
1641 for x in powerset(range(n))])\r
1642\r
1643def linegraph(G):\r
1644 """Graph, the vertices of which are edges of G,\r
1645 with two vertices being adjacent iff the corresponding\r
1646 edges share a vertex."""\r
1647 L = {}\r
1648 for x in G:\r
1649 for y in G[x]:\r
1650 nx = [frozenset([x,z]) for z in G[x] if z != y]\r
1651 ny = [frozenset([y,z]) for z in G[y] if z != x]\r
1652 L[frozenset([x,y])] = frozenset(nx+ny)\r
1653 return L\r
1654\r
1655def faces(G):\r
1656 'Return a set of faces in G. Where a face is a set of vertices on that face'\r
1657 # currently limited to triangles,squares, and pentagons\r
1658 f = set()\r
1659 for v1, edges in G.items():\r
1660 for v2 in edges:\r
1661 for v3 in G[v2]:\r
1662 if v1 == v3:\r
1663 continue\r
1664 if v1 in G[v3]:\r
1665 f.add(frozenset([v1, v2, v3]))\r
1666 else:\r
1667 for v4 in G[v3]:\r
1668 if v4 == v2:\r
1669 continue\r
1670 if v1 in G[v4]:\r
1671 f.add(frozenset([v1, v2, v3, v4]))\r
1672 else:\r
1673 for v5 in G[v4]:\r
1674 if v5 == v3 or v5 == v2:\r
1675 continue\r
1676 if v1 in G[v5]:\r
1677 f.add(frozenset([v1, v2, v3, v4, v5]))\r
1678 return f\r
1679\r
1680\r
1681class TestGraphs(unittest.TestCase):\r
1682\r
1683 def test_cube(self):\r
1684\r
1685 g = cube(3) # vert --> {v1, v2, v3}\r
1686 vertices1 = set(g)\r
1687 self.assertEqual(len(vertices1), 8) # eight vertices\r
1688 for edge in g.values():\r
1689 self.assertEqual(len(edge), 3) # each vertex connects to three edges\r
1690 vertices2 = set(v for edges in g.values() for v in edges)\r
1691 self.assertEqual(vertices1, vertices2) # edge vertices in original set\r
1692\r
1693 cubefaces = faces(g)\r
1694 self.assertEqual(len(cubefaces), 6) # six faces\r
1695 for face in cubefaces:\r
1696 self.assertEqual(len(face), 4) # each face is a square\r
1697\r
1698 def test_cuboctahedron(self):\r
1699\r
1700 # http://en.wikipedia.org/wiki/Cuboctahedron\r
1701 # 8 triangular faces and 6 square faces\r
1702 # 12 indentical vertices each connecting a triangle and square\r
1703\r
1704 g = cube(3)\r
1705 cuboctahedron = linegraph(g) # V( --> {V1, V2, V3, V4}\r
1706 self.assertEqual(len(cuboctahedron), 12)# twelve vertices\r
1707\r
1708 vertices = set(cuboctahedron)\r
1709 for edges in cuboctahedron.values():\r
1710 self.assertEqual(len(edges), 4) # each vertex connects to four other vertices\r
1711 othervertices = set(edge for edges in cuboctahedron.values() for edge in edges)\r
1712 self.assertEqual(vertices, othervertices) # edge vertices in original set\r
1713\r
1714 cubofaces = faces(cuboctahedron)\r
1715 facesizes = collections.defaultdict(int)\r
1716 for face in cubofaces:\r
1717 facesizes[len(face)] += 1\r
1718 self.assertEqual(facesizes[3], 8) # eight triangular faces\r
1719 self.assertEqual(facesizes[4], 6) # six square faces\r
1720\r
1721 for vertex in cuboctahedron:\r
1722 edge = vertex # Cuboctahedron vertices are edges in Cube\r
1723 self.assertEqual(len(edge), 2) # Two cube vertices define an edge\r
1724 for cubevert in edge:\r
1725 self.assertIn(cubevert, g)\r
1726\r
1727\r
1728#==============================================================================\r
1729\r
1730def test_main(verbose=None):\r
1731 test_classes = (\r
1732 TestSet,\r
1733 TestSetSubclass,\r
1734 TestSetSubclassWithKeywordArgs,\r
1735 TestFrozenSet,\r
1736 TestFrozenSetSubclass,\r
1737 TestSetOfSets,\r
1738 TestExceptionPropagation,\r
1739 TestBasicOpsEmpty,\r
1740 TestBasicOpsSingleton,\r
1741 TestBasicOpsTuple,\r
1742 TestBasicOpsTriple,\r
1743 TestBinaryOps,\r
1744 TestUpdateOps,\r
1745 TestMutate,\r
1746 TestSubsetEqualEmpty,\r
1747 TestSubsetEqualNonEmpty,\r
1748 TestSubsetEmptyNonEmpty,\r
1749 TestSubsetPartial,\r
1750 TestSubsetNonOverlap,\r
1751 TestOnlySetsNumeric,\r
1752 TestOnlySetsDict,\r
1753 TestOnlySetsOperator,\r
1754 TestOnlySetsTuple,\r
1755 TestOnlySetsString,\r
1756 TestOnlySetsGenerator,\r
1757 TestCopyingEmpty,\r
1758 TestCopyingSingleton,\r
1759 TestCopyingTriple,\r
1760 TestCopyingTuple,\r
1761 TestCopyingNested,\r
1762 TestIdentities,\r
1763 TestVariousIteratorArgs,\r
1764 TestGraphs,\r
1765 TestWeirdBugs,\r
1766 )\r
1767\r
1768 test_support.run_unittest(*test_classes)\r
1769\r
1770 # verify reference counting\r
1771 if verbose and hasattr(sys, "gettotalrefcount"):\r
1772 import gc\r
1773 counts = [None] * 5\r
1774 for i in xrange(len(counts)):\r
1775 test_support.run_unittest(*test_classes)\r
1776 gc.collect()\r
1777 counts[i] = sys.gettotalrefcount()\r
1778 print counts\r
1779\r
1780if __name__ == "__main__":\r
1781 test_main(verbose=True)\r
EFI Development Kit II mirror for PVE