Imagelibrary/Containers
1
0
Fork 0
mirror of https://github.com/bkthomps/Containers.git synced 2025-12-26 01:07:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add invariant checking in set test

Browse Source
This commit is contained in:
Bailey Thompson
2017-12-29 11:45:05 -05:00
committed by GitHub
parent 27c04c204a
commit e5c15efe41
1 changed files with 214 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

344
tst/set.c
View File

@@ -1,6 +1,90 @@
#include "test.h" #include "test.h"
#include "../src/set.h" #include "../src/set.h"
// Used for thorough testing, but takes longer to run.
#define LONG_TEST
/*
* Include this struct for the stubs.
*/
struct _set {
size_t key_size;
int (*comparator)(const void *const one, const void *const two);
int size;
struct node *root;
};
/*
* Include this struct for the stubs.
*/
struct node {
struct node *parent;
int balance;
void *key;
struct node *left;
struct node *right;
};
/*
* Verifies that the AVL tree rules are followed. The balance factor of an item
* must be the right height minus the left height. Also, the left key must be
* less than the right key.
*/
static int set_verify_recursive(struct node *const item)
{
#ifdef LONG_TEST
if (item == NULL) {
return 0;
}
const int left = set_verify_recursive(item->left);
const int right = set_verify_recursive(item->right);
const int max = left > right ? left : right;
assert(right - left == item->balance);
if (item->left != NULL && item->right != NULL) {
const int left_val = *(int *) item->left->key;
const int right_val = *(int *) item->right->key;
assert(left_val < right_val);
}
return max + 1;
#else
return 0;
#endif
}
static int stub_set_add(set me, void *key)
{
const int ret = set_add(me, key);
set_verify_recursive(me->root);
return ret;
}
static bool stub_set_contains(set me, void *key)
{
const bool ret = set_contains(me, key);
set_verify_recursive(me->root);
return ret;
}
static bool stub_set_remove(set me, void *key)
{
const bool ret = set_remove(me, key);
set_verify_recursive(me->root);
return ret;
}
static void stub_set_clear(set me)
{
set_clear(me);
set_verify_recursive(me->root);
}
static set stub_set_destroy(set me)
{
set_destroy(me);
set_verify_recursive(me->root);
return NULL;
}
static int compare_int(const void *const one, const void *const two) static int compare_int(const void *const one, const void *const two)
{ {
const int a = *(int *) one; const int a = *(int *) one;
@@ -14,51 +98,51 @@ void test_set(void)
int b; int b;
// left-left // left-left
b = 5; b = 5;
set_add(a, &b); stub_set_add(a, &b);
b = 3; b = 3;
set_add(a, &b); stub_set_add(a, &b);
b = 1; b = 1;
set_add(a, &b); stub_set_add(a, &b);
b = 0xdeadbeef; b = 0xdeadbeef;
set_contains(a, &b); stub_set_contains(a, &b);
set_clear(a); stub_set_clear(a);
// right-right // right-right
b = 1; b = 1;
set_add(a, &b); stub_set_add(a, &b);
b = 3; b = 3;
set_add(a, &b); stub_set_add(a, &b);
b = 5; b = 5;
set_add(a, &b); stub_set_add(a, &b);
b = 0xdeadbeef; b = 0xdeadbeef;
set_contains(a, &b); stub_set_contains(a, &b);
set_clear(a); stub_set_clear(a);
// left-right // left-right
b = 5; b = 5;
set_add(a, &b); stub_set_add(a, &b);
b = 1; b = 1;
set_add(a, &b); stub_set_add(a, &b);
b = 3; b = 3;
set_add(a, &b); stub_set_add(a, &b);
b = 0xdeadbeef; b = 0xdeadbeef;
set_contains(a, &b); stub_set_contains(a, &b);
set_clear(a); stub_set_clear(a);
// right-left // right-left
b = 1; b = 1;
set_add(a, &b); stub_set_add(a, &b);
b = 5; b = 5;
set_add(a, &b); stub_set_add(a, &b);
b = 3; b = 3;
set_add(a, &b); stub_set_add(a, &b);
b = 0xdeadbeef; b = 0xdeadbeef;
set_contains(a, &b); stub_set_contains(a, &b);
set_clear(a); stub_set_clear(a);
int count = 0; int count = 0;
bool flip = false; bool flip = false;
for (int i = 1234; i < 82400; i++) { for (int i = 1234; i < 82400; i++) {
int n = i % 765; int n = i % 765;
const bool is_already_present = set_contains(a, &n); const bool is_already_present = stub_set_contains(a, &n);
set_add(a, &n); stub_set_add(a, &n);
const bool is_now_present = set_contains(a, &n); const bool is_now_present = stub_set_contains(a, &n);
assert(is_now_present); assert(is_now_present);
if (!is_already_present && is_now_present) { if (!is_already_present && is_now_present) {
count++; count++;
@@ -69,31 +153,31 @@ void test_set(void)
} }
} }
assert(count == set_size(a)); assert(count == set_size(a));
set_contains(a, &b); stub_set_contains(a, &b);
set_destroy(a); stub_set_destroy(a);
a = set_init(sizeof(int), compare_int); a = set_init(sizeof(int), compare_int);
assert(set_size(a) == 0); assert(set_size(a) == 0);
assert(set_is_empty(a)); assert(set_is_empty(a));
b = 4; b = 4;
set_add(a, &b); stub_set_add(a, &b);
assert(set_size(a) == 1); assert(set_size(a) == 1);
set_add(a, &b); stub_set_add(a, &b);
assert(set_size(a) == 1); assert(set_size(a) == 1);
assert(!set_is_empty(a)); assert(!set_is_empty(a));
assert(set_contains(a, &b)); assert(stub_set_contains(a, &b));
b = 7; b = 7;
assert(!set_contains(a, &b)); assert(!stub_set_contains(a, &b));
set_add(a, &b); stub_set_add(a, &b);
assert(set_size(a) == 2); assert(set_size(a) == 2);
assert(set_contains(a, &b)); assert(stub_set_contains(a, &b));
int c[10] = {5, 9, 4, -5, 0, 6, 1, 5, 7, 2}; int c[10] = {5, 9, 4, -5, 0, 6, 1, 5, 7, 2};
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
set_add(a, &c[i]); stub_set_add(a, &c[i]);
assert(set_contains(a, &c[i])); assert(stub_set_contains(a, &c[i]));
} }
assert(set_size(a) == 9); assert(set_size(a) == 9);
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
assert(set_contains(a, &c[i])); assert(stub_set_contains(a, &c[i]));
} }
for (int i = -100; i < 100; i++) { for (int i = -100; i < 100; i++) {
bool contains = false; bool contains = false;
@@ -102,203 +186,203 @@ void test_set(void)
contains = true; contains = true;
} }
} }
assert(set_contains(a, &i) == contains); assert(stub_set_contains(a, &i) == contains);
} }
int num = -3; int num = -3;
assert(!set_remove(a, &num)); assert(!stub_set_remove(a, &num));
assert(set_size(a) == 9); assert(set_size(a) == 9);
assert(!set_contains(a, &num)); assert(!stub_set_contains(a, &num));
num = 6; num = 6;
assert(set_remove(a, &num)); assert(stub_set_remove(a, &num));
assert(set_size(a) == 8); assert(set_size(a) == 8);
assert(!set_contains(a, &num)); assert(!stub_set_contains(a, &num));
num = 4; num = 4;
assert(set_remove(a, &num)); assert(stub_set_remove(a, &num));
assert(set_size(a) == 7); assert(set_size(a) == 7);
assert(!set_contains(a, &num)); assert(!stub_set_contains(a, &num));
num = 7; num = 7;
assert(set_remove(a, &num)); assert(stub_set_remove(a, &num));
assert(set_size(a) == 6); assert(set_size(a) == 6);
assert(!set_contains(a, &num)); assert(!stub_set_contains(a, &num));
num = 9; num = 9;
assert(set_remove(a, &num)); assert(stub_set_remove(a, &num));
assert(set_size(a) == 5); assert(set_size(a) == 5);
assert(!set_contains(a, &num)); assert(!stub_set_contains(a, &num));
num = -5; num = -5;
assert(set_remove(a, &num)); assert(stub_set_remove(a, &num));
assert(set_size(a) == 4); assert(set_size(a) == 4);
assert(!set_contains(a, &num)); assert(!stub_set_contains(a, &num));
num = 0; num = 0;
assert(set_remove(a, &num)); assert(stub_set_remove(a, &num));
assert(set_size(a) == 3); assert(set_size(a) == 3);
assert(!set_contains(a, &num)); assert(!stub_set_contains(a, &num));
num = 1; num = 1;
assert(set_remove(a, &num)); assert(stub_set_remove(a, &num));
assert(set_size(a) == 2); assert(set_size(a) == 2);
assert(!set_contains(a, &num)); assert(!stub_set_contains(a, &num));
num = 5; num = 5;
assert(set_remove(a, &num)); assert(stub_set_remove(a, &num));
assert(set_size(a) == 1); assert(set_size(a) == 1);
assert(!set_contains(a, &num)); assert(!stub_set_contains(a, &num));
num = 2; num = 2;
assert(set_remove(a, &num)); assert(stub_set_remove(a, &num));
assert(set_size(a) == 0); assert(set_size(a) == 0);
assert(!set_contains(a, &num)); assert(!stub_set_contains(a, &num));
// Add a lot of items and remove individually. // Add a lot of items and remove individually.
for (int i = 5000; i < 6000; i++) { for (int i = 5000; i < 6000; i++) {
set_add(a, &i); stub_set_add(a, &i);
assert(set_contains(a, &i)); assert(stub_set_contains(a, &i));
} }
assert(set_size(a) == 1000); assert(set_size(a) == 1000);
for (int i = 5000; i < 5500; i++) { for (int i = 5000; i < 5500; i++) {
set_remove(a, &i); stub_set_remove(a, &i);
assert(!set_contains(a, &i)); assert(!stub_set_contains(a, &i));
} }
assert(set_size(a) == 500); assert(set_size(a) == 500);
assert(!set_is_empty(a)); assert(!set_is_empty(a));
set_clear(a); stub_set_clear(a);
assert(set_size(a) == 0); assert(set_size(a) == 0);
assert(set_is_empty(a)); assert(set_is_empty(a));
// Add a lot of items and clear. // Add a lot of items and clear.
for (int i = 5000; i < 6000; i++) { for (int i = 5000; i < 6000; i++) {
set_add(a, &i); stub_set_add(a, &i);
assert(set_contains(a, &i)); assert(stub_set_contains(a, &i));
} }
assert(set_size(a) == 1000); assert(set_size(a) == 1000);
set_clear(a); stub_set_clear(a);
int p = 0xdeadbeef; int p = 0xdeadbeef;
assert(!set_remove(a, &p)); assert(!stub_set_remove(a, &p));
assert(set_size(a) == 0); assert(set_size(a) == 0);
assert(set_is_empty(a)); assert(set_is_empty(a));
a = set_destroy(a); a = stub_set_destroy(a);
assert(a == NULL); assert(a == NULL);
// Create odd shape graph. // Create odd shape graph.
a = set_init(sizeof(int), compare_int); a = set_init(sizeof(int), compare_int);
int tmp = 10; int tmp = 10;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 5; tmp = 5;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 15; tmp = 15;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 3; tmp = 3;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 8; tmp = 8;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 12; tmp = 12;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 18; tmp = 18;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 12; tmp = 12;
set_remove(a, &tmp); stub_set_remove(a, &tmp);
tmp = 5; tmp = 5;
set_remove(a, &tmp); stub_set_remove(a, &tmp);
tmp = 3; tmp = 3;
set_remove(a, &tmp); stub_set_remove(a, &tmp);
tmp = 8; tmp = 8;
set_remove(a, &tmp); stub_set_remove(a, &tmp);
set_clear(a); stub_set_clear(a);
// Allocate many nodes. // Allocate many nodes.
for (int i = 8123; i < 12314; i += 3) { for (int i = 8123; i < 12314; i += 3) {
set_add(a, &i); stub_set_add(a, &i);
assert(set_contains(a, &i)); assert(stub_set_contains(a, &i));
} }
for (int i = 13000; i > 8000; i--) { for (int i = 13000; i > 8000; i--) {
set_remove(a, &i); stub_set_remove(a, &i);
assert(!set_contains(a, &i)); assert(!stub_set_contains(a, &i));
} }
set_clear(a); stub_set_clear(a);
// Create another odd shape graph. // Create another odd shape graph.
tmp = 20; tmp = 20;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 10; tmp = 10;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 40; tmp = 40;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 5; tmp = 5;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 15; tmp = 15;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 30; tmp = 30;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 50; tmp = 50;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 25; tmp = 25;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 35; tmp = 35;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 36; tmp = 36;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 34; tmp = 34;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 33; tmp = 33;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 32; tmp = 32;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 30; tmp = 30;
set_remove(a, &tmp); stub_set_remove(a, &tmp);
tmp = 32; tmp = 32;
assert(set_contains(a, &tmp)); assert(stub_set_contains(a, &tmp));
set_clear(a); stub_set_clear(a);
// One sided tree. // One sided tree.
tmp = 10; tmp = 10;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 9; tmp = 9;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 8; tmp = 8;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 7; tmp = 7;
set_add(a, &tmp); stub_set_add(a, &tmp);
tmp = 8; tmp = 8;
set_remove(a, &tmp); stub_set_remove(a, &tmp);
tmp = 7; tmp = 7;
assert(set_contains(a, &tmp)); assert(stub_set_contains(a, &tmp));
set_destroy(a); stub_set_destroy(a);
// Replace two sided two children // Replace two sided two children
a = set_init(sizeof(int), compare_int); a = set_init(sizeof(int), compare_int);
b = 5; b = 5;
set_add(a, &b); stub_set_add(a, &b);
b = 1; b = 1;
set_add(a, &b); stub_set_add(a, &b);
b = 6; b = 6;
set_add(a, &b); stub_set_add(a, &b);
b = -1; b = -1;
set_add(a, &b); stub_set_add(a, &b);
b = 3; b = 3;
set_add(a, &b); stub_set_add(a, &b);
b = 7; b = 7;
set_add(a, &b); stub_set_add(a, &b);
b = -2; b = -2;
set_add(a, &b); stub_set_add(a, &b);
b = 0; b = 0;
set_add(a, &b); stub_set_add(a, &b);
b = 2; b = 2;
set_add(a, &b); stub_set_add(a, &b);
b = 4; b = 4;
set_add(a, &b); stub_set_add(a, &b);
b = 1; b = 1;
set_remove(a, &b); stub_set_remove(a, &b);
assert(!set_contains(a, &b)); assert(!stub_set_contains(a, &b));
set_clear(a); stub_set_clear(a);
b = 5; b = 5;
set_add(a, &b); stub_set_add(a, &b);
b = 1; b = 1;
set_add(a, &b); stub_set_add(a, &b);
b = 6; b = 6;
set_add(a, &b); stub_set_add(a, &b);
b = -1; b = -1;
set_add(a, &b); stub_set_add(a, &b);
b = 3; b = 3;
set_add(a, &b); stub_set_add(a, &b);
b = 7; b = 7;
set_add(a, &b); stub_set_add(a, &b);
b = -2; b = -2;
set_add(a, &b); stub_set_add(a, &b);
b = 0; b = 0;
set_add(a, &b); stub_set_add(a, &b);
b = 4; b = 4;
set_add(a, &b); stub_set_add(a, &b);
b = 1; b = 1;
set_remove(a, &b); stub_set_remove(a, &b);
assert(!set_contains(a, &b)); assert(!stub_set_contains(a, &b));
set_destroy(a); stub_set_destroy(a);
} }