Beispiel #1
0
/**
 * Destroys the metrics
 * @return 0 on success.
 */
int destroy_metrics(metrics *m) {
    // Clear the copied quantiles array
    free(m->quantiles);

    // Nuke all the k/v pairs
    key_val *current = m->kv_vals;
    key_val *prev = NULL;
    while (current) {
        free(current->name);
        prev = current;
        current = current->next;
        free(prev);
    }

    // Nuke the counters
    hashmap_iter(m->counters, counter_delete_cb, NULL);
    hashmap_destroy(m->counters);

    // Nuke the timers
    hashmap_iter(m->timers, timer_delete_cb, NULL);
    hashmap_destroy(m->timers);

    // Nuke the timers
    hashmap_iter(m->sets, set_delete_cb, NULL);
    hashmap_destroy(m->sets);

    // Nuke the gauges
    hashmap_iter(m->gauges, gauge_delete_cb, NULL);
    hashmap_destroy(m->gauges);

    return 0;
}
Beispiel #2
0
void destroy() {
	hashmap_foreach(b.plugins, __unload_plugin);

	hashmap_destroy(b.plugins);
	hashmap_destroy(b.handlers);
	hashmap_destroy(b.commands);

	for (int i = 0; i < b.channels->index; ++i) {
		free(b.channels->list[i]);
	}
	VEC_DESTROY(b.channels);
	cJSON_Delete(b.config);
}
Beispiel #3
0
static char* test_hashmap_get () {
	// Test replacement.
	hashmap_t hashmap;
	hashmap_init(&hashmap, sizeof(int), 64);

	mu_assert("invalid missing key return", hashmap_get(&hashmap, "doesn't exist") == NULL);

	int value = 42;
	hashmap_put(&hashmap, "a", &value);
	mu_assert("hashmap['a'] != 42", hashmap_value(&hashmap, "a", int));

	value = 13001;
	hashmap_put(&hashmap, "a", &value);
	mu_assert("hashmap value not replaced", hashmap_value(&hashmap, "a", int));

	hashmap_destroy(&hashmap);

	// Test collisions.
	hashmap_init(&hashmap, sizeof(int), 1);

	value = 52;
	hashmap_put(&hashmap, "a", &value);
	mu_assert("hashmap['a'] != 52", hashmap_value(&hashmap, "a", int));

	value = 64;
	hashmap_put(&hashmap, "b", &value);
	mu_assert("hashmap['b'] != 64", hashmap_value(&hashmap, "b", int));

	value = 92;
	hashmap_put(&hashmap, "b", &value);
	mu_assert("hashmap[b] != 92", hashmap_value(&hashmap, "b", int));

	hashmap_destroy(&hashmap);

	// Test string storage.
	hashmap_init(&hashmap, sizeof(char*), 64);

	char* str = calloc(9, sizeof(char));
	strcpy(str, "test str");
	hashmap_put(&hashmap, "a", &str);
	mu_assert("hashmap['a'] != 'test str'", strcmp(str, hashmap_value(&hashmap, "a", char*)) == 0);

	char* str2 = calloc(10, sizeof(char));
	strcpy(str2, "test str2");
	hashmap_put(&hashmap, "b", &str2);
	mu_assert("hashmap['b'] != 'test str2'", strcmp(str2, hashmap_value(&hashmap, "b", char*)) == 0);

	hashmap_destroy_deep(&hashmap);

	return 0;
}
Beispiel #4
0
void free_sequential_query(sequential_query_t* q)
{
  switch( q->type ) {
    case SEQ_BOOLEAN:
      {
        sequential_boolean_query_t* b = (sequential_boolean_query_t*) q;
        free_sequential_query(b->left);
        free_sequential_query(b->right);
        free(b);
      }
      break;
    case SEQ_REGEXP:
      {
        sequential_regexp_query_t* b = (sequential_regexp_query_t*) q;
        results_writer_destroy( & b->results_writer );
        //free_nfa_description( & b->nfa );
        seq_free_regexp(b->matcher);

        if( b->matches.num > 0 ) {
          // pull out all of the matches and free the keys and values.
          for( hash_t i = 0; i < b->matches.size; i++ ) {
            free_seq_search_entry( & b->matches.map[i] );
          }
        }
        hashmap_destroy( & b->matches );

        free(b);
      }
      break;
  }
}
Beispiel #5
0
END_TEST

START_TEST(test_map_put_clear_get)
{
    bloom_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 = (void*)(intptr_t)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);
}
Beispiel #6
0
END_TEST

START_TEST(test_map_put_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);
    }

    for (int i=0; i<100;i++) {
        snprintf((char*)&buf, 100, "test%d", i);
        fail_unless(hashmap_get(map, (char*)buf, &out) == 0);
        fail_unless(out == (0 & i));
    }

    res = hashmap_destroy(map);
    fail_unless(res == 0);
}
Beispiel #7
0
static int free_data(void* data, void *arg) {
  userdata *dat = (userdata *) data;
  /* 删除整个子 map */
  hashmap_destroy(dat->map, free_elem, 0);
  free(dat);
  return 0;
}
Beispiel #8
0
END_TEST

START_TEST(test_map_put_delete)
{
    hashmap *map;
    int res = hashmap_init(0, &map);
    fail_unless(res == 0);

    char buf[100];
    void *out;
    int j;
    for (int i=0; i<100;i++) {
        snprintf((char*)&buf, 100, "test%d", i);
        j = 0 & i;
        out = (void *)&j;
        fail_unless(hashmap_put(map, (char*)buf, out) == 1);
    }
    fail_unless(hashmap_size(map) == 100);

    for (int i=0; i<100;i++) {
        snprintf((char*)&buf, 100, "test%d", i);
        fail_unless(hashmap_delete(map, (char*)buf) == 0);
        fail_unless(hashmap_size(map) == (100-i-1));
    }

    fail_unless(hashmap_size(map) == 0);
    res = hashmap_destroy(map);
    fail_unless(res == 0);
}
Beispiel #9
0
END_TEST

START_TEST(test_hashmap_contains) {
  HashMap *map = hashmap_create(5);

  hashmap_put(map, "foo", "bar");
  
  ck_assert_int_eq(hashmap_contains(map, "foo"), 1);
  ck_assert_int_eq(hashmap_contains(map, "baz"), 0);

  hashmap_destroy(map);
}
Beispiel #10
0
static char* test_hashmap_init () {
	hashmap_t hashmap;
	hashmap_init(&hashmap, sizeof(int), 64);

	mu_assert("hashmap element size incorrect", hashmap.element_size == sizeof(int));
	mu_assert("hashmap capacity incorrect", hashmap.capacity == 64);
	mu_assert("hashmap data not allocated", hashmap.data != NULL);

	hashmap_destroy(&hashmap);

	return 0;
}
Beispiel #11
0
static char* test_hashmap_func_ptr () {
	hashmap_t hashmap;
	hashmap_init(&hashmap, sizeof(thm__func), 64);
	thm__func value = thm__dummy;
	hashmap_put(&hashmap, "func", &value);

	mu_assert("function pointers not equal", thm__dummy == hashmap_value(&hashmap, "func", thm__func));

	hashmap_destroy(&hashmap);

	return 0;
}
Beispiel #12
0
void ini_destroy(ini_context_t *context)
{
    if (context == NULL) {
        return;
    }

    if (context->global.items != NULL) {
        free(context->global.items);
        memset(&context->global, 0, sizeof(ini_section_t));
    }

    hashmap_destroy(context->sections, ini_free_hash_data_func, NULL);
}
Beispiel #13
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);
}
Beispiel #14
0
END_TEST

START_TEST(test_hashmap_clear_index) {
  HashMap *map = hashmap_create(5);

  hashmap_put(map, "a", "test");
  hashmap_clear_index(map, 0);

  ck_assert_int_eq(map->size, 0);
  ck_assert_int_eq(hashmap_contains(map, "a"), 0);

  hashmap_destroy(map);
}
Beispiel #15
0
END_TEST

START_TEST(test_hashmap_index) {
  HashMap *map = hashmap_create(5);

  ck_assert_int_eq(hashmap_index(map, "a"), 0);
  ck_assert_int_eq(hashmap_index(map, "b"), 1);
  ck_assert_int_eq(hashmap_index(map, "c"), 2);
  ck_assert_int_eq(hashmap_index(map, "d"), 3);
  ck_assert_int_eq(hashmap_index(map, "e"), 4);
  ck_assert_int_eq(hashmap_index(map, "f"), 0);

  hashmap_destroy(map);
}
Beispiel #16
0
END_TEST

START_TEST(test_hashmap_locate_entry) {
  HashMap *map = hashmap_create(5);
  const char *key = "foo";
  const char *value = "bar";

  hashmap_put(map, key, value);
  Entry *entry = hashmap_locate_entry(map, key);

  ck_assert_str_eq(entry->key, key);
  ck_assert_str_eq(entry->value, value);

  hashmap_destroy(map);
}
Beispiel #17
0
static char* test_hashmap_keys () {
	hashmap_t hashmap;
	hashmap_init(&hashmap, sizeof(int), 64);

	int val1 = 99;
	int val2 = 100;
	hashmap_put(&hashmap, "key1", &val1);
	hashmap_put(&hashmap, "key2", &val2);

	mu_assert("key1 not stored", strcmp("key1", vector_get(hashmap.keys, 0, char*)) == 0);
	mu_assert("key2 not stored", strcmp("key2", vector_get(hashmap.keys, 1, char*)) == 0);

	hashmap_destroy(&hashmap);

	return 0;
}
Beispiel #18
0
END_TEST

START_TEST(test_hashmap_get) {
  HashMap *map = hashmap_create(5);
  const char *key = "foo";
  const char *value = "bar";
  unsigned int retrieved;
  const char *result;

  hashmap_put(map, key, value);
  retrieved = hashmap_get(map, key, &result);

  ck_assert_str_eq(result, value);
  ck_assert_int_eq(retrieved, 1);

  hashmap_destroy(map);
}
Beispiel #19
0
Hashmap *hashmap_create(Hashmap_compare compare, Hashmap_hash hash) {
    Hashmap *map = calloc(1, sizeof(Hashmap));
    check_mem(map);

    map->compare = compare == NULL ? default_compare : compare;
    map->hash = (hash == NULL) ? default_hash : hash;
    map->buckets = darray_create(sizeof(DArray *), DEFAULT_NUMBER_OF_BUCKETS);
    check_mem(map->buckets);
    map->buckets->end = map->buckets->max; // fake out expanding it

    return map;
error:
    if (map) {
        hashmap_destroy(map);
    }
    return NULL;
}
Beispiel #20
0
int main()
{
    HashMap* hashmap = hashmap_create();
    hashmap_add_node(hashmap, "trykey", "tryval", NULL, NULL);
    hashmap_add_node(hashmap, "trykey2", "tryval2", NULL, NULL);
    
    HashMapNode* node = hashmap_get(hashmap, "trykey");
    assert(!strcmp("trykey", node->key));
    assert(!strcmp("tryval", node->value));
    node = hashmap_get(hashmap, "trykey2");
    assert(!strcmp("trykey2", node->key));
    assert(!strcmp("tryval2", node->value));
    assert(hashmap->count == 2);
    hashmap_destroy(hashmap);
    assert(hashmap->count == 0);
    return 0;
}
Beispiel #21
0
END_TEST

START_TEST(test_map_delete_no_keys)
{
    hashmap *map;
    int res = hashmap_init(0, &map);
    fail_unless(res == 0);
    fail_unless(hashmap_size(map) == 0);

    char buf[100];
    for (int i=0; i<100;i++) {
        snprintf((char*)&buf, 100, "test%d", i);
        fail_unless(hashmap_delete(map, (char*)buf) == -1);
    }

    res = hashmap_destroy(map);
    fail_unless(res == 0);
}
Beispiel #22
0
END_TEST

START_TEST(test_hashmap_entry_for_key) {
  HashMap *map = hashmap_create(5);
  Entry *entry;
  const char *key = "foo";

  hashmap_put(map, key, "bar");

  // Existing entry
  entry = hashmap_entry_for_key(map, key);
  ck_assert_str_eq(entry->key, key);

  // Expecting a new entry
  entry = hashmap_entry_for_key(map, "baz");
  ck_assert(entry->key == NULL);
  
  hashmap_destroy(map);
}
Beispiel #23
0
END_TEST

START_TEST(test_map_put)
{
    bloom_hashmap *map;
    int res = hashmap_init(0, &map);
    fail_unless(res == 0);
    fail_unless(hashmap_size(map) == 0);

    char buf[100];
    for (int i=0; i<100;i++) {
        snprintf((char*)&buf, 100, "test%d", i);
        fail_unless(hashmap_put(map, (char*)buf, NULL) == 1);
    }
    fail_unless(hashmap_size(map) == 100);

    res = hashmap_destroy(map);
    fail_unless(res == 0);
}
Beispiel #24
0
END_TEST

START_TEST(test_hashmap_remove) {
  HashMap *map = hashmap_create(5);
  const char *key = "foo";
  unsigned int result;

  result = hashmap_remove(map, key);
  ck_assert_int_eq(result, 0);

  hashmap_put(map, key, "bar");
  ck_assert_int_eq(hashmap_contains(map, key), 1);
  ck_assert_int_eq(map->size, 1);  

  result = hashmap_remove(map, key);
  ck_assert_int_eq(result, 1);
  ck_assert_int_eq(hashmap_contains(map, key), 0);  
  ck_assert_int_eq(map->size, 0);

  hashmap_destroy(map);
}
Beispiel #25
0
END_TEST

START_TEST(test_map_put_iter)
{
    bloom_hashmap *map;
    int res = hashmap_init(0, &map);
    fail_unless(res == 0);

    char buf[100];
    for (int i=0; i<100;i++) {
        snprintf((char*)&buf, 100, "test%d", i);
        fail_unless(hashmap_put(map, (char*)buf, NULL) == 1);
    }

    int val = 0;
    fail_unless(hashmap_iter(map, iter_test, (void*)&val) == 0);
    fail_unless(val == 100);

    res = hashmap_destroy(map);
    fail_unless(res == 0);
}
Beispiel #26
0
/* clean up routine for flow monitoring */
void flowmon_cleanup(void)
{
    int i;

    net_disable_timestamp();

    /* destroy each table file we created */
    for (i = pna_tables - 1; i >= 0; i--) {
        if (flowtab_info[i].table_name[0] != '\0') {
            remove_proc_entry(flowtab_info[i].table_name, proc_parent);
        }
        if (flowtab_info[i].map != NULL) {
            hashmap_destroy(flowtab_info[i].map);
        }
    }

    /* free up table meta-information struct */
    vfree(flowtab_info);
    /* destroy /proc directory */
    remove_proc_entry(PNA_PROCDIR, NULL);
}
Beispiel #27
0
END_TEST

START_TEST(test_hashmap_put) {
  HashMap *map = hashmap_create(5);
  const char *key = "foo";
  const char *value = "bar";
  const char *value_replacement = "baz";
  const char *result;  

  ck_assert_int_eq(hashmap_put(map, key, value), 1);
  ck_assert_int_eq(hashmap_get(map, key, &result), 1);
  ck_assert_str_eq(result, value);
  ck_assert_int_eq(map->size, 1);
  
  ck_assert_int_eq(hashmap_put(map, key, value_replacement), 1);
  ck_assert_int_eq(hashmap_get(map, key, &result), 1);
  ck_assert_str_eq(result, value_replacement);
  ck_assert_int_eq(map->size, 1);
  
  hashmap_destroy(map);
}
Beispiel #28
0
END_TEST

START_TEST(test_map_put_grow)
{
    hashmap *map;
    int res = hashmap_init(32, &map);  // Only 32 slots
    fail_unless(res == 0);

    char buf[100];
    void *out;
    for (int i=0; i<1000;i++) {
        snprintf((char*)&buf, 100, "test%d", i);
        fail_unless(hashmap_put(map, (char*)buf, NULL) == 1);
    }

    int val = 0;
    fail_unless(hashmap_iter(map, iter_test, (void*)&val) == 0);
    fail_unless(val == 1000);
    fail_unless(hashmap_size(map) == 1000);

    res = hashmap_destroy(map);
    fail_unless(res == 0);
}
Beispiel #29
0
static void arbitrary( void )
{
	int res, val;
	hashmap_t *hashmap;

	hashmap = hashmap_create();
	assert( hashmap );

	res = hashmap_insert( hashmap, "test", 100 );
	assert( 0 == res );

	res = hashmap_insert( hashmap, "test", 101 );
	assert( 0 == res );

	res = hashmap_insert( hashmap, "test2", 3 );
	assert( 0 == res );

	res = hashmap_find( hashmap, "test2", NULL );
	assert( 1 == res );

	res = hashmap_find( hashmap, "test2", &val );
	assert( 1 == res );
	assert( 3 == val );

	res = hashmap_find( hashmap, "test", &val );
	assert( 1 == res );
	assert( 101 == val );

	hashmap_erase( hashmap, "test" );
	res = hashmap_find( hashmap, "test", NULL );
	assert( 0 == res );
	hashmap_erase( hashmap, "test" );
	res = hashmap_find( hashmap, "test", NULL );
	assert( 0 == res );

	hashmap_destroy( hashmap );
}
Beispiel #30
0
void cache_destroy(cache_t* c)
{
  int i;
  cache_list_entry_t* le;
  unsigned char* data;
  int data_number;

  // OK to destroy a zero-initialized cache.
  if( c->data == NULL ) return;

  for( i = 0; i < c->cache_size; i++ ) {
    le = & c->list[i];
    data_number = i;
    data = ((unsigned char*) c->data) + data_number * c->data_size;
    if( le->id != NULL && c->evict ) c->evict(le->id, c->data_size, data, c->context);
    if( le->id ) c->free_id(le->id);
  }

  free(c->list);
  free(c->data);
  hashmap_destroy(&c->mapping);
  c->list = NULL;
  c->data = NULL;
}