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")
Пример #4
0
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'])
Пример #5
0
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
Пример #23
0
 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
Пример #25
0
 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'))
Пример #27
0
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