More refactoring
This commit is contained in:
Leonardo Vencovsky committed
1 parent
e4d58db474
commit
71fd0b8ad5
86 files changed
+9149
-315
No files matched your search
+22
-14
@@ -1,6 +1,14 @@
|
||||
#include <inttypes.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define CMC_EXT_FALLTHROUGH
|
||||
#define CMC_EXT_INIT
|
||||
#define CMC_EXT_ITER
|
||||
#define CMC_EXT_NODE
|
||||
#define CMC_EXT_SEQ
|
||||
#define CMC_EXT_SETF
|
||||
#define CMC_EXT_STR
|
||||
|
||||
#include "unt_bitset.h"
|
||||
#include "unt_deque.h"
|
||||
#include "unt_hashbidimap.h"
|
||||
@@ -10,15 +18,15 @@
|
||||
#include "unt_hashset.h"
|
||||
#include "unt_heap.h"
|
||||
#include "unt_intervalheap.h"
|
||||
// #include "unt_linkedlist.h"
|
||||
#include "unt_linkedlist.h"
|
||||
#include "unt_list.h"
|
||||
#include "unt_queue.h"
|
||||
// #include "unt_sortedlist.h"
|
||||
#include "unt_sortedlist.h"
|
||||
#include "unt_stack.h"
|
||||
// #include "unt_treemap.h"
|
||||
// #include "unt_treeset.h"
|
||||
#include "unt_treemap.h"
|
||||
#include "unt_treeset.h"
|
||||
|
||||
// #include "unt_foreach.h"
|
||||
#include "unt_foreach.h"
|
||||
|
||||
#include "cmc/utl/assert.h"
|
||||
#include "cmc/utl/timer.h"
|
||||
@@ -70,22 +78,22 @@ int main(void)
|
||||
cmc_run(CMCHeapIter, units, tests);
|
||||
cmc_run(CMCIntervalHeap, units, tests);
|
||||
cmc_run(CMCIntervalHeapIter, units, tests);
|
||||
// cmc_run(CMCLinkedList, units, tests);
|
||||
// cmc_run(CMCLinkedListIter, units, tests);
|
||||
cmc_run(CMCLinkedList, units, tests);
|
||||
cmc_run(CMCLinkedListIter, units, tests);
|
||||
cmc_run(CMCList, units, tests);
|
||||
cmc_run(CMCListIter, units, tests);
|
||||
cmc_run(CMCQueue, units, tests);
|
||||
cmc_run(CMCQueueIter, units, tests);
|
||||
// cmc_run(CMCSortedList, units, tests);
|
||||
// cmc_run(CMCSortedListIter, units, tests);
|
||||
cmc_run(CMCSortedList, units, tests);
|
||||
cmc_run(CMCSortedListIter, units, tests);
|
||||
cmc_run(CMCStack, units, tests);
|
||||
cmc_run(CMCStackIter, units, tests);
|
||||
// cmc_run(CMCTreeMap, units, tests);
|
||||
// cmc_run(CMCTreeMapIter, units, tests);
|
||||
// cmc_run(CMCTreeSet, units, tests);
|
||||
// cmc_run(CMCTreeSetIter, units, tests);
|
||||
cmc_run(CMCTreeMap, units, tests);
|
||||
cmc_run(CMCTreeMapIter, units, tests);
|
||||
cmc_run(CMCTreeSet, units, tests);
|
||||
cmc_run(CMCTreeSetIter, units, tests);
|
||||
|
||||
// cmc_run(ForEach, units, tests);
|
||||
cmc_run(ForEach, units, tests);
|
||||
|
||||
cmc_timer_stop(timer);
|
||||
|
||||
|
||||
@@ -5,9 +5,6 @@
|
||||
|
||||
#define PFX bs
|
||||
#define SNAME bitset
|
||||
#define CMC_EXT_BITSET_INIT
|
||||
#define CMC_EXT_BITSET_ITER
|
||||
#define CMC_EXT_BITSET_STR
|
||||
#include "cmc/bitset.h"
|
||||
|
||||
struct cmc_alloc_node *bs_alloc_node =
|
||||
|
||||
@@ -6,9 +6,6 @@
|
||||
#define V size_t
|
||||
#define PFX d
|
||||
#define SNAME deque
|
||||
#define CMC_EXT_DEQUE_INIT
|
||||
#define CMC_EXT_DEQUE_ITER
|
||||
#define CMC_EXT_DEQUE_STR
|
||||
#include "cmc/deque.h"
|
||||
|
||||
struct deque_fval *d_fval = &(struct deque_fval){
|
||||
|
||||
@@ -0,0 +1,474 @@
|
||||
#ifndef CMC_TESTS_UNT_UTL_FOREACH_H
|
||||
#define CMC_TESTS_UNT_UTL_FOREACH_H
|
||||
|
||||
CMC_CREATE_UNIT(ForEach, true, {
|
||||
// CMC_CREATE_TEST(CMC<BitSet>, {
|
||||
// struct bitset *bs = bs_new(10000);
|
||||
|
||||
// // WIP
|
||||
|
||||
// bs_free(bs);
|
||||
// });
|
||||
|
||||
CMC_CREATE_TEST(CMC<Deque>, {
|
||||
struct deque *d = d_new(10000, &(struct deque_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
d_push_back(d, i);
|
||||
|
||||
size_t sum = 0;
|
||||
CMC_FOREACH (d, deque, it, d)
|
||||
{
|
||||
sum += d_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sum);
|
||||
|
||||
sum = 0;
|
||||
CMC_FOREACH_REV (d, deque, it, d)
|
||||
{
|
||||
sum += d_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sum);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
// CMC_CREATE_TEST(CMC<HashBidiMap>, {
|
||||
// struct hashbidimap *hbm =
|
||||
// hbm_new(10000, 0.7,
|
||||
// &(struct hashbidimap_fkey){ .cmp = cmc_size_cmp,
|
||||
// .cpy = NULL,
|
||||
// .str = cmc_size_str,
|
||||
// .free = NULL,
|
||||
// .hash = cmc_size_hash,
|
||||
// .pri = cmc_size_cmp },
|
||||
// &(struct hashbidimap_fval){ .cmp = cmc_size_cmp,
|
||||
// .cpy = NULL,
|
||||
// .str = cmc_size_str,
|
||||
// .free = NULL,
|
||||
// .hash = cmc_size_hash,
|
||||
// .pri = cmc_size_cmp });
|
||||
|
||||
// // WIP
|
||||
|
||||
// hbm_free(hbm);
|
||||
// });
|
||||
|
||||
CMC_CREATE_TEST(CMC<HashMap>, {
|
||||
struct hashmap *hm = hm_new(10000, 0.6,
|
||||
&(struct hashmap_fkey){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp },
|
||||
&(struct hashmap_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
hm_insert(hm, i, i);
|
||||
|
||||
size_t sumk = 0;
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (hm, hashmap, it, hm)
|
||||
{
|
||||
sumk += hm_iter_key(&it);
|
||||
sumv += hm_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumk);
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumk = 0;
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (hm, hashmap, it, hm)
|
||||
{
|
||||
sumk += hm_iter_key(&it);
|
||||
sumv += hm_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumk);
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
hm_free(hm);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<HashMultiMap>, {
|
||||
struct hashmultimap *hmm = hmm_new(10000, 0.6,
|
||||
&(struct hashmultimap_fkey){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp },
|
||||
&(struct hashmultimap_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
hmm_insert(hmm, i, i);
|
||||
|
||||
size_t sumk = 0;
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (hmm, hashmultimap, it, hmm)
|
||||
{
|
||||
sumk += hmm_iter_key(&it);
|
||||
sumv += hmm_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumk);
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumk = 0;
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (hmm, hashmultimap, it, hmm)
|
||||
{
|
||||
sumk += hmm_iter_key(&it);
|
||||
sumv += hmm_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumk);
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
hmm_free(hmm);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<HashMultiSet>, {
|
||||
struct hashmultiset *hms = hms_new(10000, 0.6,
|
||||
&(struct hashmultiset_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
hms_insert_many(hms, i, i);
|
||||
|
||||
size_t sumk = 0;
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (hms, hashmultiset, it, hms)
|
||||
{
|
||||
sumk += hms_iter_value(&it);
|
||||
sumv += hms_iter_multiplicity(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumk);
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumk = 0;
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (hms, hashmultiset, it, hms)
|
||||
{
|
||||
sumk += hms_iter_value(&it);
|
||||
sumv += hms_iter_multiplicity(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumk);
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
hms_free(hms);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<HashSet>, {
|
||||
struct hashset *hs = hs_new(10000, 0.6,
|
||||
&(struct hashset_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
hs_insert(hs, i);
|
||||
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (hs, hashset, it, hs)
|
||||
{
|
||||
sumv += hs_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (hs, hashset, it, hs)
|
||||
{
|
||||
sumv += hs_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
hs_free(hs);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<Heap>, {
|
||||
struct heap *h = h_new(10000, CMC_MAX_HEAP,
|
||||
&(struct heap_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
h_insert(h, i);
|
||||
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (h, heap, it, h)
|
||||
{
|
||||
sumv += h_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (h, heap, it, h)
|
||||
{
|
||||
sumv += h_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<IntervalHeap>, {
|
||||
struct intervalheap *ih = ih_new(10000, &(struct intervalheap_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
ih_insert(ih, i);
|
||||
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (ih, intervalheap, it, ih)
|
||||
{
|
||||
sumv += ih_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (ih, intervalheap, it, ih)
|
||||
{
|
||||
sumv += ih_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<LinkedList>, {
|
||||
struct linkedlist *ll = ll_new(&(struct linkedlist_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
ll_push_back(ll, i);
|
||||
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (ll, linkedlist, it, ll)
|
||||
{
|
||||
sumv += ll_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (ll, linkedlist, it, ll)
|
||||
{
|
||||
sumv += ll_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<List>, {
|
||||
struct list *l = l_new(10000, &(struct list_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
l_push_back(l, i);
|
||||
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (l, list, it, l)
|
||||
{
|
||||
sumv += l_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (l, list, it, l)
|
||||
{
|
||||
sumv += l_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<Queue>, {
|
||||
struct queue *q = q_new(10000, &(struct queue_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
q_enqueue(q, i);
|
||||
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (q, queue, it, q)
|
||||
{
|
||||
sumv += q_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (q, queue, it, q)
|
||||
{
|
||||
sumv += q_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<SortedList>, {
|
||||
struct sortedlist *sl = sl_new(10000, &(struct sortedlist_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
sl_insert(sl, i);
|
||||
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (sl, sortedlist, it, sl)
|
||||
{
|
||||
sumv += sl_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (sl, sortedlist, it, sl)
|
||||
{
|
||||
sumv += sl_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<Stack>, {
|
||||
struct stack *s = s_new(10000, &(struct stack_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
s_push(s, i);
|
||||
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (s, stack, it, s)
|
||||
{
|
||||
sumv += s_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (s, stack, it, s)
|
||||
{
|
||||
sumv += s_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<TreeMap>, {
|
||||
struct treemap *tm = tm_new(&(struct treemap_fkey){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp },
|
||||
&(struct treemap_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
tm_insert(tm, i, i);
|
||||
|
||||
size_t sumk = 0;
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (tm, treemap, it, tm)
|
||||
{
|
||||
sumk += tm_iter_key(&it);
|
||||
sumv += tm_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumk);
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumk = 0;
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (tm, treemap, it, tm)
|
||||
{
|
||||
sumk += tm_iter_key(&it);
|
||||
sumv += tm_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumk);
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
tm_free(tm);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(CMC<TreeSet>, {
|
||||
struct treeset *ts = ts_new(&(struct treeset_fval){ .cmp = cmc_size_cmp,
|
||||
.cpy = NULL,
|
||||
.str = cmc_size_str,
|
||||
.free = NULL,
|
||||
.hash = cmc_size_hash,
|
||||
.pri = cmc_size_cmp });
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
ts_insert(ts, i);
|
||||
|
||||
size_t sumv = 0;
|
||||
CMC_FOREACH (ts, treeset, it, ts)
|
||||
{
|
||||
sumv += ts_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
sumv = 0;
|
||||
CMC_FOREACH_REV (ts, treeset, it, ts)
|
||||
{
|
||||
sumv += ts_iter_value(&it);
|
||||
}
|
||||
cmc_assert_equals(size_t, 50005000, sumv);
|
||||
|
||||
ts_free(ts);
|
||||
});
|
||||
});
|
||||
|
||||
#endif /* CMC_TESTS_UNT_UTL_FOREACH_H */
|
||||
@@ -7,9 +7,6 @@
|
||||
#define K size_t
|
||||
#define PFX hbm
|
||||
#define SNAME hashbidimap
|
||||
#define CMC_EXT_HASHBIDIMAP_INIT
|
||||
#define CMC_EXT_HASHBIDIMAP_ITER
|
||||
#define CMC_EXT_HASHBIDIMAP_STR
|
||||
#include "cmc/hashbidimap.h"
|
||||
|
||||
struct hashbidimap_fkey *hbm_fkey = &(struct hashbidimap_fkey){
|
||||
|
||||
@@ -7,9 +7,6 @@
|
||||
#define K size_t
|
||||
#define PFX hm
|
||||
#define SNAME hashmap
|
||||
#define CMC_EXT_HASHMAP_INIT
|
||||
#define CMC_EXT_HASHMAP_ITER
|
||||
#define CMC_EXT_HASHMAP_STR
|
||||
#include "cmc/hashmap.h"
|
||||
|
||||
struct hashmap_fkey *hm_fkey = &(struct hashmap_fkey){
|
||||
|
||||
@@ -7,9 +7,6 @@
|
||||
#define K size_t
|
||||
#define PFX hmm
|
||||
#define SNAME hashmultimap
|
||||
#define CMC_EXT_HASHMULTIMAP_INIT
|
||||
#define CMC_EXT_HASHMULTIMAP_ITER
|
||||
#define CMC_EXT_HASHMULTIMAP_STR
|
||||
#include "cmc/hashmultimap.h"
|
||||
|
||||
struct hashmultimap_fkey *hmm_fkey = &(struct hashmultimap_fkey){
|
||||
|
||||
@@ -6,10 +6,6 @@
|
||||
#define V size_t
|
||||
#define PFX hms
|
||||
#define SNAME hashmultiset
|
||||
#define CMC_EXT_HASHMULTISET_INIT
|
||||
#define CMC_EXT_HASHMULTISET_ITER
|
||||
#define CMC_EXT_HASHMULTISET_SETF
|
||||
#define CMC_EXT_HASHMULTISET_STR
|
||||
#include "cmc/hashmultiset.h"
|
||||
|
||||
struct hashmultiset_fval *hms_fval = &(struct hashmultiset_fval){
|
||||
|
||||
@@ -6,10 +6,6 @@
|
||||
#define V size_t
|
||||
#define PFX hs
|
||||
#define SNAME hashset
|
||||
#define CMC_EXT_HASHSET_INIT
|
||||
#define CMC_EXT_HASHSET_ITER
|
||||
#define CMC_EXT_HASHSET_SETF
|
||||
#define CMC_EXT_HASHSET_STR
|
||||
#include "cmc/hashset.h"
|
||||
|
||||
struct hashset_fval *hs_fval = &(struct hashset_fval){
|
||||
|
||||
@@ -6,9 +6,6 @@
|
||||
#define V size_t
|
||||
#define PFX h
|
||||
#define SNAME heap
|
||||
#define CMC_EXT_HEAP_INIT
|
||||
#define CMC_EXT_HEAP_ITER
|
||||
#define CMC_EXT_HEAP_STR
|
||||
#include "cmc/heap.h"
|
||||
|
||||
struct heap_fval *h_fval = &(struct heap_fval){
|
||||
|
||||
@@ -6,9 +6,6 @@
|
||||
#define V size_t
|
||||
#define PFX ih
|
||||
#define SNAME intervalheap
|
||||
#define CMC_EXT_INTERVALHEAP_INIT
|
||||
#define CMC_EXT_INTERVALHEAP_ITER
|
||||
#define CMC_EXT_INTERVALHEAP_STR
|
||||
#include "cmc/intervalheap.h"
|
||||
|
||||
struct intervalheap_fval *ih_fval = &(struct intervalheap_fval){
|
||||
|
||||
@@ -0,0 +1,817 @@
|
||||
#ifndef CMC_TESTS_UNT_LINKEDLIST_H
|
||||
#define CMC_TESTS_UNT_LINKEDLIST_H
|
||||
|
||||
#include "utl.h"
|
||||
|
||||
#define V size_t
|
||||
#define PFX ll
|
||||
#define SNAME linkedlist
|
||||
#include "cmc/linkedlist.h"
|
||||
|
||||
struct linkedlist_fval *ll_fval = &(struct linkedlist_fval){
|
||||
.cmp = cmc_size_cmp, .cpy = NULL, .str = cmc_size_str, .free = NULL, .hash = cmc_size_hash, .pri = cmc_size_cmp
|
||||
};
|
||||
|
||||
CMC_CREATE_UNIT(CMCLinkedList, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
cmc_assert_equals(size_t, 0, ll_count(ll));
|
||||
cmc_assert_equals(ptr, NULL, ll->head);
|
||||
cmc_assert_equals(ptr, NULL, ll->tail);
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
ll_push_back(ll, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, ll_count(ll));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
cmc_assert_equals(size_t, 0, ll_count(ll));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count = 0], {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
cmc_assert_equals(size_t, 0, ll_count(ll));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_front[count], {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
ll_push_front(ll, 1);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll->head);
|
||||
cmc_assert_not_equals(ptr, NULL, ll->tail);
|
||||
cmc_assert_equals(size_t, 1, ll_count(ll));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_front[item preservation], {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
for (size_t i = 0; i < 200; i++)
|
||||
ll_push_front(ll, i);
|
||||
|
||||
for (size_t i = 0; i < ll_count(ll); i++)
|
||||
cmc_assert_equals(size_t, ll_get(ll, i), ll_count(ll) - i - 1);
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// clear
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
ll_clear(ll);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// customize
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
ll_customize(ll, NULL, NULL);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// push_front
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// push_at
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ll_push_at(ll, 10, 1));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
cmc_assert(!ll_push_at(ll, 10, 300));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_RANGE, ll_flag(ll));
|
||||
|
||||
// push_back
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
// pop_front
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(!ll_pop_front(ll));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll));
|
||||
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert(ll_pop_front(ll));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// pop_at
|
||||
cmc_assert(!ll_pop_at(ll, 0));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll));
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
cmc_assert(!ll_pop_at(ll, 1));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_RANGE, ll_flag(ll));
|
||||
cmc_assert(ll_pop_at(ll, 0));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// pop_back
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(!ll_pop_front(ll));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll));
|
||||
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert(ll_pop_front(ll));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
// front
|
||||
ll_front(ll);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll));
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
ll_front(ll);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
// back
|
||||
ll_back(ll);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll));
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
ll_back(ll);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
// get get_ref
|
||||
ll_get(ll, 0);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll));
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
ll_get_ref(ll, 0);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll));
|
||||
|
||||
cmc_assert(ll_push_at(ll, 10, 0));
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
ll_get(ll, 0);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
ll_get(ll, 1);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_RANGE, ll_flag(ll));
|
||||
ll_get_ref(ll, 0);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
ll_get_ref(ll, 1);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_RANGE, ll_flag(ll));
|
||||
|
||||
// contains
|
||||
cmc_assert(ll_contains(ll, 10));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// copy_of
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
struct linkedlist *ll2 = ll_copy_of(ll);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll2));
|
||||
|
||||
// equals
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
ll2->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ll_equals(ll, ll2));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll2));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
// get_node
|
||||
struct linkedlist_node *n = ll_get_node(ll, 0);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ll_flag(ll));
|
||||
|
||||
cmc_assert(ll_push_at(ll, 10, 0));
|
||||
n = ll_get_node(ll, 0);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
n = ll_get_node(ll, 1);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_RANGE, ll_flag(ll));
|
||||
|
||||
// functions relative to node
|
||||
ll_clear(ll);
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
n = ll_get_node(ll, 0);
|
||||
cmc_assert_not_equals(ptr, NULL, n);
|
||||
|
||||
// add_next
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ll_add_next(ll, n, 11));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// add_prev
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ll_add_prev(ll, n, 9));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// del_next
|
||||
n = ll_next_node(n);
|
||||
cmc_assert(!ll_del_next(ll, n));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_INVALID, ll_flag(ll));
|
||||
n = ll_prev_node(n);
|
||||
cmc_assert(ll_del_next(ll, n));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// del_prev
|
||||
n = ll_prev_node(n);
|
||||
cmc_assert(!ll_del_prev(ll, n));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_INVALID, ll_flag(ll));
|
||||
n = ll_next_node(n);
|
||||
cmc_assert(ll_del_prev(ll, n));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
// del_curr
|
||||
ll->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ll_del_curr(ll, n));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ll_flag(ll));
|
||||
|
||||
ll_free(ll);
|
||||
ll_free(ll2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct linkedlist *ll = ll_new_custom(ll_fval, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(ll_push_at(ll, 10, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
|
||||
cmc_assert(ll_pop_at(ll, 1));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(ll_pop_front(ll));
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
|
||||
cmc_assert(ll_pop_back(ll));
|
||||
cmc_assert_equals(int32_t, 3, total_delete);
|
||||
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 10, ll_front(ll));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 10, ll_back(ll));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 10, ll_get(ll, 0));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll_get_ref(ll, 0));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert(ll_contains(ll, 10));
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 3, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
ll_customize(ll, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, ll->callbacks);
|
||||
|
||||
ll_clear(ll);
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert(ll_push_at(ll, 10, 1));
|
||||
cmc_assert(ll_pop_at(ll, 1));
|
||||
cmc_assert(ll_pop_front(ll));
|
||||
cmc_assert(ll_pop_back(ll));
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert_equals(size_t, 10, ll_front(ll));
|
||||
cmc_assert_equals(size_t, 10, ll_back(ll));
|
||||
cmc_assert_equals(size_t, 10, ll_get(ll, 0));
|
||||
cmc_assert_not_equals(ptr, NULL, ll_get_ref(ll, 0));
|
||||
cmc_assert(ll_contains(ll, 10));
|
||||
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 3, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, ll->callbacks);
|
||||
|
||||
ll_free(ll);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
|
||||
CMC_CREATE_UNIT(CMCLinkedListIter, true, {
|
||||
CMC_CREATE_TEST(PFX##_iter_start(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_start(ll);
|
||||
|
||||
cmc_assert_equals(ptr, ll, it.target);
|
||||
cmc_assert_equals(ptr, NULL, it.cursor);
|
||||
cmc_assert_equals(size_t, 0, it.index);
|
||||
cmc_assert_equals(bool, true, it.start);
|
||||
cmc_assert_equals(bool, true, it.end);
|
||||
|
||||
cmc_assert(ll_iter_at_start(&it));
|
||||
cmc_assert(ll_iter_at_end(&it));
|
||||
|
||||
cmc_assert(ll_push_front(ll, 1));
|
||||
cmc_assert(ll_push_front(ll, 2));
|
||||
|
||||
it = ll_iter_start(ll);
|
||||
|
||||
cmc_assert_equals(size_t, 0, it.index);
|
||||
cmc_assert_equals(bool, false, it.end);
|
||||
cmc_assert_equals(ptr, ll->head, it.cursor);
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_end(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_end(ll);
|
||||
|
||||
cmc_assert_equals(ptr, ll, it.target);
|
||||
cmc_assert_equals(ptr, NULL, it.cursor);
|
||||
cmc_assert_equals(size_t, 0, it.index);
|
||||
cmc_assert_equals(bool, true, it.start);
|
||||
cmc_assert_equals(bool, true, it.end);
|
||||
|
||||
cmc_assert(ll_iter_at_start(&it));
|
||||
cmc_assert(ll_iter_at_end(&it));
|
||||
|
||||
cmc_assert(ll_push_back(ll, 1));
|
||||
cmc_assert(ll_push_back(ll, 2));
|
||||
cmc_assert(ll_push_back(ll, 3));
|
||||
|
||||
it = ll_iter_end(ll);
|
||||
|
||||
cmc_assert_equals(size_t, ll->count - 1, it.index);
|
||||
cmc_assert_equals(ptr, ll->tail, it.cursor);
|
||||
cmc_assert_equals(bool, false, it.start);
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_at_start(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_start(ll);
|
||||
|
||||
// Empty checks
|
||||
cmc_assert(ll_iter_at_start(&it));
|
||||
it = ll_iter_end(ll);
|
||||
cmc_assert(ll_iter_at_start(&it));
|
||||
|
||||
// Non-empty checks
|
||||
cmc_assert(ll_push_back(ll, 1));
|
||||
it = ll_iter_end(ll);
|
||||
cmc_assert(!ll_iter_at_start(&it));
|
||||
it = ll_iter_start(ll);
|
||||
cmc_assert(ll_iter_at_start(&it));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
cmc_assert(ll_push_front(ll, 1));
|
||||
it = ll_iter_end(ll);
|
||||
cmc_assert(!ll_iter_at_start(&it));
|
||||
it = ll_iter_start(ll);
|
||||
cmc_assert(ll_iter_at_start(&it));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_at_end(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_start(ll);
|
||||
|
||||
// Empty check
|
||||
cmc_assert(ll_iter_at_end(&it));
|
||||
it = ll_iter_end(ll);
|
||||
cmc_assert(ll_iter_at_end(&it));
|
||||
|
||||
// Non-empty checks
|
||||
cmc_assert(ll_push_back(ll, 1));
|
||||
it = ll_iter_end(ll);
|
||||
cmc_assert(ll_iter_at_end(&it));
|
||||
it = ll_iter_start(ll);
|
||||
cmc_assert(!ll_iter_at_end(&it));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
cmc_assert(ll_push_front(ll, 1));
|
||||
it = ll_iter_end(ll);
|
||||
cmc_assert(ll_iter_at_end(&it));
|
||||
it = ll_iter_start(ll);
|
||||
cmc_assert(!ll_iter_at_end(&it));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_to_start(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_start(ll);
|
||||
|
||||
cmc_assert(!ll_iter_to_start(&it));
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
ll_push_back(ll, i);
|
||||
else
|
||||
ll_push_front(ll, i);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 100, ll->count);
|
||||
|
||||
it = ll_iter_end(ll);
|
||||
|
||||
cmc_assert(!ll_iter_at_start(&it));
|
||||
cmc_assert(ll_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 100, ll_iter_value(&it));
|
||||
|
||||
cmc_assert(ll_iter_to_start(&it));
|
||||
|
||||
cmc_assert(ll_iter_at_start(&it));
|
||||
cmc_assert(!ll_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 99, ll_iter_value(&it));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_to_end(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_end(ll);
|
||||
|
||||
cmc_assert(!ll_iter_to_end(&it));
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
ll_push_back(ll, i);
|
||||
else
|
||||
ll_push_front(ll, i);
|
||||
}
|
||||
|
||||
it = ll_iter_start(ll);
|
||||
|
||||
cmc_assert(ll_iter_at_start(&it));
|
||||
cmc_assert(!ll_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 99, ll_iter_value(&it));
|
||||
|
||||
cmc_assert(ll_iter_to_end(&it));
|
||||
|
||||
cmc_assert(!ll_iter_at_start(&it));
|
||||
cmc_assert(ll_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 100, ll_iter_value(&it));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_next(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_start(ll);
|
||||
|
||||
cmc_assert(!ll_iter_next(&it));
|
||||
|
||||
for (size_t i = 1; i <= 1000; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
ll_push_back(ll, i);
|
||||
else
|
||||
ll_push_front(ll, i);
|
||||
}
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = ll_iter_start(ll); !ll_iter_at_end(&it); ll_iter_next(&it))
|
||||
{
|
||||
sum += ll_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
|
||||
ll_iter_to_start(&it);
|
||||
do
|
||||
{
|
||||
sum += ll_iter_value(&it);
|
||||
} while (ll_iter_next(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_prev(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_end(ll);
|
||||
|
||||
cmc_assert(!ll_iter_prev(&it));
|
||||
|
||||
for (size_t i = 1; i <= 1000; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
ll_push_back(ll, i);
|
||||
else
|
||||
ll_push_front(ll, i);
|
||||
}
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = ll_iter_end(ll); !ll_iter_at_start(&it); ll_iter_prev(&it))
|
||||
{
|
||||
sum += ll_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
|
||||
ll_iter_to_end(&it);
|
||||
do
|
||||
{
|
||||
sum += ll_iter_value(&it);
|
||||
} while (ll_iter_prev(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_advance(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_start(ll);
|
||||
|
||||
cmc_assert(!ll_iter_advance(&it, 1));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
ll_push_back(ll, i); // will sum all even numbers
|
||||
else
|
||||
ll_push_back(ll, 0);
|
||||
}
|
||||
|
||||
it = ll_iter_start(ll);
|
||||
|
||||
cmc_assert(!ll_iter_advance(&it, 0));
|
||||
cmc_assert(!ll_iter_advance(&it, ll->count));
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = ll_iter_start(ll);;)
|
||||
{
|
||||
sum += ll_iter_value(&it);
|
||||
|
||||
if (!ll_iter_advance(&it, 2))
|
||||
break;
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 250500, sum);
|
||||
|
||||
ll_iter_to_start(&it);
|
||||
cmc_assert(ll_iter_advance(&it, ll->count - 1));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_rewind(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_end(ll);
|
||||
|
||||
cmc_assert(!ll_iter_rewind(&it, 1));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
ll_push_front(ll, i); // will sum all even numbers
|
||||
else
|
||||
ll_push_front(ll, 0);
|
||||
}
|
||||
|
||||
it = ll_iter_end(ll);
|
||||
|
||||
cmc_assert(!ll_iter_rewind(&it, 0));
|
||||
cmc_assert(!ll_iter_rewind(&it, ll->count));
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = ll_iter_end(ll);;)
|
||||
{
|
||||
sum += ll_iter_value(&it);
|
||||
|
||||
if (!ll_iter_rewind(&it, 2))
|
||||
break;
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 250500, sum);
|
||||
|
||||
ll_iter_to_end(&it);
|
||||
cmc_assert(ll_iter_rewind(&it, ll->count - 1));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_go_to(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_end(ll);
|
||||
cmc_assert(!ll_iter_go_to(&it, 0));
|
||||
|
||||
it = ll_iter_start(ll);
|
||||
cmc_assert(!ll_iter_go_to(&it, 0));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
ll_push_back(ll, i);
|
||||
|
||||
it = ll_iter_start(ll);
|
||||
|
||||
size_t sum = 0;
|
||||
for (size_t i = 0; i < 1001; i++)
|
||||
{
|
||||
ll_iter_go_to(&it, i);
|
||||
|
||||
sum += ll_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
for (size_t i = 1001; i > 0; i--)
|
||||
{
|
||||
cmc_assert(ll_iter_go_to(&it, i - 1));
|
||||
|
||||
sum += ll_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
for (size_t i = 0; i < 1001; i += 100)
|
||||
{
|
||||
cmc_assert(ll_iter_go_to(&it, i));
|
||||
cmc_assert_equals(size_t, i, ll_iter_index(&it));
|
||||
|
||||
sum += ll_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5500, sum);
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_value(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_end(ll);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, ll_iter_value(&it));
|
||||
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
|
||||
it = ll_iter_start(ll);
|
||||
|
||||
cmc_assert_equals(size_t, 10, ll_iter_value(&it));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_rvalue(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_end(ll);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, ll_iter_rvalue(&it));
|
||||
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
|
||||
it = ll_iter_start(ll);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll_iter_rvalue(&it));
|
||||
cmc_assert_equals(size_t, 10, *ll_iter_rvalue(&it));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_index(), {
|
||||
struct linkedlist *ll = ll_new(ll_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
ll_push_back(ll, i);
|
||||
|
||||
struct linkedlist_iter it = ll_iter_start(ll);
|
||||
|
||||
for (size_t i = 0; i < 1001; i++)
|
||||
{
|
||||
cmc_assert_equals(size_t, i, ll_iter_index(&it));
|
||||
ll_iter_next(&it);
|
||||
}
|
||||
|
||||
it = ll_iter_end(ll);
|
||||
for (size_t i = 1001; i > 0; i--)
|
||||
{
|
||||
cmc_assert_equals(size_t, i - 1, ll_iter_index(&it));
|
||||
ll_iter_prev(&it);
|
||||
}
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
});
|
||||
|
||||
#ifdef CMC_TEST_MAIN
|
||||
int main(void)
|
||||
{
|
||||
int result = CMCLinkedList() + CMCLinkedListIter();
|
||||
|
||||
printf(" +---------------------------------------------------------------+");
|
||||
printf("\n");
|
||||
printf(" | CMCLinkedList Suit : %-43s |\n", result == 0 ? "PASSED" : "FAILED");
|
||||
printf(" +---------------------------------------------------------------+");
|
||||
printf("\n\n\n");
|
||||
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* CMC_TESTS_UNT_CMC_INKEDLIST_H */
|
||||
@@ -6,10 +6,6 @@
|
||||
#define V size_t
|
||||
#define PFX l
|
||||
#define SNAME list
|
||||
#define CMC_EXT_LIST_INIT
|
||||
#define CMC_EXT_LIST_ITER
|
||||
#define CMC_EXT_LIST_SEQ
|
||||
#define CMC_EXT_LIST_STR
|
||||
#include "cmc/list.h"
|
||||
|
||||
struct list_fval *l_fval = &(struct list_fval){
|
||||
|
||||
@@ -6,9 +6,6 @@
|
||||
#define V size_t
|
||||
#define PFX q
|
||||
#define SNAME queue
|
||||
#define CMC_EXT_QUEUE_INIT
|
||||
#define CMC_EXT_QUEUE_ITER
|
||||
#define CMC_EXT_QUEUE_STR
|
||||
#include "cmc/queue.h"
|
||||
|
||||
struct queue_fval *q_fval = &(struct queue_fval){
|
||||
|
||||
@@ -0,0 +1,717 @@
|
||||
#ifndef CMC_TESTS_UNT_SORTEDLIST_H
|
||||
#define CMC_TESTS_UNT_SORTEDLIST_H
|
||||
|
||||
#include "utl.h"
|
||||
|
||||
#define V size_t
|
||||
#define PFX sl
|
||||
#define SNAME sortedlist
|
||||
#include "cmc/sortedlist.h"
|
||||
|
||||
struct sortedlist_fval *sl_fval = &(struct sortedlist_fval){
|
||||
.cmp = cmc_size_cmp, .cpy = NULL, .str = cmc_size_str, .free = NULL, .hash = cmc_size_hash, .pri = cmc_size_cmp
|
||||
};
|
||||
|
||||
CMC_CREATE_UNIT(CMCSortedList, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct sortedlist *sl = sl_new(1000000, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
cmc_assert_not_equals(ptr, NULL, sl->buffer);
|
||||
cmc_assert_equals(size_t, 1000000, sl_capacity(sl));
|
||||
cmc_assert_equals(size_t, 0, sl_count(sl));
|
||||
cmc_assert_not_equals(ptr, NULL, sl->buffer);
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct sortedlist *sl = sl_new(0, sl_fval);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct sortedlist *sl = sl_new(UINT64_MAX, sl_fval);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(sl_insert(sl, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, sl_count(sl));
|
||||
|
||||
sl_clear(sl);
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_count(sl));
|
||||
cmc_assert_equals(size_t, 100, sl_capacity(sl));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[capacity = 1], {
|
||||
struct sortedlist *sl = sl_new(1, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(sl_insert(sl, i));
|
||||
|
||||
sl_sort(sl);
|
||||
|
||||
cmc_assert_equals(size_t, 50, sl_count(sl));
|
||||
cmc_assert_array_sorted_any(size_t, sl->buffer, cmc_size_cmp, 0, sl->count - 1);
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert, {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove, {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
cmc_assert(sl_insert(sl, 32));
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[count = 0], {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
cmc_assert(!sl_remove(sl, 0));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[out of range], {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
cmc_assert(sl_insert(sl, 32));
|
||||
|
||||
cmc_assert(!sl_remove(sl, 2));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(index_of, {
|
||||
struct sortedlist *sl = sl_new(1, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
for (size_t i = 0; i < 20; i++)
|
||||
cmc_assert(sl_insert(sl, i % 10));
|
||||
|
||||
/* 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9 */
|
||||
cmc_assert_equals(size_t, 4, sl_index_of(sl, 2, true));
|
||||
cmc_assert_equals(size_t, 5, sl_index_of(sl, 2, false));
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_index_of(sl, 0, true));
|
||||
cmc_assert_equals(size_t, 1, sl_index_of(sl, 0, false));
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_index_of(sl, 0, true));
|
||||
cmc_assert_equals(size_t, 0, sl_index_of(sl, 0, false));
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
|
||||
cmc_assert_equals(size_t, sl_count(sl), sl_index_of(sl, 0, true));
|
||||
cmc_assert_equals(size_t, sl_count(sl), sl_index_of(sl, 0, false));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
|
||||
// clear
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
sl_clear(sl);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
|
||||
// customize
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
sl_customize(sl, NULL, NULL);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
|
||||
// insert
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(sl_insert(sl, 10));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
|
||||
// remove
|
||||
cmc_assert(!sl_remove(sl, 2));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_RANGE, sl_flag(sl));
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
|
||||
cmc_assert(!sl_remove(sl, 0));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, sl_flag(sl));
|
||||
|
||||
// max min
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, sl_max(sl));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, sl_flag(sl));
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, sl_min(sl));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, sl_flag(sl));
|
||||
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert_equals(size_t, 1, sl_max(sl));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert_equals(size_t, 1, sl_min(sl));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
|
||||
// get
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
sl_get(sl, 1);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_RANGE, sl_flag(sl));
|
||||
|
||||
sl_get(sl, 0);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
sl_get(sl, 0);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, sl_flag(sl));
|
||||
|
||||
// index_of
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
sl_index_of(sl, 1, false);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
|
||||
// contains
|
||||
cmc_assert(sl_contains(sl, 1));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
|
||||
// sort
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
sl_sort(sl);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
|
||||
// copy_of
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
struct sortedlist *sl2 = sl_copy_of(sl);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl2));
|
||||
|
||||
// equals
|
||||
sl->flag = CMC_FLAG_ERROR;
|
||||
sl2->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(sl_equals(sl, sl2));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, sl_flag(sl2));
|
||||
|
||||
sl_free(sl);
|
||||
sl_free(sl2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct sortedlist *sl = sl_new_custom(100, sl_fval, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(sl_insert(sl, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
cmc_assert(sl_insert(sl, 0));
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 1, sl_max(sl));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_min(sl));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_get(sl, 0));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_index_of(sl, 0, true));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert(sl_contains(sl, 1));
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
|
||||
cmc_assert(sl_resize(sl, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(sl_resize(sl, 50));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
sl_customize(sl, NULL, NULL);
|
||||
|
||||
sl_clear(sl);
|
||||
cmc_assert(sl_insert(sl, 10));
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
cmc_assert(sl_insert(sl, 0));
|
||||
cmc_assert_equals(size_t, 1, sl_max(sl));
|
||||
cmc_assert_equals(size_t, 0, sl_min(sl));
|
||||
cmc_assert_equals(size_t, 0, sl_get(sl, 0));
|
||||
cmc_assert_equals(size_t, 0, sl_index_of(sl, 0, true));
|
||||
cmc_assert(sl_contains(sl, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, sl->callbacks);
|
||||
|
||||
sl_free(sl);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
|
||||
CMC_CREATE_UNIT(CMCSortedListIter, true, {
|
||||
CMC_CREATE_TEST(PFX##_iter_start(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_start(sl);
|
||||
|
||||
cmc_assert_equals(ptr, sl, it.target);
|
||||
cmc_assert_equals(size_t, 0, it.cursor);
|
||||
cmc_assert_equals(bool, true, it.start);
|
||||
cmc_assert_equals(bool, true, it.end);
|
||||
|
||||
cmc_assert(sl_iter_at_start(&it));
|
||||
cmc_assert(sl_iter_at_end(&it));
|
||||
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
cmc_assert(sl_insert(sl, 2));
|
||||
|
||||
it = sl_iter_start(sl);
|
||||
|
||||
cmc_assert_equals(size_t, 0, it.cursor);
|
||||
cmc_assert_equals(bool, false, it.end);
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_end(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_end(sl);
|
||||
|
||||
cmc_assert_equals(ptr, sl, it.target);
|
||||
cmc_assert_equals(size_t, 0, it.cursor);
|
||||
cmc_assert_equals(bool, true, it.start);
|
||||
cmc_assert_equals(bool, true, it.end);
|
||||
|
||||
cmc_assert(sl_iter_at_start(&it));
|
||||
cmc_assert(sl_iter_at_end(&it));
|
||||
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
cmc_assert(sl_insert(sl, 2));
|
||||
cmc_assert(sl_insert(sl, 3));
|
||||
|
||||
it = sl_iter_end(sl);
|
||||
|
||||
cmc_assert_equals(size_t, sl->count - 1, it.cursor);
|
||||
cmc_assert_equals(bool, false, it.start);
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_at_start(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_start(sl);
|
||||
|
||||
// Empty checks
|
||||
cmc_assert(sl_iter_at_start(&it));
|
||||
it = sl_iter_end(sl);
|
||||
cmc_assert(sl_iter_at_start(&it));
|
||||
|
||||
// Non-empty checks
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
it = sl_iter_end(sl);
|
||||
cmc_assert(!sl_iter_at_start(&it));
|
||||
it = sl_iter_start(sl);
|
||||
cmc_assert(sl_iter_at_start(&it));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_at_end(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_start(sl);
|
||||
|
||||
// Empty check
|
||||
cmc_assert(sl_iter_at_end(&it));
|
||||
it = sl_iter_end(sl);
|
||||
cmc_assert(sl_iter_at_end(&it));
|
||||
|
||||
// Non-empty checks
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
it = sl_iter_end(sl);
|
||||
cmc_assert(sl_iter_at_end(&it));
|
||||
it = sl_iter_start(sl);
|
||||
cmc_assert(!sl_iter_at_end(&it));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_to_start(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_start(sl);
|
||||
|
||||
cmc_assert(!sl_iter_to_start(&it));
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
sl_insert(sl, i);
|
||||
|
||||
cmc_assert_equals(size_t, 100, sl->count);
|
||||
|
||||
it = sl_iter_end(sl);
|
||||
|
||||
cmc_assert(!sl_iter_at_start(&it));
|
||||
cmc_assert(sl_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 100, sl_iter_value(&it));
|
||||
|
||||
cmc_assert(sl_iter_to_start(&it));
|
||||
|
||||
cmc_assert(sl_iter_at_start(&it));
|
||||
cmc_assert(!sl_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 1, sl_iter_value(&it));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_to_end(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_end(sl);
|
||||
|
||||
cmc_assert(!sl_iter_to_end(&it));
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
sl_insert(sl, i);
|
||||
|
||||
it = sl_iter_start(sl);
|
||||
|
||||
cmc_assert(sl_iter_at_start(&it));
|
||||
cmc_assert(!sl_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 1, sl_iter_value(&it));
|
||||
|
||||
cmc_assert(sl_iter_to_end(&it));
|
||||
|
||||
cmc_assert(!sl_iter_at_start(&it));
|
||||
cmc_assert(sl_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 100, sl_iter_value(&it));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_next(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_start(sl);
|
||||
|
||||
cmc_assert(!sl_iter_next(&it));
|
||||
|
||||
for (size_t i = 1; i <= 1000; i++)
|
||||
sl_insert(sl, i);
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = sl_iter_start(sl); !sl_iter_at_end(&it); sl_iter_next(&it))
|
||||
{
|
||||
sum += sl_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
|
||||
sl_iter_to_start(&it);
|
||||
do
|
||||
{
|
||||
sum += sl_iter_value(&it);
|
||||
} while (sl_iter_next(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_prev(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_end(sl);
|
||||
|
||||
cmc_assert(!sl_iter_prev(&it));
|
||||
|
||||
for (size_t i = 1; i <= 1000; i++)
|
||||
sl_insert(sl, i);
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = sl_iter_end(sl); !sl_iter_at_start(&it); sl_iter_prev(&it))
|
||||
{
|
||||
sum += sl_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
|
||||
sl_iter_to_end(&it);
|
||||
do
|
||||
{
|
||||
sum += sl_iter_value(&it);
|
||||
} while (sl_iter_prev(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_advance(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_start(sl);
|
||||
|
||||
cmc_assert(!sl_iter_advance(&it, 1));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
sl_insert(sl, i);
|
||||
|
||||
it = sl_iter_start(sl);
|
||||
|
||||
cmc_assert(!sl_iter_advance(&it, 0));
|
||||
cmc_assert(!sl_iter_advance(&it, sl->count));
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = sl_iter_start(sl);;)
|
||||
{
|
||||
sum += sl_iter_value(&it);
|
||||
|
||||
if (!sl_iter_advance(&it, 2))
|
||||
break;
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 250500, sum);
|
||||
|
||||
sl_iter_to_start(&it);
|
||||
cmc_assert(sl_iter_advance(&it, sl->count - 1));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_rewind(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_end(sl);
|
||||
|
||||
cmc_assert(!sl_iter_rewind(&it, 1));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
sl_insert(sl, i);
|
||||
|
||||
it = sl_iter_end(sl);
|
||||
|
||||
cmc_assert(!sl_iter_rewind(&it, 0));
|
||||
cmc_assert(!sl_iter_rewind(&it, sl->count));
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = sl_iter_end(sl);;)
|
||||
{
|
||||
sum += sl_iter_value(&it);
|
||||
|
||||
if (!sl_iter_rewind(&it, 2))
|
||||
break;
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 250500, sum);
|
||||
|
||||
sl_iter_to_end(&it);
|
||||
cmc_assert(sl_iter_rewind(&it, sl->count - 1));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_go_to(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_end(sl);
|
||||
cmc_assert(!sl_iter_go_to(&it, 0));
|
||||
|
||||
it = sl_iter_start(sl);
|
||||
cmc_assert(!sl_iter_go_to(&it, 0));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
sl_insert(sl, i);
|
||||
|
||||
it = sl_iter_start(sl);
|
||||
|
||||
size_t sum = 0;
|
||||
for (size_t i = 0; i < 1001; i++)
|
||||
{
|
||||
sl_iter_go_to(&it, i);
|
||||
|
||||
sum += sl_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
for (size_t i = 1001; i > 0; i--)
|
||||
{
|
||||
cmc_assert(sl_iter_go_to(&it, i - 1));
|
||||
|
||||
sum += sl_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
for (size_t i = 0; i < 1001; i += 100)
|
||||
{
|
||||
cmc_assert(sl_iter_go_to(&it, i));
|
||||
cmc_assert_equals(size_t, i, sl_iter_index(&it));
|
||||
|
||||
sum += sl_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5500, sum);
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_value(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_end(sl);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, sl_iter_value(&it));
|
||||
|
||||
cmc_assert(sl_insert(sl, 10));
|
||||
|
||||
it = sl_iter_start(sl);
|
||||
|
||||
cmc_assert_equals(size_t, 10, sl_iter_value(&it));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_index(), {
|
||||
struct sortedlist *sl = sl_new(100, sl_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
sl_insert(sl, i);
|
||||
|
||||
struct sortedlist_iter it = sl_iter_start(sl);
|
||||
|
||||
for (size_t i = 0; i < 1001; i++)
|
||||
{
|
||||
cmc_assert_equals(size_t, i, sl_iter_index(&it));
|
||||
sl_iter_next(&it);
|
||||
}
|
||||
|
||||
it = sl_iter_end(sl);
|
||||
for (size_t i = 1001; i > 0; i--)
|
||||
{
|
||||
cmc_assert_equals(size_t, i - 1, sl_iter_index(&it));
|
||||
sl_iter_prev(&it);
|
||||
}
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
});
|
||||
|
||||
#ifdef CMC_TEST_MAIN
|
||||
int main(void)
|
||||
{
|
||||
int result = CMCSortedList() + CMCSortedListIter();
|
||||
|
||||
printf(" +---------------------------------------------------------------+");
|
||||
printf("\n");
|
||||
printf(" | CMCSortedList Suit : %-43s |\n", result == 0 ? "PASSED" : "FAILED");
|
||||
printf(" +---------------------------------------------------------------+");
|
||||
printf("\n\n\n");
|
||||
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* CMC_TESTS_UNT_SORTEDLIST_H */
|
||||
@@ -6,9 +6,6 @@
|
||||
#define V size_t
|
||||
#define PFX s
|
||||
#define SNAME stack
|
||||
#define CMC_EXT_STACK_INIT
|
||||
#define CMC_EXT_STACK_ITER
|
||||
#define CMC_EXT_STACK_STR
|
||||
#include "cmc/stack.h"
|
||||
|
||||
struct stack_fval *s_fval = &(struct stack_fval){
|
||||
|
||||
@@ -0,0 +1,674 @@
|
||||
#ifndef CMC_TESTS_UNT_TREEMAP_H
|
||||
#define CMC_TESTS_UNT_TREEMAP_H
|
||||
|
||||
#include "utl.h"
|
||||
|
||||
#define V size_t
|
||||
#define K size_t
|
||||
#define PFX tm
|
||||
#define SNAME treemap
|
||||
#include "cmc/treemap.h"
|
||||
|
||||
struct treemap_fkey *tm_fkey = &(struct treemap_fkey){
|
||||
.cmp = cmc_size_cmp, .cpy = NULL, .str = cmc_size_str, .free = NULL, .hash = cmc_size_hash, .pri = cmc_size_cmp
|
||||
};
|
||||
|
||||
struct treemap_fval *tm_fval = &(struct treemap_fval){
|
||||
.cmp = cmc_size_cmp, .cpy = NULL, .str = cmc_size_str, .free = NULL, .hash = cmc_size_hash, .pri = cmc_size_cmp
|
||||
};
|
||||
|
||||
CMC_CREATE_UNIT(CMCTreeMap, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count], {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
tm_insert(map, i, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, tm_count(map));
|
||||
|
||||
tm_clear(map);
|
||||
|
||||
cmc_assert_equals(size_t, 0, tm_count(map));
|
||||
cmc_assert_equals(ptr, NULL, map->root);
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
|
||||
// clear
|
||||
map->flag = CMC_FLAG_ERROR;
|
||||
tm_clear(map);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
|
||||
// insert
|
||||
map->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(tm_insert(map, 1, 1));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
|
||||
cmc_assert(!tm_insert(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, tm_flag(map));
|
||||
|
||||
// update
|
||||
cmc_assert(!tm_update(map, 2, 2, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, tm_flag(map));
|
||||
|
||||
cmc_assert(tm_update(map, 1, 2, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
|
||||
// remove
|
||||
cmc_assert(!tm_remove(map, 2, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, tm_flag(map));
|
||||
|
||||
cmc_assert(tm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
|
||||
cmc_assert(!tm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, tm_flag(map));
|
||||
|
||||
// max min
|
||||
map->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(!tm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, tm_flag(map));
|
||||
|
||||
map->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(!tm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, tm_flag(map));
|
||||
|
||||
cmc_assert(tm_insert(map, 1, 1));
|
||||
map->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(tm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
|
||||
map->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(tm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
|
||||
// get get_ref
|
||||
tm_get(map, 2);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, tm_flag(map));
|
||||
|
||||
tm_get(map, 1);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
|
||||
tm_get_ref(map, 2);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, tm_flag(map));
|
||||
|
||||
tm_get_ref(map, 1);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
|
||||
cmc_assert(tm_remove(map, 1, NULL));
|
||||
map->flag = CMC_FLAG_ERROR;
|
||||
tm_get(map, 1);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, tm_flag(map));
|
||||
|
||||
map->flag = CMC_FLAG_ERROR;
|
||||
tm_get_ref(map, 1);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, tm_flag(map));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(tm_insert(map, i, i));
|
||||
|
||||
// copy_of
|
||||
map->flag = CMC_FLAG_ERROR;
|
||||
struct treemap *map2 = tm_copy_of(map);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map2));
|
||||
|
||||
// equals
|
||||
map->flag = CMC_FLAG_ERROR;
|
||||
map2->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(tm_equals(map, map2));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, tm_flag(map2));
|
||||
|
||||
tm_free(map);
|
||||
tm_free(map2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct treemap *map = tm_new_custom(tm_fkey, tm_fval, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(tm_insert(map, 1, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(tm_update(map, 1, 2, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
|
||||
cmc_assert(tm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(tm_insert(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(tm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(tm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 2, tm_get(map, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, tm_get_ref(map, 1));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert(tm_contains(map, 1));
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
tm_customize(map, NULL, NULL);
|
||||
|
||||
tm_clear(map);
|
||||
cmc_assert(tm_insert(map, 1, 10));
|
||||
cmc_assert(tm_update(map, 1, 2, NULL));
|
||||
cmc_assert(tm_remove(map, 1, NULL));
|
||||
cmc_assert(tm_insert(map, 1, 2));
|
||||
cmc_assert(tm_max(map, NULL, NULL));
|
||||
cmc_assert(tm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(size_t, 2, tm_get(map, 1));
|
||||
cmc_assert_not_equals(ptr, NULL, tm_get_ref(map, 1));
|
||||
cmc_assert(tm_contains(map, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map->callbacks);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
});
|
||||
|
||||
CMC_CREATE_UNIT(CMCTreeMapIter, true, {
|
||||
CMC_CREATE_TEST(PFX##_iter_start(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_start(map);
|
||||
|
||||
cmc_assert_equals(ptr, map, it.target);
|
||||
cmc_assert_equals(ptr, NULL, it.cursor);
|
||||
cmc_assert_equals(ptr, NULL, it.first);
|
||||
cmc_assert_equals(ptr, NULL, it.last);
|
||||
cmc_assert_equals(size_t, 0, it.index);
|
||||
cmc_assert_equals(bool, true, it.start);
|
||||
cmc_assert_equals(bool, true, it.end);
|
||||
|
||||
cmc_assert(tm_iter_at_start(&it));
|
||||
cmc_assert(tm_iter_at_end(&it));
|
||||
|
||||
cmc_assert(tm_insert(map, 1, 1));
|
||||
cmc_assert(tm_insert(map, 2, 2));
|
||||
cmc_assert(tm_insert(map, 3, 3));
|
||||
|
||||
it = tm_iter_start(map);
|
||||
|
||||
cmc_assert_equals(size_t, 0, it.index);
|
||||
|
||||
cmc_assert_equals(size_t, 1, it.cursor->key);
|
||||
cmc_assert_equals(size_t, 1, it.first->key);
|
||||
cmc_assert_equals(size_t, 3, it.last->key);
|
||||
cmc_assert_equals(bool, false, it.end);
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_end(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_end(map);
|
||||
|
||||
cmc_assert_equals(ptr, map, it.target);
|
||||
cmc_assert_equals(ptr, NULL, it.cursor);
|
||||
cmc_assert_equals(ptr, NULL, it.first);
|
||||
cmc_assert_equals(ptr, NULL, it.last);
|
||||
cmc_assert_equals(size_t, 0, it.index);
|
||||
cmc_assert_equals(bool, true, it.start);
|
||||
cmc_assert_equals(bool, true, it.end);
|
||||
|
||||
cmc_assert(tm_iter_at_start(&it));
|
||||
cmc_assert(tm_iter_at_end(&it));
|
||||
|
||||
cmc_assert(tm_insert(map, 1, 1));
|
||||
cmc_assert(tm_insert(map, 2, 2));
|
||||
cmc_assert(tm_insert(map, 3, 3));
|
||||
|
||||
it = tm_iter_end(map);
|
||||
|
||||
cmc_assert_equals(size_t, map->count - 1, it.index);
|
||||
|
||||
cmc_assert_equals(size_t, 3, it.cursor->key);
|
||||
cmc_assert_equals(size_t, 1, it.first->key);
|
||||
cmc_assert_equals(size_t, 3, it.last->key);
|
||||
cmc_assert_equals(bool, false, it.start);
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_at_start(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_start(map);
|
||||
|
||||
// Empty checks
|
||||
cmc_assert(tm_iter_at_start(&it));
|
||||
it = tm_iter_end(map);
|
||||
cmc_assert(tm_iter_at_start(&it));
|
||||
|
||||
// Non-empty checks
|
||||
cmc_assert(tm_insert(map, 1, 1));
|
||||
cmc_assert(tm_insert(map, 2, 2));
|
||||
it = tm_iter_end(map);
|
||||
cmc_assert(!tm_iter_at_start(&it));
|
||||
it = tm_iter_start(map);
|
||||
cmc_assert(tm_iter_at_start(&it));
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_at_end(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_start(map);
|
||||
|
||||
// Empty check
|
||||
cmc_assert(tm_iter_at_end(&it));
|
||||
it = tm_iter_end(map);
|
||||
cmc_assert(tm_iter_at_end(&it));
|
||||
|
||||
// Non-empty checks
|
||||
cmc_assert(tm_insert(map, 1, 1));
|
||||
cmc_assert(tm_insert(map, 2, 2));
|
||||
it = tm_iter_end(map);
|
||||
cmc_assert(tm_iter_at_end(&it));
|
||||
it = tm_iter_start(map);
|
||||
cmc_assert(!tm_iter_at_end(&it));
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_to_start(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_start(map);
|
||||
|
||||
cmc_assert(!tm_iter_to_start(&it));
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
tm_insert(map, i, i);
|
||||
|
||||
cmc_assert_equals(size_t, 100, map->count);
|
||||
|
||||
it = tm_iter_end(map);
|
||||
|
||||
cmc_assert(!tm_iter_at_start(&it));
|
||||
cmc_assert(tm_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 100, tm_iter_value(&it));
|
||||
|
||||
cmc_assert(tm_iter_to_start(&it));
|
||||
|
||||
cmc_assert(tm_iter_at_start(&it));
|
||||
cmc_assert(!tm_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 1, tm_iter_value(&it));
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_to_end(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_end(map);
|
||||
|
||||
cmc_assert(!tm_iter_to_end(&it));
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
tm_insert(map, i, i);
|
||||
|
||||
it = tm_iter_start(map);
|
||||
|
||||
cmc_assert(tm_iter_at_start(&it));
|
||||
cmc_assert(!tm_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 1, tm_iter_value(&it));
|
||||
|
||||
cmc_assert(tm_iter_to_end(&it));
|
||||
|
||||
cmc_assert(!tm_iter_at_start(&it));
|
||||
cmc_assert(tm_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 100, tm_iter_value(&it));
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_next(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_start(map);
|
||||
|
||||
cmc_assert(!tm_iter_next(&it));
|
||||
|
||||
for (size_t i = 1; i <= 1000; i++)
|
||||
tm_insert(map, i, i);
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = tm_iter_start(map); !tm_iter_at_end(&it); tm_iter_next(&it))
|
||||
{
|
||||
sum += tm_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
|
||||
tm_iter_to_start(&it);
|
||||
do
|
||||
{
|
||||
sum += tm_iter_value(&it);
|
||||
} while (tm_iter_next(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_prev(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_end(map);
|
||||
|
||||
cmc_assert(!tm_iter_prev(&it));
|
||||
|
||||
for (size_t i = 1; i <= 1000; i++)
|
||||
tm_insert(map, i, i);
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = tm_iter_end(map); !tm_iter_at_start(&it); tm_iter_prev(&it))
|
||||
{
|
||||
sum += tm_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
|
||||
tm_iter_to_end(&it);
|
||||
do
|
||||
{
|
||||
sum += tm_iter_value(&it);
|
||||
} while (tm_iter_prev(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_advance(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_start(map);
|
||||
|
||||
cmc_assert(!tm_iter_advance(&it, 1));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
tm_insert(map, i, i);
|
||||
|
||||
it = tm_iter_start(map);
|
||||
|
||||
cmc_assert(!tm_iter_advance(&it, 0));
|
||||
cmc_assert(!tm_iter_advance(&it, map->count));
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = tm_iter_start(map);;)
|
||||
{
|
||||
sum += tm_iter_value(&it);
|
||||
|
||||
if (!tm_iter_advance(&it, 2))
|
||||
break;
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 250500, sum);
|
||||
|
||||
tm_iter_to_start(&it);
|
||||
cmc_assert(tm_iter_advance(&it, map->count - 1));
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_rewind(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_end(map);
|
||||
|
||||
cmc_assert(!tm_iter_rewind(&it, 1));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
tm_insert(map, i, i);
|
||||
|
||||
it = tm_iter_end(map);
|
||||
|
||||
cmc_assert(!tm_iter_rewind(&it, 0));
|
||||
cmc_assert(!tm_iter_rewind(&it, map->count));
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = tm_iter_end(map);;)
|
||||
{
|
||||
sum += tm_iter_value(&it);
|
||||
|
||||
if (!tm_iter_rewind(&it, 2))
|
||||
break;
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 250500, sum);
|
||||
|
||||
tm_iter_to_end(&it);
|
||||
cmc_assert(tm_iter_rewind(&it, map->count - 1));
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_go_to(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_end(map);
|
||||
cmc_assert(!tm_iter_go_to(&it, 0));
|
||||
|
||||
it = tm_iter_start(map);
|
||||
cmc_assert(!tm_iter_go_to(&it, 0));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
tm_insert(map, i, i);
|
||||
|
||||
it = tm_iter_start(map);
|
||||
|
||||
size_t sum = 0;
|
||||
for (size_t i = 0; i < 1001; i++)
|
||||
{
|
||||
tm_iter_go_to(&it, i);
|
||||
|
||||
sum += tm_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
for (size_t i = 1001; i > 0; i--)
|
||||
{
|
||||
cmc_assert(tm_iter_go_to(&it, i - 1));
|
||||
|
||||
sum += tm_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
for (size_t i = 0; i < 1001; i += 100)
|
||||
{
|
||||
cmc_assert(tm_iter_go_to(&it, i));
|
||||
cmc_assert_equals(size_t, i, tm_iter_index(&it));
|
||||
|
||||
sum += tm_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5500, sum);
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_key(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_end(map);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, tm_iter_key(&it));
|
||||
|
||||
cmc_assert(tm_insert(map, 10, 10));
|
||||
|
||||
it = tm_iter_start(map);
|
||||
|
||||
cmc_assert_equals(size_t, 10, tm_iter_key(&it));
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_value(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_end(map);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, tm_iter_value(&it));
|
||||
|
||||
cmc_assert(tm_insert(map, 10, 10));
|
||||
|
||||
it = tm_iter_start(map);
|
||||
|
||||
cmc_assert_equals(size_t, 10, tm_iter_value(&it));
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_rvalue(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
struct treemap_iter it = tm_iter_end(map);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, tm_iter_rvalue(&it));
|
||||
|
||||
cmc_assert(tm_insert(map, 10, 10));
|
||||
|
||||
it = tm_iter_start(map);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, tm_iter_rvalue(&it));
|
||||
cmc_assert_equals(size_t, 10, *tm_iter_rvalue(&it));
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_index(), {
|
||||
struct treemap *map = tm_new(tm_fkey, tm_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
tm_insert(map, i, i);
|
||||
|
||||
struct treemap_iter it = tm_iter_start(map);
|
||||
|
||||
for (size_t i = 0; i < 1001; i++)
|
||||
{
|
||||
cmc_assert_equals(size_t, i, tm_iter_index(&it));
|
||||
tm_iter_next(&it);
|
||||
}
|
||||
|
||||
it = tm_iter_end(map);
|
||||
for (size_t i = 1001; i > 0; i--)
|
||||
{
|
||||
cmc_assert_equals(size_t, i - 1, tm_iter_index(&it));
|
||||
tm_iter_prev(&it);
|
||||
}
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
});
|
||||
|
||||
#ifdef CMC_TEST_MAIN
|
||||
int main(void)
|
||||
{
|
||||
int result = CMCTreeMap() + CMCTreeMapIter();
|
||||
|
||||
printf(" +---------------------------------------------------------------+");
|
||||
printf("\n");
|
||||
printf(" | CMCTreeMap Suit : %-46s |\n", result == 0 ? "PASSED" : "FAILED");
|
||||
printf(" +---------------------------------------------------------------+");
|
||||
printf("\n\n\n");
|
||||
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* CMC_TESTS_UNT_TREEMAP_H */
|
||||
@@ -0,0 +1,588 @@
|
||||
#ifndef CMC_TESTS_UNT_TREESET_H
|
||||
#define CMC_TESTS_UNT_TREESET_H
|
||||
|
||||
#include "utl.h"
|
||||
|
||||
#define V size_t
|
||||
#define PFX ts
|
||||
#define SNAME treeset
|
||||
#include "cmc/treeset.h"
|
||||
|
||||
struct treeset_fval *ts_fval = &(struct treeset_fval){
|
||||
.cmp = cmc_size_cmp, .cpy = NULL, .str = cmc_size_str, .free = NULL, .hash = cmc_size_hash, .pri = cmc_size_cmp
|
||||
};
|
||||
|
||||
CMC_CREATE_UNIT(CMCTreeSet, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count], {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
ts_insert(set, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, ts_count(set));
|
||||
|
||||
ts_clear(set);
|
||||
|
||||
cmc_assert_equals(size_t, 0, ts_count(set));
|
||||
cmc_assert_equals(ptr, NULL, set->root);
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set));
|
||||
|
||||
// clear
|
||||
set->flag = CMC_FLAG_ERROR;
|
||||
ts_clear(set);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set));
|
||||
|
||||
// insert
|
||||
set->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set));
|
||||
|
||||
cmc_assert(!ts_insert(set, 1));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, ts_flag(set));
|
||||
|
||||
// remove
|
||||
cmc_assert(!ts_remove(set, 2));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, ts_flag(set));
|
||||
|
||||
cmc_assert(ts_remove(set, 1));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set));
|
||||
|
||||
cmc_assert(!ts_remove(set, 1));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ts_flag(set));
|
||||
|
||||
// max min
|
||||
set->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(!ts_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ts_flag(set));
|
||||
|
||||
set->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(!ts_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, ts_flag(set));
|
||||
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
set->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ts_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set));
|
||||
|
||||
set->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ts_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set));
|
||||
|
||||
// copy_of
|
||||
set->flag = CMC_FLAG_ERROR;
|
||||
struct treeset *set2 = ts_copy_of(set);
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set2));
|
||||
|
||||
// equals
|
||||
set->flag = CMC_FLAG_ERROR;
|
||||
set2->flag = CMC_FLAG_ERROR;
|
||||
cmc_assert(ts_equals(set, set2));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set));
|
||||
cmc_assert_equals(int32_t, CMC_FLAG_OK, ts_flag(set2));
|
||||
|
||||
ts_free(set);
|
||||
ts_free(set2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct treeset *set = ts_new_custom(ts_fval, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(ts_insert(set, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(ts_remove(set, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(ts_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(ts_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert(ts_contains(set, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
ts_customize(set, NULL, NULL);
|
||||
|
||||
ts_clear(set);
|
||||
cmc_assert(ts_insert(set, 10));
|
||||
cmc_assert(ts_remove(set, 10));
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
cmc_assert(ts_max(set, NULL));
|
||||
cmc_assert(ts_min(set, NULL));
|
||||
cmc_assert(ts_contains(set, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, set->callbacks);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
});
|
||||
|
||||
CMC_CREATE_UNIT(CMCTreeSetIter, true, {
|
||||
CMC_CREATE_TEST(PFX##_iter_start(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_start(set);
|
||||
|
||||
cmc_assert_equals(ptr, set, it.target);
|
||||
cmc_assert_equals(ptr, NULL, it.cursor);
|
||||
cmc_assert_equals(ptr, NULL, it.first);
|
||||
cmc_assert_equals(ptr, NULL, it.last);
|
||||
cmc_assert_equals(size_t, 0, it.index);
|
||||
cmc_assert_equals(bool, true, it.start);
|
||||
cmc_assert_equals(bool, true, it.end);
|
||||
|
||||
cmc_assert(ts_iter_at_start(&it));
|
||||
cmc_assert(ts_iter_at_end(&it));
|
||||
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
cmc_assert(ts_insert(set, 2));
|
||||
cmc_assert(ts_insert(set, 3));
|
||||
|
||||
it = ts_iter_start(set);
|
||||
|
||||
cmc_assert_equals(size_t, 0, it.index);
|
||||
|
||||
cmc_assert_equals(size_t, 1, it.cursor->value);
|
||||
cmc_assert_equals(size_t, 1, it.first->value);
|
||||
cmc_assert_equals(size_t, 3, it.last->value);
|
||||
cmc_assert_equals(bool, false, it.end);
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_end(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_end(set);
|
||||
|
||||
cmc_assert_equals(ptr, set, it.target);
|
||||
cmc_assert_equals(ptr, NULL, it.cursor);
|
||||
cmc_assert_equals(ptr, NULL, it.first);
|
||||
cmc_assert_equals(ptr, NULL, it.last);
|
||||
cmc_assert_equals(size_t, 0, it.index);
|
||||
cmc_assert_equals(bool, true, it.start);
|
||||
cmc_assert_equals(bool, true, it.end);
|
||||
|
||||
cmc_assert(ts_iter_at_start(&it));
|
||||
cmc_assert(ts_iter_at_end(&it));
|
||||
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
cmc_assert(ts_insert(set, 2));
|
||||
cmc_assert(ts_insert(set, 3));
|
||||
|
||||
it = ts_iter_end(set);
|
||||
|
||||
cmc_assert_equals(size_t, set->count - 1, it.index);
|
||||
|
||||
cmc_assert_equals(size_t, 3, it.cursor->value);
|
||||
cmc_assert_equals(size_t, 1, it.first->value);
|
||||
cmc_assert_equals(size_t, 3, it.last->value);
|
||||
cmc_assert_equals(bool, false, it.start);
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_at_start(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_start(set);
|
||||
|
||||
// Empty checks
|
||||
cmc_assert(ts_iter_at_start(&it));
|
||||
it = ts_iter_end(set);
|
||||
cmc_assert(ts_iter_at_start(&it));
|
||||
|
||||
// Non-empty checks
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
cmc_assert(ts_insert(set, 2));
|
||||
it = ts_iter_end(set);
|
||||
cmc_assert(!ts_iter_at_start(&it));
|
||||
it = ts_iter_start(set);
|
||||
cmc_assert(ts_iter_at_start(&it));
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_at_end(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_start(set);
|
||||
|
||||
// Empty check
|
||||
cmc_assert(ts_iter_at_end(&it));
|
||||
it = ts_iter_end(set);
|
||||
cmc_assert(ts_iter_at_end(&it));
|
||||
|
||||
// Non-empty checks
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
cmc_assert(ts_insert(set, 2));
|
||||
it = ts_iter_end(set);
|
||||
cmc_assert(ts_iter_at_end(&it));
|
||||
it = ts_iter_start(set);
|
||||
cmc_assert(!ts_iter_at_end(&it));
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_to_start(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_start(set);
|
||||
|
||||
cmc_assert(!ts_iter_to_start(&it));
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
ts_insert(set, i);
|
||||
|
||||
cmc_assert_equals(size_t, 100, set->count);
|
||||
|
||||
it = ts_iter_end(set);
|
||||
|
||||
cmc_assert(!ts_iter_at_start(&it));
|
||||
cmc_assert(ts_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 100, ts_iter_value(&it));
|
||||
|
||||
cmc_assert(ts_iter_to_start(&it));
|
||||
|
||||
cmc_assert(ts_iter_at_start(&it));
|
||||
cmc_assert(!ts_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 1, ts_iter_value(&it));
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_to_end(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_end(set);
|
||||
|
||||
cmc_assert(!ts_iter_to_end(&it));
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
ts_insert(set, i);
|
||||
|
||||
it = ts_iter_start(set);
|
||||
|
||||
cmc_assert(ts_iter_at_start(&it));
|
||||
cmc_assert(!ts_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 1, ts_iter_value(&it));
|
||||
|
||||
cmc_assert(ts_iter_to_end(&it));
|
||||
|
||||
cmc_assert(!ts_iter_at_start(&it));
|
||||
cmc_assert(ts_iter_at_end(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 100, ts_iter_value(&it));
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_next(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_start(set);
|
||||
|
||||
cmc_assert(!ts_iter_next(&it));
|
||||
|
||||
for (size_t i = 1; i <= 1000; i++)
|
||||
ts_insert(set, i);
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = ts_iter_start(set); !ts_iter_at_end(&it); ts_iter_next(&it))
|
||||
{
|
||||
sum += ts_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
|
||||
ts_iter_to_start(&it);
|
||||
do
|
||||
{
|
||||
sum += ts_iter_value(&it);
|
||||
} while (ts_iter_next(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_prev(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_end(set);
|
||||
|
||||
cmc_assert(!ts_iter_prev(&it));
|
||||
|
||||
for (size_t i = 1; i <= 1000; i++)
|
||||
ts_insert(set, i);
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = ts_iter_end(set); !ts_iter_at_start(&it); ts_iter_prev(&it))
|
||||
{
|
||||
sum += ts_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
|
||||
ts_iter_to_end(&it);
|
||||
do
|
||||
{
|
||||
sum += ts_iter_value(&it);
|
||||
} while (ts_iter_prev(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_advance(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_start(set);
|
||||
|
||||
cmc_assert(!ts_iter_advance(&it, 1));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
ts_insert(set, i);
|
||||
|
||||
it = ts_iter_start(set);
|
||||
|
||||
cmc_assert(!ts_iter_advance(&it, 0));
|
||||
cmc_assert(!ts_iter_advance(&it, set->count));
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = ts_iter_start(set);;)
|
||||
{
|
||||
sum += ts_iter_value(&it);
|
||||
|
||||
if (!ts_iter_advance(&it, 2))
|
||||
break;
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 250500, sum);
|
||||
|
||||
ts_iter_to_start(&it);
|
||||
cmc_assert(ts_iter_advance(&it, set->count - 1));
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_rewind(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_end(set);
|
||||
|
||||
cmc_assert(!ts_iter_rewind(&it, 1));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
ts_insert(set, i);
|
||||
|
||||
it = ts_iter_end(set);
|
||||
|
||||
cmc_assert(!ts_iter_rewind(&it, 0));
|
||||
cmc_assert(!ts_iter_rewind(&it, set->count));
|
||||
|
||||
size_t sum = 0;
|
||||
for (it = ts_iter_end(set);;)
|
||||
{
|
||||
sum += ts_iter_value(&it);
|
||||
|
||||
if (!ts_iter_rewind(&it, 2))
|
||||
break;
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 250500, sum);
|
||||
|
||||
ts_iter_to_end(&it);
|
||||
cmc_assert(ts_iter_rewind(&it, set->count - 1));
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_go_to(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_end(set);
|
||||
cmc_assert(!ts_iter_go_to(&it, 0));
|
||||
|
||||
it = ts_iter_start(set);
|
||||
cmc_assert(!ts_iter_go_to(&it, 0));
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
ts_insert(set, i);
|
||||
|
||||
it = ts_iter_start(set);
|
||||
|
||||
size_t sum = 0;
|
||||
for (size_t i = 0; i < 1001; i++)
|
||||
{
|
||||
ts_iter_go_to(&it, i);
|
||||
|
||||
sum += ts_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
for (size_t i = 1001; i > 0; i--)
|
||||
{
|
||||
cmc_assert(ts_iter_go_to(&it, i - 1));
|
||||
|
||||
sum += ts_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 500500, sum);
|
||||
|
||||
sum = 0;
|
||||
for (size_t i = 0; i < 1001; i += 100)
|
||||
{
|
||||
cmc_assert(ts_iter_go_to(&it, i));
|
||||
cmc_assert_equals(size_t, i, ts_iter_index(&it));
|
||||
|
||||
sum += ts_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5500, sum);
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_value(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
struct treeset_iter it = ts_iter_end(set);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, ts_iter_value(&it));
|
||||
|
||||
cmc_assert(ts_insert(set, 10));
|
||||
|
||||
it = ts_iter_start(set);
|
||||
|
||||
cmc_assert_equals(size_t, 10, ts_iter_value(&it));
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(PFX##_iter_index(), {
|
||||
struct treeset *set = ts_new(ts_fval);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 0; i <= 1000; i++)
|
||||
ts_insert(set, i);
|
||||
|
||||
struct treeset_iter it = ts_iter_start(set);
|
||||
|
||||
for (size_t i = 0; i < 1001; i++)
|
||||
{
|
||||
cmc_assert_equals(size_t, i, ts_iter_index(&it));
|
||||
ts_iter_next(&it);
|
||||
}
|
||||
|
||||
it = ts_iter_end(set);
|
||||
for (size_t i = 1001; i > 0; i--)
|
||||
{
|
||||
cmc_assert_equals(size_t, i - 1, ts_iter_index(&it));
|
||||
ts_iter_prev(&it);
|
||||
}
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
});
|
||||
|
||||
#ifdef CMC_TEST_MAIN
|
||||
int main(void)
|
||||
{
|
||||
int result = CMCTreeSet() + CMCTreeSetIter();
|
||||
|
||||
printf(" +---------------------------------------------------------------+");
|
||||
printf("\n");
|
||||
printf(" | CMCTreeSet Suit : %-46s |\n", result == 0 ? "PASSED" : "FAILED");
|
||||
printf(" +---------------------------------------------------------------+");
|
||||
printf("\n\n\n");
|
||||
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* CMC_TESTS_UNT_TREESET_H */
|
||||
Reference in new issue
Block a user