open-dsi
/
clamav
mirror of https://github.com/Cisco-Talos/clamav
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Check test support for check 0.13

Browse Source 
Tests in libcheck 0.13 must have {} between START_TEST and END_TEST
else it will not compile.

Also replaced all deprecated "fail_" macros with "ck_" macros.
E.g. fail_unless() becomes ck_assert_msg()

The checks_common.h header file provided a couple of macros to
support versions older than 0.9.3.  As these older versions are
no longer relevant, I've removed those compatibility macros
entirely.
pull/117/head
Micah Snyder (micasnyd) 5 years ago
parent 898c08f08b
commit 485d8dec67
11 changed files with 530 additions and 583 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 44
      unit_tests/check_bytecode.c
  2. 349
      unit_tests/check_clamav.c
  3. 146
      unit_tests/check_clamd.c
  4. 14
      unit_tests/check_disasm.c
  5. 51
      unit_tests/check_htmlnorm.c
  6. 90
      unit_tests/check_jsnorm.c
  7. 136
      unit_tests/check_matchers.c
  8. 180
      unit_tests/check_regex.c
  9. 71
      unit_tests/check_str.c
  10. 20
      unit_tests/check_uniq.c
  11. 12
      unit_tests/checks_common.h

44
unit_tests/check_bytecode.c
Unescape View File

@ -71,21 +71,21 @@ static void runtest(const char *file, uint64_t expected, int fail, int nojit,
cctx.options->general |= CL_SCAN_GENERAL_ALLMATCHES;
cctx.virname = &virname;
cctx.engine = engine = cl_engine_new();
fail_unless(!!cctx.engine, "cannot create engine");
ck_assert_msg(!!cctx.engine, "cannot create engine");
rc = cl_engine_compile(engine);
fail_unless(!rc, "cannot compile engine");
ck_assert_msg(!rc, "cannot compile engine");
cctx.fmap = cli_calloc(sizeof(fmap_t *), engine->maxreclevel + 2);
fail_unless(!!cctx.fmap, "cannot allocate fmap");
ck_assert_msg(!!cctx.fmap, "cannot allocate fmap");
fail_unless(fd >= 0, "retmagic open failed");
ck_assert_msg(fd >= 0, "retmagic open failed");
f = fdopen(fd, "r");
fail_unless(!!f, "retmagic fdopen failed");
ck_assert_msg(!!f, "retmagic fdopen failed");
cl_debug();
if (!nojit) {
rc = cli_bytecode_init(&bcs);
fail_unless(rc == CL_SUCCESS, "cli_bytecode_init failed");
ck_assert_msg(rc == CL_SUCCESS, "cli_bytecode_init failed");
} else {
bcs.engine = NULL;
}
@ -94,22 +94,22 @@ static void runtest(const char *file, uint64_t expected, int fail, int nojit,
bcs.count = 1;
rc = cli_bytecode_load(&bc, f, NULL, 1, 0);
fail_unless(rc == CL_SUCCESS, "cli_bytecode_load failed");
ck_assert_msg(rc == CL_SUCCESS, "cli_bytecode_load failed");
fclose(f);
if (testmode && have_clamjit)
engine->bytecode_mode = CL_BYTECODE_MODE_TEST;
rc = cli_bytecode_prepare2(engine, &bcs, BYTECODE_ENGINE_MASK);
fail_unless(rc == CL_SUCCESS, "cli_bytecode_prepare failed");
ck_assert_msg(rc == CL_SUCCESS, "cli_bytecode_prepare failed");
if (have_clamjit && !nojit && nojit != -1 && !testmode) {
fail_unless(bc.state == bc_jit, "preparing for JIT failed");
ck_assert_msg(bc.state == bc_jit, "preparing for JIT failed");
}
ctx = cli_bytecode_context_alloc();
ctx->bytecode_timeout = fail == CL_ETIMEOUT ? 10 : 10000;
fail_unless(!!ctx, "cli_bytecode_context_alloc failed");
ck_assert_msg(!!ctx, "cli_bytecode_context_alloc failed");
ctx->ctx = &cctx;
if (infile) {
@ -117,9 +117,9 @@ static void runtest(const char *file, uint64_t expected, int fail, int nojit,
fdin = open(filestr, O_RDONLY);
if (fdin < 0 && errno == ENOENT)
fdin = open_testfile(infile);
fail_unless(fdin >= 0, "failed to open infile");
ck_assert_msg(fdin >= 0, "failed to open infile");
map = fmap(fdin, 0, 0);
fail_unless(!!map, "unable to fmap infile");
ck_assert_msg(!!map, "unable to fmap infile");
if (pedata)
ctx->hooks.pedata = pedata;
ctx->sections = sections;
@ -128,16 +128,16 @@ static void runtest(const char *file, uint64_t expected, int fail, int nojit,
cli_bytecode_context_setfuncid(ctx, &bc, 0);
rc = cli_bytecode_run(&bcs, &bc, ctx);
fail_unless_fmt(rc == fail, "cli_bytecode_run failed, expected: %u, have: %u\n",
ck_assert_msg(rc == fail, "cli_bytecode_run failed, expected: %u, have: %u\n",
fail, rc);
if (rc == CL_SUCCESS) {
v = cli_bytecode_context_getresult_int(ctx);
fail_unless_fmt(v == expected, "Invalid return value from bytecode run, expected: %llx, have: %llx\n",
ck_assert_msg(v == expected, "Invalid return value from bytecode run, expected: %llx, have: %llx\n",
expected, v);
}
if (infile && expectedvirname) {
fail_unless(ctx->virname &&
ck_assert_msg(ctx->virname &&
!strcmp(ctx->virname, expectedvirname),
"Invalid virname, expected: %s\n", expectedvirname);
}
@ -489,18 +489,18 @@ static void runload(const char *dbname, struct cl_engine *engine, unsigned signo
srcdir = SRCDIR;
}
str = cli_malloc(strlen(dbname) + strlen(srcdir) + 2);
fail_unless(!!str, "cli_malloc");
ck_assert_msg(!!str, "cli_malloc");
sprintf(str, "%s/%s", srcdir, dbname);
rc = cl_load(str, engine, &signo, CL_DB_STDOPT);
fail_unless_fmt(rc == CL_SUCCESS, "failed to load %s: %s\n",
ck_assert_msg(rc == CL_SUCCESS, "failed to load %s: %s\n",
dbname, cl_strerror(rc));
fail_unless_fmt(signo == signoexp, "different number of signatures loaded, expected %u, got %u\n",
ck_assert_msg(signo == signoexp, "different number of signatures loaded, expected %u, got %u\n",
signoexp, signo);
free(str);
rc = cl_engine_compile(engine);
fail_unless_fmt(rc == CL_SUCCESS, "failed to load %s: %s\n",
ck_assert_msg(rc == CL_SUCCESS, "failed to load %s: %s\n",
dbname, cl_strerror(rc));
}
@ -509,7 +509,7 @@ START_TEST(test_load_bytecode_jit)
struct cl_engine *engine;
cl_init(CL_INIT_DEFAULT);
engine = cl_engine_new();
fail_unless(!!engine, "failed to create engine\n");
ck_assert_msg(!!engine, "failed to create engine\n");
runload("input/bytecode.cvd", engine, 5);
@ -523,7 +523,7 @@ START_TEST(test_load_bytecode_int)
cl_init(CL_INIT_DEFAULT);
engine = cl_engine_new();
engine->dconf->bytecode = BYTECODE_INTERPRETER;
fail_unless(!!engine, "failed to create engine\n");
ck_assert_msg(!!engine, "failed to create engine\n");
runload("input/bytecode.cvd", engine, 5);
@ -541,7 +541,7 @@ static void *thread(void *arg)
{
struct cl_engine *engine;
engine = cl_engine_new();
fail_unless(!!engine, "failed to create engine\n");
ck_assert_msg(!!engine, "failed to create engine\n");
/* run all cl_load at once, to maximize chance of a crash
* in case of a race condition */
pthread_barrier_wait(&barrier);

349
unit_tests/check_clamav.c
Unescape View File

@ -33,30 +33,23 @@ static int fpu_words = FPU_ENDIAN_INITME;
/* extern void cl_free(struct cl_engine *engine); */
START_TEST(test_cl_free)
/*
struct cl_engine *engine = NULL;
cl_free(NULL);
*/
END_TEST
/* extern struct cl_engine *cl_dup(struct cl_engine *engine); */
START_TEST(test_cl_dup)
/*
struct cl_engine *engine;
fail_unless(NULL == cl_dup(NULL), "cl_dup null pointer");
*/
{
// struct cl_engine *engine = NULL;
// cl_free(NULL);
}
END_TEST
/* extern int cl_build(struct cl_engine *engine); */
START_TEST(test_cl_build)
/*
struct cl_engine *engine;
fail_unless(CL_ENULLARG == cl_build(NULL), "cl_build null pointer");
engine = calloc(sizeof(struct cl_engine),1);
fail_unless(engine, "cl_build calloc");
fail_unless(CL_ENULLARG == cl_build(engine), "cl_build(engine) with null ->root");
*/
/* engine->root = cli_calloc(CL_TARGET_TABLE_SIZE, sizeof(struct cli_matcher *)); */
{
// struct cl_engine *engine;
// ck_assert_msg(CL_ENULLARG == cl_build(NULL), "cl_build null pointer");
// engine = calloc(sizeof(struct cl_engine),1);
// ck_assert_msg(engine, "cl_build calloc");
// ck_assert_msg(CL_ENULLARG == cl_build(engine), "cl_build(engine) with null ->root");
// engine->root = cli_calloc(CL_TARGET_TABLE_SIZE, sizeof(struct cli_matcher *));
}
END_TEST
/* extern void cl_debug(void); */
@ -65,18 +58,20 @@ START_TEST(test_cl_debug)
int old_status = cli_debug_flag;
cli_debug_flag = 0;
cl_debug();
fail_unless(1 == cli_debug_flag, "cl_debug failed to set cli_debug_flag");
ck_assert_msg(1 == cli_debug_flag, "cl_debug failed to set cli_debug_flag");
cli_debug_flag = 1;
cl_debug();
fail_unless(1 == cli_debug_flag, "cl_debug failed when flag was already set");
ck_assert_msg(1 == cli_debug_flag, "cl_debug failed when flag was already set");
cli_debug_flag = old_status;
}
END_TEST
/* extern const char *cl_retdbdir(void); */
START_TEST(test_cl_retdbdir)
fail_unless(!strcmp(DATADIR, cl_retdbdir()), "cl_retdbdir");
{
ck_assert_msg(!strcmp(DATADIR, cl_retdbdir()), "cl_retdbdir");
}
END_TEST
#ifndef REPO_VERSION
@ -87,80 +82,81 @@ END_TEST
START_TEST(test_cl_retver)
{
const char *ver = cl_retver();
fail_unless(!strcmp(REPO_VERSION "" VERSION_SUFFIX, ver), "cl_retver");
fail_unless(strcspn(ver, "012345789") < strlen(ver),
ck_assert_msg(!strcmp(REPO_VERSION "" VERSION_SUFFIX, ver), "cl_retver");
ck_assert_msg(strcspn(ver, "012345789") < strlen(ver),
"cl_retver must have a number");
}
END_TEST
/* extern void cl_cvdfree(struct cl_cvd *cvd); */
START_TEST(test_cl_cvdfree)
/*
struct cl_cvd *cvd1, *cvd2;
cvd1 = malloc(sizeof(struct cl_cvd));
fail_unless(cvd1, "cvd malloc");
cl_cvdfree(cvd1);
cvd2 = malloc(sizeof(struct cl_cvd));
cvd2->time = malloc(1);
cvd2->md5 = malloc(1);
cvd2->dsig= malloc(1);
cvd2->builder = malloc(1);
fail_unless(cvd2, "cvd malloc");
fail_unless(cvd2->time, "cvd malloc");
fail_unless(cvd2->md5, "cvd malloc");
fail_unless(cvd2->dsig, "cvd malloc");
fail_unless(cvd2->builder, "cvd malloc");
cl_cvdfree(cvd2);
cl_cvdfree(NULL);
*/
{
// struct cl_cvd *cvd1, *cvd2;
// cvd1 = malloc(sizeof(struct cl_cvd));
// ck_assert_msg(cvd1, "cvd malloc");
// cl_cvdfree(cvd1);
// cvd2 = malloc(sizeof(struct cl_cvd));
// cvd2->time = malloc(1);
// cvd2->md5 = malloc(1);
// cvd2->dsig= malloc(1);
// cvd2->builder = malloc(1);
// ck_assert_msg(cvd2, "cvd malloc");
// ck_assert_msg(cvd2->time, "cvd malloc");
// ck_assert_msg(cvd2->md5, "cvd malloc");
// ck_assert_msg(cvd2->dsig, "cvd malloc");
// ck_assert_msg(cvd2->builder, "cvd malloc");
// cl_cvdfree(cvd2);
// cl_cvdfree(NULL);
}
END_TEST
/* extern int cl_statfree(struct cl_stat *dbstat); */
START_TEST(test_cl_statfree)
/*
struct cl_stat *stat;
fail_unless(CL_ENULLARG == cl_statfree(NULL), "cl_statfree(NULL)");
stat = malloc(sizeof(struct cl_stat));
fail_unless(NULL != stat, "malloc");
fail_unless(CL_SUCCESS == cl_statfree(stat), "cl_statfree(empty_struct)");
stat = malloc(sizeof(struct cl_stat));
fail_unless(NULL != stat, "malloc");
stat->stattab = strdup("test");
fail_unless(NULL != stat->stattab, "strdup");
fail_unless(CL_SUCCESS == cl_statfree(stat), "cl_statfree(stat with stattab)");
stat = malloc(sizeof(struct cl_stat));
fail_unless(NULL != stat, "malloc");
stat->stattab = NULL;
fail_unless(CL_SUCCESS == cl_statfree(stat), "cl_statfree(stat with stattab) set to NULL");
*/
{
// struct cl_stat *stat;
// ck_assert_msg(CL_ENULLARG == cl_statfree(NULL), "cl_statfree(NULL)");
// stat = malloc(sizeof(struct cl_stat));
// ck_assert_msg(NULL != stat, "malloc");
// ck_assert_msg(CL_SUCCESS == cl_statfree(stat), "cl_statfree(empty_struct)");
// stat = malloc(sizeof(struct cl_stat));
// ck_assert_msg(NULL != stat, "malloc");
// stat->stattab = strdup("test");
// ck_assert_msg(NULL != stat->stattab, "strdup");
// ck_assert_msg(CL_SUCCESS == cl_statfree(stat), "cl_statfree(stat with stattab)");
// stat = malloc(sizeof(struct cl_stat));
// ck_assert_msg(NULL != stat, "malloc");
// stat->stattab = NULL;
// ck_assert_msg(CL_SUCCESS == cl_statfree(stat), "cl_statfree(stat with stattab) set to NULL");
}
END_TEST
/* extern unsigned int cl_retflevel(void); */
START_TEST(test_cl_retflevel)
{}
END_TEST
/* extern struct cl_cvd *cl_cvdhead(const char *file); */
START_TEST(test_cl_cvdhead)
/*
fail_unless(NULL == cl_cvdhead(NULL), "cl_cvdhead(null)");
fail_unless(NULL == cl_cvdhead("input/cl_cvdhead/1.txt"), "cl_cvdhead(515 byte file, all nulls)");
*/
/* the data read from the file is passed to cl_cvdparse, test cases for that are separate */
{
// ck_assert_msg(NULL == cl_cvdhead(NULL), "cl_cvdhead(null)");
// ck_assert_msg(NULL == cl_cvdhead("input/cl_cvdhead/1.txt"), "cl_cvdhead(515 byte file, all nulls)");
/* the data read from the file is passed to cl_cvdparse, test cases for that are separate */
}
END_TEST
/* extern struct cl_cvd *cl_cvdparse(const char *head); */
START_TEST(test_cl_cvdparse)
{}
END_TEST
static int get_test_file(int i, char *file, unsigned fsize, unsigned long *size);
static struct cl_engine *g_engine;
#ifdef CHECK_HAVE_LOOPS
/* int cl_scandesc(int desc, const char **virname, unsigned long int *scanned, const struct cl_engine *engine, const struct cl_limits *limits, struct cl_scan_options* options) */
START_TEST(test_cl_scandesc)
{
@ -180,8 +176,8 @@ START_TEST(test_cl_scandesc)
cli_dbgmsg("scan end (scandesc) %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scandesc failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
ck_assert_msg(ret == CL_VIRUS, "cl_scandesc failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
}
close(fd);
}
@ -207,8 +203,8 @@ START_TEST(test_cl_scandesc_allscan)
cli_dbgmsg("scan end (scandesc) %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scandesc_allscan failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
ck_assert_msg(ret == CL_VIRUS, "cl_scandesc_allscan failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
}
close(fd);
}
@ -235,8 +231,8 @@ START_TEST(test_cl_scanfile)
cli_dbgmsg("scan end (scanfile) %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
ck_assert_msg(ret == CL_VIRUS, "cl_scanfile failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
}
}
END_TEST
@ -262,8 +258,8 @@ START_TEST(test_cl_scanfile_allscan)
cli_dbgmsg("scan end (scanfile_allscan) %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_allscan failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
ck_assert_msg(ret == CL_VIRUS, "cl_scanfile_allscan failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
}
}
END_TEST
@ -289,8 +285,8 @@ START_TEST(test_cl_scanfile_callback)
cli_dbgmsg("scan end (scanfile_cb) %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_cb failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
ck_assert_msg(ret == CL_VIRUS, "cl_scanfile_cb failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
}
}
END_TEST
@ -317,8 +313,8 @@ START_TEST(test_cl_scanfile_callback_allscan)
cli_dbgmsg("scan end (scanfile_cb_allscan) %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_cb_allscan failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
ck_assert_msg(ret == CL_VIRUS, "cl_scanfile_cb_allscan failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
}
}
END_TEST
@ -343,8 +339,8 @@ START_TEST(test_cl_scandesc_callback)
cli_dbgmsg("scan end (scandesc_cb) %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
ck_assert_msg(ret == CL_VIRUS, "cl_scanfile failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
}
close(fd);
}
@ -371,37 +367,41 @@ START_TEST(test_cl_scandesc_callback_allscan)
cli_dbgmsg("scan end (scandesc_cb_allscan) %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scanfile_allscan failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
ck_assert_msg(ret == CL_VIRUS, "cl_scanfile_allscan failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
}
close(fd);
}
END_TEST
#endif
/* int cl_load(const char *path, struct cl_engine **engine, unsigned int *signo, unsigned int options) */
START_TEST(test_cl_load)
{}
END_TEST
/* int cl_cvdverify(const char *file) */
START_TEST(test_cl_cvdverify)
{}
END_TEST
/* int cl_statinidir(const char *dirname, struct cl_stat *dbstat) */
START_TEST(test_cl_statinidir)
{}
END_TEST
/* int cl_statchkdir(const struct cl_stat *dbstat) */
START_TEST(test_cl_statchkdir)
{}
END_TEST
/* void cl_settempdir(const char *dir, short leavetemps) */
START_TEST(test_cl_settempdir)
{}
END_TEST
/* const char *cl_strerror(int clerror) */
START_TEST(test_cl_strerror)
{}
END_TEST
static char **testfiles = NULL;
@ -441,7 +441,7 @@ static void init_testfiles(void)
int expect = expected_testfiles;
DIR *d = opendir(OBJDIR "/../test");
fail_unless(!!d, "opendir");
ck_assert_msg(!!d, "opendir");
if (!d)
return;
testfiles = NULL;
@ -451,14 +451,14 @@ static void init_testfiles(void)
continue;
i++;
testfiles = cli_realloc(testfiles, i * sizeof(*testfiles));
fail_unless(!!testfiles, "cli_realloc");
ck_assert_msg(!!testfiles, "cli_realloc");
testfiles[i - 1] = strdup(dirent->d_name);
}
testfiles_n = i;
if (get_fpu_endian() == FPU_ENDIAN_UNKNOWN)
expect--;
expect -= skip_files();
fail_unless_fmt(testfiles_n == expect, "testfiles: %d != %d", testfiles_n, expect);
ck_assert_msg(testfiles_n == expect, "testfiles: %d != %d", testfiles_n, expect);
closedir(d);
}
@ -483,13 +483,13 @@ static void engine_setup(void)
init_testfiles();
if (!inited)
fail_unless(cl_init(CL_INIT_DEFAULT) == 0, "cl_init");
ck_assert_msg(cl_init(CL_INIT_DEFAULT) == 0, "cl_init");
inited = 1;
g_engine = cl_engine_new();
fail_unless(!!g_engine, "engine");
fail_unless_fmt(cl_load(hdb, g_engine, &sigs, CL_DB_STDOPT) == 0, "cl_load %s", hdb);
fail_unless(sigs == 1, "sigs");
fail_unless(cl_engine_compile(g_engine) == 0, "cl_engine_compile");
ck_assert_msg(!!g_engine, "engine");
ck_assert_msg(cl_load(hdb, g_engine, &sigs, CL_DB_STDOPT) == 0, "cl_load %s", hdb);
ck_assert_msg(sigs == 1, "sigs");
ck_assert_msg(cl_engine_compile(g_engine) == 0, "cl_engine_compile");
}
static void engine_teardown(void)
@ -503,16 +503,15 @@ static int get_test_file(int i, char *file, unsigned fsize, unsigned long *size)
int fd;
STATBUF st;
fail_unless(i < testfiles_n, "%i < %i %s", i, testfiles_n, file);
ck_assert_msg(i < testfiles_n, "%i < %i %s", i, testfiles_n, file);
snprintf(file, fsize, OBJDIR "/../test/%s", testfiles[i]);
fd = open(file, O_RDONLY);
fail_unless(fd > 0, "open");
fail_unless(FSTAT(fd, &st) == 0, "fstat");
ck_assert_msg(fd > 0, "open");
ck_assert_msg(FSTAT(fd, &st) == 0, "fstat");
*size = st.st_size;
return fd;
}
#ifdef CHECK_HAVE_LOOPS
static off_t pread_cb(void *handle, void *buf, size_t count, off_t offset)
{
@ -535,15 +534,15 @@ START_TEST(test_cl_scanmap_callback_handle)
int fd = get_test_file(_i, file, sizeof(file), &size);
/* intentionally use different way than scanners.c for testing */
map = cl_fmap_open_handle(&fd, 0, size, pread_cb, 1);
fail_unless(!!map, "cl_fmap_open_handle");
ck_assert_msg(!!map, "cl_fmap_open_handle");
cli_dbgmsg("scanning (handle) %s\n", file);
ret = cl_scanmap_callback(map, file, &virname, &scanned, g_engine, &options, NULL);
cli_dbgmsg("scan end (handle) %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
ck_assert_msg(ret == CL_VIRUS, "cl_scanmap_callback failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
}
close(fd);
}
@ -566,15 +565,15 @@ START_TEST(test_cl_scanmap_callback_handle_allscan)
int fd = get_test_file(_i, file, sizeof(file), &size);
/* intentionally use different way than scanners.c for testing */
map = cl_fmap_open_handle(&fd, 0, size, pread_cb, 1);
fail_unless(!!map, "cl_fmap_open_handle %s");
ck_assert_msg(!!map, "cl_fmap_open_handle %s");
cli_dbgmsg("scanning (handle) allscan %s\n", file);
ret = cl_scanmap_callback(map, file, &virname, &scanned, g_engine, &options, NULL);
cli_dbgmsg("scan end (handle) allscan %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback allscan failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
ck_assert_msg(ret == CL_VIRUS, "cl_scanmap_callback allscan failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s", virname);
}
close(fd);
}
@ -597,18 +596,18 @@ START_TEST(test_cl_scanmap_callback_mem)
int fd = get_test_file(_i, file, sizeof(file), &size);
mem = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
fail_unless(mem != MAP_FAILED, "mmap");
ck_assert_msg(mem != MAP_FAILED, "mmap");
/* intentionally use different way than scanners.c for testing */
map = cl_fmap_open_memory(mem, size);
fail_unless(!!map, "cl_fmap_open_mem");
ck_assert_msg(!!map, "cl_fmap_open_mem");
cli_dbgmsg("scanning (mem) %s\n", file);
ret = cl_scanmap_callback(map, file, &virname, &scanned, g_engine, &options, NULL);
cli_dbgmsg("scan end (mem) %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s for %s", virname, file);
ck_assert_msg(ret == CL_VIRUS, "cl_scanmap_callback failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s for %s", virname, file);
}
close(fd);
cl_fmap_close(map);
@ -635,36 +634,34 @@ START_TEST(test_cl_scanmap_callback_mem_allscan)
int fd = get_test_file(_i, file, sizeof(file), &size);
mem = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
fail_unless(mem != MAP_FAILED, "mmap");
ck_assert_msg(mem != MAP_FAILED, "mmap");
/* intentionally use different way than scanners.c for testing */
map = cl_fmap_open_memory(mem, size);
fail_unless(!!map, "cl_fmap_open_mem %s");
ck_assert_msg(!!map, "cl_fmap_open_mem %s");
cli_dbgmsg("scanning (mem) allscan %s\n", file);
ret = cl_scanmap_callback(map, file, &virname, &scanned, g_engine, &options, NULL);
cli_dbgmsg("scan end (mem) allscan %s\n", file);
if (!FALSE_NEGATIVE) {
fail_unless_fmt(ret == CL_VIRUS, "cl_scanmap_callback allscan failed for %s: %s", file, cl_strerror(ret));
fail_unless_fmt(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s for %s", virname, file);
ck_assert_msg(ret == CL_VIRUS, "cl_scanmap_callback allscan failed for %s: %s", file, cl_strerror(ret));
ck_assert_msg(virname && !strcmp(virname, "ClamAV-Test-File.UNOFFICIAL"), "virusname: %s for %s", virname, file);
}
close(fd);
cl_fmap_close(map);
munmap(mem, size);
}
END_TEST
#endif
static Suite *test_cl_suite(void)
{
Suite *s = suite_create("cl_api");
TCase *tc_cl = tcase_create("cl_dup");
TCase *tc_cl_scan = tcase_create("cl_scan");
Suite *s = suite_create("cl_suite");
TCase *tc_cl = tcase_create("cl_api");
TCase *tc_cl_scan = tcase_create("cl_scan_api");
char *user_timeout = NULL;
int expect = expected_testfiles;
suite_add_tcase(s, tc_cl);
tcase_add_test(tc_cl, test_cl_free);
tcase_add_test(tc_cl, test_cl_dup);
tcase_add_test(tc_cl, test_cl_build);
tcase_add_test(tc_cl, test_cl_debug);
tcase_add_test(tc_cl, test_cl_retdbdir);
@ -683,7 +680,7 @@ static Suite *test_cl_suite(void)
suite_add_tcase(s, tc_cl_scan);
tcase_add_checked_fixture(tc_cl_scan, engine_setup, engine_teardown);
#ifdef CHECK_HAVE_LOOPS
if (get_fpu_endian() == FPU_ENDIAN_UNKNOWN)
expect--;
expect -= skip_files();
@ -708,7 +705,6 @@ static Suite *test_cl_suite(void)
} else {
printf("Using default test timeout; alter by setting 'T' env var (in seconds)\n");
}
#endif
return s;
}
@ -725,8 +721,8 @@ static void data_setup(void)
data = malloc(sizeof(le_data) * DATA_REP);
data2 = malloc(sizeof(le_data) * DATA_REP);
fail_unless(!!data, "unable to allocate memory for fixture");
fail_unless(!!data2, "unable to allocate memory for fixture");
ck_assert_msg(!!data, "unable to allocate memory for fixture");
ck_assert_msg(!!data2, "unable to allocate memory for fixture");
p = data;
/* make multiple copies of le_data, we need to run readint tests in a loop, so we need
* to give it some data to run it on */
@ -743,7 +739,6 @@ static void data_teardown(void)
free(data2);
}
#ifdef CHECK_HAVE_LOOPS
/* test reading with different alignments, _i is parameter from tcase_add_loop_test */
START_TEST(test_cli_readint16)
{
@ -752,12 +747,12 @@ START_TEST(test_cli_readint16)
/* read 2 bytes apart, start is not always aligned*/
for (j = _i; j <= DATA_REP * sizeof(le_data) - 2; j += 2) {
value = le_expected[j & 3];
fail_unless(cli_readint16(&data[j]) == value, "(1) data read must be little endian");
ck_assert_msg(cli_readint16(&data[j]) == value, "(1) data read must be little endian");
}
/* read 2 bytes apart, always aligned*/
for (j = 0; j <= DATA_REP * sizeof(le_data) - 2; j += 2) {
value = le_expected[j & 3];
fail_unless(cli_readint16(&data[j]) == value, "(2) data read must be little endian");
ck_assert_msg(cli_readint16(&data[j]) == value, "(2) data read must be little endian");
}
}
END_TEST
@ -769,12 +764,12 @@ START_TEST(test_cli_readint32)
int32_t value = le_expected[_i & 3];
/* read 4 bytes apart, start is not always aligned*/
for (j = _i; j < DATA_REP * sizeof(le_data) - 4; j += 4) {
fail_unless(cli_readint32(&data[j]) == value, "(1) data read must be little endian");
ck_assert_msg(cli_readint32(&data[j]) == value, "(1) data read must be little endian");
}
value = le_expected[0];
/* read 4 bytes apart, always aligned*/
for (j = 0; j < DATA_REP * sizeof(le_data) - 4; j += 4) {
fail_unless(cli_readint32(&data[j]) == value, "(2) data read must be little endian");
ck_assert_msg(cli_readint32(&data[j]) == value, "(2) data read must be little endian");
}
}
END_TEST
@ -788,14 +783,14 @@ START_TEST(test_cli_writeint32)
cli_writeint32(&data2[j], 0x12345678);
}
for (j = _i; j < DATA_REP * sizeof(le_data) - 4; j += 4) {
fail_unless(cli_readint32(&data2[j]) == 0x12345678, "write/read mismatch");
ck_assert_msg(cli_readint32(&data2[j]) == 0x12345678, "write/read mismatch");
}
/* write 4 bytes apart, always aligned*/
for (j = 0; j < DATA_REP * sizeof(le_data) - 4; j += 4) {
cli_writeint32(&data2[j], 0x12345678);
}
for (j = 0; j < DATA_REP * sizeof(le_data) - 4; j += 4) {
fail_unless(cli_readint32(&data2[j]) == 0x12345678, "write/read mismatch");
ck_assert_msg(cli_readint32(&data2[j]) == 0x12345678, "write/read mismatch");
}
}
END_TEST
@ -830,7 +825,7 @@ static const size_t dsig_tests_cnt = sizeof(dsig_tests) / sizeof(dsig_tests[0]);
START_TEST(test_cli_dsig)
{
fail_unless(cli_versig(dsig_tests[_i].md5, dsig_tests[_i].dsig) == dsig_tests[_i].result,
ck_assert_msg(cli_versig(dsig_tests[_i].md5, dsig_tests[_i].dsig) == dsig_tests[_i].result,
"digital signature verification test failed");
}
END_TEST
@ -868,18 +863,18 @@ START_TEST(test_sha256)
memset(buf, 0x61, sizeof(buf));
cl_sha256(tv1, sizeof(tv1), hsha256, NULL);
fail_unless(!memcmp(hsha256, res256[0], sizeof(hsha256)), "sha256 test vector #1 failed");
ck_assert_msg(!memcmp(hsha256, res256[0], sizeof(hsha256)), "sha256 test vector #1 failed");
cl_sha256(tv2, sizeof(tv2), hsha256, NULL);
fail_unless(!memcmp(hsha256, res256[1], sizeof(hsha256)), "sha256 test vector #2 failed");
ck_assert_msg(!memcmp(hsha256, res256[1], sizeof(hsha256)), "sha256 test vector #2 failed");
sha256 = cl_hash_init("sha256");
fail_unless(sha256 != NULL, "Could not create EVP_MD_CTX for sha256");
ck_assert_msg(sha256 != NULL, "Could not create EVP_MD_CTX for sha256");
for (i = 0; i < 1000; i++)
cl_update_hash(sha256, buf, sizeof(buf));
cl_finish_hash(sha256, hsha256);
fail_unless(!memcmp(hsha256, res256[2], sizeof(hsha256)), "sha256 test vector #3 failed");
ck_assert_msg(!memcmp(hsha256, res256[2], sizeof(hsha256)), "sha256 test vector #3 failed");
}
END_TEST
@ -890,90 +885,90 @@ START_TEST(test_sanitize_path)
unsanitized = "";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL != sanitized, "sanitize_path: Empty path test failed");
ck_assert_msg(NULL == sanitized, "sanitize_path: Empty path test failed");
unsanitized = NULL;
sanitized = cli_sanitize_filepath(unsanitized, 0);
fail_if(NULL != sanitized, "sanitize_path: NULL path #1 test failed");
ck_assert_msg(NULL == sanitized, "sanitize_path: NULL path #1 test failed");
unsanitized = NULL;
sanitized = cli_sanitize_filepath(unsanitized, 50);
fail_if(NULL != sanitized, "sanitize_path: NULL path #2 test failed");
ck_assert_msg(NULL == sanitized, "sanitize_path: NULL path #2 test failed");
unsanitized = "badlen";
sanitized = cli_sanitize_filepath(unsanitized, 0);
fail_if(NULL != sanitized, "sanitize_path: Zero/bad path length test failed");
ck_assert_msg(NULL == sanitized, "sanitize_path: Zero/bad path length test failed");
unsanitized = ".." PATHSEP;
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL != sanitized, "sanitize_path: sanitized path should have been NULL");
ck_assert_msg(NULL == sanitized, "sanitize_path: sanitized path should have been NULL");
unsanitized = "." PATHSEP;
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL != sanitized, "sanitize_path: sanitized path should have been NULL (2)");
ck_assert_msg(NULL == sanitized, "sanitize_path: sanitized path should have been NULL (2)");
unsanitized = PATHSEP;
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL != sanitized, "sanitize_path: sanitized path should have been NULL (3)");
ck_assert_msg(NULL == sanitized, "sanitize_path: sanitized path should have been NULL (3)");
unsanitized = ".." PATHSEP "relative_bad_1";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL == sanitized);
fail_unless(!strcmp(sanitized, "relative_bad_1"), "sanitize_path: bad relative path test #1 failed");
ck_assert(NULL != sanitized);
ck_assert_msg(!strcmp(sanitized, "relative_bad_1"), "sanitize_path: bad relative path test #1 failed");
free(sanitized);
unsanitized = "relative" PATHSEP ".." PATHSEP "good";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL == sanitized);
fail_unless(!strcmp(sanitized, "relative" PATHSEP ".." PATHSEP "good"), "sanitize_path: good relative path test failed");
ck_assert(NULL != sanitized);
ck_assert_msg(!strcmp(sanitized, "relative" PATHSEP ".." PATHSEP "good"), "sanitize_path: good relative path test failed");
free(sanitized);
unsanitized = "relative" PATHSEP ".." PATHSEP ".." PATHSEP "bad_2";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL == sanitized);
fail_unless(!strcmp(sanitized, "relative" PATHSEP ".." PATHSEP "bad_2"), "sanitize_path: bad relative path test failed");
ck_assert(NULL != sanitized);
ck_assert_msg(!strcmp(sanitized, "relative" PATHSEP ".." PATHSEP "bad_2"), "sanitize_path: bad relative path test failed");
free(sanitized);
unsanitized = "relative" PATHSEP "." PATHSEP ".." PATHSEP ".." PATHSEP "bad_current";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL == sanitized);
fail_unless(!strcmp(sanitized, "relative" PATHSEP ".." PATHSEP "bad_current"), "sanitize_path: bad relative current path test failed");
ck_assert(NULL != sanitized);
ck_assert_msg(!strcmp(sanitized, "relative" PATHSEP ".." PATHSEP "bad_current"), "sanitize_path: bad relative current path test failed");
free(sanitized);
unsanitized = "relative/../../bad_win_posix_path";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL == sanitized);
fail_unless(!strcmp(sanitized, "relative/../bad_win_posix_path"), "sanitize_path: bad relative win posix path test failed");
ck_assert(NULL != sanitized);
ck_assert_msg(!strcmp(sanitized, "relative/../bad_win_posix_path"), "sanitize_path: bad relative win posix path test failed");
free(sanitized);
unsanitized = "" PATHSEP "absolute" PATHSEP ".." PATHSEP ".." PATHSEP "bad";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL == sanitized);
fail_unless(!strcmp(sanitized, "absolute" PATHSEP ".." PATHSEP "bad"), "sanitize_path: bad absolute path test failed");
ck_assert(NULL != sanitized);
ck_assert_msg(!strcmp(sanitized, "absolute" PATHSEP ".." PATHSEP "bad"), "sanitize_path: bad absolute path test failed");
free(sanitized);
unsanitized = "" PATHSEP "absolute" PATHSEP ".." PATHSEP "good";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL == sanitized);
fail_unless(!strcmp(sanitized, "absolute" PATHSEP ".." PATHSEP "good"), "sanitize_path: good absolute path test failed");
ck_assert(NULL != sanitized);
ck_assert_msg(!strcmp(sanitized, "absolute" PATHSEP ".." PATHSEP "good"), "sanitize_path: good absolute path test failed");
free(sanitized);
unsanitized = "relative" PATHSEP "normal";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL == sanitized);
fail_unless(!strcmp(sanitized, "relative" PATHSEP "normal"), "sanitize_path: relative normal path test failed");
ck_assert(NULL != sanitized);
ck_assert_msg(!strcmp(sanitized, "relative" PATHSEP "normal"), "sanitize_path: relative normal path test failed");
free(sanitized);
unsanitized = "relative" PATHSEP PATHSEP "doublesep";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL == sanitized);
fail_unless(!strcmp(sanitized, "relative" PATHSEP "doublesep"), "sanitize_path: relative double sep path test failed");
ck_assert(NULL != sanitized);
ck_assert_msg(!strcmp(sanitized, "relative" PATHSEP "doublesep"), "sanitize_path: relative double sep path test failed");
free(sanitized);
unsanitized = "relative" PATHSEP "shortname" PATHSEP "1";
sanitized = cli_sanitize_filepath(unsanitized, strlen(unsanitized));
fail_if(NULL == sanitized);
fail_unless(!strcmp(sanitized, "relative" PATHSEP "shortname" PATHSEP "1"), "sanitize_path: relative short name path test failed");
ck_assert(NULL != sanitized);
ck_assert_msg(!strcmp(sanitized, "relative" PATHSEP "shortname" PATHSEP "1"), "sanitize_path: relative short name path test failed");
free(sanitized);
}
END_TEST
@ -1000,7 +995,6 @@ static Suite *test_cli_suite(void)
return s;
}
#endif /* CHECK_HAVE_LOOPS */
void errmsg_expected(void)
{
@ -1019,11 +1013,11 @@ int open_testfile(const char *name)
}
str = cli_malloc(strlen(name) + strlen(srcdir) + 2);
fail_unless(!!str, "cli_malloc");
ck_assert_msg(!!str, "cli_malloc");
sprintf(str, "%s/%s", srcdir, name);
fd = open(str, O_RDONLY);
fail_unless_fmt(fd >= 0, "open() failed: %s", str);
ck_assert_msg(fd >= 0, "open() failed: %s", str);
free(str);
return fd;
}
@ -1034,9 +1028,9 @@ void diff_file_mem(int fd, const char *ref, size_t len)
size_t p, reflen = len;
char *buf = cli_malloc(len);
fail_unless_fmt(!!buf, "unable to malloc buffer: %d", len);
ck_assert_msg(!!buf, "unable to malloc buffer: %d", len);
p = read(fd, buf, len);
fail_unless_fmt(p == len, "file is smaller: %lu, expected: %lu", p, len);
ck_assert_msg(p == len, "file is smaller: %lu, expected: %lu", p, len);
p = 0;
while (len > 0) {
c1 = ref[p];
@ -1047,10 +1041,10 @@ void diff_file_mem(int fd, const char *ref, size_t len)
len--;
}
if (len > 0)
fail_unless_fmt(c1 == c2, "file contents mismatch at byte: %lu, was: %c, expected: %c", p, c2, c1);
ck_assert_msg(c1 == c2, "file contents mismatch at byte: %lu, was: %c, expected: %c", p, c2, c1);
free(buf);
p = lseek(fd, 0, SEEK_END);
fail_unless_fmt(p == reflen, "trailing garbage, file size: %ld, expected: %ld", p, reflen);
ck_assert_msg(p == reflen, "trailing garbage, file size: %ld, expected: %ld", p, reflen);
close(fd);
}
@ -1059,14 +1053,14 @@ void diff_files(int fd, int ref_fd)
char *ref;
ssize_t nread;
off_t siz = lseek(ref_fd, 0, SEEK_END);
fail_unless_fmt(siz != -1, "lseek failed");
ck_assert_msg(siz != -1, "lseek failed");
ref = cli_malloc(siz);
fail_unless_fmt(!!ref, "unable to malloc buffer: %d", siz);
ck_assert_msg(!!ref, "unable to malloc buffer: %d", siz);
fail_unless_fmt(lseek(ref_fd, 0, SEEK_SET) == 0, "lseek failed");
ck_assert_msg(lseek(ref_fd, 0, SEEK_SET) == 0, "lseek failed");
nread = read(ref_fd, ref, siz);
fail_unless_fmt(nread == siz, "short read, expected: %ld, was: %ld", siz, nread);
ck_assert_msg(nread == siz, "short read, expected: %ld, was: %ld", siz, nread);
close(ref_fd);
diff_file_mem(fd, ref, siz);
free(ref);
@ -1085,10 +1079,10 @@ void dconf_setup(void)
dconf = NULL;
#ifdef USE_MPOOL
pool = mpool_create();
fail_unless(!!pool, "unable to create pool");
ck_assert_msg(!!pool, "unable to create pool");
#endif
dconf = cli_mpool_dconf_init(pool);
fail_unless(!!dconf, "failed to init dconf");
ck_assert_msg(!!dconf, "failed to init dconf");
}
void dconf_teardown(void)
@ -1135,11 +1129,8 @@ int main(void)
check_version_compatible();
s = test_cl_suite();
sr = srunner_create(s);
#ifdef CHECK_HAVE_LOOPS
srunner_add_suite(sr, test_cli_suite());
#else
printf("*** Warning ***: your check version is too old,\nseveral important tests will not execute\n");
#endif
srunner_add_suite(sr, test_jsnorm_suite());
srunner_add_suite(sr, test_str_suite());
srunner_add_suite(sr, test_regex_suite());

146
unit_tests/check_clamd.c
Unescape View File

@ -53,7 +53,6 @@
#include "libclamav/clamav.h"
#include "libclamav/version.h"
#ifdef CHECK_HAVE_LOOPS
static int sockd;
#define SOCKET "clamd-test.socket"
@ -68,10 +67,10 @@ static void conn_setup_mayfail(int may)
sockd = socket(AF_UNIX, SOCK_STREAM, 0);
if (sockd == -1 && (may && (errno == EMFILE || errno == ENFILE)))
return;
fail_unless_fmt(sockd != -1, "Unable to create socket: %s\n", strerror(errno));
ck_assert_msg(sockd != -1, "Unable to create socket: %s\n", strerror(errno));
rc = connect(sockd, (struct sockaddr *)&nixsock, (socklen_t)sizeof(nixsock));
fail_unless_fmt(rc != -1, "Unable to connect(): %s\n", strerror(errno));
ck_assert_msg(rc != -1, "Unable to connect(): %s\n", strerror(errno));
signal(SIGPIPE, SIG_IGN);
}
@ -86,7 +85,7 @@ static int conn_tcp(int port)
struct sockaddr_in server;
int rc;
int sd = socket(AF_INET, SOCK_STREAM, 0);
fail_unless_fmt(sd != -1, "Unable to create socket: %s\n", strerror(errno));
ck_assert_msg(sd != -1, "Unable to create socket: %s\n", strerror(errno));
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
@ -94,7 +93,7 @@ static int conn_tcp(int port)
server.sin_addr.s_addr = inet_addr("127.0.0.1");
rc = connect(sd, (struct sockaddr *)&server, (socklen_t)sizeof(server));
fail_unless_fmt(rc != -1, "Unable to connect(): %s\n", strerror(errno));
ck_assert_msg(rc != -1, "Unable to connect(): %s\n", strerror(errno));
return sd;
}
@ -128,16 +127,16 @@ static void commands_setup(void)
const char *nonempty = "NONEMPTYFILE";
int fd = open(NONEXISTENT, O_RDONLY);
if (fd != -1) close(fd);
fail_unless(fd == -1, "Nonexistent file exists!\n");
ck_assert_msg(fd == -1, "Nonexistent file exists!\n");
fd = open(ACCDENIED, O_CREAT | O_WRONLY, S_IWUSR);
fail_unless_fmt(fd != -1,
ck_assert_msg(fd != -1,
"Failed to create file for access denied tests: %s\n", strerror(errno));
fail_unless_fmt(fchmod(fd, S_IWUSR) != -1,
ck_assert_msg(fchmod(fd, S_IWUSR) != -1,
"Failed to chmod: %s\n", strerror(errno));
/* must not be empty file */
fail_unless_fmt((size_t)write(fd, nonempty, strlen(nonempty)) == strlen(nonempty),
ck_assert_msg((size_t)write(fd, nonempty, strlen(nonempty)) == strlen(nonempty),
"Failed to write into testfile: %s\n", strerror(errno));
close(fd);
@ -213,10 +212,10 @@ static void *recvpartial(int sd, size_t *len, int partial)
if (off + BUFSIZ > *len) {
*len += BUFSIZ + 1;
buf = realloc(buf, *len);
fail_unless(!!buf, "Cannot realloc buffer\n");
ck_assert_msg(!!buf, "Cannot realloc buffer\n");
}
rc = recv(sd, buf + off, BUFSIZ, 0);
fail_unless_fmt(rc != -1, "recv() failed: %s\n", strerror(errno));
ck_assert_msg(rc != -1, "recv() failed: %s\n", strerror(errno));
off += rc;
} while (rc && (!partial || !memchr(buf, '\0', off)));
*len = off;
@ -235,24 +234,23 @@ static void test_command(const char *cmd, size_t len, const char *extra, const c
ssize_t rc;
rc = send(sockd, cmd, len, 0);
fail_unless_fmt((size_t)rc == len, "Unable to send(): %s\n", strerror(errno));
ck_assert_msg((size_t)rc == len, "Unable to send(): %s\n", strerror(errno));
if (extra) {
rc = send(sockd, extra, strlen(extra), 0);
fail_unless_fmt((size_t)rc == strlen(extra), "Unable to send() extra for %s: %s\n", cmd, strerror(errno));
ck_assert_msg((size_t)rc == strlen(extra), "Unable to send() extra for %s: %s\n", cmd, strerror(errno));
}
shutdown(sockd, SHUT_WR);
recvdata = recvfull(sockd, &len);
fail_unless_fmt(len == expect_len, "Reply has wrong size: %lu, expected %lu, reply: %s, expected: %s\n",
ck_assert_msg(len == expect_len, "Reply has wrong size: %lu, expected %lu, reply: %s, expected: %s\n",
len, expect_len, recvdata, expect);
rc = memcmp(recvdata, expect, expect_len);
fail_unless_fmt(!rc, "Wrong reply for command %s: |%s|, expected: |%s|\n", cmd, recvdata, expect);
ck_assert_msg(!rc, "Wrong reply for command %s: |%s|, expected: |%s|\n", cmd, recvdata, expect);
free(recvdata);
}
#ifdef CHECK_HAVE_LOOPS
START_TEST(test_basic_commands)
{
struct basic_test *test = &basic_tests[_i];
@ -314,7 +312,6 @@ START_TEST(test_compat_commands)
}
}
END_TEST
#endif
#define EXPECT_INSTREAM "stream: ClamAV-Test-File.UNOFFICIAL FOUND\n"
#define EXPECT_INSTREAM0 "stream: ClamAV-Test-File.UNOFFICIAL FOUND"
@ -328,18 +325,18 @@ START_TEST(test_stats)
conn_setup();
rc = send(sockd, "nSTATS\n", len, 0);
fail_unless_fmt((size_t)rc == len, "Unable to send(): %s\n", strerror(errno));
ck_assert_msg((size_t)rc == len, "Unable to send(): %s\n", strerror(errno));
recvdata = recvfull(sockd, &len);
fail_unless_fmt(len > strlen(STATS_REPLY), "Reply has wrong size: %lu, minimum %lu, reply: %s\n",
ck_assert_msg(len > strlen(STATS_REPLY), "Reply has wrong size: %lu, minimum %lu, reply: %s\n",
len, strlen(STATS_REPLY), recvdata);
if (len > strlen(STATS_REPLY))
len = strlen(STATS_REPLY);
rc = strncmp(recvdata, STATS_REPLY, len);
fail_unless_fmt(rc == 0, "Wrong reply: %s\n", recvdata);
ck_assert_msg(rc == 0, "Wrong reply: %s\n", recvdata);
free(recvdata);
conn_teardown();
}
@ -350,16 +347,16 @@ static size_t prepare_instream(char *buf, size_t off, size_t buflen)
STATBUF stbuf;
int fd, nread;
uint32_t chunk;
fail_unless_fmt(CLAMSTAT(SCANFILE, &stbuf) != -1, "stat failed for %s: %s", SCANFILE, strerror(errno));
ck_assert_msg(CLAMSTAT(SCANFILE, &stbuf) != -1, "stat failed for %s: %s", SCANFILE, strerror(errno));
fd = open(SCANFILE, O_RDONLY);
fail_unless_fmt(fd != -1, "open failed: %s\n", strerror(errno));
ck_assert_msg(fd != -1, "open failed: %s\n", strerror(errno));
chunk = htonl(stbuf.st_size);
memcpy(&buf[off], &chunk, sizeof(chunk));
off += 4;
nread = read(fd, &buf[off], buflen - off - 4);
fail_unless_fmt(nread == stbuf.st_size, "read failed: %d != %d, %s\n", nread, stbuf.st_size, strerror(errno));
ck_assert_msg(nread == stbuf.st_size, "read failed: %d != %d, %s\n", nread, stbuf.st_size, strerror(errno));
off += nread;
buf[off++] = 0;
buf[off++] = 0;
@ -380,16 +377,16 @@ START_TEST(test_instream)
off = prepare_instream(buf, off, sizeof(buf));
conn_setup();
fail_unless((size_t)send(sockd, buf, off, 0) == off, "send() failed: %s\n", strerror(errno));
ck_assert_msg((size_t)send(sockd, buf, off, 0) == off, "send() failed: %s\n", strerror(errno));
recvdata = recvfull(sockd, &len);
expect_len = strlen(EXPECT_INSTREAM);
fail_unless_fmt(len == expect_len, "Reply has wrong size: %lu, expected %lu, reply: %s\n",
ck_assert_msg(len == expect_len, "Reply has wrong size: %lu, expected %lu, reply: %s\n",
len, expect_len, recvdata);
rc = memcmp(recvdata, EXPECT_INSTREAM, expect_len);
fail_unless_fmt(!rc, "Wrong reply for command INSTREAM: |%s|, expected: |%s|\n", recvdata, EXPECT_INSTREAM);
ck_assert_msg(!rc, "Wrong reply for command INSTREAM: |%s|, expected: |%s|\n", recvdata, EXPECT_INSTREAM);
free(recvdata);
conn_teardown();
@ -412,7 +409,7 @@ static int sendmsg_fd(int sockd, const char *mesg, size_t msg_len, int fd, int s
iov[0].iov_len = 1;
} else {
/* send single message with ancillary data */
fail_unless(msg_len < sizeof(dummy) - 1, "message too large");
ck_assert_msg(msg_len < sizeof(dummy) - 1, "message too large");
memcpy(dummy, mesg, msg_len);
dummy[msg_len] = '\0';
iov[0].iov_base = dummy;
@ -447,7 +444,7 @@ static void tst_fildes(const char *cmd, size_t len, int fd,
int rc;
conn_setup();
fail_unless_fmt(sendmsg_fd(sockd, cmd, len, fd, singlemsg) != -1,
ck_assert_msg(sendmsg_fd(sockd, cmd, len, fd, singlemsg) != -1,
"Failed to sendmsg: %s\n", strerror(errno));
if (closefd)
@ -456,17 +453,17 @@ static void tst_fildes(const char *cmd, size_t len, int fd,
recvdata = recvfull(sockd, &len);
p = strchr(recvdata, ':');
fail_unless_fmt(!!p, "Reply doesn't contain ':' : %s\n", recvdata);
ck_assert_msg(!!p, "Reply doesn't contain ':' : %s\n", recvdata);
*p++ = '\0';
fail_unless_fmt(sscanf(recvdata, "fd[%u]", &rc) == 1, "Reply doesn't contain fd: %s\n", recvdata);
ck_assert_msg(sscanf(recvdata, "fd[%u]", &rc) == 1, "Reply doesn't contain fd: %s\n", recvdata);
len -= p - recvdata;
fail_unless_fmt(len == expect_len, "Reply has wrong size: %lu, expected %lu, reply: %s, expected: %s\n",
ck_assert_msg(len == expect_len, "Reply has wrong size: %lu, expected %lu, reply: %s, expected: %s\n",
len, expect_len, p, expect);
rc = memcmp(p, expect, expect_len);
fail_unless_fmt(!rc, "Wrong reply for command %s: |%s|, expected: |%s|\n", cmd, p, expect);
ck_assert_msg(!rc, "Wrong reply for command %s: |%s|, expected: |%s|\n", cmd, p, expect);
free(recvdata);
conn_teardown();
}
@ -488,7 +485,6 @@ static struct cmds {
{"nFILDES", '\n', CLEANFILE, CLEANFDREPLY},
{"zFILDES", '\0', CLEANFILE, CLEANFDREPLY}};
#ifdef CHECK_HAVE_LOOPS
START_TEST(test_fildes)
{
char nreply[BUFSIZ], nsend[BUFSIZ];
@ -522,7 +518,7 @@ START_TEST(test_fildes)
nsend_len = snprintf(nsend, sizeof(nsend), "%s%c", cmd->cmd, cmd->term);
fd = open(cmd->file, O_RDONLY);
fail_unless_fmt(fd != -1, "Failed to open: %s\n", strerror(errno));
ck_assert_msg(fd != -1, "Failed to open: %s\n", strerror(errno));
tst_fildes(nsend, nsend_len, fd, nreply, nreply_len, closefd, singlemsg);
@ -534,7 +530,6 @@ START_TEST(test_fildes)
}
}
END_TEST
#endif
START_TEST(test_fildes_many)
{
@ -542,9 +537,9 @@ START_TEST(test_fildes_many)
int dummyfd, i, killed = 0;
conn_setup();
dummyfd = open(SCANFILE, O_RDONLY);
fail_unless_fmt(dummyfd != -1, "failed to open %s: %s\n", SCANFILE, strerror(errno));
ck_assert_msg(dummyfd != -1, "failed to open %s: %s\n", SCANFILE, strerror(errno));
fail_unless_fmt(send(sockd, idsession, sizeof(idsession), 0) == sizeof(idsession), "send IDSESSION failed\n");
ck_assert_msg(send(sockd, idsession, sizeof(idsession), 0) == sizeof(idsession), "send IDSESSION failed\n");
for (i = 0; i < 1024; i++) {
if (sendmsg_fd(sockd, "zFILDES", sizeof("zFILDES"), dummyfd, 1) == -1) {
killed = 1;
@ -573,12 +568,12 @@ START_TEST(test_fildes_unwanted)
/* send a 'zVERSION\0' including the ancillary data.
* The \0 is from the extra char needed when sending ancillary data */
fail_unless_fmt(sendmsg_fd(sockd, "zIDSESSION", strlen("zIDSESSION"), dummyfd, 1) != -1,
ck_assert_msg(sendmsg_fd(sockd, "zIDSESSION", strlen("zIDSESSION"), dummyfd, 1) != -1,
"sendmsg failed: %s\n", strerror(errno));
recvdata = recvfull(sockd, &len);
fail_unless_fmt(!strcmp(recvdata, "1: PROTOCOL ERROR: ancillary data sent without FILDES. ERROR"),
ck_assert_msg(!strcmp(recvdata, "1: PROTOCOL ERROR: ancillary data sent without FILDES. ERROR"),
"Wrong reply: %s\n", recvdata);
free(recvdata);
@ -596,21 +591,21 @@ START_TEST(test_idsession_stress)
conn_setup();
fail_unless_fmt(send(sockd, "zIDSESSION", sizeof("zIDSESSION"), 0) == sizeof("zIDSESSION"),
ck_assert_msg(send(sockd, "zIDSESSION", sizeof("zIDSESSION"), 0) == sizeof("zIDSESSION"),
"send() failed: %s\n", strerror(errno));
for (i = 0; i < 1024; i++) {
snprintf(buf, sizeof(buf), "%u", (unsigned)(i + 1));
fail_unless(send(sockd, "zVERSION", sizeof("zVERSION"), 0) == sizeof("zVERSION"),
ck_assert_msg(send(sockd, "zVERSION", sizeof("zVERSION"), 0) == sizeof("zVERSION"),
"send failed: %s\n", strerror(errno));
data = recvpartial(sockd, &len, 1);
p = strchr(data, ':');
fail_unless_fmt(!!p, "wrong VERSION reply (%u): %s\n", i, data);
ck_assert_msg(!!p, "wrong VERSION reply (%u): %s\n", i, data);
*p++ = '\0';
fail_unless_fmt(*p == ' ', "wrong VERSION reply (%u): %s\n", i, p);
ck_assert_msg(*p == ' ', "wrong VERSION reply (%u): %s\n", i, p);
*p++ = '\0';
fail_unless_fmt(!strcmp(p, VERSION_REPLY), "wrong VERSION reply: %s\n", data);
fail_unless_fmt(!strcmp(data, buf), "wrong IDSESSION id: %s\n", data);
ck_assert_msg(!strcmp(p, VERSION_REPLY), "wrong VERSION reply: %s\n", data);
ck_assert_msg(!strcmp(data, buf), "wrong IDSESSION id: %s\n", data);
free(data);
}
@ -628,12 +623,12 @@ START_TEST(test_connections)
struct rlimit rlim;
int *sock;
int nf, maxfd = 0;
fail_unless_fmt(getrlimit(RLIMIT_NOFILE, &rlim) != -1,
ck_assert_msg(getrlimit(RLIMIT_NOFILE, &rlim) != -1,
"Failed to get RLIMIT_NOFILE: %s\n", strerror(errno));
nf = rlim.rlim_cur - 5;
sock = malloc(sizeof(int) * nf);
fail_unless(!!sock, "malloc failed\n");
ck_assert_msg(!!sock, "malloc failed\n");
for (i = 0; i < nf; i++) {
/* just open connections, and let them time out */
@ -647,7 +642,7 @@ START_TEST(test_connections)
maxfd = sockd;
}
rc = fork();
fail_unless(rc != -1, "fork() failed: %s\n", strerror(errno));
ck_assert_msg(rc != -1, "fork() failed: %s\n", strerror(errno));
if (rc == 0) {
char dummy;
int ret;
@ -696,13 +691,13 @@ START_TEST(test_stream)
infd = open(SCANFILE, O_RDONLY);
fail_unless_fmt(infd != -1, "open failed: %s\n", strerror(errno));
ck_assert_msg(infd != -1, "open failed: %s\n", strerror(errno));
conn_setup();
fail_unless_fmt(
ck_assert_msg(
send(sockd, "zSTREAM", sizeof("zSTREAM"), 0) == sizeof("zSTREAM"),
"send failed: %s\n", strerror(errno));
recvdata = recvpartial(sockd, &len, 1);
fail_unless_fmt(sscanf(recvdata, "PORT %u\n", &port) == 1,
ck_assert_msg(sscanf(recvdata, "PORT %u\n", &port) == 1,
"Wrong stream reply: %s\n", recvdata);
free(recvdata);
@ -711,15 +706,15 @@ START_TEST(test_stream)
do {
nread = read(infd, buf, sizeof(buf));
if (nread > 0)
fail_unless_fmt(send(streamsd, buf, nread, 0) == nread,
ck_assert_msg(send(streamsd, buf, nread, 0) == nread,
"send failed: %s\n", strerror(errno));
} while (nread > 0 || (nread == -1 && errno == EINTR));
fail_unless_fmt(nread != -1, "read failed: %s\n", strerror(errno));
ck_assert_msg(nread != -1, "read failed: %s\n", strerror(errno));
close(infd);
close(streamsd);
recvdata = recvfull(sockd, &len);
fail_unless_fmt(!strcmp(recvdata, "stream: ClamAV-Test-File.UNOFFICIAL FOUND"),
ck_assert_msg(!strcmp(recvdata, "stream: ClamAV-Test-File.UNOFFICIAL FOUND"),
"Wrong reply: %s\n", recvdata);
free(recvdata);
@ -743,13 +738,13 @@ static void test_idsession_commands(int split, int instream)
if (test->skiproot && isroot)
continue;
if (test->ids == IDS_OK) {
fail_unless(p + strlen(test->command) + 2 < buf + sizeof(buf), "Buffer too small");
ck_assert_msg(p + strlen(test->command) + 2 < buf + sizeof(buf), "Buffer too small");
*p++ = 'z';
strcpy(p, test->command);
p += strlen(test->command);
*p++ = '\0';
if (test->extra) {
fail_unless(p + strlen(test->extra) < buf + sizeof(buf), "Buffer too small");
ck_assert_msg(p + strlen(test->extra) < buf + sizeof(buf), "Buffer too small");
strcpy(p, test->extra);
p += strlen(test->extra);
}
@ -759,12 +754,12 @@ static void test_idsession_commands(int split, int instream)
uint32_t chunk;
/* IDS_END - in middle of other commands, perfect for inserting
* INSTREAM */
fail_unless(p + sizeof(INSTREAM_CMD) + 544 < buf + sizeof(buf), "Buffer too small");
ck_assert_msg(p + sizeof(INSTREAM_CMD) + 544 < buf + sizeof(buf), "Buffer too small");
memcpy(p, INSTREAM_CMD, sizeof(INSTREAM_CMD));
p += sizeof(INSTREAM_CMD);
p += prepare_instream(p, 0, 552);
replies[j++] = EXPECT_INSTREAM0;
fail_unless(p + sizeof(INSTREAM_CMD) + 16388 < buf + sizeof(buf), "Buffer too small");
ck_assert_msg(p + sizeof(INSTREAM_CMD) + 16388 < buf + sizeof(buf), "Buffer too small");
memcpy(p, INSTREAM_CMD, sizeof(INSTREAM_CMD));
p += sizeof(INSTREAM_CMD);
chunk = htonl(16384);
@ -779,16 +774,16 @@ static void test_idsession_commands(int split, int instream)
replies[j++] = "stream: OK";
}
}
fail_unless(p + sizeof(END_CMD) < buf + sizeof(buf), "Buffer too small");
ck_assert_msg(p + sizeof(END_CMD) < buf + sizeof(buf), "Buffer too small");
memcpy(p, END_CMD, sizeof(END_CMD));
p += sizeof(END_CMD);
if (split) {
/* test corner-cases: 1-byte sends */
for (i = 0; i < (size_t)(p - buf); i++)
fail_unless((size_t)send(sockd, &buf[i], 1, 0) == 1, "send() failed: %u, %s\n", i, strerror(errno));
ck_assert_msg((size_t)send(sockd, &buf[i], 1, 0) == 1, "send() failed: %u, %s\n", i, strerror(errno));
} else {
fail_unless(send(sockd, buf, p - buf, 0) == p - buf, "send() failed: %s\n", strerror(errno));
ck_assert_msg(send(sockd, buf, p - buf, 0) == p - buf, "send() failed: %s\n", strerror(errno));
}
recvdata = recvfull(sockd, &len);
p = recvdata;
@ -799,13 +794,13 @@ static void test_idsession_commands(int split, int instream)
if (test->ids == IDS_OK) {
unsigned id;
char *q = strchr(p, ':');
fail_unless_fmt(!!q, "No ID in reply: %s\n", p);
ck_assert_msg(!!q, "No ID in reply: %s\n", p);
*q = '\0';
fail_unless_fmt(sscanf(p, "%u", &id) == 1, "Wrong ID in reply: %s\n", p);
fail_unless(id > 0, "ID cannot be zero");
fail_unless_fmt(id <= j, "ID too big: %u, max: %u\n", id, j);
ck_assert_msg(sscanf(p, "%u", &id) == 1, "Wrong ID in reply: %s\n", p);
ck_assert_msg(id > 0, "ID cannot be zero");
ck_assert_msg(id <= j, "ID too big: %u, max: %u\n", id, j);
q += 2;
fail_unless_fmt(!strcmp(q, replies[id - 1]),
ck_assert_msg(!strcmp(q, replies[id - 1]),
"Wrong ID reply for ID %u: %s, expected %s\n",
id,
q, replies[id - 1]);
@ -820,15 +815,15 @@ static void test_idsession_commands(int split, int instream)
START_TEST(test_idsession)
{
conn_setup();
fail_unless_fmt((size_t)send(sockd, ID_CMD, sizeof(ID_CMD), 0) == sizeof(ID_CMD),
ck_assert_msg((size_t)send(sockd, ID_CMD, sizeof(ID_CMD), 0) == sizeof(ID_CMD),
"send() failed: %s\n", strerror(errno));
test_idsession_commands(0, 0);
conn_setup();
fail_unless_fmt((size_t)send(sockd, ID_CMD, sizeof(ID_CMD), 0) == sizeof(ID_CMD),
ck_assert_msg((size_t)send(sockd, ID_CMD, sizeof(ID_CMD), 0) == sizeof(ID_CMD),
"send() failed: %s\n", strerror(errno));
test_idsession_commands(1, 0);
conn_setup();
fail_unless_fmt((size_t)send(sockd, ID_CMD, sizeof(ID_CMD), 0) == sizeof(ID_CMD),
ck_assert_msg((size_t)send(sockd, ID_CMD, sizeof(ID_CMD), 0) == sizeof(ID_CMD),
"send() failed: %s\n", strerror(errno));
test_idsession_commands(0, 1);
}
@ -841,11 +836,11 @@ static Suite *test_clamd_suite(void)
tc_commands = tcase_create("clamd commands");
suite_add_tcase(s, tc_commands);
tcase_add_unchecked_fixture(tc_commands, commands_setup, commands_teardown);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_commands, test_basic_commands, 0, sizeof(basic_tests) / sizeof(basic_tests[0]));
tcase_add_loop_test(tc_commands, test_compat_commands, 0, sizeof(basic_tests) / sizeof(basic_tests[0]));
tcase_add_loop_test(tc_commands, test_fildes, 0, 4 * sizeof(fildes_cmds) / sizeof(fildes_cmds[0]));
#endif
tcase_add_test(tc_commands, test_stats);
tcase_add_test(tc_commands, test_instream);
tcase_add_test(tc_commands, test_stream);
@ -877,12 +872,3 @@ int main(void)
srunner_free(sr);
return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
#else
int main(void)
{
puts("\n*** Check version too old, clamd tests not run!\n");
/* tell automake the test was skipped */
return 77;
}
#endif

14
unit_tests/check_disasm.c
Unescape View File

@ -211,20 +211,20 @@ START_TEST(test_disasm_basic)
off_t size;
STATBUF st;
fail_unless(fd != -1, "mkstemp failed");
ck_assert_msg(fd != -1, "mkstemp failed");
ref = open_testfile("input/disasmref.bin");
fail_unless(FSTAT(ref, &st) != -1, "fstat failed");
ck_assert_msg(FSTAT(ref, &st) != -1, "fstat failed");
disasmbuf(buf, sizeof(buf), fd);
size = lseek(fd, 0, SEEK_CUR);
fail_unless_fmt(size == st.st_size, "disasm size mismatch(value %u, expected: %u)", size, st.st_size);
ck_assert_msg(size == st.st_size, "disasm size mismatch(value %u, expected: %u)", size, st.st_size);
lseek(fd, 0, SEEK_SET);
d = malloc(size * 2);
fail_unless_fmt(d != NULL, "disasm malloc(%u) failed", size);
fail_unless(read(ref, d, size) == size, "disasm reference read failed");
fail_unless(read(fd, d + size, size) == size, "disasm read failed");
ck_assert_msg(d != NULL, "disasm malloc(%u) failed", size);
ck_assert_msg(read(ref, d, size) == size, "disasm reference read failed");
ck_assert_msg(read(fd, d + size, size) == size, "disasm read failed");
close(fd);
close(ref);
fail_unless(!memcmp(d, d + size, size), "disasm data doesn't match the reference");
ck_assert_msg(!memcmp(d, d + size, size), "disasm data doesn't match the reference");
free(d);
unlink(file);
}

51
unit_tests/check_htmlnorm.c
Unescape View File

@ -39,7 +39,7 @@ static void htmlnorm_setup(void)
cl_init(CL_INIT_DEFAULT);
dconf_setup();
dir = cli_gentemp(NULL);
fail_unless(!!dir, "cli_gentemp failed");
ck_assert_msg(!!dir, "cli_gentemp failed");
}
static void htmlnorm_teardown(void)
@ -64,8 +64,6 @@ static struct test {
{"input/htmlnorm_test.html", "test.nocomment.ref", "test.notags.ref", NULL},
{"input/htmlnorm_urls.html", "urls.nocomment.ref", "urls.notags.ref", NULL}};
#ifdef CHECK_HAVE_LOOPS
static void check_dir(const char *dire, const struct test *test)
{
char filename[4096];
@ -74,7 +72,7 @@ static void check_dir(const char *dire, const struct test *test)
if (test->nocommentref) {
snprintf(filename, sizeof(filename), "%s/nocomment.html", dire);
fd = open(filename, O_RDONLY);
fail_unless(fd > 0, "unable to open: %s", filename);
ck_assert_msg(fd > 0, "unable to open: %s", filename);
reffd = open_testfile(test->nocommentref);
diff_files(fd, reffd);
@ -85,7 +83,7 @@ static void check_dir(const char *dire, const struct test *test)
if (test->notagsref) {
snprintf(filename, sizeof(filename), "%s/notags.html", dire);
fd = open(filename, O_RDONLY);
fail_unless(fd > 0, "unable to open: %s", filename);
ck_assert_msg(fd > 0, "unable to open: %s", filename);
reffd = open_testfile(test->notagsref);
diff_files(fd, reffd);
@ -96,7 +94,7 @@ static void check_dir(const char *dire, const struct test *test)
if (test->jsref) {
snprintf(filename, sizeof(filename), "%s/javascript", dire);
fd = open(filename, O_RDONLY);
fail_unless(fd > 0, "unable to open: %s", filename);
ck_assert_msg(fd > 0, "unable to open: %s", filename);
reffd = open_testfile(test->jsref);
diff_files(fd, reffd);
@ -115,30 +113,30 @@ START_TEST(test_htmlnorm_api)
memset(&hrefs, 0, sizeof(hrefs));
fd = open_testfile(tests[_i].input);
fail_unless(fd > 0, "open_testfile failed");
ck_assert_msg(fd > 0, "open_testfile failed");
map = fmap(fd, 0, 0);
fail_unless(!!map, "fmap failed");
ck_assert_msg(!!map, "fmap failed");
fail_unless(mkdir(dir, 0700) == 0, "mkdir failed");
fail_unless(html_normalise_map(map, dir, NULL, dconf) == 1, "html_normalise_map failed");
ck_assert_msg(mkdir(dir, 0700) == 0, "mkdir failed");
ck_assert_msg(html_normalise_map(map, dir, NULL, dconf) == 1, "html_normalise_map failed");
check_dir(dir, &tests[_i]);
fail_unless(cli_rmdirs(dir) == 0, "rmdirs failed");
ck_assert_msg(cli_rmdirs(dir) == 0, "rmdirs failed");
fail_unless(mkdir(dir, 0700) == 0, "mkdir failed");
fail_unless(html_normalise_map(map, dir, NULL, NULL) == 1, "html_normalise_map failed");
fail_unless(cli_rmdirs(dir) == 0, "rmdirs failed");
ck_assert_msg(mkdir(dir, 0700) == 0, "mkdir failed");
ck_assert_msg(html_normalise_map(map, dir, NULL, NULL) == 1, "html_normalise_map failed");
ck_assert_msg(cli_rmdirs(dir) == 0, "rmdirs failed");
fail_unless(mkdir(dir, 0700) == 0, "mkdir failed");
fail_unless(html_normalise_map(map, dir, &hrefs, dconf) == 1, "html_normalise_map failed");
fail_unless(cli_rmdirs(dir) == 0, "rmdirs failed");
ck_assert_msg(mkdir(dir, 0700) == 0, "mkdir failed");
ck_assert_msg(html_normalise_map(map, dir, &hrefs, dconf) == 1, "html_normalise_map failed");
ck_assert_msg(cli_rmdirs(dir) == 0, "rmdirs failed");
html_tag_arg_free(&hrefs);
memset(&hrefs, 0, sizeof(hrefs));
hrefs.scanContents = 1;
fail_unless(mkdir(dir, 0700) == 0, "mkdir failed");
fail_unless(html_normalise_map(map, dir, &hrefs, dconf) == 1, "html_normalise_map failed");
fail_unless(cli_rmdirs(dir) == 0, "rmdirs failed");
ck_assert_msg(mkdir(dir, 0700) == 0, "mkdir failed");
ck_assert_msg(html_normalise_map(map, dir, &hrefs, dconf) == 1, "html_normalise_map failed");
ck_assert_msg(cli_rmdirs(dir) == 0, "rmdirs failed");
html_tag_arg_free(&hrefs);
funmap(map);
@ -146,19 +144,18 @@ START_TEST(test_htmlnorm_api)
close(fd);
}
END_TEST
#endif
START_TEST(test_screnc_nullterminate)
{
int fd = open_testfile("input/screnc_test");
fmap_t *map;
fail_unless(mkdir(dir, 0700) == 0, "mkdir failed");
ck_assert_msg(mkdir(dir, 0700) == 0, "mkdir failed");
map = fmap(fd, 0, 0);
fail_unless(!!map, "fmap failed");
fail_unless(html_screnc_decode(map, dir) == 1, "html_screnc_decode failed");
ck_assert_msg(!!map, "fmap failed");
ck_assert_msg(html_screnc_decode(map, dir) == 1, "html_screnc_decode failed");
funmap(map);
fail_unless(cli_rmdirs(dir) == 0, "rmdirs failed");
ck_assert_msg(cli_rmdirs(dir) == 0, "rmdirs failed");
close(fd);
}
END_TEST
@ -170,9 +167,9 @@ Suite *test_htmlnorm_suite(void)
tc_htmlnorm_api = tcase_create("htmlnorm api");
suite_add_tcase(s, tc_htmlnorm_api);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_htmlnorm_api, test_htmlnorm_api, 0, sizeof(tests) / sizeof(tests[0]));
#endif
tcase_add_unchecked_fixture(tc_htmlnorm_api,
htmlnorm_setup, htmlnorm_teardown);
tcase_add_test(tc_htmlnorm_api, test_screnc_nullterminate);

90
unit_tests/check_jsnorm.c
Unescape View File

@ -61,14 +61,13 @@ static struct test op_test[] = {
{"-", 1},
{"---", 0}};
#ifdef CHECK_HAVE_LOOPS
START_TEST(test_keywords)
{
const struct keyword *kw = in_word_set(kw_test[_i].str, strlen(kw_test[_i].str));
if (kw_test[_i].is) {
fail_unless(kw && !strcmp(kw->name, kw_test[_i].str), "keyword mismatch");
ck_assert_msg(kw && !strcmp(kw->name, kw_test[_i].str), "keyword mismatch");
} else {
fail_unless(!kw, "non-keyword detected as keyword");
ck_assert_msg(!kw, "non-keyword detected as keyword");
}
}
END_TEST
@ -77,12 +76,11 @@ START_TEST(test_operators)
{
const struct operator*op = in_op_set(op_test[_i].str, strlen(op_test[_i].str));
if (op_test[_i].is)
fail_unless(op && !strcmp(op->name, op_test[_i].str), "operator mismatch");
ck_assert_msg(op && !strcmp(op->name, op_test[_i].str), "operator mismatch");
else
fail_unless(!op, "non-operator detected as operator");
ck_assert_msg(!op, "non-operator detected as operator");
}
END_TEST
#endif /* CHECK_HAVE_LOOPS */
START_TEST(test_token_string)
{
@ -91,10 +89,10 @@ START_TEST(test_token_string)
memset(&tok, 0, sizeof(tok));
TOKEN_SET(&tok, string, str);
fail_unless(TOKEN_GET(&tok, string) == str, "token string get/set");
fail_unless(TOKEN_GET(&tok, cstring) == str, "token string->cstring");
fail_unless(TOKEN_GET(&tok, scope) == NULL, "token string->scope");
fail_unless(TOKEN_GET(&tok, ival) == -1, "token string->ival");
ck_assert_msg(TOKEN_GET(&tok, string) == str, "token string get/set");
ck_assert_msg(TOKEN_GET(&tok, cstring) == str, "token string->cstring");
ck_assert_msg(TOKEN_GET(&tok, scope) == NULL, "token string->scope");
ck_assert_msg(TOKEN_GET(&tok, ival) == -1, "token string->ival");
}
END_TEST
@ -105,10 +103,10 @@ START_TEST(test_token_cstring)
memset(&tok, 0, sizeof(tok));
TOKEN_SET(&tok, cstring, str);
fail_unless(TOKEN_GET(&tok, string) == NULL, "token cstring->string");
fail_unless(TOKEN_GET(&tok, cstring) == str, "token string->cstring");
fail_unless(TOKEN_GET(&tok, scope) == NULL, "token string->scope");
fail_unless(TOKEN_GET(&tok, ival) == -1, "token string->ival");
ck_assert_msg(TOKEN_GET(&tok, string) == NULL, "token cstring->string");
ck_assert_msg(TOKEN_GET(&tok, cstring) == str, "token string->cstring");
ck_assert_msg(TOKEN_GET(&tok, scope) == NULL, "token string->scope");
ck_assert_msg(TOKEN_GET(&tok, ival) == -1, "token string->ival");
}
END_TEST
@ -119,10 +117,10 @@ START_TEST(test_token_scope)
memset(&tok, 0, sizeof(tok));
TOKEN_SET(&tok, scope, sc);
fail_unless(TOKEN_GET(&tok, string) == NULL, "token scope->string");
fail_unless(TOKEN_GET(&tok, cstring) == NULL, "token scope->cstring");
fail_unless(TOKEN_GET(&tok, scope) == sc, "token scope->scope");
fail_unless(TOKEN_GET(&tok, ival) == -1, "token scope->ival");
ck_assert_msg(TOKEN_GET(&tok, string) == NULL, "token scope->string");
ck_assert_msg(TOKEN_GET(&tok, cstring) == NULL, "token scope->cstring");
ck_assert_msg(TOKEN_GET(&tok, scope) == sc, "token scope->scope");
ck_assert_msg(TOKEN_GET(&tok, ival) == -1, "token scope->ival");
}
END_TEST
@ -133,11 +131,11 @@ START_TEST(test_token_ival)
memset(&tok, 0, sizeof(tok));
TOKEN_SET(&tok, ival, val);
fail_unless(TOKEN_GET(&tok, string) == NULL, "token ival->string");
fail_unless(TOKEN_GET(&tok, cstring) == NULL, "token ival->cstring");
fail_unless(TOKEN_GET(&tok, scope) == NULL, "token ival->scope");
fail_unless(TOKEN_GET(&tok, dval) - -1 < 1e-9, "token ival->dval");
fail_unless(TOKEN_GET(&tok, ival) == val, "token ival->ival");
ck_assert_msg(TOKEN_GET(&tok, string) == NULL, "token ival->string");
ck_assert_msg(TOKEN_GET(&tok, cstring) == NULL, "token ival->cstring");
ck_assert_msg(TOKEN_GET(&tok, scope) == NULL, "token ival->scope");
ck_assert_msg(TOKEN_GET(&tok, dval) - -1 < 1e-9, "token ival->dval");
ck_assert_msg(TOKEN_GET(&tok, ival) == val, "token ival->ival");
}
END_TEST
@ -148,18 +146,18 @@ START_TEST(test_token_dval)
memset(&tok, 0, sizeof(tok));
TOKEN_SET(&tok, dval, val);
fail_unless(TOKEN_GET(&tok, string) == NULL, "token dval->string");
fail_unless(TOKEN_GET(&tok, cstring) == NULL, "token dval->cstring");
fail_unless(TOKEN_GET(&tok, scope) == NULL, "token dval->scope");
fail_unless(TOKEN_GET(&tok, dval) - val < 1e-9, "token dval->dval");
fail_unless(TOKEN_GET(&tok, ival) == -1, "token dval->ival");
ck_assert_msg(TOKEN_GET(&tok, string) == NULL, "token dval->string");
ck_assert_msg(TOKEN_GET(&tok, cstring) == NULL, "token dval->cstring");
ck_assert_msg(TOKEN_GET(&tok, scope) == NULL, "token dval->scope");
ck_assert_msg(TOKEN_GET(&tok, dval) - val < 1e-9, "token dval->dval");
ck_assert_msg(TOKEN_GET(&tok, ival) == -1, "token dval->ival");
}
END_TEST
START_TEST(test_init_destroy)
{
struct parser_state *state = cli_js_init();
fail_unless(!!state, "cli_js_init()");
ck_assert_msg(!!state, "cli_js_init()");
cli_js_destroy(state);
cli_js_destroy(NULL);
}
@ -169,7 +167,7 @@ START_TEST(test_init_parse_destroy)
{
const char buf[] = "function (p) { return \"anonymous\";}";
struct parser_state *state = cli_js_init();
fail_unless(!!state, "cli_js_init()");
ck_assert_msg(!!state, "cli_js_init()");
cli_js_process_buffer(state, buf, strlen(buf));
cli_js_process_buffer(state, buf, strlen(buf));
cli_js_parse_done(state);
@ -187,7 +185,7 @@ START_TEST(js_begin_end)
buf[p] = ' ';
}
strncpy(buf + 8192, " stuff stuff <script language='javascript'> function () {}", 8192);
fail_unless(html_normalise_mem((unsigned char *)buf, sizeof(buf), NULL, NULL, dconf) == 1, "normalise");
ck_assert_msg(html_normalise_mem((unsigned char *)buf, sizeof(buf), NULL, NULL, dconf) == 1, "normalise");
}
END_TEST
@ -197,8 +195,8 @@ START_TEST(multiple_scripts)
"<script language='Javascript'> function foo() {} </script>"
"<script language='Javascript'> function bar() {} </script>";
fail_unless(!!dconf, "failed to init dconf");
fail_unless(html_normalise_mem((unsigned char *)buf, sizeof(buf), NULL, NULL, dconf) == 1, "normalise");
ck_assert_msg(!!dconf, "failed to init dconf");
ck_assert_msg(html_normalise_mem((unsigned char *)buf, sizeof(buf), NULL, NULL, dconf) == 1, "normalise");
/* TODO: test that both had been normalized */
}
END_TEST
@ -210,10 +208,10 @@ static void jstest_setup(void)
{
cl_init(CL_INIT_DEFAULT);
state = cli_js_init();
fail_unless(!!state, "js init");
ck_assert_msg(!!state, "js init");
tmpdir = cli_gentemp(NULL);
fail_unless(!!tmpdir, "js tmp dir");
fail_unless_fmt(mkdir(tmpdir, 0700) == 0, "tempdir mkdir of %s failed: %s", tmpdir, strerror(errno));
ck_assert_msg(!!tmpdir, "js tmp dir");
ck_assert_msg(mkdir(tmpdir, 0700) == 0, "tempdir mkdir of %s failed: %s", tmpdir, strerror(errno));
}
static void jstest_teardown(void)
@ -247,7 +245,7 @@ static void tokenizer_test(const char *in, const char *expected, int split)
fd = open(filename, O_RDONLY);
if (fd < 0) {
jstest_teardown();
fail_fmt("failed to open output file: %s", filename);
ck_assert_msg("failed to open output file: %s", filename);
}
diff_file_mem(fd, expected, len);
@ -378,7 +376,6 @@ static struct {
{jstest_buf13, jstest_expected13},
{jstest_buf14, jstest_expected14}};
#ifdef CHECK_HAVE_LOOPS
START_TEST(tokenizer_basic)
{
tokenizer_test(js_tests[_i].in, js_tests[_i].expected, 0);
@ -390,7 +387,6 @@ START_TEST(tokenizer_split)
tokenizer_test(js_tests[_i].in, js_tests[_i].expected, 1);
}
END_TEST
#endif /* CHECK_HAVE_LOOPS */
START_TEST(js_buffer)
{
@ -402,8 +398,8 @@ START_TEST(js_buffer)
char *tst = malloc(len);
char *exp = malloc(len + sizeof(s_exp) + sizeof(e_exp) - 2);
fail_unless(!!tst, "malloc");
fail_unless(!!exp, "malloc");
ck_assert_msg(!!tst, "malloc");
ck_assert_msg(!!exp, "malloc");
memset(tst, 'a', len);
strncpy(tst, s, strlen(s));
@ -424,7 +420,7 @@ START_TEST(screnc_infloop)
char buf[24700] = "<%@ language='jscript.encode'>";
size_t p;
fail_unless(!!dconf, "failed to init dconf");
ck_assert_msg(!!dconf, "failed to init dconf");
for (p = strlen(buf); p < 16384; p++) {
buf[p] = ' ';
}
@ -432,7 +428,7 @@ START_TEST(screnc_infloop)
buf[p] = 'a';
}
strncpy(buf + 24626, "#@~^ ", 10);
fail_unless(html_normalise_mem((unsigned char *)buf, sizeof(buf), NULL, NULL, dconf) == 1, "normalise");
ck_assert_msg(html_normalise_mem((unsigned char *)buf, sizeof(buf), NULL, NULL, dconf) == 1, "normalise");
}
END_TEST
@ -464,10 +460,10 @@ Suite *test_jsnorm_suite(void)
prepare();
tc_jsnorm_gperf = tcase_create("jsnorm gperf");
suite_add_tcase(s, tc_jsnorm_gperf);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_jsnorm_gperf, test_keywords, 0, sizeof(kw_test) / sizeof(kw_test[0]));
tcase_add_loop_test(tc_jsnorm_gperf, test_operators, 0, sizeof(op_test) / sizeof(op_test[0]));
#endif
tc_jsnorm_token = tcase_create("jsnorm token functions");
suite_add_tcase(s, tc_jsnorm_token);
tcase_add_test(tc_jsnorm_token, test_token_string);
@ -484,10 +480,10 @@ Suite *test_jsnorm_suite(void)
tc_jsnorm_tokenizer = tcase_create("jsnorm tokenizer");
suite_add_tcase(s, tc_jsnorm_tokenizer);
tcase_add_checked_fixture(tc_jsnorm_tokenizer, jstest_setup, jstest_teardown);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_jsnorm_tokenizer, tokenizer_basic, 0, sizeof(js_tests) / sizeof(js_tests[0]));
tcase_add_loop_test(tc_jsnorm_tokenizer, tokenizer_split, 0, sizeof(js_tests) / sizeof(js_tests[0]));
#endif
tcase_add_test(tc_jsnorm_tokenizer, js_buffer);
tc_jsnorm_bugs = tcase_create("bugs");

136
unit_tests/check_matchers.c
Unescape View File

@ -169,9 +169,9 @@ static void setup(void)
ctx.virname = &virname;
ctx.fmap = &thefmap;
ctx.engine = cl_engine_new();
fail_unless(!!ctx.engine, "cl_engine_new() failed");
ck_assert_msg(!!ctx.engine, "cl_engine_new() failed");
root = (struct cli_matcher *)MPOOL_CALLOC(ctx.engine->mempool, 1, sizeof(struct cli_matcher));
fail_unless(root != NULL, "root == NULL");
ck_assert_msg(root != NULL, "root == NULL");
#ifdef USE_MPOOL
root->mempool = ctx.engine->mempool;
#endif
@ -192,35 +192,35 @@ START_TEST(test_ac_scanbuff)
int ret;
root = ctx.engine->root[0];
fail_unless(root != NULL, "root == NULL");
ck_assert_msg(root != NULL, "root == NULL");
root->ac_only = 1;
#ifdef USE_MPOOL
root->mempool = mpool_create();
#endif
ret = cli_ac_init(root, CLI_DEFAULT_AC_MINDEPTH, CLI_DEFAULT_AC_MAXDEPTH, 1);
fail_unless(ret == CL_SUCCESS, "cli_ac_init() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_ac_init() failed");
for (i = 0; ac_testdata[i].data; i++) {
ret = cli_parse_add(root, ac_testdata[i].virname, ac_testdata[i].hexsig, 0, 0, 0, "*", 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "cli_parse_add() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_parse_add() failed");
}
ret = cli_ac_buildtrie(root);
fail_unless(ret == CL_SUCCESS, "cli_ac_buildtrie() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_ac_buildtrie() failed");
ret = cli_ac_initdata(&mdata, root->ac_partsigs, 0, 0, CLI_DEFAULT_AC_TRACKLEN);
fail_unless(ret == CL_SUCCESS, "cli_ac_initdata() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_ac_initdata() failed");
ctx.options->general &= ~CL_SCAN_GENERAL_ALLMATCHES; /* make sure all-match is disabled */
for (i = 0; ac_testdata[i].data; i++) {
ret = cli_ac_scanbuff((const unsigned char *)ac_testdata[i].data, strlen(ac_testdata[i].data), &virname, NULL, NULL, root, &mdata, 0, 0, NULL, AC_SCAN_VIR, NULL);
fail_unless_fmt(ret == CL_VIRUS, "cli_ac_scanbuff() failed for %s", ac_testdata[i].virname);
fail_unless_fmt(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);
ck_assert_msg(ret == CL_VIRUS, "cli_ac_scanbuff() failed for %s", ac_testdata[i].virname);
ck_assert_msg(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);
ret = cli_scanbuff((const unsigned char *)ac_testdata[i].data, strlen(ac_testdata[i].data), 0, &ctx, 0, NULL);
fail_unless_fmt(ret == CL_VIRUS, "cli_scanbuff() failed for %s", ac_testdata[i].virname);
fail_unless_fmt(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);
ck_assert_msg(ret == CL_VIRUS, "cli_scanbuff() failed for %s", ac_testdata[i].virname);
ck_assert_msg(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);
}
cli_ac_freedata(&mdata);
@ -235,35 +235,35 @@ START_TEST(test_ac_scanbuff_allscan)
int ret;
root = ctx.engine->root[0];
fail_unless(root != NULL, "root == NULL");
ck_assert_msg(root != NULL, "root == NULL");
root->ac_only = 1;
#ifdef USE_MPOOL
root->mempool = mpool_create();
#endif
ret = cli_ac_init(root, CLI_DEFAULT_AC_MINDEPTH, CLI_DEFAULT_AC_MAXDEPTH, 1);
fail_unless(ret == CL_SUCCESS, "cli_ac_init() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_ac_init() failed");
for (i = 0; ac_testdata[i].data; i++) {
ret = cli_parse_add(root, ac_testdata[i].virname, ac_testdata[i].hexsig, 0, 0, 0, "*", 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "cli_parse_add() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_parse_add() failed");
}
ret = cli_ac_buildtrie(root);
fail_unless(ret == CL_SUCCESS, "cli_ac_buildtrie() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_ac_buildtrie() failed");
ret = cli_ac_initdata(&mdata, root->ac_partsigs, 0, 0, CLI_DEFAULT_AC_TRACKLEN);
fail_unless(ret == CL_SUCCESS, "cli_ac_initdata() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_ac_initdata() failed");
ctx.options->general |= CL_SCAN_GENERAL_ALLMATCHES; /* enable all-match */
for (i = 0; ac_testdata[i].data; i++) {
ret = cli_ac_scanbuff((const unsigned char *)ac_testdata[i].data, strlen(ac_testdata[i].data), &virname, NULL, NULL, root, &mdata, 0, 0, NULL, AC_SCAN_VIR, NULL);
fail_unless_fmt(ret == CL_VIRUS, "cli_ac_scanbuff() failed for %s", ac_testdata[i].virname);
fail_unless_fmt(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);
ck_assert_msg(ret == CL_VIRUS, "cli_ac_scanbuff() failed for %s", ac_testdata[i].virname);
ck_assert_msg(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);
ret = cli_scanbuff((const unsigned char *)ac_testdata[i].data, strlen(ac_testdata[i].data), 0, &ctx, 0, NULL);
fail_unless_fmt(ret == CL_VIRUS, "cli_scanbuff() failed for %s", ac_testdata[i].virname);
fail_unless_fmt(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);
ck_assert_msg(ret == CL_VIRUS, "cli_scanbuff() failed for %s", ac_testdata[i].virname);
ck_assert_msg(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);
if (ctx.num_viruses)
ctx.num_viruses = 0;
}
@ -280,35 +280,35 @@ START_TEST(test_ac_scanbuff_ex)
int ret;
root = ctx.engine->root[0];
fail_unless(root != NULL, "root == NULL");
ck_assert_msg(root != NULL, "root == NULL");
root->ac_only = 1;
#ifdef USE_MPOOL
root->mempool = mpool_create();
#endif
ret = cli_ac_init(root, CLI_DEFAULT_AC_MINDEPTH, CLI_DEFAULT_AC_MAXDEPTH, 1);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_ac_init() failed");
ck_assert_msg(ret == CL_SUCCESS, "[ac_ex] cli_ac_init() failed");
for (i = 0; ac_sigopts_testdata[i].data; i++) {
ret = cli_sigopts_handler(root, ac_sigopts_testdata[i].virname, ac_sigopts_testdata[i].hexsig, ac_sigopts_testdata[i].sigopts, 0, 0, ac_sigopts_testdata[i].offset, 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_sigopts_handler() failed");
ck_assert_msg(ret == CL_SUCCESS, "[ac_ex] cli_sigopts_handler() failed");
}
ret = cli_ac_buildtrie(root);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_ac_buildtrie() failed");
ck_assert_msg(ret == CL_SUCCESS, "[ac_ex] cli_ac_buildtrie() failed");
ret = cli_ac_initdata(&mdata, root->ac_partsigs, 0, 0, CLI_DEFAULT_AC_TRACKLEN);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_ac_initdata() failed");
ck_assert_msg(ret == CL_SUCCESS, "[ac_ex] cli_ac_initdata() failed");
ctx.options->general &= ~CL_SCAN_GENERAL_ALLMATCHES; /* make sure all-match is disabled */
for (i = 0; ac_sigopts_testdata[i].data; i++) {
ret = cli_ac_scanbuff((const unsigned char *)ac_sigopts_testdata[i].data, ac_sigopts_testdata[i].dlength, &virname, NULL, NULL, root, &mdata, 0, 0, NULL, AC_SCAN_VIR, NULL);
fail_unless_fmt(ret == ac_sigopts_testdata[i].expected_result, "[ac_ex] cli_ac_scanbuff() failed for %s (%d != %d)", ac_sigopts_testdata[i].virname, ret, ac_sigopts_testdata[i].expected_result);
ck_assert_msg(ret == ac_sigopts_testdata[i].expected_result, "[ac_ex] cli_ac_scanbuff() failed for %s (%d != %d)", ac_sigopts_testdata[i].virname, ret, ac_sigopts_testdata[i].expected_result);
if (ac_sigopts_testdata[i].expected_result == CL_VIRUS)
fail_unless_fmt(!strncmp(virname, ac_sigopts_testdata[i].virname, strlen(ac_sigopts_testdata[i].virname)), "[ac_ex] Dataset %u matched with %s", i, virname);
ck_assert_msg(!strncmp(virname, ac_sigopts_testdata[i].virname, strlen(ac_sigopts_testdata[i].virname)), "[ac_ex] Dataset %u matched with %s", i, virname);
ret = cli_scanbuff((const unsigned char *)ac_sigopts_testdata[i].data, ac_sigopts_testdata[i].dlength, 0, &ctx, 0, NULL);
fail_unless_fmt(ret == ac_sigopts_testdata[i].expected_result, "[ac_ex] cli_ac_scanbuff() failed for %s (%d != %d)", ac_sigopts_testdata[i].virname, ret, ac_sigopts_testdata[i].expected_result);
ck_assert_msg(ret == ac_sigopts_testdata[i].expected_result, "[ac_ex] cli_ac_scanbuff() failed for %s (%d != %d)", ac_sigopts_testdata[i].virname, ret, ac_sigopts_testdata[i].expected_result);
}
cli_ac_freedata(&mdata);
@ -323,35 +323,35 @@ START_TEST(test_ac_scanbuff_allscan_ex)
int ret;
root = ctx.engine->root[0];
fail_unless(root != NULL, "root == NULL");
ck_assert_msg(root != NULL, "root == NULL");
root->ac_only = 1;
#ifdef USE_MPOOL
root->mempool = mpool_create();
#endif
ret = cli_ac_init(root, CLI_DEFAULT_AC_MINDEPTH, CLI_DEFAULT_AC_MAXDEPTH, 1);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_ac_init() failed");
ck_assert_msg(ret == CL_SUCCESS, "[ac_ex] cli_ac_init() failed");
for (i = 0; ac_sigopts_testdata[i].data; i++) {
ret = cli_sigopts_handler(root, ac_sigopts_testdata[i].virname, ac_sigopts_testdata[i].hexsig, ac_sigopts_testdata[i].sigopts, 0, 0, ac_sigopts_testdata[i].offset, 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_sigopts_handler() failed");
ck_assert_msg(ret == CL_SUCCESS, "[ac_ex] cli_sigopts_handler() failed");
}
ret = cli_ac_buildtrie(root);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_ac_buildtrie() failed");
ck_assert_msg(ret == CL_SUCCESS, "[ac_ex] cli_ac_buildtrie() failed");
ret = cli_ac_initdata(&mdata, root->ac_partsigs, 0, 0, CLI_DEFAULT_AC_TRACKLEN);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_ac_initdata() failed");
ck_assert_msg(ret == CL_SUCCESS, "[ac_ex] cli_ac_initdata() failed");
ctx.options->general |= CL_SCAN_GENERAL_ALLMATCHES; /* enable all-match */
for (i = 0; ac_sigopts_testdata[i].data; i++) {
ret = cli_ac_scanbuff((const unsigned char *)ac_sigopts_testdata[i].data, ac_sigopts_testdata[i].dlength, &virname, NULL, NULL, root, &mdata, 0, 0, NULL, AC_SCAN_VIR, NULL);
fail_unless_fmt(ret == ac_sigopts_testdata[i].expected_result, "[ac_ex] cli_ac_scanbuff() failed for %s (%d != %d)", ac_sigopts_testdata[i].virname, ret, ac_sigopts_testdata[i].expected_result);
ck_assert_msg(ret == ac_sigopts_testdata[i].expected_result, "[ac_ex] cli_ac_scanbuff() failed for %s (%d != %d)", ac_sigopts_testdata[i].virname, ret, ac_sigopts_testdata[i].expected_result);
if (ac_sigopts_testdata[i].expected_result == CL_VIRUS)
fail_unless_fmt(!strncmp(virname, ac_sigopts_testdata[i].virname, strlen(ac_sigopts_testdata[i].virname)), "[ac_ex] Dataset %u matched with %s", i, virname);
ck_assert_msg(!strncmp(virname, ac_sigopts_testdata[i].virname, strlen(ac_sigopts_testdata[i].virname)), "[ac_ex] Dataset %u matched with %s", i, virname);
ret = cli_scanbuff((const unsigned char *)ac_sigopts_testdata[i].data, ac_sigopts_testdata[i].dlength, 0, &ctx, 0, NULL);
fail_unless_fmt(ret == ac_sigopts_testdata[i].expected_result, "[ac_ex] cli_ac_scanbuff() failed for %s (%d != %d)", ac_sigopts_testdata[i].virname, ret, ac_sigopts_testdata[i].expected_result);
ck_assert_msg(ret == ac_sigopts_testdata[i].expected_result, "[ac_ex] cli_ac_scanbuff() failed for %s (%d != %d)", ac_sigopts_testdata[i].virname, ret, ac_sigopts_testdata[i].expected_result);
if (ctx.num_viruses)
ctx.num_viruses = 0;
}
@ -367,25 +367,25 @@ START_TEST(test_bm_scanbuff)
int ret;
root = ctx.engine->root[0];
fail_unless(root != NULL, "root == NULL");
ck_assert_msg(root != NULL, "root == NULL");
#ifdef USE_MPOOL
root->mempool = mpool_create();
#endif
ret = cli_bm_init(root);
fail_unless(ret == CL_SUCCESS, "cli_bm_init() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_bm_init() failed");
ret = cli_parse_add(root, "Sig1", "deadbabe", 0, 0, 0, "*", 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "cli_parse_add() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_parse_add() failed");
ret = cli_parse_add(root, "Sig2", "deadbeef", 0, 0, 0, "*", 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "cli_parse_add() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_parse_add() failed");
ret = cli_parse_add(root, "Sig3", "babedead", 0, 0, 0, "*", 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "cli_parse_add() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_parse_add() failed");
ctx.options->general &= ~CL_SCAN_GENERAL_ALLMATCHES; /* make sure all-match is disabled */
ret = cli_bm_scanbuff((const unsigned char *)"blah\xde\xad\xbe\xef", 12, &virname, NULL, root, 0, NULL, NULL, NULL);
fail_unless(ret == CL_VIRUS, "cli_bm_scanbuff() failed");
fail_unless(!strncmp(virname, "Sig2", 4), "Incorrect signature matched in cli_bm_scanbuff()\n");
ck_assert_msg(ret == CL_VIRUS, "cli_bm_scanbuff() failed");
ck_assert_msg(!strncmp(virname, "Sig2", 4), "Incorrect signature matched in cli_bm_scanbuff()\n");
}
END_TEST
@ -396,25 +396,25 @@ START_TEST(test_bm_scanbuff_allscan)
int ret;
root = ctx.engine->root[0];
fail_unless(root != NULL, "root == NULL");
ck_assert_msg(root != NULL, "root == NULL");
#ifdef USE_MPOOL
root->mempool = mpool_create();
#endif
ret = cli_bm_init(root);
fail_unless(ret == CL_SUCCESS, "cli_bm_init() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_bm_init() failed");
ret = cli_parse_add(root, "Sig1", "deadbabe", 0, 0, 0, "*", 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "cli_parse_add() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_parse_add() failed");
ret = cli_parse_add(root, "Sig2", "deadbeef", 0, 0, 0, "*", 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "cli_parse_add() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_parse_add() failed");
ret = cli_parse_add(root, "Sig3", "babedead", 0, 0, 0, "*", 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "cli_parse_add() failed");
ck_assert_msg(ret == CL_SUCCESS, "cli_parse_add() failed");
ctx.options->general |= CL_SCAN_GENERAL_ALLMATCHES; /* enable all-match */
ret = cli_bm_scanbuff((const unsigned char *)"blah\xde\xad\xbe\xef", 12, &virname, NULL, root, 0, NULL, NULL, NULL);
fail_unless(ret == CL_VIRUS, "cli_bm_scanbuff() failed");
fail_unless(!strncmp(virname, "Sig2", 4), "Incorrect signature matched in cli_bm_scanbuff()\n");
ck_assert_msg(ret == CL_VIRUS, "cli_bm_scanbuff() failed");
ck_assert_msg(!strncmp(virname, "Sig2", 4), "Incorrect signature matched in cli_bm_scanbuff()\n");
}
END_TEST
@ -429,45 +429,45 @@ START_TEST(test_pcre_scanbuff)
int ret;
root = ctx.engine->root[0];
fail_unless(root != NULL, "root == NULL");
ck_assert_msg(root != NULL, "root == NULL");
#ifdef USE_MPOOL
root->mempool = mpool_create();
#endif
ret = cli_pcre_init();
fail_unless(ret == CL_SUCCESS, "[pcre] cli_pcre_init() failed");
ck_assert_msg(ret == CL_SUCCESS, "[pcre] cli_pcre_init() failed");
for (i = 0; pcre_testdata[i].data; i++) {
hexlen = strlen(PCRE_BYPASS) + strlen(pcre_testdata[i].hexsig) + 1;
hexsig = cli_calloc(hexlen, sizeof(char));
fail_unless(hexsig != NULL, "[pcre] failed to prepend bypass (out-of-memory)");
ck_assert_msg(hexsig != NULL, "[pcre] failed to prepend bypass (out-of-memory)");
strncat(hexsig, PCRE_BYPASS, hexlen);
strncat(hexsig, pcre_testdata[i].hexsig, hexlen);
ret = cli_parse_add(root, pcre_testdata[i].virname, hexsig, pcre_testdata[i].sigopts, 0, 0, pcre_testdata[i].offset, 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "[pcre] cli_parse_add() failed");
ck_assert_msg(ret == CL_SUCCESS, "[pcre] cli_parse_add() failed");
free(hexsig);
}
ret = cli_pcre_build(root, CLI_DEFAULT_PCRE_MATCH_LIMIT, CLI_DEFAULT_PCRE_RECMATCH_LIMIT, NULL);
fail_unless(ret == CL_SUCCESS, "[pcre] cli_pcre_build() failed");
ck_assert_msg(ret == CL_SUCCESS, "[pcre] cli_pcre_build() failed");
// recomputate offsets
ret = cli_ac_initdata(&mdata, root->ac_partsigs, root->ac_lsigs, root->ac_reloff_num, CLI_DEFAULT_AC_TRACKLEN);
fail_unless(ret == CL_SUCCESS, "[pcre] cli_ac_initdata() failed");
ck_assert_msg(ret == CL_SUCCESS, "[pcre] cli_ac_initdata() failed");
ctx.options->general &= ~CL_SCAN_GENERAL_ALLMATCHES; /* make sure all-match is disabled */
for (i = 0; pcre_testdata[i].data; i++) {
ret = cli_pcre_scanbuf((const unsigned char *)pcre_testdata[i].data, strlen(pcre_testdata[i].data), &virname, NULL, root, NULL, NULL, NULL);
fail_unless_fmt(ret == pcre_testdata[i].expected_result, "[pcre] cli_pcre_scanbuff() failed for %s (%d != %d)", pcre_testdata[i].virname, ret, pcre_testdata[i].expected_result);
ck_assert_msg(ret == pcre_testdata[i].expected_result, "[pcre] cli_pcre_scanbuff() failed for %s (%d != %d)", pcre_testdata[i].virname, ret, pcre_testdata[i].expected_result);
if (pcre_testdata[i].expected_result == CL_VIRUS)
fail_unless_fmt(!strncmp(virname, pcre_testdata[i].virname, strlen(pcre_testdata[i].virname)), "[pcre] Dataset %u matched with %s", i, virname);
ck_assert_msg(!strncmp(virname, pcre_testdata[i].virname, strlen(pcre_testdata[i].virname)), "[pcre] Dataset %u matched with %s", i, virname);
ret = cli_scanbuff((const unsigned char *)pcre_testdata[i].data, strlen(pcre_testdata[i].data), 0, &ctx, 0, NULL);
fail_unless_fmt(ret == pcre_testdata[i].expected_result, "[pcre] cli_scanbuff() failed for %s", pcre_testdata[i].virname);
ck_assert_msg(ret == pcre_testdata[i].expected_result, "[pcre] cli_scanbuff() failed for %s", pcre_testdata[i].virname);
}
cli_ac_freedata(&mdata);
@ -483,45 +483,45 @@ START_TEST(test_pcre_scanbuff_allscan)
int ret;
root = ctx.engine->root[0];
fail_unless(root != NULL, "root == NULL");
ck_assert_msg(root != NULL, "root == NULL");
#ifdef USE_MPOOL
root->mempool = mpool_create();
#endif
ret = cli_pcre_init();
fail_unless(ret == CL_SUCCESS, "[pcre] cli_pcre_init() failed");
ck_assert_msg(ret == CL_SUCCESS, "[pcre] cli_pcre_init() failed");
for (i = 0; pcre_testdata[i].data; i++) {
hexlen = strlen(PCRE_BYPASS) + strlen(pcre_testdata[i].hexsig) + 1;
hexsig = cli_calloc(hexlen, sizeof(char));
fail_unless(hexsig != NULL, "[pcre] failed to prepend bypass (out-of-memory)");
ck_assert_msg(hexsig != NULL, "[pcre] failed to prepend bypass (out-of-memory)");
strncat(hexsig, PCRE_BYPASS, hexlen);
strncat(hexsig, pcre_testdata[i].hexsig, hexlen);
ret = cli_parse_add(root, pcre_testdata[i].virname, hexsig, 0, 0, 0, pcre_testdata[i].offset, 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "[pcre] cli_parse_add() failed");
ck_assert_msg(ret == CL_SUCCESS, "[pcre] cli_parse_add() failed");
free(hexsig);
}
ret = cli_pcre_build(root, CLI_DEFAULT_PCRE_MATCH_LIMIT, CLI_DEFAULT_PCRE_RECMATCH_LIMIT, NULL);
fail_unless(ret == CL_SUCCESS, "[pcre] cli_pcre_build() failed");
ck_assert_msg(ret == CL_SUCCESS, "[pcre] cli_pcre_build() failed");
// recomputate offsets
ret = cli_ac_initdata(&mdata, root->ac_partsigs, root->ac_lsigs, root->ac_reloff_num, CLI_DEFAULT_AC_TRACKLEN);
fail_unless(ret == CL_SUCCESS, "[pcre] cli_ac_initdata() failed");
ck_assert_msg(ret == CL_SUCCESS, "[pcre] cli_ac_initdata() failed");
ctx.options->general |= CL_SCAN_GENERAL_ALLMATCHES; /* enable all-match */
for (i = 0; pcre_testdata[i].data; i++) {
ret = cli_pcre_scanbuf((const unsigned char *)pcre_testdata[i].data, strlen(pcre_testdata[i].data), &virname, NULL, root, NULL, NULL, NULL);
fail_unless_fmt(ret == pcre_testdata[i].expected_result, "[pcre] cli_pcre_scanbuff() failed for %s (%d != %d)", pcre_testdata[i].virname, ret, pcre_testdata[i].expected_result);
ck_assert_msg(ret == pcre_testdata[i].expected_result, "[pcre] cli_pcre_scanbuff() failed for %s (%d != %d)", pcre_testdata[i].virname, ret, pcre_testdata[i].expected_result);
if (pcre_testdata[i].expected_result == CL_VIRUS)
fail_unless_fmt(!strncmp(virname, pcre_testdata[i].virname, strlen(pcre_testdata[i].virname)), "[pcre] Dataset %u matched with %s", i, virname);
ck_assert_msg(!strncmp(virname, pcre_testdata[i].virname, strlen(pcre_testdata[i].virname)), "[pcre] Dataset %u matched with %s", i, virname);
ret = cli_scanbuff((const unsigned char *)pcre_testdata[i].data, strlen(pcre_testdata[i].data), 0, &ctx, 0, NULL);
fail_unless_fmt(ret == pcre_testdata[i].expected_result, "[pcre] cli_scanbuff() failed for %s", pcre_testdata[i].virname);
ck_assert_msg(ret == pcre_testdata[i].expected_result, "[pcre] cli_scanbuff() failed for %s", pcre_testdata[i].virname);
/* num_virus field add to test case struct */
if (ctx.num_viruses)
ctx.num_viruses = 0;

180
unit_tests/check_regex.c
Unescape View File

@ -46,7 +46,7 @@ static size_t cb_called = 0;
static cl_error_t cb_fail(void *cbdata, const char *suffix, size_t len, const struct regex_list *regex)
{
fail("this pattern is not supposed to have a suffix");
ck_abort_msg("this pattern is not supposed to have a suffix");
return CL_EMEM;
}
@ -54,7 +54,7 @@ static cl_error_t cb_expect_single(void *cbdata, const char *suffix, size_t len,
{
const char *expected = cbdata;
cb_called++;
fail_unless_fmt(suffix && strcmp(suffix, expected) == 0,
ck_assert_msg(suffix && strcmp(suffix, expected) == 0,
"suffix mismatch, was: %s, expected: %s\n", suffix, expected);
return CL_SUCCESS;
}
@ -68,11 +68,11 @@ START_TEST(empty)
errmsg_expected();
preg = malloc(sizeof(*regex.preg));
fail_unless(!!preg, "malloc");
ck_assert_msg(!!preg, "malloc");
rc = cli_regex2suffix(pattern, preg, cb_fail, NULL);
free(preg);
fail_unless(rc == REG_EMPTY, "empty pattern");
fail_unless(cb_called == 0, "callback shouldn't be called");
ck_assert_msg(rc == REG_EMPTY, "empty pattern");
ck_assert_msg(cb_called == 0, "callback shouldn't be called");
}
END_TEST
@ -83,12 +83,12 @@ START_TEST(one)
regex_t *preg;
preg = malloc(sizeof(*regex.preg));
fail_unless(!!preg, "malloc");
ck_assert_msg(!!preg, "malloc");
rc = cli_regex2suffix(pattern, preg, cb_expect_single, pattern);
fail_unless(rc == 0, "single character pattern");
ck_assert_msg(rc == 0, "single character pattern");
cli_regfree(preg);
free(preg);
fail_unless(cb_called == 1, "callback should be called once");
ck_assert_msg(cb_called == 1, "callback should be called once");
}
END_TEST
@ -104,18 +104,17 @@ static const char **tests[] = {
static cl_error_t cb_expect_multi(void *cbdata, const char *suffix, size_t len, const struct regex_list *r)
{
const char **exp = cbdata;
fail_unless(!!exp, "expected data");
ck_assert_msg(!!exp, "expected data");
exp++;
fail_unless_fmt(!!*exp, "expected no suffix, got: %s\n", suffix);
fail_unless_fmt(!!exp[cb_called], "expected less suffixes, but already got: %d\n", cb_called);
fail_unless_fmt(strcmp(exp[cb_called], suffix) == 0,
ck_assert_msg(!!*exp, "expected no suffix, got: %s\n", suffix);
ck_assert_msg(!!exp[cb_called], "expected less suffixes, but already got: %d\n", cb_called);
ck_assert_msg(strcmp(exp[cb_called], suffix) == 0,
"suffix mismatch, was: %s, expected: %s\n", suffix, exp[cb_called]);
fail_unless_fmt(strlen(suffix) == len, "incorrect suffix len, expected: %d, got: %d\n", strlen(suffix), len);
ck_assert_msg(strlen(suffix) == len, "incorrect suffix len, expected: %d, got: %d\n", strlen(suffix), len);
cb_called++;
return CL_SUCCESS;
}
#ifdef CHECK_HAVE_LOOPS
START_TEST(test_suffix)
{
int rc;
@ -124,20 +123,19 @@ START_TEST(test_suffix)
size_t n = 0;
const char **p = tests[_i];
fail_unless(!!pattern, "test pattern");
ck_assert_msg(!!pattern, "test pattern");
preg = malloc(sizeof(*regex.preg));
fail_unless(!!preg, "malloc");
ck_assert_msg(!!preg, "malloc");
rc = cli_regex2suffix(pattern, preg, cb_expect_multi, tests[_i]);
fail_unless(rc == 0, "single character pattern");
ck_assert_msg(rc == 0, "single character pattern");
cli_regfree(preg);
free(preg);
p++;
while (*p++) n++;
fail_unless_fmt(cb_called == n,
ck_assert_msg(cb_called == n,
"suffix number mismatch, expected: %d, was: %d\n", n, cb_called);
}
END_TEST
#endif /* CHECK_HAVE_LOOPS */
static void setup(void)
{
@ -157,7 +155,7 @@ static void rsetup(void)
matcher.mempool = mpool_create();
#endif
rc = init_regex_list(&matcher, 1);
fail_unless(rc == 0, "init_regex_list");
ck_assert_msg(rc == 0, "init_regex_list");
}
static void rteardown(void)
@ -231,7 +229,6 @@ static const struct rtest {
{NULL, "http://key.com%00fake.example.com", "https://key.com", 0},
{NULL, "http://key.com.example.com", "key.com.invalid", 0}};
#ifdef CHECK_HAVE_LOOPS
START_TEST(regex_list_match_test)
{
const char *info;
@ -240,42 +237,41 @@ START_TEST(regex_list_match_test)
int rc;
if (!rtest->pattern) {
fail_unless(rtest->result != 1,
ck_assert_msg(rtest->result != 1,
"whitelist test must have pattern set");
/* this test entry is not meant for whitelist testing */
return;
}
fail_unless(rtest->result == 0 || rtest->result == 1 || rtest->result == 4,
ck_assert_msg(rtest->result == 0 || rtest->result == 1 || rtest->result == 4,
"whitelist test result must be either 0 or 1 or 4");
pattern = cli_strdup(rtest->pattern);
fail_unless(!!pattern, "cli_strdup");
ck_assert_msg(!!pattern, "cli_strdup");
rc = regex_list_add_pattern(&matcher, pattern);
if (rtest->result == 4) {
fail_unless(rc, "regex_list_add_pattern should return error");
ck_assert_msg(rc, "regex_list_add_pattern should return error");
free(pattern);
return;
} else
fail_unless(rc == 0, "regex_list_add_pattern");
ck_assert_msg(rc == 0, "regex_list_add_pattern");
free(pattern);
matcher.list_loaded = 1;
rc = cli_build_regex_list(&matcher);
fail_unless(rc == 0, "cli_build_regex_list");
ck_assert_msg(rc == 0, "cli_build_regex_list");
fail_unless(is_regex_ok(&matcher), "is_regex_ok");
ck_assert_msg(is_regex_ok(&matcher), "is_regex_ok");
realurl = cli_strdup(rtest->realurl);
rc = regex_list_match(&matcher, realurl, rtest->displayurl, NULL, 1, &info, 1);
fail_unless(rc == rtest->result, "regex_list_match");
ck_assert_msg(rc == rtest->result, "regex_list_match");
/* regex_list_match is not supposed to modify realurl in this case */
fail_unless(!strcmp(realurl, rtest->realurl), "realurl altered");
ck_assert_msg(!strcmp(realurl, rtest->realurl), "realurl altered");
free(realurl);
}
END_TEST
#endif /* CHECK_HAVE_LOOPS */
static struct cl_engine *engine;
static int loaded_2 = 0;
@ -287,55 +283,55 @@ static void psetup_impl(int load2)
unsigned signo = 0;
engine = cl_engine_new();
fail_unless(!!engine, "cl_engine_new");
ck_assert_msg(!!engine, "cl_engine_new");
phishing_init(engine);
fail_unless(!!engine->phishcheck, "phishing_init");
ck_assert_msg(!!engine->phishcheck, "phishing_init");
rc = init_domainlist(engine);
fail_unless(rc == 0, "init_domainlist");
ck_assert_msg(rc == 0, "init_domainlist");
f = fdopen(open_testfile("input/daily.pdb"), "r");
fail_unless(!!f, "fopen daily.pdb");
ck_assert_msg(!!f, "fopen daily.pdb");
rc = load_regex_matcher(engine, engine->domainlist_matcher, f, &signo, 0, 0, NULL, 1);
fail_unless(rc == 0, "load_regex_matcher");
ck_assert_msg(rc == 0, "load_regex_matcher");
fclose(f);
fail_unless_fmt(signo == 201, "Incorrect number of signatures: %u, expected %u", signo, 201);
ck_assert_msg(signo == 201, "Incorrect number of signatures: %u, expected %u", signo, 201);
if (load2) {
f = fdopen(open_testfile("input/daily.gdb"), "r");
fail_unless(!!f, "fopen daily.gdb");
ck_assert_msg(!!f, "fopen daily.gdb");
signo = 0;
rc = load_regex_matcher(engine, engine->domainlist_matcher, f, &signo, 0, 0, NULL, 1);
fail_unless(rc == 0, "load_regex_matcher");
ck_assert_msg(rc == 0, "load_regex_matcher");
fclose(f);
fail_unless_fmt(signo == 4, "Incorrect number of signatures: %u, expected %u", signo, 4);
ck_assert_msg(signo == 4, "Incorrect number of signatures: %u, expected %u", signo, 4);
}
loaded_2 = load2;
rc = init_whitelist(engine);
fail_unless(rc == 0, "init_whitelist");
ck_assert_msg(rc == 0, "init_whitelist");
f = fdopen(open_testfile("input/daily.wdb"), "r");
signo = 0;
rc = load_regex_matcher(engine, engine->whitelist_matcher, f, &signo, 0, 1, NULL, 1);
fail_unless(rc == 0, "load_regex_matcher");
ck_assert_msg(rc == 0, "load_regex_matcher");
fclose(f);
fail_unless_fmt(signo == 31, "Incorrect number of signatures: %u, expected %u", signo, 31);
ck_assert_msg(signo == 31, "Incorrect number of signatures: %u, expected %u", signo, 31);
rc = cli_build_regex_list(engine->whitelist_matcher);
fail_unless(rc == 0, "cli_build_regex_list");
ck_assert_msg(rc == 0, "cli_build_regex_list");
rc = cli_build_regex_list(engine->domainlist_matcher);
fail_unless(rc == 0, "cli_build_regex_list");
ck_assert_msg(rc == 0, "cli_build_regex_list");
fail_unless(is_regex_ok(engine->whitelist_matcher), "is_regex_ok");
fail_unless(is_regex_ok(engine->domainlist_matcher), "is_regex_ok");
ck_assert_msg(is_regex_ok(engine->whitelist_matcher), "is_regex_ok");
ck_assert_msg(is_regex_ok(engine->domainlist_matcher), "is_regex_ok");
}
static void psetup(void)
@ -370,16 +366,16 @@ static void do_phishing_test(const struct rtest *rtest)
ctx.options = &options;
realurl = cli_strdup(rtest->realurl);
fail_unless(!!realurl, "cli_strdup");
ck_assert_msg(!!realurl, "cli_strdup");
hrefs.count = 1;
hrefs.value = cli_malloc(sizeof(*hrefs.value));
fail_unless(!!hrefs.value, "cli_malloc");
ck_assert_msg(!!hrefs.value, "cli_malloc");
hrefs.value[0] = (unsigned char *)realurl;
hrefs.contents = cli_malloc(sizeof(*hrefs.contents));
fail_unless(!!hrefs.contents, "cli_malloc");
ck_assert_msg(!!hrefs.contents, "cli_malloc");
hrefs.tag = cli_malloc(sizeof(*hrefs.tag));
fail_unless(!!hrefs.tag, "cli_malloc");
ck_assert_msg(!!hrefs.tag, "cli_malloc");
hrefs.tag[0] = (unsigned char *)cli_strdup("href");
hrefs.contents[0] = (unsigned char *)cli_strdup(rtest->displayurl);
@ -389,34 +385,34 @@ static void do_phishing_test(const struct rtest *rtest)
rc = phishingScan(&ctx, &hrefs);
html_tag_arg_free(&hrefs);
fail_unless(rc == CL_CLEAN, "phishingScan");
ck_assert_msg(rc == CL_CLEAN, "phishingScan");
switch (rtest->result) {
case 0:
fail_unless_fmt(ctx.found_possibly_unwanted,
ck_assert_msg(ctx.found_possibly_unwanted,
"this should be phishing, realURL: %s, displayURL: %s",
rtest->realurl, rtest->displayurl);
break;
case 1:
fail_unless_fmt(!ctx.found_possibly_unwanted,
ck_assert_msg(!ctx.found_possibly_unwanted,
"this should be whitelisted, realURL: %s, displayURL: %s",
rtest->realurl, rtest->displayurl);
break;
case 2:
fail_unless_fmt(!ctx.found_possibly_unwanted,
ck_assert_msg(!ctx.found_possibly_unwanted,
"this should be clean, realURL: %s, displayURL: %s",
rtest->realurl, rtest->displayurl);
break;
case 3:
if (!loaded_2)
fail_unless_fmt(!ctx.found_possibly_unwanted,
ck_assert_msg(!ctx.found_possibly_unwanted,
"this should be clean, realURL: %s, displayURL: %s",
rtest->realurl, rtest->displayurl);
else {
fail_unless_fmt(ctx.found_possibly_unwanted,
ck_assert_msg(ctx.found_possibly_unwanted,
"this should be blacklisted, realURL: %s, displayURL: %s",
rtest->realurl, rtest->displayurl);
if (*ctx.virname)
fail_unless_fmt(!strstr((const char *)*ctx.virname, "Blacklisted"),
ck_assert_msg(!strstr((const char *)*ctx.virname, "Blacklisted"),
"should be blacklisted, but is: %s\n", ctx.virname);
}
break;
@ -437,16 +433,16 @@ static void do_phishing_test_allscan(const struct rtest *rtest)
ctx.options = &options;
realurl = cli_strdup(rtest->realurl);
fail_unless(!!realurl, "cli_strdup");
ck_assert_msg(!!realurl, "cli_strdup");
hrefs.count = 1;
hrefs.value = cli_malloc(sizeof(*hrefs.value));
fail_unless(!!hrefs.value, "cli_malloc");
ck_assert_msg(!!hrefs.value, "cli_malloc");
hrefs.value[0] = (unsigned char *)realurl;
hrefs.contents = cli_malloc(sizeof(*hrefs.contents));
fail_unless(!!hrefs.contents, "cli_malloc");
ck_assert_msg(!!hrefs.contents, "cli_malloc");
hrefs.tag = cli_malloc(sizeof(*hrefs.tag));
fail_unless(!!hrefs.tag, "cli_malloc");
ck_assert_msg(!!hrefs.tag, "cli_malloc");
hrefs.tag[0] = (unsigned char *)cli_strdup("href");
hrefs.contents[0] = (unsigned char *)cli_strdup(rtest->displayurl);
@ -457,41 +453,40 @@ static void do_phishing_test_allscan(const struct rtest *rtest)
rc = phishingScan(&ctx, &hrefs);
html_tag_arg_free(&hrefs);
fail_unless(rc == CL_CLEAN, "phishingScan");
ck_assert_msg(rc == CL_CLEAN, "phishingScan");
switch (rtest->result) {
case 0:
fail_unless_fmt(ctx.num_viruses,
ck_assert_msg(ctx.num_viruses,
"this should be phishing, realURL: %s, displayURL: %s",
rtest->realurl, rtest->displayurl);
break;
case 1:
fail_unless_fmt(!ctx.num_viruses,
ck_assert_msg(!ctx.num_viruses,
"this should be whitelisted, realURL: %s, displayURL: %s",
rtest->realurl, rtest->displayurl);
break;
case 2:
fail_unless_fmt(!ctx.num_viruses,
ck_assert_msg(!ctx.num_viruses,
"this should be clean, realURL: %s, displayURL: %s",
rtest->realurl, rtest->displayurl);
break;
case 3:
if (!loaded_2)
fail_unless_fmt(!ctx.num_viruses,
ck_assert_msg(!ctx.num_viruses,
"this should be clean, realURL: %s, displayURL: %s",
rtest->realurl, rtest->displayurl);
else {
fail_unless_fmt(ctx.num_viruses,
ck_assert_msg(ctx.num_viruses,
"this should be blacklisted, realURL: %s, displayURL: %s",
rtest->realurl, rtest->displayurl);
if (*ctx.virname)
fail_unless_fmt(!strstr((const char *)*ctx.virname, "Blacklisted"),
ck_assert_msg(!strstr((const char *)*ctx.virname, "Blacklisted"),
"should be blacklisted, but is: %s\n", ctx.virname);
}
break;
}
}
#ifdef CHECK_HAVE_LOOPS
START_TEST(phishingScan_test)
{
do_phishing_test(&rtests[_i]);
@ -503,9 +498,7 @@ START_TEST(phishingScan_test_allscan)
do_phishing_test_allscan(&rtests[_i]);
}
END_TEST
#endif
#ifdef CHECK_HAVE_LOOPS
static struct uc {
const char *in;
const char *host;
@ -534,9 +527,9 @@ START_TEST(test_url_canon)
struct uc *u = &uc[_i];
cli_url_canon(u->in, strlen(u->in), urlbuff, sizeof(urlbuff), &host, &host_len, &path, &path_len);
fail_unless(!!host && !!path, "null results\n");
fail_unless_fmt(!strcmp(u->host, host), "host incorrect: %s\n", host);
fail_unless_fmt(!strcmp(u->path, path), "path incorrect: %s\n", path);
ck_assert_msg(!!host && !!path, "null results\n");
ck_assert_msg(!strcmp(u->host, host), "host incorrect: %s\n", host);
ck_assert_msg(!strcmp(u->path, path), "path incorrect: %s\n", path);
}
END_TEST
@ -556,23 +549,22 @@ START_TEST(test_regexes)
struct regex_test *tst = &rg[_i];
int match;
fail_unless(cli_regcomp(&reg, tst->regex, REG_EXTENDED | REG_NOSUB) == 0, "cli_regcomp");
ck_assert_msg(cli_regcomp(&reg, tst->regex, REG_EXTENDED | REG_NOSUB) == 0, "cli_regcomp");
match = (cli_regexec(&reg, tst->text, 0, NULL, 0) == REG_NOMATCH) ? 0 : 1;
fail_unless_fmt(match == tst->match, "cli_regexec failed for %s and %s\n", tst->regex, tst->text);
ck_assert_msg(match == tst->match, "cli_regexec failed for %s and %s\n", tst->regex, tst->text);
cli_regfree(&reg);
}
END_TEST
#endif
START_TEST(phishing_fake_test)
{
char buf[4096];
FILE *f = fdopen(open_testfile("input/daily.pdb"), "r");
fail_unless(!!f, "fopen daily.pdb");
ck_assert_msg(!!f, "fopen daily.pdb");
while (fgets(buf, sizeof(buf), f)) {
struct rtest rtest;
const char *pdb = strchr(buf, ':');
fail_unless(!!pdb, "missing : in pdb");
ck_assert_msg(!!pdb, "missing : in pdb");
rtest.realurl = pdb;
rtest.displayurl = pdb;
rtest.result = 2;
@ -589,11 +581,11 @@ START_TEST(phishing_fake_test_allscan)
{
char buf[4096];
FILE *f = fdopen(open_testfile("input/daily.pdb"), "r");
fail_unless(!!f, "fopen daily.pdb");
ck_assert_msg(!!f, "fopen daily.pdb");
while (fgets(buf, sizeof(buf), f)) {
struct rtest rtest;
const char *pdb = strchr(buf, ':');
fail_unless(!!pdb, "missing : in pdb");
ck_assert_msg(!!pdb, "missing : in pdb");
rtest.realurl = pdb;
rtest.displayurl = pdb;
rtest.result = 2;
@ -616,42 +608,42 @@ Suite *test_regex_suite(void)
tcase_add_checked_fixture(tc_api, setup, teardown);
tcase_add_test(tc_api, empty);
tcase_add_test(tc_api, one);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_api, test_suffix, 0, sizeof(tests) / sizeof(tests[0]));
#endif
tc_matching = tcase_create("regex_list");
suite_add_tcase(s, tc_matching);
tcase_add_checked_fixture(tc_matching, rsetup, rteardown);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_matching, regex_list_match_test, 0, sizeof(rtests) / sizeof(rtests[0]));
#endif
tc_phish = tcase_create("phishingScan");
suite_add_tcase(s, tc_phish);
tcase_add_unchecked_fixture(tc_phish, psetup, pteardown);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_phish, phishingScan_test, 0, sizeof(rtests) / sizeof(rtests[0]));
tcase_add_loop_test(tc_phish, phishingScan_test_allscan, 0, sizeof(rtests) / sizeof(rtests[0]));
#endif
tcase_add_test(tc_phish, phishing_fake_test);
tcase_add_test(tc_phish, phishing_fake_test_allscan);
tc_phish2 = tcase_create("phishingScan with 2 dbs");
suite_add_tcase(s, tc_phish2);
tcase_add_unchecked_fixture(tc_phish2, psetup2, pteardown);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_phish2, phishingScan_test, 0, sizeof(rtests) / sizeof(rtests[0]));
tcase_add_loop_test(tc_phish2, phishingScan_test_allscan, 0, sizeof(rtests) / sizeof(rtests[0]));
#endif
tcase_add_test(tc_phish2, phishing_fake_test);
tcase_add_test(tc_phish2, phishing_fake_test_allscan);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_phish, test_url_canon, 0, sizeof(uc) / sizeof(uc[0]));
#endif
tc_regex = tcase_create("cli_regcomp/execute");
suite_add_tcase(s, tc_regex);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_regex, test_regexes, 0, sizeof(rg) / sizeof(rg[0]));
#endif
return s;
}

71
unit_tests/check_str.c
Unescape View File

@ -42,15 +42,15 @@
START_TEST(test_unescape_simple)
{
char *str = cli_unescape("");
fail_unless(str && strlen(str) == 0, "cli_unescape empty string");
ck_assert_msg(str && strlen(str) == 0, "cli_unescape empty string");
free(str);
str = cli_unescape("1");
fail_unless(str && !strcmp(str, "1"), "cli_unescape one char");
ck_assert_msg(str && !strcmp(str, "1"), "cli_unescape one char");
free(str);
str = cli_unescape("tesT");
fail_unless(str && !strcmp(str, "tesT"), "cli_unescape simple string");
ck_assert_msg(str && !strcmp(str, "tesT"), "cli_unescape simple string");
free(str);
}
END_TEST
@ -58,19 +58,19 @@ END_TEST
START_TEST(test_unescape_hex)
{
char *str = cli_unescape("%5a");
fail_unless(str && !strcmp(str, "\x5a"), "cli_unescape hex");
ck_assert_msg(str && !strcmp(str, "\x5a"), "cli_unescape hex");
free(str);
str = cli_unescape("%b5%8");
fail_unless(str && !strcmp(str, "\xb5%8"), "cli_unescape truncated");
ck_assert_msg(str && !strcmp(str, "\xb5%8"), "cli_unescape truncated");
free(str);
str = cli_unescape("%b5%");
fail_unless(str && !strcmp(str, "\xb5%"), "cli_unescape truncated/2");
ck_assert_msg(str && !strcmp(str, "\xb5%"), "cli_unescape truncated/2");
free(str);
str = cli_unescape("%00");
fail_unless(str && !strcmp(str, "\x1"), "cli_unescape %00");
ck_assert_msg(str && !strcmp(str, "\x1"), "cli_unescape %00");
free(str);
}
END_TEST
@ -79,16 +79,16 @@ START_TEST(test_unescape_unicode)
{
char *str = cli_unescape("%u05D0");
/* unicode is converted to utf-8 representation */
fail_unless(str && !strcmp(str, "\xd7\x90"), "cli_unescape unicode aleph");
ck_assert_msg(str && !strcmp(str, "\xd7\x90"), "cli_unescape unicode aleph");
free(str);
str = cli_unescape("%u00a2%u007f%u0080%u07ff%u0800%ue000");
fail_unless(str && !strcmp(str, "\xc2\xa2\x7f\xc2\x80\xdf\xbf\xe0\xa0\x80\xee\x80\x80"),
ck_assert_msg(str && !strcmp(str, "\xc2\xa2\x7f\xc2\x80\xdf\xbf\xe0\xa0\x80\xee\x80\x80"),
"cli_unescape utf-8 test");
free(str);
str = cli_unescape("%%u123%u12%u1%u%u1234");
fail_unless(str && !strcmp(str, "%%u123%u12%u1%u\xe1\x88\xb4"),
ck_assert_msg(str && !strcmp(str, "%%u123%u12%u1%u\xe1\x88\xb4"),
"cli_unescape unicode truncated");
free(str);
@ -111,26 +111,26 @@ static void buf_teardown(void)
START_TEST(test_append_len)
{
fail_unless(textbuffer_append_len(&buf, "test", 3) != -1, "tbuf append");
fail_unless(buf.data && !strncmp(buf.data, "tes", 3), "textbuffer_append_len");
ck_assert_msg(textbuffer_append_len(&buf, "test", 3) != -1, "tbuf append");
ck_assert_msg(buf.data && !strncmp(buf.data, "tes", 3), "textbuffer_append_len");
errmsg_expected();
fail_unless(textbuffer_append_len(&buf, "test", CLI_MAX_ALLOCATION) == -1, "tbuf append");
fail_unless(buf.data && !strncmp(buf.data, "tes", 3), "textbuffer_append_len");
ck_assert_msg(textbuffer_append_len(&buf, "test", CLI_MAX_ALLOCATION) == -1, "tbuf append");
ck_assert_msg(buf.data && !strncmp(buf.data, "tes", 3), "textbuffer_append_len");
}
END_TEST
START_TEST(test_append)
{
fail_unless(textbuffer_append(&buf, "test") != -1, "tbuf append");
fail_unless(textbuffer_putc(&buf, '\0') != -1, "tbuf putc");
fail_unless(buf.data && !strcmp(buf.data, "test"), "textbuffer_append");
ck_assert_msg(textbuffer_append(&buf, "test") != -1, "tbuf append");
ck_assert_msg(textbuffer_putc(&buf, '\0') != -1, "tbuf putc");
ck_assert_msg(buf.data && !strcmp(buf.data, "test"), "textbuffer_append");
}
END_TEST
START_TEST(test_putc)
{
fail_unless(textbuffer_putc(&buf, '\x5a') != -1, "tbuf putc");
fail_unless(buf.data && buf.data[0] == '\x5a', "textbuffer_putc");
ck_assert_msg(textbuffer_putc(&buf, '\x5a') != -1, "tbuf putc");
ck_assert_msg(buf.data && buf.data[0] == '\x5a', "textbuffer_putc");
}
END_TEST
@ -141,10 +141,10 @@ START_TEST(test_normalize)
int rc;
rc = cli_textbuffer_append_normalize(&buf, str, strlen(str));
fail_unless(rc != -1, "normalize");
ck_assert_msg(rc != -1, "normalize");
fail_unless(textbuffer_putc(&buf, '\0') != -1, "putc \\0");
fail_unless(buf.data && !strcmp(buf.data, expected), "normalized text");
ck_assert_msg(textbuffer_putc(&buf, '\0') != -1, "putc \\0");
ck_assert_msg(buf.data && !strcmp(buf.data, expected), "normalized text");
}
END_TEST
@ -156,17 +156,16 @@ START_TEST(hex2str)
const char inp2[] = "ag0026";
r = cli_hex2str(inp1);
fail_unless(!!r, "cli_hex2str NULL");
fail_unless(!memcmp(r, out1, sizeof(out1) - 1),
ck_assert_msg(!!r, "cli_hex2str NULL");
ck_assert_msg(!memcmp(r, out1, sizeof(out1) - 1),
"cli_hex2str invalid output");
free(r);
r = cli_hex2str(inp2);
fail_unless(!r, "cli_hex2str on invalid input");
ck_assert_msg(!r, "cli_hex2str on invalid input");
}
END_TEST
#ifdef CHECK_HAVE_LOOPS
static struct base64lines {
const char *line;
const char *decoded;
@ -190,10 +189,10 @@ START_TEST(test_base64)
unsigned char buf[1024];
const struct base64lines *test = &base64tests[_i];
message *m = messageCreate();
fail_unless(!!m, "Unable to create message");
ck_assert_msg(!!m, "Unable to create message");
ret = decodeLine(m, BASE64, test->line, buf, sizeof(buf));
fail_unless(!!ret, "unable to decode line");
ck_assert_msg(!!ret, "unable to decode line");
ret2 = base64Flush(m, ret);
@ -201,9 +200,9 @@ START_TEST(test_base64)
ret2 = ret;
*ret2 = '\0';
len = ret2 - buf;
fail_unless_fmt(len == test->len, "invalid base64 decoded length: %u expected %u (%s)\n",
ck_assert_msg(len == test->len, "invalid base64 decoded length: %u expected %u (%s)\n",
len, test->len, buf);
fail_unless_fmt(!memcmp(buf, test->decoded, test->len),
ck_assert_msg(!memcmp(buf, test->decoded, test->len),
"invalid base64 decoded data: %s, expected:%s\n",
buf, test->decoded);
messageDestroy(m);
@ -245,13 +244,12 @@ static unsigned u16_len(const char *s)
START_TEST(test_u16_u8)
{
char *result = cli_utf16_to_utf8(u16_tests[_i].u16, u16_len(u16_tests[_i].u16), UTF16_LE);
fail_unless(!!result, "cli_utf16_to_utf8 non-null");
fail_unless_fmt(!strcmp(result, u16_tests[_i].u8), "utf16_to_8 %d failed, expected: %s, got %s", _i, u16_tests[_i].u8, result);
ck_assert_msg(!!result, "cli_utf16_to_utf8 non-null");
ck_assert_msg(!strcmp(result, u16_tests[_i].u8), "utf16_to_8 %d failed, expected: %s, got %s", _i, u16_tests[_i].u8, result);
free(result);
}
END_TEST
#endif
Suite *test_str_suite(void)
{
@ -275,14 +273,13 @@ Suite *test_str_suite(void)
tc_str = tcase_create("str functions");
suite_add_tcase(s, tc_str);
tcase_add_test(tc_str, hex2str);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_str, test_u16_u8, 0, sizeof(u16_tests) / sizeof(u16_tests[0]));
#endif
tc_decodeline = tcase_create("decodeline");
suite_add_tcase(s, tc_decodeline);
#ifdef CHECK_HAVE_LOOPS
tcase_add_loop_test(tc_decodeline, test_base64, 0, sizeof(base64tests) / sizeof(base64tests[0]));
#endif
return s;
}

20
unit_tests/check_uniq.c
Unescape View File

@ -36,7 +36,7 @@ START_TEST(test_uniq_initfail)
{
struct uniq *U;
U = uniq_init(0);
fail_unless(U == NULL, "uniq_init(0)!=NULL");
ck_assert_msg(U == NULL, "uniq_init(0)!=NULL");
}
END_TEST
@ -58,20 +58,20 @@ START_TEST(test_uniq_known)
int i;
struct uniq *U = uniq_init(5);
fail_unless(U != 0, "uniq_init");
ck_assert_msg(U != 0, "uniq_init");
for (i = 0; tests[i].expected; i++) {
if (CL_SUCCESS != uniq_add(U, tests[i].key, tests[i].key_len, &hash, &u)) {
fail("uniq_add(%s) failed.", tests[i].key);
ck_abort_msg("uniq_add(%s) failed.", tests[i].key);
}
fail_unless_fmt(u == 1 && strcmp(hash, tests[i].expected) == 0, "uniq_add(%s) = %u - expected %s, got %s", tests[i].key, u, tests[i].expected, hash);
ck_assert_msg(u == 1 && strcmp(hash, tests[i].expected) == 0, "uniq_add(%s) = %u - expected %s, got %s", tests[i].key, u, tests[i].expected, hash);
}
for (i = 0; tests[i].expected; i++) {
if (CL_SUCCESS != uniq_get(U, tests[i].key, tests[i].key_len, &hash, &u)) {
fail("uniq_get(%s) failed.", tests[i].key);
ck_abort_msg("uniq_get(%s) failed.", tests[i].key);
}
fail_unless_fmt(u == 1 && strcmp(hash, tests[i].expected) == 0, "uniq_get(%s) = %u - expected %s, got %s", tests[i].key, u, tests[i].expected, hash);
ck_assert_msg(u == 1 && strcmp(hash, tests[i].expected) == 0, "uniq_get(%s) = %u - expected %s, got %s", tests[i].key, u, tests[i].expected, hash);
}
uniq_free(U);
@ -85,20 +85,20 @@ START_TEST(test_uniq_colls)
int i, j;
struct uniq *U = uniq_init(10);
fail_unless(U != 0, "uniq_init");
ck_assert_msg(U != 0, "uniq_init");
for (j = 4; j > 0; j--)
for (i = 0; i < j; i++) {
if (CL_SUCCESS != uniq_add(U, tests[i], strlen(tests[i]), NULL, &u)) {
fail("uniq_add(%s) failed.", tests[i]);
ck_abort_msg("uniq_add(%s) failed.", tests[i]);
}
}
for (i = 0; i < 4; i++) {
if (CL_SUCCESS != uniq_get(U, tests[i], strlen(tests[i]), NULL, &u)) {
fail("uniq_get(%s) failed.", tests[i]);
ck_abort_msg("uniq_get(%s) failed.", tests[i]);
}
fail_unless_fmt(u + i == 4, "uniq_get(%s) = %u - expected %u", tests[i], u, 4 - i);
ck_assert_msg(u + i == 4, "uniq_get(%s) = %u - expected %u", tests[i], u, 4 - i);
}
uniq_free(U);

12
unit_tests/checks_common.h
Unescape View File

@ -1,16 +1,4 @@
#ifndef CHECKS_COMMON_H
#define CHECKS_COMMON_H
#if CHECK_MAJOR_VERSION > 0 || (CHECK_MINOR_VERSION > 9 || (CHECK_MINOR_VERSION == 9 && CHECK_MICRO_VERSION > 3))
#define CHECK_HAVE_LOOPS
#endif
#if CHECK_MAJOR_VERSION > 0 || (CHECK_MINOR_VERSION > 9 || (CHECK_MINOR_VERSION == 9 && CHECK_MICRO_VERSION > 0))
#define fail_unless_fmt fail_unless
#define fail_fmt fail
#else
#define fail_unless_fmt(cond, msg, ...) fail_unless(cond, msg)
#define fail_fmt(msg, ...) fail(msg)
#endif
#endif

Write Preview
Loading…
Cancel
Save