glib/gtester.c

   1 /* GLib testing framework runner
   2  * Copyright (C) 2007 Sven Herzberg
   3  * Copyright (C) 2007 Tim Janik
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20 #include "config.h"
  21
  22 #include <glib.h>
  23 #include <glib-unix.h>
  24 #include <gstdio.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <sys/wait.h>
  30 #include <errno.h>
  31 #include <signal.h>
  32
  33 /* the read buffer size in bytes */
  34 #define READ_BUFFER_SIZE 4096
  35
  36 /* --- prototypes --- */
  37 static int      main_selftest   (int    argc,
  38                                  char **argv);
  39 static void     parse_args      (gint           *argc_p,
  40                                  gchar        ***argv_p);
  41
  42 /* --- variables --- */
  43 static GIOChannel  *ioc_report = NULL;
  44 static gboolean     gtester_quiet = FALSE;
  45 static gboolean     gtester_verbose = FALSE;
  46 static gboolean     gtester_list_tests = FALSE;
  47 static gboolean     gtester_selftest = FALSE;
  48 static gboolean     subtest_running = FALSE;
  49 static gint         subtest_exitstatus = 0;
  50 static gboolean     subtest_io_pending = FALSE;
  51 static gboolean     subtest_quiet = TRUE;
  52 static gboolean     subtest_verbose = FALSE;
  53 static gboolean     subtest_mode_fatal = TRUE;
  54 static gboolean     subtest_mode_perf = FALSE;
  55 static gboolean     subtest_mode_quick = TRUE;
  56 static gboolean     subtest_mode_undefined = TRUE;
  57 static const gchar *subtest_seedstr = NULL;
  58 static gchar       *subtest_last_seed = NULL;
  59 static GSList      *subtest_paths = NULL;
  60 static GSList      *skipped_paths = NULL;
  61 static GSList      *subtest_args = NULL;
  62 static gboolean     testcase_open = FALSE;
  63 static guint        testcase_count = 0;
  64 static guint        testcase_fail_count = 0;
  65 static const gchar *output_filename = NULL;
  66 static guint        log_indent = 0;
  67 static gint         log_fd = -1;
  68
  69 /* --- functions --- */
  70 static const char*
  71 sindent (guint n)
  72 {
  73   static const char spaces[] = "                                                                                                    ";
  74   int l = sizeof (spaces) - 1;
  75   n = MIN (n, l);
  76   return spaces + l - n;
  77 }
  78
  79 static void G_GNUC_PRINTF (1, 2)
  80 test_log_printfe (const char *format,
  81                   ...)
  82 {
  83   char *result;
  84   int r;
  85   va_list args;
  86   va_start (args, format);
  87   result = g_markup_vprintf_escaped (format, args);
  88   va_end (args);
  89   do
  90     r = write (log_fd, result, strlen (result));
  91   while (r < 0 && errno == EINTR);
  92   g_free (result);
  93 }
  94
  95 static void
  96 terminate (void)
  97 {
  98   kill (getpid(), SIGTERM);
  99   abort();
 100 }
 101
 102 static void
 103 testcase_close (long double duration,
 104                 gint        exit_status,
 105                 guint       n_forks)
 106 {
 107   g_return_if_fail (testcase_open > 0);
 108   test_log_printfe ("%s<duration>%.6Lf</duration>\n", sindent (log_indent), duration);
 109   test_log_printfe ("%s<status exit-status=\"%d\" n-forks=\"%d\" result=\"%s\"/>\n",
 110                     sindent (log_indent), exit_status, n_forks,
 111                     exit_status ? "failed" : "success");
 112   log_indent -= 2;
 113   test_log_printfe ("%s</testcase>\n", sindent (log_indent));
 114   testcase_open--;
 115   if (gtester_verbose)
 116     g_print ("%s\n", exit_status ? "FAIL" : "OK");
 117   if (exit_status && subtest_last_seed)
 118     g_print ("GTester: last random seed: %s\n", subtest_last_seed);
 119   if (exit_status)
 120     testcase_fail_count += 1;
 121   if (subtest_mode_fatal && exit_status)
 122     terminate();
 123 }
 124
 125 static void
 126 test_log_msg (GTestLogMsg *msg)
 127 {
 128   switch (msg->log_type)
 129     {
 130       guint i;
 131       gchar **strv;
 132     case G_TEST_LOG_NONE:
 133     case G_TEST_LOG_START_SUITE:
 134     case G_TEST_LOG_STOP_SUITE:
 135       break;
 136     case G_TEST_LOG_ERROR:
 137       strv = g_strsplit (msg->strings[0], "\n", -1);
 138       for (i = 0; strv[i]; i++)
 139         test_log_printfe ("%s<error>%s</error>\n", sindent (log_indent), strv[i]);
 140       g_strfreev (strv);
 141       break;
 142     case G_TEST_LOG_START_BINARY:
 143       test_log_printfe ("%s<binary file=\"%s\"/>\n", sindent (log_indent), msg->strings[0]);
 144       subtest_last_seed = g_strdup (msg->strings[1]);
 145       test_log_printfe ("%s<random-seed>%s</random-seed>\n", sindent (log_indent), subtest_last_seed);
 146       break;
 147     case G_TEST_LOG_LIST_CASE:
 148       g_print ("%s\n", msg->strings[0]);
 149       break;
 150     case G_TEST_LOG_START_CASE:
 151       testcase_count++;
 152       if (gtester_verbose)
 153         {
 154           gchar *sc = g_strconcat (msg->strings[0], ":", NULL);
 155           gchar *sleft = g_strdup_printf ("%-68s", sc);
 156           g_free (sc);
 157           g_print ("%70s ", sleft);
 158           g_free (sleft);
 159         }
 160       g_return_if_fail (testcase_open == 0);
 161       testcase_open++;
 162       test_log_printfe ("%s<testcase path=\"%s\">\n", sindent (log_indent), msg->strings[0]);
 163       log_indent += 2;
 164       break;
 165     case G_TEST_LOG_SKIP_CASE:
 166       if (FALSE && gtester_verbose) /* enable to debug test case skipping logic */
 167         {
 168           gchar *sc = g_strconcat (msg->strings[0], ":", NULL);
 169           gchar *sleft = g_strdup_printf ("%-68s", sc);
 170           g_free (sc);
 171           g_print ("%70s SKIPPED\n", sleft);
 172           g_free (sleft);
 173         }
 174       test_log_printfe ("%s<testcase path=\"%s\" skipped=\"1\"/>\n", sindent (log_indent), msg->strings[0]);
 175       break;
 176     case G_TEST_LOG_STOP_CASE:
 177       testcase_close (msg->nums[2], (int) msg->nums[0], (int) msg->nums[1]);
 178       break;
 179     case G_TEST_LOG_MIN_RESULT:
 180     case G_TEST_LOG_MAX_RESULT:
 181       test_log_printfe ("%s<performance minimize=\"%d\" maximize=\"%d\" value=\"%.16Lg\">\n",
 182                         sindent (log_indent), msg->log_type == G_TEST_LOG_MIN_RESULT, msg->log_type == G_TEST_LOG_MAX_RESULT, msg->nums[0]);
 183       test_log_printfe ("%s%s\n", sindent (log_indent + 2), msg->strings[0]);
 184       test_log_printfe ("%s</performance>\n", sindent (log_indent));
 185       break;
 186     case G_TEST_LOG_MESSAGE:
 187       test_log_printfe ("%s<message>\n%s\n%s</message>\n", sindent (log_indent), msg->strings[0], sindent (log_indent));
 188       break;
 189     }
 190 }
 191
 192 static gboolean
 193 child_report_cb (GIOChannel  *source,
 194                  GIOCondition condition,
 195                  gpointer     data)
 196 {
 197   GTestLogBuffer *tlb = data;
 198   GIOStatus status = G_IO_STATUS_NORMAL;
 199   gboolean first_read_eof = FALSE, first_read = TRUE;
 200   gsize length = 0;
 201   do
 202     {
 203       guint8 buffer[READ_BUFFER_SIZE];
 204       GError *error = NULL;
 205       status = g_io_channel_read_chars (source, (gchar*) buffer, sizeof (buffer), &length, &error);
 206       if (first_read && (condition & G_IO_IN))
 207         {
 208           /* on some unixes (MacOS) we need to detect non-blocking fd EOF
 209            * by an IO_IN select/poll followed by read()==0.
 210            */
 211           first_read_eof = length == 0;
 212         }
 213       first_read = FALSE;
 214       if (length)
 215         {
 216           GTestLogMsg *msg;
 217           g_test_log_buffer_push (tlb, length, buffer);
 218           do
 219             {
 220               msg = g_test_log_buffer_pop (tlb);
 221               if (msg)
 222                 {
 223                   test_log_msg (msg);
 224                   g_test_log_msg_free (msg);
 225                 }
 226             }
 227           while (msg);
 228         }
 229       g_clear_error (&error);
 230       /* ignore the io channel status, which will report intermediate EOFs for non blocking fds */
 231       (void) status;
 232     }
 233   while (length > 0);
 234   /* g_print ("LASTIOSTATE: first_read_eof=%d condition=%d\n", first_read_eof, condition); */
 235   if (first_read_eof || (condition & (G_IO_ERR | G_IO_HUP)))
 236     {
 237       /* if there's no data to read and select() reports an error or hangup,
 238        * the fd must have been closed remotely
 239        */
 240       subtest_io_pending = FALSE;
 241       return FALSE;
 242     }
 243   return TRUE; /* keep polling */
 244 }
 245
 246 static void
 247 child_watch_cb (GPid     pid,
 248                 gint     status,
 249                 gpointer data)
 250 {
 251   g_spawn_close_pid (pid);
 252   if (WIFEXITED (status)) /* normal exit */
 253     subtest_exitstatus = WEXITSTATUS (status);
 254   else /* signal or core dump, etc */
 255     subtest_exitstatus = 0xffffffff;
 256   subtest_running = FALSE;
 257 }
 258
 259 static gchar*
 260 queue_gfree (GSList **slistp,
 261              gchar   *string)
 262 {
 263   *slistp = g_slist_prepend (*slistp, string);
 264   return string;
 265 }
 266
 267 static void
 268 unset_cloexec_fdp (gpointer fdp_data)
 269 {
 270   int r, *fdp = fdp_data;
 271   do
 272     r = fcntl (*fdp, F_SETFD, 0 /* FD_CLOEXEC */);
 273   while (r < 0 && errno == EINTR);
 274 }
 275
 276 static gboolean
 277 launch_test_binary (const char *binary,
 278                     guint       skip_tests)
 279 {
 280   GTestLogBuffer *tlb;
 281   GSList *slist, *free_list = NULL;
 282   GError *error = NULL;
 283   int argc = 0;
 284   const gchar **argv;
 285   GPid pid = 0;
 286   gint report_pipe[2] = { -1, -1 };
 287   guint child_report_cb_id = 0;
 288   gboolean loop_pending;
 289   gint i = 0;
 290
 291   if (!g_unix_open_pipe (report_pipe, FD_CLOEXEC, &error))
 292     {
 293       if (subtest_mode_fatal)
 294         g_error ("Failed to open pipe for test binary: %s: %s", binary, error->message);
 295       else
 296         g_warning ("Failed to open pipe for test binary: %s: %s", binary, error->message);
 297       g_clear_error (&error);
 298       return FALSE;
 299     }
 300
 301   /* setup argc */
 302   for (slist = subtest_args; slist; slist = slist->next)
 303     argc++;
 304   /* argc++; */
 305   if (subtest_quiet)
 306     argc++;
 307   if (subtest_verbose)
 308     argc++;
 309   if (!subtest_mode_fatal)
 310     argc++;
 311   if (subtest_mode_quick)
 312     argc++;
 313   else
 314     argc++;
 315   if (subtest_mode_perf)
 316     argc++;
 317   if (!subtest_mode_undefined)
 318     argc++;
 319   if (gtester_list_tests)
 320     argc++;
 321   if (subtest_seedstr)
 322     argc++;
 323   argc++;
 324   if (skip_tests)
 325     argc++;
 326   for (slist = subtest_paths; slist; slist = slist->next)
 327     argc++;
 328   for (slist = skipped_paths; slist; slist = slist->next)
 329     argc++;
 330
 331   /* setup argv */
 332   argv = g_malloc ((argc + 2) * sizeof(gchar *));
 333   argv[i++] = binary;
 334   for (slist = subtest_args; slist; slist = slist->next)
 335     argv[i++] = (gchar*) slist->data;
 336   /* argv[i++] = "--debug-log"; */
 337   if (subtest_quiet)
 338     argv[i++] = "--quiet";
 339   if (subtest_verbose)
 340     argv[i++] = "--verbose";
 341   if (!subtest_mode_fatal)
 342     argv[i++] = "--keep-going";
 343   if (subtest_mode_quick)
 344     argv[i++] = "-m=quick";
 345   else
 346     argv[i++] = "-m=slow";
 347   if (subtest_mode_perf)
 348     argv[i++] = "-m=perf";
 349   if (!subtest_mode_undefined)
 350     argv[i++] = "-m=no-undefined";
 351   if (gtester_list_tests)
 352     argv[i++] = "-l";
 353   if (subtest_seedstr)
 354     argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--seed=%s", subtest_seedstr));
 355   argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--GTestLogFD=%u", report_pipe[1]));
 356   if (skip_tests)
 357     argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--GTestSkipCount=%u", skip_tests));
 358   for (slist = subtest_paths; slist; slist = slist->next)
 359     argv[i++] = queue_gfree (&free_list, g_strdup_printf ("-p=%s", (gchar*) slist->data));
 360   for (slist = skipped_paths; slist; slist = slist->next)
 361     argv[i++] = queue_gfree (&free_list, g_strdup_printf ("-s=%s", (gchar*) slist->data));
 362   argv[i++] = NULL;
 363
 364   g_spawn_async_with_pipes (NULL, /* g_get_current_dir() */
 365                             (gchar**) argv,
 366                             NULL, /* envp */
 367                             G_SPAWN_DO_NOT_REAP_CHILD, /* G_SPAWN_SEARCH_PATH */
 368                             unset_cloexec_fdp, &report_pipe[1], /* pre-exec callback */
 369                             &pid,
 370                             NULL,       /* standard_input */
 371                             NULL,       /* standard_output */
 372                             NULL,       /* standard_error */
 373                             &error);
 374   g_slist_foreach (free_list, (void(*)(void*,void*)) g_free, NULL);
 375   g_slist_free (free_list);
 376   free_list = NULL;
 377   close (report_pipe[1]);
 378
 379   if (!gtester_quiet)
 380     g_print ("(pid=%lu)\n", (unsigned long) pid);
 381
 382   if (error)
 383     {
 384       close (report_pipe[0]);
 385       if (subtest_mode_fatal)
 386         g_error ("Failed to execute test binary: %s: %s", argv[0], error->message);
 387       else
 388         g_warning ("Failed to execute test binary: %s: %s", argv[0], error->message);
 389       g_clear_error (&error);
 390       g_free (argv);
 391       return FALSE;
 392     }
 393   g_free (argv);
 394
 395   subtest_running = TRUE;
 396   subtest_io_pending = TRUE;
 397   tlb = g_test_log_buffer_new();
 398   if (report_pipe[0] >= 0)
 399     {
 400       ioc_report = g_io_channel_unix_new (report_pipe[0]);
 401       g_io_channel_set_flags (ioc_report, G_IO_FLAG_NONBLOCK, NULL);
 402       g_io_channel_set_encoding (ioc_report, NULL, NULL);
 403       g_io_channel_set_buffered (ioc_report, FALSE);
 404       child_report_cb_id = g_io_add_watch_full (ioc_report, G_PRIORITY_DEFAULT - 1, G_IO_IN | G_IO_ERR | G_IO_HUP, child_report_cb, tlb, NULL);
 405       g_io_channel_unref (ioc_report);
 406     }
 407   g_child_watch_add_full (G_PRIORITY_DEFAULT + 1, pid, child_watch_cb, NULL, NULL);
 408
 409   loop_pending = g_main_context_pending (NULL);
 410   while (subtest_running ||     /* FALSE once child exits */
 411          subtest_io_pending ||  /* FALSE once ioc_report closes */
 412          loop_pending)          /* TRUE while idler, etc are running */
 413     {
 414       /* g_print ("LOOPSTATE: subtest_running=%d subtest_io_pending=%d\n", subtest_running, subtest_io_pending); */
 415       /* check for unexpected hangs that are not signalled on report_pipe */
 416       if (!subtest_running &&   /* child exited */
 417           subtest_io_pending && /* no EOF detected on report_pipe */
 418           !loop_pending)        /* no IO events pending however */
 419         break;
 420       g_main_context_iteration (NULL, TRUE);
 421       loop_pending = g_main_context_pending (NULL);
 422     }
 423
 424   g_source_remove (child_report_cb_id);
 425   close (report_pipe[0]);
 426   g_test_log_buffer_free (tlb);
 427
 428   return TRUE;
 429 }
 430
 431 static void
 432 launch_test (const char *binary)
 433 {
 434   gboolean success = TRUE;
 435   GTimer *btimer = g_timer_new();
 436   gboolean need_restart;
 437
 438   testcase_count = 0;
 439   if (!gtester_quiet)
 440     g_print ("TEST: %s... ", binary);
 441
 442  retry:
 443   test_log_printfe ("%s<testbinary path=\"%s\">\n", sindent (log_indent), binary);
 444   log_indent += 2;
 445   g_timer_start (btimer);
 446   subtest_exitstatus = 0;
 447   success &= launch_test_binary (binary, testcase_count);
 448   success &= subtest_exitstatus == 0;
 449   need_restart = testcase_open != 0;
 450   if (testcase_open)
 451     testcase_close (0, -256, 0);
 452   g_timer_stop (btimer);
 453   test_log_printfe ("%s<duration>%.6f</duration>\n", sindent (log_indent), g_timer_elapsed (btimer, NULL));
 454   log_indent -= 2;
 455   test_log_printfe ("%s</testbinary>\n", sindent (log_indent));
 456   g_free (subtest_last_seed);
 457   subtest_last_seed = NULL;
 458   if (need_restart)
 459     {
 460       /* restart test binary, skipping processed test cases */
 461       goto retry;
 462     }
 463
 464   /* count the inability to run a test as a failure */
 465   if (!success && testcase_count == 0)
 466     testcase_fail_count++;
 467
 468   if (!gtester_quiet)
 469     g_print ("%s: %s\n", !success ? "FAIL" : "PASS", binary);
 470   g_timer_destroy (btimer);
 471   if (subtest_mode_fatal && !success)
 472     terminate();
 473 }
 474
 475 static void
 476 usage (gboolean just_version)
 477 {
 478   if (just_version)
 479     {
 480       g_print ("gtester version %d.%d.%d\n", GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
 481       return;
 482     }
 483   g_print ("Usage:\n");
 484   g_print ("gtester [OPTIONS] testprogram...\n\n");
 485   /*        12345678901234567890123456789012345678901234567890123456789012345678901234567890 */
 486   g_print ("Help Options:\n");
 487   g_print ("  -h, --help                    Show this help message\n\n");
 488   g_print ("Utility Options:\n");
 489   g_print ("  -v, --version                 Print version informations\n");
 490   g_print ("  --g-fatal-warnings            Make warnings fatal (abort)\n");
 491   g_print ("  -k, --keep-going              Continue running after tests failed\n");
 492   g_print ("  -l                            List paths of available test cases\n");
 493   g_print ("  -m {perf|slow|thorough|quick} Run test cases according to mode\n");
 494   g_print ("  -m {undefined|no-undefined}   Run test cases according to mode\n");
 495   g_print ("  -p=TESTPATH                   Only start test cases matching TESTPATH\n");
 496   g_print ("  -s=TESTPATH                   Skip test cases matching TESTPATH\n");
 497   g_print ("  --seed=SEEDSTRING             Start tests with random seed SEEDSTRING\n");
 498   g_print ("  -o=LOGFILE                    Write the test log to LOGFILE\n");
 499   g_print ("  -q, --quiet                   Suppress per test binary output\n");
 500   g_print ("  --verbose                     Report success per testcase\n");
 501 }
 502
 503 static void
 504 parse_args (gint    *argc_p,
 505             gchar ***argv_p)
 506 {
 507   guint argc = *argc_p;
 508   gchar **argv = *argv_p;
 509   guint i, e;
 510   /* parse known args */
 511   for (i = 1; i < argc; i++)
 512     {
 513       if (strcmp (argv[i], "--g-fatal-warnings") == 0)
 514         {
 515           GLogLevelFlags fatal_mask = (GLogLevelFlags) g_log_set_always_fatal ((GLogLevelFlags) G_LOG_FATAL_MASK);
 516           fatal_mask = (GLogLevelFlags) (fatal_mask | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL);
 517           g_log_set_always_fatal (fatal_mask);
 518           argv[i] = NULL;
 519         }
 520       else if (strcmp (argv[i], "--gtester-selftest") == 0)
 521         {
 522           gtester_selftest = TRUE;
 523           argv[i] = NULL;
 524           break;        /* stop parsing regular gtester arguments */
 525         }
 526       else if (strcmp (argv[i], "-h") == 0 || strcmp (argv[i], "--help") == 0)
 527         {
 528           usage (FALSE);
 529           exit (0);
 530           argv[i] = NULL;
 531         }
 532       else if (strcmp (argv[i], "-v") == 0 || strcmp (argv[i], "--version") == 0)
 533         {
 534           usage (TRUE);
 535           exit (0);
 536           argv[i] = NULL;
 537         }
 538       else if (strcmp (argv[i], "--keep-going") == 0 ||
 539                strcmp (argv[i], "-k") == 0)
 540         {
 541           subtest_mode_fatal = FALSE;
 542           argv[i] = NULL;
 543         }
 544       else if (strcmp ("-p", argv[i]) == 0 || strncmp ("-p=", argv[i], 3) == 0)
 545         {
 546           gchar *equal = argv[i] + 2;
 547           if (*equal == '=')
 548             subtest_paths = g_slist_prepend (subtest_paths, equal + 1);
 549           else if (i + 1 < argc)
 550             {
 551               argv[i++] = NULL;
 552               subtest_paths = g_slist_prepend (subtest_paths, argv[i]);
 553             }
 554           argv[i] = NULL;
 555         }
 556       else if (strcmp ("-s", argv[i]) == 0 || strncmp ("-s=", argv[i], 3) == 0)
 557         {
 558           gchar *equal = argv[i] + 2;
 559           if (*equal == '=')
 560             skipped_paths = g_slist_prepend (skipped_paths, equal + 1);
 561           else if (i + 1 < argc)
 562             {
 563               argv[i++] = NULL;
 564               skipped_paths = g_slist_prepend (skipped_paths, argv[i]);
 565             }
 566           argv[i] = NULL;
 567         }
 568       else if (strcmp ("--test-arg", argv[i]) == 0 || strncmp ("--test-arg=", argv[i], 11) == 0)
 569         {
 570           gchar *equal = argv[i] + 10;
 571           if (*equal == '=')
 572             subtest_args = g_slist_prepend (subtest_args, equal + 1);
 573           else if (i + 1 < argc)
 574             {
 575               argv[i++] = NULL;
 576               subtest_args = g_slist_prepend (subtest_args, argv[i]);
 577             }
 578           argv[i] = NULL;
 579         }
 580       else if (strcmp ("-o", argv[i]) == 0 || strncmp ("-o=", argv[i], 3) == 0)
 581         {
 582           gchar *equal = argv[i] + 2;
 583           if (*equal == '=')
 584             output_filename = equal + 1;
 585           else if (i + 1 < argc)
 586             {
 587               argv[i++] = NULL;
 588               output_filename = argv[i];
 589             }
 590           argv[i] = NULL;
 591         }
 592       else if (strcmp ("-m", argv[i]) == 0 || strncmp ("-m=", argv[i], 3) == 0)
 593         {
 594           gchar *equal = argv[i] + 2;
 595           const gchar *mode = "";
 596           if (*equal == '=')
 597             mode = equal + 1;
 598           else if (i + 1 < argc)
 599             {
 600               argv[i++] = NULL;
 601               mode = argv[i];
 602             }
 603           if (strcmp (mode, "perf") == 0)
 604             subtest_mode_perf = TRUE;
 605           else if (strcmp (mode, "slow") == 0 || strcmp (mode, "thorough") == 0)
 606             subtest_mode_quick = FALSE;
 607           else if (strcmp (mode, "quick") == 0)
 608             {
 609               subtest_mode_quick = TRUE;
 610               subtest_mode_perf = FALSE;
 611             }
 612           else if (strcmp (mode, "undefined") == 0)
 613             subtest_mode_undefined = TRUE;
 614           else if (strcmp (mode, "no-undefined") == 0)
 615             subtest_mode_undefined = FALSE;
 616           else
 617             g_error ("unknown test mode: -m %s", mode);
 618           argv[i] = NULL;
 619         }
 620       else if (strcmp ("-q", argv[i]) == 0 || strcmp ("--quiet", argv[i]) == 0)
 621         {
 622           gtester_quiet = TRUE;
 623           gtester_verbose = FALSE;
 624           argv[i] = NULL;
 625         }
 626       else if (strcmp ("--verbose", argv[i]) == 0)
 627         {
 628           gtester_quiet = FALSE;
 629           gtester_verbose = TRUE;
 630           argv[i] = NULL;
 631         }
 632       else if (strcmp ("-l", argv[i]) == 0)
 633         {
 634           gtester_list_tests = TRUE;
 635           argv[i] = NULL;
 636         }
 637       else if (strcmp ("--seed", argv[i]) == 0 || strncmp ("--seed=", argv[i], 7) == 0)
 638         {
 639           gchar *equal = argv[i] + 6;
 640           if (*equal == '=')
 641             subtest_seedstr = equal + 1;
 642           else if (i + 1 < argc)
 643             {
 644               argv[i++] = NULL;
 645               subtest_seedstr = argv[i];
 646             }
 647           argv[i] = NULL;
 648         }
 649     }
 650   /* collapse argv */
 651   e = 1;
 652   for (i = 1; i < argc; i++)
 653     if (argv[i])
 654       {
 655         argv[e++] = argv[i];
 656         if (i >= e)
 657           argv[i] = NULL;
 658       }
 659   *argc_p = e;
 660 }
 661
 662 int
 663 main (int    argc,
 664       char **argv)
 665 {
 666   guint ui;
 667
 668   g_set_prgname (argv[0]);
 669   parse_args (&argc, &argv);
 670   if (gtester_selftest)
 671     return main_selftest (argc, argv);
 672
 673   if (argc <= 1)
 674     {
 675       usage (FALSE);
 676       return 1;
 677     }
 678
 679   if (output_filename)
 680     {
 681       log_fd = g_open (output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 682       if (log_fd < 0)
 683         g_error ("Failed to open log file '%s': %s", output_filename, g_strerror (errno));
 684     }
 685
 686   test_log_printfe ("<?xml version=\"1.0\"?>\n");
 687   test_log_printfe ("%s<gtester>\n", sindent (log_indent));
 688   log_indent += 2;
 689   for (ui = 1; ui < argc; ui++)
 690     {
 691       const char *binary = argv[ui];
 692       launch_test (binary);
 693       /* we only get here on success or if !subtest_mode_fatal */
 694     }
 695   log_indent -= 2;
 696   test_log_printfe ("%s</gtester>\n", sindent (log_indent));
 697
 698   close (log_fd);
 699
 700   return testcase_fail_count == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
 701 }
 702
 703 static void
 704 fixture_setup (guint        *fix,
 705                gconstpointer test_data)
 706 {
 707   g_assert_cmphex (*fix, ==, 0);
 708   *fix = 0xdeadbeef;
 709 }
 710 static void
 711 fixture_test (guint        *fix,
 712               gconstpointer test_data)
 713 {
 714   g_assert_cmphex (*fix, ==, 0xdeadbeef);
 715   g_test_message ("This is a test message API test message.");
 716   g_test_bug_base ("http://www.example.com/bugtracker/");
 717   g_test_bug ("123");
 718   g_test_bug_base ("http://www.example.com/bugtracker?bugnum=%s;cmd=showbug");
 719   g_test_bug ("456");
 720 }
 721 static void
 722 fixture_teardown (guint        *fix,
 723                   gconstpointer test_data)
 724 {
 725   g_assert_cmphex (*fix, ==, 0xdeadbeef);
 726 }
 727
 728 static int
 729 main_selftest (int    argc,
 730                char **argv)
 731 {
 732   /* gtester main() for --gtester-selftest invocations */
 733   g_test_init (&argc, &argv, NULL);
 734   g_test_add ("/gtester/fixture-test", guint, NULL, fixture_setup, fixture_test, fixture_teardown);
 735   return g_test_run();
 736 }