summaryrefslogtreecommitdiff
path: root/src/test-map.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/test-map.c')
-rw-r--r--src/test-map.c128
1 files changed, 64 insertions, 64 deletions
diff --git a/src/test-map.c b/src/test-map.c
index 3601ee495e..48a300d6f4 100644
--- a/src/test-map.c
+++ b/src/test-map.c
@@ -6,11 +6,11 @@
#undef NDEBUG
#include <assert.h>
+#include <c-stdaux.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
-
#include "c-rbtree.h"
#include "c-rbtree-private.h"
@@ -50,7 +50,7 @@ static void test_map(void) {
/* allocate and initialize all nodes */
for (i = 0; i < sizeof(nodes) / sizeof(*nodes); ++i) {
nodes[i] = malloc(sizeof(*nodes[i]));
- assert(nodes[i]);
+ c_assert(nodes[i]);
nodes[i]->key = i;
nodes[i]->marker = 0;
c_rbnode_init(&nodes[i]->rb);
@@ -61,15 +61,15 @@ static void test_map(void) {
/* add all nodes, and verify that each node is linked */
for (i = 0; i < sizeof(nodes) / sizeof(*nodes); ++i) {
- assert(!c_rbnode_is_linked(&nodes[i]->rb));
- assert(!c_rbtree_find_entry(&t, test_compare, (void *)nodes[i]->key, Node, rb));
+ c_assert(!c_rbnode_is_linked(&nodes[i]->rb));
+ c_assert(!c_rbtree_find_entry(&t, test_compare, (void *)nodes[i]->key, Node, rb));
slot = c_rbtree_find_slot(&t, test_compare, (void *)nodes[i]->key, &p);
- assert(slot);
+ c_assert(slot);
c_rbtree_add(&t, p, slot, &nodes[i]->rb);
- assert(c_rbnode_is_linked(&nodes[i]->rb));
- assert(nodes[i] == c_rbtree_find_entry(&t, test_compare, (void *)nodes[i]->key, Node, rb));
+ c_assert(c_rbnode_is_linked(&nodes[i]->rb));
+ c_assert(nodes[i] == c_rbtree_find_entry(&t, test_compare, (void *)nodes[i]->key, Node, rb));
}
/* verify in-order traversal works */
@@ -77,128 +77,128 @@ static void test_map(void) {
v = 0;
for (p = c_rbtree_first(&t); p; p = c_rbnode_next(p)) {
++i;
- assert(!node_from_rb(p)->marker);
+ c_assert(!node_from_rb(p)->marker);
node_from_rb(p)->marker = 1;
- assert(v <= node_from_rb(p)->key);
+ c_assert(v <= node_from_rb(p)->key);
v = node_from_rb(p)->key;
- assert(!c_rbnode_next(p) || p == c_rbnode_prev(c_rbnode_next(p)));
+ c_assert(!c_rbnode_next(p) || p == c_rbnode_prev(c_rbnode_next(p)));
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
/* verify reverse in-order traversal works */
i = 0;
v = -1;
for (p = c_rbtree_last(&t); p; p = c_rbnode_prev(p)) {
++i;
- assert(node_from_rb(p)->marker);
+ c_assert(node_from_rb(p)->marker);
node_from_rb(p)->marker = 0;
- assert(v >= node_from_rb(p)->key);
+ c_assert(v >= node_from_rb(p)->key);
v = node_from_rb(p)->key;
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
/* verify post-order traversal works */
i = 0;
for (p = c_rbtree_first_postorder(&t); p; p = c_rbnode_next_postorder(p)) {
++i;
- assert(!node_from_rb(p)->marker);
- assert(!c_rbnode_parent(p) || !node_from_rb(c_rbnode_parent(p))->marker);
- assert(!p->left || node_from_rb(p->left)->marker);
- assert(!p->right || node_from_rb(p->right)->marker);
+ c_assert(!node_from_rb(p)->marker);
+ c_assert(!c_rbnode_parent(p) || !node_from_rb(c_rbnode_parent(p))->marker);
+ c_assert(!p->left || node_from_rb(p->left)->marker);
+ c_assert(!p->right || node_from_rb(p->right)->marker);
node_from_rb(p)->marker = 1;
- assert(!c_rbnode_next_postorder(p) || p == c_rbnode_prev_postorder(c_rbnode_next_postorder(p)));
+ c_assert(!c_rbnode_next_postorder(p) || p == c_rbnode_prev_postorder(c_rbnode_next_postorder(p)));
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
/* verify pre-order (inverse post-order) traversal works */
i = 0;
for (p = c_rbtree_last_postorder(&t); p; p = c_rbnode_prev_postorder(p)) {
++i;
- assert(node_from_rb(p)->marker);
- assert(!c_rbnode_parent(p) || !node_from_rb(c_rbnode_parent(p))->marker);
- assert(!p->left || node_from_rb(p->left)->marker);
- assert(!p->right || node_from_rb(p->right)->marker);
+ c_assert(node_from_rb(p)->marker);
+ c_assert(!c_rbnode_parent(p) || !node_from_rb(c_rbnode_parent(p))->marker);
+ c_assert(!p->left || node_from_rb(p->left)->marker);
+ c_assert(!p->right || node_from_rb(p->right)->marker);
node_from_rb(p)->marker = 0;
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
/* verify in-order traversal works via helper */
i = 0;
v = 0;
c_rbtree_for_each(p, &t) {
++i;
- assert(!node_from_rb(p)->marker);
+ c_assert(!node_from_rb(p)->marker);
node_from_rb(p)->marker = 1;
- assert(v <= node_from_rb(p)->key);
+ c_assert(v <= node_from_rb(p)->key);
v = node_from_rb(p)->key;
- assert(!c_rbnode_next(p) || p == c_rbnode_prev(c_rbnode_next(p)));
+ c_assert(!c_rbnode_next(p) || p == c_rbnode_prev(c_rbnode_next(p)));
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
/* verify in-order traversal works via entry-helper */
i = 0;
v = 0;
c_rbtree_for_each_entry(n, &t, rb) {
++i;
- assert(n->marker);
+ c_assert(n->marker);
n->marker = 0;
- assert(v <= n->key);
+ c_assert(v <= n->key);
v = n->key;
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
/* verify post-order traversal works via helper */
i = 0;
c_rbtree_for_each_postorder(p, &t) {
++i;
- assert(!node_from_rb(p)->marker);
- assert(!c_rbnode_parent(p) || !node_from_rb(c_rbnode_parent(p))->marker);
- assert(!p->left || node_from_rb(p->left)->marker);
- assert(!p->right || node_from_rb(p->right)->marker);
+ c_assert(!node_from_rb(p)->marker);
+ c_assert(!c_rbnode_parent(p) || !node_from_rb(c_rbnode_parent(p))->marker);
+ c_assert(!p->left || node_from_rb(p->left)->marker);
+ c_assert(!p->right || node_from_rb(p->right)->marker);
node_from_rb(p)->marker = 1;
- assert(!c_rbnode_next_postorder(p) || p == c_rbnode_prev_postorder(c_rbnode_next_postorder(p)));
+ c_assert(!c_rbnode_next_postorder(p) || p == c_rbnode_prev_postorder(c_rbnode_next_postorder(p)));
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
/* verify post-order traversal works via entry-helper */
i = 0;
c_rbtree_for_each_entry_postorder(n, &t, rb) {
++i;
- assert(n->marker);
- assert(!c_rbnode_parent(&n->rb) || node_from_rb(c_rbnode_parent(&n->rb))->marker);
- assert(!n->rb.left || !node_from_rb(n->rb.left)->marker);
- assert(!n->rb.right || !node_from_rb(n->rb.right)->marker);
+ c_assert(n->marker);
+ c_assert(!c_rbnode_parent(&n->rb) || node_from_rb(c_rbnode_parent(&n->rb))->marker);
+ c_assert(!n->rb.left || !node_from_rb(n->rb.left)->marker);
+ c_assert(!n->rb.right || !node_from_rb(n->rb.right)->marker);
n->marker = 0;
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
/* shuffle nodes again */
shuffle(nodes, sizeof(nodes) / sizeof(*nodes));
/* remove all nodes (in different order) */
for (i = 0; i < sizeof(nodes) / sizeof(*nodes); ++i) {
- assert(c_rbnode_is_linked(&nodes[i]->rb));
- assert(nodes[i] == c_rbtree_find_entry(&t, test_compare, (void *)nodes[i]->key, Node, rb));
+ c_assert(c_rbnode_is_linked(&nodes[i]->rb));
+ c_assert(nodes[i] == c_rbtree_find_entry(&t, test_compare, (void *)nodes[i]->key, Node, rb));
c_rbnode_unlink(&nodes[i]->rb);
- assert(!c_rbnode_is_linked(&nodes[i]->rb));
- assert(!c_rbtree_find_entry(&t, test_compare, (void *)nodes[i]->key, Node, rb));
+ c_assert(!c_rbnode_is_linked(&nodes[i]->rb));
+ c_assert(!c_rbtree_find_entry(&t, test_compare, (void *)nodes[i]->key, Node, rb));
}
- assert(c_rbtree_is_empty(&t));
+ c_assert(c_rbtree_is_empty(&t));
/* add all nodes again */
for (i = 0; i < sizeof(nodes) / sizeof(*nodes); ++i) {
slot = c_rbtree_find_slot(&t, test_compare, (void *)nodes[i]->key, &p);
- assert(slot);
+ c_assert(slot);
c_rbtree_add(&t, p, slot, &nodes[i]->rb);
}
@@ -208,13 +208,13 @@ static void test_map(void) {
++i;
c_rbnode_unlink(p);
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
- assert(c_rbtree_is_empty(&t));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(c_rbtree_is_empty(&t));
/* add all nodes again */
for (i = 0; i < sizeof(nodes) / sizeof(*nodes); ++i) {
slot = c_rbtree_find_slot(&t, test_compare, (void *)nodes[i]->key, &p);
- assert(slot);
+ c_assert(slot);
c_rbtree_add(&t, p, slot, &nodes[i]->rb);
}
@@ -224,13 +224,13 @@ static void test_map(void) {
++i;
c_rbnode_unlink(&n->rb);
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
- assert(c_rbtree_is_empty(&t));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(c_rbtree_is_empty(&t));
/* add all nodes again */
for (i = 0; i < sizeof(nodes) / sizeof(*nodes); ++i) {
slot = c_rbtree_find_slot(&t, test_compare, (void *)nodes[i]->key, &p);
- assert(slot);
+ c_assert(slot);
c_rbtree_add(&t, p, slot, &nodes[i]->rb);
}
@@ -238,15 +238,15 @@ static void test_map(void) {
i = 0;
c_rbtree_for_each_safe_postorder_unlink(p, safe_p, &t) {
++i;
- assert(!c_rbnode_is_linked(p));
+ c_assert(!c_rbnode_is_linked(p));
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
- assert(c_rbtree_is_empty(&t));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(c_rbtree_is_empty(&t));
/* add all nodes again */
for (i = 0; i < sizeof(nodes) / sizeof(*nodes); ++i) {
slot = c_rbtree_find_slot(&t, test_compare, (void *)nodes[i]->key, &p);
- assert(slot);
+ c_assert(slot);
c_rbtree_add(&t, p, slot, &nodes[i]->rb);
}
@@ -254,18 +254,18 @@ static void test_map(void) {
i = 0;
c_rbtree_for_each_entry_safe_postorder_unlink(n, safe_n, &t, rb) {
++i;
- assert(!c_rbnode_is_linked(&n->rb));
+ c_assert(!c_rbnode_is_linked(&n->rb));
}
- assert(i == sizeof(nodes) / sizeof(*nodes));
- assert(c_rbtree_is_empty(&t));
+ c_assert(i == sizeof(nodes) / sizeof(*nodes));
+ c_assert(c_rbtree_is_empty(&t));
/* free nodes again */
for (i = 0; i < sizeof(nodes) / sizeof(*nodes); ++i) {
- assert(!nodes[i]->marker);
+ c_assert(!nodes[i]->marker);
free(nodes[i]);
}
- assert(c_rbtree_is_empty(&t));
+ c_assert(c_rbtree_is_empty(&t));
}
int main(int argc, char **argv) {
View Lorry Controller Status