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)