CuTestTest.c - libsheepy - C lib for handling text files, strings and json like data structure with an object oriented system

CuTestTest.c (18334B)
      1 #include <assert.h>
      2 #include <setjmp.h>
      3 #include <stdlib.h>
      4 #include <stdio.h>
      5 #include <string.h>
      6 
      7 #include "CuTest.h"
      8 
      9 /*-------------------------------------------------------------------------*
     10  * Helper functions
     11  *-------------------------------------------------------------------------*/
     12 
     13 #define CompareAsserts(tc, message, expected, actual)  X_CompareAsserts((tc), __FILE__, __LINE__, (message), (expected), (actual))
     14 
     15 static void X_CompareAsserts(CuTest* tc, const char *file, int line, const char* message, const char* expected, CuString *actual)
     16 {
     17 	int mismatch;
     18 	if (expected == NULL || actual == NULL || actual==NULL) {
     19 		mismatch = (expected != NULL || actual != NULL);
     20 	} else {
     21 		const char *front = __FILE__ ":";
     22 		const size_t frontLen = strlen(front);
     23 		const size_t expectedLen = strlen(expected);
     24 
     25 		const char *matchStr = actual->buffer;
     26 
     27 		mismatch = (strncmp(matchStr, front, frontLen) != 0);
     28 		if (!mismatch) {
     29 			matchStr = strchr(matchStr + frontLen, ':');
     30 			mismatch |= (matchStr == NULL || strncmp(matchStr, ": ", 2));
     31 			if (!mismatch) {
     32 				matchStr += 2;
     33 				mismatch |= (strncmp(matchStr, expected, expectedLen) != 0);
     34 			}
     35 		}
     36 	}
     37 
     38 	CuAssert_Line(tc, file, line, message, !mismatch);
     39 }
     40 
     41 /*-------------------------------------------------------------------------*
     42  * CuString Test
     43  *-------------------------------------------------------------------------*/
     44 
     45 void TestCuStringNew(CuTest* tc)
     46 {
     47 	CuString* str = CuStringNew();
     48 	CuAssertTrue(tc, 0 == str->length);
     49 	CuAssertTrue(tc, 0 != str->size);
     50 	CuAssertStrEquals(tc, "", str->buffer);
     51 }
     52 
     53 
     54 void TestCuStringAppend(CuTest* tc)
     55 {
     56 	CuString* str = CuStringNew();
     57 	CuStringAppend(str, "hello");
     58 	CuAssertIntEquals(tc, 5, str->length);
     59 	CuAssertStrEquals(tc, "hello", str->buffer);
     60 	CuStringAppend(str, " world");
     61 	CuAssertIntEquals(tc, 11, str->length);
     62 	CuAssertStrEquals(tc, "hello world", str->buffer);
     63 }
     64 
     65 
     66 void TestCuStringAppendNULL(CuTest* tc)
     67 {
     68 	CuString* str = CuStringNew();
     69 	CuStringAppend(str, NULL);
     70 	CuAssertIntEquals(tc, 4, str->length);
     71 	CuAssertStrEquals(tc, "NULL", str->buffer);
     72 }
     73 
     74 
     75 void TestCuStringAppendChar(CuTest* tc)
     76 {
     77 	CuString* str = CuStringNew();
     78 	CuStringAppendChar(str, 'a');
     79 	CuStringAppendChar(str, 'b');
     80 	CuStringAppendChar(str, 'c');
     81 	CuStringAppendChar(str, 'd');
     82 	CuAssertIntEquals(tc, 4, str->length);
     83 	CuAssertStrEquals(tc, "abcd", str->buffer);
     84 }
     85 
     86 
     87 void TestCuStringInserts(CuTest* tc)
     88 {
     89 	CuString* str = CuStringNew();
     90 	CuStringAppend(str, "world");
     91 	CuAssertIntEquals(tc, 5, str->length);
     92 	CuAssertStrEquals(tc, "world", str->buffer);
     93 	CuStringInsert(str, "hell", 0);
     94 	CuAssertIntEquals(tc, 9, str->length);
     95 	CuAssertStrEquals(tc, "hellworld", str->buffer);
     96 	CuStringInsert(str, "o ", 4);
     97 	CuAssertIntEquals(tc, 11, str->length);
     98 	CuAssertStrEquals(tc, "hello world", str->buffer);
     99 	CuStringInsert(str, "!", 11);
    100 	CuAssertIntEquals(tc, 12, str->length);
    101 	CuAssertStrEquals(tc, "hello world!", str->buffer);
    102 }
    103 
    104 
    105 void TestCuStringResizes(CuTest* tc)
    106 {
    107 	CuString* str = CuStringNew();
    108 	int i;
    109 	for(i = 0 ; i < STRING_MAX ; ++i)
    110 	{
    111 		CuStringAppend(str, "aa");
    112 	}
    113 	CuAssertTrue(tc, STRING_MAX * 2 == str->length);
    114 	CuAssertTrue(tc, STRING_MAX * 2 <= str->size);
    115 }
    116 
    117 CuSuite* CuStringGetSuite(void)
    118 {
    119 	CuSuite* suite = CuSuiteNew();
    120 
    121 	SUITE_ADD_TEST(suite, TestCuStringNew);
    122 	SUITE_ADD_TEST(suite, TestCuStringAppend);
    123 	SUITE_ADD_TEST(suite, TestCuStringAppendNULL);
    124 	SUITE_ADD_TEST(suite, TestCuStringAppendChar);
    125 	SUITE_ADD_TEST(suite, TestCuStringInserts);
    126 	SUITE_ADD_TEST(suite, TestCuStringResizes);
    127 
    128 	return suite;
    129 }
    130 
    131 /*-------------------------------------------------------------------------*
    132  * CuTest Test
    133  *-------------------------------------------------------------------------*/
    134 
    135 void TestPasses(CuTest* tc)
    136 {
    137 	CuAssert(tc, "test should pass", 1 == 0 + 1);
    138 }
    139 
    140 void zTestFails(CuTest* tc)
    141 {
    142 	CuAssert(tc, "test should fail", 1 == 1 + 1);
    143 }
    144 
    145 
    146 void TestCuTestNew(CuTest* tc)
    147 {
    148 	CuTest* tc2 = CuTestNew("MyTest", TestPasses);
    149 	CuAssertStrEquals(tc, "MyTest", tc2->name);
    150 	CuAssertTrue(tc, !tc2->failed);
    151         CuAssertTrue(tc, tc2->message == NULL);
    152 	CuAssertTrue(tc, tc2->function == TestPasses);
    153 	CuAssertTrue(tc, tc2->ran == 0);
    154 	CuAssertTrue(tc, tc2->jumpBuf == NULL);
    155 }
    156 
    157 
    158 void TestCuTestInit(CuTest *tc)
    159 {
    160 	CuTest tc2;
    161 	CuTestInit(&tc2, "MyTest", TestPasses);
    162 	CuAssertStrEquals(tc, "MyTest", tc2.name);
    163 	CuAssertTrue(tc, !tc2.failed);
    164         CuAssertTrue(tc, tc2.message == NULL);
    165 	CuAssertTrue(tc, tc2.function == TestPasses);
    166 	CuAssertTrue(tc, tc2.ran == 0);
    167 	CuAssertTrue(tc, tc2.jumpBuf == NULL);
    168 }
    169 
    170 void TestCuAssert(CuTest* tc)
    171 {
    172 	CuTest tc2;
    173 	CuTestInit(&tc2, "MyTest", TestPasses);
    174 
    175 	CuAssert(&tc2, "test 1", 5 == 4 + 1);
    176 	CuAssertTrue(tc, !tc2.failed);
    177         CuAssertTrue(tc, tc2.message == NULL);
    178 
    179 	CuAssert(&tc2, "test 2", 0);
    180 	CuAssertTrue(tc, tc2.failed);
    181 	CompareAsserts(tc, "CuAssert didn't fail", "test 2", tc2.message);
    182 
    183 	CuAssert(&tc2, "test 3", 1);
    184 	CuAssertTrue(tc, tc2.failed);
    185 	CompareAsserts(tc, "CuAssert didn't fail", "test 2", tc2.message);
    186 
    187 	CuAssert(&tc2, "test 4", 0);
    188 	CuAssertTrue(tc, tc2.failed);
    189 	CompareAsserts(tc, "CuAssert didn't fail", "test 4", tc2.message);
    190 
    191 }
    192 
    193 void TestCuAssertPtrEquals_Success(CuTest* tc)
    194 {
    195 	CuTest tc2;
    196 	int x;
    197 
    198 	CuTestInit(&tc2, "MyTest", TestPasses);
    199 
    200 	/* test success case */
    201 	CuAssertPtrEquals(&tc2, &x, &x);
    202 	CuAssertTrue(tc, ! tc2.failed);
    203         CuAssertTrue(tc, tc2.message == NULL);
    204 }
    205 
    206 void TestCuAssertPtrEquals_Failure(CuTest* tc)
    207 {
    208 	CuTest tc2;
    209 	int x;
    210 	int* nullPtr = NULL;
    211 	char expected_message[STRING_MAX];
    212 
    213 	CuTestInit(&tc2, "MyTest", TestPasses);
    214 
    215 	/* test failing case */
    216 	sprintf(expected_message, "expected pointer <0x%p> but was <0x%p>", (void*)nullPtr, (void*)&x);
    217 	CuAssertPtrEquals(&tc2, NULL, &x);
    218 	CuAssertTrue(tc, tc2.failed);
    219 	CompareAsserts(tc, "CuAssertPtrEquals failed", expected_message, tc2.message);
    220 }
    221 
    222 void TestCuAssertPtrNotNull_Success(CuTest* tc)
    223 {
    224 	CuTest tc2;
    225 	int x;
    226 
    227 	CuTestInit(&tc2, "MyTest", TestPasses);
    228 
    229 	/* test success case */
    230 	CuAssertPtrNotNull(&tc2, &x);
    231 	CuAssertTrue(tc, ! tc2.failed);
    232         CuAssertTrue(tc, tc2.message == NULL);
    233 }
    234 
    235 void TestCuAssertPtrNotNull_Failure(CuTest* tc)
    236 {
    237 	CuTest tc2;
    238 
    239 	CuTestInit(&tc2, "MyTest", TestPasses);
    240 
    241 	/* test failing case */
    242 	CuAssertPtrNotNull(&tc2, NULL);
    243 	CuAssertTrue(tc, tc2.failed);
    244 	CompareAsserts(tc, "CuAssertPtrNotNull failed", "null pointer unexpected", tc2.message);
    245 }
    246 
    247 void TestCuTestRun(CuTest* tc)
    248 {
    249 	CuTest tc2;
    250 	CuTestInit(&tc2, "MyTest", zTestFails);
    251 	CuTestRun(&tc2);
    252 
    253 	CuAssertStrEquals(tc, "MyTest", tc2.name);
    254 	CuAssertTrue(tc, tc2.failed);
    255 	CuAssertTrue(tc, tc2.ran);
    256 	CompareAsserts(tc, "TestRun failed", "test should fail", tc2.message);
    257 }
    258 
    259 /*-------------------------------------------------------------------------*
    260  * CuSuite Test
    261  *-------------------------------------------------------------------------*/
    262 
    263 void TestCuSuiteInit(CuTest* tc)
    264 {
    265 	CuSuite ts;
    266 	CuSuiteInit(&ts);
    267 	CuAssertTrue(tc, ts.count == 0);
    268 	CuAssertTrue(tc, ts.failCount == 0);
    269 }
    270 
    271 void TestCuSuiteNew(CuTest* tc)
    272 {
    273 	CuSuite* ts = CuSuiteNew();
    274 	CuAssertTrue(tc, ts->count == 0);
    275 	CuAssertTrue(tc, ts->failCount == 0);
    276 }
    277 
    278 void TestCuSuiteAddTest(CuTest* tc)
    279 {
    280 	CuSuite ts;
    281 	CuTest tc2;
    282 
    283 	CuSuiteInit(&ts);
    284 	CuTestInit(&tc2, "MyTest", zTestFails);
    285 
    286 	CuSuiteAdd(&ts, &tc2);
    287 	CuAssertTrue(tc, ts.count == 1);
    288 
    289 	CuAssertStrEquals(tc, "MyTest", ts.list[0]->name);
    290 }
    291 
    292 void TestCuSuiteAddSuite(CuTest* tc)
    293 {
    294 	CuSuite* ts1 = CuSuiteNew();
    295 	CuSuite* ts2 = CuSuiteNew();
    296 
    297 	CuSuiteAdd(ts1, CuTestNew("TestFails1", zTestFails));
    298 	CuSuiteAdd(ts1, CuTestNew("TestFails2", zTestFails));
    299 
    300 	CuSuiteAdd(ts2, CuTestNew("TestFails3", zTestFails));
    301 	CuSuiteAdd(ts2, CuTestNew("TestFails4", zTestFails));
    302 
    303 	CuSuiteAddSuite(ts1, ts2);
    304 	CuAssertIntEquals(tc, 4, ts1->count);
    305 
    306 	CuAssertStrEquals(tc, "TestFails1", ts1->list[0]->name);
    307 	CuAssertStrEquals(tc, "TestFails2", ts1->list[1]->name);
    308 	CuAssertStrEquals(tc, "TestFails3", ts1->list[2]->name);
    309 	CuAssertStrEquals(tc, "TestFails4", ts1->list[3]->name);
    310 }
    311 
    312 void TestCuSuiteRun(CuTest* tc)
    313 {
    314 	CuSuite ts;
    315 	CuTest tc1, tc2, tc3, tc4;
    316 
    317 	CuSuiteInit(&ts);
    318 	CuTestInit(&tc1, "TestPasses", TestPasses);
    319 	CuTestInit(&tc2, "TestPasses", TestPasses);
    320 	CuTestInit(&tc3, "TestFails",  zTestFails);
    321 	CuTestInit(&tc4, "TestFails",  zTestFails);
    322 
    323 	CuSuiteAdd(&ts, &tc1);
    324 	CuSuiteAdd(&ts, &tc2);
    325 	CuSuiteAdd(&ts, &tc3);
    326 	CuSuiteAdd(&ts, &tc4);
    327 	CuAssertTrue(tc, ts.count == 4);
    328 
    329 	CuSuiteRun(&ts);
    330 	CuAssertTrue(tc, ts.count - ts.failCount == 2);
    331 	CuAssertTrue(tc, ts.failCount == 2);
    332 }
    333 
    334 void TestCuSuiteSummary(CuTest* tc)
    335 {
    336 	CuSuite ts;
    337 	CuTest tc1, tc2;
    338 	CuString summary;
    339 
    340 	CuSuiteInit(&ts);
    341 	CuTestInit(&tc1, "TestPasses", TestPasses);
    342 	CuTestInit(&tc2, "TestFails",  zTestFails);
    343 	CuStringInit(&summary);
    344 
    345 	CuSuiteAdd(&ts, &tc1);
    346 	CuSuiteAdd(&ts, &tc2);
    347 	CuSuiteRun(&ts);
    348 
    349 	CuSuiteSummary(&ts, &summary);
    350 
    351 	CuAssertTrue(tc, ts.count == 2);
    352 	CuAssertTrue(tc, ts.failCount == 1);
    353 	CuAssertStrEquals(tc, ".F\n\n", summary.buffer);
    354 }
    355 
    356 
    357 void TestCuSuiteDetails_SingleFail(CuTest* tc)
    358 {
    359 	CuSuite ts;
    360 	CuTest tc1, tc2;
    361 	CuString details;
    362 	const char* front;
    363 	const char* back;
    364 
    365 	CuSuiteInit(&ts);
    366 	CuTestInit(&tc1, "TestPasses", TestPasses);
    367 	CuTestInit(&tc2, "TestFails",  zTestFails);
    368 	CuStringInit(&details);
    369 
    370 	CuSuiteAdd(&ts, &tc1);
    371 	CuSuiteAdd(&ts, &tc2);
    372 	CuSuiteRun(&ts);
    373 
    374 	CuSuiteDetails(&ts, &details);
    375 
    376 	CuAssertTrue(tc, ts.count == 2);
    377 	CuAssertTrue(tc, ts.failCount == 1);
    378 
    379 	front = "There was 1 failure:\n"
    380 		"1) TestFails: ";
    381 	back =  "test should fail\n"
    382 		"\n!!!FAILURES!!!\n"
    383 		"Runs: 2 Passes: 1 Fails: 1\n";
    384 
    385 	CuAssertStrEquals(tc, back, details.buffer + strlen(details.buffer) - strlen(back));
    386 	details.buffer[strlen(front)] = 0;
    387 	CuAssertStrEquals(tc, front, details.buffer);
    388 }
    389 
    390 
    391 void TestCuSuiteDetails_SinglePass(CuTest* tc)
    392 {
    393 	CuSuite ts;
    394 	CuTest tc1;
    395 	CuString details;
    396 	const char* expected;
    397 
    398 	CuSuiteInit(&ts);
    399 	CuTestInit(&tc1, "TestPasses", TestPasses);
    400 	CuStringInit(&details);
    401 
    402 	CuSuiteAdd(&ts, &tc1);
    403 	CuSuiteRun(&ts);
    404 
    405 	CuSuiteDetails(&ts, &details);
    406 
    407 	CuAssertTrue(tc, ts.count == 1);
    408 	CuAssertTrue(tc, ts.failCount == 0);
    409 
    410 	expected =
    411 		"OK (1 test)\n";
    412 
    413 	CuAssertStrEquals(tc, expected, details.buffer);
    414 }
    415 
    416 void TestCuSuiteDetails_MultiplePasses(CuTest* tc)
    417 {
    418 	CuSuite ts;
    419 	CuTest tc1, tc2;
    420 	CuString details;
    421 	const char* expected;
    422 
    423 	CuSuiteInit(&ts);
    424 	CuTestInit(&tc1, "TestPasses", TestPasses);
    425 	CuTestInit(&tc2, "TestPasses", TestPasses);
    426 	CuStringInit(&details);
    427 
    428 	CuSuiteAdd(&ts, &tc1);
    429 	CuSuiteAdd(&ts, &tc2);
    430 	CuSuiteRun(&ts);
    431 
    432 	CuSuiteDetails(&ts, &details);
    433 
    434 	CuAssertTrue(tc, ts.count == 2);
    435 	CuAssertTrue(tc, ts.failCount == 0);
    436 
    437 	expected =
    438 		"OK (2 tests)\n";
    439 
    440 	CuAssertStrEquals(tc, expected, details.buffer);
    441 }
    442 
    443 void TestCuSuiteDetails_MultipleFails(CuTest* tc)
    444 {
    445 	CuSuite ts;
    446 	CuTest tc1, tc2;
    447 	CuString details;
    448 	const char* front;
    449 	const char* mid;
    450 	const char* back;
    451 
    452 	CuSuiteInit(&ts);
    453 	CuTestInit(&tc1, "TestFails1", zTestFails);
    454 	CuTestInit(&tc2, "TestFails2", zTestFails);
    455 	CuStringInit(&details);
    456 
    457 	CuSuiteAdd(&ts, &tc1);
    458 	CuSuiteAdd(&ts, &tc2);
    459 	CuSuiteRun(&ts);
    460 
    461 	CuSuiteDetails(&ts, &details);
    462 
    463 	CuAssertTrue(tc, ts.count == 2);
    464 	CuAssertTrue(tc, ts.failCount == 2);
    465 
    466 	front =
    467 		"There were 2 failures:\n"
    468 		"1) TestFails1: ";
    469 	mid =   "test should fail\n"
    470 		"2) TestFails2: ";
    471 	back =  "test should fail\n"
    472 		"\n!!!FAILURES!!!\n"
    473 		"Runs: 2 Passes: 0 Fails: 2\n";
    474 
    475 	CuAssertStrEquals(tc, back, details.buffer + strlen(details.buffer) - strlen(back));
    476 	CuAssert(tc, "Couldn't find middle", strstr(details.buffer, mid) != NULL);
    477 	details.buffer[strlen(front)] = 0;
    478 	CuAssertStrEquals(tc, front, details.buffer);
    479 }
    480 
    481 
    482 /*-------------------------------------------------------------------------*
    483  * Misc Test
    484  *-------------------------------------------------------------------------*/
    485 
    486 void TestCuStrCopy(CuTest* tc)
    487 {
    488 	const char* old = "hello world";
    489 	const char* newStr = CuStrCopy(old);
    490 	CuAssert(tc, "old is new", strcmp(old, newStr) == 0);
    491 }
    492 
    493 
    494 void TestCuStringAppendFormat(CuTest* tc)
    495 {
    496 	int i;
    497 	char* text = CuStrAlloc(301);		/* long string */
    498 	CuString* str = CuStringNew();
    499 	for (i = 0 ; i < 300 ; ++i)
    500 		text[i] = 'a';
    501 	text[300] = '\0';
    502 	CuStringAppendFormat(str, "%s", text);
    503 
    504 	/* buffer limit raised to HUGE_STRING_LEN so no overflow */
    505 
    506 	CuAssert(tc, "length of str->buffer is 300", 300 == strlen(str->buffer));
    507 }
    508 
    509 void TestFail(CuTest* tc)
    510 {
    511 	jmp_buf buf;
    512 	int pointReached = 0;
    513 	CuTest* tc2 = CuTestNew("TestFails", zTestFails);
    514 	tc2->jumpBuf = &buf;
    515 	if (setjmp(buf) == 0)
    516 	{
    517 		CuFail(tc2, "hello world");
    518 		pointReached = 1;
    519 	}
    520 	CuAssert(tc, "point was not reached", pointReached == 0);
    521 }
    522 
    523 void TestAssertStrEquals(CuTest* tc)
    524 {
    525 	jmp_buf buf;
    526 	CuTest *tc2 = CuTestNew("TestAssertStrEquals", zTestFails);
    527 
    528 	const char* expected = "expected <hello> but was <world>";
    529 	const char *expectedMsg = "some text: expected <hello> but was <world>";
    530 
    531 	tc2->jumpBuf = &buf;
    532 	if (setjmp(buf) == 0)
    533 	{
    534 		CuAssertStrEquals(tc2, "hello", "world");
    535 	}
    536 	CuAssertTrue(tc, tc2->failed);
    537 	CompareAsserts(tc, "CuAssertStrEquals failed", expected, tc2->message);
    538 	if (setjmp(buf) == 0)
    539 	{
    540 		CuAssertStrEquals_Msg(tc2, "some text", "hello", "world");
    541 	}
    542 	CuAssertTrue(tc, tc2->failed);
    543 	CompareAsserts(tc, "CuAssertStrEquals failed", expectedMsg, tc2->message);
    544 }
    545 
    546 void TestAssertStrEquals_NULL(CuTest* tc)
    547 {
    548 	jmp_buf buf;
    549 	CuTest *tc2 = CuTestNew("TestAssertStrEquals_NULL", zTestFails);
    550 
    551 	tc2->jumpBuf = &buf;
    552 	if (setjmp(buf) == 0)
    553 	{
    554 		CuAssertStrEquals(tc2, NULL, NULL);
    555 	}
    556 	CuAssertTrue(tc, !tc2->failed);
    557 	CompareAsserts(tc, "CuAssertStrEquals_NULL failed", NULL, tc2->message);
    558 	if (setjmp(buf) == 0)
    559 	{
    560 		CuAssertStrEquals_Msg(tc2, "some text", NULL, NULL);
    561 	}
    562 	CuAssertTrue(tc, !tc2->failed);
    563 	CompareAsserts(tc, "CuAssertStrEquals_NULL failed", NULL, tc2->message);
    564 }
    565 
    566 void TestAssertStrEquals_FailNULLStr(CuTest* tc)
    567 {
    568 	jmp_buf buf;
    569 	CuTest *tc2 = CuTestNew("TestAssertStrEquals_FailNULLStr", zTestFails);
    570 
    571 	const char* expected = "expected <hello> but was <NULL>";
    572 	const char *expectedMsg = "some text: expected <hello> but was <NULL>";
    573 
    574 	tc2->jumpBuf = &buf;
    575 	if (setjmp(buf) == 0)
    576 	{
    577 		CuAssertStrEquals(tc2, "hello", NULL);
    578 	}
    579 	CuAssertTrue(tc, tc2->failed);
    580 	CompareAsserts(tc, "CuAssertStrEquals_FailNULLStr failed", expected, tc2->message);
    581 	if (setjmp(buf) == 0)
    582 	{
    583 		CuAssertStrEquals_Msg(tc2, "some text", "hello", NULL);
    584 	}
    585 	CuAssertTrue(tc, tc2->failed);
    586 	CompareAsserts(tc, "CuAssertStrEquals_FailNULLStr failed", expectedMsg, tc2->message);
    587 }
    588 
    589 void TestAssertStrEquals_FailStrNULL(CuTest* tc)
    590 {
    591 	jmp_buf buf;
    592 	CuTest *tc2 = CuTestNew("TestAssertStrEquals_FailStrNULL", zTestFails);
    593 
    594 	const char* expected = "expected <NULL> but was <hello>";
    595 	const char *expectedMsg = "some text: expected <NULL> but was <hello>";
    596 
    597 	tc2->jumpBuf = &buf;
    598 	if (setjmp(buf) == 0)
    599 	{
    600 		CuAssertStrEquals(tc2, NULL, "hello");
    601 	}
    602 	CuAssertTrue(tc, tc2->failed);
    603 	CompareAsserts(tc, "CuAssertStrEquals_FailStrNULL failed", expected, tc2->message);
    604 	if (setjmp(buf) == 0)
    605 	{
    606 		CuAssertStrEquals_Msg(tc2, "some text", NULL, "hello");
    607 	}
    608 	CuAssertTrue(tc, tc2->failed);
    609 	CompareAsserts(tc, "CuAssertStrEquals_FailStrNULL failed", expectedMsg, tc2->message);
    610 }
    611 
    612 void TestAssertIntEquals(CuTest* tc)
    613 {
    614 	jmp_buf buf;
    615 	CuTest *tc2 = CuTestNew("TestAssertIntEquals", zTestFails);
    616 	const char* expected = "expected <42> but was <32>";
    617 	const char* expectedMsg = "some text: expected <42> but was <32>";
    618 	tc2->jumpBuf = &buf;
    619 	if (setjmp(buf) == 0)
    620 	{
    621 		CuAssertIntEquals(tc2, 42, 32);
    622 	}
    623 	CuAssertTrue(tc, tc2->failed);
    624 	CompareAsserts(tc, "CuAssertIntEquals failed", expected, tc2->message);
    625 	if (setjmp(buf) == 0)
    626 	{
    627 		CuAssertIntEquals_Msg(tc2, "some text", 42, 32);
    628 	}
    629 	CuAssertTrue(tc, tc2->failed);
    630 	CompareAsserts(tc, "CuAssertStrEquals failed", expectedMsg, tc2->message);
    631 }
    632 
    633 void TestAssertDblEquals(CuTest* tc)
    634 {
    635 	jmp_buf buf;
    636 	double x = 3.33;
    637 	double y = 10.0 / 3.0;
    638 	CuTest *tc2 = CuTestNew("TestAssertDblEquals", zTestFails);
    639 	char expected[STRING_MAX];
    640 	char expectedMsg[STRING_MAX];
    641 	sprintf(expected, "expected <%lf> but was <%lf>", x, y);
    642 	sprintf(expectedMsg, "some text: expected <%lf> but was <%lf>", x, y);
    643 
    644 	CuTestInit(tc2, "TestAssertDblEquals", TestPasses);
    645 
    646 	CuAssertDblEquals(tc2, x, x, 0.0);
    647 	CuAssertTrue(tc, ! tc2->failed);
    648         CuAssertTrue(tc, tc2->message == NULL);
    649         
    650 	CuAssertDblEquals(tc2, x, y, 0.01);
    651 	CuAssertTrue(tc, ! tc2->failed);
    652         CuAssertTrue(tc, tc2->message == NULL);
    653 
    654 	tc2->jumpBuf = &buf;
    655 	if (setjmp(buf) == 0)
    656 	{
    657 		CuAssertDblEquals(tc2, x, y, 0.001);
    658 	}
    659 	CuAssertTrue(tc, tc2->failed);
    660 	CompareAsserts(tc, "CuAssertDblEquals failed", expected, tc2->message);
    661 	tc2->jumpBuf = &buf;
    662 	if (setjmp(buf) == 0)
    663 	{
    664 		CuAssertDblEquals_Msg(tc2, "some text", x, y, 0.001);
    665 	}
    666 	CuAssertTrue(tc, tc2->failed);
    667 	CompareAsserts(tc, "CuAssertDblEquals failed", expectedMsg, tc2->message);
    668 }
    669 
    670 /*-------------------------------------------------------------------------*
    671  * main
    672  *-------------------------------------------------------------------------*/
    673 
    674 CuSuite* CuGetSuite(void)
    675 {
    676 	CuSuite* suite = CuSuiteNew();
    677 
    678 	SUITE_ADD_TEST(suite, TestCuStringAppendFormat);
    679 	SUITE_ADD_TEST(suite, TestCuStrCopy);
    680 	SUITE_ADD_TEST(suite, TestFail);
    681 	SUITE_ADD_TEST(suite, TestAssertStrEquals);
    682 	SUITE_ADD_TEST(suite, TestAssertStrEquals_NULL);
    683 	SUITE_ADD_TEST(suite, TestAssertStrEquals_FailStrNULL);
    684 	SUITE_ADD_TEST(suite, TestAssertStrEquals_FailNULLStr);
    685 	SUITE_ADD_TEST(suite, TestAssertIntEquals);
    686 	SUITE_ADD_TEST(suite, TestAssertDblEquals);
    687 
    688 	SUITE_ADD_TEST(suite, TestCuTestNew);
    689 	SUITE_ADD_TEST(suite, TestCuTestInit);
    690 	SUITE_ADD_TEST(suite, TestCuAssert);
    691 	SUITE_ADD_TEST(suite, TestCuAssertPtrEquals_Success);
    692 	SUITE_ADD_TEST(suite, TestCuAssertPtrEquals_Failure);
    693 	SUITE_ADD_TEST(suite, TestCuAssertPtrNotNull_Success);
    694 	SUITE_ADD_TEST(suite, TestCuAssertPtrNotNull_Failure);
    695 	SUITE_ADD_TEST(suite, TestCuTestRun);
    696 
    697 	SUITE_ADD_TEST(suite, TestCuSuiteInit);
    698 	SUITE_ADD_TEST(suite, TestCuSuiteNew);
    699 	SUITE_ADD_TEST(suite, TestCuSuiteAddTest);
    700 	SUITE_ADD_TEST(suite, TestCuSuiteAddSuite);
    701 	SUITE_ADD_TEST(suite, TestCuSuiteRun);
    702 	SUITE_ADD_TEST(suite, TestCuSuiteSummary);
    703 	SUITE_ADD_TEST(suite, TestCuSuiteDetails_SingleFail);
    704 	SUITE_ADD_TEST(suite, TestCuSuiteDetails_SinglePass);
    705 	SUITE_ADD_TEST(suite, TestCuSuiteDetails_MultiplePasses);
    706 	SUITE_ADD_TEST(suite, TestCuSuiteDetails_MultipleFails);
    707 
    708 	return suite;
    709 }
	libsheepy C lib for handling text files, strings and json like data structure with an object oriented system
	git clone https://spartatek.se/git/libsheepy.git
	Log \| Files \| Refs \| README \| LICENSE