test_subproc.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <cmocka.h>
#include <amxc/amxc_variant.h>
#include <amxc/amxc_lqueue.h>
#include <amxp/amxp_subproc.h>
#include <amxp/amxp_syssig.h>
#include <amxp/amxp_slot.h>
#include "test_subproc.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions
static void	slot_test_subproc_stop (UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
static void	handle_events (void)
void	test_subproc_new_delete (UNUSED void **state)
void	test_subproc_open_fd (UNUSED void **state)
void	test_subproc_vstart (UNUSED void **state)
void	test_subproc_astart (UNUSED void **state)
void	test_subproc_vstart_read_stdout (UNUSED void **state)
void	test_subproc_start_read_stdout (UNUSED void **state)
void	test_subproc_start_crashing_app (UNUSED void **state)
void	test_subproc_kill (UNUSED void **state)
void	test_subproc_wait (UNUSED void **state)
void	test_subproc_helper_functions (UNUSED void **state)

Variables
static bool	subproc_is_running = false

Function Documentation

handle_events()

static void handle_events ( void  )

static

Definition at line 84 of file test_subproc.c.

                                {
    printf("Handling events ");
    while(amxp_signal_read() == 0) {
        printf(".");
    }
    printf("\n");
}

slot_test_subproc_stop()

static void slot_test_subproc_stop ( UNUSED const char *const  sig_name, UNUSED const amxc_var_t *const  data, UNUSED void *const  priv  )

static

Definition at line 77 of file test_subproc.c.

                                                            {
    subproc_is_running = false;
}

test_subproc_astart()

void test_subproc_astart

(

UNUSED void **

state

)

Definition at line 171 of file test_subproc.c.

                                              {
    amxp_subproc_t* subproc = NULL;
    amxc_array_t cmd;
 
    amxc_array_init(&cmd, 2);
    amxc_array_append_data(&cmd, "ls");
    amxc_array_append_data(&cmd, "-la");
 
    assert_int_equal(amxp_subproc_new(&subproc), 0);
    assert_ptr_not_equal(subproc, NULL);
 
    amxp_slot_connect(amxp_subproc_get_sigmngr(subproc), "stop", NULL, slot_test_subproc_stop, NULL);
    assert_int_equal(amxp_subproc_astart(subproc, &cmd), 0);
    subproc_is_running = true;
    assert_true(amxp_subproc_is_running(subproc));
    assert_int_equal(amxp_subproc_astart(subproc, &cmd), -1);
 
    while(amxp_syssig_read() == -1) {
        printf("Waiting for sigchld");
        sleep(1);
    }
 
    handle_events();
 
    assert_false(subproc_is_running);
    assert_false(amxp_subproc_is_running(subproc));
 
    assert_int_equal(amxp_subproc_astart(NULL, NULL), -1);
    assert_int_equal(amxp_subproc_astart(subproc, NULL), -1);
 
    amxc_array_clean(&cmd, NULL);
    assert_int_equal(amxp_subproc_astart(subproc, &cmd), -1);
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_ptr_equal(subproc, NULL);
}

test_subproc_helper_functions()

void test_subproc_helper_functions

(

UNUSED void **

state

)

Definition at line 427 of file test_subproc.c.

                                                        {
    int result;
    int err;
    amxp_subproc_t* subproc = NULL;
    char* cmd_sleep_1[] = { "sleep", "2", NULL};
 
 
    result = amxp_subproc_ifexited(NULL);
    assert_int_equal(result, -1);
 
    result = amxp_subproc_ifsignaled(NULL);
    assert_int_equal(result, -1);
 
    result = amxp_subproc_get_exitstatus(NULL);
    assert_int_equal(result, -1);
 
    result = amxp_subproc_get_termsig(NULL);
    assert_int_equal(result, -1);
 
    assert_int_equal(amxp_subproc_new(&subproc), 0);
    assert_ptr_not_equal(subproc, NULL);
 
    err = amxp_subproc_vstart(subproc, cmd_sleep_1);
    assert_int_equal(err, 0);
    assert_true(amxp_subproc_is_running(subproc));
 
    err = amxp_subproc_wait(subproc, -1);
    assert_int_equal(err, 0);
    assert_false(amxp_subproc_is_running(subproc));
 
    result = amxp_subproc_ifexited(subproc);
    assert_int_equal(result, 1);
 
    result = amxp_subproc_get_exitstatus(subproc);
    assert_int_equal(result, 0);
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_int_equal(amxp_subproc_new(&subproc), 0);
 
    assert_int_equal(amxp_subproc_start(subproc, "test_app/a.out", "crash", NULL), 0);
    assert_true(amxp_subproc_is_running(subproc));
 
    err = amxp_subproc_wait(subproc, -1);
    assert_int_equal(err, 0);
    assert_false(amxp_subproc_is_running(subproc));
 
    result = amxp_subproc_ifexited(subproc);
    assert_int_equal(result, 0);
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_int_equal(amxp_subproc_new(&subproc), 0);
 
    assert_int_equal(amxp_subproc_start(subproc, "test_app/a.out", "wsignal", NULL), 0);
    assert_true(amxp_subproc_is_running(subproc));
 
    amxp_subproc_kill(subproc, SIGTERM);
 
    err = amxp_subproc_wait(subproc, -1);
    assert_int_equal(err, 0);
    assert_false(amxp_subproc_is_running(subproc));
 
    result = amxp_subproc_ifexited(subproc);
    assert_int_equal(result, 0);
 
    result = amxp_subproc_ifsignaled(subproc);
    assert_int_equal(result, 1);
 
    result = amxp_subproc_get_termsig(subproc);
    assert_int_equal(result, SIGTERM);
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_ptr_equal(subproc, NULL);
}

test_subproc_kill()

void test_subproc_kill

(

UNUSED void **

state

)

Definition at line 302 of file test_subproc.c.

                                            {
    amxp_subproc_t* subproc = NULL;
 
    assert_int_equal(amxp_subproc_new(&subproc), 0);
    assert_ptr_not_equal(subproc, NULL);
 
    amxp_slot_connect(amxp_subproc_get_sigmngr(subproc), "stop", NULL, slot_test_subproc_stop, NULL);
 
    assert_int_equal(amxp_subproc_start(subproc, "test_app/a.out", "wsignal", NULL), 0);
    subproc_is_running = true;
    assert_true(amxp_subproc_is_running(subproc));
 
    while(amxp_syssig_read() == -1) {
        amxp_subproc_kill(subproc, SIGTERM);
        sleep(1);
    }
 
    handle_events();
 
    assert_false(subproc_is_running);
    assert_false(amxp_subproc_is_running(subproc));
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_ptr_equal(subproc, NULL);
}

test_subproc_new_delete()

void test_subproc_new_delete

(

UNUSED void **

state

)

Definition at line 92 of file test_subproc.c.

                                                  {
    amxp_subproc_t* subproc = NULL;
 
    assert_int_not_equal(amxp_subproc_new(NULL), 0);
    assert_int_not_equal(amxp_subproc_delete(NULL), 0);
 
    assert_int_equal(amxp_subproc_new(&subproc), 0);
    assert_ptr_not_equal(subproc, NULL);
    assert_int_not_equal(amxp_subproc_new(&subproc), 0);
 
    assert_false(subproc->is_running);
    assert_false(amxp_subproc_is_running(subproc));
    assert_false(amxp_subproc_is_running(NULL));
    assert_int_equal(subproc->pid, 0);
    assert_int_equal(amxp_subproc_get_pid(subproc), 0);
    assert_int_equal(amxp_subproc_get_pid(NULL), -1);
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 2; j++) {
            assert_int_equal(subproc->fd[i][j], -1);
        }
    }
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_ptr_equal(subproc, NULL);
}

test_subproc_open_fd()

void test_subproc_open_fd

(

UNUSED void **

state

)

Definition at line 118 of file test_subproc.c.

                                               {
    amxp_subproc_t* subproc = NULL;
    int fd = -1;
 
    assert_int_equal(amxp_subproc_new(&subproc), 0);
    assert_ptr_not_equal(subproc, NULL);
 
    assert_int_equal(amxp_subproc_open_fd(NULL, STDIN_FILENO), -1);
 
    fd = amxp_subproc_open_fd(subproc, STDOUT_FILENO);
    assert_int_not_equal(fd, -1);
    assert_int_equal(amxp_subproc_open_fd(subproc, STDOUT_FILENO), fd);
    assert_int_not_equal(amxp_subproc_open_fd(subproc, STDERR_FILENO), -1);
    assert_int_not_equal(amxp_subproc_open_fd(subproc, STDIN_FILENO), -1);
    assert_int_equal(amxp_subproc_open_fd(subproc, 999), -1);
    assert_int_equal(amxp_subproc_open_fd(subproc, -1), -1);
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_ptr_equal(subproc, NULL);
}

test_subproc_start_crashing_app()

void test_subproc_start_crashing_app

(

UNUSED void **

state

)

Definition at line 277 of file test_subproc.c.

                                                          {
    amxp_subproc_t* subproc = NULL;
 
    assert_int_equal(amxp_subproc_new(&subproc), 0);
    assert_ptr_not_equal(subproc, NULL);
 
    amxp_slot_connect(amxp_subproc_get_sigmngr(subproc), "stop", NULL, slot_test_subproc_stop, NULL);
 
    assert_int_equal(amxp_subproc_start(subproc, "test_app/a.out", "crash", NULL), 0);
    subproc_is_running = true;
    assert_true(amxp_subproc_is_running(subproc));
 
    while(amxp_syssig_read() == -1) {
        sleep(1);
    }
 
    handle_events();
 
    assert_false(subproc_is_running);
    assert_false(amxp_subproc_is_running(subproc));
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_ptr_equal(subproc, NULL);
}

test_subproc_start_read_stdout()

void test_subproc_start_read_stdout

(

UNUSED void **

state

)

Definition at line 242 of file test_subproc.c.

                                                         {
    amxp_subproc_t* subproc = NULL;
    char buffer[1024] = "";
    int fd = -1;
 
    assert_int_equal(amxp_subproc_new(&subproc), 0);
    assert_ptr_not_equal(subproc, NULL);
 
    fd = amxp_subproc_open_fd(subproc, STDOUT_FILENO);
    assert_int_not_equal(fd, -1);
    amxp_slot_connect(amxp_subproc_get_sigmngr(subproc), "stop", NULL, slot_test_subproc_stop, NULL);
 
    assert_ptr_equal(amxp_subproc_find(subproc->pid - 1), NULL);
 
    for(int i = 0; i < 2; i++) {
        assert_int_equal(amxp_subproc_start(subproc, "ls", "-la", NULL), 0);
        subproc_is_running = true;
        assert_true(amxp_subproc_is_running(subproc));
 
        while(amxp_syssig_read() == -1) {
            while(read(fd, buffer, 1023) > 0) {
                printf("%s", buffer);
            }
        }
 
        handle_events();
 
        assert_false(subproc_is_running);
        assert_false(amxp_subproc_is_running(subproc));
    }
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_ptr_equal(subproc, NULL);
}

test_subproc_vstart()

void test_subproc_vstart

(

UNUSED void **

state

)

Definition at line 139 of file test_subproc.c.

                                              {
    amxp_subproc_t* subproc = NULL;
    char* cmd[] = { "ls", "-la", NULL };
    char* cmd2[] = { NULL };
 
    assert_int_equal(amxp_subproc_new(&subproc), 0);
    assert_ptr_not_equal(subproc, NULL);
 
    amxp_slot_connect(amxp_subproc_get_sigmngr(subproc), "stop", NULL, slot_test_subproc_stop, NULL);
    assert_int_equal(amxp_subproc_vstart(subproc, cmd), 0);
    subproc_is_running = true;
    assert_true(amxp_subproc_is_running(subproc));
    assert_int_equal(amxp_subproc_vstart(subproc, cmd), -1);
 
    while(amxp_syssig_read() == -1) {
        printf("Waiting for sigchld");
        sleep(1);
    }
 
    handle_events();
 
    assert_false(subproc_is_running);
    assert_false(amxp_subproc_is_running(subproc));
 
    assert_int_equal(amxp_subproc_vstart(NULL, NULL), -1);
    assert_int_equal(amxp_subproc_vstart(subproc, NULL), -1);
    assert_int_equal(amxp_subproc_vstart(subproc, cmd2), -1);
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_ptr_equal(subproc, NULL);
}

test_subproc_vstart_read_stdout()

void test_subproc_vstart_read_stdout

(

UNUSED void **

state

)

Definition at line 208 of file test_subproc.c.

                                                          {
    amxp_subproc_t* subproc = NULL;
    char buffer[1024] = "";
    int fd = -1;
    char* cmd[] = { "ls", "-la", NULL };
 
    assert_int_equal(amxp_subproc_new(&subproc), 0);
    assert_ptr_not_equal(subproc, NULL);
 
    fd = amxp_subproc_open_fd(subproc, STDOUT_FILENO);
    assert_int_not_equal(fd, -1);
    amxp_slot_connect(amxp_subproc_get_sigmngr(subproc), "stop", NULL, slot_test_subproc_stop, NULL);
 
    for(int i = 0; i < 2; i++) {
        assert_int_equal(amxp_subproc_vstart(subproc, cmd), 0);
        subproc_is_running = true;
        assert_true(amxp_subproc_is_running(subproc));
 
        while(amxp_syssig_read() == -1) {
            while(read(fd, buffer, 1023) > 0) {
                printf("%s", buffer);
            }
        }
 
        handle_events();
 
        assert_false(subproc_is_running);
        assert_false(amxp_subproc_is_running(subproc));
    }
 
    assert_int_equal(amxp_subproc_delete(&subproc), 0);
    assert_ptr_equal(subproc, NULL);
}

test_subproc_wait()

void test_subproc_wait

(

UNUSED void **

state

)

Definition at line 328 of file test_subproc.c.

                                            {
    int err;
 
    amxp_subproc_t* subproc_sleep_10 = NULL;
    char* cmd_sleep_10[] = { "sleep", "10", NULL};
 
    amxp_subproc_t* subproc_sleep_2 = NULL;
    char* cmd_sleep_2[] = { "sleep", "2", NULL};
 
    assert_int_equal(amxp_subproc_new(&subproc_sleep_10), 0);
    assert_ptr_not_equal(subproc_sleep_10, NULL);
 
    assert_int_equal(amxp_subproc_new(&subproc_sleep_2), 0);
    assert_ptr_not_equal(subproc_sleep_2, NULL);
 
    // Test general behaviour (-1 --> no timeout)
    err = amxp_subproc_vstart_wait(subproc_sleep_2, -1, cmd_sleep_2);
    assert_int_equal(err, 0);
    assert_false(amxp_subproc_is_running(subproc_sleep_2));
 
    // Test timeout (500ms)
    err = amxp_subproc_vstart_wait(subproc_sleep_2, 500, cmd_sleep_2);
    assert_int_equal(err, 1);
    assert_true(amxp_subproc_is_running(subproc_sleep_2));
 
    // wait for (sleep 2) child to finish
    err = amxp_subproc_wait(subproc_sleep_2, -1);
    assert_int_equal(err, 0);
    assert_false(amxp_subproc_is_running(subproc_sleep_2));
 
    // test for case of short running async child and long running sync child
    // --> short running child
    err = amxp_subproc_vstart(subproc_sleep_2, cmd_sleep_2);
    assert_int_equal(err, 0);
    assert_true(amxp_subproc_is_running(subproc_sleep_2));
 
    // --> long running child (no timeout)
    err = amxp_subproc_vstart_wait(subproc_sleep_10, -1, cmd_sleep_10);
    assert_int_equal(err, 0);
    assert_false(amxp_subproc_is_running(subproc_sleep_2));
    assert_false(amxp_subproc_is_running(subproc_sleep_10));
 
    // test for case of short running async child and long running sync child
    // --> short running child
    err = amxp_subproc_vstart(subproc_sleep_2, cmd_sleep_2);
    assert_int_equal(err, 0);
    assert_true(amxp_subproc_is_running(subproc_sleep_2));
 
    // --> long running child (with timeout but will finish normally)
    err = amxp_subproc_vstart_wait(subproc_sleep_10, 15000, cmd_sleep_10);
    assert_int_equal(err, 0);
    assert_false(amxp_subproc_is_running(subproc_sleep_2));
    assert_false(amxp_subproc_is_running(subproc_sleep_10));
 
    // test for case of short running async child and long running sync child
    // --> short running child
    err = amxp_subproc_vstart(subproc_sleep_2, cmd_sleep_2);
    assert_int_equal(err, 0);
    assert_true(amxp_subproc_is_running(subproc_sleep_2));
 
    // --> long running child (with timeout)
    err = amxp_subproc_vstart_wait(subproc_sleep_10, 7500, cmd_sleep_10);
    assert_int_equal(err, 1);
    assert_false(amxp_subproc_is_running(subproc_sleep_2));
    assert_true(amxp_subproc_is_running(subproc_sleep_10));
 
    // wait for (sleep 10) child to finish
    err = amxp_subproc_wait(subproc_sleep_10, -1);
    assert_int_equal(err, 0);
    assert_false(amxp_subproc_is_running(subproc_sleep_2));
 
    // argument checking
    err = amxp_subproc_vstart_wait(NULL, 4000, cmd_sleep_2);
    assert_int_not_equal(err, 0);
 
    err = amxp_subproc_vstart_wait(subproc_sleep_2, 4000, NULL);
    assert_int_not_equal(err, 0);
 
    // amxp_subproc_start_wait
    err = amxp_subproc_start_wait(subproc_sleep_2, 4000, "sleep", "1", NULL);
    assert_int_equal(err, 0);
    assert_false(amxp_subproc_is_running(subproc_sleep_2));
 
    // argument checking
    err = amxp_subproc_start_wait(NULL, 4000, "sleep", "1", NULL);
    assert_int_not_equal(err, 0);
 
    // argument checking -- unfortunately doesnt detect non existing commands
    err = amxp_subproc_start_wait(subproc_sleep_2, 4000, "non_existing_command", "1", NULL);
    assert_int_equal(err, 0);
 
    // cleanup test
    assert_int_equal(amxp_subproc_delete(&subproc_sleep_10), 0);
    assert_ptr_equal(subproc_sleep_10, NULL);
 
    assert_int_equal(amxp_subproc_delete(&subproc_sleep_2), 0);
    assert_ptr_equal(subproc_sleep_2, NULL);
}

Variable Documentation

subproc_is_running

bool subproc_is_running = false

static

Definition at line 75 of file test_subproc.c.