tests/test_process.c

   1 #include <sys/types.h>
   2 #include <sys/wait.h>
   3 #include <fcntl.h>
   4 #include <unistd.h>
   5 #include <signal.h>
   6 #include <errno.h>
   7 #include <limits.h>
   8
   9 #include <CUnit/CUnit.h>
  10
  11 #include "process.h"
  12
  13 #include "test_process.h"
  14
  15 void test_wait_for_death(void)
  16 {
  17   pid_t pid = fork();
  18
  19   if (pid == 0) {
  20     usleep(20000);
  21     execl("/bin/true", "/bin/true", NULL);
  22     _exit(1);
  23   }
  24
  25   CU_ASSERT(!wait_for_death(pid, 0, 2000));
  26   CU_ASSERT(wait_for_death(pid, 0, 20000));
  27 }
  28
  29 void test_ensure_death(void)
  30 {
  31   pid_t pid = fork();
  32
  33   if (pid == 0) {
  34     signal(SIGTERM, SIG_IGN);
  35     signal(SIGHUP, SIG_IGN);
  36     execl("/bin/true", "/bin/true", NULL);
  37     _exit(0);
  38   }
  39
  40   ensure_death(pid);
  41
  42   CU_ASSERT(waitpid(pid, NULL, WNOHANG) < 0);
  43   CU_ASSERT(errno == ECHILD);
  44 }
  45
  46 int child_function(void *a)
  47 {
  48   char *s = a;
  49   ssize_t l = strlen(s);
  50   char buffer[LINE_MAX];
  51   ssize_t l_in;
  52   ssize_t l_out;
  53
  54   if (write(STDOUT_FILENO, s, l) < l)
  55     return 1;
  56
  57   l_in = read(STDIN_FILENO, buffer, sizeof buffer);
  58
  59   if (l_in <= 0)
  60     return 1;
  61
  62   l_out = write(STDOUT_FILENO, buffer, l_in);
  63
  64   if (l_out != l_in)
  65     return 1;
  66
  67   return 0;
  68 }
  69
  70 void test_create_child_function(void)
  71 {
  72   char *s1 = "hello";
  73   char *s2 = "world";
  74   ssize_t l1 = strlen(s1);
  75   ssize_t l2 = strlen(s2);
  76   struct child_process child = {
  77     .function = child_function,
  78     .argument = s1,
  79     .stdin_fd = REDIRECT_PIPE,
  80     .stdout_fd = REDIRECT_PIPE,
  81     .stderr_fd = REDIRECT_DEV_NULL,
  82   };
  83   int status;
  84   char buffer[LINE_MAX];
  85
  86   CU_ASSERT(create_child(&child));
  87
  88   CU_ASSERT(child.pid > 0);
  89
  90   CU_ASSERT(read(child.stdout_fd, buffer, sizeof buffer) == l1);
  91   CU_ASSERT(strncmp(buffer, s1, l1) == 0);
  92
  93   CU_ASSERT(waitpid(child.pid, NULL, WNOHANG) == 0);
  94
  95   CU_ASSERT(write(child.stdin_fd, s2, l2) == l2);
  96   CU_ASSERT(read(child.stdout_fd, buffer, sizeof buffer) == l2);
  97
  98   CU_ASSERT(strncmp(buffer, s2, l2) == 0);
  99
 100   CU_ASSERT(waitpid(child.pid, &status, 0) == child.pid);
 101
 102   CU_ASSERT(WIFEXITED(status));
 103   CU_ASSERT(WEXITSTATUS(status) == 0);
 104
 105   (void) close(child.stdin_fd);
 106   (void) close(child.stdout_fd);
 107 }
 108
 109 void test_create_child_process(void)
 110 {
 111   const char *s1 = "hello\n";
 112   const char *s2 = "olleh\n";
 113   ssize_t l1 = strlen(s1);
 114   ssize_t l2 = strlen(s2);
 115   const char *argv[] = { "sh", "-c", "rev", NULL };
 116   struct child_process child = {
 117     .path = "/bin/sh",
 118     .argv = argv,
 119     .stdin_fd = REDIRECT_PIPE,
 120     .stdout_fd = REDIRECT_PIPE,
 121     .stderr_fd = REDIRECT_DEV_NULL,
 122     .function = NULL,
 123   };
 124   char buffer[LINE_MAX];
 125
 126   CU_ASSERT(create_child(&child));
 127
 128   CU_ASSERT(write(child.stdin_fd, s1, l1) == l1);
 129   (void) close(child.stdin_fd);
 130
 131   CU_ASSERT(read(child.stdout_fd, buffer, sizeof buffer) == l2);
 132   (void) close(child.stdout_fd);
 133
 134   CU_ASSERT(strncmp(buffer, s2, l2) == 0);
 135
 136   CU_ASSERT(wait_for_death(child.pid, 0, 0));
 137 }
 138
 139 CU_TestInfo process_tests[] = {
 140   { "test_wait_for_death", test_wait_for_death },
 141   { "test_ensure_death", test_ensure_death },
 142   { "test_create_child_function", test_create_child_function },
 143   { "test_create_child_process", test_create_child_process },
 144   CU_TEST_INFO_NULL,
 145 };