475 lines
18 KiB
C
475 lines
18 KiB
C
#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 */
|