pd.if.org Git - nbds/blob - test/CuTest.c

   1 #include <assert.h>
   2 #include <setjmp.h>
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <math.h>
   7
   8 #include "CuTest.h"
   9
  10 /*-------------------------------------------------------------------------*
  11  * CuStr
  12  *-------------------------------------------------------------------------*/
  13
  14 char* CuStrAlloc(int size)
  15 {
  16         char* newStr = (char*) malloc( sizeof(char) * (size) );
  17         return newStr;
  18 }
  19
  20 char* CuStrCopy(const char* old)
  21 {
  22         int len = strlen(old);
  23         char* newStr = CuStrAlloc(len + 1);
  24         strcpy(newStr, old);
  25         return newStr;
  26 }
  27
  28 /*-------------------------------------------------------------------------*
  29  * CuString
  30  *-------------------------------------------------------------------------*/
  31
  32 void CuStringInit(CuString* str)
  33 {
  34         str->length = 0;
  35         str->size = STRING_MAX;
  36         str->buffer = (char*) malloc(sizeof(char) * str->size);
  37         str->buffer[0] = '\0';
  38 }
  39
  40 CuString* CuStringNew(void)
  41 {
  42         CuString* str = (CuString*) malloc(sizeof(CuString));
  43         str->length = 0;
  44         str->size = STRING_MAX;
  45         str->buffer = (char*) malloc(sizeof(char) * str->size);
  46         str->buffer[0] = '\0';
  47         return str;
  48 }
  49
  50 void CuStringResize(CuString* str, int newSize)
  51 {
  52         str->buffer = (char*) realloc(str->buffer, sizeof(char) * newSize);
  53         str->size = newSize;
  54 }
  55
  56 void CuStringAppend(CuString* str, const char* text)
  57 {
  58         int length;
  59
  60         if (text == NULL) {
  61                 text = "NULL";
  62         }
  63
  64         length = strlen(text);
  65         if (str->length + length + 1 >= str->size)
  66                 CuStringResize(str, str->length + length + 1 + STRING_INC);
  67         str->length += length;
  68         strcat(str->buffer, text);
  69 }
  70
  71 void CuStringAppendChar(CuString* str, char ch)
  72 {
  73         char text[2];
  74         text[0] = ch;
  75         text[1] = '\0';
  76         CuStringAppend(str, text);
  77 }
  78
  79 void CuStringAppendFormat(CuString* str, const char* format, ...)
  80 {
  81         va_list argp;
  82         char buf[HUGE_STRING_LEN];
  83         va_start(argp, format);
  84         vsprintf(buf, format, argp);
  85         va_end(argp);
  86         CuStringAppend(str, buf);
  87 }
  88
  89 void CuStringInsert(CuString* str, const char* text, int pos)
  90 {
  91         int length = strlen(text);
  92         if (pos > str->length)
  93                 pos = str->length;
  94         if (str->length + length + 1 >= str->size)
  95                 CuStringResize(str, str->length + length + 1 + STRING_INC);
  96         memmove(str->buffer + pos + length, str->buffer + pos, (str->length - pos) + 1);
  97         str->length += length;
  98         memcpy(str->buffer + pos, text, length);
  99 }
 100
 101 /*-------------------------------------------------------------------------*
 102  * CuTest
 103  *-------------------------------------------------------------------------*/
 104
 105 void CuTestInit(CuTest* t, const char* name, TestFunction function)
 106 {
 107         t->name = CuStrCopy(name);
 108         t->failed = 0;
 109         t->ran = 0;
 110         t->message = NULL;
 111         t->function = function;
 112         t->jumpBuf = NULL;
 113 }
 114
 115 CuTest* CuTestNew(const char* name, TestFunction function)
 116 {
 117         CuTest* tc = CU_ALLOC(CuTest);
 118         CuTestInit(tc, name, function);
 119         return tc;
 120 }
 121
 122 void CuTestRun(CuTest* tc)
 123 {
 124         jmp_buf buf;
 125         tc->jumpBuf = &buf;
 126         if (setjmp(buf) == 0)
 127         {
 128                 tc->ran = 1;
 129                 (tc->function)(tc);
 130         }
 131         tc->jumpBuf = 0;
 132 }
 133
 134 static void CuFailInternal(CuTest* tc, const char* file, int line, CuString* string)
 135 {
 136         char buf[HUGE_STRING_LEN];
 137
 138         sprintf(buf, "%s:%d: ", file, line);
 139         CuStringInsert(string, buf, 0);
 140
 141         tc->failed = 1;
 142         tc->message = string->buffer;
 143 #ifdef ENABLE_TRACE
 144     extern void lwt_dump(const char *);
 145     lwt_dump(tc->name);
 146 #endif
 147         if (tc->jumpBuf != 0) longjmp(*(tc->jumpBuf), 0);
 148 }
 149
 150 void CuFail_Line(CuTest* tc, const char* file, int line, const char* message2, const char* message)
 151 {
 152         CuString string;
 153
 154         CuStringInit(&string);
 155         if (message2 != NULL)
 156         {
 157                 CuStringAppend(&string, message2);
 158                 CuStringAppend(&string, ": ");
 159         }
 160         CuStringAppend(&string, message);
 161         CuFailInternal(tc, file, line, &string);
 162 }
 163
 164 void CuAssert_Line(CuTest* tc, const char* file, int line, const char* message, int condition)
 165 {
 166         if (condition) return;
 167         CuFail_Line(tc, file, line, NULL, message);
 168 }
 169
 170 void CuAssertStrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
 171         const char* expected, const char* actual)
 172 {
 173         CuString string;
 174         if ((expected == NULL && actual == NULL) ||
 175             (expected != NULL && actual != NULL &&
 176              strcmp(expected, actual) == 0))
 177         {
 178                 return;
 179         }
 180
 181         CuStringInit(&string);
 182         if (message != NULL)
 183         {
 184                 CuStringAppend(&string, message);
 185                 CuStringAppend(&string, ": ");
 186         }
 187         CuStringAppend(&string, "expected <");
 188         CuStringAppend(&string, expected);
 189         CuStringAppend(&string, "> but was <");
 190         CuStringAppend(&string, actual);
 191         CuStringAppend(&string, ">");
 192         CuFailInternal(tc, file, line, &string);
 193 }
 194
 195 void CuAssertIntEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
 196         int expected, int actual)
 197 {
 198         char buf[STRING_MAX];
 199         if (expected == actual) return;
 200         sprintf(buf, "expected <%d> but was <%d>", expected, actual);
 201         CuFail_Line(tc, file, line, message, buf);
 202 }
 203
 204 void CuAssertDblEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
 205         double expected, double actual, double delta)
 206 {
 207         char buf[STRING_MAX];
 208         if (fabs(expected - actual) <= delta) return;
 209         sprintf(buf, "expected <%lf> but was <%lf>", expected, actual);
 210         CuFail_Line(tc, file, line, message, buf);
 211 }
 212
 213 void CuAssertPtrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
 214         void* expected, void* actual)
 215 {
 216         char buf[STRING_MAX];
 217         if (expected == actual) return;
 218         sprintf(buf, "expected pointer <0x%p> but was <0x%p>", expected, actual);
 219         CuFail_Line(tc, file, line, message, buf);
 220 }
 221
 222
 223 /*-------------------------------------------------------------------------*
 224  * CuSuite
 225  *-------------------------------------------------------------------------*/
 226
 227 void CuSuiteInit(CuSuite* testSuite)
 228 {
 229         testSuite->count = 0;
 230         testSuite->failCount = 0;
 231 }
 232
 233 CuSuite* CuSuiteNew(void)
 234 {
 235         CuSuite* testSuite = CU_ALLOC(CuSuite);
 236         CuSuiteInit(testSuite);
 237         return testSuite;
 238 }
 239
 240 void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase)
 241 {
 242         assert(testSuite->count < MAX_TEST_CASES);
 243         testSuite->list[testSuite->count] = testCase;
 244         testSuite->count++;
 245 }
 246
 247 void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2)
 248 {
 249         int i;
 250         for (i = 0 ; i < testSuite2->count ; ++i)
 251         {
 252                 CuTest* testCase = testSuite2->list[i];
 253                 CuSuiteAdd(testSuite, testCase);
 254         }
 255 }
 256
 257 void CuSuiteRun(CuSuite* testSuite)
 258 {
 259         int i;
 260         for (i = 0 ; i < testSuite->count ; ++i)
 261         {
 262                 CuTest* testCase = testSuite->list[i];
 263                 CuTestRun(testCase);
 264                 if (testCase->failed) { testSuite->failCount += 1; }
 265         }
 266 }
 267
 268 void CuSuiteSummary(CuSuite* testSuite, CuString* summary)
 269 {
 270         int i;
 271         for (i = 0 ; i < testSuite->count ; ++i)
 272         {
 273                 CuTest* testCase = testSuite->list[i];
 274                 CuStringAppend(summary, testCase->failed ? "F" : ".");
 275         }
 276         CuStringAppend(summary, "\n\n");
 277 }
 278
 279 void CuSuiteDetails(CuSuite* testSuite, CuString* details)
 280 {
 281         int i;
 282         int failCount = 0;
 283
 284         if (testSuite->failCount == 0)
 285         {
 286                 int passCount = testSuite->count - testSuite->failCount;
 287                 const char* testWord = passCount == 1 ? "test" : "tests";
 288                 CuStringAppendFormat(details, "OK (%d %s)\n", passCount, testWord);
 289         }
 290         else
 291         {
 292                 if (testSuite->failCount == 1)
 293                         CuStringAppend(details, "There was 1 failure:\n");
 294                 else
 295                         CuStringAppendFormat(details, "There were %d failures:\n", testSuite->failCount);
 296
 297                 for (i = 0 ; i < testSuite->count ; ++i)
 298                 {
 299                         CuTest* testCase = testSuite->list[i];
 300                         if (testCase->failed)
 301                         {
 302                                 failCount++;
 303                                 CuStringAppendFormat(details, "%d) %s: %s\n",
 304                                         failCount, testCase->name, testCase->message);
 305                         }
 306                 }
 307                 CuStringAppend(details, "\n!!!FAILURES!!!\n");
 308
 309                 CuStringAppendFormat(details, "Runs: %d ",   testSuite->count);
 310                 CuStringAppendFormat(details, "Passes: %d ", testSuite->count - testSuite->failCount);
 311                 CuStringAppendFormat(details, "Fails: %d\n",  testSuite->failCount);
 312         }
 313 }