void test_contains_key_multiple() {
hash_map_put(map, "key", "value");
hash_map_put(map, "key2", "value2");
TEST_ASSERT_TRUE(hash_map_contains_key(map, "key"));
TEST_ASSERT_TRUE(hash_map_contains_key(map, "key2"));
}
void test_collision() {
// these two would collide and chaining should come into play
hash_map_put(map, "1234567890", "9090");
hash_map_put(map, "1234567809", "0909");
TEST_ASSERT_EQUAL_STRING("9090", hash_map_get(map, "1234567890"));
TEST_ASSERT_EQUAL_STRING("0909", hash_map_get(map, "1234567809"));
}
void test_put_get() {
hash_map_put(map, "key", "value");
TEST_ASSERT_EQUAL_STRING("value", (char *) hash_map_get(map, "key"));
hash_map_put(map, "key", "value2");
TEST_ASSERT_EQUAL_STRING("value2", (char *) hash_map_get(map, "key"));
hash_map_put(map, "key2", "value3");
TEST_ASSERT_EQUAL_STRING("value3", (char *) hash_map_get(map, "key2"));
}
char* dns_map_put_token(dns_map* map, const char* domain, char* token, int flag_update) {
char* old_token = hash_map_put(map->domain_to_token, domain, strlen(domain), token);
if (flag_update)
write_domain_token_entry(map->h_domain2token, domain, token);
// TODO: implement this as a dynamic list
hash_map_put(map->tokens, (void*) token, strlen(token), (void*) 1);
return old_token;
}
uint8_t* dns_map_put_ipv4(dns_map* map, const char* token, uint8_t* ip, int flag_update) {
uint8_t* old_ip = hash_map_put(map->token_to_ip, token, strlen(token), ip);
if (flag_update)
write_token_ip_entry(map->h_token2ip, token, ip);
// TODO: implement this as a dynamic list
hash_map_put(map->tokens, (void*) token, strlen(token), (void*) 1);
return old_ip;
}
void test_put_remove() {
hash_map_put(map, "abcd", "the alphabet");
hash_map_put(map, "1234", "some numbers");
hash_map_remove(map, "abcd");
hash_map_remove(map, "1234");
TEST_ASSERT_NULL(hash_map_get(map, "abcd"));
TEST_ASSERT_NULL(hash_map_get(map, "1234"));
hash_map_put(map, "abcd", "try it again");
TEST_ASSERT_EQUAL_STRING("try it again", hash_map_get(map, "abcd"));
}
void test_clear() {
hash_map_put(map, "key", "value");
hash_map_put(map, "key2", "value2");
hash_map_put(map, "key3", "value3");
hash_map_clear(map);
TEST_ASSERT_EQUAL_UINT(0, hash_map_size(map));
TEST_ASSERT_NULL(hash_map_get(map, "key"));
TEST_ASSERT_NULL(hash_map_get(map, "key2"));
TEST_ASSERT_NULL(hash_map_get(map, "key3"));
}
struct vm_object *vm_string_intern(struct vm_object *string)
{
struct vm_reference *intern;
struct vm_object *result;
pthread_mutex_lock(&literals_mutex);
if (hash_map_get(literals, string, (void **) &intern) == 0) {
pthread_mutex_unlock(&literals_mutex);
result = vm_reference_get(intern);
return result;
}
result = string;
intern = vm_reference_alloc(result, VM_REFERENCE_STRONG);
if (!intern) {
result = throw_oom_error();
goto out;
}
if (hash_map_put(literals, string, intern))
result = throw_oom_error();
out:
pthread_mutex_unlock(&literals_mutex);
return result;
}
struct vm_object *vm_string_intern(struct vm_object *string)
{
struct vm_object *intern;
pthread_rwlock_rdlock(&literals_rwlock);
if (hash_map_get(literals, string, (void **) &intern) == 0) {
pthread_rwlock_unlock(&literals_rwlock);
return intern;
}
pthread_rwlock_unlock(&literals_rwlock);
pthread_rwlock_wrlock(&literals_rwlock);
/*
* XXX: we should notify GC that we store a reference to
* string here (both as a key and a value). It should be
* marked as a weak reference.
*/
intern = string;
if (hash_map_put(literals, string, intern))
intern = throw_oom_error();
pthread_rwlock_unlock(&literals_rwlock);
return intern;
}
void test_size() {
TEST_ASSERT_EQUAL_UINT(0, hash_map_size(map));
hash_map_put(map, "key", "value");
TEST_ASSERT_EQUAL_UINT(1, hash_map_size(map));
hash_map_put(map, "key2", "value");
TEST_ASSERT_EQUAL_UINT(2, hash_map_size(map));
// if the same key was updated, size should not change
hash_map_put(map, "key", "value2");
TEST_ASSERT_EQUAL_UINT(2, hash_map_size(map));
// if hashs collide, size should still work
hash_map_put(map, "1234567890", "9090");
hash_map_put(map, "1234567809", "0909");
TEST_ASSERT_EQUAL_UINT(4, hash_map_size(map));
hash_map_remove(map, "key");
hash_map_remove(map, "key2");
hash_map_remove(map, "1234567890");
hash_map_remove(map, "1234567809");
TEST_ASSERT_EQUAL_UINT(0, hash_map_size(map));
}
void test_keys() {
char *keys[] = { "key", "keys2", "1234567890", "1234567809" };
char *values[] = { "value", "value2", "9090", "0909" };
linked_list *keys_list = hash_map_keys(map);
TEST_ASSERT_EQUAL_UINT(0, linked_list_size(keys_list));
for (int i = 0; i < sizeof(keys) / sizeof(*keys); i++) {
hash_map_put(map, keys[i], values[i]);
}
keys_list = hash_map_keys(map);
TEST_ASSERT_EQUAL_UINT(4, linked_list_size(keys_list));
linked_list_node *node = linked_list_head(keys_list);
for (int i = 0; i < sizeof(keys) / sizeof(*keys); i++) {
TEST_ASSERT_EQUAL_STRING(keys[i], node->data);
node = node->next;
}
}
void test_contains_key_null_key() {
hash_map_put(map, "null key", NULL);
TEST_ASSERT_TRUE(hash_map_contains_key(map, "null key"));
}
