gtester.c 22.2 KB
Newer Older
1 2 3
/* GLib testing framework runner
 * Copyright (C) 2007 Sven Herzberg
 * Copyright (C) 2007 Tim Janik
4
 *
5 6 7 8
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * 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 13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
14
 *
15 16 17 18
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
19
 */
20
#include <glib.h>
21
#include <gstdio.h>
22 23 24
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
Tim Janik's avatar
Tim Janik committed
25
#include <fcntl.h>
26
#include <sys/wait.h>
Tim Janik's avatar
Tim Janik committed
27 28
#include <errno.h>
#include <signal.h>
29

30
/* the read buffer size in bytes */
31 32 33
#define READ_BUFFER_SIZE 4096

/* --- prototypes --- */
34 35
static int      main_selftest   (int    argc,
                                 char **argv);
36 37
static void     parse_args      (gint           *argc_p,
                                 gchar        ***argv_p);
38

39
/* --- variables --- */
40
static GIOChannel  *ioc_report = NULL;
41
static gboolean     gtester_quiet = FALSE;
42 43
static gboolean     gtester_verbose = FALSE;
static gboolean     gtester_list_tests = FALSE;
44
static gboolean     gtester_selftest = FALSE;
45
static gboolean     subtest_running = FALSE;
46
static gint         subtest_exitstatus = 0;
47 48 49
static gboolean     subtest_io_pending = FALSE;
static gboolean     subtest_quiet = TRUE;
static gboolean     subtest_verbose = FALSE;
50
static gboolean     subtest_mode_fatal = TRUE;
51 52 53
static gboolean     subtest_mode_perf = FALSE;
static gboolean     subtest_mode_quick = TRUE;
static const gchar *subtest_seedstr = NULL;
54
static gchar       *subtest_last_seed = NULL;
55
static GSList      *subtest_paths = NULL;
56
static GSList      *subtest_args = NULL;
57
static gboolean     testcase_open = FALSE;
58 59
static guint        testcase_count = 0;
static guint        testcase_fail_count = 0;
60 61 62
static const gchar *output_filename = NULL;
static guint        log_indent = 0;
static gint         log_fd = -1;
63

64
/* --- functions --- */
65 66 67 68
static const char*
sindent (guint n)
{
  static const char spaces[] = "                                                                                                    ";
69 70
  int l = sizeof (spaces) - 1;
  n = MIN (n, l);
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
  return spaces + l - n;
}

static void G_GNUC_PRINTF (1, 2)
test_log_printfe (const char *format,
                  ...)
{
  char *result;
  int r;
  va_list args;
  va_start (args, format);
  result = g_markup_vprintf_escaped (format, args);
  va_end (args);
  do
    r = write (log_fd, result, strlen (result));
  while (r < 0 && errno == EINTR);
  g_free (result);
}

90 91 92 93 94 95 96 97 98
static void
terminate (void)
{
  kill (getpid(), SIGTERM);
  abort();
}

static void
testcase_close (long double duration,
99
                gint        exit_status,
100 101 102 103
                guint       n_forks)
{
  g_return_if_fail (testcase_open > 0);
  test_log_printfe ("%s<duration>%.6Lf</duration>\n", sindent (log_indent), duration);
104 105 106
  test_log_printfe ("%s<status exit-status=\"%d\" n-forks=\"%d\" result=\"%s\"/>\n",
                    sindent (log_indent), exit_status, n_forks,
                    exit_status ? "failed" : "success");
107 108 109 110 111
  log_indent -= 2;
  test_log_printfe ("%s</testcase>\n", sindent (log_indent));
  testcase_open--;
  if (gtester_verbose)
    g_print ("%s\n", exit_status ? "FAIL" : "OK");
112 113
  if (exit_status && subtest_last_seed)
    g_print ("GTester: last random seed: %s\n", subtest_last_seed);
114 115 116 117 118 119
  if (exit_status)
    testcase_fail_count += 1;
  if (subtest_mode_fatal && testcase_fail_count)
    terminate();
}

120 121 122 123 124
static void
test_log_msg (GTestLogMsg *msg)
{
  switch (msg->log_type)
    {
125 126
      guint i;
      gchar **strv;
127 128 129
    case G_TEST_LOG_NONE:
      break;
    case G_TEST_LOG_ERROR:
130 131 132 133
      strv = g_strsplit (msg->strings[0], "\n", -1);
      for (i = 0; strv[i]; i++)
        test_log_printfe ("%s<error>%s</error>\n", sindent (log_indent), strv[i]);
      g_strfreev (strv);
134 135 136
      break;
    case G_TEST_LOG_START_BINARY:
      test_log_printfe ("%s<binary file=\"%s\"/>\n", sindent (log_indent), msg->strings[0]);
137 138
      subtest_last_seed = g_strdup (msg->strings[1]);
      test_log_printfe ("%s<random-seed>%s</random-seed>\n", sindent (log_indent), subtest_last_seed);
139 140 141 142 143
      break;
    case G_TEST_LOG_LIST_CASE:
      g_print ("%s\n", msg->strings[0]);
      break;
    case G_TEST_LOG_START_CASE:
144
      testcase_count++;
145 146 147 148 149 150 151 152 153 154 155 156 157
      if (gtester_verbose)
        {
          gchar *sc = g_strconcat (msg->strings[0], ":", NULL);
          gchar *sleft = g_strdup_printf ("%-68s", sc);
          g_free (sc);
          g_print ("%70s ", sleft);
          g_free (sleft);
        }
      g_return_if_fail (testcase_open == 0);
      testcase_open++;
      test_log_printfe ("%s<testcase path=\"%s\">\n", sindent (log_indent), msg->strings[0]);
      log_indent += 2;
      break;
158
    case G_TEST_LOG_SKIP_CASE:
159
      if (FALSE && gtester_verbose) /* enable to debug test case skipping logic */
160 161 162 163 164 165 166 167 168
        {
          gchar *sc = g_strconcat (msg->strings[0], ":", NULL);
          gchar *sleft = g_strdup_printf ("%-68s", sc);
          g_free (sc);
          g_print ("%70s SKIPPED\n", sleft);
          g_free (sleft);
        }
      test_log_printfe ("%s<testcase path=\"%s\" skipped=\"1\"/>\n", sindent (log_indent), msg->strings[0]);
      break;
169
    case G_TEST_LOG_STOP_CASE:
170
      testcase_close (msg->nums[2], (int) msg->nums[0], (int) msg->nums[1]);
171 172 173 174 175 176 177 178
      break;
    case G_TEST_LOG_MIN_RESULT:
    case G_TEST_LOG_MAX_RESULT:
      test_log_printfe ("%s<performance minimize=\"%d\" maximize=\"%d\" value=\"%.16Lg\">\n",
                        sindent (log_indent), msg->log_type == G_TEST_LOG_MIN_RESULT, msg->log_type == G_TEST_LOG_MAX_RESULT, msg->nums[0]);
      test_log_printfe ("%s%s\n", sindent (log_indent + 2), msg->strings[0]);
      test_log_printfe ("%s</performance>\n", sindent (log_indent));
      break;
179 180 181
    case G_TEST_LOG_MESSAGE:
      test_log_printfe ("%s<message>\n%s\n%s</message>\n", sindent (log_indent), msg->strings[0], sindent (log_indent));
      break;
182 183 184
    }
}

185
static gboolean
186 187 188
child_report_cb (GIOChannel  *source,
                 GIOCondition condition,
                 gpointer     data)
189
{
Tim Janik's avatar
Tim Janik committed
190
  GTestLogBuffer *tlb = data;
191
  GIOStatus status = G_IO_STATUS_NORMAL;
192
  gboolean first_read_eof = FALSE, first_read = TRUE;
Tim Janik's avatar
Tim Janik committed
193 194
  gsize length = 0;
  do
195
    {
Tim Janik's avatar
Tim Janik committed
196
      guint8 buffer[READ_BUFFER_SIZE];
197
      GError *error = NULL;
Tim Janik's avatar
Tim Janik committed
198
      status = g_io_channel_read_chars (source, (gchar*) buffer, sizeof (buffer), &length, &error);
199 200 201 202 203 204 205 206
      if (first_read && (condition & G_IO_IN))
        {
          /* on some unixes (MacOS) we need to detect non-blocking fd EOF
           * by an IO_IN select/poll followed by read()==0.
           */
          first_read_eof = length == 0;
        }
      first_read = FALSE;
Tim Janik's avatar
Tim Janik committed
207
      if (length)
208
        {
Tim Janik's avatar
Tim Janik committed
209 210 211 212 213 214 215
          GTestLogMsg *msg;
          g_test_log_buffer_push (tlb, length, buffer);
          do
            {
              msg = g_test_log_buffer_pop (tlb);
              if (msg)
                {
216
                  test_log_msg (msg);
Tim Janik's avatar
Tim Janik committed
217 218 219 220
                  g_test_log_msg_free (msg);
                }
            }
          while (msg);
221
        }
222
      g_clear_error (&error);
223
      /* ignore the io channel status, which will report intermediate EOFs for non blocking fds */
Tim Janik's avatar
Tim Janik committed
224
      (void) status;
225
    }
Tim Janik's avatar
Tim Janik committed
226
  while (length > 0);
227
  /* g_print ("LASTIOSTATE: first_read_eof=%d condition=%d\n", first_read_eof, condition); */
228
  if (first_read_eof || (condition & (G_IO_ERR | G_IO_HUP)))
Tim Janik's avatar
Tim Janik committed
229 230 231 232 233 234 235 236
    {
      /* if there's no data to read and select() reports an error or hangup,
       * the fd must have been closed remotely
       */
      subtest_io_pending = FALSE;
      return FALSE;
    }
  return TRUE; /* keep polling */
237 238 239 240 241 242 243 244
}

static void
child_watch_cb (GPid     pid,
		gint     status,
		gpointer data)
{
  g_spawn_close_pid (pid);
245 246 247 248
  if (WIFEXITED (status)) /* normal exit */
    subtest_exitstatus = WEXITSTATUS (status);
  else /* signal or core dump, etc */
    subtest_exitstatus = 0xffffffff;
249 250
  subtest_running = FALSE;
}
251

252 253 254 255 256 257
static gchar*
queue_gfree (GSList **slistp,
             gchar   *string)
{
  *slistp = g_slist_prepend (*slistp, string);
  return string;
258 259
}

Tim Janik's avatar
Tim Janik committed
260 261 262 263 264 265 266 267 268
static void
unset_cloexec_fdp (gpointer fdp_data)
{
  int r, *fdp = fdp_data;
  do
    r = fcntl (*fdp, F_SETFD, 0 /* FD_CLOEXEC */);
  while (r < 0 && errno == EINTR);
}

269
static gboolean
270 271
launch_test_binary (const char *binary,
                    guint       skip_tests)
272
{
Tim Janik's avatar
Tim Janik committed
273
  GTestLogBuffer *tlb;
274 275
  GSList *slist, *free_list = NULL;
  GError *error = NULL;
276 277
  int argc = 0;
  const gchar **argv;
278
  GPid pid = 0;
Tim Janik's avatar
Tim Janik committed
279
  gint report_pipe[2] = { -1, -1 };
280 281
  guint child_report_cb_id = 0;
  gboolean loop_pending;
Tim Janik's avatar
Tim Janik committed
282 283 284 285 286 287 288 289
  gint i = 0;

  if (pipe (report_pipe) < 0)
    {
      if (subtest_mode_fatal)
        g_error ("Failed to open pipe for test binary: %s: %s", binary, g_strerror (errno));
      else
        g_warning ("Failed to open pipe for test binary: %s: %s", binary, g_strerror (errno));
290
      return FALSE;
Tim Janik's avatar
Tim Janik committed
291
    }
292

293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
  /* setup argc */
  for (slist = subtest_args; slist; slist = slist->next)
    argc++;
  /* argc++; */
  if (subtest_quiet)
    argc++;
  if (subtest_verbose)
    argc++;
  if (!subtest_mode_fatal)
    argc++;
  if (subtest_mode_quick)
    argc++;
  else
    argc++;
  if (subtest_mode_perf)
    argc++;
  if (gtester_list_tests)
    argc++;
  if (subtest_seedstr)
    argc++;
  argc++;
  if (skip_tests)
    argc++;
  for (slist = subtest_paths; slist; slist = slist->next)
    argc++;

319
  /* setup argv */
320
  argv = g_malloc ((argc + 2) * sizeof(gchar *));
321
  argv[i++] = binary;
322 323
  for (slist = subtest_args; slist; slist = slist->next)
    argv[i++] = (gchar*) slist->data;
324
  /* argv[i++] = "--debug-log"; */
325
  if (subtest_quiet)
Tim Janik's avatar
Tim Janik committed
326
    argv[i++] = "--quiet";
327
  if (subtest_verbose)
Tim Janik's avatar
Tim Janik committed
328
    argv[i++] = "--verbose";
329 330 331 332 333 334 335 336
  if (!subtest_mode_fatal)
    argv[i++] = "--keep-going";
  if (subtest_mode_quick)
    argv[i++] = "-m=quick";
  else
    argv[i++] = "-m=slow";
  if (subtest_mode_perf)
    argv[i++] = "-m=perf";
337 338
  if (gtester_list_tests)
    argv[i++] = "-l";
339 340
  if (subtest_seedstr)
    argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--seed=%s", subtest_seedstr));
341 342 343
  argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--GTestLogFD=%u", report_pipe[1]));
  if (skip_tests)
    argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--GTestSkipCount=%u", skip_tests));
344 345 346 347 348 349 350 351
  for (slist = subtest_paths; slist; slist = slist->next)
    argv[i++] = queue_gfree (&free_list, g_strdup_printf ("-p=%s", (gchar*) slist->data));
  argv[i++] = NULL;

  g_spawn_async_with_pipes (NULL, /* g_get_current_dir() */
                            (gchar**) argv,
                            NULL, /* envp */
                            G_SPAWN_DO_NOT_REAP_CHILD, /* G_SPAWN_SEARCH_PATH */
Tim Janik's avatar
Tim Janik committed
352
                            unset_cloexec_fdp, &report_pipe[1], /* pre-exec callback */
353
                            &pid,
354
                            NULL,       /* standard_input */
Tim Janik's avatar
Tim Janik committed
355
                            NULL,       /* standard_output */
356
                            NULL,       /* standard_error */
357
                            &error);
358 359 360
  g_slist_foreach (free_list, (void(*)(void*,void*)) g_free, NULL);
  g_slist_free (free_list);
  free_list = NULL;
Tim Janik's avatar
Tim Janik committed
361
  close (report_pipe[1]);
362

363 364 365
  if (!gtester_quiet)
    g_print ("(pid=%lu)\n", (unsigned long) pid);

366 367
  if (error)
    {
Tim Janik's avatar
Tim Janik committed
368
      close (report_pipe[0]);
369 370 371 372 373
      if (subtest_mode_fatal)
        g_error ("Failed to execute test binary: %s: %s", argv[0], error->message);
      else
        g_warning ("Failed to execute test binary: %s: %s", argv[0], error->message);
      g_clear_error (&error);
374
      g_free (argv);
375
      return FALSE;
376
    }
377
  g_free (argv);
Tim Janik's avatar
Tim Janik committed
378

379 380
  subtest_running = TRUE;
  subtest_io_pending = TRUE;
Tim Janik's avatar
Tim Janik committed
381 382
  tlb = g_test_log_buffer_new();
  if (report_pipe[0] >= 0)
383
    {
Tim Janik's avatar
Tim Janik committed
384
      ioc_report = g_io_channel_unix_new (report_pipe[0]);
385
      g_io_channel_set_flags (ioc_report, G_IO_FLAG_NONBLOCK, NULL);
Tim Janik's avatar
Tim Janik committed
386 387
      g_io_channel_set_encoding (ioc_report, NULL, NULL);
      g_io_channel_set_buffered (ioc_report, FALSE);
388
      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);
389 390 391
      g_io_channel_unref (ioc_report);
    }
  g_child_watch_add_full (G_PRIORITY_DEFAULT + 1, pid, child_watch_cb, NULL, NULL);
392

393 394 395 396 397
  loop_pending = g_main_context_pending (NULL);
  while (subtest_running ||     /* FALSE once child exits */
         subtest_io_pending ||  /* FALSE once ioc_report closes */
         loop_pending)          /* TRUE while idler, etc are running */
    {
398
      /* g_print ("LOOPSTATE: subtest_running=%d subtest_io_pending=%d\n", subtest_running, subtest_io_pending); */
399 400 401 402 403 404 405 406
      /* check for unexpected hangs that are not signalled on report_pipe */
      if (!subtest_running &&   /* child exited */
          subtest_io_pending && /* no EOF detected on report_pipe */
          !loop_pending)        /* no IO events pending however */
        break;
      g_main_context_iteration (NULL, TRUE);
      loop_pending = g_main_context_pending (NULL);
    }
Tim Janik's avatar
Tim Janik committed
407

408
  g_source_remove (child_report_cb_id);
Tim Janik's avatar
Tim Janik committed
409 410
  close (report_pipe[0]);
  g_test_log_buffer_free (tlb);
411 412 413 414 415 416 417

  return TRUE;
}

static void
launch_test (const char *binary)
{
418
  gboolean success = TRUE;
419
  GTimer *btimer = g_timer_new();
420 421 422
  gboolean need_restart;
  testcase_count = 0;
  testcase_fail_count = 0;
423 424
  if (!gtester_quiet)
    g_print ("TEST: %s... ", binary);
425 426

 retry:
427 428 429
  test_log_printfe ("%s<testbinary path=\"%s\">\n", sindent (log_indent), binary);
  log_indent += 2;
  g_timer_start (btimer);
430 431 432 433 434
  subtest_exitstatus = 0;
  success &= launch_test_binary (binary, testcase_count);
  success &= subtest_exitstatus == 0;
  need_restart = testcase_open != 0;
  if (testcase_open)
435
    testcase_close (0, -256, 0);
436 437 438 439
  g_timer_stop (btimer);
  test_log_printfe ("%s<duration>%.6f</duration>\n", sindent (log_indent), g_timer_elapsed (btimer, NULL));
  log_indent -= 2;
  test_log_printfe ("%s</testbinary>\n", sindent (log_indent));
440 441
  g_free (subtest_last_seed);
  subtest_last_seed = NULL;
442 443 444 445 446 447
  if (need_restart)
    {
      /* restart test binary, skipping processed test cases */
      goto retry;
    }

448
  if (!gtester_quiet)
449
    g_print ("%s: %s\n", testcase_fail_count || !success ? "FAIL" : "PASS", binary);
450
  g_timer_destroy (btimer);
451 452
  if (subtest_mode_fatal && !success)
    terminate();
453
}
454

455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
static void
usage (gboolean just_version)
{
  if (just_version)
    {
      g_print ("gtester version %d.%d.%d\n", GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
      return;
    }
  g_print ("Usage: gtester [OPTIONS] testprogram...\n");
  /*        12345678901234567890123456789012345678901234567890123456789012345678901234567890 */
  g_print ("Options:\n");
  g_print ("  -h, --help                  show this help message\n");
  g_print ("  -v, --version               print version informations\n");
  g_print ("  --g-fatal-warnings          make warnings fatal (abort)\n");
  g_print ("  -k, --keep-going            continue running after tests failed\n");
  g_print ("  -l                          list paths of available test cases\n");
471 472
  g_print ("  -m=perf, -m=slow, -m=quick -m=thorough\n");
  g_print ("                              run test cases in mode perf, slow/thorough or quick (default)\n");
473 474 475
  g_print ("  -p=TESTPATH                 only start test cases matching TESTPATH\n");
  g_print ("  --seed=SEEDSTRING           start all tests with random number seed SEEDSTRING\n");
  g_print ("  -o=LOGFILE                  write the test log to LOGFILE\n");
476 477
  g_print ("  -q, --quiet                 suppress per test binary output\n");
  g_print ("  --verbose                   report success per testcase\n");
478
}
479

480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
static void
parse_args (gint    *argc_p,
            gchar ***argv_p)
{
  guint argc = *argc_p;
  gchar **argv = *argv_p;
  guint i, e;
  /* parse known args */
  for (i = 1; i < argc; i++)
    {
      if (strcmp (argv[i], "--g-fatal-warnings") == 0)
        {
          GLogLevelFlags fatal_mask = (GLogLevelFlags) g_log_set_always_fatal ((GLogLevelFlags) G_LOG_FATAL_MASK);
          fatal_mask = (GLogLevelFlags) (fatal_mask | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL);
          g_log_set_always_fatal (fatal_mask);
          argv[i] = NULL;
        }
497 498 499 500
      else if (strcmp (argv[i], "--gtester-selftest") == 0)
        {
          gtester_selftest = TRUE;
          argv[i] = NULL;
501
          break;        /* stop parsing regular gtester arguments */
502
        }
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
      else if (strcmp (argv[i], "-h") == 0 || strcmp (argv[i], "--help") == 0)
        {
          usage (FALSE);
          exit (0);
          argv[i] = NULL;
        }
      else if (strcmp (argv[i], "-v") == 0 || strcmp (argv[i], "--version") == 0)
        {
          usage (TRUE);
          exit (0);
          argv[i] = NULL;
        }
      else if (strcmp (argv[i], "--keep-going") == 0 ||
               strcmp (argv[i], "-k") == 0)
        {
          subtest_mode_fatal = FALSE;
          argv[i] = NULL;
        }
      else if (strcmp ("-p", argv[i]) == 0 || strncmp ("-p=", argv[i], 3) == 0)
        {
          gchar *equal = argv[i] + 2;
          if (*equal == '=')
            subtest_paths = g_slist_prepend (subtest_paths, equal + 1);
          else if (i + 1 < argc)
            {
              argv[i++] = NULL;
              subtest_paths = g_slist_prepend (subtest_paths, argv[i]);
            }
          argv[i] = NULL;
        }
533 534 535 536 537 538 539 540 541 542 543 544
      else if (strcmp ("--test-arg", argv[i]) == 0 || strncmp ("--test-arg=", argv[i], 11) == 0)
        {
          gchar *equal = argv[i] + 10;
          if (*equal == '=')
            subtest_args = g_slist_prepend (subtest_args, equal + 1);
          else if (i + 1 < argc)
            {
              argv[i++] = NULL;
              subtest_args = g_slist_prepend (subtest_args, argv[i]);
            }
          argv[i] = NULL;
        }
545 546 547 548
      else if (strcmp ("-o", argv[i]) == 0 || strncmp ("-o=", argv[i], 3) == 0)
        {
          gchar *equal = argv[i] + 2;
          if (*equal == '=')
549
            output_filename = equal + 1;
550 551 552
          else if (i + 1 < argc)
            {
              argv[i++] = NULL;
553
              output_filename = argv[i];
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
            }
          argv[i] = NULL;
        }
      else if (strcmp ("-m", argv[i]) == 0 || strncmp ("-m=", argv[i], 3) == 0)
        {
          gchar *equal = argv[i] + 2;
          const gchar *mode = "";
          if (*equal == '=')
            mode = equal + 1;
          else if (i + 1 < argc)
            {
              argv[i++] = NULL;
              mode = argv[i];
            }
          if (strcmp (mode, "perf") == 0)
            subtest_mode_perf = TRUE;
570
          else if (strcmp (mode, "slow") == 0 || strcmp (mode, "thorough") == 0)
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
            subtest_mode_quick = FALSE;
          else if (strcmp (mode, "quick") == 0)
            {
              subtest_mode_quick = TRUE;
              subtest_mode_perf = FALSE;
            }
          else
            g_error ("unknown test mode: -m %s", mode);
          argv[i] = NULL;
        }
      else if (strcmp ("-q", argv[i]) == 0 || strcmp ("--quiet", argv[i]) == 0)
        {
          gtester_quiet = TRUE;
          gtester_verbose = FALSE;
          argv[i] = NULL;
        }
      else if (strcmp ("--verbose", argv[i]) == 0)
        {
          gtester_quiet = FALSE;
          gtester_verbose = TRUE;
          argv[i] = NULL;
        }
      else if (strcmp ("-l", argv[i]) == 0)
        {
          gtester_list_tests = TRUE;
          argv[i] = NULL;
        }
      else if (strcmp ("--seed", argv[i]) == 0 || strncmp ("--seed=", argv[i], 7) == 0)
        {
          gchar *equal = argv[i] + 6;
          if (*equal == '=')
            subtest_seedstr = equal + 1;
          else if (i + 1 < argc)
            {
              argv[i++] = NULL;
              subtest_seedstr = argv[i];
            }
          argv[i] = NULL;
        }
    }
  /* collapse argv */
  e = 1;
  for (i = 1; i < argc; i++)
    if (argv[i])
      {
        argv[e++] = argv[i];
        if (i >= e)
          argv[i] = NULL;
      }
  *argc_p = e;
621 622
}

623 624 625 626 627 628
int
main (int    argc,
      char **argv)
{
  guint ui;

Tim Janik's avatar
Tim Janik committed
629 630 631 632
  /* some unices need SA_RESTART for SIGCHLD to return -EAGAIN for io.
   * we must fiddle with sigaction() *before* glib is used, otherwise
   * we could revoke signal hanmdler setups from glib initialization code.
   */
633
  if (TRUE)
Tim Janik's avatar
Tim Janik committed
634 635 636 637 638 639 640 641 642
    {
      struct sigaction sa;
      struct sigaction osa;
      sa.sa_handler = SIG_DFL;
      sigfillset (&sa.sa_mask);
      sa.sa_flags = SA_RESTART;
      sigaction (SIGCHLD, &sa, &osa);
    }

643 644
  g_set_prgname (argv[0]);
  parse_args (&argc, &argv);
645 646
  if (gtester_selftest)
    return main_selftest (argc, argv);
647 648 649 650 651 652 653

  if (argc <= 1)
    {
      usage (FALSE);
      return 1;
    }

654 655 656 657 658 659 660 661 662 663
  if (output_filename)
    {
      log_fd = g_open (output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
      if (log_fd < 0)
        g_error ("Failed to open log file '%s': %s", output_filename, g_strerror (errno));
    }

  test_log_printfe ("<?xml version=\"1.0\"?>\n");
  test_log_printfe ("%s<gtester>\n", sindent (log_indent));
  log_indent += 2;
664 665 666 667
  for (ui = 1; ui < argc; ui++)
    {
      const char *binary = argv[ui];
      launch_test (binary);
668
      /* we only get here on success or if !subtest_mode_fatal */
669
    }
670 671 672 673
  log_indent -= 2;
  test_log_printfe ("%s</gtester>\n", sindent (log_indent));

  close (log_fd);
674

675
  return testcase_fail_count == 0 ? 0 : 1;
676
}
677 678

static void
679 680
fixture_setup (guint        *fix,
               gconstpointer test_data)
681 682 683 684 685
{
  g_assert_cmphex (*fix, ==, 0);
  *fix = 0xdeadbeef;
}
static void
686 687
fixture_test (guint        *fix,
              gconstpointer test_data)
688 689
{
  g_assert_cmphex (*fix, ==, 0xdeadbeef);
690 691 692 693 694
  g_test_message ("This is a test message API test message.");
  g_test_bug_base ("http://www.example.com/bugtracker/");
  g_test_bug ("123");
  g_test_bug_base ("http://www.example.com/bugtracker?bugnum=%s;cmd=showbug");
  g_test_bug ("456");
695 696
}
static void
697 698
fixture_teardown (guint        *fix,
                  gconstpointer test_data)
699 700 701 702 703 704 705 706 707 708
{
  g_assert_cmphex (*fix, ==, 0xdeadbeef);
}

static int
main_selftest (int    argc,
               char **argv)
{
  /* gtester main() for --gtester-selftest invokations */
  g_test_init (&argc, &argv, NULL);
709
  g_test_add ("/gtester/fixture-test", guint, NULL, fixture_setup, fixture_test, fixture_teardown);
710 711
  return g_test_run();
}