admin/C-Macro-Collections
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reworked assert.h and test.h and added the cmc prefix to the logging utility

Browse Source 
Integrated the assert utility with the test utility. Now any assertion that fails inside the unit test will trigger failure and is no longer needed to manually pass or fail a test.
Also reworked makefiles.
This commit is contained in:
Leonardo committed 2019-09-06 12:17:11 -03:00
1 parent abdbfa2018
commit 1928fdd6d5
20 files changed
+368 -414
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

.travis.yml
+2 -2
View File
@@ -13,8 +13,8 @@ script:
- sudo ln -s /usr/bin/gcc-6 /usr/local/bin/gcc - sudo ln -s /usr/bin/gcc-6 /usr/local/bin/gcc
- export CC=gcc-7 - export CC=gcc-7
- cd ./tests - cd ./tests
- make --always-make - make
- cd ./main - cd ./main
- make --always-make - make
after_success: after_success:
- bash <(curl -s https://codecov.io/bash) - bash <(curl -s https://codecov.io/bash)
src/cmc/deque.h
+37
View File
@@ -139,6 +139,9 @@
FMOD void PFX##_iter_to_end(SNAME##_iter *iter); \ FMOD void PFX##_iter_to_end(SNAME##_iter *iter); \
FMOD bool PFX##_iter_next(SNAME##_iter *iter); \ FMOD bool PFX##_iter_next(SNAME##_iter *iter); \
FMOD bool PFX##_iter_prev(SNAME##_iter *iter); \ FMOD bool PFX##_iter_prev(SNAME##_iter *iter); \
FMOD bool PFX##_iter_advance(SNAME##_iter *iter, size_t steps); \
FMOD bool PFX##_iter_rewind(SNAME##_iter *iter, size_t steps); \
FMOD bool PFX##_iter_go_to(SNAME##_iter *iter, size_t index); \
/* Iterator Access */ \ /* Iterator Access */ \
FMOD V PFX##_iter_value(SNAME##_iter *iter); \ FMOD V PFX##_iter_value(SNAME##_iter *iter); \
FMOD V *PFX##_iter_rvalue(SNAME##_iter *iter); \ FMOD V *PFX##_iter_rvalue(SNAME##_iter *iter); \
@@ -514,6 +517,40 @@
return true; \ return true; \
} \ } \
\ \
FMOD bool PFX##_iter_advance(SNAME##_iter *iter, size_t steps) \
{ \
if (iter->end) \
return false; \
\
if (iter->index + steps > PFX##_count(iter->target)) \
return false; \
\
/* TODO */ \
\
return true; \
} \
\
FMOD bool PFX##_iter_rewind(SNAME##_iter *iter, size_t steps) \
{ \
if (iter->start) \
return false; \
\
if (iter->index < steps) \
return false; \
\
/* TODO */ \
\
return true; \
} \
\
FMOD bool PFX##_iter_go_to(SNAME##_iter *iter, size_t index) \
{ \
\
/* TODO */ \
\
return true; \
} \
\
FMOD V PFX##_iter_value(SNAME##_iter *iter) \ FMOD V PFX##_iter_value(SNAME##_iter *iter) \
{ \ { \
if (PFX##_empty(iter->target)) \ if (PFX##_empty(iter->target)) \
src/utl/assert.h
+230 -2
View File
@@ -46,6 +46,7 @@
#define CMC_ASSERT_H #define CMC_ASSERT_H
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
@@ -53,6 +54,15 @@
#define CMC_ASSERT_GLUE_(dtype, assertion) cmc_assert_##assertion##_##dtype #define CMC_ASSERT_GLUE_(dtype, assertion) cmc_assert_##assertion##_##dtype
#define CMC_ASSERT_GLUE(dtype, assertion) CMC_ASSERT_GLUE_(dtype, assertion) #define CMC_ASSERT_GLUE(dtype, assertion) CMC_ASSERT_GLUE_(dtype, assertion)
/**
* This is a global variable that can be used to test if all assertions passed.
* If a single assertion fails, this variable will be set to false.
*
* This variable is also used in test.h utility to automatically pass or fail a
* unit test. Once the unit test finishes, this variable is set back to true.
*/
static bool cmc_assert_state = true;
/** /**
* expression : An expression that is expected to be evaluated to true. * expression : An expression that is expected to be evaluated to true.
*/ */
@@ -62,6 +72,8 @@
const char *str = #expression; \ const char *str = #expression; \
if (!(expression)) \ if (!(expression)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }\n", \ "Assertion Failed at %s:%s:%u for { %s }\n", \
__FILE__, __func__, __LINE__, str); \ __FILE__, __func__, __LINE__, str); \
@@ -155,6 +167,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRId8 " Actual: %" PRId8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRId8 " Actual: %" PRId8 "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -171,6 +185,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRId16 " Actual: %" PRId16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRId16 " Actual: %" PRId16 "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -187,6 +203,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRId32 " Actual: %" PRId32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRId32 " Actual: %" PRId32 "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -203,6 +221,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRId64 " Actual: %" PRId64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRId64 " Actual: %" PRId64 "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -219,6 +239,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIu8 " Actual: %" PRIu8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIu8 " Actual: %" PRIu8 "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -235,6 +257,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIu16 " Actual: %" PRIu16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIu16 " Actual: %" PRIu16 "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -251,6 +275,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIu32 " Actual: %" PRIu32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIu32 " Actual: %" PRIu32 "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -267,6 +293,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIu64 " Actual: %" PRIu64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIu64 " Actual: %" PRIu64 "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -283,6 +311,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIdMAX " Actual: %" PRIdMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIdMAX " Actual: %" PRIdMAX "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -299,6 +329,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -315,6 +347,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -331,6 +365,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %f Actual: %f\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %f Actual: %f\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -347,6 +383,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %lf Actual: %lf\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %lf Actual: %lf\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -363,6 +401,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %p Actual: %p\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %p Actual: %p\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -370,7 +410,7 @@
\ \
} while (0) } while (0)
#define cmc_assert_equals__Bool(expected, actual) \ #define cmc_assert_equals__Bool(expected, actual) \
do \ do \
{ \ { \
const char *str = #actual; \ const char *str = #actual; \
@@ -379,6 +419,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected: %d Actual: %d\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected: %d Actual: %d\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -395,6 +437,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRId8 " Actual: %" PRId8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRId8 " Actual: %" PRId8 "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -411,6 +455,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRId16 " Actual: %" PRId16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRId16 " Actual: %" PRId16 "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -427,6 +473,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRId32 " Actual: %" PRId32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRId32 " Actual: %" PRId32 "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -443,6 +491,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRId64 " Actual: %" PRId64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRId64 " Actual: %" PRId64 "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -459,6 +509,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIu8 " Actual: %" PRIu8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIu8 " Actual: %" PRIu8 "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -475,6 +527,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIu16 " Actual: %" PRIu16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIu16 " Actual: %" PRIu16 "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -491,6 +545,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIu32 " Actual: %" PRIu32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIu32 " Actual: %" PRIu32 "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -507,6 +563,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIu64 " Actual: %" PRIu64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIu64 " Actual: %" PRIu64 "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -523,6 +581,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIdMAX " Actual: %" PRIdMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIdMAX " Actual: %" PRIdMAX "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -539,6 +599,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -555,6 +617,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -571,6 +635,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %f Actual: %f\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %f Actual: %f\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -587,6 +653,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %lf Actual: %lf\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %lf Actual: %lf\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -603,6 +671,8 @@
\ \
if ((not_expected_) == (actual_)) \ if ((not_expected_) == (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %p Actual: %p\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %p Actual: %p\n", \
__FILE__, __func__, __LINE__, str, not_expected_, actual_); \ __FILE__, __func__, __LINE__, str, not_expected_, actual_); \
@@ -610,7 +680,7 @@
\ \
} while (0) } while (0)
#define cmc_assert_not_equals__Bool(expected, actual) \ #define cmc_assert_not_equals__Bool(expected, actual) \
do \ do \
{ \ { \
const char *str = #actual; \ const char *str = #actual; \
@@ -619,6 +689,8 @@
\ \
if ((expected_) != (actual_)) \ if ((expected_) != (actual_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected: %d Actual: %d\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected: %d Actual: %d\n", \
__FILE__, __func__, __LINE__, str, expected_, actual_); \ __FILE__, __func__, __LINE__, str, expected_, actual_); \
@@ -635,6 +707,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRId8 " Actual: %" PRId8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRId8 " Actual: %" PRId8 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -651,6 +725,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRId16 " Actual: %" PRId16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRId16 " Actual: %" PRId16 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -667,6 +743,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRId32 " Actual: %" PRId32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRId32 " Actual: %" PRId32 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -683,6 +761,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRId64 " Actual: %" PRId64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRId64 " Actual: %" PRId64 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -699,6 +779,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIu8 " Actual: %" PRIu8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIu8 " Actual: %" PRIu8 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -715,6 +797,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIu16 " Actual: %" PRIu16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIu16 " Actual: %" PRIu16 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -731,6 +815,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIu32 " Actual: %" PRIu32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIu32 " Actual: %" PRIu32 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -747,6 +833,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIu64 " Actual: %" PRIu64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIu64 " Actual: %" PRIu64 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -763,6 +851,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIdMAX " Actual: %" PRIdMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIdMAX " Actual: %" PRIdMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -779,6 +869,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -795,6 +887,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -811,6 +905,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %f Actual: %f\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %f Actual: %f\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -827,6 +923,8 @@
\ \
if ((actual_) <= (boundary_)) \ if ((actual_) <= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %lf Actual: %lf\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (excluded): %lf Actual: %lf\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -843,6 +941,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRId8 " Actual: %" PRId8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRId8 " Actual: %" PRId8 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -859,6 +959,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRId16 " Actual: %" PRId16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRId16 " Actual: %" PRId16 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -875,6 +977,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRId32 " Actual: %" PRId32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRId32 " Actual: %" PRId32 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -891,6 +995,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRId64 " Actual: %" PRId64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRId64 " Actual: %" PRId64 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -907,6 +1013,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIu8 " Actual: %" PRIu8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIu8 " Actual: %" PRIu8 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -923,6 +1031,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIu16 " Actual: %" PRIu16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIu16 " Actual: %" PRIu16 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -939,6 +1049,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIu32 " Actual: %" PRIu32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIu32 " Actual: %" PRIu32 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -955,6 +1067,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIu64 " Actual: %" PRIu64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIu64 " Actual: %" PRIu64 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -971,6 +1085,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIdMAX " Actual: %" PRIdMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIdMAX " Actual: %" PRIdMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -987,6 +1103,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1003,6 +1121,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1019,6 +1139,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %f Actual: %f\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %f Actual: %f\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1035,6 +1157,8 @@
\ \
if ((actual_) < (boundary_)) \ if ((actual_) < (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %lf Actual: %lf\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Greater (included): %lf Actual: %lf\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1051,6 +1175,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRId8 " Actual: %" PRId8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRId8 " Actual: %" PRId8 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1067,6 +1193,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRId16 " Actual: %" PRId16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRId16 " Actual: %" PRId16 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1083,6 +1211,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRId32 " Actual: %" PRId32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRId32 " Actual: %" PRId32 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1099,6 +1229,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRId64 " Actual: %" PRId64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRId64 " Actual: %" PRId64 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1115,6 +1247,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIu8 " Actual: %" PRIu8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIu8 " Actual: %" PRIu8 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1131,6 +1265,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIu16 " Actual: %" PRIu16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIu16 " Actual: %" PRIu16 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1147,6 +1283,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIu32 " Actual: %" PRIu32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIu32 " Actual: %" PRIu32 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1163,6 +1301,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIu64 " Actual: %" PRIu64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIu64 " Actual: %" PRIu64 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1179,6 +1319,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIdMAX " Actual: %" PRIdMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIdMAX " Actual: %" PRIdMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1195,6 +1337,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1211,6 +1355,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1227,6 +1373,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %f Actual: %f\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %f Actual: %f\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1243,6 +1391,8 @@
\ \
if ((actual_) >= (boundary_)) \ if ((actual_) >= (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %lf Actual: %lf\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (excluded): %lf Actual: %lf\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1259,6 +1409,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRId8 " Actual: %" PRId8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRId8 " Actual: %" PRId8 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1275,6 +1427,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRId16 " Actual: %" PRId16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRId16 " Actual: %" PRId16 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1291,6 +1445,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRId32 " Actual: %" PRId32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRId32 " Actual: %" PRId32 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1307,6 +1463,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRId64 " Actual: %" PRId64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRId64 " Actual: %" PRId64 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1323,6 +1481,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIu8 " Actual: %" PRIu8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIu8 " Actual: %" PRIu8 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1339,6 +1499,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIu16 " Actual: %" PRIu16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIu16 " Actual: %" PRIu16 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1355,6 +1517,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIu32 " Actual: %" PRIu32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIu32 " Actual: %" PRIu32 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1371,6 +1535,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIu64 " Actual: %" PRIu64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIu64 " Actual: %" PRIu64 "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1387,6 +1553,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIdMAX " Actual: %" PRIdMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIdMAX " Actual: %" PRIdMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1403,6 +1571,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1419,6 +1589,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIuMAX " Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %" PRIuMAX " Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1435,6 +1607,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %f Actual: %f\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %f Actual: %f\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1451,6 +1625,8 @@
\ \
if ((actual_) > (boundary_)) \ if ((actual_) > (boundary_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %lf Actual: %lf\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Lesser (included): %lf Actual: %lf\n", \
__FILE__, __func__, __LINE__, str, boundary_, actual_); \ __FILE__, __func__, __LINE__, str, boundary_, actual_); \
@@ -1468,6 +1644,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRId8 ", %" PRId8 "] Actual: %" PRId8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRId8 ", %" PRId8 "] Actual: %" PRId8 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1485,6 +1663,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRId16 ", %" PRId16 "] Actual: %" PRId16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRId16 ", %" PRId16 "] Actual: %" PRId16 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1502,6 +1682,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRId32 ", %" PRId32 "] Actual: %" PRId32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRId32 ", %" PRId32 "] Actual: %" PRId32 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1519,6 +1701,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRId32 ", %" PRId32 "] Actual: %" PRId32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRId32 ", %" PRId32 "] Actual: %" PRId32 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1536,6 +1720,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIu8 ", %" PRIu8 "] Actual: %" PRIu8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIu8 ", %" PRIu8 "] Actual: %" PRIu8 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1553,6 +1739,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIu16 ", %" PRIu16 "] Actual: %" PRIu16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIu16 ", %" PRIu16 "] Actual: %" PRIu16 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1570,6 +1758,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIu32 ", %" PRIu32 "] Actual: %" PRIu32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIu32 ", %" PRIu32 "] Actual: %" PRIu32 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1587,6 +1777,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIu64 ", %" PRIu64 "] Actual: %" PRIu64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIu64 ", %" PRIu64 "] Actual: %" PRIu64 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1604,6 +1796,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIdMAX ", %" PRIdMAX "] Actual: %" PRIdMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIdMAX ", %" PRIdMAX "] Actual: %" PRIdMAX "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1621,6 +1815,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIuMAX ", %" PRIuMAX "] Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIuMAX ", %" PRIuMAX "] Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1638,6 +1834,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIuMAX ", %" PRIuMAX "] Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%" PRIuMAX ", %" PRIuMAX "] Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1655,6 +1853,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%f, %f] Actual: %f\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%f, %f] Actual: %f\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1672,6 +1872,8 @@
\ \
if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \ if ((actual_) < (lower_bound_) || (actual_) > (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%lf, %lf] Actual: %lf\n", \ "Assertion Failed at %s:%s:%u for { %s }: Expected Range: [%lf, %lf] Actual: %lf\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1689,6 +1891,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRId8 ", %" PRId8 "] Actual: %" PRId8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRId8 ", %" PRId8 "] Actual: %" PRId8 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1706,6 +1910,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRId16 ", %" PRId16 "] Actual: %" PRId16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRId16 ", %" PRId16 "] Actual: %" PRId16 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1723,6 +1929,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRId32 ", %" PRId32 "] Actual: %" PRId32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRId32 ", %" PRId32 "] Actual: %" PRId32 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1740,6 +1948,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRId32 ", %" PRId32 "] Actual: %" PRId32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRId32 ", %" PRId32 "] Actual: %" PRId32 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1757,6 +1967,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIu8 ", %" PRIu8 "] Actual: %" PRIu8 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIu8 ", %" PRIu8 "] Actual: %" PRIu8 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1774,6 +1986,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIu16 ", %" PRIu16 "] Actual: %" PRIu16 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIu16 ", %" PRIu16 "] Actual: %" PRIu16 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1791,6 +2005,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIu32 ", %" PRIu32 "] Actual: %" PRIu32 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIu32 ", %" PRIu32 "] Actual: %" PRIu32 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1808,6 +2024,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIu64 ", %" PRIu64 "] Actual: %" PRIu64 "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIu64 ", %" PRIu64 "] Actual: %" PRIu64 "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1825,6 +2043,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIdMAX ", %" PRIdMAX "] Actual: %" PRIdMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIdMAX ", %" PRIdMAX "] Actual: %" PRIdMAX "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1842,6 +2062,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIuMAX ", %" PRIuMAX "] Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIuMAX ", %" PRIuMAX "] Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1859,6 +2081,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIuMAX ", %" PRIuMAX "] Actual: %" PRIuMAX "\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%" PRIuMAX ", %" PRIuMAX "] Actual: %" PRIuMAX "\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1876,6 +2100,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%f, %f] Actual: %f\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%f, %f] Actual: %f\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
@@ -1893,6 +2119,8 @@
\ \
if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \ if ((actual_) >= (lower_bound_) && (actual_) <= (upper_bound_)) \
{ \ { \
cmc_assert_state = false; \
\
fprintf(stderr, \ fprintf(stderr, \
"Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%lf, %lf] Actual: %lf\n", \ "Assertion Failed at %s:%s:%u for { %s }: Not Expected Range: [%lf, %lf] Actual: %lf\n", \
__FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \ __FILE__, __func__, __LINE__, str, lower_bound_, upper_bound_, actual_); \
src/utl/log.h
+12 -12
View File
@@ -85,21 +85,21 @@ static struct
typedef enum cmc_log_type_e typedef enum cmc_log_type_e
{ {
LOG_TRACE = 1, CMC_LOG_TRACE = 1,
LOG_DEBUG = 2, CMC_LOG_DEBUG = 2,
LOG_INFO = 3, CMC_LOG_INFO = 3,
LOG_WARN = 4, CMC_LOG_WARN = 4,
LOG_ERROR = 5, CMC_LOG_ERROR = 5,
LOG_FATAL = 6 CMC_LOG_FATAL = 6
} cmc_log_type; } cmc_log_type;
#define log_trace(fmt, ...) cmc_log(LOG_TRACE, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__) #define cmc_log_trace(fmt, ...) cmc_log(CMC_LOG_TRACE, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__)
#define log_debug(fmt, ...) cmc_log(LOG_DEBUG, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__) #define cmc_log_debug(fmt, ...) cmc_log(CMC_LOG_DEBUG, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__)
#define log_info(fmt, ...) cmc_log(LOG_INFO, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__) #define cmc_log_info(fmt, ...) cmc_log(CMC_LOG_INFO, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__)
#define log_warn(fmt, ...) cmc_log(LOG_WARN, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__) #define cmc_log_warn(fmt, ...) cmc_log(CMC_LOG_WARN, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__)
#define log_error(fmt, ...) cmc_log(LOG_ERROR, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__) #define cmc_log_error(fmt, ...) cmc_log(CMC_LOG_ERROR, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__)
#define log_fatal(fmt, ...) cmc_log(LOG_FATAL, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__) #define cmc_log_fatal(fmt, ...) cmc_log(CMC_LOG_FATAL, __FILE__, __func__, __LINE__, fmt, __VA_ARGS__)
static void cmc_log(cmc_log_type log, const char *filename, const char *funcname, int line, const char *fmt, ...) static void cmc_log(cmc_log_type log, const char *filename, const char *funcname, int line, const char *fmt, ...)
{ {
src/utl/test.h
+30 -36
View File
@@ -11,6 +11,10 @@
/** /**
* Simple Unit Test Utility * Simple Unit Test Utility
* *
* Required imports:
* - assert.h (to integrate with the cmc_assert_state variable)
* - timer.h (to calculate the execution time for the unit test)
*
* CMC_CREATE_UNIT * CMC_CREATE_UNIT
* Create a UnitTest * Create a UnitTest
* Parameters: * Parameters:
@@ -42,6 +46,7 @@
#ifndef CMC_TEST_H #ifndef CMC_TEST_H
#define CMC_TEST_H #define CMC_TEST_H
#include "assert.h"
#include "timer.h" #include "timer.h"
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
@@ -92,7 +97,7 @@ static void cmc_test_log(const char *unit_name, const char *current_test, bool a
} }
#define CMC_CREATE_UNIT(UNAME, VERBOSE, BODY) \ #define CMC_CREATE_UNIT(UNAME, VERBOSE, BODY) \
void UNAME(void) \ uintmax_t UNAME(void) \
{ \ { \
const char *unit_name = #UNAME; \ const char *unit_name = #UNAME; \
const char *current_test = NULL; \ const char *current_test = NULL; \
@@ -104,11 +109,13 @@ static void cmc_test_log(const char *unit_name, const char *current_test, bool a
\ \
/* Tests */ \ /* Tests */ \
timer_start(timer); \ timer_start(timer); \
\
BODY; \ BODY; \
\
timer_stop(timer); \ timer_stop(timer); \
timer_calc(timer); \ timer_calc(timer); \
\ \
unittest_abort: \ unittest_abort: \
if (tinfo.aborted) \ if (tinfo.aborted) \
{ \ { \
cmc_test_log(unit_name, current_test, true, false); \ cmc_test_log(unit_name, current_test, true, false); \
@@ -122,51 +129,38 @@ static void cmc_test_log(const char *unit_name, const char *current_test, bool a
printf("| |\n"); \ printf("| |\n"); \
printf("| Total Unit Test Runtime : %9.0f milliseconds |\n", timer.result); \ printf("| Total Unit Test Runtime : %9.0f milliseconds |\n", timer.result); \
printf("+--------------------------------------------------+\n"); \ printf("+--------------------------------------------------+\n"); \
\
return tinfo.failed; \
} }
#define CMC_CREATE_TEST(TNAME, BODY) \ #define CMC_CREATE_TEST(TNAME, BODY) \
do \
{ \
current_test = #TNAME; \
\
tinfo.total += 1; \
\
BODY; \
\
} while (0)
#define CMC_TEST_PASS() \
do \
{ \
tinfo.passed += 1; \
if (tinfo.verbose) \
cmc_test_log(unit_name, current_test, false, true); \
\
} while (0)
#define CMC_TEST_FAIL() \
do \ do \
{ \ { \
tinfo.failed += 1; \ current_test = #TNAME; \
if (tinfo.verbose) \ \
tinfo.total += 1; \
\
/* Provided by assert.h */ \
cmc_assert_state = true; \
\
BODY; \
\
if (!cmc_assert_state) \
{ \
tinfo.failed += 1; \
cmc_test_log(unit_name, current_test, false, false); \ cmc_test_log(unit_name, current_test, false, false); \
} \
else \
{ \
tinfo.passed += 1; \
cmc_test_log(unit_name, current_test, false, true); \
} \
\ \
} while (0)
#define CMC_TEST_PASS_ELSE_FAIL(EXPRESSION) \
do \
{ \
if (EXPRESSION) \
CMC_TEST_PASS(); \
else \
CMC_TEST_FAIL(); \
\
} while (0) } while (0)
#define CMC_TEST_ABORT() \ #define CMC_TEST_ABORT() \
do \ do \
{ \ { \
\
tinfo.aborted = true; \ tinfo.aborted = true; \
tinfo.total -= 1; \ tinfo.total -= 1; \
goto unittest_abort; \ goto unittest_abort; \
tests/Makefile
+3 -1
View File
@@ -2,7 +2,7 @@ CC = gcc
CFLAGS = -std=c11 -Wall -Wextra CFLAGS = -std=c11 -Wall -Wextra
CFLAGS += -Wno-unused-function -Wno-unused-parameter -Wno-unused-variable -Wno-unused-label CFLAGS += -Wno-unused-function -Wno-unused-parameter -Wno-unused-variable -Wno-unused-label
main: main: FORCE
$(CC) foreach.c -o foreach.exe $(CFLAGS) $(CC) foreach.c -o foreach.exe $(CFLAGS)
./foreach.exe ./foreach.exe
$(CC) iterators.c -o iterators.exe $(CFLAGS) $(CC) iterators.c -o iterators.exe $(CFLAGS)
@@ -21,3 +21,5 @@ dev: main
windev: main windev: main
del *.exe .\\sep\\*.o .\\sep\\*.exe del *.exe .\\sep\\*.o .\\sep\\*.exe
FORCE:
tests/main/Makefile
+9 -1
View File
@@ -4,7 +4,7 @@ CFLAGS += -Wno-unused-function -Wno-unused-parameter -Wno-unused-variable -Wno-u
CVFLAGS = --coverage -O0 CVFLAGS = --coverage -O0
INCLUDE = ../../src/ INCLUDE = ../../src/
main: main: FORCE
$(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE) $(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE)
./main ./main
gcov ./main.c gcov ./main.c
@@ -14,3 +14,11 @@ dev:
./main ./main
gcov ./main.c -n gcov ./main.c -n
rm *.gcda *.gcno *.exe rm *.gcda *.gcno *.exe
windev:
$(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE)
./main
gcov ./main.c -n
del *.gcda *.gcno *.exe
FORCE:
tests/main/main.c
+15 -13
View File
@@ -14,20 +14,22 @@
int main(void) int main(void)
{ {
deque_test(); uintmax_t failed = 0;
hashmap_test();
hashset_test(); failed += deque_test();
heap_test(); failed += hashmap_test();
linkedlist_test(); failed += hashset_test();
list_test(); failed += heap_test();
queue_test(); failed += linkedlist_test();
stack_test(); failed += list_test();
treemap_test(); failed += queue_test();
treeset_test(); failed += stack_test();
failed += treemap_test();
failed += treeset_test();
/* ext */ /* ext */
multimap_test(); failed += multimap_test();
multiset_test(); failed += multiset_test();
return 0; return failed;
} }
tests/main/unt/deque.c
+1 -14
View File
@@ -7,14 +7,9 @@ CMC_CREATE_UNIT(deque_test, true, {
deque *d = d_new(1000000); deque *d = d_new(1000000);
cmc_assert_not_equals(ptr, NULL, d); cmc_assert_not_equals(ptr, NULL, d);
cmc_assert_not_equals(ptr, NULL, d->buffer);
bool passed = d->capacity == 1000000 && d->count == 0 && d->buffer;
cmc_assert_equals(size_t, 1000000, d->capacity); cmc_assert_equals(size_t, 1000000, d->capacity);
cmc_assert_equals(size_t, 0, d_count(d)); cmc_assert_equals(size_t, 0, d_count(d));
cmc_assert_not_equals(ptr, NULL, d->buffer);
CMC_TEST_PASS_ELSE_FAIL(passed);
d_free(d); d_free(d);
}); });
@@ -23,16 +18,12 @@ CMC_CREATE_UNIT(deque_test, true, {
deque *d = d_new(0); deque *d = d_new(0);
cmc_assert_equals(ptr, NULL, d); cmc_assert_equals(ptr, NULL, d);
CMC_TEST_PASS_ELSE_FAIL(d == NULL);
}); });
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
deque *d = d_new(UINT64_MAX); deque *d = d_new(UINT64_MAX);
cmc_assert_equals(ptr, NULL, d); cmc_assert_equals(ptr, NULL, d);
CMC_TEST_PASS_ELSE_FAIL(d == NULL);
}); });
CMC_CREATE_TEST(clear[count capacity], { CMC_CREATE_TEST(clear[count capacity], {
@@ -50,8 +41,6 @@ CMC_CREATE_UNIT(deque_test, true, {
cmc_assert_equals(size_t, 0, d_count(d)); cmc_assert_equals(size_t, 0, d_count(d));
cmc_assert_equals(size_t, 100, d_capacity(d)); cmc_assert_equals(size_t, 100, d_capacity(d));
CMC_TEST_PASS_ELSE_FAIL(d_count(d) == 0 && d_capacity(d) == 100);
d_free(d); d_free(d);
}); });
@@ -66,8 +55,6 @@ CMC_CREATE_UNIT(deque_test, true, {
cmc_assert_equals(size_t, 50, d_count(d)); cmc_assert_equals(size_t, 50, d_count(d));
cmc_assert_lesser_equals(size_t, d_capacity(d), d_count(d)); cmc_assert_lesser_equals(size_t, d_capacity(d), d_count(d));
CMC_TEST_PASS_ELSE_FAIL(d_count(d) == 50 && d_count(d) <= d_capacity(d));
d_free(d); d_free(d);
}); });
tests/main/unt/hashmap.c
+2 -10
View File
@@ -8,13 +8,11 @@ CMC_CREATE_UNIT(hashmap_test, true, {
CMC_CREATE_TEST(new, { CMC_CREATE_TEST(new, {
hashmap *map = hm_new(943722, 0.6, cmp, hash); hashmap *map = hm_new(943722, 0.6, cmp, hash);
bool passed = (map->capacity >= (943722 / 0.6)) && map->count == 0 && map->buffer;
cmc_assert_not_equals(ptr, NULL, map); cmc_assert_not_equals(ptr, NULL, map);
cmc_assert_not_equals(ptr, NULL, map->buffer);
cmc_assert_equals(size_t, 0, hm_count(map));
cmc_assert_greater_equals(size_t, (943722 / 0.6), hm_capacity(map)); cmc_assert_greater_equals(size_t, (943722 / 0.6), hm_capacity(map));
CMC_TEST_PASS_ELSE_FAIL(passed);
hm_free(map); hm_free(map);
}); });
@@ -22,16 +20,12 @@ CMC_CREATE_UNIT(hashmap_test, true, {
hashmap *map = hm_new(0, 0.6, cmp, hash); hashmap *map = hm_new(0, 0.6, cmp, hash);
cmc_assert_equals(ptr, NULL, map); cmc_assert_equals(ptr, NULL, map);
CMC_TEST_PASS_ELSE_FAIL(map == NULL);
}); });
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
hashmap *map = hm_new(UINT64_MAX, 0.6, cmp, hash); hashmap *map = hm_new(UINT64_MAX, 0.6, cmp, hash);
cmc_assert_equals(ptr, NULL, map); cmc_assert_equals(ptr, NULL, map);
CMC_TEST_PASS_ELSE_FAIL(map == NULL);
}); });
CMC_CREATE_TEST(clear[count capacity], { CMC_CREATE_TEST(clear[count capacity], {
@@ -48,8 +42,6 @@ CMC_CREATE_UNIT(hashmap_test, true, {
cmc_assert_equals(size_t, 0, hm_count(map)); cmc_assert_equals(size_t, 0, hm_count(map));
CMC_TEST_PASS_ELSE_FAIL(hm_count(map) == 0);
hm_free(map); hm_free(map);
}); });
tests/main/unt/hashset.c
+3 -11
View File
@@ -8,12 +8,10 @@ CMC_CREATE_UNIT(hashset_test, true, {
CMC_CREATE_TEST(new, { CMC_CREATE_TEST(new, {
hashset *set = hs_new(943722, 0.6, cmp, hash); hashset *set = hs_new(943722, 0.6, cmp, hash);
bool passed = (set->capacity >= (943722 / 0.6)) && set->count == 0 && set->buffer;
cmc_assert_not_equals(ptr, NULL, set); cmc_assert_not_equals(ptr, NULL, set);
cmc_assert(hs_capacity(set) > (943722 / 0.6)); cmc_assert_not_equals(ptr, NULL, set->buffer);
cmc_assert_equals(size_t, 0, hs_count(set));
CMC_TEST_PASS_ELSE_FAIL(passed); cmc_assert_greater_equals(size_t, (943722 / 0.6), hs_capacity(set));
hs_free(set); hs_free(set);
}); });
@@ -22,16 +20,12 @@ CMC_CREATE_UNIT(hashset_test, true, {
hashset *set = hs_new(0, 0.6, cmp, hash); hashset *set = hs_new(0, 0.6, cmp, hash);
cmc_assert_equals(ptr, NULL, set); cmc_assert_equals(ptr, NULL, set);
CMC_TEST_PASS_ELSE_FAIL(set == NULL);
}); });
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
hashset *set = hs_new(UINT64_MAX, 0.6, cmp, hash); hashset *set = hs_new(UINT64_MAX, 0.6, cmp, hash);
cmc_assert_equals(ptr, NULL, set); cmc_assert_equals(ptr, NULL, set);
CMC_TEST_PASS_ELSE_FAIL(set == NULL);
}); });
CMC_CREATE_TEST(clear[count capacity], { CMC_CREATE_TEST(clear[count capacity], {
@@ -48,8 +42,6 @@ CMC_CREATE_UNIT(hashset_test, true, {
cmc_assert_equals(size_t, 0, hs_count(set)); cmc_assert_equals(size_t, 0, hs_count(set));
CMC_TEST_PASS_ELSE_FAIL(hs_count(set) == 0);
hs_free(set); hs_free(set);
}); });
tests/main/unt/heap.c
+2 -15
View File
@@ -9,14 +9,9 @@ CMC_CREATE_UNIT(heap_test, true, {
heap *h = h_new(1000000, cmc_max_heap, cmp); heap *h = h_new(1000000, cmc_max_heap, cmp);
cmc_assert_not_equals(ptr, NULL, h); cmc_assert_not_equals(ptr, NULL, h);
bool passed = h->capacity == 1000000 && h->count == 0 && h->buffer;
cmc_assert_equals(size_t, 1000000, h->capacity);
cmc_assert_equals(size_t, 0, h_count(h));
cmc_assert_not_equals(ptr, NULL, h->buffer); cmc_assert_not_equals(ptr, NULL, h->buffer);
cmc_assert_equals(size_t, 1000000, h_capacity(h));
CMC_TEST_PASS_ELSE_FAIL(passed); cmc_assert_equals(size_t, 0, h_count(h));
h_free(h); h_free(h);
}); });
@@ -25,16 +20,12 @@ CMC_CREATE_UNIT(heap_test, true, {
heap *h = h_new(0, cmc_max_heap, cmp); heap *h = h_new(0, cmc_max_heap, cmp);
cmc_assert_equals(ptr, NULL, h); cmc_assert_equals(ptr, NULL, h);
CMC_TEST_PASS_ELSE_FAIL(h == NULL);
}); });
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
heap *h = h_new(UINT64_MAX, cmc_max_heap, cmp); heap *h = h_new(UINT64_MAX, cmc_max_heap, cmp);
cmc_assert_equals(ptr, NULL, h); cmc_assert_equals(ptr, NULL, h);
CMC_TEST_PASS_ELSE_FAIL(h == NULL);
}); });
CMC_CREATE_TEST(clear[count capacity], { CMC_CREATE_TEST(clear[count capacity], {
@@ -52,8 +43,6 @@ CMC_CREATE_UNIT(heap_test, true, {
cmc_assert_equals(size_t, 0, h_count(h)); cmc_assert_equals(size_t, 0, h_count(h));
cmc_assert_equals(size_t, 100, h_capacity(h)); cmc_assert_equals(size_t, 100, h_capacity(h));
CMC_TEST_PASS_ELSE_FAIL(h_count(h) == 0 && h_capacity(h) == 100);
h_free(h); h_free(h);
}); });
@@ -67,8 +56,6 @@ CMC_CREATE_UNIT(heap_test, true, {
cmc_assert_equals(size_t, 50, h_count(h)); cmc_assert_equals(size_t, 50, h_count(h));
CMC_TEST_PASS_ELSE_FAIL(h_count(h) == 50);
h_free(h); h_free(h);
}); });
tests/main/unt/linkedlist.c
-19
View File
@@ -7,15 +7,10 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
linkedlist *ll = ll_new(); linkedlist *ll = ll_new();
cmc_assert_not_equals(ptr, NULL, ll); cmc_assert_not_equals(ptr, NULL, ll);
bool passed = ll->count == 0 && ll->head == NULL && ll->tail == NULL;
cmc_assert_equals(size_t, 0, ll_count(ll)); cmc_assert_equals(size_t, 0, ll_count(ll));
cmc_assert_equals(ptr, NULL, ll->head); cmc_assert_equals(ptr, NULL, ll->head);
cmc_assert_equals(ptr, NULL, ll->tail); cmc_assert_equals(ptr, NULL, ll->tail);
CMC_TEST_PASS_ELSE_FAIL(passed);
ll_free(ll); ll_free(ll);
}); });
@@ -33,8 +28,6 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
cmc_assert_equals(size_t, 0, ll_count(ll)); cmc_assert_equals(size_t, 0, ll_count(ll));
CMC_TEST_PASS_ELSE_FAIL(ll_count(ll) == 0);
ll_free(ll); ll_free(ll);
}); });
@@ -47,8 +40,6 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
cmc_assert_equals(size_t, 0, ll_count(ll)); cmc_assert_equals(size_t, 0, ll_count(ll));
CMC_TEST_PASS_ELSE_FAIL(ll_count(ll) == 0);
ll_free(ll); ll_free(ll);
}); });
@@ -63,8 +54,6 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
cmc_assert_not_equals(ptr, NULL, ll->tail); cmc_assert_not_equals(ptr, NULL, ll->tail);
cmc_assert_equals(size_t, 1, ll_count(ll)); cmc_assert_equals(size_t, 1, ll_count(ll));
CMC_TEST_PASS_ELSE_FAIL(ll->head && ll->tail && ll_count(ll) == 1);
ll_free(ll); ll_free(ll);
}); });
@@ -76,16 +65,8 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
for (size_t i = 0; i < 200; i++) for (size_t i = 0; i < 200; i++)
ll_push_front(ll, i); ll_push_front(ll, i);
bool passed = true;
for (size_t i = 0; i < ll_count(ll); i++) for (size_t i = 0; i < ll_count(ll); i++)
{
passed = passed && ll_get(ll, i) == (ll_count(ll) - i - 1);
cmc_assert_equals(size_t, ll_get(ll, i), ll_count(ll) - i - 1); cmc_assert_equals(size_t, ll_get(ll, i), ll_count(ll) - i - 1);
}
CMC_TEST_PASS_ELSE_FAIL(passed && ll_count(ll) == 200);
ll_free(ll); ll_free(ll);
}); });
tests/main/unt/list.c
+5 -90
View File
@@ -7,14 +7,9 @@ CMC_CREATE_UNIT(list_test, true, {
list *l = l_new(1000000); list *l = l_new(1000000);
cmc_assert_not_equals(ptr, NULL, l); cmc_assert_not_equals(ptr, NULL, l);
bool passed = l->capacity == 1000000 && l->count == 0 && l->buffer;
cmc_assert_equals(size_t, 1000000, l->capacity);
cmc_assert_equals(size_t, 0, l_count(l));
cmc_assert_not_equals(ptr, NULL, l->buffer); cmc_assert_not_equals(ptr, NULL, l->buffer);
cmc_assert_equals(size_t, 1000000, l_capacity(l));
CMC_TEST_PASS_ELSE_FAIL(passed); cmc_assert_equals(size_t, 0, l_count(l));
l_free(l); l_free(l);
}); });
@@ -23,16 +18,12 @@ CMC_CREATE_UNIT(list_test, true, {
list *l = l_new(0); list *l = l_new(0);
cmc_assert_equals(ptr, NULL, l); cmc_assert_equals(ptr, NULL, l);
CMC_TEST_PASS_ELSE_FAIL(l == NULL);
}); });
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
list *l = l_new(UINT64_MAX); list *l = l_new(UINT64_MAX);
cmc_assert_equals(ptr, NULL, l); cmc_assert_equals(ptr, NULL, l);
CMC_TEST_PASS_ELSE_FAIL(l == NULL);
}); });
CMC_CREATE_TEST(new_from[count item_preservation], { CMC_CREATE_TEST(new_from[count item_preservation], {
@@ -47,17 +38,9 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l); cmc_assert_not_equals(ptr, NULL, l);
bool passed = true;
for (size_t i = 0; i < 5; i++) for (size_t i = 0; i < 5; i++)
{
cmc_assert_equals(size_t, i, l_get(l, i)); cmc_assert_equals(size_t, i, l_get(l, i));
passed = passed && l_get(l, i) == i;
}
CMC_TEST_PASS_ELSE_FAIL(passed && l_count(l) == 5);
l_free(l); l_free(l);
}); });
@@ -70,8 +53,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l); cmc_assert_not_equals(ptr, NULL, l);
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 1);
l_free(l); l_free(l);
}); });
@@ -90,8 +71,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_equals(size_t, 0, l_count(l)); cmc_assert_equals(size_t, 0, l_count(l));
cmc_assert_equals(size_t, 100, l_capacity(l)); cmc_assert_equals(size_t, 100, l_capacity(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 0 && l_capacity(l) == 100);
l_free(l); l_free(l);
}); });
@@ -105,15 +84,8 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_equals(size_t, 100, l_count(l)); cmc_assert_equals(size_t, 100, l_count(l));
bool passed = true;
for (size_t i = 0; i < 100; i++) for (size_t i = 0; i < 100; i++)
{
passed = passed && l_get(l, i) == i;
cmc_assert_equals(size_t, i, l_get(l, i)); cmc_assert_equals(size_t, i, l_get(l, i));
}
CMC_TEST_PASS_ELSE_FAIL(passed);
l_free(l); l_free(l);
}); });
@@ -128,8 +100,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_equals(size_t, 250, l_count(l)); cmc_assert_equals(size_t, 250, l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 250);
l_free(l); l_free(l);
}); });
@@ -143,8 +113,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l)); cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) <= l_capacity(l));
l_free(l); l_free(l);
}); });
@@ -156,16 +124,8 @@ CMC_CREATE_UNIT(list_test, true, {
for (size_t i = 0; i < 250; i++) for (size_t i = 0; i < 250; i++)
cmc_assert(l_push_front(l, i)); cmc_assert(l_push_front(l, i));
bool passed = true;
for (size_t i = 0; i < l_count(l); i++) for (size_t i = 0; i < l_count(l); i++)
{
passed = passed && l_get(l, i) == (l_count(l) - i - 1);
cmc_assert_equals(size_t, l_get(l, i), l_count(l) - i - 1); cmc_assert_equals(size_t, l_get(l, i), l_count(l) - i - 1);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
l_free(l); l_free(l);
}); });
@@ -183,8 +143,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_equals(size_t, 250, l_count(l)); cmc_assert_equals(size_t, 250, l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 250);
l_free(l); l_free(l);
}); });
@@ -201,8 +159,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l)); cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) <= l_capacity(l));
l_free(l); l_free(l);
}); });
@@ -217,16 +173,8 @@ CMC_CREATE_UNIT(list_test, true, {
for (size_t i = 1; i < 249; i++) for (size_t i = 1; i < 249; i++)
cmc_assert(l_push(l, i, l_count(l) - 1)); cmc_assert(l_push(l, i, l_count(l) - 1));
bool passed = true;
for (size_t i = 0; i < l_count(l); i++) for (size_t i = 0; i < l_count(l); i++)
{
passed = passed && l_get(l, i) == i;
cmc_assert_equals(size_t, l_get(l, i), i); cmc_assert_equals(size_t, l_get(l, i), i);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
l_free(l); l_free(l);
}); });
@@ -241,8 +189,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_equals(size_t, 250, l_count(l)); cmc_assert_equals(size_t, 250, l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 250);
l_free(l); l_free(l);
}); });
@@ -256,8 +202,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l)); cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) <= l_capacity(l));
l_free(l); l_free(l);
}); });
@@ -269,16 +213,8 @@ CMC_CREATE_UNIT(list_test, true, {
for (size_t i = 0; i < 250; i++) for (size_t i = 0; i < 250; i++)
cmc_assert(l_push_back(l, i)); cmc_assert(l_push_back(l, i));
bool passed = true;
for (size_t i = 0; i < l_count(l); i++) for (size_t i = 0; i < l_count(l); i++)
{
passed = passed && l_get(l, i) == i;
cmc_assert_equals(size_t, l_get(l, i), i); cmc_assert_equals(size_t, l_get(l, i), i);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
l_free(l); l_free(l);
}); });
@@ -293,8 +229,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert(l_pop_front(l)); cmc_assert(l_pop_front(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 250 - 1);
l_free(l); l_free(l);
}); });
@@ -306,16 +240,10 @@ CMC_CREATE_UNIT(list_test, true, {
for (size_t i = 0; i < 250; i++) for (size_t i = 0; i < 250; i++)
l_push_back(l, i); l_push_back(l, i);
bool passed = l_pop_front(l); cmc_assert(l_pop_front(l));
for (size_t i = 0; i < l_count(l); i++) for (size_t i = 0; i < l_count(l); i++)
{
passed = passed && l_get(l, i) == i + 1;
cmc_assert_equals(size_t, l_get(l, i), i + 1); cmc_assert_equals(size_t, l_get(l, i), i + 1);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
l_free(l); l_free(l);
}); });
@@ -325,7 +253,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l); cmc_assert_not_equals(ptr, NULL, l);
cmc_assert(!l_pop_front(l)); cmc_assert(!l_pop_front(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 0);
l_free(l); l_free(l);
}); });
@@ -337,8 +264,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert(l_push_back(l, 10)); cmc_assert(l_push_back(l, 10));
cmc_assert(l_pop_front(l)); cmc_assert(l_pop_front(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 0);
l_free(l); l_free(l);
}); });
@@ -349,12 +274,10 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert(l_push_back(l, 1)); cmc_assert(l_push_back(l, 1));
cmc_assert(l_push_front(l, 2)); cmc_assert(l_push_front(l, 2));
bool passed = l_pop_front(l) && l->buffer[1] == 0; cmc_assert(l_pop_front(l));
cmc_assert_equals(size_t, 0, l->buffer[1]); cmc_assert_equals(size_t, 0, l->buffer[1]);
CMC_TEST_PASS_ELSE_FAIL(passed && l_count(l) == 1);
l_free(l); l_free(l);
}); });
@@ -364,8 +287,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l); cmc_assert_not_equals(ptr, NULL, l);
cmc_assert(!l_pop(l, 1)); cmc_assert(!l_pop(l, 1));
CMC_TEST_PASS_ELSE_FAIL(!l_pop(l, 1));
l_free(l); l_free(l);
}); });
@@ -374,8 +295,7 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l); cmc_assert_not_equals(ptr, NULL, l);
cmc_assert(l_push_back(l, 1)); cmc_assert(l_push_back(l, 1));
cmc_assert(l_pop(l, 0));
CMC_TEST_PASS_ELSE_FAIL(l_pop(l, 0));
cmc_assert_equals(size_t, 0, l->buffer[0]); cmc_assert_equals(size_t, 0, l->buffer[0]);
@@ -391,8 +311,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert(l_push_back(l, 3)); cmc_assert(l_push_back(l, 3));
cmc_assert(l_pop(l, 1)); cmc_assert(l_pop(l, 1));
CMC_TEST_PASS_ELSE_FAIL(0 == l->buffer[2]);
l_free(l); l_free(l);
}); });
@@ -401,7 +319,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l); cmc_assert_not_equals(ptr, NULL, l);
cmc_assert(!l_pop_back(l)); cmc_assert(!l_pop_back(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 0);
l_free(l); l_free(l);
}); });
@@ -413,8 +330,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert(l_push_back(l, 10)); cmc_assert(l_push_back(l, 10));
cmc_assert(l_pop_back(l)); cmc_assert(l_pop_back(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 0);
l_free(l); l_free(l);
}); });
}) })
tests/main/unt/multimap.c
+2 -24
View File
@@ -8,13 +8,11 @@ CMC_CREATE_UNIT(multimap_test, true, {
CMC_CREATE_TEST(new, { CMC_CREATE_TEST(new, {
multimap *map = mm_new(943722, 0.8, cmp, hash); multimap *map = mm_new(943722, 0.8, cmp, hash);
bool passed = (map->capacity >= (943722 / 0.8)) && map->count == 0 && map->buffer;
cmc_assert_not_equals(ptr, NULL, map); cmc_assert_not_equals(ptr, NULL, map);
cmc_assert_not_equals(ptr, NULL, map->buffer);
cmc_assert_equals(size_t, 0, mm_count(map));
cmc_assert_greater_equals(size_t, (943722 / 0.8), mm_capacity(map)); cmc_assert_greater_equals(size_t, (943722 / 0.8), mm_capacity(map));
CMC_TEST_PASS_ELSE_FAIL(passed);
mm_free(map); mm_free(map);
}); });
@@ -22,16 +20,12 @@ CMC_CREATE_UNIT(multimap_test, true, {
multimap *map = mm_new(0, 0.8, cmp, hash); multimap *map = mm_new(0, 0.8, cmp, hash);
cmc_assert_equals(ptr, NULL, map); cmc_assert_equals(ptr, NULL, map);
CMC_TEST_PASS_ELSE_FAIL(map == NULL);
}); });
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
multimap *map = mm_new(UINT64_MAX, 0.8, cmp, hash); multimap *map = mm_new(UINT64_MAX, 0.8, cmp, hash);
cmc_assert_equals(ptr, NULL, map); cmc_assert_equals(ptr, NULL, map);
CMC_TEST_PASS_ELSE_FAIL(map == NULL);
}); });
CMC_CREATE_TEST(clear[count capacity], { CMC_CREATE_TEST(clear[count capacity], {
@@ -48,8 +42,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 0, mm_count(map)); cmc_assert_equals(size_t, 0, mm_count(map));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 0);
mm_free(map); mm_free(map);
}); });
@@ -63,8 +55,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 200, mm_count(map)); cmc_assert_equals(size_t, 200, mm_count(map));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 200);
mm_free(map); mm_free(map);
}); });
@@ -83,8 +73,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 140, mm_count(map)); cmc_assert_equals(size_t, 140, mm_count(map));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 140);
mm_free(map); mm_free(map);
}); });
@@ -97,8 +85,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert(!mm_remove(map, 10, &r)); cmc_assert(!mm_remove(map, 10, &r));
CMC_TEST_PASS_ELSE_FAIL(!mm_remove(map, 10, &r));
mm_free(map); mm_free(map);
}); });
@@ -112,8 +98,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert(mm_insert(map, 10, 11)); cmc_assert(mm_insert(map, 10, 11));
cmc_assert(mm_remove(map, 10, &r)); cmc_assert(mm_remove(map, 10, &r));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 0);
mm_free(map); mm_free(map);
}); });
@@ -127,8 +111,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 50, mm_count(map)); cmc_assert_equals(size_t, 50, mm_count(map));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 50);
mm_free(map); mm_free(map);
}); });
@@ -147,8 +129,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 50, mm_count(map)); cmc_assert_equals(size_t, 50, mm_count(map));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 50);
mm_free(map); mm_free(map);
}); });
@@ -165,8 +145,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 100, mm_get(map, 10)); cmc_assert_equals(size_t, 100, mm_get(map, 10));
CMC_TEST_PASS_ELSE_FAIL(mm_get(map, 10) == 100);
mm_free(map); mm_free(map);
}); });
tests/main/unt/multiset.c
+5 -21
View File
@@ -8,12 +8,10 @@ CMC_CREATE_UNIT(multiset_test, true, {
CMC_CREATE_TEST(new, { CMC_CREATE_TEST(new, {
multiset *set = ms_new(943722, 0.6, cmp, hash); multiset *set = ms_new(943722, 0.6, cmp, hash);
bool passed = (set->capacity >= (943722 / 0.6)) && set->count == 0 && set->buffer;
cmc_assert_not_equals(ptr, NULL, set); cmc_assert_not_equals(ptr, NULL, set);
cmc_assert(ms_capacity(set) > (943722 / 0.6)); cmc_assert_not_equals(ptr, NULL, set->buffer);
cmc_assert_equals(size_t, 0, ms_count(set));
CMC_TEST_PASS_ELSE_FAIL(passed); cmc_assert_greater_equals(size_t, ((size_t)(943722 / 0.6)), ms_capacity(set));
ms_free(set); ms_free(set);
}); });
@@ -22,16 +20,12 @@ CMC_CREATE_UNIT(multiset_test, true, {
multiset *set = ms_new(0, 0.6, cmp, hash); multiset *set = ms_new(0, 0.6, cmp, hash);
cmc_assert_equals(ptr, NULL, set); cmc_assert_equals(ptr, NULL, set);
CMC_TEST_PASS_ELSE_FAIL(set == NULL);
}); });
CMC_CREATE_TEST(new[edge_case:capacity = UINTMAX_MAX], { CMC_CREATE_TEST(new[edge_case:capacity = UINTMAX_MAX], {
multiset *set = ms_new(UINTMAX_MAX, 0.99, cmp, hash); multiset *set = ms_new(UINTMAX_MAX, 0.99, cmp, hash);
cmc_assert_equals(ptr, NULL, set); cmc_assert_equals(ptr, NULL, set);
CMC_TEST_PASS_ELSE_FAIL(set == NULL);
}); });
CMC_CREATE_TEST(clear[count capacity], { CMC_CREATE_TEST(clear[count capacity], {
@@ -48,8 +42,6 @@ CMC_CREATE_UNIT(multiset_test, true, {
cmc_assert_equals(size_t, 0, ms_count(set)); cmc_assert_equals(size_t, 0, ms_count(set));
CMC_TEST_PASS_ELSE_FAIL(ms_count(set) == 0);
ms_free(set); ms_free(set);
}); });
@@ -68,12 +60,8 @@ CMC_CREATE_UNIT(multiset_test, true, {
cmc_assert_equals(size_t, 3, ms_count(set)); cmc_assert_equals(size_t, 3, ms_count(set));
cmc_assert_equals(size_t, 6, ms_cardinality(set)); cmc_assert_equals(size_t, 6, ms_cardinality(set));
bool passed = ms_count(set) == 3 && ms_cardinality(set) == 6;
for (size_t i = 0; i <= 3; i++) for (size_t i = 0; i <= 3; i++)
passed = passed && ms_multiplicity_of(set, i) == i; cmc_assert_equals(size_t, i, ms_multiplicity_of(set, i));
CMC_TEST_PASS_ELSE_FAIL(passed);
ms_free(set); ms_free(set);
}); });
@@ -89,12 +77,8 @@ CMC_CREATE_UNIT(multiset_test, true, {
cmc_assert_equals(size_t, 20, ms_count(set)); cmc_assert_equals(size_t, 20, ms_count(set));
cmc_assert_equals(size_t, 100, ms_cardinality(set)); cmc_assert_equals(size_t, 100, ms_cardinality(set));
bool passed = ms_count(set) == 20 && ms_cardinality(set) == 100;
for (size_t i = 0; i < 20; i++) for (size_t i = 0; i < 20; i++)
passed = passed && ms_multiplicity_of(set, i) == 5; cmc_assert_equals(size_t, 5, ms_multiplicity_of(set, i));
CMC_TEST_PASS_ELSE_FAIL(passed);
ms_free(set); ms_free(set);
}); });
tests/main/unt/queue.c
+4 -16
View File
@@ -7,15 +7,11 @@ CMC_CREATE_UNIT(queue_test, true, {
queue *q = q_new(1000000); queue *q = q_new(1000000);
cmc_assert_not_equals(ptr, NULL, q); cmc_assert_not_equals(ptr, NULL, q);
cmc_assert_not_equals(ptr, NULL, q->buffer);
bool passed = q->capacity == 1000000 && q->count == 0 && q->buffer; cmc_assert_equals(size_t, 1000000, q_capacity(q));
cmc_assert_equals(size_t, 1000000, q->capacity);
cmc_assert_equals(size_t, 0, q_count(q)); cmc_assert_equals(size_t, 0, q_count(q));
cmc_assert_not_equals(ptr, NULL, q->buffer); cmc_assert_not_equals(ptr, NULL, q->buffer);
CMC_TEST_PASS_ELSE_FAIL(passed);
q_free(q); q_free(q);
}); });
@@ -23,16 +19,12 @@ CMC_CREATE_UNIT(queue_test, true, {
queue *q = q_new(0); queue *q = q_new(0);
cmc_assert_equals(ptr, NULL, q); cmc_assert_equals(ptr, NULL, q);
CMC_TEST_PASS_ELSE_FAIL(q == NULL);
}); });
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
queue *q = q_new(UINT64_MAX); queue *q = q_new(UINT64_MAX);
cmc_assert_equals(ptr, NULL, q); cmc_assert_equals(ptr, NULL, q);
CMC_TEST_PASS_ELSE_FAIL(q == NULL);
}); });
CMC_CREATE_TEST(clear[count capacity], { CMC_CREATE_TEST(clear[count capacity], {
@@ -41,7 +33,7 @@ CMC_CREATE_UNIT(queue_test, true, {
cmc_assert_not_equals(ptr, NULL, q); cmc_assert_not_equals(ptr, NULL, q);
for (size_t i = 0; i < 50; i++) for (size_t i = 0; i < 50; i++)
q_enqueue(q, i); cmc_assert(q_enqueue(q, i));
cmc_assert_equals(size_t, 50, q_count(q)); cmc_assert_equals(size_t, 50, q_count(q));
@@ -50,8 +42,6 @@ CMC_CREATE_UNIT(queue_test, true, {
cmc_assert_equals(size_t, 0, q_count(q)); cmc_assert_equals(size_t, 0, q_count(q));
cmc_assert_equals(size_t, 100, q_capacity(q)); cmc_assert_equals(size_t, 100, q_capacity(q));
CMC_TEST_PASS_ELSE_FAIL(q_count(q) == 0 && q_capacity(q) == 100);
q_free(q); q_free(q);
}); });
@@ -61,12 +51,10 @@ CMC_CREATE_UNIT(queue_test, true, {
cmc_assert_not_equals(ptr, NULL, q); cmc_assert_not_equals(ptr, NULL, q);
for (size_t i = 0; i < 50; i++) for (size_t i = 0; i < 50; i++)
q_enqueue(q, i); cmc_assert(q_enqueue(q, i));
cmc_assert_equals(size_t, 50, q_count(q)); cmc_assert_equals(size_t, 50, q_count(q));
CMC_TEST_PASS_ELSE_FAIL(q_count(q) == 50);
q_free(q); q_free(q);
}); });
tests/main/unt/stack.c
+6 -118
View File
@@ -9,15 +9,11 @@ CMC_CREATE_UNIT(stack_test, true, {
stack *s = s_new(1000000); stack *s = s_new(1000000);
cmc_assert_not_equals(ptr, NULL, s); cmc_assert_not_equals(ptr, NULL, s);
cmc_assert_not_equals(ptr, NULL, s->buffer);
bool passed = s->capacity == 1000000 && s->count == 0 && s->buffer; cmc_assert_equals(size_t, 1000000, s_capacity(s));
cmc_assert_equals(size_t, 1000000, s->capacity);
cmc_assert_equals(size_t, 0, s_count(s)); cmc_assert_equals(size_t, 0, s_count(s));
cmc_assert_not_equals(ptr, NULL, s->buffer); cmc_assert_not_equals(ptr, NULL, s->buffer);
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s); s_free(s);
}); });
@@ -25,16 +21,12 @@ CMC_CREATE_UNIT(stack_test, true, {
stack *s = s_new(0); stack *s = s_new(0);
cmc_assert_equals(ptr, NULL, s); cmc_assert_equals(ptr, NULL, s);
CMC_TEST_PASS_ELSE_FAIL(s == NULL);
}); });
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
stack *s = s_new(UINT64_MAX); stack *s = s_new(UINT64_MAX);
cmc_assert_equals(ptr, NULL, s); cmc_assert_equals(ptr, NULL, s);
CMC_TEST_PASS_ELSE_FAIL(s == NULL);
}); });
CMC_CREATE_TEST(clear[count capacity], { CMC_CREATE_TEST(clear[count capacity], {
@@ -52,8 +44,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 0, s_count(s)); cmc_assert_equals(size_t, 0, s_count(s));
cmc_assert_equals(size_t, 100, s_capacity(s)); cmc_assert_equals(size_t, 100, s_capacity(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) == 0 && s_capacity(s) == 100);
s_free(s); s_free(s);
}); });
@@ -68,8 +58,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 50, s_count(s)); cmc_assert_equals(size_t, 50, s_count(s));
cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s)); cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) == 50 && s_count(s) <= s_capacity(s));
s_free(s); s_free(s);
}); });
@@ -83,8 +71,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 250, s_count(s)); cmc_assert_equals(size_t, 250, s_count(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) == 250);
s_free(s); s_free(s);
}); });
@@ -98,8 +84,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s)); cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) <= s_capacity(s));
s_free(s); s_free(s);
}); });
@@ -111,16 +95,8 @@ CMC_CREATE_UNIT(stack_test, true, {
for (size_t i = 0; i < 250; i++) for (size_t i = 0; i < 250; i++)
cmc_assert(s_push(s, i)); cmc_assert(s_push(s, i));
bool passed = true;
for (size_t i = 0; i < s_count(s); i++) for (size_t i = 0; i < s_count(s); i++)
{
passed = s->buffer[i] == i;
cmc_assert_equals(size_t, i, s->buffer[i]); cmc_assert_equals(size_t, i, s->buffer[i]);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s); s_free(s);
}); });
@@ -137,8 +113,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 249, s_count(s)); cmc_assert_equals(size_t, 249, s_count(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) == 249);
s_free(s); s_free(s);
}); });
@@ -154,8 +128,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s)); cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) <= s_capacity(s));
s_free(s); s_free(s);
}); });
@@ -170,16 +142,8 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(s_pop(s)); cmc_assert(s_pop(s));
cmc_assert(s_pop(s)); cmc_assert(s_pop(s));
bool passed = true;
for (size_t i = 0; i < s_count(s); i++) for (size_t i = 0; i < s_count(s); i++)
{
passed = s->buffer[i] == i;
cmc_assert_equals(size_t, i, s->buffer[i]); cmc_assert_equals(size_t, i, s->buffer[i]);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s); s_free(s);
}); });
@@ -191,8 +155,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(bool, false, s_pop(s)); cmc_assert_equals(bool, false, s_pop(s));
CMC_TEST_PASS_ELSE_FAIL(!s_pop(s));
s_free(s); s_free(s);
}); });
@@ -204,16 +166,8 @@ CMC_CREATE_UNIT(stack_test, true, {
for (size_t i = 0; i < 250; i++) for (size_t i = 0; i < 250; i++)
s_push_if(s, i, i % 2 == 0); s_push_if(s, i, i % 2 == 0);
bool passed = true;
for (size_t i = 0; i < s_count(s); i++) for (size_t i = 0; i < s_count(s); i++)
{
passed = passed && s->buffer[i] % 2 == 0;
cmc_assert(s->buffer[i] % 2 == 0); cmc_assert(s->buffer[i] % 2 == 0);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s); s_free(s);
}); });
@@ -229,16 +183,8 @@ CMC_CREATE_UNIT(stack_test, true, {
s_pop_if(s, s_top(s) % 2 == 0); s_pop_if(s, s_top(s) % 2 == 0);
} }
bool passed = true;
for (size_t i = 0; i < s_count(s); i++) for (size_t i = 0; i < s_count(s); i++)
{ cmc_assert_not_equals(uint32_t, 0, s->buffer[i] % 2);
passed = passed && !(s->buffer[i] % 2 == 0);
cmc_assert(!(s->buffer[i] % 2 == 0));
}
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s); s_free(s);
}); });
@@ -256,8 +202,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 247, s_top(s)); cmc_assert_equals(size_t, 247, s_top(s));
CMC_TEST_PASS_ELSE_FAIL(247 == s_top(s));
s_free(s); s_free(s);
}); });
@@ -272,8 +216,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, s_impl_default_value(), s_top(s)); cmc_assert_equals(size_t, s_impl_default_value(), s_top(s));
CMC_TEST_PASS_ELSE_FAIL(s_impl_default_value() == s_top(s));
s_free(s); s_free(s);
}); });
@@ -286,8 +228,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 1, s_count(s)); cmc_assert_equals(size_t, 1, s_count(s));
cmc_assert_equals(size_t, 10, s_top(s)); cmc_assert_equals(size_t, 10, s_top(s));
CMC_TEST_PASS_ELSE_FAIL(10 == s_top(s));
s_free(s); s_free(s);
}); });
@@ -299,12 +239,8 @@ CMC_CREATE_UNIT(stack_test, true, {
for (size_t i = 0; i < 150; i++) for (size_t i = 0; i < 150; i++)
cmc_assert(s_push(s, i)); cmc_assert(s_push(s, i));
bool passed = true;
for (size_t i = 0; i < 150; i++) for (size_t i = 0; i < 150; i++)
passed = passed && s_contains(s, i, cmp); cmc_assert(s_contains(s, i, cmp));
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s); s_free(s);
}); });
@@ -316,8 +252,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(bool, false, s_contains(s, 10, cmp)); cmc_assert_equals(bool, false, s_contains(s, 10, cmp));
CMC_TEST_PASS_ELSE_FAIL(!s_contains(s, 10, cmp));
s_free(s); s_free(s);
}); });
@@ -328,8 +262,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(s_empty(s)); cmc_assert(s_empty(s));
CMC_TEST_PASS_ELSE_FAIL(s_empty(s));
s_free(s); s_free(s);
}); });
@@ -342,8 +274,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(s_pop(s)); cmc_assert(s_pop(s));
cmc_assert(s_empty(s)); cmc_assert(s_empty(s));
CMC_TEST_PASS_ELSE_FAIL(s_empty(s));
s_free(s); s_free(s);
}); });
@@ -357,8 +287,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(s_full(s)); cmc_assert(s_full(s));
CMC_TEST_PASS_ELSE_FAIL(s_full(s));
s_free(s); s_free(s);
}); });
@@ -371,8 +299,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(s_full(s)); cmc_assert(s_full(s));
CMC_TEST_PASS_ELSE_FAIL(s_full(s));
s_free(s); s_free(s);
}); });
@@ -385,8 +311,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_not_equals(ptr, NULL, iter); cmc_assert_not_equals(ptr, NULL, iter);
CMC_TEST_PASS_ELSE_FAIL(s && iter);
s_iter_free(iter); s_iter_free(iter);
s_free(s); s_free(s);
}); });
@@ -405,10 +329,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(iter.start); cmc_assert(iter.start);
cmc_assert(iter.end); cmc_assert(iter.end);
bool passed = iter.target == s && iter.cursor == 0 && iter.start && iter.end;
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s); s_free(s);
}); });
@@ -421,7 +341,7 @@ CMC_CREATE_UNIT(stack_test, true, {
s_iter_init(&iter, s); s_iter_init(&iter, s);
CMC_TEST_PASS_ELSE_FAIL(s_iter_start(&iter)); cmc_assert(s_iter_start(&iter));
s_free(s); s_free(s);
}); });
@@ -435,7 +355,7 @@ CMC_CREATE_UNIT(stack_test, true, {
s_iter_init(&iter, s); s_iter_init(&iter, s);
CMC_TEST_PASS_ELSE_FAIL(s_iter_end(&iter)); cmc_assert(s_iter_end(&iter));
s_free(s); s_free(s);
}); });
@@ -464,8 +384,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 40200, total); cmc_assert_equals(size_t, 40200, total);
CMC_TEST_PASS_ELSE_FAIL(total == 40200);
s_free(s); s_free(s);
}); });
@@ -496,8 +414,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 40200, total); cmc_assert_equals(size_t, 40200, total);
CMC_TEST_PASS_ELSE_FAIL(total == 40200);
s_free(s); s_free(s);
}); });
@@ -521,8 +437,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 20, total); cmc_assert_equals(size_t, 20, total);
CMC_TEST_PASS_ELSE_FAIL(total == 20);
s_free(s); s_free(s);
}); });
@@ -552,8 +466,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 2000, total); cmc_assert_equals(size_t, 2000, total);
CMC_TEST_PASS_ELSE_FAIL(total == 2000);
s_free(s); s_free(s);
}); });
@@ -565,7 +477,6 @@ CMC_CREATE_UNIT(stack_test, true, {
for (size_t i = 0; i < 50; i++) for (size_t i = 0; i < 50; i++)
cmc_assert(s_push(s, i)); cmc_assert(s_push(s, i));
bool passed = true;
stack_iter it1; stack_iter it1;
stack_iter it2; stack_iter it2;
@@ -581,7 +492,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, it1.cursor, it2.cursor); cmc_assert_equals(size_t, it1.cursor, it2.cursor);
cmc_assert_equals(bool, it1.start, it2.start); cmc_assert_equals(bool, it1.start, it2.start);
cmc_assert_equals(bool, it1.end, it2.end); cmc_assert_equals(bool, it1.end, it2.end);
passed = passed && it1.target == it2.target && it1.cursor == it2.cursor && it1.start == it2.start && it1.end == it2.end;
it1 = s->it_end(s); it1 = s->it_end(s);
s_iter_to_end(&it2); s_iter_to_end(&it2);
@@ -590,9 +500,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, it1.cursor, it2.cursor); cmc_assert_equals(size_t, it1.cursor, it2.cursor);
cmc_assert_equals(bool, it1.start, it2.start); cmc_assert_equals(bool, it1.start, it2.start);
cmc_assert_equals(bool, it1.end, it2.end); cmc_assert_equals(bool, it1.end, it2.end);
passed = passed && it1.target == it2.target && it1.cursor == it2.cursor && it1.start == it2.start && it1.end == it2.end;
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s); s_free(s);
}); });
@@ -608,14 +515,10 @@ CMC_CREATE_UNIT(stack_test, true, {
s_iter_to_end(&iter); s_iter_to_end(&iter);
cmc_assert_equals(bool, false, s_iter_next(&iter)); cmc_assert_equals(bool, false, s_iter_next(&iter));
bool passed = !s_iter_next(&iter);
s_iter_to_start(&iter); s_iter_to_start(&iter);
cmc_assert_equals(bool, false, s_iter_prev(&iter)); cmc_assert_equals(bool, false, s_iter_prev(&iter));
passed = !s_iter_prev(&iter);
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s); s_free(s);
}); });
@@ -634,14 +537,10 @@ CMC_CREATE_UNIT(stack_test, true, {
s_iter_to_end(&iter); s_iter_to_end(&iter);
cmc_assert_equals(bool, false, s_iter_next(&iter)); cmc_assert_equals(bool, false, s_iter_next(&iter));
bool passed = !s_iter_next(&iter);
s_iter_to_start(&iter); s_iter_to_start(&iter);
cmc_assert_equals(bool, false, s_iter_prev(&iter)); cmc_assert_equals(bool, false, s_iter_prev(&iter));
passed = !s_iter_prev(&iter);
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s); s_free(s);
}); });
@@ -657,8 +556,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, s_impl_default_value(), s_iter_value(&iter)); cmc_assert_equals(size_t, s_impl_default_value(), s_iter_value(&iter));
CMC_TEST_PASS_ELSE_FAIL(s_impl_default_value() == s_iter_value(&iter));
s_free(s); s_free(s);
}); });
@@ -673,8 +570,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(ptr, NULL, s_iter_rvalue(&iter)); cmc_assert_equals(ptr, NULL, s_iter_rvalue(&iter));
CMC_TEST_PASS_ELSE_FAIL(NULL == s_iter_rvalue(&iter));
s_free(s); s_free(s);
}); });
@@ -688,18 +583,15 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 10, s_count(s)); cmc_assert_equals(size_t, 10, s_count(s));
bool passed = true;
size_t total = 0; size_t total = 0;
for (stack_iter it = s->it_start(s); false; ) for (stack_iter it = s->it_start(s); false; )
{ {
passed = passed && s_iter_index(&it) == 0;
cmc_assert_equals(size_t, 0, s_iter_index(&it)); cmc_assert_equals(size_t, 0, s_iter_index(&it));
} }
for (stack_iter it = s->it_start(s); false; ) for (stack_iter it = s->it_start(s); false; )
{ {
passed = passed && s_iter_index(&it) == s_count(s) - 1;
cmc_assert_equals(size_t, s_count(s) - 1, s_iter_index(&it)); cmc_assert_equals(size_t, s_count(s) - 1, s_iter_index(&it));
} }
@@ -717,8 +609,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 90, total); cmc_assert_equals(size_t, 90, total);
CMC_TEST_PASS_ELSE_FAIL(passed && total == 90);
s_free(s); s_free(s);
}); });
@@ -732,8 +622,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 0, s_iter_index(&iter)); cmc_assert_equals(size_t, 0, s_iter_index(&iter));
CMC_TEST_PASS_ELSE_FAIL(0 == s_iter_index(&iter));
s_free(s); s_free(s);
}); });
tests/main/unt/treemap.c
-4
View File
@@ -10,8 +10,6 @@ CMC_CREATE_UNIT(treemap_test, true, {
cmc_assert_not_equals(ptr, NULL, map); cmc_assert_not_equals(ptr, NULL, map);
CMC_TEST_PASS_ELSE_FAIL(map);
tm_free(map); tm_free(map);
}); });
@@ -30,8 +28,6 @@ CMC_CREATE_UNIT(treemap_test, true, {
cmc_assert_equals(size_t, 0, tm_count(map)); cmc_assert_equals(size_t, 0, tm_count(map));
cmc_assert_equals(ptr, NULL, map->root); cmc_assert_equals(ptr, NULL, map->root);
CMC_TEST_PASS_ELSE_FAIL(tm_count(map) == 0);
tm_free(map); tm_free(map);
}); });
tests/main/unt/treeset.c
-5
View File
@@ -10,8 +10,6 @@ CMC_CREATE_UNIT(treeset_test, true, {
cmc_assert_not_equals(ptr, NULL, set); cmc_assert_not_equals(ptr, NULL, set);
CMC_TEST_PASS_ELSE_FAIL(set);
ts_free(set); ts_free(set);
}); });
@@ -30,9 +28,6 @@ CMC_CREATE_UNIT(treeset_test, true, {
cmc_assert_equals(size_t, 0, ts_count(set)); cmc_assert_equals(size_t, 0, ts_count(set));
cmc_assert_equals(ptr, NULL, set->root); cmc_assert_equals(ptr, NULL, set->root);
CMC_TEST_PASS_ELSE_FAIL(ts_count(set) == 0);
ts_free(set); ts_free(set);
}); });