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