begriffs open source - libtap/blob - tap.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdarg.h>
   4 #include <string.h>
   5 #include "tap.h"
   6 \r
   7 static int expected_tests = NO_PLAN;\r
   8 static int failed_tests;\r
   9 static int current_test;
  10 static char *todo_mesg = NULL;\r
  11
  12 void plan (int tests) {\r
  13     expected_tests = tests;\r
  14     if (tests != NO_PLAN)\r
  15         printf("1..%d\n", tests);\r
  16 }
  17
  18 static char *vstrdupf (const char *fmt, va_list args) {
  19     char *str;
  20     int size = vsnprintf(NULL, 0, fmt, args) + 1;
  21     str = malloc(size);
  22     vsprintf(str, fmt, args);
  23     return str;
  24 }
  25
  26 static int vok_at_loc (const char *file,
  27                        int         line,
  28                        int         test,
  29                        const char *fmt,
  30                        va_list     args)
  31 {
  32     char *name = vstrdupf(fmt, args);
  33     printf("%sok %d", test ? "" : "not ", ++current_test);
  34     if (*name)
  35         printf(" - %s", name);
  36     if (todo_mesg) {
  37         printf(" # TODO");
  38         if (*todo_mesg)
  39             printf(" %s", todo_mesg);
  40     }
  41     printf("\n");\r
  42     if (!test) {
  43         if (*name)\r
  44             diag("  Failed%s test '%s'\n  at %s line %d.",
  45                 todo_mesg ? " (TODO)" : "", name, file, line);\r
  46         else\r
  47             diag("  Failed%s test at %s line %d.",
  48                 todo_mesg ? " (TODO)" : "", file, line);
  49         if (!todo_mesg)\r
  50             failed_tests++;\r
  51     }\r
  52     free(name);
  53     return test;
  54 }
  55 \r
  56 int ok_at_loc (const char *file, int line, int test, const char *fmt, ...) {
  57     va_list args;
  58     va_start(args, fmt);
  59     vok_at_loc(file, line, test, fmt, args);
  60     va_end(args);
  61     return test;\r
  62 }\r
  63
  64 static int mystrcmp (const char *a, const char *b) {
  65     return a == b ? 0 : !a ? -1 : !b ? 1 : strcmp(a, b);
  66 }
  67
  68 int is_at_loc (const char *file,
  69                int         line,
  70                const char *got,
  71                const char *expected,
  72                const char *fmt,
  73                ...)
  74 {
  75     int test = !mystrcmp(got, expected);
  76     va_list args;
  77     va_start(args, fmt);
  78     vok_at_loc(file, line, test, fmt, args);
  79     va_end(args);
  80     if (!test) {
  81         diag("         got: '%s'", got);
  82         diag("    expected: '%s'", expected);
  83     }
  84     return test;
  85 }
  86
  87 int isnt_at_loc (const char *file,
  88                  int         line,
  89                  const char *got,
  90                  const char *expected,
  91                  const char *fmt,
  92                  ...)
  93 {
  94     int test = mystrcmp(got, expected);
  95     va_list args;
  96     va_start(args, fmt);
  97     vok_at_loc(file, line, test, fmt, args);
  98     va_end(args);
  99     if (!test) {
 100         diag("         got: '%s'", got);
 101         diag("    expected: anything else");
 102     }
 103     return test;
 104 }
 105 \r
 106 static void vdiag_to_fh (FILE *fh, const char *fmt, va_list args) {\r
 107     char *mesg, *line;
 108     int i;\r
 109     if (!fmt)
 110         return;\r
 111     mesg = vstrdupf(fmt, args);\r
 112     line = mesg;\r
 113     for (i = 0; *line; i++) {\r
 114         char c = mesg[i];\r
 115         if (!c || c == '\n') {\r
 116             mesg[i] = '\0';\r
 117             fprintf(fh, "# %s\n", line);\r
 118             if (!c) break;\r
 119             mesg[i] = c;\r
 120             line = &mesg[i+1];\r
 121         }\r
 122     }\r
 123     free(mesg);
 124     return;\r
 125 }\r
 126
 127 int diag (const char *fmt, ...) {
 128     va_list args;
 129     va_start(args, fmt);
 130     vdiag_to_fh(stderr, fmt, args);
 131     va_end(args);
 132     return 1;
 133 }
 134
 135 int note (const char *fmt, ...) {
 136     va_list args;
 137     va_start(args, fmt);
 138     vdiag_to_fh(stdout, fmt, args);
 139     va_end(args);
 140     return 1;
 141 }
 142 \r
 143 int exit_status () {\r
 144     int retval = EXIT_SUCCESS;\r
 145     if (expected_tests == NO_PLAN) {\r
 146         printf("1..%d\n", current_test);\r
 147     }\r
 148     else if (current_test != expected_tests) {\r
 149         diag("Looks like you planned %d test%s but ran %d.",\r
 150             expected_tests, expected_tests > 1 ? "s" : "", current_test);\r
 151         retval = EXIT_FAILURE;\r
 152     }\r
 153     if (failed_tests) {\r
 154         diag("Looks like you failed %d test%s of %d run.",\r
 155             failed_tests, failed_tests > 1 ? "s" : "", current_test);\r
 156         retval = EXIT_FAILURE;\r
 157     }\r
 158     return retval;\r
 159 }
 160
 161 void skippy (int n, const char *fmt, ...) {
 162     char *why;
 163     va_list args;
 164     va_start(args, fmt);
 165     why = vstrdupf(fmt, args);
 166     va_end(args);
 167     while (n --> 0) {
 168         printf("ok %d ", ++current_test);
 169         note("skip %s\n", why);
 170     }
 171     free(why);
 172 }
 173
 174 void ctodo (int ignore, const char *fmt, ...) {
 175     va_list args;
 176     va_start(args, fmt);
 177     todo_mesg = vstrdupf(fmt, args);
 178     va_end(args);
 179 }
 180
 181 void cendtodo () {
 182     free(todo_mesg);
 183     todo_mesg = NULL;
 184 }
 185
 186 #ifndef _WIN32
 187 #   include <sys/mman.h>
 188     /* Create a shared memory int to keep track of whether a piece of code
 189     executed dies. to be used in the dies_ok and lives_ok macros  */
 190     int tap_test_died (int status) {
 191         static int *test_died = NULL;
 192         int prev;
 193         if (!test_died) {
 194             test_died = mmap(0, sizeof (int), PROT_READ | PROT_WRITE,
 195                              MAP_SHARED | MAP_ANONYMOUS, -1, 0);
 196             *test_died = 0;
 197         }
 198         prev = *test_died;
 199         *test_died = status;
 200         return prev;
 201     }
 202 #endif
 203