git.ozlabs.org Git - ccan/blob - ccan/err/test/run.c

   1 #include <ccan/err/err.c>
   2 #include <ccan/tap/tap.h>
   3 #include <unistd.h>
   4 #include <string.h>
   5 #include <errno.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <sys/types.h>
   9 #include <sys/wait.h>
  10
  11 #define BUFFER_MAX 1024
  12
  13 int main(int argc, char *argv[])
  14 {
  15         int pfd[2];
  16         const char *base;
  17
  18         (void)argc;
  19         plan_tests(24);
  20
  21         err_set_progname(argv[0]);
  22
  23         /* In case it only prints out the basename of argv[0]. */
  24         base = strrchr(argv[0], '/');
  25         if (base)
  26                 base++;
  27         else
  28                 base = argv[0];
  29
  30         /* Test err() in child */
  31         if (pipe(pfd))
  32                 abort();
  33         fflush(stdout);
  34         if (fork()) {
  35                 char buffer[BUFFER_MAX+1];
  36                 unsigned int i;
  37                 int status;
  38
  39                 /* We are parent. */
  40                 close(pfd[1]);
  41                 for (i = 0; i < BUFFER_MAX; i++) {
  42                         if (read(pfd[0], buffer + i, 1) == 0) {
  43                                 buffer[i] = '\0';
  44                                 ok1(strstr(buffer, "running err:"));
  45                                 ok1(strstr(buffer, strerror(ENOENT)));
  46                                 ok1(strstr(buffer, base));
  47                                 ok1(buffer[i-1] == '\n');
  48                                 break;
  49                         }
  50                 }
  51                 close(pfd[0]);
  52                 ok1(wait(&status) != -1);
  53                 ok1(WIFEXITED(status));
  54                 ok1(WEXITSTATUS(status) == 17);
  55         } else {
  56                 close(pfd[0]);
  57                 dup2(pfd[1], STDERR_FILENO);
  58                 errno = ENOENT;
  59                 err(17, "running %s", "err");
  60                 abort();
  61         }
  62
  63         /* Test errx() in child */
  64         if (pipe(pfd))
  65                 abort();
  66         fflush(stdout);
  67         if (fork()) {
  68                 char buffer[BUFFER_MAX+1];
  69                 unsigned int i;
  70                 int status;
  71
  72                 /* We are parent. */
  73                 close(pfd[1]);
  74                 for (i = 0; i < BUFFER_MAX; i++) {
  75                         if (read(pfd[0], buffer + i, 1) == 0) {
  76                                 buffer[i] = '\0';
  77                                 ok1(strstr(buffer, "running errx\n"));
  78                                 ok1(strstr(buffer, base));
  79                                 break;
  80                         }
  81                 }
  82                 close(pfd[0]);
  83                 ok1(wait(&status) != -1);
  84                 ok1(WIFEXITED(status));
  85                 ok1(WEXITSTATUS(status) == 17);
  86         } else {
  87                 close(pfd[0]);
  88                 dup2(pfd[1], STDERR_FILENO);
  89                 errx(17, "running %s", "errx");
  90                 abort();
  91         }
  92
  93
  94         /* Test warn() in child */
  95         if (pipe(pfd))
  96                 abort();
  97         fflush(stdout);
  98         if (fork()) {
  99                 char buffer[BUFFER_MAX+1];
 100                 unsigned int i;
 101                 int status;
 102
 103                 /* We are parent. */
 104                 close(pfd[1]);
 105                 for (i = 0; i < BUFFER_MAX; i++) {
 106                         if (read(pfd[0], buffer + i, 1) == 0) {
 107                                 buffer[i] = '\0';
 108                                 ok1(strstr(buffer, "running warn:"));
 109                                 ok1(strstr(buffer, strerror(ENOENT)));
 110                                 ok1(strstr(buffer, base));
 111                                 ok1(buffer[i-1] == '\n');
 112                                 break;
 113                         }
 114                 }
 115                 close(pfd[0]);
 116                 ok1(wait(&status) != -1);
 117                 ok1(WIFEXITED(status));
 118                 ok1(WEXITSTATUS(status) == 17);
 119         } else {
 120                 close(pfd[0]);
 121                 dup2(pfd[1], STDERR_FILENO);
 122                 errno = ENOENT;
 123                 warn("running %s", "warn");
 124                 exit(17);
 125         }
 126
 127         /* Test warnx() in child */
 128         if (pipe(pfd))
 129                 abort();
 130         fflush(stdout);
 131         if (fork()) {
 132                 char buffer[BUFFER_MAX+1];
 133                 unsigned int i;
 134                 int status;
 135
 136                 /* We are parent. */
 137                 close(pfd[1]);
 138                 for (i = 0; i < BUFFER_MAX; i++) {
 139                         if (read(pfd[0], buffer + i, 1) == 0) {
 140                                 buffer[i] = '\0';
 141                                 ok1(strstr(buffer, "running warnx\n"));
 142                                 ok1(strstr(buffer, base));
 143                                 break;
 144                         }
 145                 }
 146                 close(pfd[0]);
 147                 ok1(wait(&status) != -1);
 148                 ok1(WIFEXITED(status));
 149                 ok1(WEXITSTATUS(status) == 17);
 150         } else {
 151                 close(pfd[0]);
 152                 dup2(pfd[1], STDERR_FILENO);
 153                 warnx("running %s", "warnx");
 154                 exit(17);
 155         }
 156         return exit_status();
 157 }
 158