Lib/test/test_sets.py

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