Ejemplo n.º 1
0
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);
}
Ejemplo n.º 2
0
void hashmap_free(hashmap *hm) {
    hashmap_clear(hm);
    hm->alloc.cfree(hm->buckets);
    hm->buckets = NULL;
    hm->buckets_x = 0;
    hm->reserved = 0;
}
Ejemplo n.º 3
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));
                }
        }
}
Ejemplo n.º 4
0
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);
}
Ejemplo n.º 5
0
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);
}
Ejemplo n.º 6
0
Archivo: cvcl.c Proyecto: MohsinN/jpf
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);
}
Ejemplo n.º 8
0
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);
}
Ejemplo n.º 10
0
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 );
}
Ejemplo n.º 11
0
void set_clear(Set *s) {
        hashmap_clear(MAKE_HASHMAP(s));
}
Ejemplo n.º 12
0
static void
purgetrylist(struct evbuffer *rsps) {
  hashmap_clear(cfg.trylist_hashmap);
  evbuffer_add_printf(rsps, "OK");
}
Ejemplo n.º 13
0
void hashmap_term( hashmap_t *hashmap )
{
	assert( NULL != hashmap );
	hashmap_clear( hashmap );
	free( hashmap->buckets );
}
Ejemplo n.º 14
0
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");
}