wvtest/c/wvtest.c - vendor/google/platform - Git at Google

 /*
  * WvTest:
  *   Copyright (C)1997-2012 Net Integration Technologies and contributors.
  *       Licensed under the GNU Library General Public License, version 2.
  *       See the included file named LICENSE for license information.
  *       You can get wvtest from: http://github.com/apenwarr/wvtest
  */
 #include "wvtest.h"
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <ctype.h>
 #ifdef _WIN32
 #include <direct.h>
 #else
 #include <unistd.h>
 #include <sys/wait.h>
 #endif
 #include <errno.h>
 #include <signal.h>

 #include <stdlib.h>

 #ifdef HAVE_VALGRIND_MEMCHECK_H
 # include <valgrind/memcheck.h>
 # include <valgrind/valgrind.h>
 #else
 # define VALGRIND_COUNT_ERRORS 0
 # define VALGRIND_DO_LEAK_CHECK
 # define VALGRIND_COUNT_LEAKS(a,b,c,d) (a=b=c=d=0)
 #endif

 #define MAX_TEST_TIME 40     // max seconds for a single test to run
 #define MAX_TOTAL_TIME 120*60 // max seconds for the entire suite to run

 #define TEST_START_FORMAT "! %s:%-5d %-40s "

 static int fails, runs;
 static time_t start_time;
 static bool run_twice;

 static void alarm_handler(int sig);

 static int memerrs()
 {
     return (int)VALGRIND_COUNT_ERRORS;
 }

 static int memleaks()
 {
     int leaked = 0, dubious = 0, reachable = 0, suppressed = 0;
     VALGRIND_DO_LEAK_CHECK;
     VALGRIND_COUNT_LEAKS(leaked, dubious, reachable, suppressed);
     printf("memleaks: sure:%d dubious:%d reachable:%d suppress:%d\n",
 	   leaked, dubious, reachable, suppressed);
     fflush(stdout);

     // dubious+reachable are normally non-zero because of globals...
     // return leaked+dubious+reachable;
     return leaked;
 }

 // Return 1 if no children are running or zombies, 0 if there are any running
 // or zombie children.
 // Will wait for any already-terminated children first.
 // Passes if no rogue children were running, fails otherwise.
 // If your test gets a failure in here, either you're not killing all your
 // children, or you're not calling waitpid(2) on all of them.
 static bool no_running_children()
 {
 #ifndef _WIN32
     pid_t wait_result;

     // Acknowledge and complain about any zombie children
     do
     {
 	int status = 0;
         wait_result = waitpid(-1, &status, WNOHANG);

         if (wait_result > 0)
         {
             char buf[256];
             snprintf(buf, sizeof(buf) - 1, "%d", wait_result);
             buf[sizeof(buf)-1] = '\0';
             WVFAILEQSTR("Unclaimed dead child process", buf);
         }
     } while (wait_result > 0);

     // There should not be any running children, so waitpid should return -1
     WVPASS(errno == ECHILD);
     WVPASS(wait_result == -1);
     return (wait_result == -1 && errno == ECHILD);
 #endif
     return true;
 }


 static void alarm_handler(int sig)
 {
     printf("\n! WvTest  Current test took longer than %d seconds!  FAILED\n",
 	   MAX_TEST_TIME);
     fflush(stdout);
     abort();
 }


 static const char *pathstrip(const char *filename)
 {
     const char *cptr;
     cptr = strrchr(filename, '/');
     if (cptr) filename = cptr + 1;
     cptr = strrchr(filename, '\\');
     if (cptr) filename = cptr + 1;
     return filename;
 }

 static bool prefix_match(const char *s, char * const *prefixes)
 {
     char *const *prefix;
     for (prefix = prefixes; prefix && *prefix; prefix++)
     {
 	if (!strncasecmp(s, *prefix, strlen(*prefix)))
 	    return true;
     }
     return false;
 }

 static struct WvTest *wvtest_first, *wvtest_last;

 void wvtest_register(struct WvTest *ptr)
 {
 	if (wvtest_first == NULL)
 		wvtest_first = ptr;
 	else
 		wvtest_last->next = ptr;
 	wvtest_last = ptr;
 	wvtest_last->next = NULL;
 }

 int wvtest_run_all(char * const *prefixes)
 {
     int old_valgrind_errs = 0, new_valgrind_errs;
     int old_valgrind_leaks = 0, new_valgrind_leaks;

 #ifdef _WIN32
     /* I should be doing something to do with SetTimer here,
      * not sure exactly what just yet */
 #else
     char *disable = getenv("WVTEST_DISABLE_TIMEOUT");
     if (disable != NULL && disable[0] != '\0' && disable[0] != '0')
         signal(SIGALRM, SIG_IGN);
     else
         signal(SIGALRM, alarm_handler);
     alarm(MAX_TEST_TIME);
 #endif
     start_time = time(NULL);

     // make sure we can always start out in the same directory, so tests have
     // access to their files.  If a test uses chdir(), we want to be able to
     // reverse it.
     char wd[1024];
     if (!getcwd(wd, sizeof(wd)))
 	strcpy(wd, ".");

     const char *slowstr1 = getenv("WVTEST_MIN_SLOWNESS");
     const char *slowstr2 = getenv("WVTEST_MAX_SLOWNESS");
     int min_slowness = 0, max_slowness = 65535;
     if (slowstr1) min_slowness = atoi(slowstr1);
     if (slowstr2) max_slowness = atoi(slowstr2);

 #ifdef _WIN32
     run_twice = false;
 #else
     char *parallel_str = getenv("WVTEST_PARALLEL");
     if (parallel_str)
         run_twice = atoi(parallel_str) > 0;
 #endif

     // there are lots of fflush() calls in here because stupid win32 doesn't
     // flush very often by itself.
     fails = runs = 0;
     struct WvTest *cur;

     for (cur = wvtest_first; cur != NULL; cur = cur->next)
     {
 	if (cur->slowness <= max_slowness
 	    && cur->slowness >= min_slowness
 	    && (!prefixes
 		|| prefix_match(cur->idstr, prefixes)
 		|| prefix_match(cur->descr, prefixes)))
 	{
 #ifndef _WIN32
             // set SIGPIPE back to default, helps catch tests which don't set
             // this signal to SIG_IGN (which is almost always what you want)
             // on startup
             signal(SIGPIPE, SIG_DFL);

             pid_t child = 0;
             if (run_twice)
             {
                 // I see everything twice!
                 printf("Running test in parallel.\n");
                 child = fork();
             }
 #endif

 	    printf("\nTesting \"%s\" in %s:\n", cur->descr, cur->idstr);
 	    fflush(stdout);

 	    cur->main();
 	    if (chdir(wd)) {
 		perror("Unable to change back to original directory");
 	    }

 	    new_valgrind_errs = memerrs();
 	    WVPASS(new_valgrind_errs == old_valgrind_errs);
 	    old_valgrind_errs = new_valgrind_errs;

 	    new_valgrind_leaks = memleaks();
 	    WVPASS(new_valgrind_leaks == old_valgrind_leaks);
 	    old_valgrind_leaks = new_valgrind_leaks;

 	    fflush(stderr);
 	    printf("\n");
 	    fflush(stdout);

 #ifndef _WIN32
             if (run_twice)
             {
                 if (!child)
                 {
                     // I see everything once!
                     printf("Child exiting.\n");
                     _exit(0);
                 }
                 else
                 {
                     printf("Waiting for child to exit.\n");
                     int result;
                     while ((result = waitpid(child, NULL, 0)) == -1 &&
                             errno == EINTR)
                         printf("Waitpid interrupted, retrying.\n");
                 }
             }
 #endif

             WVPASS(no_running_children());
 	}
     }

     WVPASS(runs > 0);

     if (prefixes && *prefixes && **prefixes)
 	printf("WvTest: WARNING: only ran tests starting with "
 	       "specifed prefix(es).\n");
     else
 	printf("WvTest: ran all tests.\n");
     printf("WvTest: %d test%s, %d failure%s.\n",
 	   runs, runs==1 ? "" : "s",
 	   fails, fails==1 ? "": "s");
     fflush(stdout);

     return fails != 0;
 }


 // If we aren't running in parallel, we want to output the name of the test
 // before we run it, so we know what happened if it crashes.  If we are
 // running in parallel, outputting this information in multiple printf()s
 // can confuse parsers, so we want to output everything in one printf().
 //
 // This function gets called by both start() and check().  If we're not
 // running in parallel, just print the data.  If we're running in parallel,
 // and we're starting a test, save a copy of the file/line/description until
 // the test is done and we can output it all at once.
 //
 // Yes, this is probably the worst API of all time.
 static void print_result_str(bool start, const char *_file, int _line,
 			     const char *_condstr, const char *result)
 {
     static char *file;
     static char *condstr;
     static int line;
     char *cptr;

     if (start)
     {
         if (file)
             free(file);
         if (condstr)
             free(condstr);
         file = strdup(pathstrip(_file));
         condstr = strdup(_condstr);
         line = _line;

         for (cptr = condstr; *cptr; cptr++)
         {
             if (!isprint((unsigned char)*cptr))
                 *cptr = '!';
         }
     }

     if (run_twice)
     {
         if (!start)
             printf(TEST_START_FORMAT "%s\n", file, line, condstr, result);
     }
     else
     {
         if (start)
             printf(TEST_START_FORMAT, file, line, condstr);
         else
             printf("%s\n", result);
     }
     fflush(stdout);

     if (!start)
     {
         if (file)
             free(file);
         if (condstr)
             free(condstr);
         file = condstr = NULL;
     }
 }

 static inline void
 print_result(bool start, const char *file, int line,
 	     const char *condstr, bool result)
 {
 	print_result_str(start, file, line, condstr, result ? "ok" : "FAILED");
 }

 void wvtest_start(const char *file, int line, const char *condstr)
 {
     // Either print the file, line, and condstr, or save them for later.
     print_result(true, file, line, condstr, false);
 }


 void wvtest_check(bool cond, const char *reason)
 {
 #ifndef _WIN32
     alarm(MAX_TEST_TIME); // restart per-test timeout
 #endif
     if (!start_time) start_time = time(NULL);

     if (time(NULL) - start_time > MAX_TOTAL_TIME)
     {
 	printf("\n! WvTest   Total run time exceeded %d seconds!  FAILED\n",
 	       MAX_TOTAL_TIME);
 	fflush(stdout);
 	abort();
     }

     runs++;

     print_result_str(false, NULL, 0, NULL, cond ? "ok" : (reason ? reason : "FAILED"));

     if (!cond)
     {
 	fails++;

 	if (getenv("WVTEST_DIE_FAST"))
 	    abort();
     }
 }


 bool wvtest_start_check_eq(const char *file, int line,
 			   int a, int b, bool expect_pass)
 {
     size_t len = 11 + 11 + 8 + 1;
     char *str = malloc(len);
     sprintf(str, "%d %s %d", a, expect_pass ? "==" : "!=", b);

     wvtest_start(file, line, str);
     free(str);

     bool cond = (a == b);
     if (!expect_pass)
         cond = !cond;

     wvtest_check(cond, NULL);
     return cond;
 }


 bool wvtest_start_check_lt(const char *file, int line,
 			   int a, int b)
 {
     size_t len = 11 + 11 + 8 + 1;
     char *str = malloc(len);
     sprintf(str, "%d < %d", a, b);

     wvtest_start(file, line, str);
     free(str);

     bool cond = (a < b);
     wvtest_check(cond, NULL);
     return cond;
 }
 bool wvtest_start_check_eq_str(const char *file, int line,
 			       const char *a, const char *b, bool expect_pass)
 {
     if (!a) a = "";
     if (!b) b = "";

     size_t len = strlen(a) + strlen(b) + 8 + 1;
     char *str = malloc(len);
     sprintf(str, "[%s] %s [%s]", a, expect_pass ? "==" : "!=", b);

     wvtest_start(file, line, str);

     bool cond = !strcmp(a, b);
     if (!expect_pass)
         cond = !cond;

     wvtest_check(cond, NULL);
     return cond;
 }


 bool wvtest_start_check_lt_str(const char *file, int line,
 			       const char *a, const char *b)
 {
     if (!a) a = "";
     if (!b) b = "";

     size_t len = strlen(a) + strlen(b) + 8 + 1;
     char *str = malloc(len);
     sprintf(str, "[%s] < [%s]", a, b);

     wvtest_start(file, line, str);
     free(str);

     bool cond = strcmp(a, b) < 0;
     wvtest_check(cond, NULL);
     return cond;
 }
	/*
	* WvTest:
	* Copyright (C)1997-2012 Net Integration Technologies and contributors.
	* Licensed under the GNU Library General Public License, version 2.
	* See the included file named LICENSE for license information.
	* You can get wvtest from: http://github.com/apenwarr/wvtest
	*/
	#include "wvtest.h"
	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include <ctype.h>
	#ifdef _WIN32
	#include <direct.h>
	#else
	#include <unistd.h>
	#include <sys/wait.h>
	#endif
	#include <errno.h>
	#include <signal.h>

	#include <stdlib.h>

	#ifdef HAVE_VALGRIND_MEMCHECK_H
	# include <valgrind/memcheck.h>
	# include <valgrind/valgrind.h>
	#else
	# define VALGRIND_COUNT_ERRORS 0
	# define VALGRIND_DO_LEAK_CHECK
	# define VALGRIND_COUNT_LEAKS(a,b,c,d) (a=b=c=d=0)
	#endif

	#define MAX_TEST_TIME 40 // max seconds for a single test to run
	#define MAX_TOTAL_TIME 120*60 // max seconds for the entire suite to run

	#define TEST_START_FORMAT "! %s:%-5d %-40s "

	static int fails, runs;
	static time_t start_time;
	static bool run_twice;

	static void alarm_handler(int sig);

	static int memerrs()
	{
	return (int)VALGRIND_COUNT_ERRORS;
	}

	static int memleaks()
	{
	int leaked = 0, dubious = 0, reachable = 0, suppressed = 0;
	VALGRIND_DO_LEAK_CHECK;
	VALGRIND_COUNT_LEAKS(leaked, dubious, reachable, suppressed);
	printf("memleaks: sure:%d dubious:%d reachable:%d suppress:%d\n",
	leaked, dubious, reachable, suppressed);
	fflush(stdout);

	// dubious+reachable are normally non-zero because of globals...
	// return leaked+dubious+reachable;
	return leaked;
	}

	// Return 1 if no children are running or zombies, 0 if there are any running
	// or zombie children.
	// Will wait for any already-terminated children first.
	// Passes if no rogue children were running, fails otherwise.
	// If your test gets a failure in here, either you're not killing all your
	// children, or you're not calling waitpid(2) on all of them.
	static bool no_running_children()
	{
	#ifndef _WIN32
	pid_t wait_result;

	// Acknowledge and complain about any zombie children
	do
	{
	int status = 0;
	wait_result = waitpid(-1, &status, WNOHANG);

	if (wait_result > 0)
	{
	char buf[256];
	snprintf(buf, sizeof(buf) - 1, "%d", wait_result);
	buf[sizeof(buf)-1] = '\0';
	WVFAILEQSTR("Unclaimed dead child process", buf);
	}
	} while (wait_result > 0);

	// There should not be any running children, so waitpid should return -1
	WVPASS(errno == ECHILD);
	WVPASS(wait_result == -1);
	return (wait_result == -1 && errno == ECHILD);
	#endif
	return true;
	}


	static void alarm_handler(int sig)
	{
	printf("\n! WvTest Current test took longer than %d seconds! FAILED\n",
	MAX_TEST_TIME);
	fflush(stdout);
	abort();
	}


	static const char pathstrip(const char filename)
	{
	const char *cptr;
	cptr = strrchr(filename, '/');
	if (cptr) filename = cptr + 1;
	cptr = strrchr(filename, '\\');
	if (cptr) filename = cptr + 1;
	return filename;
	}

	static bool prefix_match(const char s, char const *prefixes)
	{
	char const prefix;
	for (prefix = prefixes; prefix && *prefix; prefix++)
	{
	if (!strncasecmp(s, prefix, strlen(prefix)))
	return true;
	}
	return false;
	}

	static struct WvTest wvtest_first, wvtest_last;

	void wvtest_register(struct WvTest *ptr)
	{
	if (wvtest_first == NULL)
	wvtest_first = ptr;
	else
	wvtest_last->next = ptr;
	wvtest_last = ptr;
	wvtest_last->next = NULL;
	}

	int wvtest_run_all(char * const *prefixes)
	{
	int old_valgrind_errs = 0, new_valgrind_errs;
	int old_valgrind_leaks = 0, new_valgrind_leaks;

	#ifdef _WIN32
	/* I should be doing something to do with SetTimer here,
	* not sure exactly what just yet */
	#else
	char *disable = getenv("WVTEST_DISABLE_TIMEOUT");
	if (disable != NULL && disable[0] != '\0' && disable[0] != '0')
	signal(SIGALRM, SIG_IGN);
	else
	signal(SIGALRM, alarm_handler);
	alarm(MAX_TEST_TIME);
	#endif
	start_time = time(NULL);

	// make sure we can always start out in the same directory, so tests have
	// access to their files. If a test uses chdir(), we want to be able to
	// reverse it.
	char wd[1024];
	if (!getcwd(wd, sizeof(wd)))
	strcpy(wd, ".");

	const char *slowstr1 = getenv("WVTEST_MIN_SLOWNESS");
	const char *slowstr2 = getenv("WVTEST_MAX_SLOWNESS");
	int min_slowness = 0, max_slowness = 65535;
	if (slowstr1) min_slowness = atoi(slowstr1);
	if (slowstr2) max_slowness = atoi(slowstr2);

	#ifdef _WIN32
	run_twice = false;
	#else
	char *parallel_str = getenv("WVTEST_PARALLEL");
	if (parallel_str)
	run_twice = atoi(parallel_str) > 0;
	#endif

	// there are lots of fflush() calls in here because stupid win32 doesn't
	// flush very often by itself.
	fails = runs = 0;
	struct WvTest *cur;

	for (cur = wvtest_first; cur != NULL; cur = cur->next)
	{
	if (cur->slowness <= max_slowness
	&& cur->slowness >= min_slowness
	&& (!prefixes
	\|\| prefix_match(cur->idstr, prefixes)
	\|\| prefix_match(cur->descr, prefixes)))
	{
	#ifndef _WIN32
	// set SIGPIPE back to default, helps catch tests which don't set
	// this signal to SIG_IGN (which is almost always what you want)
	// on startup
	signal(SIGPIPE, SIG_DFL);

	pid_t child = 0;
	if (run_twice)
	{
	// I see everything twice!
	printf("Running test in parallel.\n");
	child = fork();
	}
	#endif

	printf("\nTesting \"%s\" in %s:\n", cur->descr, cur->idstr);
	fflush(stdout);

	cur->main();
	if (chdir(wd)) {
	perror("Unable to change back to original directory");
	}

	new_valgrind_errs = memerrs();
	WVPASS(new_valgrind_errs == old_valgrind_errs);
	old_valgrind_errs = new_valgrind_errs;

	new_valgrind_leaks = memleaks();
	WVPASS(new_valgrind_leaks == old_valgrind_leaks);
	old_valgrind_leaks = new_valgrind_leaks;

	fflush(stderr);
	printf("\n");
	fflush(stdout);

	#ifndef _WIN32
	if (run_twice)
	{
	if (!child)
	{
	// I see everything once!
	printf("Child exiting.\n");
	_exit(0);
	}
	else
	{
	printf("Waiting for child to exit.\n");
	int result;
	while ((result = waitpid(child, NULL, 0)) == -1 &&
	errno == EINTR)
	printf("Waitpid interrupted, retrying.\n");
	}
	}
	#endif

	WVPASS(no_running_children());
	}
	}

	WVPASS(runs > 0);

	if (prefixes && prefixes && *prefixes)
	printf("WvTest: WARNING: only ran tests starting with "
	"specifed prefix(es).\n");
	else
	printf("WvTest: ran all tests.\n");
	printf("WvTest: %d test%s, %d failure%s.\n",
	runs, runs==1 ? "" : "s",
	fails, fails==1 ? "": "s");
	fflush(stdout);

	return fails != 0;
	}


	// If we aren't running in parallel, we want to output the name of the test
	// before we run it, so we know what happened if it crashes. If we are
	// running in parallel, outputting this information in multiple printf()s
	// can confuse parsers, so we want to output everything in one printf().
	//
	// This function gets called by both start() and check(). If we're not
	// running in parallel, just print the data. If we're running in parallel,
	// and we're starting a test, save a copy of the file/line/description until
	// the test is done and we can output it all at once.
	//
	// Yes, this is probably the worst API of all time.
	static void print_result_str(bool start, const char *_file, int _line,
	const char _condstr, const char result)
	{
	static char *file;
	static char *condstr;
	static int line;
	char *cptr;

	if (start)
	{
	if (file)
	free(file);
	if (condstr)
	free(condstr);
	file = strdup(pathstrip(_file));
	condstr = strdup(_condstr);
	line = _line;

	for (cptr = condstr; *cptr; cptr++)
	{
	if (!isprint((unsigned char)*cptr))
	*cptr = '!';
	}
	}

	if (run_twice)
	{
	if (!start)
	printf(TEST_START_FORMAT "%s\n", file, line, condstr, result);
	}
	else
	{
	if (start)
	printf(TEST_START_FORMAT, file, line, condstr);
	else
	printf("%s\n", result);
	}
	fflush(stdout);

	if (!start)
	{
	if (file)
	free(file);
	if (condstr)
	free(condstr);
	file = condstr = NULL;
	}
	}

	static inline void
	print_result(bool start, const char *file, int line,
	const char *condstr, bool result)
	{
	print_result_str(start, file, line, condstr, result ? "ok" : "FAILED");
	}

	void wvtest_start(const char file, int line, const char condstr)
	{
	// Either print the file, line, and condstr, or save them for later.
	print_result(true, file, line, condstr, false);
	}


	void wvtest_check(bool cond, const char *reason)
	{
	#ifndef _WIN32
	alarm(MAX_TEST_TIME); // restart per-test timeout
	#endif
	if (!start_time) start_time = time(NULL);

	if (time(NULL) - start_time > MAX_TOTAL_TIME)
	{
	printf("\n! WvTest Total run time exceeded %d seconds! FAILED\n",
	MAX_TOTAL_TIME);
	fflush(stdout);
	abort();
	}

	runs++;

	print_result_str(false, NULL, 0, NULL, cond ? "ok" : (reason ? reason : "FAILED"));

	if (!cond)
	{
	fails++;

	if (getenv("WVTEST_DIE_FAST"))
	abort();
	}
	}


	bool wvtest_start_check_eq(const char *file, int line,
	int a, int b, bool expect_pass)
	{
	size_t len = 11 + 11 + 8 + 1;
	char *str = malloc(len);
	sprintf(str, "%d %s %d", a, expect_pass ? "==" : "!=", b);

	wvtest_start(file, line, str);
	free(str);

	bool cond = (a == b);
	if (!expect_pass)
	cond = !cond;

	wvtest_check(cond, NULL);
	return cond;
	}


	bool wvtest_start_check_lt(const char *file, int line,
	int a, int b)
	{
	size_t len = 11 + 11 + 8 + 1;
	char *str = malloc(len);
	sprintf(str, "%d < %d", a, b);

	wvtest_start(file, line, str);
	free(str);

	bool cond = (a < b);
	wvtest_check(cond, NULL);
	return cond;
	}
	bool wvtest_start_check_eq_str(const char *file, int line,
	const char a, const char b, bool expect_pass)
	{
	if (!a) a = "";
	if (!b) b = "";

	size_t len = strlen(a) + strlen(b) + 8 + 1;
	char *str = malloc(len);
	sprintf(str, "[%s] %s [%s]", a, expect_pass ? "==" : "!=", b);

	wvtest_start(file, line, str);

	bool cond = !strcmp(a, b);
	if (!expect_pass)
	cond = !cond;

	wvtest_check(cond, NULL);
	return cond;
	}


	bool wvtest_start_check_lt_str(const char *file, int line,
	const char a, const char b)
	{
	if (!a) a = "";
	if (!b) b = "";

	size_t len = strlen(a) + strlen(b) + 8 + 1;
	char *str = malloc(len);
	sprintf(str, "[%s] < [%s]", a, b);

	wvtest_start(file, line, str);
	free(str);

	bool cond = strcmp(a, b) < 0;
	wvtest_check(cond, NULL);
	return cond;
	}