Lib/test/test_sets.py

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