END_TEST START_TEST(test_map_put_clear_get) { hashmap *map; int res = hashmap_init(0, &map); fail_unless(res == 0); char buf[100]; void *out; for (int i=0; i<100;i++) { snprintf((char*)&buf, 100, "test%d", i); out = 0 & i; fail_unless(hashmap_put(map, (char*)buf, out) == 1); } fail_unless(hashmap_size(map) == 100); fail_unless(hashmap_clear(map) == 0); fail_unless(hashmap_size(map) == 0); for (int i=0; i<100;i++) { snprintf((char*)&buf, 100, "test%d", i); fail_unless(hashmap_get(map, (char*)buf, &out) == -1); } res = hashmap_destroy(map); fail_unless(res == 0); }
void hashmap_free(hashmap *hm) { hashmap_clear(hm); hm->alloc.cfree(hm->buckets); hm->buckets = NULL; hm->buckets_x = 0; hm->reserved = 0; }
static void test_hashmap_remove_and_replace(void) { _cleanup_hashmap_free_ Hashmap *m = NULL; int valid; void *key1 = UINT_TO_PTR(1); void *key2 = UINT_TO_PTR(2); void *key3 = UINT_TO_PTR(3); void *r; int i, j; log_info("%s", __func__); m = hashmap_new(&trivial_hash_ops); assert_se(m); valid = hashmap_remove_and_replace(m, key1, key2, NULL); assert_se(valid == -ENOENT); valid = hashmap_put(m, key1, key1); assert_se(valid == 1); valid = hashmap_remove_and_replace(NULL, key1, key2, key2); assert_se(valid == -ENOENT); valid = hashmap_remove_and_replace(m, key1, key2, key2); assert_se(valid == 0); r = hashmap_get(m, key2); assert_se(r == key2); assert_se(!hashmap_get(m, key1)); valid = hashmap_put(m, key3, key3); assert_se(valid == 1); valid = hashmap_remove_and_replace(m, key3, key2, key2); assert_se(valid == 0); r = hashmap_get(m, key2); assert_se(r == key2); assert_se(!hashmap_get(m, key3)); /* Repeat this test several times to increase the chance of hitting * the less likely case in hashmap_remove_and_replace where it * compensates for the backward shift. */ for (i = 0; i < 20; i++) { hashmap_clear(m); for (j = 1; j < 7; j++) hashmap_put(m, UINT_TO_PTR(10*i + j), UINT_TO_PTR(10*i + j)); valid = hashmap_remove_and_replace(m, UINT_TO_PTR(10*i + 1), UINT_TO_PTR(10*i + 2), UINT_TO_PTR(10*i + 2)); assert_se(valid == 0); assert_se(!hashmap_get(m, UINT_TO_PTR(10*i + 1))); for (j = 2; j < 7; j++) { r = hashmap_get(m, UINT_TO_PTR(10*i + j)); assert_se(r == UINT_TO_PTR(10*i + j)); } } }
void tcache_clear() { iterator it; hashmap_iter_begin(&cache->entries, &it); hashmap_pair *pair; while((pair = iter_next(&it)) != NULL) { tcache_entry_value *entry = pair->val; SDL_DestroyTexture(entry->tex); } hashmap_clear(&cache->entries); }
END_TEST START_TEST(test_map_clear_no_keys) { hashmap *map; int res = hashmap_init(0, &map); fail_unless(res == 0); fail_unless(hashmap_clear(map) == 0); res = hashmap_destroy(map); fail_unless(res == 0); }
void freeStuff() { iter_t iter; char* varname; hashmap_iterate(&vars, &iter); while ((varname = (char*) hashmap_next(&vars, &iter))) free(varname); hashmap_clear(&vars, NULL, NULL, NULL); Expr el; linkedlist_iterate(&exprPool, &iter); while ((el = linkedlist_next(&exprPool, &iter))){ vc_deleteExpr(el); } linkedlist_clear(&exprPool, NULL, NULL); }
/* The clear function will need to clean the whole chain */ void TestHashmaplinked_ClearHandlesCollision( CuTest * tc ) { hashmap_t *hm; hm = hashmap_new(__uint_hash, __uint_compare, 4); hashmap_put(hm, (void *) 1, (void *) 50); /* all of the rest cause collisions */ hashmap_put(hm, (void *) 5, (void *) 51); hashmap_put(hm, (void *) 9, (void *) 52); hashmap_clear(hm); CuAssertTrue(tc, 0 == hashmap_count(hm)); hashmap_freeall(hm); }
END_TEST START_TEST(test_hashmap_clear) { HashMap *map = hashmap_create(5); hashmap_put(map, "foo", "bar"); hashmap_put(map, "baz", "boo"); hashmap_clear(map); ck_assert_int_eq(map->size, 0); ck_assert_int_eq(hashmap_contains(map, "foo"), 0); ck_assert_int_eq(hashmap_contains(map, "baz"), 0); hashmap_destroy(map); }
void TestHashmaplinked_ClearRemovesAll( CuTest * tc ) { hashmap_t *hm; unsigned long val; hm = hashmap_new(__uint_hash, __uint_compare, 11); hashmap_put(hm, (void *) 1, (void *) 92); hashmap_put(hm, (void *) 2, (void *) 102); hashmap_clear(hm); val = (unsigned long) hashmap_get(hm, (void *) 1); CuAssertTrue(tc, 0 == val); CuAssertTrue(tc, 0 == hashmap_count(hm)); hashmap_freeall(hm); }
static void clear_test( void ) { int res; hashmap_t hashmap; size_t size; unsigned int existed; res = hashmap_init( &hashmap ); assert( 0 == res ); res = hashmap_insert( &hashmap, "test", 1 ); assert( 0 == res ); hashmap_clear( &hashmap ); size = hashmap_size( &hashmap ); assert( 0 == size ); res = hashmap_insert_existed( &hashmap, "test", 1, &existed ); assert( 0 == res ); assert( 0 == existed ); hashmap_term( &hashmap ); }
void set_clear(Set *s) { hashmap_clear(MAKE_HASHMAP(s)); }
static void purgetrylist(struct evbuffer *rsps) { hashmap_clear(cfg.trylist_hashmap); evbuffer_add_printf(rsps, "OK"); }
void hashmap_term( hashmap_t *hashmap ) { assert( NULL != hashmap ); hashmap_clear( hashmap ); free( hashmap->buckets ); }
void hashmap_test(void) { printf("hashmap: running tests..."); Hashmap *map_1; map_1 = hashmap_create(100, NULL, &hashmap_hash_cstring, &hashmap_compare_cstring); hashmap_add(map_1, "pickles", (void*)pickle_value); assert( hashmap_count(map_1) == 1 ); assert( hashmap_contains(map_1, "apricots") == HASHMAP_NOT_FOUND ); assert( hashmap_contains(map_1, "pickles") == HASHMAP_FOUND ); assert( hashmap_item(map_1, "apricots") == NULL ); assert( hashmap_item(map_1, "pickles") == pickle_value ); hashmap_add(map_1, "pickles", (void*)pickle_value); assert( hashmap_count(map_1) == 1 ); hashmap_add(map_1, "apples", (void*)apple_value); assert( hashmap_count(map_1) == 2 ); assert( hashmap_contains(map_1, "apricots") == HASHMAP_NOT_FOUND ); assert( hashmap_contains(map_1, "pickles") == HASHMAP_FOUND ); assert( hashmap_contains(map_1, "apples") == HASHMAP_FOUND ); assert( hashmap_item(map_1, "apricots") == NULL ); assert( hashmap_item(map_1, "pickles") == pickle_value ); assert( hashmap_item(map_1, "apples") == apple_value ); hashmap_add(map_1, "pizza", (void*)pizza_value); assert( hashmap_count(map_1) == 3 ); assert( hashmap_contains(map_1, "apricots") == HASHMAP_NOT_FOUND ); assert( hashmap_contains(map_1, "pickles") == HASHMAP_FOUND ); assert( hashmap_contains(map_1, "apples") == HASHMAP_FOUND ); assert( hashmap_contains(map_1, "pizza") == HASHMAP_FOUND ); assert( hashmap_item(map_1, "apricots") == NULL ); assert( hashmap_item(map_1, "pickles") == pickle_value ); assert( hashmap_item(map_1, "apples") == apple_value ); assert( hashmap_item(map_1, "pizza") == pizza_value ); assert(map_1->buckets[28].pair_count == 1); assert(map_1->buckets[66].pair_count == 1); assert(map_1->buckets[51].pair_count == 1); assert(map_1->buckets[10].pair_count == 0); hashmap_enumerate(map_1, test_enumerator_); hashmap_remove(map_1, "apples"); assert( hashmap_count(map_1) == 2 ); assert( hashmap_contains(map_1, "apricots") == HASHMAP_NOT_FOUND ); assert( hashmap_contains(map_1, "pickles") == HASHMAP_FOUND ); assert( hashmap_contains(map_1, "apples") == HASHMAP_NOT_FOUND ); assert( hashmap_contains(map_1, "pizza") == HASHMAP_FOUND ); assert( hashmap_item(map_1, "apricots") == NULL ); assert( hashmap_item(map_1, "pickles") == pickle_value ); assert( hashmap_item(map_1, "apples") == NULL ); assert( hashmap_item(map_1, "pizza") == pizza_value ); hashmap_clear(map_1); assert( hashmap_count(map_1) == 0 ); hashmap_dispose(map_1); assert( (unsigned long)hashmap_hash_cstring(NULL, "pickles") % 100 == 28 ); assert( (unsigned long)hashmap_hash_cstring(NULL, "apples") % 100 == 66 ); assert( (unsigned long)hashmap_hash_cstring(NULL, "pizza") % 100 == 51 ); assert( (unsigned long)hashmap_hash_cstring(NULL, "apricots") % 100 == 10 ); map_1 = hashmap_create(1, NULL, &hashmap_hash_cstring, &hashmap_compare_cstring); hashmap_add(map_1, "pickles", (void*)pickle_value); assert( hashmap_count(map_1) == 1 ); hashmap_add(map_1, "pizza", (void*)pizza_value); assert( hashmap_count(map_1) == 2 ); hashmap_add(map_1, "apples", (void*)apple_value); assert( hashmap_count(map_1) == 3 ); assert( hashmap_contains(map_1, "apricots") == HASHMAP_NOT_FOUND ); assert( hashmap_contains(map_1, "pickles") == HASHMAP_FOUND ); assert( hashmap_contains(map_1, "apples") == HASHMAP_FOUND ); assert( hashmap_contains(map_1, "pizza") == HASHMAP_FOUND ); assert( hashmap_item(map_1, "apricots") == NULL ); assert( hashmap_item(map_1, "pickles") == pickle_value ); assert( hashmap_item(map_1, "apples") == apple_value ); assert( hashmap_item(map_1, "pizza") == pizza_value ); assert(map_1->buckets[0].pair_count == 3); hashmap_add(map_1, "pizza", (void*)apple_value); assert( hashmap_count(map_1) == 3 ); assert( hashmap_contains(map_1, "apricots") == HASHMAP_NOT_FOUND ); assert( hashmap_contains(map_1, "pickles") == HASHMAP_FOUND ); assert( hashmap_contains(map_1, "apples") == HASHMAP_FOUND ); assert( hashmap_contains(map_1, "pizza") == HASHMAP_FOUND ); assert( hashmap_item(map_1, "apricots") == NULL ); assert( hashmap_item(map_1, "pickles") == pickle_value ); assert( hashmap_item(map_1, "apples") == apple_value ); assert( hashmap_item(map_1, "pizza") == apple_value ); assert(strcmp(map_1->buckets[0].pairs[0]->key, "apples") == 0); assert(strcmp(map_1->buckets[0].pairs[1]->key, "pickles") == 0); assert(strcmp(map_1->buckets[0].pairs[2]->key, "pizza") == 0); hashmap_dispose(map_1); printf("ok.\n"); }