Commit f1d751b7 authored by Tim Janik's avatar Tim Janik

Implemented g_test_trap_fork() API.

* gtestframework.h: added g_assert_cmphex(). reworked g_test_trap*() API.

* gtestframework.c: implemented g_test_trap_fork() API.

svn path=/trunk/; revision=5879
parent ca1c4240
......@@ -18,8 +18,17 @@
*/
#include "config.h"
#include "gtestframework.h"
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif /* HAVE_SYS_SELECT_H */
/* --- structures --- */
struct GTestCase
......@@ -37,7 +46,11 @@ struct GTestSuite
GSList *cases;
};
/* --- prototypes --- */
static void test_trap_clear (void);
/* --- variables --- */
static int test_stdmsg = 1;
static gboolean test_mode_quick = TRUE;
static gboolean test_mode_perf = FALSE;
static gboolean test_mode_fatal = TRUE;
......@@ -51,6 +64,10 @@ static gchar *test_run_name = "";
static GSList *test_paths = NULL;
static GTestSuite *test_suite_root = NULL;
static GSList *test_run_free_queue = NULL;
static int test_trap_last_status = 0;
static int test_trap_last_pid = 0;
static char *test_trap_last_stdout = NULL;
static char *test_trap_last_stderr = NULL;
/* --- functions --- */
static void
......@@ -270,14 +287,15 @@ test_case_run (GTestCase *tc)
if (tc->fixture_setup)
tc->fixture_setup (fixture);
tc->fixture_test (fixture);
if (tc->fixture_teardown)
tc->fixture_teardown (fixture);
test_trap_clear();
while (test_run_free_queue)
{
gpointer freeme = test_run_free_queue->data;
test_run_free_queue = g_slist_delete_link (test_run_free_queue, test_run_free_queue);
g_free (freeme);
}
if (tc->fixture_teardown)
tc->fixture_teardown (fixture);
g_free (fixture);
if (!test_run_quiet)
g_print ("OK\n");
......@@ -398,6 +416,7 @@ g_assertion_message_cmpnum (const char *domain,
switch (numtype)
{
case 'i': s = g_strdup_printf ("assertion failed (%s): (%.0Lf %s %.0Lf)", expr, arg1, cmp, arg2); break;
case 'x': s = g_strdup_printf ("assertion failed (%s): (0x%08Lx %s 0x%08Lx)", expr, (guint64) arg1, cmp, (guint64) arg2); break;
case 'f': s = g_strdup_printf ("assertion failed (%s): (%.9Lg %s %.9Lg)", expr, arg1, cmp, arg2); break;
/* ideally use: floats=%.7g double=%.17g */
}
......@@ -437,3 +456,300 @@ g_strcmp0 (const char *str1,
return str1 != str2;
return strcmp (str1, str2);
}
static int /* 0 on success */
kill_child (int pid,
int *status,
int patience)
{
int wr;
if (patience >= 3) /* try graceful reap */
{
if (waitpid (pid, status, WNOHANG) > 0)
return 0;
}
if (patience >= 2) /* try SIGHUP */
{
kill (pid, SIGHUP);
if (waitpid (pid, status, WNOHANG) > 0)
return 0;
g_usleep (20 * 1000); /* give it some scheduling/shutdown time */
if (waitpid (pid, status, WNOHANG) > 0)
return 0;
g_usleep (50 * 1000); /* give it some scheduling/shutdown time */
if (waitpid (pid, status, WNOHANG) > 0)
return 0;
g_usleep (100 * 1000); /* give it some scheduling/shutdown time */
if (waitpid (pid, status, WNOHANG) > 0)
return 0;
}
if (patience >= 1) /* try SIGTERM */
{
kill (pid, SIGTERM);
if (waitpid (pid, status, WNOHANG) > 0)
return 0;
g_usleep (200 * 1000); /* give it some scheduling/shutdown time */
if (waitpid (pid, status, WNOHANG) > 0)
return 0;
g_usleep (400 * 1000); /* give it some scheduling/shutdown time */
if (waitpid (pid, status, WNOHANG) > 0)
return 0;
}
/* finish it off */
kill (pid, SIGKILL);
do
wr = waitpid (pid, status, 0);
while (wr < 0 && errno == EINTR);
return wr;
}
static inline int
g_string_must_read (GString *gstring,
int fd)
{
#define STRING_BUFFER_SIZE 4096
char buf[STRING_BUFFER_SIZE];
gssize bytes;
again:
bytes = read (fd, buf, sizeof (buf));
if (bytes == 0)
return 0; /* EOF, calling this function assumes data is available */
else if (bytes > 0)
{
g_string_append_len (gstring, buf, bytes);
return 1;
}
else if (bytes < 0 && errno == EINTR)
goto again;
else /* bytes < 0 */
{
g_warning ("failed to read() from child process (%d): %s", test_trap_last_pid, g_strerror (errno));
return 1; /* ignore error after warning */
}
}
static inline void
g_string_write_out (GString *gstring,
int outfd,
int *stringpos)
{
if (*stringpos < gstring->len)
{
int r;
do
r = write (outfd, gstring->str + *stringpos, gstring->len - *stringpos);
while (r < 0 && errno == EINTR);
*stringpos += MAX (r, 0);
}
}
static int
sane_dup2 (int fd1,
int fd2)
{
int ret;
do
ret = dup2 (fd1, fd2);
while (ret < 0 && errno == EINTR);
return ret;
}
static void
test_trap_clear (void)
{
test_trap_last_status = 0;
test_trap_last_pid = 0;
g_free (test_trap_last_stdout);
test_trap_last_stdout = NULL;
g_free (test_trap_last_stderr);
test_trap_last_stderr = NULL;
}
static guint64
test_time_stamp (void)
{
GTimeVal tv;
guint64 stamp;
g_get_current_time (&tv);
stamp = tv.tv_sec;
stamp = stamp * 1000000 + tv.tv_usec;
return stamp;
}
gboolean
g_test_trap_fork (guint64 usec_timeout,
GTestTrapFlags test_trap_flags)
{
int stdout_pipe[2] = { -1, -1 };
int stderr_pipe[2] = { -1, -1 };
int stdtst_pipe[2] = { -1, -1 };
test_trap_clear();
if (pipe (stdout_pipe) < 0 || pipe (stderr_pipe) < 0 || pipe (stdtst_pipe) < 0)
g_error ("failed to create pipes to fork test program: %s", g_strerror (errno));
signal (SIGCHLD, SIG_DFL);
test_trap_last_pid = fork ();
if (test_trap_last_pid < 0)
g_error ("failed to fork test program: %s", g_strerror (errno));
if (test_trap_last_pid == 0) /* child */
{
int fd0 = -1;
close (stdout_pipe[0]);
close (stderr_pipe[0]);
close (stdtst_pipe[0]);
if (!(test_trap_flags & G_TEST_TRAP_INHERIT_STDIN))
fd0 = open ("/dev/null", O_RDONLY);
if (sane_dup2 (stdout_pipe[1], 1) < 0 || sane_dup2 (stderr_pipe[1], 2) < 0 || (fd0 >= 0 && sane_dup2 (fd0, 0) < 0))
g_error ("failed to dup2() in forked test program: %s", g_strerror (errno));
if (fd0 >= 3)
close (fd0);
if (stdout_pipe[1] >= 3)
close (stdout_pipe[1]);
if (stderr_pipe[1] >= 3)
close (stderr_pipe[1]);
test_stdmsg = stdtst_pipe[1];
return TRUE;
}
else /* parent */
{
GString *sout = g_string_new (NULL);
GString *serr = g_string_new (NULL);
GString *stst = g_string_new (NULL);
guint64 sstamp;
int soutpos = 0, serrpos = 0, ststpos = 0, wr, need_wait = TRUE;
close (stdout_pipe[1]);
close (stderr_pipe[1]);
close (stdtst_pipe[1]);
sstamp = test_time_stamp();
/* read data until we get EOF on all pipes */
while (stdout_pipe[0] >= 0 || stderr_pipe[0] >= 0 || stdtst_pipe[0] > 0)
{
fd_set fds;
struct timeval tv;
FD_ZERO (&fds);
if (stdout_pipe[0] >= 0)
FD_SET (stdout_pipe[0], &fds);
if (stderr_pipe[0] >= 0)
FD_SET (stderr_pipe[0], &fds);
if (stdtst_pipe[0] >= 0)
FD_SET (stdtst_pipe[0], &fds);
tv.tv_sec = 0;
tv.tv_usec = MIN (usec_timeout ? usec_timeout : 1000000, 100 * 1000); // sleep at most 0.5 seconds to catch clock skews, etc.
int ret = select (MAX (MAX (stdout_pipe[0], stderr_pipe[0]), stdtst_pipe[0]) + 1, &fds, NULL, NULL, &tv);
if (ret < 0 && errno != EINTR)
{
g_warning ("Unexpected error in select() while reading from child process (%d): %s", test_trap_last_pid, g_strerror (errno));
break;
}
if (stdout_pipe[0] >= 0 && FD_ISSET (stdout_pipe[0], &fds) &&
g_string_must_read (sout, stdout_pipe[0]) == 0)
{
close (stdout_pipe[0]);
stdout_pipe[0] = -1;
}
if (stderr_pipe[0] >= 0 && FD_ISSET (stderr_pipe[0], &fds) &&
g_string_must_read (serr, stderr_pipe[0]) == 0)
{
close (stderr_pipe[0]);
stderr_pipe[0] = -1;
}
if (stdtst_pipe[0] >= 0 && FD_ISSET (stdtst_pipe[0], &fds) &&
g_string_must_read (stst, stdtst_pipe[0]) == 0)
{
close (stdtst_pipe[0]);
stdtst_pipe[0] = -1;
}
if (!(test_trap_flags & G_TEST_TRAP_SILENCE_STDOUT))
g_string_write_out (sout, 1, &soutpos);
if (!(test_trap_flags & G_TEST_TRAP_SILENCE_STDERR))
g_string_write_out (serr, 2, &serrpos);
if (TRUE) // FIXME: needs capturing into log file
g_string_write_out (stst, 1, &ststpos);
if (usec_timeout)
{
guint64 nstamp = test_time_stamp();
int status = 0;
sstamp = MIN (sstamp, nstamp); // guard against backwards clock skews
if (usec_timeout < nstamp - sstamp)
{
/* timeout reached, need to abort the child now */
kill_child (test_trap_last_pid, &status, 3);
test_trap_last_status = 1024; /* timeout */
if (0 && WIFSIGNALED (status))
g_printerr ("%s: child timed out and received: %s\n", G_STRFUNC, g_strsignal (WTERMSIG (status)));
need_wait = FALSE;
break;
}
}
}
close (stdout_pipe[0]);
close (stderr_pipe[0]);
close (stdtst_pipe[0]);
if (need_wait)
{
int status = 0;
do
wr = waitpid (test_trap_last_pid, &status, 0);
while (wr < 0 && errno == EINTR);
if (WIFEXITED (status)) /* normal exit */
test_trap_last_status = WEXITSTATUS (status); /* 0..255 */
else if (WIFSIGNALED (status))
test_trap_last_status = (WTERMSIG (status) << 12); /* signalled */
else /* WCOREDUMP (status) */
test_trap_last_status = 512; /* coredump */
}
test_trap_last_stdout = g_string_free (sout, FALSE);
test_trap_last_stderr = g_string_free (serr, FALSE);
g_string_free (stst, TRUE);
return FALSE;
}
}
gboolean
g_test_trap_has_passed (void)
{
return test_trap_last_status == 0; /* exit_status == 0 && !signal && !coredump */
}
gboolean
g_test_trap_reached_timeout (void)
{
return 0 != (test_trap_last_status & 1024); /* timeout flag */
}
void
g_test_trap_assertions (const char *domain,
const char *file,
int line,
const char *func,
gboolean must_pass,
gboolean must_fail,
const char *stdout_pattern,
const char *stderr_pattern)
{
if (test_trap_last_pid == 0)
g_error ("child process failed to exit after g_test_trap_fork() and before g_test_trap_assert*()");
if (must_pass && !g_test_trap_has_passed())
{
char *msg = g_strdup_printf ("child process (%d) of test trap failed unexpectedly", test_trap_last_pid);
g_assertion_message (domain, file, line, func, msg);
g_free (msg);
}
if (must_fail && g_test_trap_has_passed())
{
char *msg = g_strdup_printf ("child process (%d) did not fail as expected", test_trap_last_pid);
g_assertion_message (domain, file, line, func, msg);
g_free (msg);
}
if (stdout_pattern && !g_pattern_match_simple (stdout_pattern, test_trap_last_stdout))
{
char *msg = g_strdup_printf ("stdout of child process (%d) failed to match: %s", test_trap_last_pid, stdout_pattern);
g_assertion_message (domain, file, line, func, msg);
g_free (msg);
}
if (stderr_pattern && !g_pattern_match_simple (stderr_pattern, test_trap_last_stderr))
{
char *msg = g_strdup_printf ("stderr of child process (%d) failed to match: %s", test_trap_last_pid, stderr_pattern);
g_assertion_message (domain, file, line, func, msg);
g_free (msg);
}
}
......@@ -33,6 +33,9 @@ typedef struct GTestSuite GTestSuite;
#define g_assert_cmpint(n1, cmp, n2) do { if (n1 cmp n2) ; else \
g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
#n1 " " #cmp " " #n2, n1, #cmp, n2, 'i'); } while (0)
#define g_assert_cmphex(n1, cmp, n2) do { if (n1 cmp n2) ; else \
g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
#n1 " " #cmp " " #n2, n1, #cmp, n2, 'x'); } while (0)
#define g_assert_cmpfloat(n1,cmp,n2) do { if (n1 cmp n2) ; else \
g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
#n1 " " #cmp " " #n2, n1, #cmp, n2, 'f'); } while (0)
......@@ -49,13 +52,6 @@ void g_test_maximized_result (double maximized_quantity,
const char *format,
...) G_GNUC_PRINTF (2, 3);
/* guards used around forked tests */
guint g_test_trap_fork ();
void g_test_trap_assert_passed (void);
void g_test_trap_assert_failed (void);
void g_test_trap_assert_stdout (const char *stdout_pattern);
void g_test_trap_assert_stderr (const char *stderr_pattern);
/* initialize testing framework */
void g_test_init (int *argc,
char ***argv,
......@@ -83,25 +79,48 @@ double g_test_timer_last (void); // repeat last elapsed() result
void g_test_queue_free (gpointer gfree_pointer);
void g_test_queue_unref (gpointer gobjectunref_pointer);
/* test traps are guards used around forked tests */
typedef enum {
G_TEST_TRAP_SILENCE_STDOUT = 1 << 7,
G_TEST_TRAP_SILENCE_STDERR = 1 << 8,
G_TEST_TRAP_INHERIT_STDIN = 1 << 9,
} GTestTrapFlags;
gboolean g_test_trap_fork (guint64 usec_timeout,
GTestTrapFlags test_trap_flags);
gboolean g_test_trap_has_passed (void);
gboolean g_test_trap_reached_timeout (void);
#define g_test_trap_assert_passed() g_test_trap_assertions (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, 1, 0, 0, 0)
#define g_test_trap_assert_failed() g_test_trap_assertions (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, 0, 1, 0, 0)
#define g_test_trap_assert_stdout(soutpattern) g_test_trap_assertions (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, 0, 0, soutpattern, 0)
#define g_test_trap_assert_stderr(serrpattern) g_test_trap_assertions (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, 0, 0, 0, serrpattern)
/* provide seed-able random numbers for tests */
long double g_test_rand_range (long double range_start,
long double range_end);
double g_test_rand_range (double range_start,
double range_end);
/* semi-internal API */
GTestCase* g_test_create_case (const char *test_name,
GTestCase* g_test_create_case (const char *test_name,
gsize data_size,
void (*data_setup) (void),
void (*data_test) (void),
void (*data_teardown) (void));
GTestSuite* g_test_create_suite (const char *suite_name);
GTestSuite* g_test_get_root (void);
void g_test_suite_add (GTestSuite *suite,
GTestSuite* g_test_create_suite (const char *suite_name);
GTestSuite* g_test_get_root (void);
void g_test_suite_add (GTestSuite *suite,
GTestCase *test_case);
void g_test_suite_add_suite (GTestSuite *suite,
void g_test_suite_add_suite (GTestSuite *suite,
GTestSuite *nestedsuite);
int g_test_run_suite (GTestSuite *suite);
int g_test_run_suite (GTestSuite *suite);
/* internal ABI */
void g_test_trap_assertions (const char *domain,
const char *file,
int line,
const char *func,
gboolean must_pass,
gboolean must_fail,
const char *stdout_pattern,
const char *stderr_pattern);
void g_assertion_message (const char *domain,
const char *file,
int line,
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment