297 lines
8.1 KiB
C
297 lines
8.1 KiB
C
// SPDX-FileCopyrightText: 2015 Jeffrey Crowell <crowell@bu.edu>
|
|
// SPDX-FileCopyrightText: 2018 ret2libc <sirmy15@gmail.com>
|
|
// SPDX-License-Identifier: LGPL-3.0-only
|
|
|
|
// minunit.h comes from http://www.jera.com/techinfo/jtns/jtn002.html
|
|
//
|
|
// You may use the code in this tech note for any purpose,
|
|
// with the understanding that it comes with NO WARRANTY.
|
|
|
|
#ifndef _MINUNIT_H_
|
|
#define _MINUNIT_H_
|
|
|
|
#include <rz_types.h>
|
|
|
|
#if __WINDOWS__
|
|
#define TRED
|
|
#define TGREEN
|
|
#define TYELLOW
|
|
#define TBLUE
|
|
#define TMAGENTA
|
|
#define TCYAN
|
|
#define TBOLD
|
|
#define TRESET
|
|
#else
|
|
#define TRED "\x1b[31m"
|
|
#define TGREEN "\x1b[32m"
|
|
#define TYELLOW "\x1b[33m"
|
|
#define TBLUE "\x1b[34m"
|
|
#define TMAGENTA "\x1b[35m"
|
|
#define TCYAN "\x1b[36m"
|
|
#define TBOLD "\x1b[1m"
|
|
#define TRESET "\x1b[0m"
|
|
#endif
|
|
|
|
#define MU_PASSED 1
|
|
#define MU_ERR 0
|
|
|
|
#define MU_TEST_UNBROKEN 0
|
|
#define MU_TEST_BROKEN 1
|
|
|
|
#define MU_BUF_SIZE 8192
|
|
|
|
void snprint_mem(char *out, size_t out_size, const ut8 *buf, size_t len) {
|
|
size_t i;
|
|
*out = '\0';
|
|
for (i = 0; i < len; i++) {
|
|
size_t out_len;
|
|
if (i > 0) {
|
|
out_len = strlen(out);
|
|
snprintf(out + out_len, out_size - out_len, " ");
|
|
}
|
|
out_len = strlen(out);
|
|
snprintf(out + out_len, out_size - out_len, "%02x", buf[i]);
|
|
}
|
|
}
|
|
|
|
#define mu_assert(message, test) \
|
|
do { \
|
|
if (!(test)) { \
|
|
mu_fail(message); \
|
|
mu_test_status = MU_TEST_UNBROKEN; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define mu_perror(message) \
|
|
do { \
|
|
if (mu_test_status != MU_TEST_BROKEN) { \
|
|
printf(TBOLD TRED "ERR\n[XX] Fail at line %d: " TRESET "%s\n\n", __LINE__, message); \
|
|
} else { \
|
|
printf(TBOLD TYELLOW "Broken at line %d: " TRESET "%s\n\n", __LINE__, message); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define mu_psyserror(message) \
|
|
do { \
|
|
perror(message); \
|
|
mu_perror(message); \
|
|
} while (0)
|
|
|
|
#define mu_fail(message) \
|
|
do { \
|
|
mu_perror(message); \
|
|
if (mu_test_status != MU_TEST_BROKEN) \
|
|
return MU_ERR; \
|
|
} while (0)
|
|
|
|
#define mu_ignore \
|
|
do { \
|
|
printf(TYELLOW "IGN\n" TRESET); \
|
|
return MU_PASSED; \
|
|
} while (0)
|
|
|
|
#define mu_end \
|
|
do { \
|
|
printf(TGREEN "OK\n" TRESET); \
|
|
return MU_PASSED; \
|
|
} while (0)
|
|
|
|
#define mu_cleanup_end \
|
|
do { \
|
|
if (retval == MU_PASSED) { \
|
|
mu_end; \
|
|
} else { \
|
|
return retval; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define mu_sysfail(message) \
|
|
do { \
|
|
perror(message); \
|
|
mu_fail(message); \
|
|
} while (0)
|
|
|
|
#define mu_assert_true(actual, message) \
|
|
do { \
|
|
bool act__ = (actual); \
|
|
if (!(act__)) { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected true, got false", (message)); \
|
|
mu_assert(_meqstr, false); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define mu_assert_false(actual, message) \
|
|
do { \
|
|
bool act__ = (actual); \
|
|
if ((act__)) { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected false, got true", (message)); \
|
|
mu_assert(_meqstr, false); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define mu_assert_eq(actual, expected, message) \
|
|
do { \
|
|
ut64 act__ = (ut64)(actual); \
|
|
ut64 exp__ = (ut64)(expected); \
|
|
if ((exp__) != (act__)) { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected %" PFMT64d ", got %" PFMT64d ".", (message), (ut64)(exp__), (ut64)(act__)); \
|
|
mu_assert(_meqstr, false); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define mu_assert_eqf(actual, expected, message) \
|
|
do { \
|
|
double act__ = (double)(actual); \
|
|
double exp__ = (double)(expected); \
|
|
if ((exp__) != (act__)) { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected %lf, got %lf.", (message), exp__, act__); \
|
|
mu_assert(_meqstr, false); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define mu_assert_neq(actual, expected, message) \
|
|
do { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
ut64 act__ = (ut64)(actual); \
|
|
ut64 exp__ = (ut64)(expected); \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected not %" PFMT64d ", got %" PFMT64d ".", (message), (exp__), (act__)); \
|
|
mu_assert(_meqstr, (exp__) != (act__)); \
|
|
} while (0)
|
|
|
|
#define mu_assert_ptreq(actual, expected, message) \
|
|
do { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
const void *act__ = (actual); \
|
|
const void *exp__ = (expected); \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected %p, got %p.", (message), (exp__), (act__)); \
|
|
mu_assert(_meqstr, (exp__) == (act__)); \
|
|
} while (0)
|
|
|
|
#define mu_assert_ptrneq(actual, expected, message) \
|
|
do { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
const void *act__ = (actual); \
|
|
const void *exp__ = (expected); \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected not %p, got %p.", (message), (exp__), (act__)); \
|
|
mu_assert(_meqstr, (exp__) != (act__)); \
|
|
} while (0)
|
|
|
|
#define mu_assert_null(actual, message) \
|
|
do { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
const void *act__ = (actual); \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected to be NULL but it wasn't.", (message)); \
|
|
mu_assert(_meqstr, (act__) == NULL); \
|
|
} while (0)
|
|
|
|
#define mu_assert_notnull(actual, message) \
|
|
do { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
const void *act__ = (actual); \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected to not be NULL but it was.", (message)); \
|
|
mu_assert(_meqstr, (act__) != NULL); \
|
|
} while (0)
|
|
|
|
#define mu_assert_eq_fmt(actual, expected, message, fmt) \
|
|
do { \
|
|
ut64 act__ = (ut64)(actual); \
|
|
ut64 exp__ = (ut64)(expected); \
|
|
if ((exp__) != (act__)) { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected " fmt ", got " fmt ".", (message), (exp__), (act__)); \
|
|
mu_assert(_meqstr, false); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define mu_assert_streq(actual, expected, message) \
|
|
do { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
const char *act__ = (actual); \
|
|
act__ = act__ ? act__ : "(null)"; \
|
|
const char *exp__ = (expected); \
|
|
exp__ = exp__ ? exp__ : "(null)"; \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected %s, got %s.", (message), (exp__), (act__)); \
|
|
mu_assert(_meqstr, strcmp((exp__), (act__)) == 0); \
|
|
} while (0)
|
|
|
|
#define mu_assert_strcontains(actual, expected, message) \
|
|
do { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
const char *act__ = (actual); \
|
|
act__ = act__ ? act__ : "(null)"; \
|
|
const char *exp__ = (expected); \
|
|
exp__ = exp__ ? exp__ : "(null)"; \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected to find %s in %s.", (message), (exp__), (act__)); \
|
|
mu_assert(_meqstr, strstr((act__), (exp__)) != NULL); \
|
|
} while (0)
|
|
|
|
#define mu_assert_streq_free(actual, expected, message) \
|
|
do { \
|
|
char *act2__ = (actual); \
|
|
mu_assert_streq(act2__, (expected), (message)); \
|
|
free(act2__); \
|
|
} while (0)
|
|
|
|
#define mu_assert_nullable_streq(actual, expected, message) \
|
|
do { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
const char *act__ = (actual); \
|
|
const char *exp__ = (expected); \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected %s, got %s.", (message), (exp__ ? exp__ : "NULL"), (act__ ? act__ : "NULL")); \
|
|
mu_assert(_meqstr, ((act__) == NULL && (exp__) == NULL) || ((act__) != NULL && (exp__) != NULL && strcmp((exp__), (act__)) == 0)); \
|
|
} while (0)
|
|
|
|
#define mu_assert_memeq(actual, expected, len, message) \
|
|
do { \
|
|
char _meqstr[MU_BUF_SIZE]; \
|
|
size_t _meqstr_len; \
|
|
const ut8 *act__ = (actual); \
|
|
const ut8 *exp__ = (expected); \
|
|
snprintf(_meqstr, MU_BUF_SIZE, "%s: expected ", message); \
|
|
_meqstr_len = strlen(_meqstr); \
|
|
snprint_mem(_meqstr + _meqstr_len, MU_BUF_SIZE - _meqstr_len, (exp__), (len)); \
|
|
_meqstr_len = strlen(_meqstr); \
|
|
snprintf(_meqstr + _meqstr_len, MU_BUF_SIZE - _meqstr_len, ", got "); \
|
|
_meqstr_len = strlen(_meqstr); \
|
|
snprint_mem(_meqstr + _meqstr_len, MU_BUF_SIZE - _meqstr_len, (act__), (len)); \
|
|
mu_assert(_meqstr, memcmp((exp__), (act__), (len)) == 0); \
|
|
} while (0)
|
|
|
|
#define mu_run_test_named(test, name, ...) \
|
|
do { \
|
|
int result; \
|
|
printf(TBOLD "%s" TRESET " ", name); \
|
|
mu_test_status = MU_TEST_UNBROKEN; \
|
|
result = test(__VA_ARGS__); \
|
|
tests_run++; \
|
|
tests_passed += result; \
|
|
} while (0)
|
|
|
|
#define mu_run_test(test, ...) mu_run_test_named(test, #test, __VA_ARGS__)
|
|
|
|
#define mu_cleanup_fail(label, message) \
|
|
do { \
|
|
mu_perror(message); \
|
|
retval = MU_ERR; \
|
|
goto label; \
|
|
} while (0)
|
|
#define mu_cleanup_sysfail(label, message) \
|
|
do { \
|
|
mu_psyserror(message); \
|
|
retval = MU_ERR; \
|
|
goto label; \
|
|
} while (0)
|
|
int tests_run = 0;
|
|
int tests_passed = 0;
|
|
int mu_test_status = MU_TEST_UNBROKEN;
|
|
|
|
#define mu_main(fcn) \
|
|
int main(int argc, char **argv) { \
|
|
return fcn(); \
|
|
}
|
|
|
|
#endif
|