def setUp(self):
self.test_hash_table = HashTable()
self.test_hash_table.put(54, "cat")
self.test_hash_table.put(26, "dog")
self.test_hash_table.put(93, "lion")
self.test_hash_table.put(17, "tiger")
self.test_hash_table.put(77, "bird")
self.test_hash_table.put(31, "cow")
self.test_hash_table.put(44, "goat")
self.test_hash_table.put(55, "pig")
self.test_hash_table.put(20, "chicken")
def test_hash_returns_correct_result(self):
self.assertEqual(HashTable.hash_function(54, self.test_hash_table.size), 10)
self.assertEqual(HashTable.hash_function(26, self.test_hash_table.size), 4)
self.assertEqual(HashTable.hash_function(93, self.test_hash_table.size), 5)
self.assertEqual(HashTable.hash_function(17, self.test_hash_table.size), 6)
self.assertEqual(HashTable.hash_function(77, self.test_hash_table.size), 0)
self.assertEqual(HashTable.hash_function(31, self.test_hash_table.size), 9)
self.assertEqual(HashTable.hash_function(44, self.test_hash_table.size), 0)
self.assertEqual(HashTable.hash_function(55, self.test_hash_table.size), 0)
self.assertEqual(HashTable.hash_function(20, self.test_hash_table.size), 9)
def test_set_item_works_correct(self):
set_test_hash_table = HashTable()
set_test_hash_table[18] = "monkey"
self.assertEqual(set_test_hash_table[18], "monkey")
set_test_hash_table[54] = "elephant"
self.assertEqual(set_test_hash_table[54], "elephant")
set_test_hash_table[65] = "pigeon"
set_test_hash_table[65] = "crocodile"
self.assertEqual(set_test_hash_table[65], "crocodile")
class TestHashTable(unittest.TestCase):
def setUp(self):
self.hash_table = HashTable(4)
def tearDown(self):
self.hash_table = None
def test_create_table(self):
self.assertTrue(self.hash_table.table == [[], [], [], []])
def test_remainder_method(self):
self.assertTrue(self.hash_table.remainder_method(30) == 2)
def test_mid_square_method(self):
self.assertTrue(self.hash_table.mid_square_method(55) == 2)
def test_hash_string(self):
self.assertTrue(self.hash_table.hash_string('abc') == 2)
def test_insert_with_linear_addressing(self):
self.hash_table .insert('abc')
self.assertTrue(self.hash_table.table[2] == ['abc'])
class TestHashTable(unittest.TestCase):
def setUp(self):
self.hash_table = HashTable(4)
def tearDown(self):
self.hash_table = None
def test_create_table(self):
self.assertTrue(self.hash_table.table == [[], [], [], []])
def test_remainder_method(self):
self.assertTrue(self.hash_table.remainder_method(30) == 2)
def test_mid_square_method(self):
self.assertTrue(self.hash_table.mid_square_method(55) == 2)
def test_hash_string(self):
self.assertTrue(self.hash_table.hash_string('abc') == 2)
def test_insert_with_linear_addressing(self):
self.hash_table.insert('abc')
self.assertTrue(self.hash_table.table[2] == ['abc'])
def test_init_works_correct(self):
self.assertEqual(HashTable().size, 11)
self.assertEqual(HashTable().slots, [None]*self.test_hash_table.size)
self.assertEqual(HashTable().data, [None]*self.test_hash_table.size)
def test_retrieving_based_on_a_key_returns_the_value_stored():
hash_table = HashTable()
hash_table.add('yahia','24')
assert hash_table.get('yahia') == '24'
def test_adding_a_key_and_value_to_hashtable():
hash_table = HashTable()
hash_table.add('yahia','24')
assert hash_table.get('yahia') == '24'
def test_hash_a_key_to_an_in_range_value():
hash_table = HashTable()
assert hash_table.hash('8000')< hash_table.size
def test_retrieve_a_value_from_a_bucket_within_the_hashtable_that_has_a_collision():
hash_table = HashTable()
hash_table.add('yahia','24')
hash_table.add('yaiha','30')
assert hash_table.get('yahia') == '24'
assert hash_table.get('yaiha') == '30'
def test_table_has_hash(): ht = HashTable() assert ht.hash
def test_multiple_insertions_get():
ht = HashTable()
ht.add('babies', 25)
ht.add('goats', 99)
assert ht.get('goats') == 99
def test_get_value_works():
ht = HashTable()
ht.add('babies', 25)
assert ht.get('babies') == 25
class HashTableTest(unittest.TestCase):
def setUp(self):
self.test_hash_table = HashTable()
self.test_hash_table.put(54, "cat")
self.test_hash_table.put(26, "dog")
self.test_hash_table.put(93, "lion")
self.test_hash_table.put(17, "tiger")
self.test_hash_table.put(77, "bird")
self.test_hash_table.put(31, "cow")
self.test_hash_table.put(44, "goat")
self.test_hash_table.put(55, "pig")
self.test_hash_table.put(20, "chicken")
def test_init_works_correct(self):
self.assertEqual(HashTable().size, 11)
self.assertEqual(HashTable().slots, [None]*self.test_hash_table.size)
self.assertEqual(HashTable().data, [None]*self.test_hash_table.size)
def test_hash_returns_correct_result(self):
self.assertEqual(HashTable.hash_function(54, self.test_hash_table.size), 10)
self.assertEqual(HashTable.hash_function(26, self.test_hash_table.size), 4)
self.assertEqual(HashTable.hash_function(93, self.test_hash_table.size), 5)
self.assertEqual(HashTable.hash_function(17, self.test_hash_table.size), 6)
self.assertEqual(HashTable.hash_function(77, self.test_hash_table.size), 0)
self.assertEqual(HashTable.hash_function(31, self.test_hash_table.size), 9)
self.assertEqual(HashTable.hash_function(44, self.test_hash_table.size), 0)
self.assertEqual(HashTable.hash_function(55, self.test_hash_table.size), 0)
self.assertEqual(HashTable.hash_function(20, self.test_hash_table.size), 9)
def test_rehash_returns_correct_result(self):
self.assertEqual(HashTable.rehash(0, self.test_hash_table.size), 1)
self.assertEqual(HashTable.rehash(5, self.test_hash_table.size), 6)
self.assertEqual(HashTable.rehash(10, self.test_hash_table.size), 0)
def test_put_works_correct(self):
self.assertEqual(self.test_hash_table.slots, [77, 44, 55, 20, 26, 93, 17, None, None, 31, 54])
self.assertEqual(self.test_hash_table.data, ['bird', 'goat', 'pig', 'chicken', 'dog', 'lion', 'tiger', None,
None, 'cow', 'cat'])
def test_get_works_correct(self):
self.assertEqual(self.test_hash_table.get(54), "cat")
self.assertEqual(self.test_hash_table.get(26), "dog")
self.assertEqual(self.test_hash_table.get(93), "lion")
self.assertEqual(self.test_hash_table.get(17), "tiger")
self.assertEqual(self.test_hash_table.get(77), "bird")
self.assertEqual(self.test_hash_table.get(31), "cow")
self.assertEqual(self.test_hash_table.get(44), "goat")
self.assertEqual(self.test_hash_table.get(55), "pig")
self.assertEqual(self.test_hash_table.get(20), "chicken")
self.assertIsNone(self.test_hash_table.get(18))
self.test_hash_table.put(18, "antelope")
self.test_hash_table.put(19, "sparrow")
self.assertIsNone(self.test_hash_table.get(21))
def test_getitem_returns_correct_value(self):
self.assertEqual(self.test_hash_table[54], "cat")
def test_set_item_works_correct(self):
set_test_hash_table = HashTable()
set_test_hash_table[18] = "monkey"
self.assertEqual(set_test_hash_table[18], "monkey")
set_test_hash_table[54] = "elephant"
self.assertEqual(set_test_hash_table[54], "elephant")
set_test_hash_table[65] = "pigeon"
set_test_hash_table[65] = "crocodile"
self.assertEqual(set_test_hash_table[65], "crocodile")
def test_table_has_get(): ht = HashTable() assert ht.get
def test_can_retrieve_proper_info_with_collisions2():
ht = HashTable()
collision_key = ht.find_collision_key('babies')
ht.add('babies', 55)
ht.add(collision_key, 10000000)
collision_key2 = ht.find_collision_key('goats')
ht.add('goats', 99)
ht.add(collision_key2, 9887766554433231)
assert (ht.get('babies') == 55) and (ht.get('goats') == 99) and (ht.get(collision_key) == 10000000)
def test_can_retrieve_proper_info_with_collisions():
ht = HashTable()
collision_key = ht.find_collision_key('babies')
ht.add('babies', 55)
ht.add(collision_key, 10000000)
assert ht.get('babies') == 55
def test_table_has_add(): ht = HashTable() assert ht.add
def test_random_collision():
ht = HashTable()
collision_key = ht.find_collision_key('babies')
assert (collision_key != 'babies') and (ht.hash('babies') == ht.hash(collision_key))
def test_add_actually_adds():
ht = HashTable()
ht.add('babies', 25)
assert ht.contains('babies')
def test_rehash_returns_correct_result(self):
self.assertEqual(HashTable.rehash(0, self.test_hash_table.size), 1)
self.assertEqual(HashTable.rehash(5, self.test_hash_table.size), 6)
self.assertEqual(HashTable.rehash(10, self.test_hash_table.size), 0)
def test_hash_is_in_range():
ht = HashTable()
index = ht.hash('babies')
assert 0 <= index <= 1024
def setUp(self):
self.hash_table = HashTable(4)
def test_returns_null_for_a_key_that_does_not_exist_in_the_hashtable():
hash_table = HashTable()
assert hash_table.get('test') == None
def setUp(self):
self.hash_table = HashTable(4)
def test_handle_a_collision_within_the_hashtable():
hash_table = HashTable()
hash_table.add('yahia','24')
hash_table.add('yaiha','30')
print(hash_table.contains('yahia'))
print(hash_table.contains('yaiha'))
from hash_table.hash_table import HashTable
hash_table = HashTable(10)
hash_table.set(100, 1)
hash_table.set(25, 2)
hash_table.set(25, 3)
a = hash_table.get(25)
print(a)
print(hash_table.keys())
print(hash_table.values())
print(hash_table.contains_key(73))
print(hash_table.contains_value(5))
for key in hash_table.keys():
print(key, hash_table.get(key))
def test_table_has_contains(): ht = HashTable() assert ht.contains
