From 032d34a6bddc5be3cddc5c7f073489f36f996164 Mon Sep 17 00:00:00 2001 From: Leonardo Date: Thu, 11 Apr 2019 14:45:23 -0300 Subject: [PATCH] Revamped iterator test and added examples --- {tests => examples}/iterators/deque.c | 15 +- {tests => examples}/iterators/hashmap.c | 15 +- {tests => examples}/iterators/hashset.c | 15 +- {tests => examples}/iterators/heap.c | 19 +- {tests => examples}/iterators/linkedlist.c | 15 +- {tests => examples}/iterators/list.c | 15 +- {tests => examples}/iterators/queue.c | 15 +- {tests => examples}/iterators/stack.c | 15 +- {tests => examples}/iterators/treemap.c | 15 +- {tests => examples}/iterators/treeset.c | 15 +- tests/foreach.c | 22 +- tests/iterators.c | 480 +++++++++++++++++++++ 12 files changed, 594 insertions(+), 62 deletions(-) rename {tests => examples}/iterators/deque.c (83%) rename {tests => examples}/iterators/hashmap.c (86%) rename {tests => examples}/iterators/hashset.c (85%) rename {tests => examples}/iterators/heap.c (77%) rename {tests => examples}/iterators/linkedlist.c (82%) rename {tests => examples}/iterators/list.c (82%) rename {tests => examples}/iterators/queue.c (82%) rename {tests => examples}/iterators/stack.c (82%) rename {tests => examples}/iterators/treemap.c (84%) rename {tests => examples}/iterators/treeset.c (82%) create mode 100644 tests/iterators.c diff --git a/tests/iterators/deque.c b/examples/iterators/deque.c similarity index 83% rename from tests/iterators/deque.c rename to examples/iterators/deque.c index 70b6965..04079b0 100644 --- a/tests/iterators/deque.c +++ b/examples/iterators/deque.c @@ -1,10 +1,15 @@ -// Checks if the deque iterator can go back and forward in the deque without -// hitting invalid states or a null pointer. Check is done visually. +/** + * deque.c + * + * Creation Date: 11/04/2019 + * + * Authors: + * Leonardo Vencovsky (https://github.com/LeoVen) + * + */ #include #include -#include -#include -#include "../../src/deque.h" +#include "deque.h" DEQUE_GENERATE(d, deque, static, int) diff --git a/tests/iterators/hashmap.c b/examples/iterators/hashmap.c similarity index 86% rename from tests/iterators/hashmap.c rename to examples/iterators/hashmap.c index 2e187a2..800ebb8 100644 --- a/tests/iterators/hashmap.c +++ b/examples/iterators/hashmap.c @@ -1,10 +1,15 @@ -// Checks if the hashmap iterator can go back and forward in the hashmap without -// hitting invalid states or a null pointer. Check is done visually. +/** + * hashmap.c + * + * Creation Date: 11/04/2019 + * + * Authors: + * Leonardo Vencovsky (https://github.com/LeoVen) + * + */ #include #include -#include -#include -#include "../../src/hashmap.h" +#include "hashmap.h" HASHMAP_GENERATE(hm, hmap, static, int, double) diff --git a/tests/iterators/hashset.c b/examples/iterators/hashset.c similarity index 85% rename from tests/iterators/hashset.c rename to examples/iterators/hashset.c index 793f4bf..2e150d6 100644 --- a/tests/iterators/hashset.c +++ b/examples/iterators/hashset.c @@ -1,10 +1,15 @@ -// Checks if the hash set iterator can go back and forward in the hash set without -// hitting invalid states or a null pointer. Check is done visually. +/** + * hashset.c + * + * Creation Date: 11/04/2019 + * + * Authors: + * Leonardo Vencovsky (https://github.com/LeoVen) + * + */ #include #include -#include -#include -#include "../../src/hashset.h" +#include "hashset.h" HASHSET_GENERATE(hs, hash_set, static, int) diff --git a/tests/iterators/heap.c b/examples/iterators/heap.c similarity index 77% rename from tests/iterators/heap.c rename to examples/iterators/heap.c index 45f4ca8..de760d7 100644 --- a/tests/iterators/heap.c +++ b/examples/iterators/heap.c @@ -1,10 +1,15 @@ -// Checks if the heap iterator can go back and forward in the heap without -// hitting invalid states or a null pointer. Check is done visually. +/** + * heap.c + * + * Creation Date: 11/04/2019 + * + * Authors: + * Leonardo Vencovsky (https://github.com/LeoVen) + * + */ #include #include -#include -#include -#include "../../src/heap.h" +#include "heap.h" int intcmp(int a, int b) { @@ -41,7 +46,7 @@ int main(int argc, char const *argv[]) for (h_iter_tostart(&iter); !h_iter_end(&iter); /**/) { h_iter_next(&iter, &r, &i); - printf("L[%2d] = %2d\n", i, r); + printf("H[%2d] = %2d\n", i, r); } printf("\n"); @@ -49,7 +54,7 @@ int main(int argc, char const *argv[]) for (h_iter_toend(&iter); !h_iter_start(&iter); /**/) { h_iter_prev(&iter, &r, &i); - printf("L[%2d] = %2d\n", i, r); + printf("H[%2d] = %2d\n", i, r); } h_free(h); diff --git a/tests/iterators/linkedlist.c b/examples/iterators/linkedlist.c similarity index 82% rename from tests/iterators/linkedlist.c rename to examples/iterators/linkedlist.c index ad51577..4c12b19 100644 --- a/tests/iterators/linkedlist.c +++ b/examples/iterators/linkedlist.c @@ -1,10 +1,15 @@ -// Checks if the linked list iterator can go back and forward in the list -// without hitting invalid states or a null pointer. Check is done visually. +/** + * linkedlist.c + * + * Creation Date: 11/04/2019 + * + * Authors: + * Leonardo Vencovsky (https://github.com/LeoVen) + * + */ #include #include -#include -#include -#include "../../src/linkedlist.h" +#include "linkedlist.h" LINKEDLIST_GENERATE(ll, linked, static, int) diff --git a/tests/iterators/list.c b/examples/iterators/list.c similarity index 82% rename from tests/iterators/list.c rename to examples/iterators/list.c index 012ef8f..4011130 100644 --- a/tests/iterators/list.c +++ b/examples/iterators/list.c @@ -1,10 +1,15 @@ -// Checks if the list iterator can go back and forward in the list without -// hitting invalid states or a null pointer. Check is done visually. +/** + * list.c + * + * Creation Date: 11/04/2019 + * + * Authors: + * Leonardo Vencovsky (https://github.com/LeoVen) + * + */ #include #include -#include -#include -#include "../../src/list.h" +#include "list.h" LIST_GENERATE(l, list, static, int) diff --git a/tests/iterators/queue.c b/examples/iterators/queue.c similarity index 82% rename from tests/iterators/queue.c rename to examples/iterators/queue.c index ac0ba5f..39c6d9d 100644 --- a/tests/iterators/queue.c +++ b/examples/iterators/queue.c @@ -1,10 +1,15 @@ -// Checks if the queue iterator can go back and forward in the queue without -// hitting invalid states or a null pointer. Check is done visually. +/** + * queue.c + * + * Creation Date: 11/04/2019 + * + * Authors: + * Leonardo Vencovsky (https://github.com/LeoVen) + * + */ #include #include -#include -#include -#include "../../src/queue.h" +#include "queue.h" QUEUE_GENERATE(q, queue, static, int) diff --git a/tests/iterators/stack.c b/examples/iterators/stack.c similarity index 82% rename from tests/iterators/stack.c rename to examples/iterators/stack.c index 0d66f9e..c8213ce 100644 --- a/tests/iterators/stack.c +++ b/examples/iterators/stack.c @@ -1,10 +1,15 @@ -// Checks if the stack iterator can go back and forward in the stack without -// hitting invalid states or a null pointer. Check is done visually. +/** + * stack.c + * + * Creation Date: 11/04/2019 + * + * Authors: + * Leonardo Vencovsky (https://github.com/LeoVen) + * + */ #include #include -#include -#include -#include "../../src/stack.h" +#include "stack.h" STACK_GENERATE(s, stack, static, int) diff --git a/tests/iterators/treemap.c b/examples/iterators/treemap.c similarity index 84% rename from tests/iterators/treemap.c rename to examples/iterators/treemap.c index 305cd8f..61471ba 100644 --- a/tests/iterators/treemap.c +++ b/examples/iterators/treemap.c @@ -1,10 +1,15 @@ -// Checks if the treemap iterator can go back and forward in the treemap without -// hitting invalid states or a null pointer. Check is done visually. +/** + * treemap.c + * + * Creation Date: 11/04/2019 + * + * Authors: + * Leonardo Vencovsky (https://github.com/LeoVen) + * + */ #include #include -#include -#include -#include "../../src/treemap.h" +#include "treemap.h" int intcmp(int a, int b) { diff --git a/tests/iterators/treeset.c b/examples/iterators/treeset.c similarity index 82% rename from tests/iterators/treeset.c rename to examples/iterators/treeset.c index cc1e9ce..2bf5547 100644 --- a/tests/iterators/treeset.c +++ b/examples/iterators/treeset.c @@ -1,10 +1,15 @@ -// Checks if the treeset iterator can go back and forward in the treeset without -// hitting invalid states or a null pointer. Check is done visually. +/** + * treeset.c + * + * Creation Date: 11/04/2019 + * + * Authors: + * Leonardo Vencovsky (https://github.com/LeoVen) + * + */ #include #include -#include -#include -#include "../../src/treeset.h" +#include "treeset.h" int intcmp(int a, int b) { diff --git a/tests/foreach.c b/tests/foreach.c index 1beba28..da59bf9 100644 --- a/tests/foreach.c +++ b/tests/foreach.c @@ -19,18 +19,18 @@ size_t inthash(int t) return a; } -COLLECTION_GENERATE( LIST, PUBLIC, l, list, /* FMOD */, /* K */, int) -COLLECTION_GENERATE( STACK, PUBLIC, s, stack, /* FMOD */, /* K */, int) -COLLECTION_GENERATE( QUEUE, PUBLIC, q, queue, /* FMOD */, /* K */, int) -COLLECTION_GENERATE( DEQUE, PUBLIC, d, deque, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(LIST, PUBLIC, l, list, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(STACK, PUBLIC, s, stack, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(QUEUE, PUBLIC, q, queue, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(DEQUE, PUBLIC, d, deque, /* FMOD */, /* K */, int) COLLECTION_GENERATE(LINKEDLIST, PUBLIC, ll, linked, /* FMOD */, /* K */, int) -COLLECTION_GENERATE( HEAP, PUBLIC, h, heap, /* FMOD */, /* K */, int) -COLLECTION_GENERATE( TREESET, PUBLIC, ts, tset, /* FMOD */, /* K */, int) -COLLECTION_GENERATE( TREEMAP, PUBLIC, tm, tmap, /* FMOD */, int, int) -COLLECTION_GENERATE( HASHSET, PUBLIC, hs, hset, /* FMOD */, /* K */, int) -COLLECTION_GENERATE( HASHMAP, PUBLIC, hm, hmap, /* FMOD */, int, int) +COLLECTION_GENERATE(HEAP, PUBLIC, h, heap, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(TREESET, PUBLIC, ts, tset, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(TREEMAP, PUBLIC, tm, tmap, /* FMOD */, int, int) +COLLECTION_GENERATE(HASHSET, PUBLIC, hs, hset, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(HASHMAP, PUBLIC, hm, hmap, /* FMOD */, int, int) -int main(int argc, char const *argv[]) +int main(void) { list *l = l_new(1000); stack *s = s_new(1000); @@ -112,6 +112,7 @@ int main(int argc, char const *argv[]) sum11 += value; }) + printf("\n-------------------- FOR_EACH --------------------\n"); if (sum0 == 50005000) printf("%10s PASSED\n", "LIST"); if (sum1 == 50005000) @@ -180,6 +181,7 @@ int main(int argc, char const *argv[]) sum11 += value; }) + printf("-------------------- FOR_EACH_REV --------------------\n"); if (sum0 == 50005000) printf("%10s PASSED\n", "LIST"); if (sum1 == 50005000) diff --git a/tests/iterators.c b/tests/iterators.c new file mode 100644 index 0000000..ef81c67 --- /dev/null +++ b/tests/iterators.c @@ -0,0 +1,480 @@ +#include +#include +#include "../src/macro_collections.h" + +int intcmp(int a, int b) +{ + return a - b; +} + +size_t inthash(int t) +{ + size_t a = t; + a += ~(a << 15); + a ^= (a >> 10); + a += (a << 3); + a ^= (a >> 6); + a += ~(a << 11); + a ^= (a >> 16); + return a; +} + +COLLECTION_GENERATE(LIST, PUBLIC, l, list, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(STACK, PUBLIC, s, stack, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(QUEUE, PUBLIC, q, queue, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(DEQUE, PUBLIC, d, deque, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(LINKEDLIST, PUBLIC, ll, linked, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(HEAP, PUBLIC, h, heap, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(TREESET, PUBLIC, ts, tset, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(TREEMAP, PUBLIC, tm, tmap, /* FMOD */, int, double) +COLLECTION_GENERATE(HASHSET, PUBLIC, hs, hset, /* FMOD */, /* K */, int) +COLLECTION_GENERATE(HASHMAP, PUBLIC, hm, hmap, /* FMOD */, int, double) + +void deque_iter_test(void) +{ + size_t i; + int r, sum = 0; + + // Initialize deque and add some elements + deque *d = d_new(10); + for (int i = 0; i < 10; i++) + { + i % 2 == 0 ? d_push_back(d, i) : d_push_front(d, i); + } + + // Initialize iterator + deque_iter iter; + d_iter_new(&iter, d); + + // Make the iterator go back and forward + for (int j = 0; j < 4; j++) + { + while (d_iter_next(&iter, &r, &i)) + sum += r; + while (d_iter_prev(&iter, &r, &i)) + sum += r; + } + + for (d_iter_tostart(&iter); !d_iter_end(&iter); /**/) + { + d_iter_next(&iter, &r, &i); + sum += r; + } + + for (d_iter_toend(&iter); !d_iter_start(&iter); /**/) + { + d_iter_prev(&iter, &r, &i); + sum += r; + } + + d_free(d); + + if (sum == 450) + printf("%10s PASSED\n", "DEQUE"); +} + +void hashmap_iter_test(void) +{ + size_t i; + int k, sum = 0; + double dsum = 0.0, v, varr[10] = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9}; + + // Initialize hashmap and add some element + hmap *hm = hm_new(50, 0.9, intcmp, inthash); + for (int i = 0; i < 10; i++) + hm_insert(hm, i, varr[i]); + + // Initialize iterator + hmap_iter iter; + hm_iter_new(&iter, hm); + + // Make the iterator go back and forward + for (int j = 0; j < 4; j++) + { + while (hm_iter_next(&iter, &k, &v, &i)) + { + sum += k; + dsum += v; + } + while (hm_iter_prev(&iter, &k, &v, &i)) + { + sum += k; + dsum += v; + } + } + + for (hm_iter_tostart(&iter); !hm_iter_end(&iter); /**/) + { + hm_iter_next(&iter, &k, &v, &i); + sum += k; + dsum += v; + } + + for (hm_iter_toend(&iter); !hm_iter_start(&iter); /**/) + { + hm_iter_prev(&iter, &k, &v, &i); + { + sum += k; + dsum += v; + } + } + + hm_free(hm); + + if (sum == 450 && dsum == 45.0) + printf("%10s PASSED\n", "HASHMAP"); +} + +void hashset_iter_test(void) +{ + size_t i; + int r, sum = 0; + + // Initialize hash set and add some elements + hset *hs = hs_new(10, 0.9, intcmp, inthash); + for (int i = 0; i < 10; i++) + hs_insert(hs, i); + + // Initialize iterator + hset_iter iter; + hs_iter_new(&iter, hs); + + // Make the iterator go back and forward + for (int j = 0; j < 4; j++) + { + while (hs_iter_next(&iter, &r, &i)) + sum += r; + while (hs_iter_prev(&iter, &r, &i)) + sum += r; + } + + for (hs_iter_tostart(&iter); !hs_iter_end(&iter); /**/) + { + hs_iter_next(&iter, &r, &i); + sum += r; + } + + for (hs_iter_toend(&iter); !hs_iter_start(&iter); /**/) + { + hs_iter_prev(&iter, &r, &i); + sum += r; + } + + hs_free(hs); + + if (sum == 450) + printf("%10s PASSED\n", "HASHSET"); +} + +void heap_iter_test(void) +{ + size_t i; + int r, sum = 0; + + // Initialize heap and add some elements + heap *h = h_new(10, MinHeap, intcmp); + for (int i = 9; i >= 0; i--) + h_insert(h, i); + + // Initialize iterator + heap_iter iter; + h_iter_new(&iter, h); + + // Make the iterator go back and forward + for (int j = 0; j < 4; j++) + { + while (h_iter_next(&iter, &r, &i)) + sum += r; + while (h_iter_prev(&iter, &r, &i)) + sum += r; + } + + for (h_iter_tostart(&iter); !h_iter_end(&iter); /**/) + { + h_iter_next(&iter, &r, &i); + sum += r; + } + + for (h_iter_toend(&iter); !h_iter_start(&iter); /**/) + { + h_iter_prev(&iter, &r, &i); + sum += r; + } + + h_free(h); + + if (sum == 450) + printf("%10s PASSED\n", "HEAP"); +} + +void linkedlist_iter_test(void) +{ + size_t i; + int r, sum = 0; + + // Initialize linked list and add some elements + linked *ll = ll_new(); + for (int i = 0; i < 10; i++) + ll_push_back(ll, i); + + // Initialize iterator + linked_iter iter; + ll_iter_new(&iter, ll); + + // Make the iterator go back and forward + for (int j = 0; j < 4; j++) + { + while (ll_iter_next(&iter, &r, &i)) + sum += r; + while (ll_iter_prev(&iter, &r, &i)) + sum += r; + } + + for (ll_iter_tostart(&iter); !ll_iter_end(&iter); /**/) + { + ll_iter_next(&iter, &r, &i); + sum += r; + } + + for (ll_iter_toend(&iter); !ll_iter_start(&iter); /**/) + { + ll_iter_prev(&iter, &r, &i); + sum += r; + } + + ll_free(ll); + + if (sum == 450) + printf("%10s PASSED\n", "LINKEDLIST"); +} + +void list_iter_test(void) +{ + size_t i; + int r, sum = 0; + + // Initialize list and add some elements + list *l = l_new(10); + for (int i = 0; i < 10; i++) + l_push_back(l, i); + + // Initialize iterator + list_iter iter; + l_iter_new(&iter, l); + + // Make the iterator go back and forward + for (int j = 0; j < 4; j++) + { + while (l_iter_next(&iter, &r, &i)) + sum += r; + while (l_iter_prev(&iter, &r, &i)) + sum += r; + } + + for (l_iter_tostart(&iter); !l_iter_end(&iter); /**/) + { + l_iter_next(&iter, &r, &i); + sum += r; + } + + for (l_iter_toend(&iter); !l_iter_start(&iter); /**/) + { + l_iter_prev(&iter, &r, &i); + sum += r; + } + + l_free(l); + + if (sum == 450) + printf("%10s PASSED\n", "LIST"); +} + +void queue_iter_test(void) +{ + size_t i; + int r, sum = 0; + + // Initialize queue and add some elements + queue *q = q_new(10); + for (int i = 0; i < 10; i++) + q_enqueue(q, i); + + // Initialize iterator + queue_iter iter; + q_iter_new(&iter, q); + + // Make the iterator go back and forward + for (int j = 0; j < 4; j++) + { + while (q_iter_next(&iter, &r, &i)) + sum += r; + while (q_iter_prev(&iter, &r, &i)) + sum += r; + } + + for (q_iter_tostart(&iter); !q_iter_end(&iter); /**/) + { + q_iter_next(&iter, &r, &i); + sum += r; + } + + for (q_iter_toend(&iter); !q_iter_start(&iter); /**/) + { + q_iter_prev(&iter, &r, &i); + sum += r; + } + + q_free(q); + + if (sum == 450) + printf("%10s PASSED\n", "QUEUE"); +} + +void stack_iter_test(void) +{ + size_t i; + int r, sum = 0; + + // Initialize stack and add some elements + stack *s = s_new(10); + for (int i = 0; i < 10; i++) + s_push(s, i); + + // Initialize iterator + stack_iter iter; + s_iter_new(&iter, s); + + // Make the iterator go back and forward + for (int j = 0; j < 4; j++) + { + while (s_iter_next(&iter, &r, &i)) + sum += r; + while (s_iter_prev(&iter, &r, &i)) + sum += r; + } + + for (s_iter_tostart(&iter); !s_iter_end(&iter); /**/) + { + s_iter_next(&iter, &r, &i); + sum += r; + } + + for (s_iter_toend(&iter); !s_iter_start(&iter); /**/) + { + s_iter_prev(&iter, &r, &i); + sum += r; + } + + s_free(s); + + if (sum == 450) + printf("%10s PASSED\n", "STACK"); +} + +void treemap_iter_test(void) +{ + size_t i; + int k, sum = 0; + double dsum = 0, v, varr[10] = {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9}; + + // Initialize treemap and add some element + tmap *tm = tm_new(intcmp); + for (int i = 0; i < 10; i++) + tm_insert(tm, i, varr[i]); + + // Initialize iterator + tmap_iter iter; + tm_iter_new(&iter, tm); + + // Make the iterator go back and forward + for (int j = 0; j < 4; j++) + { + while (tm_iter_next(&iter, &k, &v, &i)) + { + sum += k; + dsum += v; + } + while (tm_iter_prev(&iter, &k, &v, &i)) + { + sum += k; + dsum += v; + } + } + + for (tm_iter_tostart(&iter); !tm_iter_end(&iter); /**/) + { + tm_iter_next(&iter, &k, &v, &i); + sum += k; + dsum += v; + } + + for (tm_iter_toend(&iter); !tm_iter_start(&iter); /**/) + { + tm_iter_prev(&iter, &k, &v, &i); + sum += k; + dsum += v; + } + + tm_free(tm); + + if (sum == 450 && dsum == 45.0) + printf("%10s PASSED\n", "TREEMAP"); +} + +void treeset_iter_test(void) +{ + size_t i; + int r, sum = 0; + + // Initialize treeset and add some elements + tset *ts = ts_new(intcmp); + for (int i = 0; i < 10; i++) + ts_insert(ts, i); + + // Initialize iterator + tset_iter iter; + ts_iter_new(&iter, ts); + + // Make the iterator go back and forward + for (int j = 0; j < 4; j++) + { + while (ts_iter_next(&iter, &r, &i)) + sum += r; + while (ts_iter_prev(&iter, &r, &i)) + sum += r; + } + + for (ts_iter_tostart(&iter); !ts_iter_end(&iter); /**/) + { + ts_iter_next(&iter, &r, &i); + sum += r; + } + + for (ts_iter_toend(&iter); !ts_iter_start(&iter); /**/) + { + ts_iter_prev(&iter, &r, &i); + sum += r; + } + + ts_free(ts); + + if (sum == 450) + printf("%10s PASSED\n", "TREESET"); +} + +int main(void) +{ + printf("\n-------------------- ITERATORS --------------------\n"); + deque_iter_test(); + hashmap_iter_test(); + hashset_iter_test(); + heap_iter_test(); + linkedlist_iter_test(); + list_iter_test(); + queue_iter_test(); + stack_iter_test(); + treemap_iter_test(); + treeset_iter_test(); + + return 0; +}