def test_pop(self):
test = Set([1, 2, 3, "a", "b", "c"])
testOther = Set([1, 2, 3, "a", "b", "c"])
testOther.remove(test.pop())
self.assertEqual(test, testOther)
def test_pop_not_equal(self):
test = Set([1, 2, 3, "a", "b", "c"])
testOther = Set([1, 2, 3, "a", "b", "c"])
test.pop()
self.assertNotEqual(test, testOther)
def test_discard_items_not_in_set(self):
test = Set([1, 2, 3, "a", "b", "c"])
testOther = Set([1, 2, 3, "a", "b", "c"])
test.discard("d")
test.discard(0)
test.discard("e")
self.assertEqual(test, testOther)
def test_discard_items_in_set(self):
test = Set([1, 2, 3, "a", "b", "c"])
testOther = Set([3, "a", "c"])
test.discard(1)
test.discard(2)
test.discard("b")
self.assertEqual(test, testOther)
def test_discard_items_at_back(self):
test = Set([1, 2, 3, "a", "b", "c"])
testOther = Set([1, 2, 3])
test.discard("c")
test.discard("b")
test.discard("a")
self.assertEqual(test, testOther)
def test_remove_items_in_set(self):
test = Set([1, 2, 3, "a", "b", "c"])
testOther = Set([3, "a", "c"])
test.remove(1)
test.remove(2)
test.remove("b")
self.assertEqual(test, testOther)
def test_contains_doesnt_modify(self):
# Create two equal sets...
large_set1 = Set(range(100))
large_set2 = Set(range(100))
# Call contains on the first.
for i in range(100):
i in large_set1
'z' in large_set1
# Make sure they are still equal. THIS TESTS REQUIRES
# THAT THE EQUAL METHOD HAS BEEN FINISHED.
self.assertEqual(large_set1, large_set2)
def test_copy_is_shallow(self):
the_list = [1, 2, 3]
set1 = Set([the_list])
set1_copy = set1.copy()
the_list[0] = -1
same_list = set1_copy.pop()
self.assertEqual(the_list[0], same_list[0])
def test_contains_In(self):
# Make a set containing the ints 0-99...
large_set = Set(range(100))
# Make sure each one is in the set...
for i in range(100):
self.assertTrue(i in large_set)
def test_pop_element(self):
test = Set([1, 2, 3, "a", "b", "c"])
elem = test.pop()
self.assertRaises(KeyError, test.remove, elem)
def test_remove_items_in_set_already_removed(self):
test = Set([1, 2, 3, "a", "b", "c"])
test.remove(1)
test.remove(2)
test.remove("c")
self.assertRaises(KeyError, test.remove, "c")
def test_iterator_non_empty(self):
set1 = Set([1, 2, 3, "a", "b", "c"])
py_set1 = set([1, 2, 3, "a", "b", "c"])
visited = []
for item in set1:
visited.append(item)
self.assertEqual(py_set1, set(visited))
self.assertEqual(len(py_set1), len(visited))
def test_iterator_directly(self):
set1 = Set([1, 2, 3, "a", "b", "c"])
py_set1 = set([1, 2, 3, "a", "b", "c"])
visited = []
it = iter(set1)
for item in it:
visited.append(item)
self.assertEqual(py_set1, set(visited))
self.assertEqual(len(py_set1), len(visited))
def test_str_non_empty(self):
# This test takes advantage of the fact that our string
# representation is exactly the same as the python set.
set1 = Set(["a", "b", "c", 1, 2, 3])
py_set1 = set(["a", "b", "c", 1, 2, 3])
py_set2 = eval(str(set1))
self.assertEqual(py_set1, py_set2)
py_set2 = eval(repr(set1))
self.assertEqual(py_set1, py_set2)
def test_add_several_equal_items(self):
num_items = 100
items = range(num_items)
# Add them once
for i in items:
self.test_set.add(i)
# Add them again
for i in items:
self.test_set.add(i)
self.assertEqual(len(self.test_set), num_items)
self.assertEqual(self.test_set, Set(range(num_items)))
def test_symmetric_difference_op_empty_Empty(self):
result = Set() ^ Set()
self.assertEqual(result, Set())
def test_pop_empty_set(self):
test = Set()
self.assertRaises(KeyError, test.pop)
def test_symmetric_difference_op_equal(self):
set1, set2 = self._make_equal_sets()
result = set1 ^ set2
self.assertEqual(result, Set())
def test_symmetric_difference_op_empty_non_Empty(self):
set1 = Set([1, 2, 3])
equalSet1 = Set([1, 2, 3])
result = Set() ^ set1
self.assertEqual(result, equalSet1)
def test_contains_not_In(self):
large_set = Set([1, 2, 3, "a", "b", "c"])
self.assertFalse("z" in large_set)
def test_remove_empty_set(self):
test = Set()
self.assertRaises(KeyError, test.remove, 1)
def test_remove_items_not_in_set(self):
test = Set([1, 2, 3, "a", "b", "c"])
self.assertRaises(KeyError, test.remove, "d")
self.assertRaises(KeyError, test.remove, 5)
def test_symmetric_difference_op_subset(self):
set1, set2 = self._make_strict_subsets()
correct_result = \
Set(set(set1).symmetric_difference(set(set2)))
result = set1 ^ set2
self.assertEqual(result, correct_result)
def test_copy_empty(self):
set1 = Set()
set1_copy = set1.copy()
self.assertEqual(set1, set1_copy)
def test_symmetric_difference_op_intersecting(self):
set1, set2 = self._make_intersecting_sets()
correct_result = \
Set(set(set2).symmetric_difference(set(set1)))
result = set2 ^ set1
self.assertEqual(result, correct_result)
def test_copy_non_empty(self):
set1 = Set([1, 2, 3, "a", "b", "c"])
set1_copy = set1.copy()
self.assertEqual(set1, set1_copy)
def test_copy_not_alias(self):
set1 = Set([1, 2, 3, "a", "b", "c"])
set1_copy = set1.copy()
self.assertIsNot(set1, set1_copy)
def test_copy_no_array_alias(self):
set1 = Set([1, 2, 3, "a", "b", "c"])
set1_copy = set1.copy()
set1.pop()
self.assertNotEqual(set1, set1_copy)
def test_str_empty(self):
self.assertEqual(str(Set()), 'set([])')
self.assertEqual(repr(Set()), 'set([])')
def test_symmetric_difference_disjoint(self):
set1, set2 = self._make_disjoint_sets()
correct_result = \
Set(set(set2).symmetric_difference(set(set1)))
result = set2.symmetric_difference(set1)
self.assertEqual(result, correct_result)
