@@ -1,3 +1,10 @@

+Wed Oct 22 20:52:37 EEST 2008 (edwin)

+-------------------------------------

+ * unit_tests/check_clamav.c, unit_tests/check_disasm.c,

+ unit_tests/check_jsnorm.c, unit_tests/check_matchers.c,

+ unit_tests/check_regex.c, unit_tests/check_uniq.c,

+ unit_tests/checks.h: support building with older versions of check

+

 Wed Oct 22 17:45:11 EEST 2008 (edwin)

 -------------------------------------

  * configure, m4/acinclude.m4: fix typo in previous commit

@@ -326,7 +326,7 @@ int open_testfile(const char *name)

 	sprintf(str, "%s/%s", srcdir, name);

 	fd = open(str, O_RDONLY);

-	fail_unless(fd >= 0, "open() failed: %s", str);

+	fail_unless_fmt(fd >= 0, "open() failed: %s", str);

 	free(str);

 	return fd;

 }

@@ -337,9 +337,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(!!buf, "unable to malloc buffer: %d", len);

+	fail_unless_fmt(!!buf, "unable to malloc buffer: %d", len);

 	p = read(fd, buf, len);

-	fail_unless(p == len,  "file is smaller: %lu, expected: %lu", p, len);

+	fail_unless_fmt(p == len,  "file is smaller: %lu, expected: %lu", p, len);

 	p = 0;

 	while(len > 0) {

 		c1 = ref[p];

@@ -350,10 +350,10 @@ void diff_file_mem(int fd, const char *ref, size_t len)

 		len--;

 	}

 	if (len > 0)

-		fail_unless(c1 == c2, "file contents mismatch at byte: %lu, was: %c, expected: %c", p, c2, c1);

+		fail_unless_fmt(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(p == reflen, "trailing garbage, file size: %ld, expected: %ld", p, reflen);

+        fail_unless_fmt(p == reflen, "trailing garbage, file size: %ld, expected: %ld", p, reflen);

 	close(fd);

 }

@@ -362,14 +362,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(siz != -1, "lseek failed");

+	fail_unless_fmt(siz != -1, "lseek failed");

 	ref = cli_malloc(siz);

-	fail_unless(!!ref, "unable to malloc buffer: %d", siz);

+	fail_unless_fmt(!!ref, "unable to malloc buffer: %d", siz);

-	fail_unless(lseek(ref_fd, 0, SEEK_SET) == 0,"lseek failed");

+	fail_unless_fmt(lseek(ref_fd, 0, SEEK_SET) == 0,"lseek failed");

 	nread = read(ref_fd, ref, siz);

-        fail_unless(nread == siz, "short read, expected: %ld, was: %ld", siz, nread);

+        fail_unless_fmt(nread == siz, "short read, expected: %ld, was: %ld", siz, nread);

 	close(ref_fd);

 	diff_file_mem(fd, ref, siz);

 	free(ref);

@@ -126,10 +126,10 @@ START_TEST (test_disasm_basic) {

   fail_unless(fstat(ref, &st)!=-1, "fstat failed");

   disasmbuf(buf, sizeof(buf), fd);

   size = lseek(fd, 0, SEEK_CUR);

-  fail_unless(size==st.st_size, "disasm size mismatch(value %u, expected: %u)", size, st.st_size);

+  fail_unless_fmt(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(d!=NULL, "disasm malloc(%u) failed", size);

+  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");

   close(fd);

@@ -252,7 +252,7 @@ static void tokenizer_test(const char *in, const char *expected, int split)

 	fd = open(filename, O_RDONLY);

 	if(fd < 0) {

 		jstest_teardown();

-		fail("failed to open output file: %s", filename);

+		fail_fmt("failed to open output file: %s", filename);

 	}

 	diff_file_mem(fd, expected, len);

@@ -77,8 +77,8 @@ START_TEST (test_ac_scanbuff) {

     for(i = 0; ac_testdata[i].data; i++) {

 	ret = cli_ac_scanbuff(ac_testdata[i].data, strlen(ac_testdata[i].data), &virname, NULL, NULL, root, &mdata, 0, 0, -1, NULL, AC_SCAN_VIR, NULL);

-	fail_unless(ret == CL_VIRUS, "cli_ac_scanbuff() failed for %s", ac_testdata[i].virname);

-	fail_unless(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);

+	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);

     }

     cli_ac_freedata(&mdata);

@@ -52,7 +52,7 @@ static int cb_expect_single(void *cbdata, const char *suffix, size_t len, const

 {

 	const char *expected = cbdata;

 	cb_called++;

-	fail_unless(suffix && strcmp(suffix, expected) == 0,

+	fail_unless_fmt(suffix && strcmp(suffix, expected) == 0,

 			"suffix mismatch, was: %s, expected: %s\n", suffix, expected);

 	return 0;

 }

@@ -107,11 +107,11 @@ static int cb_expect_multi(void *cbdata, const char *suffix, size_t len, const s

 	const char **exp = cbdata;

 	fail_unless(!!exp, "expected data");

 	exp++;

-	fail_unless(!!*exp, "expected no suffix, got: %s\n",suffix);

-	fail_unless(!!exp[cb_called], "expected less suffixes, but already got: %d\n", cb_called);

-	fail_unless(strcmp(exp[cb_called], suffix) == 0,

+	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,

 			"suffix mismatch, was: %s, expected: %s\n",suffix, exp[cb_called]);

-	fail_unless(strlen(suffix) == len, "incorrect suffix len, expected: %d, got: %d\n", strlen(suffix), len);

+	fail_unless_fmt(strlen(suffix) == len, "incorrect suffix len, expected: %d, got: %d\n", strlen(suffix), len);

 	cb_called++;

 	return 0;

 }

@@ -134,7 +134,7 @@ START_TEST (test_suffix)

 	free(preg);

 	p++;

 	while(*p++) n++;

-	fail_unless(cb_called == n,

+	fail_unless_fmt(cb_called == n,

 			"suffix number mismatch, expected: %d, was: %d\n", n, cb_called);

 }

 END_TEST

@@ -374,30 +374,30 @@ static void do_phishing_test(const struct rtest *rtest)

 	fail_unless(rc == CL_CLEAN,"phishingScan");

 	switch(rtest->result) {

 		case 0:

-			fail_unless(ctx.found_possibly_unwanted,

+			fail_unless_fmt(ctx.found_possibly_unwanted,

 					"this should be phishing, realURL: %s, displayURL: %s",

 					rtest->realurl, rtest->displayurl);

 			break;

 		case 1:

-			fail_unless(!ctx.found_possibly_unwanted,

+			fail_unless_fmt(!ctx.found_possibly_unwanted,

 					"this should be whitelisted, realURL: %s, displayURL: %s",

 					rtest->realurl, rtest->displayurl);

 			break;

 		case 2:

-			fail_unless(!ctx.found_possibly_unwanted,

+			fail_unless_fmt(!ctx.found_possibly_unwanted,

 					"this should be clean, realURL: %s, displayURL: %s",

 					rtest->realurl, rtest->displayurl);

 			break;

 		case 3:

 			if(!loaded_2)

-				fail_unless(!ctx.found_possibly_unwanted,

+				fail_unless_fmt(!ctx.found_possibly_unwanted,

 					"this should be clean, realURL: %s, displayURL: %s",

 					rtest->realurl, rtest->displayurl);

 			else {

-				fail_unless(ctx.found_possibly_unwanted,

+				fail_unless_fmt(ctx.found_possibly_unwanted,

 					"this should be blacklisted, realURL: %s, displayURL: %s",

 					rtest->realurl, rtest->displayurl);

-				fail_unless(!strstr((const char*)ctx.virname,"Blacklisted"),

+				fail_unless_fmt(!strstr((const char*)ctx.virname,"Blacklisted"),

 						"should be blacklisted, but is: %s\n", ctx.virname);

 			}

 			break;

@@ -59,12 +59,12 @@ START_TEST (test_uniq_known) {

   for(i=0; tests[i].expected; i++) {

     u = uniq_add(U, tests[i].key, tests[i].key_len, &hash);

-    fail_unless(u==0 && strcmp(hash, tests[i].expected)==0, "uniq_add(%s) = %u - expected %s, got %s", tests[i].key, u, tests[i].expected, hash);

+    fail_unless_fmt(u==0 && 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++) {

     u = uniq_get(U, tests[i].key, tests[i].key_len, &hash);

-    fail_unless(u==1 && strcmp(hash, tests[i].expected)==0, "uniq_get(%s) = %u - expected %s, got %s", tests[i].key, u, tests[i].expected, hash);

+    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);

   }

   uniq_free(U);

@@ -86,7 +86,7 @@ START_TEST (test_uniq_colls) {

   for (i=0; i<4; i++) {

     u = uniq_add(U, tests[i], strlen(tests[i]), NULL);

-    fail_unless(u+i==4, "uniq_get(%s) = %u - expected %u", tests[i], u, 4-i);

+    fail_unless_fmt(u+i==4, "uniq_get(%s) = %u - expected %u", tests[i], u, 4-i);

   }

   uniq_free(U);

@@ -4,6 +4,15 @@

 #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

+

 Suite *test_jsnorm_suite(void);

 Suite *test_str_suite(void);

 Suite *test_regex_suite(void);