def __init__(self, capacity=16, source=None): """Construct.""" if source is not None: self._hash_map = hash_map.HashMap( capacity, ((element, PRESENT) for element in source) ) else: self._hash_map = hash_map.HashMap(capacity)
def test_construct_capacity(capacity, raises): """ GIVEN initial capacity and whether ValueError should be raised WHEN a HashMap is constructed with the capacity THEN ValueError is raised when expected raises is True. """ if raises: with pytest.raises(ValueError): hash_map.HashMap(capacity) else: hash_map.HashMap(capacity)
def mocked_buckets_hash_map(): """HashMap with mocked buckets and _calculate_index.""" capacity = 16 test_hash_map = hash_map.HashMap(capacity) for idx in range(capacity): test_hash_map._buckets[idx] = mock.MagicMock() test_hash_map._calculate_index = mock.MagicMock() return test_hash_map
def test_delete_missing(): """ GIVEN empty hash map WHEN delete is called with a key THEN KeyError is raised. """ test_hash_map = hash_map.HashMap() with pytest.raises(KeyError): test_hash_map.delete("key 1")
def test_set_get_missing(): """ GIVEN empty hash map WHEN get is called with a key THEN KeyError is raised. """ test_hash_map = hash_map.HashMap() with pytest.raises(KeyError): test_hash_map.get("key 1")
def test_exists_missing(): """ GIVEN empty hash map WHEN exists is called with a key THEN False is returned. """ test_hash_map = hash_map.HashMap() exists = test_hash_map.exists("key 1") assert exists is False
def test_size(actions, expected_size): """ GIVEN empty hash map, actions to modify the hash map and expected size WHEN the actions are performed on the map THEN the map has the expected size. """ test_hash_map = hash_map.HashMap() for operation, args in actions: getattr(test_hash_map, operation)(*args) assert test_hash_map.size == expected_size
def test_clone_capacity_copied(): """ GIVEN empty hash map and capacity of the hash map WHEN hash map is cloned THEN the cloned map has the same capacity. """ capacity = 16 test_hash_map = hash_map.HashMap(capacity) cloned_hash_map = test_hash_map.clone() assert cloned_hash_map.capacity == capacity
def test_calculate_index(key, capacity, expected_index): """ GIVEN key, capacity of HashMap and expected index WHEN HashMap is constructed with the capacity and _calculate_index is called with the key THEN the expected index is returned. """ test_hash_map = hash_map.HashMap(capacity) index = test_hash_map._calculate_index(key) assert index == expected_index
def test_construct_source(elements): """ GIVEN list of key value tuples WHEN hash map is constructed with list as source THEN map contains each element in the list. """ test_hash_map = hash_map.HashMap(source=elements) element_set = set(iter(test_hash_map)) assert len(element_set) == len(elements) for element in elements: assert element in element_set
def test_size_delete_raises(): """ GIVEN hash map with a single element WHEN delete is called with a different key than the element THEN size is not decremented. """ test_hash_map = hash_map.HashMap() test_hash_map.set_("key 1", "value 1") with pytest.raises(KeyError): test_hash_map.delete("key 2") assert test_hash_map.size == 1
def test_delete_present(): """ GIVEN empty hash map and key and value WHEN set is called with the key and value and delete is called with the key THEN the key no longer exists in the hash map. """ test_hash_map = hash_map.HashMap() key = "key 1" test_hash_map.set_(key, "value 1") test_hash_map.delete(key) assert test_hash_map.exists(key) is False
def test_exists_present(): """ GIVEN empty hash map and key and value WHEN set is called with the key and value and exists is called with the key THEN True is returned. """ test_hash_map = hash_map.HashMap() key = "key 1" test_hash_map.set_(key, "value 1") exists = test_hash_map.exists(key) assert exists is True
def test_clone_elements(elements): """ GIVEN empty hash map and elements to add to it WHEN hash map is constructed with list as source and cloned THEN cloned map contains each element in the list. """ test_hash_map = hash_map.HashMap(source=elements) cloned_hash_map = test_hash_map.clone() element_set = set(iter(cloned_hash_map)) assert len(element_set) == len(elements) for element in elements: assert element in element_set
def test_iterate(elements): """ GIVEN empty hash map and elements to set WHEN elements are set and the map is iterated over THEN all elements are returned. """ test_hash_map = hash_map.HashMap() for element in elements: test_hash_map.set_(*element) element_set = set(iter(test_hash_map)) assert len(element_set) == len(elements) for element in elements: assert element in element_set
def test_clear(elements): """ GIVEN empty hash map and elements to set WHEN elements are set and clear is called THEN the map has zero size and iterating over it returns an empty list. """ test_hash_map = hash_map.HashMap() for element in elements: test_hash_map.set_(*element) test_hash_map.clear() assert test_hash_map.size == 0 assert list(iter(test_hash_map)) == []
def test_set_get(): """ GIVEN empty hash map and key and value WHEN set is called with the key and value and get is called with the key THEN the value is returned. """ test_hash_map = hash_map.HashMap() key = "key 1" value = "value 1" test_hash_map.set_(key, value) return_value = test_hash_map.get(key) assert return_value == value
def test_clone_not_same(): """ GIVEN empty hash map WHEN hash map is cloned THEN the cloned map is not the same object and contains different buckets. """ test_hash_map = hash_map.HashMap() cloned_hash_map = test_hash_map.clone() assert id(cloned_hash_map) != id(test_hash_map) for original_bucket, cloned_bucket in zip( test_hash_map._buckets, cloned_hash_map._buckets ): assert id(original_bucket) != id(cloned_bucket)
def test_resize_down(initial_capacity, initial_size, expected_capacity): """ GIVEN empty hash map, initial capacity, initial number of elements and expected capacity WHEN the initial size is added to the map and then one is removed THEN the capacity is the expected final capacity and all key value pairs except the removed pair are still in the map. """ elements = [(f"key {idx + 1}", f"value {idx + 1}") for idx in range(initial_size)] test_hash_map = hash_map.HashMap(initial_capacity, elements) test_hash_map.delete(elements[-1][0]) assert test_hash_map.capacity == expected_capacity assert len(test_hash_map._buckets) == expected_capacity assert test_hash_map.size == initial_size - 1 element_set = set(iter(test_hash_map)) assert len(element_set) == len(elements[:-1]) for element in elements[:-1]: assert element in element_set
def test_resize_up(initial_capacity, initial_size, expected_capacity): """ GIVEN empty hash map, initial capacity, initial number of elements and expected capacity WHEN the initial size plus one key and value is added to the map THEN the capacity is the expected final capacity and all added key value pairs are still in the map. """ elements = [ (f"key {idx + 1}", f"value {idx + 1}") for idx in range(initial_size + 1) ] test_hash_map = hash_map.HashMap(initial_capacity, elements) assert test_hash_map.capacity == expected_capacity assert len(test_hash_map._buckets) == expected_capacity assert test_hash_map.size == initial_size + 1 element_set = set(iter(test_hash_map)) assert len(element_set) == len(elements) for element in elements: assert element in element_set