void test_hash_table_new_free(void)
{
HashTable *hash_table;
hash_table = hash_table_new(int_hash, int_equal);
assert(hash_table != NULL);
/* Add some values */
hash_table_insert(hash_table, &value1, &value1);
hash_table_insert(hash_table, &value2, &value2);
hash_table_insert(hash_table, &value3, &value3);
hash_table_insert(hash_table, &value4, &value4);
/* Free the hash table */
hash_table_free(hash_table);
/* Test out of memory scenario */
alloc_test_set_limit(0);
hash_table = hash_table_new(int_hash, int_equal);
assert(hash_table == NULL);
assert(alloc_test_get_allocated() == 0);
alloc_test_set_limit(1);
hash_table = hash_table_new(int_hash, int_equal);
assert(hash_table == NULL);
assert(alloc_test_get_allocated() == 0);
}
void test_trie_insert(void)
{
Trie *trie;
unsigned int entries;
size_t allocated;
trie = generate_trie();
/* Test insert of NULL value has no effect */
entries = trie_num_entries(trie);
assert(trie_insert(trie, "hello world", NULL) == 0);
assert(trie_num_entries(trie) == entries);
/* Test out of memory scenario */
allocated = alloc_test_get_allocated();
alloc_test_set_limit(0);
assert(trie_insert(trie, "a", "test value") == 0);
assert(trie_num_entries(trie) == entries);
/* Test rollback */
alloc_test_set_limit(5);
assert(trie_insert(trie, "hello world", "test value") == 0);
assert(alloc_test_get_allocated() == allocated);
assert(trie_num_entries(trie) == entries);
trie_free(trie);
}
void test_set_intersection (void) {
int numbers1[] = {1, 2, 3, 4, 5, 6, 7};
int numbers2[] = {5, 6, 7, 8, 9, 10, 11};
int result[] = {5, 6, 7};
int i;
Set* set1;
Set* set2;
Set* result_set;
size_t allocated;
/* Create the first set */
set1 = set_new (int_hash, int_equal);
for (i = 0; i < 7; ++i) {
set_insert (set1, &numbers1[i]);
}
/* Create the second set */
set2 = set_new (int_hash, int_equal);
for (i = 0; i < 7; ++i) {
set_insert (set2, &numbers2[i]);
}
/* Perform the intersection */
result_set = set_intersection (set1, set2);
assert (set_num_entries (result_set) == 3);
for (i = 0; i < 3; ++i) {
assert (set_query (result_set, &result[i]) != 0);
}
/* Test out of memory scenario */
alloc_test_set_limit (0);
assert (set_intersection (set1, set2) == NULL);
/* Can allocate set, can't copy all values */
alloc_test_set_limit (2 + 2);
allocated = alloc_test_get_allocated();
assert (set_intersection (set1, set2) == NULL);
assert (alloc_test_get_allocated() == allocated);
set_free (set1);
set_free (set2);
set_free (result_set);
}
static void run_test(UnitTestFunction test) {
/* Turn off any allocation limits that may have been set
* by a previous test. */
alloc_test_set_limit(-1);
/* Run the test */
test();
/* Check that all memory was correctly freed back during
* the test. */
assert(alloc_test_get_allocated() == 0);
}
void test_set_new_free (void) {
Set* set;
int i;
int* value;
set = set_new (int_hash, int_equal);
set_register_free_function (set, free);
assert (set != NULL);
/* Fill the set with many values before freeing */
for (i = 0; i < 10000; ++i) {
value = (int*) malloc (sizeof (int));
*value = i;
set_insert (set, value);
}
/* Free the set */
set_free (set);
/* Test out of memory scenario */
alloc_test_set_limit (0);
set = set_new (int_hash, int_equal);
assert (set == NULL);
alloc_test_set_limit (1);
set = set_new (int_hash, int_equal);
assert (set == NULL);
assert (alloc_test_get_allocated() == 0);
}
