nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 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, see <http://www.gnu.org/licenses/>.
17 */
18 #include "config.h"
19  
20 #include <glib.h>
21 #include <glib-unix.h>
22 #include <gstdio.h>
23 #include <string.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <fcntl.h>
27 #include <sys/wait.h>
28 #include <errno.h>
29 #include <signal.h>
30  
31 /* the read buffer size in bytes */
32 #define READ_BUFFER_SIZE 4096
33  
34 /* --- prototypes --- */
35 static int main_selftest (int argc,
36 char **argv);
37 static void parse_args (gint *argc_p,
38 gchar ***argv_p);
39  
40 /* --- variables --- */
41 static GIOChannel *ioc_report = NULL;
42 static gboolean gtester_quiet = FALSE;
43 static gboolean gtester_verbose = FALSE;
44 static gboolean gtester_list_tests = FALSE;
45 static gboolean gtester_selftest = FALSE;
46 static gboolean subtest_running = FALSE;
47 static gint subtest_exitstatus = 0;
48 static gboolean subtest_io_pending = FALSE;
49 static gboolean subtest_quiet = TRUE;
50 static gboolean subtest_verbose = FALSE;
51 static gboolean subtest_mode_fatal = TRUE;
52 static gboolean subtest_mode_perf = FALSE;
53 static gboolean subtest_mode_quick = TRUE;
54 static gboolean subtest_mode_undefined = TRUE;
55 static const gchar *subtest_seedstr = NULL;
56 static gchar *subtest_last_seed = NULL;
57 static GSList *subtest_paths = NULL;
58 static GSList *skipped_paths = NULL;
59 static GSList *subtest_args = NULL;
60 static gboolean testcase_open = FALSE;
61 static guint testcase_count = 0;
62 static guint testcase_fail_count = 0;
63 static const gchar *output_filename = NULL;
64 static guint log_indent = 0;
65 static gint log_fd = -1;
66  
67 /* --- functions --- */
68 static const char*
69 sindent (guint n)
70 {
71 static const char spaces[] = " ";
72 int l = sizeof (spaces) - 1;
73 n = MIN (n, l);
74 return spaces + l - n;
75 }
76  
77 static void G_GNUC_PRINTF (1, 2)
78 test_log_printfe (const char *format,
79 ...)
80 {
81 char *result;
82 int r;
83 va_list args;
84 va_start (args, format);
85 result = g_markup_vprintf_escaped (format, args);
86 va_end (args);
87 do
88 r = write (log_fd, result, strlen (result));
89 while (r < 0 && errno == EINTR);
90 g_free (result);
91 }
92  
93 static void
94 terminate (void)
95 {
96 kill (getpid(), SIGTERM);
97 abort();
98 }
99  
100 static void
101 testcase_close (long double duration,
102 gint exit_status,
103 guint n_forks)
104 {
105 g_return_if_fail (testcase_open > 0);
106 test_log_printfe ("%s<duration>%.6Lf</duration>\n", sindent (log_indent), duration);
107 test_log_printfe ("%s<status exit-status=\"%d\" n-forks=\"%d\" result=\"%s\"/>\n",
108 sindent (log_indent), exit_status, n_forks,
109 exit_status ? "failed" : "success");
110 log_indent -= 2;
111 test_log_printfe ("%s</testcase>\n", sindent (log_indent));
112 testcase_open--;
113 if (gtester_verbose)
114 g_print ("%s\n", exit_status ? "FAIL" : "OK");
115 if (exit_status && subtest_last_seed)
116 g_print ("GTester: last random seed: %s\n", subtest_last_seed);
117 if (exit_status)
118 testcase_fail_count += 1;
119 if (subtest_mode_fatal && exit_status)
120 terminate();
121 }
122  
123 static void
124 test_log_msg (GTestLogMsg *msg)
125 {
126 switch (msg->log_type)
127 {
128 guint i;
129 gchar **strv;
130 case G_TEST_LOG_NONE:
131 case G_TEST_LOG_START_SUITE:
132 case G_TEST_LOG_STOP_SUITE:
133 break;
134 case G_TEST_LOG_ERROR:
135 strv = g_strsplit (msg->strings[0], "\n", -1);
136 for (i = 0; strv[i]; i++)
137 test_log_printfe ("%s<error>%s</error>\n", sindent (log_indent), strv[i]);
138 g_strfreev (strv);
139 break;
140 case G_TEST_LOG_START_BINARY:
141 test_log_printfe ("%s<binary file=\"%s\"/>\n", sindent (log_indent), msg->strings[0]);
142 subtest_last_seed = g_strdup (msg->strings[1]);
143 test_log_printfe ("%s<random-seed>%s</random-seed>\n", sindent (log_indent), subtest_last_seed);
144 break;
145 case G_TEST_LOG_LIST_CASE:
146 g_print ("%s\n", msg->strings[0]);
147 break;
148 case G_TEST_LOG_START_CASE:
149 testcase_count++;
150 if (gtester_verbose)
151 {
152 gchar *sc = g_strconcat (msg->strings[0], ":", NULL);
153 gchar *sleft = g_strdup_printf ("%-68s", sc);
154 g_free (sc);
155 g_print ("%70s ", sleft);
156 g_free (sleft);
157 }
158 g_return_if_fail (testcase_open == 0);
159 testcase_open++;
160 test_log_printfe ("%s<testcase path=\"%s\">\n", sindent (log_indent), msg->strings[0]);
161 log_indent += 2;
162 break;
163 case G_TEST_LOG_SKIP_CASE:
164 if (FALSE && gtester_verbose) /* enable to debug test case skipping logic */
165 {
166 gchar *sc = g_strconcat (msg->strings[0], ":", NULL);
167 gchar *sleft = g_strdup_printf ("%-68s", sc);
168 g_free (sc);
169 g_print ("%70s SKIPPED\n", sleft);
170 g_free (sleft);
171 }
172 test_log_printfe ("%s<testcase path=\"%s\" skipped=\"1\"/>\n", sindent (log_indent), msg->strings[0]);
173 break;
174 case G_TEST_LOG_STOP_CASE:
175 testcase_close (msg->nums[2], (int) msg->nums[0], (int) msg->nums[1]);
176 break;
177 case G_TEST_LOG_MIN_RESULT:
178 case G_TEST_LOG_MAX_RESULT:
179 test_log_printfe ("%s<performance minimize=\"%d\" maximize=\"%d\" value=\"%.16Lg\">\n",
180 sindent (log_indent), msg->log_type == G_TEST_LOG_MIN_RESULT, msg->log_type == G_TEST_LOG_MAX_RESULT, msg->nums[0]);
181 test_log_printfe ("%s%s\n", sindent (log_indent + 2), msg->strings[0]);
182 test_log_printfe ("%s</performance>\n", sindent (log_indent));
183 break;
184 case G_TEST_LOG_MESSAGE:
185 test_log_printfe ("%s<message>\n%s\n%s</message>\n", sindent (log_indent), msg->strings[0], sindent (log_indent));
186 break;
187 }
188 }
189  
190 static gboolean
191 child_report_cb (GIOChannel *source,
192 GIOCondition condition,
193 gpointer data)
194 {
195 GTestLogBuffer *tlb = data;
196 GIOStatus status = G_IO_STATUS_NORMAL;
197 gboolean first_read_eof = FALSE, first_read = TRUE;
198 gsize length = 0;
199 do
200 {
201 guint8 buffer[READ_BUFFER_SIZE];
202 GError *error = NULL;
203 status = g_io_channel_read_chars (source, (gchar*) buffer, sizeof (buffer), &length, &error);
204 if (first_read && (condition & G_IO_IN))
205 {
206 /* on some unixes (MacOS) we need to detect non-blocking fd EOF
207 * by an IO_IN select/poll followed by read()==0.
208 */
209 first_read_eof = length == 0;
210 }
211 first_read = FALSE;
212 if (length)
213 {
214 GTestLogMsg *msg;
215 g_test_log_buffer_push (tlb, length, buffer);
216 do
217 {
218 msg = g_test_log_buffer_pop (tlb);
219 if (msg)
220 {
221 test_log_msg (msg);
222 g_test_log_msg_free (msg);
223 }
224 }
225 while (msg);
226 }
227 g_clear_error (&error);
228 /* ignore the io channel status, which will report intermediate EOFs for non blocking fds */
229 (void) status;
230 }
231 while (length > 0);
232 /* g_print ("LASTIOSTATE: first_read_eof=%d condition=%d\n", first_read_eof, condition); */
233 if (first_read_eof || (condition & (G_IO_ERR | G_IO_HUP)))
234 {
235 /* if there's no data to read and select() reports an error or hangup,
236 * the fd must have been closed remotely
237 */
238 subtest_io_pending = FALSE;
239 return FALSE;
240 }
241 return TRUE; /* keep polling */
242 }
243  
244 static void
245 child_watch_cb (GPid pid,
246 gint status,
247 gpointer data)
248 {
249 g_spawn_close_pid (pid);
250 if (WIFEXITED (status)) /* normal exit */
251 subtest_exitstatus = WEXITSTATUS (status);
252 else /* signal or core dump, etc */
253 subtest_exitstatus = 0xffffffff;
254 subtest_running = FALSE;
255 }
256  
257 static gchar*
258 queue_gfree (GSList **slistp,
259 gchar *string)
260 {
261 *slistp = g_slist_prepend (*slistp, string);
262 return string;
263 }
264  
265 static void
266 unset_cloexec_fdp (gpointer fdp_data)
267 {
268 int r, *fdp = fdp_data;
269 do
270 r = fcntl (*fdp, F_SETFD, 0 /* FD_CLOEXEC */);
271 while (r < 0 && errno == EINTR);
272 }
273  
274 static gboolean
275 launch_test_binary (const char *binary,
276 guint skip_tests)
277 {
278 GTestLogBuffer *tlb;
279 GSList *slist, *free_list = NULL;
280 GError *error = NULL;
281 int argc = 0;
282 const gchar **argv;
283 GPid pid = 0;
284 gint report_pipe[2] = { -1, -1 };
285 guint child_report_cb_id = 0;
286 gboolean loop_pending;
287 gint i = 0;
288  
289 if (!g_unix_open_pipe (report_pipe, FD_CLOEXEC, &error))
290 {
291 if (subtest_mode_fatal)
292 g_error ("Failed to open pipe for test binary: %s: %s", binary, error->message);
293 else
294 g_warning ("Failed to open pipe for test binary: %s: %s", binary, error->message);
295 g_clear_error (&error);
296 return FALSE;
297 }
298  
299 /* setup argc */
300 for (slist = subtest_args; slist; slist = slist->next)
301 argc++;
302 /* argc++; */
303 if (subtest_quiet)
304 argc++;
305 if (subtest_verbose)
306 argc++;
307 if (!subtest_mode_fatal)
308 argc++;
309 if (subtest_mode_quick)
310 argc++;
311 else
312 argc++;
313 if (subtest_mode_perf)
314 argc++;
315 if (!subtest_mode_undefined)
316 argc++;
317 if (gtester_list_tests)
318 argc++;
319 if (subtest_seedstr)
320 argc++;
321 argc++;
322 if (skip_tests)
323 argc++;
324 for (slist = subtest_paths; slist; slist = slist->next)
325 argc++;
326 for (slist = skipped_paths; slist; slist = slist->next)
327 argc++;
328  
329 /* setup argv */
330 argv = g_malloc ((argc + 2) * sizeof(gchar *));
331 argv[i++] = binary;
332 for (slist = subtest_args; slist; slist = slist->next)
333 argv[i++] = (gchar*) slist->data;
334 /* argv[i++] = "--debug-log"; */
335 if (subtest_quiet)
336 argv[i++] = "--quiet";
337 if (subtest_verbose)
338 argv[i++] = "--verbose";
339 if (!subtest_mode_fatal)
340 argv[i++] = "--keep-going";
341 if (subtest_mode_quick)
342 argv[i++] = "-m=quick";
343 else
344 argv[i++] = "-m=slow";
345 if (subtest_mode_perf)
346 argv[i++] = "-m=perf";
347 if (!subtest_mode_undefined)
348 argv[i++] = "-m=no-undefined";
349 if (gtester_list_tests)
350 argv[i++] = "-l";
351 if (subtest_seedstr)
352 argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--seed=%s", subtest_seedstr));
353 argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--GTestLogFD=%u", report_pipe[1]));
354 if (skip_tests)
355 argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--GTestSkipCount=%u", skip_tests));
356 for (slist = subtest_paths; slist; slist = slist->next)
357 argv[i++] = queue_gfree (&free_list, g_strdup_printf ("-p=%s", (gchar*) slist->data));
358 for (slist = skipped_paths; slist; slist = slist->next)
359 argv[i++] = queue_gfree (&free_list, g_strdup_printf ("-s=%s", (gchar*) slist->data));
360 argv[i++] = NULL;
361  
362 g_spawn_async_with_pipes (NULL, /* g_get_current_dir() */
363 (gchar**) argv,
364 NULL, /* envp */
365 G_SPAWN_DO_NOT_REAP_CHILD, /* G_SPAWN_SEARCH_PATH */
366 unset_cloexec_fdp, &report_pipe[1], /* pre-exec callback */
367 &pid,
368 NULL, /* standard_input */
369 NULL, /* standard_output */
370 NULL, /* standard_error */
371 &error);
372 g_slist_foreach (free_list, (void(*)(void*,void*)) g_free, NULL);
373 g_slist_free (free_list);
374 free_list = NULL;
375 close (report_pipe[1]);
376  
377 if (!gtester_quiet)
378 g_print ("(pid=%lu)\n", (unsigned long) pid);
379  
380 if (error)
381 {
382 close (report_pipe[0]);
383 if (subtest_mode_fatal)
384 g_error ("Failed to execute test binary: %s: %s", argv[0], error->message);
385 else
386 g_warning ("Failed to execute test binary: %s: %s", argv[0], error->message);
387 g_clear_error (&error);
388 g_free (argv);
389 return FALSE;
390 }
391 g_free (argv);
392  
393 subtest_running = TRUE;
394 subtest_io_pending = TRUE;
395 tlb = g_test_log_buffer_new();
396 if (report_pipe[0] >= 0)
397 {
398 ioc_report = g_io_channel_unix_new (report_pipe[0]);
399 g_io_channel_set_flags (ioc_report, G_IO_FLAG_NONBLOCK, NULL);
400 g_io_channel_set_encoding (ioc_report, NULL, NULL);
401 g_io_channel_set_buffered (ioc_report, FALSE);
402 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);
403 g_io_channel_unref (ioc_report);
404 }
405 g_child_watch_add_full (G_PRIORITY_DEFAULT + 1, pid, child_watch_cb, NULL, NULL);
406  
407 loop_pending = g_main_context_pending (NULL);
408 while (subtest_running || /* FALSE once child exits */
409 subtest_io_pending || /* FALSE once ioc_report closes */
410 loop_pending) /* TRUE while idler, etc are running */
411 {
412 /* g_print ("LOOPSTATE: subtest_running=%d subtest_io_pending=%d\n", subtest_running, subtest_io_pending); */
413 /* check for unexpected hangs that are not signalled on report_pipe */
414 if (!subtest_running && /* child exited */
415 subtest_io_pending && /* no EOF detected on report_pipe */
416 !loop_pending) /* no IO events pending however */
417 break;
418 g_main_context_iteration (NULL, TRUE);
419 loop_pending = g_main_context_pending (NULL);
420 }
421  
422 if (subtest_io_pending)
423 g_source_remove (child_report_cb_id);
424  
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 }