atf_error_t
atf_list_init(atf_list_t *l)
{
struct list_entry *lebeg, *leend;
lebeg = new_entry(NULL, false);
if (lebeg == NULL) {
return atf_no_memory_error();
}
leend = new_entry(NULL, false);
if (leend == NULL) {
free(lebeg);
return atf_no_memory_error();
}
lebeg->m_next = leend;
lebeg->m_prev = NULL;
leend->m_next = NULL;
leend->m_prev = lebeg;
l->m_size = 0;
l->m_begin = lebeg;
l->m_end = leend;
return atf_no_error();
}
atf_error_t
atf_error_new(const char *type, void *data, size_t datalen,
void (*format)(const atf_error_t, char *, size_t))
{
atf_error_t err;
PRE(!error_on_flight);
PRE(data != NULL || datalen == 0);
PRE(datalen != 0 || data == NULL);
err = malloc(sizeof(*err));
if (err == NULL)
err = atf_no_memory_error();
else {
if (!error_init(err, type, data, datalen, format)) {
free(err);
err = atf_no_memory_error();
} else {
err->m_free = true;
error_on_flight = true;
}
}
INV(err != NULL);
POST(error_on_flight);
return err;
}
static
atf_error_t
handle_tcarg(const char *tcarg, char **tcname, enum tc_part *tcpart)
{
atf_error_t err;
err = atf_no_error();
*tcname = strdup(tcarg);
if (*tcname == NULL) {
err = atf_no_memory_error();
goto out;
}
char *delim = strchr(*tcname, ':');
if (delim != NULL) {
*delim = '\0';
delim++;
if (strcmp(delim, "body") == 0) {
*tcpart = BODY;
} else if (strcmp(delim, "cleanup") == 0) {
*tcpart = CLEANUP;
} else {
err = usage_error("Invalid test case part `%s'", delim);
goto out;
}
}
out:
return err;
}
ATF_TC_BODY(no_memory_twice, tc)
{
{
atf_error_t err = atf_no_memory_error();
ATF_REQUIRE(atf_error_is(err, "no_memory"));
ATF_REQUIRE(atf_error_data(err) == NULL);
atf_error_free(err);
}
{
atf_error_t err = atf_no_memory_error();
ATF_REQUIRE(atf_error_is(err, "no_memory"));
ATF_REQUIRE(atf_error_data(err) == NULL);
atf_error_free(err);
}
}
atf_error_t
atf_text_for_each_word(const char *instr, const char *sep,
atf_error_t (*func)(const char *, void *),
void *data)
{
atf_error_t err;
char *str, *str2, *last;
str = strdup(instr);
if (str == NULL) {
err = atf_no_memory_error();
goto out;
}
err = atf_no_error();
str2 = strtok_r(str, sep, &last);
while (str2 != NULL && !atf_is_error(err)) {
err = func(str2, data);
str2 = strtok_r(NULL, sep, &last);
}
free(str);
out:
return err;
}
ATF_TC_BODY(no_memory_format, tc)
{
atf_error_t err;
char buf[1024];
err = atf_no_memory_error();
atf_error_format(err, buf, sizeof(buf));
ATF_REQUIRE(strcmp(buf, "Not enough memory") == 0);
atf_error_free(err);
}
static
atf_error_t
controlled_main(int argc, char **argv,
atf_error_t (*add_tcs_hook)(atf_tp_t *),
int *exitcode)
{
atf_error_t err;
struct params p;
atf_tp_t tp;
char **raw_config;
err = process_params(argc, argv, &p);
if (atf_is_error(err))
goto out;
err = handle_srcdir(&p);
if (atf_is_error(err))
goto out_p;
raw_config = atf_map_to_charpp(&p.m_config);
if (raw_config == NULL) {
err = atf_no_memory_error();
goto out_p;
}
err = atf_tp_init(&tp, (const char* const*)raw_config);
atf_utils_free_charpp(raw_config);
if (atf_is_error(err))
goto out_p;
err = add_tcs_hook(&tp);
if (atf_is_error(err))
goto out_tp;
if (p.m_do_list) {
list_tcs(&tp);
INV(!atf_is_error(err));
*exitcode = EXIT_SUCCESS;
} else {
err = run_tc(&tp, &p, exitcode);
}
out_tp:
atf_tp_fini(&tp);
out_p:
params_fini(&p);
out:
return err;
}
static
atf_error_t
copy_contents(const atf_fs_path_t *p, char **buf)
{
atf_error_t err;
char *str;
str = (char *)malloc(atf_dynstr_length(&p->m_data) + 1);
if (str == NULL)
err = atf_no_memory_error();
else {
strcpy(str, atf_dynstr_cstring(&p->m_data));
*buf = str;
err = atf_no_error();
}
return err;
}
atf_error_t
atf_list_append(atf_list_t *l, void *data, bool managed)
{
struct list_entry *le, *next, *prev;
atf_error_t err;
next = (struct list_entry *)l->m_end;
prev = next->m_prev;
le = new_entry_and_link(data, managed, prev, next);
if (le == NULL)
err = atf_no_memory_error();
else {
l->m_size++;
err = atf_no_error();
}
return err;
}
static
atf_error_t
list_to_array(const atf_list_t *l, char ***ap)
{
atf_error_t err;
char **a;
a = (char **)malloc((atf_list_size(l) + 1) * sizeof(char *));
if (a == NULL)
err = atf_no_memory_error();
else {
char **aiter;
atf_list_citer_t liter;
aiter = a;
atf_list_for_each_c(liter, l) {
*aiter = strdup((const char *)atf_list_citer_data(liter));
aiter++;
}
*aiter = NULL;
err = atf_no_error();
}
