colin/NetworkManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

shared/c-rbtree: reimport

Browse Source 
git subtree pull --prefix shared/c-rbtree git@github.com:c-util/c-rbtree.git master --squash
This commit is contained in:
Thomas Haller
2019-04-14 17:23:01 +02:00
parent 06136cdd42 7d5c09c3ca
commit 72de3d45cc
20 changed files with 252 additions and 940 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
shared/c-rbtree/src/test-map.c
View File

@@ -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) {