def test_hash_two_letter_key():
size = 8
char = "ab"
h = HashTable(size)
assert h.hash(char) == (
sum([ord(c) for c in char]) % size
)
def test_set_one_letter_key():
size = 8
chars = "habcdefg"
h = HashTable(size)
for c in chars:
h.set(c, 63)
assert h.table == [[(letter, 63)] for letter in chars]
def test_hash_on_valid_key(self):
"""Verify that a string key hashes to the expected value. Somewhat
tautological.
"""
h = HashTable()
hashed = h.hash(self.valid_key)
expected = sum([ord(i) for i in list(self.valid_key)]) % 16
self.assertEqual(hashed, expected)
def test_delete_entry(self):
my_hash_table = HashTable()
my_hash_table.add_entry("key1", "value1")
my_hash_table.add_entry("key2", "value2")
my_hash_table.add_entry("key3", "value3")
my_hash_table.delete_entry_by_key("key2")
self.assertEqual(my_hash_table.current_items_count, 2)
with self.assertRaises(KeyError):
my_hash_table.get_value_by_key("key2")
def test_get_one_letter_key():
size = 8
chars = "habcdefg"
h = HashTable(size)
for c in chars:
h.set(c, 63)
h.set('i', 8)
h.set('r', 15)
assert h.get('r') == 15
assert h.get('i') == 8
assert h.get('c') == 63
def test_get_key_not_exist(self):
my_hash_table = HashTable()
with self.assertRaises(KeyError):
my_hash_table.get_value_by_key("key1")
my_hash_table.add_entry("key1", "value1")
with self.assertRaises(KeyError):
my_hash_table.get_value_by_key("key2")
def test_add_multiple_elements(self):
my_hash_table = HashTable()
my_hash_table.add_entry("key1", "value1")
my_hash_table.add_entry("key2", "value2")
my_hash_table.add_entry("key3", "value3")
self.assertEqual(my_hash_table.current_items_count, 3)
self.assertEqual(my_hash_table.get_value_by_key("key1"), "value1")
self.assertEqual(my_hash_table.get_value_by_key("key2"), "value2")
self.assertEqual(my_hash_table.get_value_by_key("key3"), "value3")
def test_set_on_existing_key(self):
"""Set a value using a key that already exists."""
h = HashTable()
h.set(self.present_pair[0], self.present_pair[1])
self.assertEqual(self.present_pair[1], h.get(self.present_pair[0]))
h.set(self.overwrite_pair[0], self.overwrite_pair[1])
self.assertEqual(self.overwrite_pair[1], h.get(self.overwrite_pair[0]))
class HashTableTest(unittest.TestCase):
def setUp(self):
self.hash_table = HashTable(8)
def test_hash_function(self):
hash_value = self.hash_table._hash_function('abc')
self.assertEquals(hash_value, 297)
def test_set_and_set(self):
self.hash_table.set('key', 'value')
value = self.hash_table.get('key')
self.assertEquals(value, 'value')
def test_remove(self):
self.hash_table.set('key', 'value')
self.hash_table.remove('key')
with self.assertRaises(ValueError):
self.hash_table.get('key')
def test_update_existing_element(self):
my_hash_table = HashTable()
my_hash_table.add_entry("key1", "value1")
my_hash_table.add_entry("key2", "value2")
my_hash_table.add_entry("key2", "newValue2")
self.assertEqual(my_hash_table.current_items_count, 2)
self.assertEqual(my_hash_table.get_value_by_key("key2"), "newValue2")
def test_set_on_slot_with_collisions(self):
"""Set a value using a key that hashes to a bin already containing
other keys.
"""
h = HashTable()
h.set(self.present_pair[0], self.present_pair[1])
h.set(self.colliding_pair[0], self.colliding_pair[1])
self.assertEqual(self.present_pair[1], h.get(self.present_pair[0]))
self.assertEqual(self.colliding_pair[1], h.get(self.colliding_pair[0]))
def test_get_from_hash_with_collisions(self):
"""Get a value from a hash using a key that collides with another
key in the hash.
"""
h = HashTable()
for key, val in self.pairs.items():
h.set(key, val)
h.set(self.colliding_pair[0], self.colliding_pair[1])
self.assertEqual(self.present_pair[1], h.get(self.present_pair[0]))
self.assertEqual(self.colliding_pair[1], h.get(self.colliding_pair[0]))
def test_set_key_overwrite():
ht = HashTable()
ht.set('key', 1)
assert ht.get('key') == 1
ht.set('key', 2)
assert ht.get('key') == 2
def test_number_strings(n):
ht = HashTable()
ht.set(str(n), n)
assert ht.get(str(n)) == n
def test_non_string_key():
ht = HashTable()
with pytest.raises(TypeError):
ht.set(6, 5)
with pytest.raises(TypeError):
ht.get(6)
def test_nonexistent_key():
ht = HashTable()
with pytest.raises(KeyError):
ht.get('key')
def test_add_first_to_empty_table(self):
my_hash_table = HashTable()
my_hash_table.add_entry("key1", "value1")
self.assertEqual(my_hash_table.current_items_count, 1)
self.assertEqual(my_hash_table.get_value_by_key("key1"), "value1")
def setUp(self):
self.hash_table = HashTable(8)
def test_hash_one_letter_key():
size = 8
char = "a"
h = HashTable(size)
assert h.hash(char) == (ord(char) % size)
def test_collision(self):
my_ht = HashTable(11)
my_ht.set('puck', 20)
my_ht.set('uckp', 30)
self.assertEqual(30, my_ht.get('uckp'))
def test_words(words):
ht = HashTable()
for k, v in words.items():
ht.set(k, v)
for k, v in words.items():
assert ht.get(k) == v
def test_key_reuse(self):
my_ht = HashTable(11)
my_ht.set('puck', 20)
self.assertEqual('key already in use', my_ht.set('puck', 30))
def test_set_on_empty_slot(self):
"""Set a value using a key that hashes to an empty bin."""
h = HashTable()
h.set(self.present_pair[0], self.present_pair[1])
self.assertEqual(self.present_pair[1], h.get(self.present_pair[0]))
def test_get_nonstring(self):
my_ht = HashTable(11)
self.assertEqual('key must be a string!', my_ht.get(4))
def test_multiple_sets():
size = 8
chars = "habcdefg"
h = HashTable(size)
for c in chars:
h.set(c, 63)
h.set('i', 80)
h.set('r', 15)
h.set('i', 9)
h.set('i', 10)
h.set('i', 14)
assert h.get('i') == 14
def test_nonkey(self):
my_ht = HashTable(11)
my_ht.set('puck', 20)
self.assertEqual('key is not in table', my_ht.get('python'))
def test_set_all_words():
wordlist = _make_wordlist()
h = HashTable(256)
for ind, word in enumerate(wordlist):
h.set(word[:-1], word[:-1])
assert h.get('zoom') == 'zoom'
def test_set_to_empty(self):
my_ht = HashTable(11)
my_ht.set('puck', 20)
self.assertEqual(20, my_ht.get('puck'))
def test_get_from_hash_containing_value(self):
"""Get a value from a hash using a key which it contains."""
h = HashTable()
for key, val in self.pairs.items():
h.set(key, val)
self.assertEqual(self.present_pair[1], h.get(self.present_pair[0]))
