Imagelibrary/Containers
1
0
Fork 0
mirror of https://github.com/bkthomps/Containers.git synced 2025-11-16 12:34:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add more testing (#23)

Browse Source 
Increase code coverage so that other than the out-of-memory conditions, the code is entirely covered.

Some areas of the code have been tweaked for performance optimizations.

Bug fix! A bug has been identified and fixed in the unordered_multiset data structure in the unordered_multiset_remove_all function.

This bug would occur when more than one entry exists in the bucket in which the element is occupying, and that element had a count of more than one.
This commit is contained in:
Bailey Thompson
2019-04-30 23:22:36 -04:00
committed by GitHub
parent 6b297bfc51
commit 20e8839143
20 changed files with 1544 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/forward_list.c
View File

@@ -184,7 +184,7 @@ int forward_list_add_last(forward_list me, void *const data)
*/
static bool forward_list_is_illegal_input(forward_list me, const int index)
{
return index < 0 || index >= me->item_count || me->item_count == 0;
return index < 0 || index >= me->item_count;
}
/**

2
src/list.c
View File

@@ -253,7 +253,7 @@ int list_add_last(list me, void *const data)
*/
static bool list_is_illegal_input(list me, const int index)
{
return index < 0 || index >= me->item_count || me->item_count == 0;
return index < 0 || index >= me->item_count;
}
/**

2
src/unordered_multiset.c
View File

@@ -389,7 +389,7 @@ bool unordered_multiset_remove_all(unordered_multiset me, void *const key)
if (unordered_multiset_is_equal(me, traverse->next, hash, key)) {
struct node *const backup = traverse->next;
traverse->next = traverse->next->next;
me->size -= traverse->count;
me->size -= backup->count;
free(backup->key);
free(backup);
me->used--;

11
src/vector.c
View File

@@ -99,7 +99,8 @@ bool vector_is_empty(vector me)
}
/*
* Sets the space of the buffer.
* Sets the space of the buffer. Assumes that size is at least the same as the
* amount of items currently in the vector.
*/
static int vector_set_space(vector me, const int size)
{
@@ -109,9 +110,6 @@ static int vector_set_space(vector me, const int size)
}
me->data = temp;
me->item_capacity = size;
if (me->item_capacity < me->item_count) {
me->item_count = me->item_capacity;
}
return 0;
}
@@ -240,7 +238,7 @@ int vector_add_last(vector me, void *const data)
*/
static bool vector_is_illegal_input(vector me, const int index)
{
return index < 0 || index >= me->item_count || me->item_count == 0;
return index < 0 || index >= me->item_count;
}
/**
@@ -398,9 +396,8 @@ int vector_get_last(void *const data, vector me)
*/
int vector_clear(vector me)
{
const int ret = vector_set_space(me, START_SPACE);
me->item_count = 0;
return ret;
return vector_set_space(me, START_SPACE);
}
/**

5
tst/array.c
View File

@@ -3,6 +3,8 @@
void test_array(void)
{
assert(!array_init(-1, sizeof(int)));
assert(!array_init(1, 0));
array me = array_init(10, sizeof(int));
assert(me);
assert(array_size(me) == 10);
@@ -31,6 +33,9 @@ void test_array(void)
for (int i = 0; i < 10; i++) {
assert(data[i] == i);
}
int get = 0xdeadbeef;
assert(array_set(me, -1, &get) == -EINVAL);
assert(array_get(&get, me, -1) == -EINVAL);
me = array_destroy(me);
assert(!me);
}

1
tst/deque.c
View File

@@ -3,6 +3,7 @@
void test_deque(void)
{
assert(!deque_init(0));
int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
deque me = deque_init(sizeof(int));
assert(me);

1
tst/forward_list.c
View File

@@ -3,6 +3,7 @@
void test_forward_list(void)
{
assert(!forward_list_init(0));
int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
forward_list me = forward_list_init(sizeof(int));
assert(me);

10
tst/list.c
View File

@@ -3,6 +3,7 @@
void test_list(void)
{
assert(!list_init(0));
int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
list me = list_init(sizeof(int));
assert(me);
@@ -34,8 +35,9 @@ void test_list(void)
for (int i = 0; i < 3; i++) {
assert(10 - i == trimmed[i]);
}
int index = list_size(me);
int add = 3;
list_add_last(me, &add);
list_add_at(me, index, &add);
add = -1;
list_add_at(me, 1, &add);
add = -2;
@@ -63,6 +65,12 @@ void test_list(void)
list_remove_first(me);
list_remove_at(me, 2);
list_remove_last(me);
get = 34;
list_add_at(me, 0, &get);
int first = 0xdeadbeef;
list_get_first(&first, me);
assert(first == get);
list_remove_first(me);
assert(list_size(me) == 3);
get = 345;
list_get_first(&get, me);

416
tst/map.c
View File

@@ -10,6 +10,9 @@ static int compare_int(const void *const one, const void *const two)
void test_map(void)
{
assert(!map_init(0, sizeof(int), compare_int));
assert(!map_init(sizeof(int), 0, compare_int));
assert(!map_init(sizeof(int), sizeof(int), NULL));
map me = map_init(sizeof(int), sizeof(int), compare_int);
assert(me);
assert(map_size(me) == 0);
@@ -117,4 +120,417 @@ void test_map(void)
assert(map_is_empty(me));
me = map_destroy(me);
assert(!me);
me = map_init(sizeof(int), sizeof(int), compare_int);
assert(me);
// left-left
key = 5;
map_put(me, &key, &num);
key = 3;
map_put(me, &key, &num);
key = 1;
map_put(me, &key, &num);
key = 0xdeadbeef;
map_contains(me, &key);
map_clear(me);
// right-right
key = 1;
map_put(me, &key, &num);
key = 3;
map_put(me, &key, &num);
key = 5;
map_put(me, &key, &num);
key = 0xdeadbeef;
map_contains(me, &key);
map_clear(me);
// left-right
key = 5;
map_put(me, &key, &num);
key = 1;
map_put(me, &key, &num);
key = 3;
map_put(me, &key, &num);
key = 0xdeadbeef;
map_contains(me, &key);
map_clear(me);
// right-left
key = 1;
map_put(me, &key, &num);
key = 5;
map_put(me, &key, &num);
key = 3;
map_put(me, &key, &num);
key = 0xdeadbeef;
map_contains(me, &key);
map_clear(me);
// Two children edge case.
key = 8;
map_put(me, &key, &num);
key = 5;
map_put(me, &key, &num);
key = 11;
map_put(me, &key, &num);
key = 2;
map_put(me, &key, &num);
key = 6;
map_put(me, &key, &num);
key = 10;
map_put(me, &key, &num);
key = 15;
map_put(me, &key, &num);
key = 1;
map_put(me, &key, &num);
key = 3;
map_put(me, &key, &num);
key = 4;
map_put(me, &key, &num);
key = 7;
map_put(me, &key, &num);
key = 9;
map_put(me, &key, &num);
key = 12;
map_put(me, &key, &num);
key = 13;
map_put(me, &key, &num);
key = 16;
map_put(me, &key, &num);
key = 14;
map_put(me, &key, &num);
map_clear(me);
// Two children edge case.
key = 8;
map_put(me, &key, &num);
key = 4;
map_put(me, &key, &num);
key = 12;
map_put(me, &key, &num);
key = 2;
map_put(me, &key, &num);
key = 6;
map_put(me, &key, &num);
key = 10;
map_put(me, &key, &num);
key = 15;
map_put(me, &key, &num);
key = 1;
map_put(me, &key, &num);
key = 3;
map_put(me, &key, &num);
key = 5;
map_put(me, &key, &num);
key = 7;
map_put(me, &key, &num);
key = 9;
map_put(me, &key, &num);
key = 11;
map_put(me, &key, &num);
key = 13;
map_put(me, &key, &num);
key = 16;
map_put(me, &key, &num);
key = 14;
map_put(me, &key, &num);
map_clear(me);
// Add a lot of items.
int count = 0;
bool flip = false;
for (int i = 1234; i < 82400; i++) {
key = i % 765;
const bool is_already_present = map_contains(me, &key);
map_put(me, &key, &num);
const bool is_now_present = map_contains(me, &key);
assert(is_now_present);
if (!is_already_present && is_now_present) {
count++;
}
if (i == 1857 && !flip) {
i *= -1;
flip = true;
}
}
assert(count == map_size(me));
map_put(me, &key, &num);
map_destroy(me);
me = map_init(sizeof(int), sizeof(int), compare_int);
assert(map_size(me) == 0);
assert(map_is_empty(me));
key = 4;
map_put(me, &key, &num);
assert(map_size(me) == 1);
map_put(me, &key, &num);
assert(map_size(me) == 1);
assert(!map_is_empty(me));
assert(map_contains(me, &key));
key = 7;
assert(!map_contains(me, &key));
map_put(me, &key, &num);
assert(map_size(me) == 2);
assert(map_contains(me, &key));
int c[10] = {5, 9, 4, -5, 0, 6, 1, 5, 7, 2};
for (int i = 0; i < 10; i++) {
map_put(me, &c[i], &num);
assert(map_contains(me, &c[i]));
}
assert(map_size(me) == 9);
for (int i = 0; i < 10; i++) {
assert(map_contains(me, &c[i]));
}
for (int i = -100; i < 100; i++) {
bool contains = false;
for (int j = 0; j < 10; j++) {
if (c[j] == i) {
contains = true;
}
}
assert(map_contains(me, &i) == contains);
}
num = -3;
assert(!map_remove(me, &num));
assert(map_size(me) == 9);
assert(!map_contains(me, &num));
num = 6;
assert(map_remove(me, &num));
assert(map_size(me) == 8);
assert(!map_contains(me, &num));
num = 4;
assert(map_remove(me, &num));
assert(map_size(me) == 7);
assert(!map_contains(me, &num));
num = 7;
assert(map_remove(me, &num));
assert(map_size(me) == 6);
assert(!map_contains(me, &num));
num = 9;
assert(map_remove(me, &num));
assert(map_size(me) == 5);
assert(!map_contains(me, &num));
num = -5;
assert(map_remove(me, &num));
assert(map_size(me) == 4);
assert(!map_contains(me, &num));
num = 0;
assert(map_remove(me, &num));
assert(map_size(me) == 3);
assert(!map_contains(me, &num));
num = 1;
assert(map_remove(me, &num));
assert(map_size(me) == 2);
assert(!map_contains(me, &num));
num = 5;
assert(map_remove(me, &num));
assert(map_size(me) == 1);
assert(!map_contains(me, &num));
num = 2;
assert(map_remove(me, &num));
assert(map_size(me) == 0);
assert(!map_contains(me, &num));
// Add a lot of items and remove individually.
for (int i = 5000; i < 6000; i++) {
map_put(me, &i, &num);
assert(map_contains(me, &i));
}
assert(map_size(me) == 1000);
for (int i = 5000; i < 5500; i++) {
map_remove(me, &i);
assert(!map_contains(me, &i));
}
assert(map_size(me) == 500);
assert(!map_is_empty(me));
map_clear(me);
assert(map_size(me) == 0);
assert(map_is_empty(me));
// Add a lot of items and clear.
for (int i = 5000; i < 6000; i++) {
map_put(me, &i, &num);
assert(map_contains(me, &i));
}
assert(map_size(me) == 1000);
map_clear(me);
int p = 0xdeadbeef;
assert(!map_remove(me, &p));
assert(map_size(me) == 0);
assert(map_is_empty(me));
me = map_destroy(me);
assert(!me);
// Create odd shape graph.
me = map_init(sizeof(int), sizeof(int), compare_int);
key = 10;
map_put(me, &key, &num);
key = 5;
map_put(me, &key, &num);
key = 15;
map_put(me, &key, &num);
key = 3;
map_put(me, &key, &num);
key = 8;
map_put(me, &key, &num);
key = 12;
map_put(me, &key, &num);
key = 18;
map_put(me, &key, &num);
key = 12;
map_remove(me, &key);
key = 5;
map_remove(me, &key);
key = 3;
map_remove(me, &key);
key = 8;
map_remove(me, &key);
map_clear(me);
// Allocate many nodes.
for (int i = 8123; i < 12314; i += 3) {
map_put(me, &i, &num);
assert(map_contains(me, &i));
}
for (int i = 13000; i > 8000; i--) {
map_remove(me, &i);
assert(!map_contains(me, &i));
}
map_clear(me);
// Create another odd shape graph.
key = 20;
map_put(me, &key, &num);
key = 10;
map_put(me, &key, &num);
key = 40;
map_put(me, &key, &num);
key = 5;
map_put(me, &key, &num);
key = 15;
map_put(me, &key, &num);
key = 30;
map_put(me, &key, &num);
key = 50;
map_put(me, &key, &num);
key = 25;
map_put(me, &key, &num);
key = 35;
map_put(me, &key, &num);
key = 36;
map_put(me, &key, &num);
key = 34;
map_put(me, &key, &num);
key = 33;
map_put(me, &key, &num);
key = 32;
map_put(me, &key, &num);
key = 30;
map_remove(me, &key);
key = 32;
assert(map_contains(me, &key));
map_clear(me);
// One sided tree.
key = 10;
map_put(me, &key, &num);
key = 9;
map_put(me, &key, &num);
key = 8;
map_put(me, &key, &num);
key = 7;
map_put(me, &key, &num);
key = 8;
map_remove(me, &key);
key = 7;
assert(map_contains(me, &key));
map_destroy(me);
// Replace two sided two children.
me = map_init(sizeof(int), sizeof(int), compare_int);
key = 5;
map_put(me, &key, &num);
key = 1;
map_put(me, &key, &num);
key = 6;
map_put(me, &key, &num);
key = -1;
map_put(me, &key, &num);
key = 3;
map_put(me, &key, &num);
key = 7;
map_put(me, &key, &num);
key = -2;
map_put(me, &key, &num);
key = 0;
map_put(me, &key, &num);
key = 2;
map_put(me, &key, &num);
key = 4;
map_put(me, &key, &num);
key = 1;
map_remove(me, &key);
assert(!map_contains(me, &key));
map_clear(me);
key = 5;
map_put(me, &key, &num);
key = 1;
map_put(me, &key, &num);
key = 6;
map_put(me, &key, &num);
key = -1;
map_put(me, &key, &num);
key = 3;
map_put(me, &key, &num);
key = 7;
map_put(me, &key, &num);
key = -2;
map_put(me, &key, &num);
key = 0;
map_put(me, &key, &num);
key = 4;
map_put(me, &key, &num);
key = 1;
map_remove(me, &key);
assert(!map_contains(me, &key));
me = map_destroy(me);
assert(!me);
me = map_init(sizeof(int), sizeof(int), compare_int);
for (int i = 4817; i > -2983; i -= 11) {
map_put(me, &i, &num);
assert(map_contains(me, &i));
}
for (int i = -432; i < 3849; i += 7) {
map_remove(me, &i);
assert(!map_contains(me, &i));
}
map_clear(me);
key = 5;
map_put(me, &key, &num);
key = 7;
map_put(me, &key, &num);
key = 5;
map_remove(me, &key);
map_clear(me);
// Two children edge case other side.
key = 8;
map_put(me, &key, &num);
key = 4;
map_put(me, &key, &num);
key = 12;
map_put(me, &key, &num);
key = 2;
map_put(me, &key, &num);
key = 6;
map_put(me, &key, &num);
key = 10;
map_put(me, &key, &num);
key = 16;
map_put(me, &key, &num);
key = 1;
map_put(me, &key, &num);
key = 3;
map_put(me, &key, &num);
key = 5;
map_put(me, &key, &num);
key = 7;
map_put(me, &key, &num);
key = 9;
map_put(me, &key, &num);
key = 11;
map_put(me, &key, &num);
key = 15;
map_put(me, &key, &num);
key = 17;
map_put(me, &key, &num);
key = 13;
map_put(me, &key, &num);
map_clear(me);
assert(!map_get(&value, me, &key));
}

435
tst/multimap.c
View File

@@ -10,6 +10,10 @@ static int compare_int(const void *const one, const void *const two)
void test_multimap(void)
{
assert(!multimap_init(0, sizeof(int), compare_int, compare_int));
assert(!multimap_init(sizeof(int), 0, compare_int, compare_int));
assert(!multimap_init(sizeof(int), sizeof(int), NULL, compare_int));
assert(!multimap_init(sizeof(int), sizeof(int), compare_int, NULL));
multimap me = multimap_init(sizeof(int), sizeof(int),
compare_int, compare_int);
assert(me);
@@ -146,4 +150,435 @@ void test_multimap(void)
assert(multimap_size(me) == 1);
me = multimap_destroy(me);
assert(!me);
me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
assert(me);
// left-left
key = 5;
multimap_put(me, &key, &num);
key = 3;
multimap_put(me, &key, &num);
key = 1;
multimap_put(me, &key, &num);
key = 0xdeadbeef;
multimap_contains(me, &key);
multimap_clear(me);
// right-right
key = 1;
multimap_put(me, &key, &num);
key = 3;
multimap_put(me, &key, &num);
key = 5;
multimap_put(me, &key, &num);
key = 0xdeadbeef;
multimap_contains(me, &key);
multimap_clear(me);
// left-right
key = 5;
multimap_put(me, &key, &num);
key = 1;
multimap_put(me, &key, &num);
key = 3;
multimap_put(me, &key, &num);
key = 0xdeadbeef;
multimap_contains(me, &key);
multimap_clear(me);
// right-left
key = 1;
multimap_put(me, &key, &num);
key = 5;
multimap_put(me, &key, &num);
key = 3;
multimap_put(me, &key, &num);
key = 0xdeadbeef;
multimap_contains(me, &key);
multimap_clear(me);
// Two children edge case.
key = 8;
multimap_put(me, &key, &num);
key = 5;
multimap_put(me, &key, &num);
key = 11;
multimap_put(me, &key, &num);
key = 2;
multimap_put(me, &key, &num);
key = 6;
multimap_put(me, &key, &num);
key = 10;
multimap_put(me, &key, &num);
key = 15;
multimap_put(me, &key, &num);
key = 1;
multimap_put(me, &key, &num);
key = 3;
multimap_put(me, &key, &num);
key = 4;
multimap_put(me, &key, &num);
key = 7;
multimap_put(me, &key, &num);
key = 9;
multimap_put(me, &key, &num);
key = 12;
multimap_put(me, &key, &num);
key = 13;
multimap_put(me, &key, &num);
key = 16;
multimap_put(me, &key, &num);
key = 14;
multimap_put(me, &key, &num);
multimap_clear(me);
// Two children edge case.
key = 8;
multimap_put(me, &key, &num);
key = 4;
multimap_put(me, &key, &num);
key = 12;
multimap_put(me, &key, &num);
key = 2;
multimap_put(me, &key, &num);
key = 6;
multimap_put(me, &key, &num);
key = 10;
multimap_put(me, &key, &num);
key = 15;
multimap_put(me, &key, &num);
key = 1;
multimap_put(me, &key, &num);
key = 3;
multimap_put(me, &key, &num);
key = 5;
multimap_put(me, &key, &num);
key = 7;
multimap_put(me, &key, &num);
key = 9;
multimap_put(me, &key, &num);
key = 11;
multimap_put(me, &key, &num);
key = 13;
multimap_put(me, &key, &num);
key = 16;
multimap_put(me, &key, &num);
key = 14;
multimap_put(me, &key, &num);
multimap_clear(me);
// Add a lot of items.
count = 0;
bool flip = false;
for (int i = 1234; i < 82400; i++) {
key = i % 765;
multimap_put(me, &key, &num);
assert(multimap_contains(me, &key));
count++;
if (i == 1857 && !flip) {
i *= -1;
flip = true;
}
}
assert(count == multimap_size(me));
multimap_put(me, &key, &num);
multimap_destroy(me);
me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
assert(multimap_size(me) == 0);
assert(multimap_is_empty(me));
key = 4;
multimap_put(me, &key, &num);
assert(multimap_size(me) == 1);
multimap_put(me, &key, &num);
assert(multimap_size(me) == 2);
assert(!multimap_is_empty(me));
assert(multimap_contains(me, &key));
key = 7;
assert(!multimap_contains(me, &key));
multimap_put(me, &key, &num);
assert(multimap_size(me) == 3);
assert(multimap_contains(me, &key));
int c[10] = {5, 9, 4, -5, 0, 6, 1, 5, 7, 2};
for (int i = 0; i < 10; i++) {
multimap_put(me, &c[i], &value);
assert(multimap_contains(me, &c[i]));
}
assert(multimap_size(me) == 13);
for (int i = 0; i < 10; i++) {
assert(multimap_contains(me, &c[i]));
}
for (int i = -100; i < 100; i++) {
bool contains = false;
for (int j = 0; j < 10; j++) {
if (c[j] == i) {
contains = true;
}
}
assert(multimap_contains(me, &i) == contains);
}
num = -3;
assert(!multimap_remove(me, &num, &value));
assert(multimap_size(me) == 13);
assert(!multimap_contains(me, &num));
num = 6;
assert(multimap_remove(me, &num, &value));
assert(multimap_size(me) == 12);
assert(!multimap_contains(me, &num));
num = 4;
assert(multimap_remove(me, &num, &value));
assert(multimap_size(me) == 11);
assert(multimap_contains(me, &num));
num = 7;
assert(multimap_remove(me, &num, &value));
assert(multimap_size(me) == 10);
assert(multimap_contains(me, &num));
num = 9;
assert(multimap_remove(me, &num, &value));
assert(multimap_size(me) == 9);
assert(!multimap_contains(me, &num));
num = -5;
assert(multimap_remove(me, &num, &value));
assert(multimap_size(me) == 8);
assert(!multimap_contains(me, &num));
num = 0;
assert(multimap_remove(me, &num, &value));
assert(multimap_size(me) == 7);
assert(!multimap_contains(me, &num));
num = 1;
assert(multimap_remove(me, &num, &value));
assert(multimap_size(me) == 6);
assert(!multimap_contains(me, &num));
num = 5;
assert(multimap_remove(me, &num, &value));
assert(multimap_size(me) == 5);
assert(multimap_contains(me, &num));
num = 2;
assert(multimap_remove(me, &num, &value));
assert(multimap_size(me) == 4);
assert(!multimap_contains(me, &num));
multimap_clear(me);
// Add a lot of items and remove individually.
value = 37;
for (int i = 5000; i < 6000; i++) {
multimap_put(me, &i, &value);
assert(multimap_contains(me, &i));
}
assert(multimap_size(me) == 1000);
for (int i = 5000; i < 5500; i++) {
multimap_remove(me, &i, &value);
assert(!multimap_contains(me, &i));
}
assert(multimap_size(me) == 500);
assert(!multimap_is_empty(me));
multimap_clear(me);
assert(multimap_size(me) == 0);
assert(multimap_is_empty(me));
// Add a lot of items and clear.
for (int i = 5000; i < 6000; i++) {
multimap_put(me, &i, &num);
assert(multimap_contains(me, &i));
}
assert(multimap_size(me) == 1000);
multimap_clear(me);
int p = 0xdeadbeef;
assert(!multimap_remove(me, &p, &value));
assert(multimap_size(me) == 0);
assert(multimap_is_empty(me));
me = multimap_destroy(me);
assert(!me);
// Create odd shape graph.
me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
key = 10;
multimap_put(me, &key, &num);
key = 5;
multimap_put(me, &key, &num);
key = 15;
multimap_put(me, &key, &num);
key = 3;
multimap_put(me, &key, &num);
key = 8;
multimap_put(me, &key, &num);
key = 12;
multimap_put(me, &key, &num);
key = 18;
multimap_put(me, &key, &num);
key = 12;
multimap_remove(me, &key, &value);
key = 5;
multimap_remove(me, &key, &value);
key = 3;
multimap_remove(me, &key, &value);
key = 8;
multimap_remove(me, &key, &value);
multimap_clear(me);
// Allocate many nodes.
value = 54;
for (int i = 8123; i < 12314; i += 3) {
multimap_put(me, &i, &value);
assert(multimap_contains(me, &i));
}
for (int i = 13000; i > 8000; i--) {
multimap_remove(me, &i, &value);
assert(!multimap_contains(me, &i));
}
multimap_clear(me);
// Create another odd shape graph.
key = 20;
multimap_put(me, &key, &num);
key = 10;
multimap_put(me, &key, &num);
key = 40;
multimap_put(me, &key, &num);
key = 5;
multimap_put(me, &key, &num);
key = 15;
multimap_put(me, &key, &num);
key = 30;
multimap_put(me, &key, &num);
key = 50;
multimap_put(me, &key, &num);
key = 25;
multimap_put(me, &key, &num);
key = 35;
multimap_put(me, &key, &num);
key = 36;
multimap_put(me, &key, &num);
key = 34;
multimap_put(me, &key, &num);
key = 33;
multimap_put(me, &key, &num);
key = 32;
multimap_put(me, &key, &num);
key = 30;
multimap_remove(me, &key, &value);
key = 32;
assert(multimap_contains(me, &key));
multimap_clear(me);
// One sided tree.
key = 10;
multimap_put(me, &key, &num);
key = 9;
multimap_put(me, &key, &num);
key = 8;
multimap_put(me, &key, &num);
key = 7;
multimap_put(me, &key, &num);
key = 8;
multimap_remove(me, &key, &value);
key = 7;
assert(multimap_contains(me, &key));
multimap_destroy(me);
// Replace two sided two children.
me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
key = 5;
multimap_put(me, &key, &num);
key = 1;
multimap_put(me, &key, &num);
key = 6;
multimap_put(me, &key, &num);
key = -1;
multimap_put(me, &key, &num);
key = 3;
multimap_put(me, &key, &num);
key = 7;
multimap_put(me, &key, &num);
key = -2;
multimap_put(me, &key, &num);
key = 0;
multimap_put(me, &key, &num);
key = 2;
multimap_put(me, &key, &num);
key = 4;
multimap_put(me, &key, &num);
key = 1;
multimap_remove_all(me, &key);
assert(!multimap_contains(me, &key));
multimap_clear(me);
key = 5;
multimap_put(me, &key, &num);
key = 1;
multimap_put(me, &key, &num);
key = 6;
multimap_put(me, &key, &num);
key = -1;
multimap_put(me, &key, &num);
key = 3;
multimap_put(me, &key, &num);
key = 7;
multimap_put(me, &key, &num);
key = -2;
multimap_put(me, &key, &num);
key = 0;
multimap_put(me, &key, &num);
key = 4;
multimap_put(me, &key, &num);
key = 1;
multimap_remove_all(me, &key);
assert(!multimap_contains(me, &key));
me = multimap_destroy(me);
assert(!me);
me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
value = 97;
for (int i = 4817; i > -2983; i -= 11) {
multimap_put(me, &i, &value);
assert(multimap_contains(me, &i));
}
for (int i = -432; i < 3849; i += 7) {
multimap_remove(me, &i, &value);
assert(!multimap_contains(me, &i));
}
multimap_clear(me);
key = 5;
multimap_put(me, &key, &num);
key = 7;
multimap_put(me, &key, &num);
key = 5;
multimap_remove(me, &key, &value);
multimap_clear(me);
// Two children edge case other side.
key = 8;
multimap_put(me, &key, &num);
key = 4;
multimap_put(me, &key, &num);
key = 12;
multimap_put(me, &key, &num);
key = 2;
multimap_put(me, &key, &num);
key = 6;
multimap_put(me, &key, &num);
key = 10;
multimap_put(me, &key, &num);
key = 16;
multimap_put(me, &key, &num);
key = 1;
multimap_put(me, &key, &num);
key = 3;
multimap_put(me, &key, &num);
key = 5;
multimap_put(me, &key, &num);
key = 7;
multimap_put(me, &key, &num);
key = 9;
multimap_put(me, &key, &num);
key = 11;
multimap_put(me, &key, &num);
key = 15;
multimap_put(me, &key, &num);
key = 17;
multimap_put(me, &key, &num);
key = 13;
multimap_put(me, &key, &num);
multimap_clear(me);
assert(multimap_count(me, &key) == 0);
assert(!multimap_remove_all(me, &key));
// Edge case.
me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
value = 17;
key = 5;
multimap_put(me, &key, &value);
key = 3;
multimap_put(me, &key, &value);
key = 7;
multimap_put(me, &key, &value);
key = 2;
multimap_put(me, &key, &value);
key = 6;
multimap_put(me, &key, &value);
key = 9;
multimap_put(me, &key, &value);
key = 3;
multimap_remove(me, &key, &value);
}

413
tst/multiset.c
View File

@@ -10,6 +10,8 @@ static int compare_int(const void *const one, const void *const two)
void test_multiset(void)
{
assert(!multiset_init(0, compare_int));
assert(!multiset_init(sizeof(int), NULL));
multiset me = multiset_init(sizeof(int), compare_int);
assert(me);
assert(multiset_size(me) == 0);
@@ -135,4 +137,415 @@ void test_multiset(void)
assert(multiset_size(me) == 1);
me = multiset_destroy(me);
assert(!me);
me = multiset_init(sizeof(int), compare_int);
assert(me);
// left-left
key = 5;
multiset_put(me, &key);
key = 3;
multiset_put(me, &key);
key = 1;
multiset_put(me, &key);
key = 0xdeadbeef;
multiset_contains(me, &key);
multiset_clear(me);
// right-right
key = 1;
multiset_put(me, &key);
key = 3;
multiset_put(me, &key);
key = 5;
multiset_put(me, &key);
key = 0xdeadbeef;
multiset_contains(me, &key);
multiset_clear(me);
// left-right
key = 5;
multiset_put(me, &key);
key = 1;
multiset_put(me, &key);
key = 3;
multiset_put(me, &key);
key = 0xdeadbeef;
multiset_contains(me, &key);
multiset_clear(me);
// right-left
key = 1;
multiset_put(me, &key);
key = 5;
multiset_put(me, &key);
key = 3;
multiset_put(me, &key);
key = 0xdeadbeef;
multiset_contains(me, &key);
multiset_clear(me);
// Two children edge case.
key = 8;
multiset_put(me, &key);
key = 5;
multiset_put(me, &key);
key = 11;
multiset_put(me, &key);
key = 2;
multiset_put(me, &key);
key = 6;
multiset_put(me, &key);
key = 10;
multiset_put(me, &key);
key = 15;
multiset_put(me, &key);
key = 1;
multiset_put(me, &key);
key = 3;
multiset_put(me, &key);
key = 4;
multiset_put(me, &key);
key = 7;
multiset_put(me, &key);
key = 9;
multiset_put(me, &key);
key = 12;
multiset_put(me, &key);
key = 13;
multiset_put(me, &key);
key = 16;
multiset_put(me, &key);
key = 14;
multiset_put(me, &key);
multiset_clear(me);
// Two children edge case.
key = 8;
multiset_put(me, &key);
key = 4;
multiset_put(me, &key);
key = 12;
multiset_put(me, &key);
key = 2;
multiset_put(me, &key);
key = 6;
multiset_put(me, &key);
key = 10;
multiset_put(me, &key);
key = 15;
multiset_put(me, &key);
key = 1;
multiset_put(me, &key);
key = 3;
multiset_put(me, &key);
key = 5;
multiset_put(me, &key);
key = 7;
multiset_put(me, &key);
key = 9;
multiset_put(me, &key);
key = 11;
multiset_put(me, &key);
key = 13;
multiset_put(me, &key);
key = 16;
multiset_put(me, &key);
key = 14;
multiset_put(me, &key);
multiset_clear(me);
// Add a lot of items.
int count = 0;
bool flip = false;
for (int i = 1234; i < 82400; i++) {
key = i % 765;
multiset_put(me, &key);
assert(multiset_contains(me, &key));
count++;
if (i == 1857 && !flip) {
i *= -1;
flip = true;
}
}
assert(count == multiset_size(me));
multiset_contains(me, &key);
multiset_destroy(me);
me = multiset_init(sizeof(int), compare_int);
assert(multiset_size(me) == 0);
assert(multiset_is_empty(me));
key = 4;
multiset_put(me, &key);
assert(multiset_size(me) == 1);
multiset_put(me, &key);
assert(multiset_size(me) == 2);
assert(!multiset_is_empty(me));
assert(multiset_contains(me, &key));
key = 7;
assert(!multiset_contains(me, &key));
multiset_put(me, &key);
assert(multiset_size(me) == 3);
assert(multiset_contains(me, &key));
int c[10] = {5, 9, 4, -5, 0, 6, 1, 5, 7, 2};
for (int i = 0; i < 10; i++) {
multiset_put(me, &c[i]);
assert(multiset_contains(me, &c[i]));
}
assert(multiset_size(me) == 13);
for (int i = 0; i < 10; i++) {
assert(multiset_contains(me, &c[i]));
}
for (int i = -100; i < 100; i++) {
bool contains = false;
for (int j = 0; j < 10; j++) {
if (c[j] == i) {
contains = true;
}
}
assert(multiset_contains(me, &i) == contains);
}
num = -3;
assert(!multiset_remove(me, &num));
assert(multiset_size(me) == 13);
assert(!multiset_contains(me, &num));
num = 6;
assert(multiset_remove(me, &num));
assert(multiset_size(me) == 12);
assert(!multiset_contains(me, &num));
num = 4;
assert(multiset_remove(me, &num));
assert(multiset_size(me) == 11);
assert(multiset_contains(me, &num));
num = 7;
assert(multiset_remove(me, &num));
assert(multiset_size(me) == 10);
assert(multiset_contains(me, &num));
num = 9;
assert(multiset_remove(me, &num));
assert(multiset_size(me) == 9);
assert(!multiset_contains(me, &num));
num = -5;
assert(multiset_remove(me, &num));
assert(multiset_size(me) == 8);
assert(!multiset_contains(me, &num));
num = 0;
assert(multiset_remove(me, &num));
assert(multiset_size(me) == 7);
assert(!multiset_contains(me, &num));
num = 1;
assert(multiset_remove(me, &num));
assert(multiset_size(me) == 6);
assert(!multiset_contains(me, &num));
num = 5;
assert(multiset_remove(me, &num));
assert(multiset_size(me) == 5);
assert(multiset_contains(me, &num));
num = 2;
assert(multiset_remove(me, &num));
assert(multiset_size(me) == 4);
assert(!multiset_contains(me, &num));
multiset_clear(me);
// Add a lot of items and remove individually.
for (int i = 5000; i < 6000; i++) {
multiset_put(me, &i);
assert(multiset_contains(me, &i));
}
assert(multiset_size(me) == 1000);
for (int i = 5000; i < 5500; i++) {
multiset_remove(me, &i);
assert(!multiset_contains(me, &i));
}
assert(multiset_size(me) == 500);
assert(!multiset_is_empty(me));
multiset_clear(me);
assert(multiset_size(me) == 0);
assert(multiset_is_empty(me));
// Add a lot of items and clear.
for (int i = 5000; i < 6000; i++) {
multiset_put(me, &i);
assert(multiset_contains(me, &i));
}
assert(multiset_size(me) == 1000);
multiset_clear(me);
int p = 0xdeadbeef;
assert(!multiset_remove(me, &p));
assert(multiset_size(me) == 0);
assert(multiset_is_empty(me));
me = multiset_destroy(me);
assert(!me);
// Create odd shape graph.
me = multiset_init(sizeof(int), compare_int);
key = 10;
multiset_put(me, &key);
key = 5;
multiset_put(me, &key);
key = 15;
multiset_put(me, &key);
key = 3;
multiset_put(me, &key);
key = 8;
multiset_put(me, &key);
key = 12;
multiset_put(me, &key);
key = 18;
multiset_put(me, &key);
key = 12;
multiset_remove(me, &key);
key = 5;
multiset_remove(me, &key);
key = 3;
multiset_remove(me, &key);
key = 8;
multiset_remove(me, &key);
multiset_clear(me);
// Allocate many nodes.
for (int i = 8123; i < 12314; i += 3) {
multiset_put(me, &i);
assert(multiset_contains(me, &i));
}
for (int i = 13000; i > 8000; i--) {
multiset_remove(me, &i);
assert(!multiset_contains(me, &i));
}
multiset_clear(me);
// Create another odd shape graph.
key = 20;
multiset_put(me, &key);
key = 10;
multiset_put(me, &key);
key = 40;
multiset_put(me, &key);
key = 5;
multiset_put(me, &key);
key = 15;
multiset_put(me, &key);
key = 30;
multiset_put(me, &key);
key = 50;
multiset_put(me, &key);
key = 25;
multiset_put(me, &key);
key = 35;
multiset_put(me, &key);
key = 36;
multiset_put(me, &key);
key = 34;
multiset_put(me, &key);
key = 33;
multiset_put(me, &key);
key = 32;
multiset_put(me, &key);
key = 30;
multiset_remove(me, &key);
key = 32;
assert(multiset_contains(me, &key));
multiset_clear(me);
// One sided tree.
key = 10;
multiset_put(me, &key);
key = 9;
multiset_put(me, &key);
key = 8;
multiset_put(me, &key);
key = 7;
multiset_put(me, &key);
key = 8;
multiset_remove(me, &key);
key = 7;
assert(multiset_contains(me, &key));
multiset_destroy(me);
// Replace two sided two children.
me = multiset_init(sizeof(int), compare_int);
key = 5;
multiset_put(me, &key);
key = 1;
multiset_put(me, &key);
key = 6;
multiset_put(me, &key);
key = -1;
multiset_put(me, &key);
key = 3;
multiset_put(me, &key);
key = 7;
multiset_put(me, &key);
key = -2;
multiset_put(me, &key);
key = 0;
multiset_put(me, &key);
key = 2;
multiset_put(me, &key);
key = 4;
multiset_put(me, &key);
key = 1;
multiset_remove(me, &key);
assert(!multiset_contains(me, &key));
multiset_clear(me);
key = 5;
multiset_put(me, &key);
key = 1;
multiset_put(me, &key);
key = 6;
multiset_put(me, &key);
key = -1;
multiset_put(me, &key);
key = 3;
multiset_put(me, &key);
key = 7;
multiset_put(me, &key);
key = -2;
multiset_put(me, &key);
key = 0;
multiset_put(me, &key);
key = 4;
multiset_put(me, &key);
key = 1;
multiset_remove(me, &key);
assert(!multiset_contains(me, &key));
me = multiset_destroy(me);
assert(!me);
me = multiset_init(sizeof(int), compare_int);
for (int i = 4817; i > -2983; i -= 11) {
multiset_put(me, &i);
assert(multiset_contains(me, &i));
}
for (int i = -432; i < 3849; i += 7) {
multiset_remove(me, &i);
assert(!multiset_contains(me, &i));
}
multiset_clear(me);
key = 5;
multiset_put(me, &key);
key = 7;
multiset_put(me, &key);
key = 5;
multiset_remove(me, &key);
multiset_clear(me);
// Two children edge case other side.
key = 8;
multiset_put(me, &key);
key = 4;
multiset_put(me, &key);
key = 12;
multiset_put(me, &key);
key = 2;
multiset_put(me, &key);
key = 6;
multiset_put(me, &key);
key = 10;
multiset_put(me, &key);
key = 16;
multiset_put(me, &key);
key = 1;
multiset_put(me, &key);
key = 3;
multiset_put(me, &key);
key = 5;
multiset_put(me, &key);
key = 7;
multiset_put(me, &key);
key = 9;
multiset_put(me, &key);
key = 11;
multiset_put(me, &key);
key = 15;
multiset_put(me, &key);
key = 17;
multiset_put(me, &key);
key = 13;
multiset_put(me, &key);
multiset_clear(me);
assert(multiset_count(me, &key) == 0);
assert(!multiset_remove_all(me, &key));
}

7
tst/priority_queue.c
View File

@@ -55,11 +55,16 @@ bool stub_priority_queue_pop(void *const data, priority_queue me)
void test_priority_queue(void)
{
assert(!priority_queue_init(0, compare_int));
assert(!priority_queue_init(sizeof(int), NULL));
priority_queue me = priority_queue_init(sizeof(int), compare_int);
assert(me);
assert(priority_queue_size(me) == 0);
assert(priority_queue_is_empty(me));
int item = 5;
int item = 0xdeadbeef;
assert(!priority_queue_pop(&item, me));
assert(item == 0xdeadbeef);
item = 5;
stub_priority_queue_push(me, &item);
item = 2;
stub_priority_queue_push(me, &item);

1
tst/queue.c
View File

@@ -3,6 +3,7 @@
void test_queue(void)
{
assert(!queue_init(0));
int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
queue me = queue_init(sizeof(int));
assert(me);

53
tst/set.c
View File

@@ -114,6 +114,8 @@ static int compare_int(const void *const one, const void *const two)
void test_set(void)
{
assert(!set_init(0, compare_int));
assert(!set_init(sizeof(int), NULL));
set me = set_init(sizeof(int), compare_int);
assert(me);
int key;
@@ -476,4 +478,55 @@ void test_set(void)
assert(!stub_set_contains(me, &key));
me = stub_set_destroy(me);
assert(!me);
me = set_init(sizeof(int), compare_int);
for (int i = 4817; i > -2983; i -= 11) {
stub_set_put(me, &i);
assert(stub_set_contains(me, &i));
}
for (int i = -432; i < 3849; i += 7) {
stub_set_remove(me, &i);
assert(!stub_set_contains(me, &i));
}
stub_set_clear(me);
key = 5;
stub_set_put(me, &key);
key = 7;
stub_set_put(me, &key);
key = 5;
stub_set_remove(me, &key);
stub_set_clear(me);
// Two children edge case other side.
key = 8;
stub_set_put(me, &key);
key = 4;
stub_set_put(me, &key);
key = 12;
stub_set_put(me, &key);
key = 2;
stub_set_put(me, &key);
key = 6;
stub_set_put(me, &key);
key = 10;
stub_set_put(me, &key);
key = 16;
stub_set_put(me, &key);
key = 1;
stub_set_put(me, &key);
key = 3;
stub_set_put(me, &key);
key = 5;
stub_set_put(me, &key);
key = 7;
stub_set_put(me, &key);
key = 9;
stub_set_put(me, &key);
key = 11;
stub_set_put(me, &key);
key = 15;
stub_set_put(me, &key);
key = 17;
stub_set_put(me, &key);
key = 13;
stub_set_put(me, &key);
stub_set_clear(me);
}

1
tst/stack.c
View File

@@ -3,6 +3,7 @@
void test_stack(void)
{
assert(!stack_init(0));
int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
stack me = stack_init(sizeof(int));
assert(me);

35
tst/unordered_map.c
View File

@@ -18,10 +18,19 @@ static unsigned long hash_int(const void *const key)
return hash;
}
static unsigned long bad_hash_int(const void *const key)
{
return 5;
}
void test_unordered_map(void)
{
assert(!unordered_map_init(0, sizeof(int), hash_int, compare_int));
assert(!unordered_map_init(sizeof(int), 0, hash_int, compare_int));
assert(!unordered_map_init(sizeof(int), sizeof(int), NULL, compare_int));
assert(!unordered_map_init(sizeof(int), sizeof(int), hash_int, NULL));
unordered_map me = unordered_map_init(sizeof(int), sizeof(int),
hash_int, compare_int);
hash_int, compare_int);
assert(unordered_map_size(me) == 0);
assert(unordered_map_is_empty(me));
int key = 4;
@@ -129,5 +138,27 @@ void test_unordered_map(void)
assert(unordered_map_size(me) == 0);
assert(unordered_map_is_empty(me));
me = unordered_map_destroy(me);
assert(me == NULL);
assert(!me);
me = unordered_map_init(sizeof(int), sizeof(int), bad_hash_int,
compare_int);
num = 1;
unordered_map_put(me, &num, &num);
num = 2;
unordered_map_put(me, &num, &num);
num = 3;
unordered_map_put(me, &num, &num);
num = 4;
unordered_map_put(me, &num, &num);
assert(unordered_map_size(me) == 4);
unordered_map_put(me, &num, &num);
assert(unordered_map_size(me) == 4);
assert(unordered_map_remove(me, &num));
assert(!unordered_map_remove(me, &num));
assert(unordered_map_size(me) == 3);
unordered_map_rehash(me);
assert(unordered_map_size(me) == 3);
key = 5;
value = 0xdeadbeef;
assert(!unordered_map_get(&value, me, &key));
assert(value == 0xdeadbeef);
}

83
tst/unordered_multimap.c
View File

@@ -18,8 +18,23 @@ static unsigned long hash_int(const void *const key)
return hash;
}
static unsigned long bad_hash_int(const void *const key)
{
return 5;
}
void test_unordered_multimap(void)
{
assert(!unordered_multimap_init(0, sizeof(int), hash_int, compare_int,
compare_int));
assert(!unordered_multimap_init(sizeof(int), 0, hash_int, compare_int,
compare_int));
assert(!unordered_multimap_init(sizeof(int), sizeof(int), NULL, compare_int,
compare_int));
assert(!unordered_multimap_init(sizeof(int), sizeof(int), hash_int, NULL,
compare_int));
assert(!unordered_multimap_init(sizeof(int), sizeof(int), hash_int,
compare_int, NULL));
unordered_multimap me =
unordered_multimap_init(sizeof(int), sizeof(int), hash_int,
compare_int, compare_int);
@@ -160,4 +175,72 @@ void test_unordered_multimap(void)
assert(unordered_multimap_size(me) == 1);
me = unordered_multimap_destroy(me);
assert(!me);
me = unordered_multimap_init(sizeof(int), sizeof(int), bad_hash_int,
compare_int, compare_int);
key = 1;
unordered_multimap_put(me, &key, &value);
key = 2;
unordered_multimap_put(me, &key, &value);
key = 3;
unordered_multimap_put(me, &key, &value);
assert(unordered_multimap_size(me) == 3);
unordered_multimap_put(me, &key, &value);
assert(unordered_multimap_size(me) == 4);
key = 4;
unordered_multimap_put(me, &key, &value);
assert(unordered_multimap_size(me) == 5);
assert(unordered_multimap_remove(me, &key, &value));
assert(!unordered_multimap_remove(me, &key, &value));
assert(unordered_multimap_size(me) == 4);
unordered_multimap_rehash(me);
assert(unordered_multimap_size(me) == 4);
me = unordered_multimap_init(sizeof(int), sizeof(int), bad_hash_int,
compare_int, compare_int);
key = 1;
unordered_multimap_put(me, &key, &value);
key = 2;
unordered_multimap_put(me, &key, &value);
key = 3;
unordered_multimap_put(me, &key, &value);
assert(unordered_multimap_size(me) == 3);
unordered_multimap_put(me, &key, &value);
assert(unordered_multimap_size(me) == 4);
key = 4;
unordered_multimap_put(me, &key, &value);
assert(unordered_multimap_size(me) == 5);
assert(unordered_multimap_remove_all(me, &key));
assert(!unordered_multimap_remove_all(me, &key));
assert(unordered_multimap_size(me) == 4);
unordered_multimap_rehash(me);
assert(unordered_multimap_size(me) == 4);
unordered_multimap_clear(me);
assert(unordered_multimap_size(me) == 0);
assert(!unordered_multimap_remove_all(me, &key));
assert(unordered_multimap_size(me) == 0);
me = unordered_multimap_init(sizeof(int), sizeof(int), bad_hash_int,
compare_int, compare_int);
key = 1;
value = 10;
unordered_multimap_put(me, &key, &value);
key = 2;
value = 11;
unordered_multimap_put(me, &key, &value);
key = 3;
value = 12;
unordered_multimap_put(me, &key, &value);
key = 4;
value = 14;
unordered_multimap_put(me, &key, &value);
key = 3;
value = 13;
unordered_multimap_put(me, &key, &value);
unordered_multimap_get_start(me, &key);
value = 20;
unordered_multimap_get_next(&value, me);
assert(value == 12);
unordered_multimap_get_next(&value, me);
assert(value == 13);
value = 30;
assert(!unordered_multimap_get_next(&value, me));
assert(value == 30);
}

48
tst/unordered_multiset.c
View File

@@ -18,8 +18,16 @@ static unsigned long hash_int(const void *const key)
return hash;
}
static unsigned long bad_hash_int(const void *const key)
{
return 5;
}
void test_unordered_multiset(void)
{
assert(!unordered_multiset_init(0, hash_int, compare_int));
assert(!unordered_multiset_init(sizeof(int), NULL, compare_int));
assert(!unordered_multiset_init(sizeof(int), hash_int, NULL));
unordered_multiset me =
unordered_multiset_init(sizeof(int), hash_int, compare_int);
assert(me);
@@ -148,4 +156,44 @@ void test_unordered_multiset(void)
assert(unordered_multiset_size(me) == 1);
me = unordered_multiset_destroy(me);
assert(!me);
me = unordered_multiset_init(sizeof(int), bad_hash_int, compare_int);
num = 1;
unordered_multiset_put(me, &num);
num = 2;
unordered_multiset_put(me, &num);
num = 3;
unordered_multiset_put(me, &num);
assert(unordered_multiset_size(me) == 3);
unordered_multiset_put(me, &num);
assert(unordered_multiset_size(me) == 4);
num = 4;
unordered_multiset_put(me, &num);
assert(unordered_multiset_size(me) == 5);
assert(unordered_multiset_remove(me, &num));
assert(!unordered_multiset_remove(me, &num));
assert(unordered_multiset_size(me) == 4);
unordered_multiset_rehash(me);
assert(unordered_multiset_size(me) == 4);
me = unordered_multiset_init(sizeof(int), bad_hash_int, compare_int);
num = 1;
unordered_multiset_put(me, &num);
num = 2;
unordered_multiset_put(me, &num);
num = 3;
unordered_multiset_put(me, &num);
assert(unordered_multiset_size(me) == 3);
unordered_multiset_put(me, &num);
assert(unordered_multiset_size(me) == 4);
num = 4;
unordered_multiset_put(me, &num);
assert(unordered_multiset_size(me) == 5);
assert(unordered_multiset_remove_all(me, &num));
assert(!unordered_multiset_remove_all(me, &num));
assert(unordered_multiset_size(me) == 4);
unordered_multiset_rehash(me);
assert(unordered_multiset_size(me) == 4);
unordered_multiset_clear(me);
assert(unordered_multiset_size(me) == 0);
assert(!unordered_multiset_remove_all(me, &num));
assert(unordered_multiset_size(me) == 0);
}

25
tst/unordered_set.c
View File

@@ -18,8 +18,16 @@ static unsigned long hash_int(const void *const key)
return hash;
}
static unsigned long bad_hash_int(const void *const key)
{
return 5;
}
void test_unordered_set(void)
{
assert(!unordered_set_init(0, hash_int, compare_int));
assert(!unordered_set_init(sizeof(int), NULL, compare_int));
assert(!unordered_set_init(sizeof(int), hash_int, NULL));
unordered_set me = unordered_set_init(sizeof(int), hash_int, compare_int);
assert(me);
assert(unordered_set_size(me) == 0);
@@ -125,4 +133,21 @@ void test_unordered_set(void)
assert(unordered_set_is_empty(me));
me = unordered_set_destroy(me);
assert(!me);
me = unordered_set_init(sizeof(int), bad_hash_int, compare_int);
num = 1;
unordered_set_put(me, &num);
num = 2;
unordered_set_put(me, &num);
num = 3;
unordered_set_put(me, &num);
num = 4;
unordered_set_put(me, &num);
assert(unordered_set_size(me) == 4);
unordered_set_put(me, &num);
assert(unordered_set_size(me) == 4);
assert(unordered_set_remove(me, &num));
assert(!unordered_set_remove(me, &num));
assert(unordered_set_size(me) == 3);
unordered_set_rehash(me);
assert(unordered_set_size(me) == 3);
}

7
tst/vector.c
View File

@@ -63,6 +63,7 @@ static void test_vector_dynamic(void)
void test_vector(void)
{
assert(!vector_init(0));
int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
vector me = vector_init(sizeof(int));
assert(me);
@@ -158,6 +159,7 @@ void test_vector(void)
assert(arr[0] == -5);
assert(arr[1] == -6);
assert(arr[2] == -7);
assert(vector_reserve(me, 100) == 0);
assert(vector_set_at(me, 4, &set) == -EINVAL);
assert(vector_get_at(&set, me, 4) == -EINVAL);
assert(vector_remove_at(me, 4) == -EINVAL);
@@ -167,6 +169,11 @@ void test_vector(void)
assert(vector_remove_at(me, -1) == -EINVAL);
assert(vector_add_at(me, -1, &set) == -EINVAL);
vector_clear(me);
for (int i = 0; i < 32; i++) {
vector_add_last(me, &i);
}
vector_clear(me);
assert(vector_capacity(me) == 8);
assert(vector_size(me) == 0);
assert(vector_is_empty(me));
assert(vector_remove_first(me) == -EINVAL);