home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 June / maximum-cd-2011-06.iso / DiscContents / LibO_3.3.1_Win_x86_install_multi.exe / libreoffice1.cab / test_sets.py < prev    next >
Encoding:
Python Source  |  2011-02-15  |  27.2 KB  |  861 lines
  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)
  861.