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);
}
}
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);
}
}
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_advance (List *lp)
{
if (lp == NULL)
return;
if (list_at_end(lp))
return;
lp->current++;
}
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);
}
END_TEST
START_TEST(test_add_end)
{
List * lp = check_list_create();
const char * tval = "abc";
list_add_end (lp, tval);
fail_unless (list_val (lp) != NULL,
"List current val should not be null after new insertion");
fail_unless (!list_at_end (lp),
"List should be at end after new insertion");
fail_unless (strcmp(tval, (char *) list_val (lp)) == 0,
"List current val should equal newly inserted val");
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;
}
