/// Rewrites the test cases list from the input to the output.
///
/// \param [in,out] input Stream from which to read the test program's test
/// cases list. The current location must be after the header and at the
/// first identifier (if any).
/// \param [out] output Stream to which to write the generic list.
///
/// \return An error object.
static kyua_error_t
parse_tests(FILE* input, FILE* output)
{
char line[512]; // It's ugly to have a limit, but it's easier this way.
if (fgets_no_newline(line, sizeof(line), input) == NULL) {
return fgets_error(input, "Empty test cases list");
}
kyua_error_t error;
do {
char* key = NULL; char* value = NULL;
error = parse_property(line, &key, &value);
if (kyua_error_is_set(error))
break;
if (strcmp(key, "ident") == 0) {
error = parse_test_case(input, output, value);
} else {
error = kyua_generic_error_new("Expected ident property, got %s",
key);
}
} while (!kyua_error_is_set(error) &&
fgets_no_newline(line, sizeof(line), input) != NULL);
if (!kyua_error_is_set(error)) {
if (ferror(input))
error = kyua_libc_error_new(errno, "fgets failed");
else
assert(feof(input));
}
return error;
}
static struct TestSet *parse_set(struct TestFile *tf)
{
struct TestSet *set = NEW0(struct TestSet);
char *tok;
size_t len;
assert(tf->next_pos);
assert(tf->next_pos > tf->read_pos);
set->name = expect_name(tf, &set->name_len, "set");
if (!set->name)
goto err;
if (expect_eol(tf))
goto err;
// set contents: dep, tolerance, setup, teardown, test case, fortran
set->tolerance = 0.0; // XXX magic number == BAD
for (;;) {
tok = next_token(tf, &len);
if (tok == END_OF_LINE) {
if (!next_line(tf)) {
syntax_error(tf);
goto err; // EOF
}
} else if (tok) {
if (same_token("dep", 3, tok, len)) {
struct TestDependency *dep = parse_dependency(tf);
if (!dep)
goto err;
dep->next = set->deps;
set->deps = dep;
set->n_deps++;
} else if (same_token("use", 3, tok, len)) {
struct TestModule *mod = parse_module(tf);
if (!mod)
goto err;
mod->next = set->mods;
set->mods = mod;
set->n_mods++;
} else if (same_token("tolerance", 9, tok, len)) {
char *tolend;
tok = next_token(tf, &len);
if (!tok || tok == END_OF_LINE) {
fail(tf, tf->read_pos, "expected tolerance value");
goto err;
}
set->tolerance = strtod(tf->read_pos, &tolend);
if (tolend == tf->read_pos || tolend != tf->next_pos) {
fail(tf, tf->read_pos, "not a floating point value");
goto err;
}
tf->next_pos = tolend;
} else if (same_token("setup", 5, tok, len)) {
if (set->setup) {
fail(tf, tf->next_pos,
"more than one setup case specified");
goto err;
}
set->setup = parse_support(tf, "setup");
if (!set->setup)
goto err;
} else if (same_token("teardown", 8, tok, len)) {
if (set->teardown) {
fail(tf, tf->next_pos,
"more than one teardown case specified");
goto err;
}
set->teardown = parse_support(tf, "teardown");
if (!set->teardown)
goto err;
} else if (same_token("test", 4, tok, len)) {
struct TestCase *test = parse_test_case(tf);
if (!test)
goto err;
test->next = set->tests;
set->tests = test;
set->n_tests++;
} else if (same_token("end", 3, tok, len)) {
tf->next_pos = tf->read_pos;
break; // end of test set
} else { // fortran code
struct Code *code;
tf->next_pos = tf->read_pos = tf->line_pos;
code = parse_fortran(tf, NULL);
// XXX check for parse fail?
code->next = set->code;
set->code = code;
}
} else { // EOF
fail(tf, tf->read_pos, "expected end set");
goto err;
}
}
// end set name
if (parse_end_sequence(tf, "set", set->name, set->name_len))
goto err;
return set;
err:
free_sets(set);
return NULL;
}
