pd.if.org Git - nbds/blob - util/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         if (tc->jumpBuf != 0) longjmp(*(tc->jumpBuf), 0);
 144 }
 145
 146 void CuFail_Line(CuTest* tc, const char* file, int line, const char* message2, const char* message)
 147 {
 148         CuString string;
 149
 150         CuStringInit(&string);
 151         if (message2 != NULL)
 152         {
 153                 CuStringAppend(&string, message2);
 154                 CuStringAppend(&string, ": ");
 155         }
 156         CuStringAppend(&string, message);
 157         CuFailInternal(tc, file, line, &string);
 158 }
 159
 160 void CuAssert_Line(CuTest* tc, const char* file, int line, const char* message, int condition)
 161 {
 162         if (condition) return;
 163         CuFail_Line(tc, file, line, NULL, message);
 164 }
 165
 166 void CuAssertStrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
 167         const char* expected, const char* actual)
 168 {
 169         CuString string;
 170         if ((expected == NULL && actual == NULL) ||
 171             (expected != NULL && actual != NULL &&
 172              strcmp(expected, actual) == 0))
 173         {
 174                 return;
 175         }
 176
 177         CuStringInit(&string);
 178         if (message != NULL)
 179         {
 180                 CuStringAppend(&string, message);
 181                 CuStringAppend(&string, ": ");
 182         }
 183         CuStringAppend(&string, "expected <");
 184         CuStringAppend(&string, expected);
 185         CuStringAppend(&string, "> but was <");
 186         CuStringAppend(&string, actual);
 187         CuStringAppend(&string, ">");
 188         CuFailInternal(tc, file, line, &string);
 189 }
 190
 191 void CuAssertIntEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
 192         int expected, int actual)
 193 {
 194         char buf[STRING_MAX];
 195         if (expected == actual) return;
 196         sprintf(buf, "expected <%d> but was <%d>", expected, actual);
 197         CuFail_Line(tc, file, line, message, buf);
 198 }
 199
 200 void CuAssertDblEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
 201         double expected, double actual, double delta)
 202 {
 203         char buf[STRING_MAX];
 204         if (fabs(expected - actual) <= delta) return;
 205         sprintf(buf, "expected <%lf> but was <%lf>", expected, actual);
 206         CuFail_Line(tc, file, line, message, buf);
 207 }
 208
 209 void CuAssertPtrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message,
 210         void* expected, void* actual)
 211 {
 212         char buf[STRING_MAX];
 213         if (expected == actual) return;
 214         sprintf(buf, "expected pointer <0x%p> but was <0x%p>", expected, actual);
 215         CuFail_Line(tc, file, line, message, buf);
 216 }
 217
 218
 219 /*-------------------------------------------------------------------------*
 220  * CuSuite
 221  *-------------------------------------------------------------------------*/
 222
 223 void CuSuiteInit(CuSuite* testSuite)
 224 {
 225         testSuite->count = 0;
 226         testSuite->failCount = 0;
 227 }
 228
 229 CuSuite* CuSuiteNew(void)
 230 {
 231         CuSuite* testSuite = CU_ALLOC(CuSuite);
 232         CuSuiteInit(testSuite);
 233         return testSuite;
 234 }
 235
 236 void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase)
 237 {
 238         assert(testSuite->count < MAX_TEST_CASES);
 239         testSuite->list[testSuite->count] = testCase;
 240         testSuite->count++;
 241 }
 242
 243 void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2)
 244 {
 245         int i;
 246         for (i = 0 ; i < testSuite2->count ; ++i)
 247         {
 248                 CuTest* testCase = testSuite2->list[i];
 249                 CuSuiteAdd(testSuite, testCase);
 250         }
 251 }
 252
 253 void CuSuiteRun(CuSuite* testSuite)
 254 {
 255         int i;
 256         for (i = 0 ; i < testSuite->count ; ++i)
 257         {
 258                 CuTest* testCase = testSuite->list[i];
 259                 CuTestRun(testCase);
 260                 if (testCase->failed) { testSuite->failCount += 1; }
 261         }
 262 }
 263
 264 void CuSuiteSummary(CuSuite* testSuite, CuString* summary)
 265 {
 266         int i;
 267         for (i = 0 ; i < testSuite->count ; ++i)
 268         {
 269                 CuTest* testCase = testSuite->list[i];
 270                 CuStringAppend(summary, testCase->failed ? "F" : ".");
 271         }
 272         CuStringAppend(summary, "\n\n");
 273 }
 274
 275 void CuSuiteDetails(CuSuite* testSuite, CuString* details)
 276 {
 277         int i;
 278         int failCount = 0;
 279
 280         if (testSuite->failCount == 0)
 281         {
 282                 int passCount = testSuite->count - testSuite->failCount;
 283                 const char* testWord = passCount == 1 ? "test" : "tests";
 284                 CuStringAppendFormat(details, "OK (%d %s)\n", passCount, testWord);
 285         }
 286         else
 287         {
 288                 if (testSuite->failCount == 1)
 289                         CuStringAppend(details, "There was 1 failure:\n");
 290                 else
 291                         CuStringAppendFormat(details, "There were %d failures:\n", testSuite->failCount);
 292
 293                 for (i = 0 ; i < testSuite->count ; ++i)
 294                 {
 295                         CuTest* testCase = testSuite->list[i];
 296                         if (testCase->failed)
 297                         {
 298                                 failCount++;
 299                                 CuStringAppendFormat(details, "%d) %s: %s\n",
 300                                         failCount, testCase->name, testCase->message);
 301                         }
 302                 }
 303                 CuStringAppend(details, "\n!!!FAILURES!!!\n");
 304
 305                 CuStringAppendFormat(details, "Runs: %d ",   testSuite->count);
 306                 CuStringAppendFormat(details, "Passes: %d ", testSuite->count - testSuite->failCount);
 307                 CuStringAppendFormat(details, "Fails: %d\n",  testSuite->failCount);
 308         }
 309 }