def final_test(self):
map = HashMap()
map[1] = 100
map[5] = 500
map[20] = 5
map["Hello"] = "Goodbye"
assert (map.exists("Hello"))
assert (map["Hello"]) == "Goodbye"
map.delete("Hello")
assert (map["Hello"]) == None
class LRUCache:
def __init__(self, cache_size):
self.map = HashMap()
self.store = LinkedList()
self.cache_size = cache_size
def count(self):
return len(self.map)
def __getitem__(self, key):
if self.map[key]:
node = self.map[key]
self.update_node(
node
) # Because this is now the most recently seen object. i.e. keep it in cache
return node.val
return False
def __str__(self):
return 'Map: ' + str(self.map) + '\n' + 'Store: ' + str(self.store)
def __setitem__(self, key, val):
if key in self.map:
self.map[key].val = val
self.update_node(self.map[key])
else:
new_node = self.store.append(key, val)
self.map[key] = new_node
if self.count() > self.cache_size:
self.eject()
return val
def update_node(self, node):
node.remove()
self.store.append(node.key, node.val)
def eject(self):
rm_node = self.store.first()
rm_node.remove()
self.map.delete(rm_node.key)
def test_hash_map():
hash_map = HashMap(2)
# Test HashMap get and put
key = "abcde"
value = "ramiz"
hash_map.put(key, value)
output = hash_map.get(key)
assert_(value, output)
# Test size
assert_(1, hash_map.size())
# delete
hash_map.delete("abcde")
assert_(0, hash_map.size())
# Test Rehash
hash_map.put("mine", "mine")
# this should trigger rehashing
hash_map.put("hi", "hi")
assert_(2, hash_map.size())
print("All Tests Passed!")
def test_delete(self):
hash = HashMap()
hash[1] = 100
hash[2] = 200
hash[3.1] = 64
assert (hash[1]) == 100
assert (hash[2]) == 200
assert (hash[3.1]) == 64
assert (hash.data_count) == 3
hash.delete(2)
hash.delete(3.1)
assert (hash[2]) == None
assert (hash[3.1]) == None
assert (hash.data_count) == 1
# Deleting key not in hash should not decrement data count
hash.delete(555)
assert (hash.data_count) == 1
class HashMapTests(unittest.TestCase, DictTestCases):
def setUp(self):
self.uut = HashMap()
def mock_hashes_to(self, index=0):
class Mock(object):
def __hash__(self):
return index
def __str__(self):
return "mock(%s)" % index
__repr__ = __str__
return Mock()
def test_initial_current_capacity_is_16(self):
self.assertEqual(16, self.uut.capacity())
def test_initial_doubling_size_is_12(self):
self.assertEqual(12, self.uut.doubling_size())
def test_when_inialized_with_one_half_then_doubling_size_is_8(self):
uut = HashMap(0.5)
self.assertEqual(8, uut.doubling_size())
def test_initial_len_is_0(self):
self.assertEqual(0, len(self.uut))
def test_insertion_increses_size_to_1(self):
self.uut.insert(self.mock_hashes_to(), 42)
def test_collisions_are_handled(self):
first = self.mock_hashes_to(1)
second = self.mock_hashes_to(1)
self.uut.insert(first, "spam")
self.uut.insert(second, "eggs")
self.assertEqual("spam", self.uut.get(first))
self.assertEqual("eggs", self.uut.get(second))
def test_inserting_items_with_a_higher_value_works(self):
item = self.mock_hashes_to(99)
self.uut.insert(item, 42)
self.assertEqual(42, self.uut.get(item))
def test_when_at_doubling_size_then_the_capacity_doubles(self):
for i in xrange(11):
self.uut.insert(i, "_")
self.assertEqual(16, self.uut.capacity())
self.uut.insert(12, "_")
self.assertEqual(32, self.uut.capacity())
self.assertEqual(12, len(self.uut))
def test_len_is_0_after_delete_of_empty(self):
self.uut.delete("foo")
self.assertEqual(0, len(self.uut))
def test_len_is_0_after_delete_of_only_item(self):
self.uut.insert("foo", "_")
self.uut.delete("foo")
self.assertEqual(0, len(self.uut))
def test_len_is_0_after_delete_of_only_item_twice(self):
self.uut.insert("foo", "_")
self.uut.delete("foo")
self.uut.delete("foo")
self.assertEqual(0, len(self.uut))
class TestHashMapMethods(unittest.TestCase):
def setUp(self):
self.hash = HashMap()
self.hash["first"] = 1
self.hash["second"] = 2
self.hash["third"] = 3
def test_get_gets_by_key(self):
self.assertEqual(self.hash["first"], 1)
self.assertEqual(self.hash["second"], 2)
self.assertEqual(self.hash["third"], 3)
def test_get_returns_none_for_absent_keys(self):
self.assertIsNone(self.hash["fourth"])
def test_set_sets_key_value_pair(self):
self.hash["fourth"] = 4
self.assertIsNone(self.hash[4])
self.assertEqual(self.hash["fourth"], 4)
def test_set_overwrites_value(self):
self.hash["one"] = 1
self.hash["one"] = "one"
self.assertEqual(self.hash["one"], "one")
def test_set_works_with_various_data_types(self):
self.hash["fourth"] = 4
self.hash[5] = 5
self.assertEqual(self.hash["fourth"], 4)
self.assertEqual(self.hash[5], 5)
def test_include(self):
self.assertTrue(self.hash.include("first"))
self.assertFalse(self.hash.include("fourth"))
def test_delete(self):
self.assertEqual(self.hash["first"], 1)
self.hash.delete("first")
self.assertIsNone(self.hash["first"])
def test_count_keeps_count_with_insertions(self):
self.assertEqual(self.hash.count, 3)
self.hash["fifth"] = 5
self.assertEqual(self.hash.count, 4)
def test_count_does_not_change_with_update(self):
self.hash["first"] = 2
self.assertEqual(self.hash.count, 3)
def test_count_keeps_count_with_deletions(self):
self.hash.delete("first")
self.assertEqual(self.hash.count, 2)
def test_resize_increases_length_of_store(self):
i = 10
while i < 17:
self.hash[i] = i + 1
i += 1
self.assertEqual(len(self.hash.store), 16)
def test_resize_rehashes_values(self):
contents = []
keys = ["first", "second", "third"]
for key in keys:
contents.append([key, self.hash[key]])
self.hash.resize()
for pair in contents:
key, val = pair
self.assertEqual(val, self.hash[key])
def test___str__(self):
expected_pairs = ["'first': 1", "'second': 2", "'third': 3"]
actual_pairs = str(self.hash).split(", ")
self.assertEqual(actual_pairs.sort(), expected_pairs.sort())
from hash_map import HashMap
# A basic demo of the methods in our hashmap class
hash_map = HashMap()
print "Welcome to a brief tutorial of our hashmap!\n"
print "At the beginning the hashmap is: " + str(hash_map)
hash_map["AAPL"] = 100
hash_map["GOOG"] = 200
hash_map["SP500"] = 175.75
print "After inserting our positions: " + str(hash_map)
hash_map["GOOG"] = 400
print "After doubling our number of shares in Google: " + str(hash_map)
hash_map.delete("AAPL")
print "After selling all of our shares in Apple: " + str(hash_map)
other_hash_map = HashMap()
other_hash_map["GOOG"] = 100
other_hash_map["DIS"] = 500
print "My friend recommends a different set of positions: " + str(
other_hash_map)
hash_map.update(other_hash_map)
print "Our positions after updating with friend's recommendations: " + str(
hash_map)
print "A list of tickers of our positions: " + str(hash_map.keys())
print "A list of the number of shares for each position: " + str(
hash_map.values())
class HashMapTests(unittest.TestCase):
def setUp(self):
self.hash_map = HashMap()
def tearDown(self):
self.hash_map = None
# test creation of empty hashmap
def test_create_hash_map(self):
self.assertTrue(self.hash_map.is_empty())
self.assertEqual(len(self.hash_map), 0)
# test insertion of key into hashmap and getter method
def test_can_insert_into_hash_map(self):
self.assertFalse(self.hash_map.has_key("test"))
self.hash_map["test"] = "testing"
self.assertTrue(self.hash_map.has_key("test"))
self.assertEqual(len(self.hash_map), 1)
self.assertEqual("testing", self.hash_map["test"])
# test updating of key that already exists in hashmap
def test_can_update_key_in_hash_map(self):
self.hash_map["test"] = "testing"
self.hash_map["test"] = "testing123"
self.assertEqual("testing123", self.hash_map["test"])
# test deleting of key in hashmap
def test_can_delete_key_in_hash_map(self):
self.hash_map["test"] = "testing"
self.hash_map.delete("test")
self.assertFalse(self.hash_map.has_key("test"))
self.assertIsNone(self.hash_map.get("test"))
# test that number of buckets grows after number of key/value pairs
# becomes greater than number of buckets
def test_hash_map_resize_after_insert(self):
self.assertEqual(8, self.hash_map.num_buckets())
i = 1
while i <= 9:
self.hash_map[i] = i
i += 1
self.assertEqual(16, self.hash_map.num_buckets())
# test that number of buckets shrinks after number of key/value pairs
# becomes less than one quarter of the number of buckets
def test_hash_map_shrink_after_delete(self):
i = 1
while i <= 9:
self.hash_map[i] = i
i += 1
while i > 0:
self.hash_map.delete(i)
i -= 1
self.assertEqual(8, self.hash_map.num_buckets())
# test that update method incorporates key/value pairs of another hashmap
def test_hash_map_updates_with_other_hash_map(self):
self.hash_map["test"] = "testing"
other_hash_map = HashMap()
other_hash_map["test"] = "testing123"
other_hash_map["another test"] = "another testing123"
self.hash_map.update(other_hash_map)
self.assertEqual("testing123", self.hash_map["test"])
self.assertEqual(["testing123", "another testing123"],
self.hash_map.values())
