ATF_TC_BODY (status_signaled, tc)
{
{
const int rawstatus = fork_and_wait_child (child_sigkill);
atf_process_status_t s;
RE (atf_process_status_init (&s, rawstatus));
ATF_CHECK (!atf_process_status_exited (&s));
ATF_CHECK (atf_process_status_signaled (&s));
ATF_CHECK_EQ (atf_process_status_termsig (&s), SIGKILL);
ATF_CHECK (!atf_process_status_coredump (&s));
atf_process_status_fini (&s);
}
{
const int rawstatus = fork_and_wait_child (child_sigterm);
atf_process_status_t s;
RE (atf_process_status_init (&s, rawstatus));
ATF_CHECK (!atf_process_status_exited (&s));
ATF_CHECK (atf_process_status_signaled (&s));
ATF_CHECK_EQ (atf_process_status_termsig (&s), SIGTERM);
ATF_CHECK (!atf_process_status_coredump (&s));
atf_process_status_fini (&s);
}
}
ATF_TC_BODY (status_exited, tc)
{
{
const int rawstatus = fork_and_wait_child (child_exit_success);
atf_process_status_t s;
RE (atf_process_status_init (&s, rawstatus));
ATF_CHECK (atf_process_status_exited (&s));
ATF_CHECK_EQ (atf_process_status_exitstatus (&s), EXIT_SUCCESS);
ATF_CHECK (!atf_process_status_signaled (&s));
atf_process_status_fini (&s);
}
{
const int rawstatus = fork_and_wait_child (child_exit_failure);
atf_process_status_t s;
RE (atf_process_status_init (&s, rawstatus));
ATF_CHECK (atf_process_status_exited (&s));
ATF_CHECK_EQ (atf_process_status_exitstatus (&s), EXIT_FAILURE);
ATF_CHECK (!atf_process_status_signaled (&s));
atf_process_status_fini (&s);
}
}
/* TODO: Investigate if it's worth to add this functionality as part of
* the public API. I.e. a function to easily run a test case body in a
* subprocess. */
void
run_h_tc(atf_tc_t *tc, const char *outname, const char *errname,
const char *resname)
{
atf_fs_path_t outpath, errpath;
atf_process_stream_t outb, errb;
atf_process_child_t child;
atf_process_status_t status;
RE(atf_fs_path_init_fmt(&outpath, outname));
RE(atf_fs_path_init_fmt(&errpath, errname));
struct run_h_tc_data data = { tc, resname };
RE(atf_process_stream_init_redirect_path(&outb, &outpath));
RE(atf_process_stream_init_redirect_path(&errb, &errpath));
RE(atf_process_fork(&child, run_h_tc_child, &outb, &errb, &data));
atf_process_stream_fini(&errb);
atf_process_stream_fini(&outb);
RE(atf_process_child_wait(&child, &status));
ATF_CHECK(atf_process_status_exited(&status));
atf_process_status_fini(&status);
atf_fs_path_fini(&errpath);
atf_fs_path_fini(&outpath);
}
ATF_TC_BODY (child_pid, tc)
{
atf_process_stream_t outsb, errsb;
atf_process_child_t child;
atf_process_status_t status;
pid_t pid;
RE (atf_process_stream_init_capture (&outsb));
RE (atf_process_stream_init_inherit (&errsb));
RE (atf_process_fork (&child, child_report_pid, &outsb, &errsb, NULL));
ATF_CHECK_EQ (read (atf_process_child_stdout (&child), &pid, sizeof (pid)), sizeof (pid));
printf ("Expected PID: %d\n", (int) atf_process_child_pid (&child));
printf ("Actual PID: %d\n", (int) pid);
ATF_CHECK_EQ (atf_process_child_pid (&child), pid);
RE (atf_process_child_wait (&child, &status));
atf_process_status_fini (&status);
atf_process_stream_fini (&outsb);
atf_process_stream_fini (&errsb);
}
ATF_TC_BODY (exec_success, tc)
{
atf_process_status_t status;
do_exec (tc, "exit-success", &status);
ATF_CHECK (atf_process_status_exited (&status));
ATF_CHECK_EQ (atf_process_status_exitstatus (&status), EXIT_SUCCESS);
atf_process_status_fini (&status);
}
ATF_TC_BODY (exec_failure, tc)
{
atf_process_status_t status;
do_exec (tc, "exit-failure", &status);
ATF_CHECK (atf_process_status_exited (&status));
ATF_CHECK_EQ (atf_process_status_exitstatus (&status), EXIT_FAILURE);
atf_process_status_fini (&status);
}
impl::child::~child(void)
{
if (!m_waited) {
::kill(atf_process_child_pid(&m_child), SIGTERM);
atf_process_status_t s;
atf_error_t err = atf_process_child_wait(&m_child, &s);
INV(!atf_is_error(err));
atf_process_status_fini(&s);
}
}
ATF_TC_BODY (fork_cookie, tc)
{
atf_process_stream_t outsb, errsb;
RE (atf_process_stream_init_inherit (&outsb));
RE (atf_process_stream_init_inherit (&errsb));
{
atf_process_child_t child;
atf_process_status_t status;
RE (atf_process_fork (&child, child_cookie, &outsb, &errsb, NULL));
RE (atf_process_child_wait (&child, &status));
ATF_CHECK (atf_process_status_exited (&status));
ATF_CHECK_EQ (atf_process_status_exitstatus (&status), exit_v_null);
atf_process_status_fini (&status);
}
{
atf_process_child_t child;
atf_process_status_t status;
int dummy_int;
RE (atf_process_fork (&child, child_cookie, &outsb, &errsb, &dummy_int));
RE (atf_process_child_wait (&child, &status));
ATF_CHECK (atf_process_status_exited (&status));
ATF_CHECK_EQ (atf_process_status_exitstatus (&status), exit_v_notnull);
atf_process_status_fini (&status);
}
atf_process_stream_fini (&errsb);
atf_process_stream_fini (&outsb);
}
impl::child::~child(void)
{
if (!m_waited) {
::kill(atf_process_child_pid(&m_child), SIGTERM);
atf_process_status_t s;
#if defined(__minix) && !defined(NDEBUG)
atf_error_t err =
#endif /* defined(__minix) && !defined(NDEBUG) */
atf_process_child_wait(&m_child, &s);
INV(!atf_is_error(err));
atf_process_status_fini(&s);
}
}
ATF_TC_BODY (status_coredump, tc)
{
struct rlimit rl;
rl.rlim_cur = RLIM_INFINITY;
rl.rlim_max = RLIM_INFINITY;
if (setrlimit (RLIMIT_CORE, &rl) == -1)
atf_tc_skip ("Cannot unlimit the core file size; check limits " "manually");
const int rawstatus = fork_and_wait_child (child_sigquit);
atf_process_status_t s;
RE (atf_process_status_init (&s, rawstatus));
ATF_CHECK (!atf_process_status_exited (&s));
ATF_CHECK (atf_process_status_signaled (&s));
ATF_CHECK_EQ (atf_process_status_termsig (&s), SIGQUIT);
ATF_CHECK (atf_process_status_coredump (&s));
atf_process_status_fini (&s);
}
ATF_TC_BODY (exec_list, tc)
{
atf_fs_path_t process_helpers;
atf_list_t argv;
atf_process_status_t status;
RE (atf_list_init (&argv));
get_process_helpers_path (tc, true, &process_helpers);
atf_list_append (&argv, strdup (atf_fs_path_cstring (&process_helpers)), true);
atf_list_append (&argv, strdup ("echo"), true);
atf_list_append (&argv, strdup ("test-message"), true);
{
atf_fs_path_t outpath;
atf_process_stream_t outsb;
RE (atf_fs_path_init_fmt (&outpath, "stdout"));
RE (atf_process_stream_init_redirect_path (&outsb, &outpath));
RE (atf_process_exec_list (&status, &process_helpers, &argv, &outsb, NULL));
atf_process_stream_fini (&outsb);
atf_fs_path_fini (&outpath);
}
atf_list_fini (&argv);
ATF_CHECK (atf_process_status_exited (&status));
ATF_CHECK_EQ (atf_process_status_exitstatus (&status), EXIT_SUCCESS);
{
int fd = open ("stdout", O_RDONLY);
ATF_CHECK (fd != -1);
check_line (fd, "test-message");
close (fd);
}
atf_process_status_fini (&status);
atf_fs_path_fini (&process_helpers);
}
static void do_fork (const struct base_stream *outfs, void *out, const struct base_stream *errfs, void *err)
{
atf_process_child_t child;
atf_process_status_t status;
struct child_print_data cpd = { "msg" };
outfs->init (out);
errfs->init (err);
RE (atf_process_fork (&child, child_print, outfs->m_sb_ptr, errfs->m_sb_ptr, &cpd));
if (outfs->process != NULL)
outfs->process (out, &child);
if (errfs->process != NULL)
errfs->process (err, &child);
RE (atf_process_child_wait (&child, &status));
outfs->fini (out);
errfs->fini (err);
atf_process_status_fini (&status);
}
ATF_TC_BODY (child_wait_eintr, tc)
{
atf_process_child_t child;
atf_process_status_t status;
{
atf_process_stream_t outsb, errsb;
RE (atf_process_stream_init_capture (&outsb));
RE (atf_process_stream_init_inherit (&errsb));
RE (atf_process_fork (&child, child_spawn_loop_and_wait_eintr, &outsb, &errsb, NULL));
atf_process_stream_fini (&outsb);
atf_process_stream_fini (&errsb);
}
{
/* Wait until the child process performs the wait call. This is
* racy, because the message we get from it is sent *before*
* doing the real system call... but I can't figure any other way
* to do this. */
char buf[16];
printf ("Waiting for child to issue wait(2)\n");
ATF_REQUIRE (read (atf_process_child_stdout (&child), buf, sizeof (buf)) > 0);
sleep (1);
}
printf ("Interrupting child's wait(2) call\n");
kill (atf_process_child_pid (&child), SIGHUP);
printf ("Waiting for child's completion\n");
RE (atf_process_child_wait (&child, &status));
ATF_REQUIRE (atf_process_status_exited (&status));
ATF_REQUIRE_EQ (atf_process_status_exitstatus (&status), EXIT_SUCCESS);
atf_process_status_fini (&status);
}
static void child_spawn_loop_and_wait_eintr (void *v)
{
atf_process_child_t child;
atf_process_status_t status;
struct sigaction sighup, old_sighup;
#define RE_ABORT(expr) \
do { \
atf_error_t _aux_err = expr; \
if (atf_is_error(_aux_err)) { \
atf_error_free(_aux_err); \
abort(); \
} \
} while (0)
{
atf_process_stream_t outsb, errsb;
RE_ABORT (atf_process_stream_init_capture (&outsb));
RE_ABORT (atf_process_stream_init_inherit (&errsb));
RE_ABORT (atf_process_fork (&child, child_loop, &outsb, &errsb, NULL));
atf_process_stream_fini (&outsb);
atf_process_stream_fini (&errsb);
}
sighup.sa_handler = nop_signal;
sigemptyset (&sighup.sa_mask);
sighup.sa_flags = 0;
if (sigaction (SIGHUP, &sighup, &old_sighup) == -1)
abort ();
printf ("waiting\n");
fflush (stdout);
fprintf (stderr, "Child entering wait(2)\n");
atf_error_t err = atf_process_child_wait (&child, &status);
fprintf (stderr, "Child's wait(2) terminated\n");
if (!atf_is_error (err))
{
fprintf (stderr, "wait completed successfully (not interrupted)\n");
abort ();
}
if (!atf_error_is (err, "libc"))
{
fprintf (stderr, "wait did not raise libc_error\n");
abort ();
}
if (atf_libc_error_code (err) != EINTR)
{
fprintf (stderr, "libc_error is not EINTR\n");
abort ();
}
atf_error_free (err);
sigaction (SIGHUP, &old_sighup, NULL);
fprintf (stderr, "Child is killing subchild\n");
kill (atf_process_child_pid (&child), SIGTERM);
RE_ABORT (atf_process_child_wait (&child, &status));
atf_process_status_fini (&status);
#undef RE_ABORT
exit (EXIT_SUCCESS);
}
impl::status::~status(void)
{
atf_process_status_fini(&m_status);
}
