void
cairo_test_fini (cairo_test_context_t *ctx)
{
if (ctx->log_file == NULL)
return;
if (ctx->log_file != stderr)
fclose (ctx->log_file);
ctx->log_file = NULL;
free (ctx->ref_name);
cairo_surface_destroy (ctx->ref_image);
cairo_surface_destroy (ctx->ref_image_flattened);
if (ctx->test_name != NULL)
free ((char *) ctx->test_name);
if (ctx->own_targets)
cairo_boilerplate_free_targets (ctx->targets_to_test);
cairo_boilerplate_fini ();
cairo_debug_reset_static_data ();
#if HAVE_FCFINI
FcFini ();
#endif
}
static void
cairo_perf_fini (cairo_perf_t *perf)
{
cairo_boilerplate_free_targets (perf->targets);
free (perf->times);
cairo_debug_reset_static_data ();
#if HAVE_FCFINI
FcFini ();
#endif
}
static cairo_test_status_t
cairo_test_expecting (cairo_test_t *test,
cairo_test_status_t expectation)
{
/* we use volatile here to make sure values are not clobbered
* by longjmp */
volatile size_t i, j, num_targets;
volatile cairo_bool_t limited_targets = FALSE, print_fail_on_stdout = TRUE;
#ifdef HAVE_SIGNAL_H
void (*old_segfault_handler)(int);
#endif
volatile cairo_test_status_t status, ret;
cairo_boilerplate_target_t ** volatile targets_to_test;
#ifdef HAVE_UNISTD_H
if (isatty (2)) {
fail_face = "\033[41m\033[37m\033[1m";
normal_face = "\033[m";
if (isatty (1))
print_fail_on_stdout = FALSE;
}
#endif
srcdir = getenv ("srcdir");
if (!srcdir)
srcdir = ".";
cairo_test_init (test->name);
printf ("%s\n", test->description);
if (expectation == CAIRO_TEST_FAILURE)
printf ("Expecting failure\n");
{
int tmp_num_targets;
cairo_bool_t tmp_limited_targets;
targets_to_test = cairo_boilerplate_get_targets (&tmp_num_targets, &tmp_limited_targets);
num_targets = tmp_num_targets;
limited_targets = tmp_limited_targets;
}
/* The intended logic here is that we return overall SUCCESS
* iff. there is at least one tested backend and that all tested
* backends return SUCCESS, OR, there's backends were manually
* limited, and none were tested.
* In other words:
*
* if backends limited and no backend tested
* -> SUCCESS
* else if any backend not SUCCESS
* -> FAILURE
* else if all backends UNTESTED
* -> FAILURE
* else (== some backend SUCCESS)
* -> SUCCESS
*
* Also, on a crash, run no further tests.
*/
status = ret = CAIRO_TEST_UNTESTED;
for (i = 0; i < num_targets && status != CAIRO_TEST_CRASHED; i++) {
for (j = 0; j < NUM_DEVICE_OFFSETS; j++) {
cairo_boilerplate_target_t * volatile target = targets_to_test[i];
volatile int dev_offset = j * 25;
cairo_test_log ("Testing %s with %s target (dev offset %d)\n", test->name, target->name, dev_offset);
printf ("%s-%s-%s [%d]:\t", test->name, target->name,
cairo_boilerplate_content_name (target->content),
dev_offset);
#ifdef HAVE_SIGNAL_H
/* Set up a checkpoint to get back to in case of segfaults. */
old_segfault_handler = signal (SIGSEGV, segfault_handler);
if (0 == setjmp (jmpbuf))
#endif
status = cairo_test_for_target (test, target, dev_offset);
#ifdef HAVE_SIGNAL_H
else
status = CAIRO_TEST_CRASHED;
signal (SIGSEGV, old_segfault_handler);
#endif
cairo_test_log ("TEST: %s TARGET: %s FORMAT: %s OFFSET: %d RESULT: ",
test->name, target->name,
cairo_boilerplate_content_name (target->content),
dev_offset);
switch (status) {
case CAIRO_TEST_SUCCESS:
printf ("PASS\n");
cairo_test_log ("PASS\n");
if (ret == CAIRO_TEST_UNTESTED)
ret = CAIRO_TEST_SUCCESS;
break;
case CAIRO_TEST_UNTESTED:
printf ("UNTESTED\n");
cairo_test_log ("UNTESTED\n");
break;
case CAIRO_TEST_CRASHED:
if (print_fail_on_stdout) {
printf ("!!!CRASHED!!!\n");
} else {
/* eat the test name */
printf ("\r");
fflush (stdout);
}
cairo_test_log ("CRASHED\n");
fprintf (stderr, "%s-%s-%s [%d]:\t%s!!!CRASHED!!!%s\n",
test->name, target->name,
cairo_boilerplate_content_name (target->content), dev_offset,
fail_face, normal_face);
ret = CAIRO_TEST_FAILURE;
break;
default:
case CAIRO_TEST_FAILURE:
if (expectation == CAIRO_TEST_FAILURE) {
printf ("XFAIL\n");
cairo_test_log ("XFAIL\n");
} else {
if (print_fail_on_stdout) {
printf ("FAIL\n");
} else {
/* eat the test name */
printf ("\r");
fflush (stdout);
}
fprintf (stderr, "%s-%s-%s [%d]:\t%sFAIL%s\n",
test->name, target->name,
cairo_boilerplate_content_name (target->content), dev_offset,
fail_face, normal_face);
cairo_test_log ("FAIL\n");
}
ret = status;
break;
}
}
}
if (ret != CAIRO_TEST_SUCCESS)
printf ("Check %s%s out for more information.\n", test->name, CAIRO_TEST_LOG_SUFFIX);
/* if the set of targets to test was limited using CAIRO_TEST_TARGET, we
* behave slightly differently, to ensure that limiting the targets does
* not increase the number of tests failing. */
if (limited_targets) {
/* if all untested, success */
if (ret == CAIRO_TEST_UNTESTED) {
printf ("None of the tested backends passed, but tested targets are manually limited.\n"
"Passing the test, to not fail the suite.\n");
ret = CAIRO_TEST_SUCCESS;
}
/* if all passed, but expecting failure, return failure to not
* trigger an XPASS failure */
if (expectation == CAIRO_TEST_FAILURE && ret == CAIRO_TEST_SUCCESS) {
printf ("All tested backends passed, but tested targets are manually limited\n"
"and the test suite expects this test to fail for at least one target.\n"
"Intentionally failing the test, to not fail the suite.\n");
ret = CAIRO_TEST_FAILURE;
}
} else {
if (ret == CAIRO_TEST_UNTESTED)
ret = CAIRO_TEST_FAILURE;
}
cairo_test_fini ();
cairo_boilerplate_free_targets (targets_to_test);
return ret;
}
int
main (int argc, char *argv[])
{
int i, j, num_targets;
cairo_perf_case_t *perf_case;
cairo_perf_t perf;
cairo_boilerplate_target_t **targets;
cairo_surface_t *surface;
parse_options (&perf, argc, argv);
if (check_cpu_affinity()) {
fputs(
"NOTICE: cairo-perf and the X server should be bound to CPUs (either the same\n"
"or separate) on SMP systems. Not doing so causes random results when the X\n"
"server is moved to or from cairo-perf's CPU during the benchmarks:\n"
"\n"
" $ sudo taskset -cp 0 $(pidof X)\n"
" $ taskset -cp 1 $$\n"
"\n"
"See taskset(1) for information about changing CPU affinity.\n",
stderr);
}
targets = cairo_boilerplate_get_targets (&num_targets, NULL);
for (i = 0; i < num_targets; i++) {
cairo_boilerplate_target_t *target = targets[i];
if (! target_is_measurable (target))
continue;
perf.target = target;
perf.test_number = 0;
for (j = 0; perf_cases[j].run; j++) {
perf_case = &perf_cases[j];
for (perf.size = perf_case->min_size;
perf.size <= perf_case->max_size;
perf.size *= 2)
{
surface = (target->create_surface) (NULL,
target->content,
perf.size, perf.size,
CAIRO_BOILERPLATE_MODE_PERF,
&target->closure);
if (surface == NULL) {
fprintf (stderr,
"Error: Failed to create target surface: %s\n",
target->name);
cairo_boilerplate_free_targets (targets);
cairo_perf_fini ();
exit (1);
}
cairo_perf_timer_set_synchronize (target->synchronize,
target->closure);
perf.cr = cairo_create (surface);
perf_case->run (&perf, perf.cr, perf.size, perf.size);
if (cairo_status (perf.cr)) {
fprintf (stderr, "Error: Test left cairo in an error state: %s\n",
cairo_status_to_string (cairo_status (perf.cr)));
cairo_boilerplate_free_targets (targets);
cairo_perf_fini ();
exit (1);
}
cairo_destroy (perf.cr);
cairo_surface_destroy (surface);
if (target->cleanup)
target->cleanup (target->closure);
}
}
}
cairo_boilerplate_free_targets (targets);
cairo_perf_fini ();
return 0;
}