+++ /dev/null
-#!/usr/bin/env python\r
-\r
-import unittest, operator, copy, pickle, random\r
-from test import test_support\r
-\r
-test_support.import_module("sets", deprecated=True)\r
-from sets import Set, ImmutableSet\r
-\r
-empty_set = Set()\r
-\r
-#==============================================================================\r
-\r
-class TestBasicOps(unittest.TestCase):\r
-\r
- def test_repr(self):\r
- if self.repr is not None:\r
- self.assertEqual(repr(self.set), self.repr)\r
-\r
- def test_length(self):\r
- self.assertEqual(len(self.set), self.length)\r
-\r
- def test_self_equality(self):\r
- self.assertEqual(self.set, self.set)\r
-\r
- def test_equivalent_equality(self):\r
- self.assertEqual(self.set, self.dup)\r
-\r
- def test_copy(self):\r
- self.assertEqual(self.set.copy(), self.dup)\r
-\r
- def test_self_union(self):\r
- result = self.set | self.set\r
- self.assertEqual(result, self.dup)\r
-\r
- def test_empty_union(self):\r
- result = self.set | empty_set\r
- self.assertEqual(result, self.dup)\r
-\r
- def test_union_empty(self):\r
- result = empty_set | self.set\r
- self.assertEqual(result, self.dup)\r
-\r
- def test_self_intersection(self):\r
- result = self.set & self.set\r
- self.assertEqual(result, self.dup)\r
-\r
- def test_empty_intersection(self):\r
- result = self.set & empty_set\r
- self.assertEqual(result, empty_set)\r
-\r
- def test_intersection_empty(self):\r
- result = empty_set & self.set\r
- self.assertEqual(result, empty_set)\r
-\r
- def test_self_symmetric_difference(self):\r
- result = self.set ^ self.set\r
- self.assertEqual(result, empty_set)\r
-\r
- def checkempty_symmetric_difference(self):\r
- result = self.set ^ empty_set\r
- self.assertEqual(result, self.set)\r
-\r
- def test_self_difference(self):\r
- result = self.set - self.set\r
- self.assertEqual(result, empty_set)\r
-\r
- def test_empty_difference(self):\r
- result = self.set - empty_set\r
- self.assertEqual(result, self.dup)\r
-\r
- def test_empty_difference_rev(self):\r
- result = empty_set - self.set\r
- self.assertEqual(result, empty_set)\r
-\r
- def test_iteration(self):\r
- for v in self.set:\r
- self.assertIn(v, self.values)\r
-\r
- def test_pickling(self):\r
- p = pickle.dumps(self.set)\r
- copy = pickle.loads(p)\r
- self.assertEqual(self.set, copy,\r
- "%s != %s" % (self.set, copy))\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestBasicOpsEmpty(TestBasicOps):\r
- def setUp(self):\r
- self.case = "empty set"\r
- self.values = []\r
- self.set = Set(self.values)\r
- self.dup = Set(self.values)\r
- self.length = 0\r
- self.repr = "Set([])"\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestBasicOpsSingleton(TestBasicOps):\r
- def setUp(self):\r
- self.case = "unit set (number)"\r
- self.values = [3]\r
- self.set = Set(self.values)\r
- self.dup = Set(self.values)\r
- self.length = 1\r
- self.repr = "Set([3])"\r
-\r
- def test_in(self):\r
- self.assertTrue(3 in self.set)\r
-\r
- def test_not_in(self):\r
- self.assertTrue(2 not in self.set)\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestBasicOpsTuple(TestBasicOps):\r
- def setUp(self):\r
- self.case = "unit set (tuple)"\r
- self.values = [(0, "zero")]\r
- self.set = Set(self.values)\r
- self.dup = Set(self.values)\r
- self.length = 1\r
- self.repr = "Set([(0, 'zero')])"\r
-\r
- def test_in(self):\r
- self.assertTrue((0, "zero") in self.set)\r
-\r
- def test_not_in(self):\r
- self.assertTrue(9 not in self.set)\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestBasicOpsTriple(TestBasicOps):\r
- def setUp(self):\r
- self.case = "triple set"\r
- self.values = [0, "zero", operator.add]\r
- self.set = Set(self.values)\r
- self.dup = Set(self.values)\r
- self.length = 3\r
- self.repr = None\r
-\r
-#==============================================================================\r
-\r
-def baditer():\r
- raise TypeError\r
- yield True\r
-\r
-def gooditer():\r
- yield True\r
-\r
-class TestExceptionPropagation(unittest.TestCase):\r
- """SF 628246: Set constructor should not trap iterator TypeErrors"""\r
-\r
- def test_instanceWithException(self):\r
- self.assertRaises(TypeError, Set, baditer())\r
-\r
- def test_instancesWithoutException(self):\r
- # All of these iterables should load without exception.\r
- Set([1,2,3])\r
- Set((1,2,3))\r
- Set({'one':1, 'two':2, 'three':3})\r
- Set(xrange(3))\r
- Set('abc')\r
- Set(gooditer())\r
-\r
-#==============================================================================\r
-\r
-class TestSetOfSets(unittest.TestCase):\r
- def test_constructor(self):\r
- inner = Set([1])\r
- outer = Set([inner])\r
- element = outer.pop()\r
- self.assertEqual(type(element), ImmutableSet)\r
- outer.add(inner) # Rebuild set of sets with .add method\r
- outer.remove(inner)\r
- self.assertEqual(outer, Set()) # Verify that remove worked\r
- outer.discard(inner) # Absence of KeyError indicates working fine\r
-\r
-#==============================================================================\r
-\r
-class TestBinaryOps(unittest.TestCase):\r
- def setUp(self):\r
- self.set = Set((2, 4, 6))\r
-\r
- def test_eq(self): # SF bug 643115\r
- self.assertEqual(self.set, Set({2:1,4:3,6:5}))\r
-\r
- def test_union_subset(self):\r
- result = self.set | Set([2])\r
- self.assertEqual(result, Set((2, 4, 6)))\r
-\r
- def test_union_superset(self):\r
- result = self.set | Set([2, 4, 6, 8])\r
- self.assertEqual(result, Set([2, 4, 6, 8]))\r
-\r
- def test_union_overlap(self):\r
- result = self.set | Set([3, 4, 5])\r
- self.assertEqual(result, Set([2, 3, 4, 5, 6]))\r
-\r
- def test_union_non_overlap(self):\r
- result = self.set | Set([8])\r
- self.assertEqual(result, Set([2, 4, 6, 8]))\r
-\r
- def test_intersection_subset(self):\r
- result = self.set & Set((2, 4))\r
- self.assertEqual(result, Set((2, 4)))\r
-\r
- def test_intersection_superset(self):\r
- result = self.set & Set([2, 4, 6, 8])\r
- self.assertEqual(result, Set([2, 4, 6]))\r
-\r
- def test_intersection_overlap(self):\r
- result = self.set & Set([3, 4, 5])\r
- self.assertEqual(result, Set([4]))\r
-\r
- def test_intersection_non_overlap(self):\r
- result = self.set & Set([8])\r
- self.assertEqual(result, empty_set)\r
-\r
- def test_sym_difference_subset(self):\r
- result = self.set ^ Set((2, 4))\r
- self.assertEqual(result, Set([6]))\r
-\r
- def test_sym_difference_superset(self):\r
- result = self.set ^ Set((2, 4, 6, 8))\r
- self.assertEqual(result, Set([8]))\r
-\r
- def test_sym_difference_overlap(self):\r
- result = self.set ^ Set((3, 4, 5))\r
- self.assertEqual(result, Set([2, 3, 5, 6]))\r
-\r
- def test_sym_difference_non_overlap(self):\r
- result = self.set ^ Set([8])\r
- self.assertEqual(result, Set([2, 4, 6, 8]))\r
-\r
- def test_cmp(self):\r
- a, b = Set('a'), Set('b')\r
- self.assertRaises(TypeError, cmp, a, b)\r
-\r
- # You can view this as a buglet: cmp(a, a) does not raise TypeError,\r
- # because __eq__ is tried before __cmp__, and a.__eq__(a) returns True,\r
- # which Python thinks is good enough to synthesize a cmp() result\r
- # without calling __cmp__.\r
- self.assertEqual(cmp(a, a), 0)\r
-\r
- self.assertRaises(TypeError, cmp, a, 12)\r
- self.assertRaises(TypeError, cmp, "abc", a)\r
-\r
- def test_inplace_on_self(self):\r
- t = self.set.copy()\r
- t |= t\r
- self.assertEqual(t, self.set)\r
- t &= t\r
- self.assertEqual(t, self.set)\r
- t -= t\r
- self.assertEqual(len(t), 0)\r
- t = self.set.copy()\r
- t ^= t\r
- self.assertEqual(len(t), 0)\r
-\r
-\r
-#==============================================================================\r
-\r
-class TestUpdateOps(unittest.TestCase):\r
- def setUp(self):\r
- self.set = Set((2, 4, 6))\r
-\r
- def test_union_subset(self):\r
- self.set |= Set([2])\r
- self.assertEqual(self.set, Set((2, 4, 6)))\r
-\r
- def test_union_superset(self):\r
- self.set |= Set([2, 4, 6, 8])\r
- self.assertEqual(self.set, Set([2, 4, 6, 8]))\r
-\r
- def test_union_overlap(self):\r
- self.set |= Set([3, 4, 5])\r
- self.assertEqual(self.set, Set([2, 3, 4, 5, 6]))\r
-\r
- def test_union_non_overlap(self):\r
- self.set |= Set([8])\r
- self.assertEqual(self.set, Set([2, 4, 6, 8]))\r
-\r
- def test_union_method_call(self):\r
- self.set.union_update(Set([3, 4, 5]))\r
- self.assertEqual(self.set, Set([2, 3, 4, 5, 6]))\r
-\r
- def test_intersection_subset(self):\r
- self.set &= Set((2, 4))\r
- self.assertEqual(self.set, Set((2, 4)))\r
-\r
- def test_intersection_superset(self):\r
- self.set &= Set([2, 4, 6, 8])\r
- self.assertEqual(self.set, Set([2, 4, 6]))\r
-\r
- def test_intersection_overlap(self):\r
- self.set &= Set([3, 4, 5])\r
- self.assertEqual(self.set, Set([4]))\r
-\r
- def test_intersection_non_overlap(self):\r
- self.set &= Set([8])\r
- self.assertEqual(self.set, empty_set)\r
-\r
- def test_intersection_method_call(self):\r
- self.set.intersection_update(Set([3, 4, 5]))\r
- self.assertEqual(self.set, Set([4]))\r
-\r
- def test_sym_difference_subset(self):\r
- self.set ^= Set((2, 4))\r
- self.assertEqual(self.set, Set([6]))\r
-\r
- def test_sym_difference_superset(self):\r
- self.set ^= Set((2, 4, 6, 8))\r
- self.assertEqual(self.set, Set([8]))\r
-\r
- def test_sym_difference_overlap(self):\r
- self.set ^= Set((3, 4, 5))\r
- self.assertEqual(self.set, Set([2, 3, 5, 6]))\r
-\r
- def test_sym_difference_non_overlap(self):\r
- self.set ^= Set([8])\r
- self.assertEqual(self.set, Set([2, 4, 6, 8]))\r
-\r
- def test_sym_difference_method_call(self):\r
- self.set.symmetric_difference_update(Set([3, 4, 5]))\r
- self.assertEqual(self.set, Set([2, 3, 5, 6]))\r
-\r
- def test_difference_subset(self):\r
- self.set -= Set((2, 4))\r
- self.assertEqual(self.set, Set([6]))\r
-\r
- def test_difference_superset(self):\r
- self.set -= Set((2, 4, 6, 8))\r
- self.assertEqual(self.set, Set([]))\r
-\r
- def test_difference_overlap(self):\r
- self.set -= Set((3, 4, 5))\r
- self.assertEqual(self.set, Set([2, 6]))\r
-\r
- def test_difference_non_overlap(self):\r
- self.set -= Set([8])\r
- self.assertEqual(self.set, Set([2, 4, 6]))\r
-\r
- def test_difference_method_call(self):\r
- self.set.difference_update(Set([3, 4, 5]))\r
- self.assertEqual(self.set, Set([2, 6]))\r
-\r
-#==============================================================================\r
-\r
-class TestMutate(unittest.TestCase):\r
- def setUp(self):\r
- self.values = ["a", "b", "c"]\r
- self.set = Set(self.values)\r
-\r
- def test_add_present(self):\r
- self.set.add("c")\r
- self.assertEqual(self.set, Set("abc"))\r
-\r
- def test_add_absent(self):\r
- self.set.add("d")\r
- self.assertEqual(self.set, Set("abcd"))\r
-\r
- def test_add_until_full(self):\r
- tmp = Set()\r
- expected_len = 0\r
- for v in self.values:\r
- tmp.add(v)\r
- expected_len += 1\r
- self.assertEqual(len(tmp), expected_len)\r
- self.assertEqual(tmp, self.set)\r
-\r
- def test_remove_present(self):\r
- self.set.remove("b")\r
- self.assertEqual(self.set, Set("ac"))\r
-\r
- def test_remove_absent(self):\r
- try:\r
- self.set.remove("d")\r
- self.fail("Removing missing element should have raised LookupError")\r
- except LookupError:\r
- pass\r
-\r
- def test_remove_until_empty(self):\r
- expected_len = len(self.set)\r
- for v in self.values:\r
- self.set.remove(v)\r
- expected_len -= 1\r
- self.assertEqual(len(self.set), expected_len)\r
-\r
- def test_discard_present(self):\r
- self.set.discard("c")\r
- self.assertEqual(self.set, Set("ab"))\r
-\r
- def test_discard_absent(self):\r
- self.set.discard("d")\r
- self.assertEqual(self.set, Set("abc"))\r
-\r
- def test_clear(self):\r
- self.set.clear()\r
- self.assertEqual(len(self.set), 0)\r
-\r
- def test_pop(self):\r
- popped = {}\r
- while self.set:\r
- popped[self.set.pop()] = None\r
- self.assertEqual(len(popped), len(self.values))\r
- for v in self.values:\r
- self.assertIn(v, popped)\r
-\r
- def test_update_empty_tuple(self):\r
- self.set.union_update(())\r
- self.assertEqual(self.set, Set(self.values))\r
-\r
- def test_update_unit_tuple_overlap(self):\r
- self.set.union_update(("a",))\r
- self.assertEqual(self.set, Set(self.values))\r
-\r
- def test_update_unit_tuple_non_overlap(self):\r
- self.set.union_update(("a", "z"))\r
- self.assertEqual(self.set, Set(self.values + ["z"]))\r
-\r
-#==============================================================================\r
-\r
-class TestSubsets(unittest.TestCase):\r
-\r
- case2method = {"<=": "issubset",\r
- ">=": "issuperset",\r
- }\r
-\r
- reverse = {"==": "==",\r
- "!=": "!=",\r
- "<": ">",\r
- ">": "<",\r
- "<=": ">=",\r
- ">=": "<=",\r
- }\r
-\r
- def test_issubset(self):\r
- x = self.left\r
- y = self.right\r
- for case in "!=", "==", "<", "<=", ">", ">=":\r
- expected = case in self.cases\r
- # Test the binary infix spelling.\r
- result = eval("x" + case + "y", locals())\r
- self.assertEqual(result, expected)\r
- # Test the "friendly" method-name spelling, if one exists.\r
- if case in TestSubsets.case2method:\r
- method = getattr(x, TestSubsets.case2method[case])\r
- result = method(y)\r
- self.assertEqual(result, expected)\r
-\r
- # Now do the same for the operands reversed.\r
- rcase = TestSubsets.reverse[case]\r
- result = eval("y" + rcase + "x", locals())\r
- self.assertEqual(result, expected)\r
- if rcase in TestSubsets.case2method:\r
- method = getattr(y, TestSubsets.case2method[rcase])\r
- result = method(x)\r
- self.assertEqual(result, expected)\r
-#------------------------------------------------------------------------------\r
-\r
-class TestSubsetEqualEmpty(TestSubsets):\r
- left = Set()\r
- right = Set()\r
- name = "both empty"\r
- cases = "==", "<=", ">="\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestSubsetEqualNonEmpty(TestSubsets):\r
- left = Set([1, 2])\r
- right = Set([1, 2])\r
- name = "equal pair"\r
- cases = "==", "<=", ">="\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestSubsetEmptyNonEmpty(TestSubsets):\r
- left = Set()\r
- right = Set([1, 2])\r
- name = "one empty, one non-empty"\r
- cases = "!=", "<", "<="\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestSubsetPartial(TestSubsets):\r
- left = Set([1])\r
- right = Set([1, 2])\r
- name = "one a non-empty proper subset of other"\r
- cases = "!=", "<", "<="\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestSubsetNonOverlap(TestSubsets):\r
- left = Set([1])\r
- right = Set([2])\r
- name = "neither empty, neither contains"\r
- cases = "!="\r
-\r
-#==============================================================================\r
-\r
-class TestOnlySetsInBinaryOps(unittest.TestCase):\r
-\r
- def test_eq_ne(self):\r
- # Unlike the others, this is testing that == and != *are* allowed.\r
- self.assertEqual(self.other == self.set, False)\r
- self.assertEqual(self.set == self.other, False)\r
- self.assertEqual(self.other != self.set, True)\r
- self.assertEqual(self.set != self.other, True)\r
-\r
- def test_ge_gt_le_lt(self):\r
- self.assertRaises(TypeError, lambda: self.set < self.other)\r
- self.assertRaises(TypeError, lambda: self.set <= self.other)\r
- self.assertRaises(TypeError, lambda: self.set > self.other)\r
- self.assertRaises(TypeError, lambda: self.set >= self.other)\r
-\r
- self.assertRaises(TypeError, lambda: self.other < self.set)\r
- self.assertRaises(TypeError, lambda: self.other <= self.set)\r
- self.assertRaises(TypeError, lambda: self.other > self.set)\r
- self.assertRaises(TypeError, lambda: self.other >= self.set)\r
-\r
- def test_union_update_operator(self):\r
- try:\r
- self.set |= self.other\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("expected TypeError")\r
-\r
- def test_union_update(self):\r
- if self.otherIsIterable:\r
- self.set.union_update(self.other)\r
- else:\r
- self.assertRaises(TypeError, self.set.union_update, self.other)\r
-\r
- def test_union(self):\r
- self.assertRaises(TypeError, lambda: self.set | self.other)\r
- self.assertRaises(TypeError, lambda: self.other | self.set)\r
- if self.otherIsIterable:\r
- self.set.union(self.other)\r
- else:\r
- self.assertRaises(TypeError, self.set.union, self.other)\r
-\r
- def test_intersection_update_operator(self):\r
- try:\r
- self.set &= self.other\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("expected TypeError")\r
-\r
- def test_intersection_update(self):\r
- if self.otherIsIterable:\r
- self.set.intersection_update(self.other)\r
- else:\r
- self.assertRaises(TypeError,\r
- self.set.intersection_update,\r
- self.other)\r
-\r
- def test_intersection(self):\r
- self.assertRaises(TypeError, lambda: self.set & self.other)\r
- self.assertRaises(TypeError, lambda: self.other & self.set)\r
- if self.otherIsIterable:\r
- self.set.intersection(self.other)\r
- else:\r
- self.assertRaises(TypeError, self.set.intersection, self.other)\r
-\r
- def test_sym_difference_update_operator(self):\r
- try:\r
- self.set ^= self.other\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("expected TypeError")\r
-\r
- def test_sym_difference_update(self):\r
- if self.otherIsIterable:\r
- self.set.symmetric_difference_update(self.other)\r
- else:\r
- self.assertRaises(TypeError,\r
- self.set.symmetric_difference_update,\r
- self.other)\r
-\r
- def test_sym_difference(self):\r
- self.assertRaises(TypeError, lambda: self.set ^ self.other)\r
- self.assertRaises(TypeError, lambda: self.other ^ self.set)\r
- if self.otherIsIterable:\r
- self.set.symmetric_difference(self.other)\r
- else:\r
- self.assertRaises(TypeError, self.set.symmetric_difference, self.other)\r
-\r
- def test_difference_update_operator(self):\r
- try:\r
- self.set -= self.other\r
- except TypeError:\r
- pass\r
- else:\r
- self.fail("expected TypeError")\r
-\r
- def test_difference_update(self):\r
- if self.otherIsIterable:\r
- self.set.difference_update(self.other)\r
- else:\r
- self.assertRaises(TypeError,\r
- self.set.difference_update,\r
- self.other)\r
-\r
- def test_difference(self):\r
- self.assertRaises(TypeError, lambda: self.set - self.other)\r
- self.assertRaises(TypeError, lambda: self.other - self.set)\r
- if self.otherIsIterable:\r
- self.set.difference(self.other)\r
- else:\r
- self.assertRaises(TypeError, self.set.difference, self.other)\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestOnlySetsNumeric(TestOnlySetsInBinaryOps):\r
- def setUp(self):\r
- self.set = Set((1, 2, 3))\r
- self.other = 19\r
- self.otherIsIterable = False\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestOnlySetsDict(TestOnlySetsInBinaryOps):\r
- def setUp(self):\r
- self.set = Set((1, 2, 3))\r
- self.other = {1:2, 3:4}\r
- self.otherIsIterable = True\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestOnlySetsOperator(TestOnlySetsInBinaryOps):\r
- def setUp(self):\r
- self.set = Set((1, 2, 3))\r
- self.other = operator.add\r
- self.otherIsIterable = False\r
-\r
- def test_ge_gt_le_lt(self):\r
- with test_support.check_py3k_warnings():\r
- super(TestOnlySetsOperator, self).test_ge_gt_le_lt()\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestOnlySetsTuple(TestOnlySetsInBinaryOps):\r
- def setUp(self):\r
- self.set = Set((1, 2, 3))\r
- self.other = (2, 4, 6)\r
- self.otherIsIterable = True\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestOnlySetsString(TestOnlySetsInBinaryOps):\r
- def setUp(self):\r
- self.set = Set((1, 2, 3))\r
- self.other = 'abc'\r
- self.otherIsIterable = True\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestOnlySetsGenerator(TestOnlySetsInBinaryOps):\r
- def setUp(self):\r
- def gen():\r
- for i in xrange(0, 10, 2):\r
- yield i\r
- self.set = Set((1, 2, 3))\r
- self.other = gen()\r
- self.otherIsIterable = True\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestOnlySetsofSets(TestOnlySetsInBinaryOps):\r
- def setUp(self):\r
- self.set = Set((1, 2, 3))\r
- self.other = [Set('ab'), ImmutableSet('cd')]\r
- self.otherIsIterable = True\r
-\r
-#==============================================================================\r
-\r
-class TestCopying(unittest.TestCase):\r
-\r
- def test_copy(self):\r
- dup = self.set.copy()\r
- self.assertEqual(len(dup), len(self.set))\r
- dup_list = sorted(dup)\r
- set_list = sorted(self.set)\r
- self.assertEqual(len(dup_list), len(set_list))\r
- for i, el in enumerate(dup_list):\r
- self.assertIs(el, set_list[i])\r
-\r
- def test_deep_copy(self):\r
- dup = copy.deepcopy(self.set)\r
- self.assertSetEqual(dup, self.set)\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestCopyingEmpty(TestCopying):\r
- def setUp(self):\r
- self.set = Set()\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestCopyingSingleton(TestCopying):\r
- def setUp(self):\r
- self.set = Set(["hello"])\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestCopyingTriple(TestCopying):\r
- def setUp(self):\r
- self.set = Set(["zero", 0, None])\r
-\r
- def test_copy(self):\r
- with test_support.check_py3k_warnings():\r
- super(TestCopyingTriple, self).test_copy()\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestCopyingTuple(TestCopying):\r
- def setUp(self):\r
- self.set = Set([(1, 2)])\r
-\r
-#------------------------------------------------------------------------------\r
-\r
-class TestCopyingNested(TestCopying):\r
- def setUp(self):\r
- self.set = Set([((1, 2), (3, 4))])\r
-\r
-#==============================================================================\r
-\r
-class TestIdentities(unittest.TestCase):\r
- def setUp(self):\r
- self.a = Set([random.randrange(100) for i in xrange(50)])\r
- self.b = Set([random.randrange(100) for i in xrange(50)])\r
-\r
- def test_binopsVsSubsets(self):\r
- a, b = self.a, self.b\r
- self.assertTrue(a - b <= a)\r
- self.assertTrue(b - a <= b)\r
- self.assertTrue(a & b <= a)\r
- self.assertTrue(a & b <= b)\r
- self.assertTrue(a | b >= a)\r
- self.assertTrue(a | b >= b)\r
- self.assertTrue(a ^ b <= a | b)\r
-\r
- def test_commutativity(self):\r
- a, b = self.a, self.b\r
- self.assertEqual(a&b, b&a)\r
- self.assertEqual(a|b, b|a)\r
- self.assertEqual(a^b, b^a)\r
- if a != b:\r
- self.assertNotEqual(a-b, b-a)\r
-\r
- def test_reflexsive_relations(self):\r
- a, zero = self.a, Set()\r
- self.assertEqual(a ^ a, zero)\r
- self.assertEqual(a - a, zero)\r
- self.assertEqual(a | a, a)\r
- self.assertEqual(a & a, a)\r
- self.assertTrue(a <= a)\r
- self.assertTrue(a >= a)\r
- self.assertTrue(a == a)\r
-\r
- def test_summations(self):\r
- # check that sums of parts equal the whole\r
- a, b = self.a, self.b\r
- self.assertEqual((a-b)|(a&b)|(b-a), a|b)\r
- self.assertEqual((a&b)|(a^b), a|b)\r
- self.assertEqual(a|(b-a), a|b)\r
- self.assertEqual((a-b)|b, a|b)\r
- self.assertEqual((a-b)|(a&b), a)\r
- self.assertEqual((b-a)|(a&b), b)\r
- self.assertEqual((a-b)|(b-a), a^b)\r
-\r
- def test_exclusion(self):\r
- # check that inverse operations do not overlap\r
- a, b, zero = self.a, self.b, Set()\r
- self.assertEqual((a-b)&b, zero)\r
- self.assertEqual((b-a)&a, zero)\r
- self.assertEqual((a&b)&(a^b), zero)\r
-\r
- def test_cardinality_relations(self):\r
- a, b = self.a, self.b\r
- self.assertEqual(len(a), len(a-b) + len(a&b))\r
- self.assertEqual(len(b), len(b-a) + len(a&b))\r
- self.assertEqual(len(a^b), len(a-b) + len(b-a))\r
- self.assertEqual(len(a|b), len(a-b) + len(a&b) + len(b-a))\r
- self.assertEqual(len(a^b) + len(a&b), len(a|b))\r
-\r
-#==============================================================================\r
-\r
-libreftest = """\r
-Example from the Library Reference: Doc/lib/libsets.tex\r
-\r
->>> from sets import Set as Base # override _repr to get sorted output\r
->>> class Set(Base):\r
-... def _repr(self):\r
-... return Base._repr(self, sorted=True)\r
->>> engineers = Set(['John', 'Jane', 'Jack', 'Janice'])\r
->>> programmers = Set(['Jack', 'Sam', 'Susan', 'Janice'])\r
->>> managers = Set(['Jane', 'Jack', 'Susan', 'Zack'])\r
->>> employees = engineers | programmers | managers # union\r
->>> engineering_management = engineers & managers # intersection\r
->>> fulltime_management = managers - engineers - programmers # difference\r
->>> engineers.add('Marvin')\r
->>> print engineers\r
-Set(['Jack', 'Jane', 'Janice', 'John', 'Marvin'])\r
->>> employees.issuperset(engineers) # superset test\r
-False\r
->>> employees.union_update(engineers) # update from another set\r
->>> employees.issuperset(engineers)\r
-True\r
->>> for group in [engineers, programmers, managers, employees]:\r
-... group.discard('Susan') # unconditionally remove element\r
-... print group\r
-...\r
-Set(['Jack', 'Jane', 'Janice', 'John', 'Marvin'])\r
-Set(['Jack', 'Janice', 'Sam'])\r
-Set(['Jack', 'Jane', 'Zack'])\r
-Set(['Jack', 'Jane', 'Janice', 'John', 'Marvin', 'Sam', 'Zack'])\r
-"""\r
-\r
-#==============================================================================\r
-\r
-__test__ = {'libreftest' : libreftest}\r
-\r
-def test_main(verbose=None):\r
- import doctest\r
- from test import test_sets\r
- test_support.run_unittest(\r
- TestSetOfSets,\r
- TestExceptionPropagation,\r
- TestBasicOpsEmpty,\r
- TestBasicOpsSingleton,\r
- TestBasicOpsTuple,\r
- TestBasicOpsTriple,\r
- TestBinaryOps,\r
- TestUpdateOps,\r
- TestMutate,\r
- TestSubsetEqualEmpty,\r
- TestSubsetEqualNonEmpty,\r
- TestSubsetEmptyNonEmpty,\r
- TestSubsetPartial,\r
- TestSubsetNonOverlap,\r
- TestOnlySetsNumeric,\r
- TestOnlySetsDict,\r
- TestOnlySetsOperator,\r
- TestOnlySetsTuple,\r
- TestOnlySetsString,\r
- TestOnlySetsGenerator,\r
- TestOnlySetsofSets,\r
- TestCopyingEmpty,\r
- TestCopyingSingleton,\r
- TestCopyingTriple,\r
- TestCopyingTuple,\r
- TestCopyingNested,\r
- TestIdentities,\r
- doctest.DocTestSuite(test_sets),\r
- )\r
-\r
-if __name__ == "__main__":\r
- test_main(verbose=True)\r
projects / mirror_edk2.git / blobdiff