static void srunner_iterate_suites (SRunner *sr, enum print_output CK_ATTRIBUTE_UNUSED print_mode) { List *slst; List *tcl; TCase *tc; slst = sr->slst; for (list_front(slst); !list_at_end(slst); list_advance(slst)) { Suite *s = list_val(slst); log_suite_start (sr, s); tcl = s->tclst; for (list_front(tcl);!list_at_end (tcl); list_advance (tcl)) { tc = list_val (tcl); srunner_run_tcase (sr, tc); } log_suite_end (sr, s); } }
static void srunner_iterate_suites (SRunner *sr, const char *sname, const char *tcname, enum print_output CK_ATTRIBUTE_UNUSED print_mode) { List *slst; List *tcl; TCase *tc; slst = sr->slst; for (list_front(slst); !list_at_end(slst); list_advance(slst)) { Suite *s = list_val(slst); if (((sname != NULL) && (strcmp (sname, s->name) != 0)) || ((tcname != NULL) && (!suite_tcase (s, tcname)))) continue; log_suite_start (sr, s); tcl = s->tclst; for (list_front(tcl);!list_at_end (tcl); list_advance (tcl)) { tc = list_val (tcl); if ((tcname != NULL) && (strcmp (tcname, tc->name) != 0)) { continue; } srunner_run_tcase (sr, tc); } log_suite_end (sr, s); } }
void srunner_free (SRunner *sr) { List *l; TestResult *tr; if (sr == NULL) return; free (sr->stats); l = sr->slst; for (list_front(l); !list_at_end(l); list_advance(l)) { suite_free(list_val(l)); } list_free(sr->slst); l = sr->resultlst; for (list_front(l); !list_at_end(l); list_advance(l)) { tr = list_val(l); free(tr->file); free(tr->msg); free(tr); } list_free (sr->resultlst); free (sr); }
static TestResult * tcase_run_checked_setup (SRunner *sr, TCase *tc) { TestResult *tr = NULL; List *l; Fixture *f; enum fork_status fstat = srunner_fork_status(sr); l = tc->ch_sflst; if (fstat == CK_FORK) { send_ctx_info(CK_CTX_SETUP); } for (list_front(l); !list_at_end(l); list_advance(l)) { if (fstat == CK_NOFORK) { send_ctx_info(CK_CTX_SETUP); } f = list_val(l); f->fun(); /* Stop the setup and return the failure if nofork mode. */ if (fstat == CK_NOFORK) { tr = receive_result_info_nofork (tc->name, "checked_setup", 0); if (tr->rtype != CK_PASS) { break; } free(tr->file); free(tr->msg); free(tr); tr = NULL; } } return tr; }
static int srunner_run_unchecked_setup (SRunner *sr, TCase *tc) { TestResult *tr; List *l; Fixture *f; int rval = 1; set_fork_status(CK_NOFORK); l = tc->unch_sflst; for (list_front(l); !list_at_end(l); list_advance(l)) { send_ctx_info(CK_CTX_SETUP); f = list_val(l); f->fun(); tr = receive_result_info_nofork (tc->name, "unchecked_setup", 0); if (tr->rtype != CK_PASS) { srunner_add_failure(sr, tr); rval = 0; break; } free(tr->file); free(tr->msg); free(tr); } set_fork_status(srunner_fork_status(sr)); return rval; }
static void srunner_iterate_tcase_tfuns (SRunner *sr, TCase *tc) { List *tfl; TF *tfun; TestResult *tr = NULL; tfl = tc->tflst; for (list_front(tfl); !list_at_end (tfl); list_advance (tfl)) { int i; tfun = list_val (tfl); for (i = tfun->loop_start; i < tfun->loop_end; i++) { log_test_start (sr, tc, tfun); switch (srunner_fork_status(sr)) { case CK_FORK: #ifdef _POSIX_VERSION tr = tcase_run_tfun_fork (sr, tc, tfun, i); #else /* _POSIX_VERSION */ eprintf("This version does not support fork", __FILE__, __LINE__); #endif /* _POSIX_VERSION */ break; case CK_NOFORK: tr = tcase_run_tfun_nofork (sr, tc, tfun, i); break; default: eprintf("Bad fork status in SRunner", __FILE__, __LINE__); } srunner_add_failure (sr, tr); log_test_end(sr, tr); } } }
void list_apply (List *lp, void (*fp) (void *)) { if (lp == NULL || fp == NULL) return; for (list_front(lp); !list_at_end(lp); list_advance(lp)) fp (list_val(lp)); }
static void srunner_run_teardown (List *l) { Fixture *f; for (list_front(l); !list_at_end(l); list_advance(l)) { f = list_val(l); send_ctx_info(CK_CTX_TEARDOWN); f->fun (); } }
static void suite_free (Suite *s) { List *l; if (s == NULL) return; l = s->tclst; for (list_front(l); !list_at_end(l); list_advance (l)) { tcase_free (list_val(l)); } list_free (s->tclst); free(s); }
static void srunner_send_evt (SRunner *sr, void *obj, enum cl_event evt) { List *l; Log *lg; l = sr->loglst; for (list_front(l); !list_at_end(l); list_advance(l)) { lg = list_val(l); fflush(lg->lfile); lg->lfun (sr, lg->lfile, lg->mode, obj, evt); fflush(lg->lfile); } }
static void srunner_fprint_results (FILE *file, SRunner *sr, enum print_output print_mode) { List *resultlst; resultlst = sr->resultlst; for (list_front(resultlst); !list_at_end(resultlst); list_advance(resultlst)) { TestResult *tr = list_val(resultlst); tr_fprint (file, tr, print_mode); } return; }
END_TEST START_TEST(test_add_end_and_next) { List *lp = check_list_create(); const char *tval1 = "abc"; const char *tval2 = "123"; list_add_end (lp, tval1); list_add_end (lp, tval2); list_front(lp); fail_unless (strcmp (tval1, list_val (lp)) == 0, "List head val should equal first inserted val"); list_advance (lp); fail_unless (!list_at_end (lp), "List should not be at end after two adds and one next"); fail_unless (strcmp (tval2, list_val (lp)) == 0, "List val should equal second inserted val"); list_advance(lp); fail_unless (list_at_end (lp), "List should be at and after two adds and two nexts"); list_free (lp); }
int suite_tcase (Suite *s, const char *tcname) { List *l; TCase *tc; if (s == NULL) return 0; l = s->tclst; for (list_front (l); !list_at_end (l); list_advance (l)) { tc = list_val (l); if (strcmp (tcname, tc->name) == 0) return 1; } return 0; }
void srunner_end_logging (SRunner *sr) { List *l; int rval; srunner_send_evt (sr, NULL, CLENDLOG_SR); l = sr->loglst; for (list_front(l); !list_at_end(l); list_advance(l)) { Log *lg = list_val(l); if (lg->close) { rval = fclose (lg->lfile); if (rval != 0) eprintf ("Error in call to fclose while closing log file:", __FILE__, __LINE__ - 2); } free (lg); } list_free(l); sr->loglst = NULL; }