mirror of
https://github.com/bkthomps/Containers.git
synced 2025-11-16 12:34:47 +00:00
Add invariant checking in set test
This commit is contained in:
Bailey Thompson
344
tst/set.c
344
tst/set.c
@@ -1,6 +1,90 @@
|
||||
#include "test.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)
|
||||
{
|
||||
const int a = *(int *) one;
|
||||
@@ -14,51 +98,51 @@ void test_set(void)
|
||||
int b;
|
||||
// left-left
|
||||
b = 5;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 3;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 1;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 0xdeadbeef;
|
||||
set_contains(a, &b);
|
||||
set_clear(a);
|
||||
stub_set_contains(a, &b);
|
||||
stub_set_clear(a);
|
||||
// right-right
|
||||
b = 1;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 3;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 5;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 0xdeadbeef;
|
||||
set_contains(a, &b);
|
||||
set_clear(a);
|
||||
stub_set_contains(a, &b);
|
||||
stub_set_clear(a);
|
||||
// left-right
|
||||
b = 5;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 1;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 3;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 0xdeadbeef;
|
||||
set_contains(a, &b);
|
||||
set_clear(a);
|
||||
stub_set_contains(a, &b);
|
||||
stub_set_clear(a);
|
||||
// right-left
|
||||
b = 1;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 5;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 3;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 0xdeadbeef;
|
||||
set_contains(a, &b);
|
||||
set_clear(a);
|
||||
stub_set_contains(a, &b);
|
||||
stub_set_clear(a);
|
||||
int count = 0;
|
||||
bool flip = false;
|
||||
for (int i = 1234; i < 82400; i++) {
|
||||
int n = i % 765;
|
||||
const bool is_already_present = set_contains(a, &n);
|
||||
set_add(a, &n);
|
||||
const bool is_now_present = set_contains(a, &n);
|
||||
const bool is_already_present = stub_set_contains(a, &n);
|
||||
stub_set_add(a, &n);
|
||||
const bool is_now_present = stub_set_contains(a, &n);
|
||||
assert(is_now_present);
|
||||
if (!is_already_present && is_now_present) {
|
||||
count++;
|
||||
@@ -69,31 +153,31 @@ void test_set(void)
|
||||
}
|
||||
}
|
||||
assert(count == set_size(a));
|
||||
set_contains(a, &b);
|
||||
set_destroy(a);
|
||||
stub_set_contains(a, &b);
|
||||
stub_set_destroy(a);
|
||||
a = set_init(sizeof(int), compare_int);
|
||||
assert(set_size(a) == 0);
|
||||
assert(set_is_empty(a));
|
||||
b = 4;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
assert(set_size(a) == 1);
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
assert(set_size(a) == 1);
|
||||
assert(!set_is_empty(a));
|
||||
assert(set_contains(a, &b));
|
||||
assert(stub_set_contains(a, &b));
|
||||
b = 7;
|
||||
assert(!set_contains(a, &b));
|
||||
set_add(a, &b);
|
||||
assert(!stub_set_contains(a, &b));
|
||||
stub_set_add(a, &b);
|
||||
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};
|
||||
for (int i = 0; i < 10; i++) {
|
||||
set_add(a, &c[i]);
|
||||
assert(set_contains(a, &c[i]));
|
||||
stub_set_add(a, &c[i]);
|
||||
assert(stub_set_contains(a, &c[i]));
|
||||
}
|
||||
assert(set_size(a) == 9);
|
||||
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++) {
|
||||
bool contains = false;
|
||||
@@ -102,203 +186,203 @@ void test_set(void)
|
||||
contains = true;
|
||||
}
|
||||
}
|
||||
assert(set_contains(a, &i) == contains);
|
||||
assert(stub_set_contains(a, &i) == contains);
|
||||
}
|
||||
int num = -3;
|
||||
assert(!set_remove(a, &num));
|
||||
assert(!stub_set_remove(a, &num));
|
||||
assert(set_size(a) == 9);
|
||||
assert(!set_contains(a, &num));
|
||||
assert(!stub_set_contains(a, &num));
|
||||
num = 6;
|
||||
assert(set_remove(a, &num));
|
||||
assert(stub_set_remove(a, &num));
|
||||
assert(set_size(a) == 8);
|
||||
assert(!set_contains(a, &num));
|
||||
assert(!stub_set_contains(a, &num));
|
||||
num = 4;
|
||||
assert(set_remove(a, &num));
|
||||
assert(stub_set_remove(a, &num));
|
||||
assert(set_size(a) == 7);
|
||||
assert(!set_contains(a, &num));
|
||||
assert(!stub_set_contains(a, &num));
|
||||
num = 7;
|
||||
assert(set_remove(a, &num));
|
||||
assert(stub_set_remove(a, &num));
|
||||
assert(set_size(a) == 6);
|
||||
assert(!set_contains(a, &num));
|
||||
assert(!stub_set_contains(a, &num));
|
||||
num = 9;
|
||||
assert(set_remove(a, &num));
|
||||
assert(stub_set_remove(a, &num));
|
||||
assert(set_size(a) == 5);
|
||||
assert(!set_contains(a, &num));
|
||||
assert(!stub_set_contains(a, &num));
|
||||
num = -5;
|
||||
assert(set_remove(a, &num));
|
||||
assert(stub_set_remove(a, &num));
|
||||
assert(set_size(a) == 4);
|
||||
assert(!set_contains(a, &num));
|
||||
assert(!stub_set_contains(a, &num));
|
||||
num = 0;
|
||||
assert(set_remove(a, &num));
|
||||
assert(stub_set_remove(a, &num));
|
||||
assert(set_size(a) == 3);
|
||||
assert(!set_contains(a, &num));
|
||||
assert(!stub_set_contains(a, &num));
|
||||
num = 1;
|
||||
assert(set_remove(a, &num));
|
||||
assert(stub_set_remove(a, &num));
|
||||
assert(set_size(a) == 2);
|
||||
assert(!set_contains(a, &num));
|
||||
assert(!stub_set_contains(a, &num));
|
||||
num = 5;
|
||||
assert(set_remove(a, &num));
|
||||
assert(stub_set_remove(a, &num));
|
||||
assert(set_size(a) == 1);
|
||||
assert(!set_contains(a, &num));
|
||||
assert(!stub_set_contains(a, &num));
|
||||
num = 2;
|
||||
assert(set_remove(a, &num));
|
||||
assert(stub_set_remove(a, &num));
|
||||
assert(set_size(a) == 0);
|
||||
assert(!set_contains(a, &num));
|
||||
assert(!stub_set_contains(a, &num));
|
||||
// Add a lot of items and remove individually.
|
||||
for (int i = 5000; i < 6000; i++) {
|
||||
set_add(a, &i);
|
||||
assert(set_contains(a, &i));
|
||||
stub_set_add(a, &i);
|
||||
assert(stub_set_contains(a, &i));
|
||||
}
|
||||
assert(set_size(a) == 1000);
|
||||
for (int i = 5000; i < 5500; i++) {
|
||||
set_remove(a, &i);
|
||||
assert(!set_contains(a, &i));
|
||||
stub_set_remove(a, &i);
|
||||
assert(!stub_set_contains(a, &i));
|
||||
}
|
||||
assert(set_size(a) == 500);
|
||||
assert(!set_is_empty(a));
|
||||
set_clear(a);
|
||||
stub_set_clear(a);
|
||||
assert(set_size(a) == 0);
|
||||
assert(set_is_empty(a));
|
||||
// Add a lot of items and clear.
|
||||
for (int i = 5000; i < 6000; i++) {
|
||||
set_add(a, &i);
|
||||
assert(set_contains(a, &i));
|
||||
stub_set_add(a, &i);
|
||||
assert(stub_set_contains(a, &i));
|
||||
}
|
||||
assert(set_size(a) == 1000);
|
||||
set_clear(a);
|
||||
stub_set_clear(a);
|
||||
int p = 0xdeadbeef;
|
||||
assert(!set_remove(a, &p));
|
||||
assert(!stub_set_remove(a, &p));
|
||||
assert(set_size(a) == 0);
|
||||
assert(set_is_empty(a));
|
||||
a = set_destroy(a);
|
||||
a = stub_set_destroy(a);
|
||||
assert(a == NULL);
|
||||
// Create odd shape graph.
|
||||
a = set_init(sizeof(int), compare_int);
|
||||
int tmp = 10;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 5;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 15;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 3;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 8;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 12;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 18;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 12;
|
||||
set_remove(a, &tmp);
|
||||
stub_set_remove(a, &tmp);
|
||||
tmp = 5;
|
||||
set_remove(a, &tmp);
|
||||
stub_set_remove(a, &tmp);
|
||||
tmp = 3;
|
||||
set_remove(a, &tmp);
|
||||
stub_set_remove(a, &tmp);
|
||||
tmp = 8;
|
||||
set_remove(a, &tmp);
|
||||
set_clear(a);
|
||||
stub_set_remove(a, &tmp);
|
||||
stub_set_clear(a);
|
||||
// Allocate many nodes.
|
||||
for (int i = 8123; i < 12314; i += 3) {
|
||||
set_add(a, &i);
|
||||
assert(set_contains(a, &i));
|
||||
stub_set_add(a, &i);
|
||||
assert(stub_set_contains(a, &i));
|
||||
}
|
||||
for (int i = 13000; i > 8000; i--) {
|
||||
set_remove(a, &i);
|
||||
assert(!set_contains(a, &i));
|
||||
stub_set_remove(a, &i);
|
||||
assert(!stub_set_contains(a, &i));
|
||||
}
|
||||
set_clear(a);
|
||||
stub_set_clear(a);
|
||||
// Create another odd shape graph.
|
||||
tmp = 20;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 10;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 40;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 5;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 15;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 30;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 50;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 25;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 35;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 36;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 34;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 33;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 32;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 30;
|
||||
set_remove(a, &tmp);
|
||||
stub_set_remove(a, &tmp);
|
||||
tmp = 32;
|
||||
assert(set_contains(a, &tmp));
|
||||
set_clear(a);
|
||||
assert(stub_set_contains(a, &tmp));
|
||||
stub_set_clear(a);
|
||||
// One sided tree.
|
||||
tmp = 10;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 9;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 8;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 7;
|
||||
set_add(a, &tmp);
|
||||
stub_set_add(a, &tmp);
|
||||
tmp = 8;
|
||||
set_remove(a, &tmp);
|
||||
stub_set_remove(a, &tmp);
|
||||
tmp = 7;
|
||||
assert(set_contains(a, &tmp));
|
||||
set_destroy(a);
|
||||
assert(stub_set_contains(a, &tmp));
|
||||
stub_set_destroy(a);
|
||||
// Replace two sided two children
|
||||
a = set_init(sizeof(int), compare_int);
|
||||
b = 5;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 1;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 6;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = -1;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 3;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 7;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = -2;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 0;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 2;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 4;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 1;
|
||||
set_remove(a, &b);
|
||||
assert(!set_contains(a, &b));
|
||||
set_clear(a);
|
||||
stub_set_remove(a, &b);
|
||||
assert(!stub_set_contains(a, &b));
|
||||
stub_set_clear(a);
|
||||
b = 5;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 1;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 6;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = -1;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 3;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 7;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = -2;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 0;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 4;
|
||||
set_add(a, &b);
|
||||
stub_set_add(a, &b);
|
||||
b = 1;
|
||||
set_remove(a, &b);
|
||||
assert(!set_contains(a, &b));
|
||||
set_destroy(a);
|
||||
stub_set_remove(a, &b);
|
||||
assert(!stub_set_contains(a, &b));
|
||||
stub_set_destroy(a);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user