Beispiel #1
0
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);
    }
}
Beispiel #2
0
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);
    }
}
Beispiel #3
0
/* 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);
}
Beispiel #4
0
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);
}
Beispiel #5
0
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);
}
Beispiel #6
0
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);
}
Beispiel #7
0
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);
    }
}
Beispiel #8
0
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);
}
Beispiel #9
0
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);
    }
}
Beispiel #10
0
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);
}
Beispiel #11
0
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);
}
Beispiel #12
0
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);
}
Beispiel #13
0
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);
}
Beispiel #14
0
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);
}
Beispiel #15
0
impl::status::~status(void)
{
    atf_process_status_fini(&m_status);
}