]>
Commit | Line | Data |
---|---|---|
4710c53d | 1 | #!/usr/bin/env python\r |
2 | \r | |
3 | import unittest, operator, copy, pickle, random\r | |
4 | from test import test_support\r | |
5 | \r | |
6 | test_support.import_module("sets", deprecated=True)\r | |
7 | from sets import Set, ImmutableSet\r | |
8 | \r | |
9 | empty_set = Set()\r | |
10 | \r | |
11 | #==============================================================================\r | |
12 | \r | |
13 | class TestBasicOps(unittest.TestCase):\r | |
14 | \r | |
15 | def test_repr(self):\r | |
16 | if self.repr is not None:\r | |
17 | self.assertEqual(repr(self.set), self.repr)\r | |
18 | \r | |
19 | def test_length(self):\r | |
20 | self.assertEqual(len(self.set), self.length)\r | |
21 | \r | |
22 | def test_self_equality(self):\r | |
23 | self.assertEqual(self.set, self.set)\r | |
24 | \r | |
25 | def test_equivalent_equality(self):\r | |
26 | self.assertEqual(self.set, self.dup)\r | |
27 | \r | |
28 | def test_copy(self):\r | |
29 | self.assertEqual(self.set.copy(), self.dup)\r | |
30 | \r | |
31 | def test_self_union(self):\r | |
32 | result = self.set | self.set\r | |
33 | self.assertEqual(result, self.dup)\r | |
34 | \r | |
35 | def test_empty_union(self):\r | |
36 | result = self.set | empty_set\r | |
37 | self.assertEqual(result, self.dup)\r | |
38 | \r | |
39 | def test_union_empty(self):\r | |
40 | result = empty_set | self.set\r | |
41 | self.assertEqual(result, self.dup)\r | |
42 | \r | |
43 | def test_self_intersection(self):\r | |
44 | result = self.set & self.set\r | |
45 | self.assertEqual(result, self.dup)\r | |
46 | \r | |
47 | def test_empty_intersection(self):\r | |
48 | result = self.set & empty_set\r | |
49 | self.assertEqual(result, empty_set)\r | |
50 | \r | |
51 | def test_intersection_empty(self):\r | |
52 | result = empty_set & self.set\r | |
53 | self.assertEqual(result, empty_set)\r | |
54 | \r | |
55 | def test_self_symmetric_difference(self):\r | |
56 | result = self.set ^ self.set\r | |
57 | self.assertEqual(result, empty_set)\r | |
58 | \r | |
59 | def checkempty_symmetric_difference(self):\r | |
60 | result = self.set ^ empty_set\r | |
61 | self.assertEqual(result, self.set)\r | |
62 | \r | |
63 | def test_self_difference(self):\r | |
64 | result = self.set - self.set\r | |
65 | self.assertEqual(result, empty_set)\r | |
66 | \r | |
67 | def test_empty_difference(self):\r | |
68 | result = self.set - empty_set\r | |
69 | self.assertEqual(result, self.dup)\r | |
70 | \r | |
71 | def test_empty_difference_rev(self):\r | |
72 | result = empty_set - self.set\r | |
73 | self.assertEqual(result, empty_set)\r | |
74 | \r | |
75 | def test_iteration(self):\r | |
76 | for v in self.set:\r | |
77 | self.assertIn(v, self.values)\r | |
78 | \r | |
79 | def test_pickling(self):\r | |
80 | p = pickle.dumps(self.set)\r | |
81 | copy = pickle.loads(p)\r | |
82 | self.assertEqual(self.set, copy,\r | |
83 | "%s != %s" % (self.set, copy))\r | |
84 | \r | |
85 | #------------------------------------------------------------------------------\r | |
86 | \r | |
87 | class TestBasicOpsEmpty(TestBasicOps):\r | |
88 | def setUp(self):\r | |
89 | self.case = "empty set"\r | |
90 | self.values = []\r | |
91 | self.set = Set(self.values)\r | |
92 | self.dup = Set(self.values)\r | |
93 | self.length = 0\r | |
94 | self.repr = "Set([])"\r | |
95 | \r | |
96 | #------------------------------------------------------------------------------\r | |
97 | \r | |
98 | class TestBasicOpsSingleton(TestBasicOps):\r | |
99 | def setUp(self):\r | |
100 | self.case = "unit set (number)"\r | |
101 | self.values = [3]\r | |
102 | self.set = Set(self.values)\r | |
103 | self.dup = Set(self.values)\r | |
104 | self.length = 1\r | |
105 | self.repr = "Set([3])"\r | |
106 | \r | |
107 | def test_in(self):\r | |
108 | self.assertTrue(3 in self.set)\r | |
109 | \r | |
110 | def test_not_in(self):\r | |
111 | self.assertTrue(2 not in self.set)\r | |
112 | \r | |
113 | #------------------------------------------------------------------------------\r | |
114 | \r | |
115 | class TestBasicOpsTuple(TestBasicOps):\r | |
116 | def setUp(self):\r | |
117 | self.case = "unit set (tuple)"\r | |
118 | self.values = [(0, "zero")]\r | |
119 | self.set = Set(self.values)\r | |
120 | self.dup = Set(self.values)\r | |
121 | self.length = 1\r | |
122 | self.repr = "Set([(0, 'zero')])"\r | |
123 | \r | |
124 | def test_in(self):\r | |
125 | self.assertTrue((0, "zero") in self.set)\r | |
126 | \r | |
127 | def test_not_in(self):\r | |
128 | self.assertTrue(9 not in self.set)\r | |
129 | \r | |
130 | #------------------------------------------------------------------------------\r | |
131 | \r | |
132 | class TestBasicOpsTriple(TestBasicOps):\r | |
133 | def setUp(self):\r | |
134 | self.case = "triple set"\r | |
135 | self.values = [0, "zero", operator.add]\r | |
136 | self.set = Set(self.values)\r | |
137 | self.dup = Set(self.values)\r | |
138 | self.length = 3\r | |
139 | self.repr = None\r | |
140 | \r | |
141 | #==============================================================================\r | |
142 | \r | |
143 | def baditer():\r | |
144 | raise TypeError\r | |
145 | yield True\r | |
146 | \r | |
147 | def gooditer():\r | |
148 | yield True\r | |
149 | \r | |
150 | class TestExceptionPropagation(unittest.TestCase):\r | |
151 | """SF 628246: Set constructor should not trap iterator TypeErrors"""\r | |
152 | \r | |
153 | def test_instanceWithException(self):\r | |
154 | self.assertRaises(TypeError, Set, baditer())\r | |
155 | \r | |
156 | def test_instancesWithoutException(self):\r | |
157 | # All of these iterables should load without exception.\r | |
158 | Set([1,2,3])\r | |
159 | Set((1,2,3))\r | |
160 | Set({'one':1, 'two':2, 'three':3})\r | |
161 | Set(xrange(3))\r | |
162 | Set('abc')\r | |
163 | Set(gooditer())\r | |
164 | \r | |
165 | #==============================================================================\r | |
166 | \r | |
167 | class TestSetOfSets(unittest.TestCase):\r | |
168 | def test_constructor(self):\r | |
169 | inner = Set([1])\r | |
170 | outer = Set([inner])\r | |
171 | element = outer.pop()\r | |
172 | self.assertEqual(type(element), ImmutableSet)\r | |
173 | outer.add(inner) # Rebuild set of sets with .add method\r | |
174 | outer.remove(inner)\r | |
175 | self.assertEqual(outer, Set()) # Verify that remove worked\r | |
176 | outer.discard(inner) # Absence of KeyError indicates working fine\r | |
177 | \r | |
178 | #==============================================================================\r | |
179 | \r | |
180 | class TestBinaryOps(unittest.TestCase):\r | |
181 | def setUp(self):\r | |
182 | self.set = Set((2, 4, 6))\r | |
183 | \r | |
184 | def test_eq(self): # SF bug 643115\r | |
185 | self.assertEqual(self.set, Set({2:1,4:3,6:5}))\r | |
186 | \r | |
187 | def test_union_subset(self):\r | |
188 | result = self.set | Set([2])\r | |
189 | self.assertEqual(result, Set((2, 4, 6)))\r | |
190 | \r | |
191 | def test_union_superset(self):\r | |
192 | result = self.set | Set([2, 4, 6, 8])\r | |
193 | self.assertEqual(result, Set([2, 4, 6, 8]))\r | |
194 | \r | |
195 | def test_union_overlap(self):\r | |
196 | result = self.set | Set([3, 4, 5])\r | |
197 | self.assertEqual(result, Set([2, 3, 4, 5, 6]))\r | |
198 | \r | |
199 | def test_union_non_overlap(self):\r | |
200 | result = self.set | Set([8])\r | |
201 | self.assertEqual(result, Set([2, 4, 6, 8]))\r | |
202 | \r | |
203 | def test_intersection_subset(self):\r | |
204 | result = self.set & Set((2, 4))\r | |
205 | self.assertEqual(result, Set((2, 4)))\r | |
206 | \r | |
207 | def test_intersection_superset(self):\r | |
208 | result = self.set & Set([2, 4, 6, 8])\r | |
209 | self.assertEqual(result, Set([2, 4, 6]))\r | |
210 | \r | |
211 | def test_intersection_overlap(self):\r | |
212 | result = self.set & Set([3, 4, 5])\r | |
213 | self.assertEqual(result, Set([4]))\r | |
214 | \r | |
215 | def test_intersection_non_overlap(self):\r | |
216 | result = self.set & Set([8])\r | |
217 | self.assertEqual(result, empty_set)\r | |
218 | \r | |
219 | def test_sym_difference_subset(self):\r | |
220 | result = self.set ^ Set((2, 4))\r | |
221 | self.assertEqual(result, Set([6]))\r | |
222 | \r | |
223 | def test_sym_difference_superset(self):\r | |
224 | result = self.set ^ Set((2, 4, 6, 8))\r | |
225 | self.assertEqual(result, Set([8]))\r | |
226 | \r | |
227 | def test_sym_difference_overlap(self):\r | |
228 | result = self.set ^ Set((3, 4, 5))\r | |
229 | self.assertEqual(result, Set([2, 3, 5, 6]))\r | |
230 | \r | |
231 | def test_sym_difference_non_overlap(self):\r | |
232 | result = self.set ^ Set([8])\r | |
233 | self.assertEqual(result, Set([2, 4, 6, 8]))\r | |
234 | \r | |
235 | def test_cmp(self):\r | |
236 | a, b = Set('a'), Set('b')\r | |
237 | self.assertRaises(TypeError, cmp, a, b)\r | |
238 | \r | |
239 | # You can view this as a buglet: cmp(a, a) does not raise TypeError,\r | |
240 | # because __eq__ is tried before __cmp__, and a.__eq__(a) returns True,\r | |
241 | # which Python thinks is good enough to synthesize a cmp() result\r | |
242 | # without calling __cmp__.\r | |
243 | self.assertEqual(cmp(a, a), 0)\r | |
244 | \r | |
245 | self.assertRaises(TypeError, cmp, a, 12)\r | |
246 | self.assertRaises(TypeError, cmp, "abc", a)\r | |
247 | \r | |
248 | def test_inplace_on_self(self):\r | |
249 | t = self.set.copy()\r | |
250 | t |= t\r | |
251 | self.assertEqual(t, self.set)\r | |
252 | t &= t\r | |
253 | self.assertEqual(t, self.set)\r | |
254 | t -= t\r | |
255 | self.assertEqual(len(t), 0)\r | |
256 | t = self.set.copy()\r | |
257 | t ^= t\r | |
258 | self.assertEqual(len(t), 0)\r | |
259 | \r | |
260 | \r | |
261 | #==============================================================================\r | |
262 | \r | |
263 | class TestUpdateOps(unittest.TestCase):\r | |
264 | def setUp(self):\r | |
265 | self.set = Set((2, 4, 6))\r | |
266 | \r | |
267 | def test_union_subset(self):\r | |
268 | self.set |= Set([2])\r | |
269 | self.assertEqual(self.set, Set((2, 4, 6)))\r | |
270 | \r | |
271 | def test_union_superset(self):\r | |
272 | self.set |= Set([2, 4, 6, 8])\r | |
273 | self.assertEqual(self.set, Set([2, 4, 6, 8]))\r | |
274 | \r | |
275 | def test_union_overlap(self):\r | |
276 | self.set |= Set([3, 4, 5])\r | |
277 | self.assertEqual(self.set, Set([2, 3, 4, 5, 6]))\r | |
278 | \r | |
279 | def test_union_non_overlap(self):\r | |
280 | self.set |= Set([8])\r | |
281 | self.assertEqual(self.set, Set([2, 4, 6, 8]))\r | |
282 | \r | |
283 | def test_union_method_call(self):\r | |
284 | self.set.union_update(Set([3, 4, 5]))\r | |
285 | self.assertEqual(self.set, Set([2, 3, 4, 5, 6]))\r | |
286 | \r | |
287 | def test_intersection_subset(self):\r | |
288 | self.set &= Set((2, 4))\r | |
289 | self.assertEqual(self.set, Set((2, 4)))\r | |
290 | \r | |
291 | def test_intersection_superset(self):\r | |
292 | self.set &= Set([2, 4, 6, 8])\r | |
293 | self.assertEqual(self.set, Set([2, 4, 6]))\r | |
294 | \r | |
295 | def test_intersection_overlap(self):\r | |
296 | self.set &= Set([3, 4, 5])\r | |
297 | self.assertEqual(self.set, Set([4]))\r | |
298 | \r | |
299 | def test_intersection_non_overlap(self):\r | |
300 | self.set &= Set([8])\r | |
301 | self.assertEqual(self.set, empty_set)\r | |
302 | \r | |
303 | def test_intersection_method_call(self):\r | |
304 | self.set.intersection_update(Set([3, 4, 5]))\r | |
305 | self.assertEqual(self.set, Set([4]))\r | |
306 | \r | |
307 | def test_sym_difference_subset(self):\r | |
308 | self.set ^= Set((2, 4))\r | |
309 | self.assertEqual(self.set, Set([6]))\r | |
310 | \r | |
311 | def test_sym_difference_superset(self):\r | |
312 | self.set ^= Set((2, 4, 6, 8))\r | |
313 | self.assertEqual(self.set, Set([8]))\r | |
314 | \r | |
315 | def test_sym_difference_overlap(self):\r | |
316 | self.set ^= Set((3, 4, 5))\r | |
317 | self.assertEqual(self.set, Set([2, 3, 5, 6]))\r | |
318 | \r | |
319 | def test_sym_difference_non_overlap(self):\r | |
320 | self.set ^= Set([8])\r | |
321 | self.assertEqual(self.set, Set([2, 4, 6, 8]))\r | |
322 | \r | |
323 | def test_sym_difference_method_call(self):\r | |
324 | self.set.symmetric_difference_update(Set([3, 4, 5]))\r | |
325 | self.assertEqual(self.set, Set([2, 3, 5, 6]))\r | |
326 | \r | |
327 | def test_difference_subset(self):\r | |
328 | self.set -= Set((2, 4))\r | |
329 | self.assertEqual(self.set, Set([6]))\r | |
330 | \r | |
331 | def test_difference_superset(self):\r | |
332 | self.set -= Set((2, 4, 6, 8))\r | |
333 | self.assertEqual(self.set, Set([]))\r | |
334 | \r | |
335 | def test_difference_overlap(self):\r | |
336 | self.set -= Set((3, 4, 5))\r | |
337 | self.assertEqual(self.set, Set([2, 6]))\r | |
338 | \r | |
339 | def test_difference_non_overlap(self):\r | |
340 | self.set -= Set([8])\r | |
341 | self.assertEqual(self.set, Set([2, 4, 6]))\r | |
342 | \r | |
343 | def test_difference_method_call(self):\r | |
344 | self.set.difference_update(Set([3, 4, 5]))\r | |
345 | self.assertEqual(self.set, Set([2, 6]))\r | |
346 | \r | |
347 | #==============================================================================\r | |
348 | \r | |
349 | class TestMutate(unittest.TestCase):\r | |
350 | def setUp(self):\r | |
351 | self.values = ["a", "b", "c"]\r | |
352 | self.set = Set(self.values)\r | |
353 | \r | |
354 | def test_add_present(self):\r | |
355 | self.set.add("c")\r | |
356 | self.assertEqual(self.set, Set("abc"))\r | |
357 | \r | |
358 | def test_add_absent(self):\r | |
359 | self.set.add("d")\r | |
360 | self.assertEqual(self.set, Set("abcd"))\r | |
361 | \r | |
362 | def test_add_until_full(self):\r | |
363 | tmp = Set()\r | |
364 | expected_len = 0\r | |
365 | for v in self.values:\r | |
366 | tmp.add(v)\r | |
367 | expected_len += 1\r | |
368 | self.assertEqual(len(tmp), expected_len)\r | |
369 | self.assertEqual(tmp, self.set)\r | |
370 | \r | |
371 | def test_remove_present(self):\r | |
372 | self.set.remove("b")\r | |
373 | self.assertEqual(self.set, Set("ac"))\r | |
374 | \r | |
375 | def test_remove_absent(self):\r | |
376 | try:\r | |
377 | self.set.remove("d")\r | |
378 | self.fail("Removing missing element should have raised LookupError")\r | |
379 | except LookupError:\r | |
380 | pass\r | |
381 | \r | |
382 | def test_remove_until_empty(self):\r | |
383 | expected_len = len(self.set)\r | |
384 | for v in self.values:\r | |
385 | self.set.remove(v)\r | |
386 | expected_len -= 1\r | |
387 | self.assertEqual(len(self.set), expected_len)\r | |
388 | \r | |
389 | def test_discard_present(self):\r | |
390 | self.set.discard("c")\r | |
391 | self.assertEqual(self.set, Set("ab"))\r | |
392 | \r | |
393 | def test_discard_absent(self):\r | |
394 | self.set.discard("d")\r | |
395 | self.assertEqual(self.set, Set("abc"))\r | |
396 | \r | |
397 | def test_clear(self):\r | |
398 | self.set.clear()\r | |
399 | self.assertEqual(len(self.set), 0)\r | |
400 | \r | |
401 | def test_pop(self):\r | |
402 | popped = {}\r | |
403 | while self.set:\r | |
404 | popped[self.set.pop()] = None\r | |
405 | self.assertEqual(len(popped), len(self.values))\r | |
406 | for v in self.values:\r | |
407 | self.assertIn(v, popped)\r | |
408 | \r | |
409 | def test_update_empty_tuple(self):\r | |
410 | self.set.union_update(())\r | |
411 | self.assertEqual(self.set, Set(self.values))\r | |
412 | \r | |
413 | def test_update_unit_tuple_overlap(self):\r | |
414 | self.set.union_update(("a",))\r | |
415 | self.assertEqual(self.set, Set(self.values))\r | |
416 | \r | |
417 | def test_update_unit_tuple_non_overlap(self):\r | |
418 | self.set.union_update(("a", "z"))\r | |
419 | self.assertEqual(self.set, Set(self.values + ["z"]))\r | |
420 | \r | |
421 | #==============================================================================\r | |
422 | \r | |
423 | class TestSubsets(unittest.TestCase):\r | |
424 | \r | |
425 | case2method = {"<=": "issubset",\r | |
426 | ">=": "issuperset",\r | |
427 | }\r | |
428 | \r | |
429 | reverse = {"==": "==",\r | |
430 | "!=": "!=",\r | |
431 | "<": ">",\r | |
432 | ">": "<",\r | |
433 | "<=": ">=",\r | |
434 | ">=": "<=",\r | |
435 | }\r | |
436 | \r | |
437 | def test_issubset(self):\r | |
438 | x = self.left\r | |
439 | y = self.right\r | |
440 | for case in "!=", "==", "<", "<=", ">", ">=":\r | |
441 | expected = case in self.cases\r | |
442 | # Test the binary infix spelling.\r | |
443 | result = eval("x" + case + "y", locals())\r | |
444 | self.assertEqual(result, expected)\r | |
445 | # Test the "friendly" method-name spelling, if one exists.\r | |
446 | if case in TestSubsets.case2method:\r | |
447 | method = getattr(x, TestSubsets.case2method[case])\r | |
448 | result = method(y)\r | |
449 | self.assertEqual(result, expected)\r | |
450 | \r | |
451 | # Now do the same for the operands reversed.\r | |
452 | rcase = TestSubsets.reverse[case]\r | |
453 | result = eval("y" + rcase + "x", locals())\r | |
454 | self.assertEqual(result, expected)\r | |
455 | if rcase in TestSubsets.case2method:\r | |
456 | method = getattr(y, TestSubsets.case2method[rcase])\r | |
457 | result = method(x)\r | |
458 | self.assertEqual(result, expected)\r | |
459 | #------------------------------------------------------------------------------\r | |
460 | \r | |
461 | class TestSubsetEqualEmpty(TestSubsets):\r | |
462 | left = Set()\r | |
463 | right = Set()\r | |
464 | name = "both empty"\r | |
465 | cases = "==", "<=", ">="\r | |
466 | \r | |
467 | #------------------------------------------------------------------------------\r | |
468 | \r | |
469 | class TestSubsetEqualNonEmpty(TestSubsets):\r | |
470 | left = Set([1, 2])\r | |
471 | right = Set([1, 2])\r | |
472 | name = "equal pair"\r | |
473 | cases = "==", "<=", ">="\r | |
474 | \r | |
475 | #------------------------------------------------------------------------------\r | |
476 | \r | |
477 | class TestSubsetEmptyNonEmpty(TestSubsets):\r | |
478 | left = Set()\r | |
479 | right = Set([1, 2])\r | |
480 | name = "one empty, one non-empty"\r | |
481 | cases = "!=", "<", "<="\r | |
482 | \r | |
483 | #------------------------------------------------------------------------------\r | |
484 | \r | |
485 | class TestSubsetPartial(TestSubsets):\r | |
486 | left = Set([1])\r | |
487 | right = Set([1, 2])\r | |
488 | name = "one a non-empty proper subset of other"\r | |
489 | cases = "!=", "<", "<="\r | |
490 | \r | |
491 | #------------------------------------------------------------------------------\r | |
492 | \r | |
493 | class TestSubsetNonOverlap(TestSubsets):\r | |
494 | left = Set([1])\r | |
495 | right = Set([2])\r | |
496 | name = "neither empty, neither contains"\r | |
497 | cases = "!="\r | |
498 | \r | |
499 | #==============================================================================\r | |
500 | \r | |
501 | class TestOnlySetsInBinaryOps(unittest.TestCase):\r | |
502 | \r | |
503 | def test_eq_ne(self):\r | |
504 | # Unlike the others, this is testing that == and != *are* allowed.\r | |
505 | self.assertEqual(self.other == self.set, False)\r | |
506 | self.assertEqual(self.set == self.other, False)\r | |
507 | self.assertEqual(self.other != self.set, True)\r | |
508 | self.assertEqual(self.set != self.other, True)\r | |
509 | \r | |
510 | def test_ge_gt_le_lt(self):\r | |
511 | self.assertRaises(TypeError, lambda: self.set < self.other)\r | |
512 | self.assertRaises(TypeError, lambda: self.set <= self.other)\r | |
513 | self.assertRaises(TypeError, lambda: self.set > self.other)\r | |
514 | self.assertRaises(TypeError, lambda: self.set >= self.other)\r | |
515 | \r | |
516 | self.assertRaises(TypeError, lambda: self.other < self.set)\r | |
517 | self.assertRaises(TypeError, lambda: self.other <= self.set)\r | |
518 | self.assertRaises(TypeError, lambda: self.other > self.set)\r | |
519 | self.assertRaises(TypeError, lambda: self.other >= self.set)\r | |
520 | \r | |
521 | def test_union_update_operator(self):\r | |
522 | try:\r | |
523 | self.set |= self.other\r | |
524 | except TypeError:\r | |
525 | pass\r | |
526 | else:\r | |
527 | self.fail("expected TypeError")\r | |
528 | \r | |
529 | def test_union_update(self):\r | |
530 | if self.otherIsIterable:\r | |
531 | self.set.union_update(self.other)\r | |
532 | else:\r | |
533 | self.assertRaises(TypeError, self.set.union_update, self.other)\r | |
534 | \r | |
535 | def test_union(self):\r | |
536 | self.assertRaises(TypeError, lambda: self.set | self.other)\r | |
537 | self.assertRaises(TypeError, lambda: self.other | self.set)\r | |
538 | if self.otherIsIterable:\r | |
539 | self.set.union(self.other)\r | |
540 | else:\r | |
541 | self.assertRaises(TypeError, self.set.union, self.other)\r | |
542 | \r | |
543 | def test_intersection_update_operator(self):\r | |
544 | try:\r | |
545 | self.set &= self.other\r | |
546 | except TypeError:\r | |
547 | pass\r | |
548 | else:\r | |
549 | self.fail("expected TypeError")\r | |
550 | \r | |
551 | def test_intersection_update(self):\r | |
552 | if self.otherIsIterable:\r | |
553 | self.set.intersection_update(self.other)\r | |
554 | else:\r | |
555 | self.assertRaises(TypeError,\r | |
556 | self.set.intersection_update,\r | |
557 | self.other)\r | |
558 | \r | |
559 | def test_intersection(self):\r | |
560 | self.assertRaises(TypeError, lambda: self.set & self.other)\r | |
561 | self.assertRaises(TypeError, lambda: self.other & self.set)\r | |
562 | if self.otherIsIterable:\r | |
563 | self.set.intersection(self.other)\r | |
564 | else:\r | |
565 | self.assertRaises(TypeError, self.set.intersection, self.other)\r | |
566 | \r | |
567 | def test_sym_difference_update_operator(self):\r | |
568 | try:\r | |
569 | self.set ^= self.other\r | |
570 | except TypeError:\r | |
571 | pass\r | |
572 | else:\r | |
573 | self.fail("expected TypeError")\r | |
574 | \r | |
575 | def test_sym_difference_update(self):\r | |
576 | if self.otherIsIterable:\r | |
577 | self.set.symmetric_difference_update(self.other)\r | |
578 | else:\r | |
579 | self.assertRaises(TypeError,\r | |
580 | self.set.symmetric_difference_update,\r | |
581 | self.other)\r | |
582 | \r | |
583 | def test_sym_difference(self):\r | |
584 | self.assertRaises(TypeError, lambda: self.set ^ self.other)\r | |
585 | self.assertRaises(TypeError, lambda: self.other ^ self.set)\r | |
586 | if self.otherIsIterable:\r | |
587 | self.set.symmetric_difference(self.other)\r | |
588 | else:\r | |
589 | self.assertRaises(TypeError, self.set.symmetric_difference, self.other)\r | |
590 | \r | |
591 | def test_difference_update_operator(self):\r | |
592 | try:\r | |
593 | self.set -= self.other\r | |
594 | except TypeError:\r | |
595 | pass\r | |
596 | else:\r | |
597 | self.fail("expected TypeError")\r | |
598 | \r | |
599 | def test_difference_update(self):\r | |
600 | if self.otherIsIterable:\r | |
601 | self.set.difference_update(self.other)\r | |
602 | else:\r | |
603 | self.assertRaises(TypeError,\r | |
604 | self.set.difference_update,\r | |
605 | self.other)\r | |
606 | \r | |
607 | def test_difference(self):\r | |
608 | self.assertRaises(TypeError, lambda: self.set - self.other)\r | |
609 | self.assertRaises(TypeError, lambda: self.other - self.set)\r | |
610 | if self.otherIsIterable:\r | |
611 | self.set.difference(self.other)\r | |
612 | else:\r | |
613 | self.assertRaises(TypeError, self.set.difference, self.other)\r | |
614 | \r | |
615 | #------------------------------------------------------------------------------\r | |
616 | \r | |
617 | class TestOnlySetsNumeric(TestOnlySetsInBinaryOps):\r | |
618 | def setUp(self):\r | |
619 | self.set = Set((1, 2, 3))\r | |
620 | self.other = 19\r | |
621 | self.otherIsIterable = False\r | |
622 | \r | |
623 | #------------------------------------------------------------------------------\r | |
624 | \r | |
625 | class TestOnlySetsDict(TestOnlySetsInBinaryOps):\r | |
626 | def setUp(self):\r | |
627 | self.set = Set((1, 2, 3))\r | |
628 | self.other = {1:2, 3:4}\r | |
629 | self.otherIsIterable = True\r | |
630 | \r | |
631 | #------------------------------------------------------------------------------\r | |
632 | \r | |
633 | class TestOnlySetsOperator(TestOnlySetsInBinaryOps):\r | |
634 | def setUp(self):\r | |
635 | self.set = Set((1, 2, 3))\r | |
636 | self.other = operator.add\r | |
637 | self.otherIsIterable = False\r | |
638 | \r | |
639 | def test_ge_gt_le_lt(self):\r | |
640 | with test_support.check_py3k_warnings():\r | |
641 | super(TestOnlySetsOperator, self).test_ge_gt_le_lt()\r | |
642 | \r | |
643 | #------------------------------------------------------------------------------\r | |
644 | \r | |
645 | class TestOnlySetsTuple(TestOnlySetsInBinaryOps):\r | |
646 | def setUp(self):\r | |
647 | self.set = Set((1, 2, 3))\r | |
648 | self.other = (2, 4, 6)\r | |
649 | self.otherIsIterable = True\r | |
650 | \r | |
651 | #------------------------------------------------------------------------------\r | |
652 | \r | |
653 | class TestOnlySetsString(TestOnlySetsInBinaryOps):\r | |
654 | def setUp(self):\r | |
655 | self.set = Set((1, 2, 3))\r | |
656 | self.other = 'abc'\r | |
657 | self.otherIsIterable = True\r | |
658 | \r | |
659 | #------------------------------------------------------------------------------\r | |
660 | \r | |
661 | class TestOnlySetsGenerator(TestOnlySetsInBinaryOps):\r | |
662 | def setUp(self):\r | |
663 | def gen():\r | |
664 | for i in xrange(0, 10, 2):\r | |
665 | yield i\r | |
666 | self.set = Set((1, 2, 3))\r | |
667 | self.other = gen()\r | |
668 | self.otherIsIterable = True\r | |
669 | \r | |
670 | #------------------------------------------------------------------------------\r | |
671 | \r | |
672 | class TestOnlySetsofSets(TestOnlySetsInBinaryOps):\r | |
673 | def setUp(self):\r | |
674 | self.set = Set((1, 2, 3))\r | |
675 | self.other = [Set('ab'), ImmutableSet('cd')]\r | |
676 | self.otherIsIterable = True\r | |
677 | \r | |
678 | #==============================================================================\r | |
679 | \r | |
680 | class TestCopying(unittest.TestCase):\r | |
681 | \r | |
682 | def test_copy(self):\r | |
683 | dup = self.set.copy()\r | |
684 | self.assertEqual(len(dup), len(self.set))\r | |
685 | dup_list = sorted(dup)\r | |
686 | set_list = sorted(self.set)\r | |
687 | self.assertEqual(len(dup_list), len(set_list))\r | |
688 | for i, el in enumerate(dup_list):\r | |
689 | self.assertIs(el, set_list[i])\r | |
690 | \r | |
691 | def test_deep_copy(self):\r | |
692 | dup = copy.deepcopy(self.set)\r | |
693 | self.assertSetEqual(dup, self.set)\r | |
694 | \r | |
695 | #------------------------------------------------------------------------------\r | |
696 | \r | |
697 | class TestCopyingEmpty(TestCopying):\r | |
698 | def setUp(self):\r | |
699 | self.set = Set()\r | |
700 | \r | |
701 | #------------------------------------------------------------------------------\r | |
702 | \r | |
703 | class TestCopyingSingleton(TestCopying):\r | |
704 | def setUp(self):\r | |
705 | self.set = Set(["hello"])\r | |
706 | \r | |
707 | #------------------------------------------------------------------------------\r | |
708 | \r | |
709 | class TestCopyingTriple(TestCopying):\r | |
710 | def setUp(self):\r | |
711 | self.set = Set(["zero", 0, None])\r | |
712 | \r | |
713 | def test_copy(self):\r | |
714 | with test_support.check_py3k_warnings():\r | |
715 | super(TestCopyingTriple, self).test_copy()\r | |
716 | \r | |
717 | #------------------------------------------------------------------------------\r | |
718 | \r | |
719 | class TestCopyingTuple(TestCopying):\r | |
720 | def setUp(self):\r | |
721 | self.set = Set([(1, 2)])\r | |
722 | \r | |
723 | #------------------------------------------------------------------------------\r | |
724 | \r | |
725 | class TestCopyingNested(TestCopying):\r | |
726 | def setUp(self):\r | |
727 | self.set = Set([((1, 2), (3, 4))])\r | |
728 | \r | |
729 | #==============================================================================\r | |
730 | \r | |
731 | class TestIdentities(unittest.TestCase):\r | |
732 | def setUp(self):\r | |
733 | self.a = Set([random.randrange(100) for i in xrange(50)])\r | |
734 | self.b = Set([random.randrange(100) for i in xrange(50)])\r | |
735 | \r | |
736 | def test_binopsVsSubsets(self):\r | |
737 | a, b = self.a, self.b\r | |
738 | self.assertTrue(a - b <= a)\r | |
739 | self.assertTrue(b - a <= b)\r | |
740 | self.assertTrue(a & b <= a)\r | |
741 | self.assertTrue(a & b <= b)\r | |
742 | self.assertTrue(a | b >= a)\r | |
743 | self.assertTrue(a | b >= b)\r | |
744 | self.assertTrue(a ^ b <= a | b)\r | |
745 | \r | |
746 | def test_commutativity(self):\r | |
747 | a, b = self.a, self.b\r | |
748 | self.assertEqual(a&b, b&a)\r | |
749 | self.assertEqual(a|b, b|a)\r | |
750 | self.assertEqual(a^b, b^a)\r | |
751 | if a != b:\r | |
752 | self.assertNotEqual(a-b, b-a)\r | |
753 | \r | |
754 | def test_reflexsive_relations(self):\r | |
755 | a, zero = self.a, Set()\r | |
756 | self.assertEqual(a ^ a, zero)\r | |
757 | self.assertEqual(a - a, zero)\r | |
758 | self.assertEqual(a | a, a)\r | |
759 | self.assertEqual(a & a, a)\r | |
760 | self.assertTrue(a <= a)\r | |
761 | self.assertTrue(a >= a)\r | |
762 | self.assertTrue(a == a)\r | |
763 | \r | |
764 | def test_summations(self):\r | |
765 | # check that sums of parts equal the whole\r | |
766 | a, b = self.a, self.b\r | |
767 | self.assertEqual((a-b)|(a&b)|(b-a), a|b)\r | |
768 | self.assertEqual((a&b)|(a^b), a|b)\r | |
769 | self.assertEqual(a|(b-a), a|b)\r | |
770 | self.assertEqual((a-b)|b, a|b)\r | |
771 | self.assertEqual((a-b)|(a&b), a)\r | |
772 | self.assertEqual((b-a)|(a&b), b)\r | |
773 | self.assertEqual((a-b)|(b-a), a^b)\r | |
774 | \r | |
775 | def test_exclusion(self):\r | |
776 | # check that inverse operations do not overlap\r | |
777 | a, b, zero = self.a, self.b, Set()\r | |
778 | self.assertEqual((a-b)&b, zero)\r | |
779 | self.assertEqual((b-a)&a, zero)\r | |
780 | self.assertEqual((a&b)&(a^b), zero)\r | |
781 | \r | |
782 | def test_cardinality_relations(self):\r | |
783 | a, b = self.a, self.b\r | |
784 | self.assertEqual(len(a), len(a-b) + len(a&b))\r | |
785 | self.assertEqual(len(b), len(b-a) + len(a&b))\r | |
786 | self.assertEqual(len(a^b), len(a-b) + len(b-a))\r | |
787 | self.assertEqual(len(a|b), len(a-b) + len(a&b) + len(b-a))\r | |
788 | self.assertEqual(len(a^b) + len(a&b), len(a|b))\r | |
789 | \r | |
790 | #==============================================================================\r | |
791 | \r | |
792 | libreftest = """\r | |
793 | Example from the Library Reference: Doc/lib/libsets.tex\r | |
794 | \r | |
795 | >>> from sets import Set as Base # override _repr to get sorted output\r | |
796 | >>> class Set(Base):\r | |
797 | ... def _repr(self):\r | |
798 | ... return Base._repr(self, sorted=True)\r | |
799 | >>> engineers = Set(['John', 'Jane', 'Jack', 'Janice'])\r | |
800 | >>> programmers = Set(['Jack', 'Sam', 'Susan', 'Janice'])\r | |
801 | >>> managers = Set(['Jane', 'Jack', 'Susan', 'Zack'])\r | |
802 | >>> employees = engineers | programmers | managers # union\r | |
803 | >>> engineering_management = engineers & managers # intersection\r | |
804 | >>> fulltime_management = managers - engineers - programmers # difference\r | |
805 | >>> engineers.add('Marvin')\r | |
806 | >>> print engineers\r | |
807 | Set(['Jack', 'Jane', 'Janice', 'John', 'Marvin'])\r | |
808 | >>> employees.issuperset(engineers) # superset test\r | |
809 | False\r | |
810 | >>> employees.union_update(engineers) # update from another set\r | |
811 | >>> employees.issuperset(engineers)\r | |
812 | True\r | |
813 | >>> for group in [engineers, programmers, managers, employees]:\r | |
814 | ... group.discard('Susan') # unconditionally remove element\r | |
815 | ... print group\r | |
816 | ...\r | |
817 | Set(['Jack', 'Jane', 'Janice', 'John', 'Marvin'])\r | |
818 | Set(['Jack', 'Janice', 'Sam'])\r | |
819 | Set(['Jack', 'Jane', 'Zack'])\r | |
820 | Set(['Jack', 'Jane', 'Janice', 'John', 'Marvin', 'Sam', 'Zack'])\r | |
821 | """\r | |
822 | \r | |
823 | #==============================================================================\r | |
824 | \r | |
825 | __test__ = {'libreftest' : libreftest}\r | |
826 | \r | |
827 | def test_main(verbose=None):\r | |
828 | import doctest\r | |
829 | from test import test_sets\r | |
830 | test_support.run_unittest(\r | |
831 | TestSetOfSets,\r | |
832 | TestExceptionPropagation,\r | |
833 | TestBasicOpsEmpty,\r | |
834 | TestBasicOpsSingleton,\r | |
835 | TestBasicOpsTuple,\r | |
836 | TestBasicOpsTriple,\r | |
837 | TestBinaryOps,\r | |
838 | TestUpdateOps,\r | |
839 | TestMutate,\r | |
840 | TestSubsetEqualEmpty,\r | |
841 | TestSubsetEqualNonEmpty,\r | |
842 | TestSubsetEmptyNonEmpty,\r | |
843 | TestSubsetPartial,\r | |
844 | TestSubsetNonOverlap,\r | |
845 | TestOnlySetsNumeric,\r | |
846 | TestOnlySetsDict,\r | |
847 | TestOnlySetsOperator,\r | |
848 | TestOnlySetsTuple,\r | |
849 | TestOnlySetsString,\r | |
850 | TestOnlySetsGenerator,\r | |
851 | TestOnlySetsofSets,\r | |
852 | TestCopyingEmpty,\r | |
853 | TestCopyingSingleton,\r | |
854 | TestCopyingTriple,\r | |
855 | TestCopyingTuple,\r | |
856 | TestCopyingNested,\r | |
857 | TestIdentities,\r | |
858 | doctest.DocTestSuite(test_sets),\r | |
859 | )\r | |
860 | \r | |
861 | if __name__ == "__main__":\r | |
862 | test_main(verbose=True)\r |