From caa802c98ae98f8bcbd335f3e756de5cf6df6bb0 Mon Sep 17 00:00:00 2001 From: Bruno Raoult Date: Fri, 12 Jan 2024 11:42:24 +0100 Subject: [PATCH] .gitgnore, fix indent (no spaces, etc...) --- .gitignore | 1 + AllTests.c | 18 +- CuTest.c | 378 +++++++++++----------- CuTest.h | 48 +-- CuTestTest.c | 878 +++++++++++++++++++++++++------------------------- make-tests.sh | 10 +- style.css | 24 +- 7 files changed, 679 insertions(+), 678 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9e7271a --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/.ccls-cache/ diff --git a/AllTests.c b/AllTests.c index 5c849ef..01e7a93 100644 --- a/AllTests.c +++ b/AllTests.c @@ -7,19 +7,19 @@ CuSuite* CuStringGetSuite(); void RunAllTests(void) { - CuString *output = CuStringNew(); - CuSuite* suite = CuSuiteNew(); + CuString *output = CuStringNew(); + CuSuite* suite = CuSuiteNew(); - CuSuiteAddSuite(suite, CuGetSuite()); - CuSuiteAddSuite(suite, CuStringGetSuite()); + CuSuiteAddSuite(suite, CuGetSuite()); + CuSuiteAddSuite(suite, CuStringGetSuite()); - CuSuiteRun(suite); - CuSuiteSummary(suite, output); - CuSuiteDetails(suite, output); - printf("%s\n", output->buffer); + CuSuiteRun(suite); + CuSuiteSummary(suite, output); + CuSuiteDetails(suite, output); + printf("%s\n", output->buffer); } int main(void) { - RunAllTests(); + RunAllTests(); } diff --git a/CuTest.c b/CuTest.c index f075cfb..d9e325d 100644 --- a/CuTest.c +++ b/CuTest.c @@ -13,16 +13,16 @@ char* CuStrAlloc(int size) { - char* newStr = (char*) malloc( sizeof(char) * (size) ); - return newStr; + char* newStr = (char*) malloc( sizeof(char) * (size) ); + return newStr; } char* CuStrCopy(const char* old) { - int len = strlen(old); - char* newStr = CuStrAlloc(len + 1); - strcpy(newStr, old); - return newStr; + int len = strlen(old); + char* newStr = CuStrAlloc(len + 1); + strcpy(newStr, old); + return newStr; } /*-------------------------------------------------------------------------* @@ -31,78 +31,78 @@ char* CuStrCopy(const char* old) void CuStringInit(CuString* str) { - str->length = 0; - str->size = STRING_MAX; - str->buffer = (char*) malloc(sizeof(char) * str->size); - str->buffer[0] = '\0'; + str->length = 0; + str->size = STRING_MAX; + str->buffer = (char*) malloc(sizeof(char) * str->size); + str->buffer[0] = '\0'; } CuString* CuStringNew(void) { - CuString* str = (CuString*) malloc(sizeof(CuString)); - str->length = 0; - str->size = STRING_MAX; - str->buffer = (char*) malloc(sizeof(char) * str->size); - str->buffer[0] = '\0'; - return str; + CuString* str = (CuString*) malloc(sizeof(CuString)); + str->length = 0; + str->size = STRING_MAX; + str->buffer = (char*) malloc(sizeof(char) * str->size); + str->buffer[0] = '\0'; + return str; } void CuStringDelete(CuString *str) { - if (!str) return; - free(str->buffer); - free(str); + if (!str) return; + free(str->buffer); + free(str); } void CuStringResize(CuString* str, int newSize) { - str->buffer = (char*) realloc(str->buffer, sizeof(char) * newSize); - str->size = newSize; + str->buffer = (char*) realloc(str->buffer, sizeof(char) * newSize); + str->size = newSize; } void CuStringAppend(CuString* str, const char* text) { - int length; + int length; - if (text == NULL) { - text = "NULL"; - } + if (text == NULL) { + text = "NULL"; + } - length = strlen(text); - if (str->length + length + 1 >= str->size) - CuStringResize(str, str->length + length + 1 + STRING_INC); - str->length += length; - strcat(str->buffer, text); + length = strlen(text); + if (str->length + length + 1 >= str->size) + CuStringResize(str, str->length + length + 1 + STRING_INC); + str->length += length; + strcat(str->buffer, text); } void CuStringAppendChar(CuString* str, char ch) { - char text[2]; - text[0] = ch; - text[1] = '\0'; - CuStringAppend(str, text); + char text[2]; + text[0] = ch; + text[1] = '\0'; + CuStringAppend(str, text); } void CuStringAppendFormat(CuString* str, const char* format, ...) { - va_list argp; - char buf[HUGE_STRING_LEN]; - va_start(argp, format); - vsprintf(buf, format, argp); - va_end(argp); - CuStringAppend(str, buf); + va_list argp; + char buf[HUGE_STRING_LEN]; + va_start(argp, format); + vsprintf(buf, format, argp); + va_end(argp); + CuStringAppend(str, buf); } void CuStringInsert(CuString* str, const char* text, int pos) { - int length = strlen(text); - if (pos > str->length) - pos = str->length; - if (str->length + length + 1 >= str->size) - CuStringResize(str, str->length + length + 1 + STRING_INC); - memmove(str->buffer + pos + length, str->buffer + pos, (str->length - pos) + 1); - str->length += length; - memcpy(str->buffer + pos, text, length); + int length = strlen(text); + if (pos > str->length) + pos = str->length; + if (str->length + length + 1 >= str->size) + CuStringResize(str, str->length + length + 1 + STRING_INC); + memmove(str->buffer + pos + length, str->buffer + pos, (str->length - pos) + 1); + str->length += length; + memcpy(str->buffer + pos, text, length); } /*-------------------------------------------------------------------------* @@ -111,124 +111,124 @@ void CuStringInsert(CuString* str, const char* text, int pos) void CuTestInit(CuTest* t, const char* name, TestFunction function) { - t->name = CuStrCopy(name); - t->failed = 0; - t->ran = 0; - t->message = NULL; - t->function = function; - t->jumpBuf = NULL; + t->name = CuStrCopy(name); + t->failed = 0; + t->ran = 0; + t->message = NULL; + t->function = function; + t->jumpBuf = NULL; } CuTest* CuTestNew(const char* name, TestFunction function) { - CuTest* tc = CU_ALLOC(CuTest); - CuTestInit(tc, name, function); - return tc; + CuTest* tc = CU_ALLOC(CuTest); + CuTestInit(tc, name, function); + return tc; } void CuTestDelete(CuTest *t) { - if (!t) return; - free(t->name); - free(t); + if (!t) return; + free(t->name); + free(t); } void CuTestRun(CuTest* tc) { - jmp_buf buf; - tc->jumpBuf = &buf; - if (setjmp(buf) == 0) - { - tc->ran = 1; - (tc->function)(tc); - } - tc->jumpBuf = 0; + jmp_buf buf; + tc->jumpBuf = &buf; + if (setjmp(buf) == 0) + { + tc->ran = 1; + (tc->function)(tc); + } + tc->jumpBuf = 0; } static void CuFailInternal(CuTest* tc, const char* file, int line, CuString* string) { - char buf[HUGE_STRING_LEN]; + char buf[HUGE_STRING_LEN]; - sprintf(buf, "%s:%d: ", file, line); - CuStringInsert(string, buf, 0); + sprintf(buf, "%s:%d: ", file, line); + CuStringInsert(string, buf, 0); - tc->failed = 1; - tc->message = string->buffer; - if (tc->jumpBuf != 0) longjmp(*(tc->jumpBuf), 0); + tc->failed = 1; + tc->message = string->buffer; + if (tc->jumpBuf != 0) longjmp(*(tc->jumpBuf), 0); } void CuFail_Line(CuTest* tc, const char* file, int line, const char* message2, const char* message) { - CuString string; + CuString string; - CuStringInit(&string); - if (message2 != NULL) - { - CuStringAppend(&string, message2); - CuStringAppend(&string, ": "); - } - CuStringAppend(&string, message); - CuFailInternal(tc, file, line, &string); + CuStringInit(&string); + if (message2 != NULL) + { + CuStringAppend(&string, message2); + CuStringAppend(&string, ": "); + } + CuStringAppend(&string, message); + CuFailInternal(tc, file, line, &string); } void CuAssert_Line(CuTest* tc, const char* file, int line, const char* message, int condition) { - if (condition) return; - CuFail_Line(tc, file, line, NULL, message); + if (condition) return; + CuFail_Line(tc, file, line, NULL, message); } -void CuAssertStrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, - const char* expected, const char* actual) +void CuAssertStrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, + const char* expected, const char* actual) { - CuString string; - if ((expected == NULL && actual == NULL) || - (expected != NULL && actual != NULL && - strcmp(expected, actual) == 0)) - { - return; - } + CuString string; + if ((expected == NULL && actual == NULL) || + (expected != NULL && actual != NULL && + strcmp(expected, actual) == 0)) + { + return; + } - CuStringInit(&string); - if (message != NULL) - { - CuStringAppend(&string, message); - CuStringAppend(&string, ": "); - } - CuStringAppend(&string, "expected <"); - CuStringAppend(&string, expected); - CuStringAppend(&string, "> but was <"); - CuStringAppend(&string, actual); - CuStringAppend(&string, ">"); - CuFailInternal(tc, file, line, &string); + CuStringInit(&string); + if (message != NULL) + { + CuStringAppend(&string, message); + CuStringAppend(&string, ": "); + } + CuStringAppend(&string, "expected <"); + CuStringAppend(&string, expected); + CuStringAppend(&string, "> but was <"); + CuStringAppend(&string, actual); + CuStringAppend(&string, ">"); + CuFailInternal(tc, file, line, &string); } -void CuAssertIntEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, - int expected, int actual) +void CuAssertIntEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, + int expected, int actual) { - char buf[STRING_MAX]; - if (expected == actual) return; - sprintf(buf, "expected <%d> but was <%d>", expected, actual); - CuFail_Line(tc, file, line, message, buf); + char buf[STRING_MAX]; + if (expected == actual) return; + sprintf(buf, "expected <%d> but was <%d>", expected, actual); + CuFail_Line(tc, file, line, message, buf); } -void CuAssertDblEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, - double expected, double actual, double delta) +void CuAssertDblEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, + double expected, double actual, double delta) { - char buf[STRING_MAX]; - if (fabs(expected - actual) <= delta) return; + char buf[STRING_MAX]; + if (fabs(expected - actual) <= delta) return; /* sprintf(buf, "expected <%lf> but was <%lf>", expected, actual); */ - sprintf(buf, "expected <%f> but was <%f>", expected, actual); + sprintf(buf, "expected <%f> but was <%f>", expected, actual); - CuFail_Line(tc, file, line, message, buf); + CuFail_Line(tc, file, line, message, buf); } -void CuAssertPtrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, - void* expected, void* actual) +void CuAssertPtrEquals_LineMsg(CuTest* tc, const char* file, int line, const char* message, + void* expected, void* actual) { - char buf[STRING_MAX]; - if (expected == actual) return; - sprintf(buf, "expected pointer <0x%p> but was <0x%p>", expected, actual); - CuFail_Line(tc, file, line, message, buf); + char buf[STRING_MAX]; + if (expected == actual) return; + sprintf(buf, "expected pointer <0x%p> but was <0x%p>", expected, actual); + CuFail_Line(tc, file, line, message, buf); } @@ -238,103 +238,103 @@ void CuAssertPtrEquals_LineMsg(CuTest* tc, const char* file, int line, const cha void CuSuiteInit(CuSuite* testSuite) { - testSuite->count = 0; - testSuite->failCount = 0; - memset(testSuite->list, 0, sizeof(testSuite->list)); + testSuite->count = 0; + testSuite->failCount = 0; + memset(testSuite->list, 0, sizeof(testSuite->list)); } CuSuite* CuSuiteNew(void) { - CuSuite* testSuite = CU_ALLOC(CuSuite); - CuSuiteInit(testSuite); - return testSuite; + CuSuite* testSuite = CU_ALLOC(CuSuite); + CuSuiteInit(testSuite); + return testSuite; } void CuSuiteDelete(CuSuite *testSuite) { - unsigned int n; - for (n=0; n < MAX_TEST_CASES; n++) + unsigned int n; + for (n=0; n < MAX_TEST_CASES; n++) + { + if (testSuite->list[n]) { - if (testSuite->list[n]) - { - CuTestDelete(testSuite->list[n]); - } + CuTestDelete(testSuite->list[n]); } - free(testSuite); + } + free(testSuite); } void CuSuiteAdd(CuSuite* testSuite, CuTest *testCase) { - assert(testSuite->count < MAX_TEST_CASES); - testSuite->list[testSuite->count] = testCase; - testSuite->count++; + assert(testSuite->count < MAX_TEST_CASES); + testSuite->list[testSuite->count] = testCase; + testSuite->count++; } void CuSuiteAddSuite(CuSuite* testSuite, CuSuite* testSuite2) { - int i; - for (i = 0 ; i < testSuite2->count ; ++i) - { - CuTest* testCase = testSuite2->list[i]; - CuSuiteAdd(testSuite, testCase); - } + int i; + for (i = 0 ; i < testSuite2->count ; ++i) + { + CuTest* testCase = testSuite2->list[i]; + CuSuiteAdd(testSuite, testCase); + } } void CuSuiteRun(CuSuite* testSuite) { - int i; - for (i = 0 ; i < testSuite->count ; ++i) - { - CuTest* testCase = testSuite->list[i]; - CuTestRun(testCase); - if (testCase->failed) { testSuite->failCount += 1; } - } + int i; + for (i = 0 ; i < testSuite->count ; ++i) + { + CuTest* testCase = testSuite->list[i]; + CuTestRun(testCase); + if (testCase->failed) { testSuite->failCount += 1; } + } } void CuSuiteSummary(CuSuite* testSuite, CuString* summary) { - int i; - for (i = 0 ; i < testSuite->count ; ++i) - { - CuTest* testCase = testSuite->list[i]; - CuStringAppend(summary, testCase->failed ? "F" : "."); - } - CuStringAppend(summary, "\n\n"); + int i; + for (i = 0 ; i < testSuite->count ; ++i) + { + CuTest* testCase = testSuite->list[i]; + CuStringAppend(summary, testCase->failed ? "F" : "."); + } + CuStringAppend(summary, "\n\n"); } void CuSuiteDetails(CuSuite* testSuite, CuString* details) { - int i; - int failCount = 0; + int i; + int failCount = 0; - if (testSuite->failCount == 0) - { - int passCount = testSuite->count - testSuite->failCount; - const char* testWord = passCount == 1 ? "test" : "tests"; - CuStringAppendFormat(details, "OK (%d %s)\n", passCount, testWord); - } - else - { - if (testSuite->failCount == 1) - CuStringAppend(details, "There was 1 failure:\n"); - else - CuStringAppendFormat(details, "There were %d failures:\n", testSuite->failCount); + if (testSuite->failCount == 0) + { + int passCount = testSuite->count - testSuite->failCount; + const char* testWord = passCount == 1 ? "test" : "tests"; + CuStringAppendFormat(details, "OK (%d %s)\n", passCount, testWord); + } + else + { + if (testSuite->failCount == 1) + CuStringAppend(details, "There was 1 failure:\n"); + else + CuStringAppendFormat(details, "There were %d failures:\n", testSuite->failCount); - for (i = 0 ; i < testSuite->count ; ++i) - { - CuTest* testCase = testSuite->list[i]; - if (testCase->failed) - { - failCount++; - CuStringAppendFormat(details, "%d) %s: %s\n", - failCount, testCase->name, testCase->message); - } - } - CuStringAppend(details, "\n!!!FAILURES!!!\n"); + for (i = 0 ; i < testSuite->count ; ++i) + { + CuTest* testCase = testSuite->list[i]; + if (testCase->failed) + { + failCount++; + CuStringAppendFormat(details, "%d) %s: %s\n", + failCount, testCase->name, testCase->message); + } + } + CuStringAppend(details, "\n!!!FAILURES!!!\n"); - CuStringAppendFormat(details, "Runs: %d ", testSuite->count); - CuStringAppendFormat(details, "Passes: %d ", testSuite->count - testSuite->failCount); - CuStringAppendFormat(details, "Fails: %d\n", testSuite->failCount); - } + CuStringAppendFormat(details, "Runs: %d ", testSuite->count); + CuStringAppendFormat(details, "Passes: %d ", testSuite->count - testSuite->failCount); + CuStringAppendFormat(details, "Fails: %d\n", testSuite->failCount); + } } diff --git a/CuTest.h b/CuTest.h index 603dc18..5c8b4bb 100644 --- a/CuTest.h +++ b/CuTest.h @@ -17,9 +17,9 @@ char* CuStrCopy(const char* old); typedef struct { - int length; - int size; - char* buffer; + int length; + int size; + char* buffer; } CuString; void CuStringInit(CuString* str); @@ -40,12 +40,12 @@ typedef void (*TestFunction)(CuTest *); struct CuTest { - char* name; - TestFunction function; - int failed; - int ran; - const char* message; - jmp_buf *jumpBuf; + char* name; + TestFunction function; + int failed; + int ran; + const char* message; + jmp_buf *jumpBuf; }; void CuTestInit(CuTest* t, const char* name, TestFunction function); @@ -56,18 +56,18 @@ void CuTestDelete(CuTest *t); /* Internal versions of assert functions -- use the public versions */ void CuFail_Line(CuTest* tc, const char* file, int line, const char* message2, const char* message); void CuAssert_Line(CuTest* tc, const char* file, int line, const char* message, int condition); -void CuAssertStrEquals_LineMsg(CuTest* tc, - const char* file, int line, const char* message, - const char* expected, const char* actual); -void CuAssertIntEquals_LineMsg(CuTest* tc, - const char* file, int line, const char* message, - int expected, int actual); -void CuAssertDblEquals_LineMsg(CuTest* tc, - const char* file, int line, const char* message, - double expected, double actual, double delta); -void CuAssertPtrEquals_LineMsg(CuTest* tc, - const char* file, int line, const char* message, - void* expected, void* actual); +void CuAssertStrEquals_LineMsg(CuTest* tc, + const char* file, int line, const char* message, + const char* expected, const char* actual); +void CuAssertIntEquals_LineMsg(CuTest* tc, + const char* file, int line, const char* message, + int expected, int actual); +void CuAssertDblEquals_LineMsg(CuTest* tc, + const char* file, int line, const char* message, + double expected, double actual, double delta); +void CuAssertPtrEquals_LineMsg(CuTest* tc, + const char* file, int line, const char* message, + void* expected, void* actual); /* public assert functions */ @@ -95,9 +95,9 @@ void CuAssertPtrEquals_LineMsg(CuTest* tc, typedef struct { - int count; - CuTest* list[MAX_TEST_CASES]; - int failCount; + int count; + CuTest* list[MAX_TEST_CASES]; + int failCount; } CuSuite; diff --git a/CuTestTest.c b/CuTestTest.c index 547f119..1a7b01a 100644 --- a/CuTestTest.c +++ b/CuTestTest.c @@ -14,28 +14,28 @@ static void X_CompareAsserts(CuTest* tc, const char *file, int line, const char* message, const char* expected, const char* actual) { - int mismatch; - if (expected == NULL || actual == NULL) { - mismatch = (expected != NULL || actual != NULL); - } else { - const char *front = __FILE__ ":"; - const size_t frontLen = strlen(front); - const size_t expectedLen = strlen(expected); + int mismatch; + if (expected == NULL || actual == NULL) { + mismatch = (expected != NULL || actual != NULL); + } else { + const char *front = __FILE__ ":"; + const size_t frontLen = strlen(front); + const size_t expectedLen = strlen(expected); - const char *matchStr = actual; + const char *matchStr = actual; - mismatch = (strncmp(matchStr, front, frontLen) != 0); - if (!mismatch) { - matchStr = strchr(matchStr + frontLen, ':'); - mismatch |= (matchStr == NULL || strncmp(matchStr, ": ", 2)); - if (!mismatch) { - matchStr += 2; - mismatch |= (strncmp(matchStr, expected, expectedLen) != 0); - } - } - } + mismatch = (strncmp(matchStr, front, frontLen) != 0); + if (!mismatch) { + matchStr = strchr(matchStr + frontLen, ':'); + mismatch |= (matchStr == NULL || strncmp(matchStr, ": ", 2)); + if (!mismatch) { + matchStr += 2; + mismatch |= (strncmp(matchStr, expected, expectedLen) != 0); + } + } + } - CuAssert_Line(tc, file, line, message, !mismatch); + CuAssert_Line(tc, file, line, message, !mismatch); } /*-------------------------------------------------------------------------* @@ -44,88 +44,88 @@ static void X_CompareAsserts(CuTest* tc, const char *file, int line, const char* void TestCuStringNew(CuTest* tc) { - CuString* str = CuStringNew(); - CuAssertTrue(tc, 0 == str->length); - CuAssertTrue(tc, 0 != str->size); - CuAssertStrEquals(tc, "", str->buffer); + CuString* str = CuStringNew(); + CuAssertTrue(tc, 0 == str->length); + CuAssertTrue(tc, 0 != str->size); + CuAssertStrEquals(tc, "", str->buffer); } void TestCuStringAppend(CuTest* tc) { - CuString* str = CuStringNew(); - CuStringAppend(str, "hello"); - CuAssertIntEquals(tc, 5, str->length); - CuAssertStrEquals(tc, "hello", str->buffer); - CuStringAppend(str, " world"); - CuAssertIntEquals(tc, 11, str->length); - CuAssertStrEquals(tc, "hello world", str->buffer); + CuString* str = CuStringNew(); + CuStringAppend(str, "hello"); + CuAssertIntEquals(tc, 5, str->length); + CuAssertStrEquals(tc, "hello", str->buffer); + CuStringAppend(str, " world"); + CuAssertIntEquals(tc, 11, str->length); + CuAssertStrEquals(tc, "hello world", str->buffer); } void TestCuStringAppendNULL(CuTest* tc) { - CuString* str = CuStringNew(); - CuStringAppend(str, NULL); - CuAssertIntEquals(tc, 4, str->length); - CuAssertStrEquals(tc, "NULL", str->buffer); + CuString* str = CuStringNew(); + CuStringAppend(str, NULL); + CuAssertIntEquals(tc, 4, str->length); + CuAssertStrEquals(tc, "NULL", str->buffer); } void TestCuStringAppendChar(CuTest* tc) { - CuString* str = CuStringNew(); - CuStringAppendChar(str, 'a'); - CuStringAppendChar(str, 'b'); - CuStringAppendChar(str, 'c'); - CuStringAppendChar(str, 'd'); - CuAssertIntEquals(tc, 4, str->length); - CuAssertStrEquals(tc, "abcd", str->buffer); + CuString* str = CuStringNew(); + CuStringAppendChar(str, 'a'); + CuStringAppendChar(str, 'b'); + CuStringAppendChar(str, 'c'); + CuStringAppendChar(str, 'd'); + CuAssertIntEquals(tc, 4, str->length); + CuAssertStrEquals(tc, "abcd", str->buffer); } void TestCuStringInserts(CuTest* tc) { - CuString* str = CuStringNew(); - CuStringAppend(str, "world"); - CuAssertIntEquals(tc, 5, str->length); - CuAssertStrEquals(tc, "world", str->buffer); - CuStringInsert(str, "hell", 0); - CuAssertIntEquals(tc, 9, str->length); - CuAssertStrEquals(tc, "hellworld", str->buffer); - CuStringInsert(str, "o ", 4); - CuAssertIntEquals(tc, 11, str->length); - CuAssertStrEquals(tc, "hello world", str->buffer); - CuStringInsert(str, "!", 11); - CuAssertIntEquals(tc, 12, str->length); - CuAssertStrEquals(tc, "hello world!", str->buffer); + CuString* str = CuStringNew(); + CuStringAppend(str, "world"); + CuAssertIntEquals(tc, 5, str->length); + CuAssertStrEquals(tc, "world", str->buffer); + CuStringInsert(str, "hell", 0); + CuAssertIntEquals(tc, 9, str->length); + CuAssertStrEquals(tc, "hellworld", str->buffer); + CuStringInsert(str, "o ", 4); + CuAssertIntEquals(tc, 11, str->length); + CuAssertStrEquals(tc, "hello world", str->buffer); + CuStringInsert(str, "!", 11); + CuAssertIntEquals(tc, 12, str->length); + CuAssertStrEquals(tc, "hello world!", str->buffer); } void TestCuStringResizes(CuTest* tc) { - CuString* str = CuStringNew(); - int i; - for(i = 0 ; i < STRING_MAX ; ++i) - { - CuStringAppend(str, "aa"); - } - CuAssertTrue(tc, STRING_MAX * 2 == str->length); - CuAssertTrue(tc, STRING_MAX * 2 <= str->size); + CuString* str = CuStringNew(); + int i; + for(i = 0 ; i < STRING_MAX ; ++i) + { + CuStringAppend(str, "aa"); + } + CuAssertTrue(tc, STRING_MAX * 2 == str->length); + CuAssertTrue(tc, STRING_MAX * 2 <= str->size); } CuSuite* CuStringGetSuite(void) { - CuSuite* suite = CuSuiteNew(); + CuSuite* suite = CuSuiteNew(); - SUITE_ADD_TEST(suite, TestCuStringNew); - SUITE_ADD_TEST(suite, TestCuStringAppend); - SUITE_ADD_TEST(suite, TestCuStringAppendNULL); - SUITE_ADD_TEST(suite, TestCuStringAppendChar); - SUITE_ADD_TEST(suite, TestCuStringInserts); - SUITE_ADD_TEST(suite, TestCuStringResizes); + SUITE_ADD_TEST(suite, TestCuStringNew); + SUITE_ADD_TEST(suite, TestCuStringAppend); + SUITE_ADD_TEST(suite, TestCuStringAppendNULL); + SUITE_ADD_TEST(suite, TestCuStringAppendChar); + SUITE_ADD_TEST(suite, TestCuStringInserts); + SUITE_ADD_TEST(suite, TestCuStringResizes); - return suite; + return suite; } /*-------------------------------------------------------------------------* @@ -134,126 +134,126 @@ CuSuite* CuStringGetSuite(void) void TestPasses(CuTest* tc) { - CuAssert(tc, "test should pass", 1 == 0 + 1); + CuAssert(tc, "test should pass", 1 == 0 + 1); } void zTestFails(CuTest* tc) { - CuAssert(tc, "test should fail", 1 == 1 + 1); + CuAssert(tc, "test should fail", 1 == 1 + 1); } void TestCuTestNew(CuTest* tc) { - CuTest* tc2 = CuTestNew("MyTest", TestPasses); - CuAssertStrEquals(tc, "MyTest", tc2->name); - CuAssertTrue(tc, !tc2->failed); - CuAssertTrue(tc, tc2->message == NULL); - CuAssertTrue(tc, tc2->function == TestPasses); - CuAssertTrue(tc, tc2->ran == 0); - CuAssertTrue(tc, tc2->jumpBuf == NULL); + CuTest* tc2 = CuTestNew("MyTest", TestPasses); + CuAssertStrEquals(tc, "MyTest", tc2->name); + CuAssertTrue(tc, !tc2->failed); + CuAssertTrue(tc, tc2->message == NULL); + CuAssertTrue(tc, tc2->function == TestPasses); + CuAssertTrue(tc, tc2->ran == 0); + CuAssertTrue(tc, tc2->jumpBuf == NULL); } void TestCuTestInit(CuTest *tc) { - CuTest tc2; - CuTestInit(&tc2, "MyTest", TestPasses); - CuAssertStrEquals(tc, "MyTest", tc2.name); - CuAssertTrue(tc, !tc2.failed); - CuAssertTrue(tc, tc2.message == NULL); - CuAssertTrue(tc, tc2.function == TestPasses); - CuAssertTrue(tc, tc2.ran == 0); - CuAssertTrue(tc, tc2.jumpBuf == NULL); + CuTest tc2; + CuTestInit(&tc2, "MyTest", TestPasses); + CuAssertStrEquals(tc, "MyTest", tc2.name); + CuAssertTrue(tc, !tc2.failed); + CuAssertTrue(tc, tc2.message == NULL); + CuAssertTrue(tc, tc2.function == TestPasses); + CuAssertTrue(tc, tc2.ran == 0); + CuAssertTrue(tc, tc2.jumpBuf == NULL); } void TestCuAssert(CuTest* tc) { - CuTest tc2; - CuTestInit(&tc2, "MyTest", TestPasses); + CuTest tc2; + CuTestInit(&tc2, "MyTest", TestPasses); - CuAssert(&tc2, "test 1", 5 == 4 + 1); - CuAssertTrue(tc, !tc2.failed); - CuAssertTrue(tc, tc2.message == NULL); + CuAssert(&tc2, "test 1", 5 == 4 + 1); + CuAssertTrue(tc, !tc2.failed); + CuAssertTrue(tc, tc2.message == NULL); - CuAssert(&tc2, "test 2", 0); - CuAssertTrue(tc, tc2.failed); - CompareAsserts(tc, "CuAssert didn't fail", "test 2", tc2.message); + CuAssert(&tc2, "test 2", 0); + CuAssertTrue(tc, tc2.failed); + CompareAsserts(tc, "CuAssert didn't fail", "test 2", tc2.message); - CuAssert(&tc2, "test 3", 1); - CuAssertTrue(tc, tc2.failed); - CompareAsserts(tc, "CuAssert didn't fail", "test 2", tc2.message); + CuAssert(&tc2, "test 3", 1); + CuAssertTrue(tc, tc2.failed); + CompareAsserts(tc, "CuAssert didn't fail", "test 2", tc2.message); - CuAssert(&tc2, "test 4", 0); - CuAssertTrue(tc, tc2.failed); - CompareAsserts(tc, "CuAssert didn't fail", "test 4", tc2.message); + CuAssert(&tc2, "test 4", 0); + CuAssertTrue(tc, tc2.failed); + CompareAsserts(tc, "CuAssert didn't fail", "test 4", tc2.message); } void TestCuAssertPtrEquals_Success(CuTest* tc) { - CuTest tc2; - int x; + CuTest tc2; + int x; - CuTestInit(&tc2, "MyTest", TestPasses); + CuTestInit(&tc2, "MyTest", TestPasses); - /* test success case */ - CuAssertPtrEquals(&tc2, &x, &x); - CuAssertTrue(tc, ! tc2.failed); - CuAssertTrue(tc, NULL == tc2.message); + /* test success case */ + CuAssertPtrEquals(&tc2, &x, &x); + CuAssertTrue(tc, ! tc2.failed); + CuAssertTrue(tc, NULL == tc2.message); } void TestCuAssertPtrEquals_Failure(CuTest* tc) { - CuTest tc2; - int x; - int* nullPtr = NULL; - char expected_message[STRING_MAX]; + CuTest tc2; + int x; + int* nullPtr = NULL; + char expected_message[STRING_MAX]; - CuTestInit(&tc2, "MyTest", TestPasses); + CuTestInit(&tc2, "MyTest", TestPasses); - /* test failing case */ - sprintf(expected_message, "expected pointer <0x%p> but was <0x%p>", nullPtr, &x); - CuAssertPtrEquals(&tc2, NULL, &x); - CuAssertTrue(tc, tc2.failed); - CompareAsserts(tc, "CuAssertPtrEquals failed", expected_message, tc2.message); + /* test failing case */ + sprintf(expected_message, "expected pointer <0x%p> but was <0x%p>", nullPtr, &x); + CuAssertPtrEquals(&tc2, NULL, &x); + CuAssertTrue(tc, tc2.failed); + CompareAsserts(tc, "CuAssertPtrEquals failed", expected_message, tc2.message); } void TestCuAssertPtrNotNull_Success(CuTest* tc) { - CuTest tc2; - int x; + CuTest tc2; + int x; - CuTestInit(&tc2, "MyTest", TestPasses); + CuTestInit(&tc2, "MyTest", TestPasses); - /* test success case */ - CuAssertPtrNotNull(&tc2, &x); - CuAssertTrue(tc, ! tc2.failed); - CuAssertTrue(tc, NULL == tc2.message); + /* test success case */ + CuAssertPtrNotNull(&tc2, &x); + CuAssertTrue(tc, ! tc2.failed); + CuAssertTrue(tc, NULL == tc2.message); } void TestCuAssertPtrNotNull_Failure(CuTest* tc) { - CuTest tc2; + CuTest tc2; - CuTestInit(&tc2, "MyTest", TestPasses); + CuTestInit(&tc2, "MyTest", TestPasses); - /* test failing case */ - CuAssertPtrNotNull(&tc2, NULL); - CuAssertTrue(tc, tc2.failed); - CompareAsserts(tc, "CuAssertPtrNotNull failed", "null pointer unexpected", tc2.message); + /* test failing case */ + CuAssertPtrNotNull(&tc2, NULL); + CuAssertTrue(tc, tc2.failed); + CompareAsserts(tc, "CuAssertPtrNotNull failed", "null pointer unexpected", tc2.message); } void TestCuTestRun(CuTest* tc) { - CuTest tc2; - CuTestInit(&tc2, "MyTest", zTestFails); - CuTestRun(&tc2); + CuTest tc2; + CuTestInit(&tc2, "MyTest", zTestFails); + CuTestRun(&tc2); - CuAssertStrEquals(tc, "MyTest", tc2.name); - CuAssertTrue(tc, tc2.failed); - CuAssertTrue(tc, tc2.ran); - CompareAsserts(tc, "TestRun failed", "test should fail", tc2.message); + CuAssertStrEquals(tc, "MyTest", tc2.name); + CuAssertTrue(tc, tc2.failed); + CuAssertTrue(tc, tc2.ran); + CompareAsserts(tc, "TestRun failed", "test should fail", tc2.message); } /*-------------------------------------------------------------------------* @@ -262,220 +262,220 @@ void TestCuTestRun(CuTest* tc) void TestCuSuiteInit(CuTest* tc) { - CuSuite ts; - CuSuiteInit(&ts); - CuAssertTrue(tc, ts.count == 0); - CuAssertTrue(tc, ts.failCount == 0); + CuSuite ts; + CuSuiteInit(&ts); + CuAssertTrue(tc, ts.count == 0); + CuAssertTrue(tc, ts.failCount == 0); } void TestCuSuiteNew(CuTest* tc) { - CuSuite* ts = CuSuiteNew(); - CuAssertTrue(tc, ts->count == 0); - CuAssertTrue(tc, ts->failCount == 0); + CuSuite* ts = CuSuiteNew(); + CuAssertTrue(tc, ts->count == 0); + CuAssertTrue(tc, ts->failCount == 0); } void TestCuSuiteAddTest(CuTest* tc) { - CuSuite ts; - CuTest tc2; + CuSuite ts; + CuTest tc2; - CuSuiteInit(&ts); - CuTestInit(&tc2, "MyTest", zTestFails); + CuSuiteInit(&ts); + CuTestInit(&tc2, "MyTest", zTestFails); - CuSuiteAdd(&ts, &tc2); - CuAssertTrue(tc, ts.count == 1); + CuSuiteAdd(&ts, &tc2); + CuAssertTrue(tc, ts.count == 1); - CuAssertStrEquals(tc, "MyTest", ts.list[0]->name); + CuAssertStrEquals(tc, "MyTest", ts.list[0]->name); } void TestCuSuiteAddSuite(CuTest* tc) { - CuSuite* ts1 = CuSuiteNew(); - CuSuite* ts2 = CuSuiteNew(); + CuSuite* ts1 = CuSuiteNew(); + CuSuite* ts2 = CuSuiteNew(); - CuSuiteAdd(ts1, CuTestNew("TestFails1", zTestFails)); - CuSuiteAdd(ts1, CuTestNew("TestFails2", zTestFails)); + CuSuiteAdd(ts1, CuTestNew("TestFails1", zTestFails)); + CuSuiteAdd(ts1, CuTestNew("TestFails2", zTestFails)); - CuSuiteAdd(ts2, CuTestNew("TestFails3", zTestFails)); - CuSuiteAdd(ts2, CuTestNew("TestFails4", zTestFails)); + CuSuiteAdd(ts2, CuTestNew("TestFails3", zTestFails)); + CuSuiteAdd(ts2, CuTestNew("TestFails4", zTestFails)); - CuSuiteAddSuite(ts1, ts2); - CuAssertIntEquals(tc, 4, ts1->count); + CuSuiteAddSuite(ts1, ts2); + CuAssertIntEquals(tc, 4, ts1->count); - CuAssertStrEquals(tc, "TestFails1", ts1->list[0]->name); - CuAssertStrEquals(tc, "TestFails2", ts1->list[1]->name); - CuAssertStrEquals(tc, "TestFails3", ts1->list[2]->name); - CuAssertStrEquals(tc, "TestFails4", ts1->list[3]->name); + CuAssertStrEquals(tc, "TestFails1", ts1->list[0]->name); + CuAssertStrEquals(tc, "TestFails2", ts1->list[1]->name); + CuAssertStrEquals(tc, "TestFails3", ts1->list[2]->name); + CuAssertStrEquals(tc, "TestFails4", ts1->list[3]->name); } void TestCuSuiteRun(CuTest* tc) { - CuSuite ts; - CuTest tc1, tc2, tc3, tc4; + CuSuite ts; + CuTest tc1, tc2, tc3, tc4; - CuSuiteInit(&ts); - CuTestInit(&tc1, "TestPasses", TestPasses); - CuTestInit(&tc2, "TestPasses", TestPasses); - CuTestInit(&tc3, "TestFails", zTestFails); - CuTestInit(&tc4, "TestFails", zTestFails); + CuSuiteInit(&ts); + CuTestInit(&tc1, "TestPasses", TestPasses); + CuTestInit(&tc2, "TestPasses", TestPasses); + CuTestInit(&tc3, "TestFails", zTestFails); + CuTestInit(&tc4, "TestFails", zTestFails); - CuSuiteAdd(&ts, &tc1); - CuSuiteAdd(&ts, &tc2); - CuSuiteAdd(&ts, &tc3); - CuSuiteAdd(&ts, &tc4); - CuAssertTrue(tc, ts.count == 4); + CuSuiteAdd(&ts, &tc1); + CuSuiteAdd(&ts, &tc2); + CuSuiteAdd(&ts, &tc3); + CuSuiteAdd(&ts, &tc4); + CuAssertTrue(tc, ts.count == 4); - CuSuiteRun(&ts); - CuAssertTrue(tc, ts.count - ts.failCount == 2); - CuAssertTrue(tc, ts.failCount == 2); + CuSuiteRun(&ts); + CuAssertTrue(tc, ts.count - ts.failCount == 2); + CuAssertTrue(tc, ts.failCount == 2); } void TestCuSuiteSummary(CuTest* tc) { - CuSuite ts; - CuTest tc1, tc2; - CuString summary; + CuSuite ts; + CuTest tc1, tc2; + CuString summary; - CuSuiteInit(&ts); - CuTestInit(&tc1, "TestPasses", TestPasses); - CuTestInit(&tc2, "TestFails", zTestFails); - CuStringInit(&summary); + CuSuiteInit(&ts); + CuTestInit(&tc1, "TestPasses", TestPasses); + CuTestInit(&tc2, "TestFails", zTestFails); + CuStringInit(&summary); - CuSuiteAdd(&ts, &tc1); - CuSuiteAdd(&ts, &tc2); - CuSuiteRun(&ts); + CuSuiteAdd(&ts, &tc1); + CuSuiteAdd(&ts, &tc2); + CuSuiteRun(&ts); - CuSuiteSummary(&ts, &summary); + CuSuiteSummary(&ts, &summary); - CuAssertTrue(tc, ts.count == 2); - CuAssertTrue(tc, ts.failCount == 1); - CuAssertStrEquals(tc, ".F\n\n", summary.buffer); + CuAssertTrue(tc, ts.count == 2); + CuAssertTrue(tc, ts.failCount == 1); + CuAssertStrEquals(tc, ".F\n\n", summary.buffer); } void TestCuSuiteDetails_SingleFail(CuTest* tc) { - CuSuite ts; - CuTest tc1, tc2; - CuString details; - const char* front; - const char* back; + CuSuite ts; + CuTest tc1, tc2; + CuString details; + const char* front; + const char* back; - CuSuiteInit(&ts); - CuTestInit(&tc1, "TestPasses", TestPasses); - CuTestInit(&tc2, "TestFails", zTestFails); - CuStringInit(&details); + CuSuiteInit(&ts); + CuTestInit(&tc1, "TestPasses", TestPasses); + CuTestInit(&tc2, "TestFails", zTestFails); + CuStringInit(&details); - CuSuiteAdd(&ts, &tc1); - CuSuiteAdd(&ts, &tc2); - CuSuiteRun(&ts); + CuSuiteAdd(&ts, &tc1); + CuSuiteAdd(&ts, &tc2); + CuSuiteRun(&ts); - CuSuiteDetails(&ts, &details); + CuSuiteDetails(&ts, &details); - CuAssertTrue(tc, ts.count == 2); - CuAssertTrue(tc, ts.failCount == 1); + CuAssertTrue(tc, ts.count == 2); + CuAssertTrue(tc, ts.failCount == 1); - front = "There was 1 failure:\n" - "1) TestFails: "; - back = "test should fail\n" - "\n!!!FAILURES!!!\n" - "Runs: 2 Passes: 1 Fails: 1\n"; + front = "There was 1 failure:\n" + "1) TestFails: "; + back = "test should fail\n" + "\n!!!FAILURES!!!\n" + "Runs: 2 Passes: 1 Fails: 1\n"; - CuAssertStrEquals(tc, back, details.buffer + strlen(details.buffer) - strlen(back)); - details.buffer[strlen(front)] = 0; - CuAssertStrEquals(tc, front, details.buffer); + CuAssertStrEquals(tc, back, details.buffer + strlen(details.buffer) - strlen(back)); + details.buffer[strlen(front)] = 0; + CuAssertStrEquals(tc, front, details.buffer); } void TestCuSuiteDetails_SinglePass(CuTest* tc) { - CuSuite ts; - CuTest tc1; - CuString details; - const char* expected; + CuSuite ts; + CuTest tc1; + CuString details; + const char* expected; - CuSuiteInit(&ts); - CuTestInit(&tc1, "TestPasses", TestPasses); - CuStringInit(&details); + CuSuiteInit(&ts); + CuTestInit(&tc1, "TestPasses", TestPasses); + CuStringInit(&details); - CuSuiteAdd(&ts, &tc1); - CuSuiteRun(&ts); + CuSuiteAdd(&ts, &tc1); + CuSuiteRun(&ts); - CuSuiteDetails(&ts, &details); + CuSuiteDetails(&ts, &details); - CuAssertTrue(tc, ts.count == 1); - CuAssertTrue(tc, ts.failCount == 0); + CuAssertTrue(tc, ts.count == 1); + CuAssertTrue(tc, ts.failCount == 0); - expected = - "OK (1 test)\n"; + expected = + "OK (1 test)\n"; - CuAssertStrEquals(tc, expected, details.buffer); + CuAssertStrEquals(tc, expected, details.buffer); } void TestCuSuiteDetails_MultiplePasses(CuTest* tc) { - CuSuite ts; - CuTest tc1, tc2; - CuString details; - const char* expected; + CuSuite ts; + CuTest tc1, tc2; + CuString details; + const char* expected; - CuSuiteInit(&ts); - CuTestInit(&tc1, "TestPasses", TestPasses); - CuTestInit(&tc2, "TestPasses", TestPasses); - CuStringInit(&details); + CuSuiteInit(&ts); + CuTestInit(&tc1, "TestPasses", TestPasses); + CuTestInit(&tc2, "TestPasses", TestPasses); + CuStringInit(&details); - CuSuiteAdd(&ts, &tc1); - CuSuiteAdd(&ts, &tc2); - CuSuiteRun(&ts); + CuSuiteAdd(&ts, &tc1); + CuSuiteAdd(&ts, &tc2); + CuSuiteRun(&ts); - CuSuiteDetails(&ts, &details); + CuSuiteDetails(&ts, &details); - CuAssertTrue(tc, ts.count == 2); - CuAssertTrue(tc, ts.failCount == 0); + CuAssertTrue(tc, ts.count == 2); + CuAssertTrue(tc, ts.failCount == 0); - expected = - "OK (2 tests)\n"; + expected = + "OK (2 tests)\n"; - CuAssertStrEquals(tc, expected, details.buffer); + CuAssertStrEquals(tc, expected, details.buffer); } void TestCuSuiteDetails_MultipleFails(CuTest* tc) { - CuSuite ts; - CuTest tc1, tc2; - CuString details; - const char* front; - const char* mid; - const char* back; + CuSuite ts; + CuTest tc1, tc2; + CuString details; + const char* front; + const char* mid; + const char* back; - CuSuiteInit(&ts); - CuTestInit(&tc1, "TestFails1", zTestFails); - CuTestInit(&tc2, "TestFails2", zTestFails); - CuStringInit(&details); + CuSuiteInit(&ts); + CuTestInit(&tc1, "TestFails1", zTestFails); + CuTestInit(&tc2, "TestFails2", zTestFails); + CuStringInit(&details); - CuSuiteAdd(&ts, &tc1); - CuSuiteAdd(&ts, &tc2); - CuSuiteRun(&ts); + CuSuiteAdd(&ts, &tc1); + CuSuiteAdd(&ts, &tc2); + CuSuiteRun(&ts); - CuSuiteDetails(&ts, &details); + CuSuiteDetails(&ts, &details); - CuAssertTrue(tc, ts.count == 2); - CuAssertTrue(tc, ts.failCount == 2); + CuAssertTrue(tc, ts.count == 2); + CuAssertTrue(tc, ts.failCount == 2); - front = - "There were 2 failures:\n" - "1) TestFails1: "; - mid = "test should fail\n" - "2) TestFails2: "; - back = "test should fail\n" - "\n!!!FAILURES!!!\n" - "Runs: 2 Passes: 0 Fails: 2\n"; + front = + "There were 2 failures:\n" + "1) TestFails1: "; + mid = "test should fail\n" + "2) TestFails2: "; + back = "test should fail\n" + "\n!!!FAILURES!!!\n" + "Runs: 2 Passes: 0 Fails: 2\n"; - CuAssertStrEquals(tc, back, details.buffer + strlen(details.buffer) - strlen(back)); - CuAssert(tc, "Couldn't find middle", strstr(details.buffer, mid) != NULL); - details.buffer[strlen(front)] = 0; - CuAssertStrEquals(tc, front, details.buffer); + CuAssertStrEquals(tc, back, details.buffer + strlen(details.buffer) - strlen(back)); + CuAssert(tc, "Couldn't find middle", strstr(details.buffer, mid) != NULL); + details.buffer[strlen(front)] = 0; + CuAssertStrEquals(tc, front, details.buffer); } @@ -485,186 +485,186 @@ void TestCuSuiteDetails_MultipleFails(CuTest* tc) void TestCuStrCopy(CuTest* tc) { - const char* old = "hello world"; - const char* newStr = CuStrCopy(old); - CuAssert(tc, "old is new", strcmp(old, newStr) == 0); + const char* old = "hello world"; + const char* newStr = CuStrCopy(old); + CuAssert(tc, "old is new", strcmp(old, newStr) == 0); } void TestCuStringAppendFormat(CuTest* tc) { - int i; - char* text = CuStrAlloc(301); /* long string */ - CuString* str = CuStringNew(); - for (i = 0 ; i < 300 ; ++i) - text[i] = 'a'; - text[300] = '\0'; - CuStringAppendFormat(str, "%s", text); + int i; + char* text = CuStrAlloc(301); /* long string */ + CuString* str = CuStringNew(); + for (i = 0 ; i < 300 ; ++i) + text[i] = 'a'; + text[300] = '\0'; + CuStringAppendFormat(str, "%s", text); - /* buffer limit raised to HUGE_STRING_LEN so no overflow */ + /* buffer limit raised to HUGE_STRING_LEN so no overflow */ - CuAssert(tc, "length of str->buffer is 300", 300 == strlen(str->buffer)); + CuAssert(tc, "length of str->buffer is 300", 300 == strlen(str->buffer)); } void TestFail(CuTest* tc) { - jmp_buf buf; - int pointReached = 0; - CuTest* tc2 = CuTestNew("TestFails", zTestFails); - tc2->jumpBuf = &buf; - if (setjmp(buf) == 0) - { - CuFail(tc2, "hello world"); - pointReached = 1; - } - CuAssert(tc, "point was not reached", pointReached == 0); + jmp_buf buf; + int pointReached = 0; + CuTest* tc2 = CuTestNew("TestFails", zTestFails); + tc2->jumpBuf = &buf; + if (setjmp(buf) == 0) + { + CuFail(tc2, "hello world"); + pointReached = 1; + } + CuAssert(tc, "point was not reached", pointReached == 0); } void TestAssertStrEquals(CuTest* tc) { - jmp_buf buf; - CuTest *tc2 = CuTestNew("TestAssertStrEquals", zTestFails); + jmp_buf buf; + CuTest *tc2 = CuTestNew("TestAssertStrEquals", zTestFails); - const char* expected = "expected but was "; - const char *expectedMsg = "some text: expected but was "; + const char* expected = "expected but was "; + const char *expectedMsg = "some text: expected but was "; - tc2->jumpBuf = &buf; - if (setjmp(buf) == 0) - { - CuAssertStrEquals(tc2, "hello", "world"); - } - CuAssertTrue(tc, tc2->failed); - CompareAsserts(tc, "CuAssertStrEquals failed", expected, tc2->message); - if (setjmp(buf) == 0) - { - CuAssertStrEquals_Msg(tc2, "some text", "hello", "world"); - } - CuAssertTrue(tc, tc2->failed); - CompareAsserts(tc, "CuAssertStrEquals failed", expectedMsg, tc2->message); + tc2->jumpBuf = &buf; + if (setjmp(buf) == 0) + { + CuAssertStrEquals(tc2, "hello", "world"); + } + CuAssertTrue(tc, tc2->failed); + CompareAsserts(tc, "CuAssertStrEquals failed", expected, tc2->message); + if (setjmp(buf) == 0) + { + CuAssertStrEquals_Msg(tc2, "some text", "hello", "world"); + } + CuAssertTrue(tc, tc2->failed); + CompareAsserts(tc, "CuAssertStrEquals failed", expectedMsg, tc2->message); } void TestAssertStrEquals_NULL(CuTest* tc) { - jmp_buf buf; - CuTest *tc2 = CuTestNew("TestAssertStrEquals_NULL", zTestFails); + jmp_buf buf; + CuTest *tc2 = CuTestNew("TestAssertStrEquals_NULL", zTestFails); - tc2->jumpBuf = &buf; - if (setjmp(buf) == 0) - { - CuAssertStrEquals(tc2, NULL, NULL); - } - CuAssertTrue(tc, !tc2->failed); - CompareAsserts(tc, "CuAssertStrEquals_NULL failed", NULL, tc2->message); - if (setjmp(buf) == 0) - { - CuAssertStrEquals_Msg(tc2, "some text", NULL, NULL); - } - CuAssertTrue(tc, !tc2->failed); - CompareAsserts(tc, "CuAssertStrEquals_NULL failed", NULL, tc2->message); + tc2->jumpBuf = &buf; + if (setjmp(buf) == 0) + { + CuAssertStrEquals(tc2, NULL, NULL); + } + CuAssertTrue(tc, !tc2->failed); + CompareAsserts(tc, "CuAssertStrEquals_NULL failed", NULL, tc2->message); + if (setjmp(buf) == 0) + { + CuAssertStrEquals_Msg(tc2, "some text", NULL, NULL); + } + CuAssertTrue(tc, !tc2->failed); + CompareAsserts(tc, "CuAssertStrEquals_NULL failed", NULL, tc2->message); } void TestAssertStrEquals_FailNULLStr(CuTest* tc) { - jmp_buf buf; - CuTest *tc2 = CuTestNew("TestAssertStrEquals_FailNULLStr", zTestFails); + jmp_buf buf; + CuTest *tc2 = CuTestNew("TestAssertStrEquals_FailNULLStr", zTestFails); - const char* expected = "expected but was "; - const char *expectedMsg = "some text: expected but was "; + const char* expected = "expected but was "; + const char *expectedMsg = "some text: expected but was "; - tc2->jumpBuf = &buf; - if (setjmp(buf) == 0) - { - CuAssertStrEquals(tc2, "hello", NULL); - } - CuAssertTrue(tc, tc2->failed); - CompareAsserts(tc, "CuAssertStrEquals_FailNULLStr failed", expected, tc2->message); - if (setjmp(buf) == 0) - { - CuAssertStrEquals_Msg(tc2, "some text", "hello", NULL); - } - CuAssertTrue(tc, tc2->failed); - CompareAsserts(tc, "CuAssertStrEquals_FailNULLStr failed", expectedMsg, tc2->message); + tc2->jumpBuf = &buf; + if (setjmp(buf) == 0) + { + CuAssertStrEquals(tc2, "hello", NULL); + } + CuAssertTrue(tc, tc2->failed); + CompareAsserts(tc, "CuAssertStrEquals_FailNULLStr failed", expected, tc2->message); + if (setjmp(buf) == 0) + { + CuAssertStrEquals_Msg(tc2, "some text", "hello", NULL); + } + CuAssertTrue(tc, tc2->failed); + CompareAsserts(tc, "CuAssertStrEquals_FailNULLStr failed", expectedMsg, tc2->message); } void TestAssertStrEquals_FailStrNULL(CuTest* tc) { - jmp_buf buf; - CuTest *tc2 = CuTestNew("TestAssertStrEquals_FailStrNULL", zTestFails); + jmp_buf buf; + CuTest *tc2 = CuTestNew("TestAssertStrEquals_FailStrNULL", zTestFails); - const char* expected = "expected but was "; - const char *expectedMsg = "some text: expected but was "; + const char* expected = "expected but was "; + const char *expectedMsg = "some text: expected but was "; - tc2->jumpBuf = &buf; - if (setjmp(buf) == 0) - { - CuAssertStrEquals(tc2, NULL, "hello"); - } - CuAssertTrue(tc, tc2->failed); - CompareAsserts(tc, "CuAssertStrEquals_FailStrNULL failed", expected, tc2->message); - if (setjmp(buf) == 0) - { - CuAssertStrEquals_Msg(tc2, "some text", NULL, "hello"); - } - CuAssertTrue(tc, tc2->failed); - CompareAsserts(tc, "CuAssertStrEquals_FailStrNULL failed", expectedMsg, tc2->message); + tc2->jumpBuf = &buf; + if (setjmp(buf) == 0) + { + CuAssertStrEquals(tc2, NULL, "hello"); + } + CuAssertTrue(tc, tc2->failed); + CompareAsserts(tc, "CuAssertStrEquals_FailStrNULL failed", expected, tc2->message); + if (setjmp(buf) == 0) + { + CuAssertStrEquals_Msg(tc2, "some text", NULL, "hello"); + } + CuAssertTrue(tc, tc2->failed); + CompareAsserts(tc, "CuAssertStrEquals_FailStrNULL failed", expectedMsg, tc2->message); } void TestAssertIntEquals(CuTest* tc) { - jmp_buf buf; - CuTest *tc2 = CuTestNew("TestAssertIntEquals", zTestFails); - const char* expected = "expected <42> but was <32>"; - const char* expectedMsg = "some text: expected <42> but was <32>"; - tc2->jumpBuf = &buf; - if (setjmp(buf) == 0) - { - CuAssertIntEquals(tc2, 42, 32); - } - CuAssertTrue(tc, tc2->failed); - CompareAsserts(tc, "CuAssertIntEquals failed", expected, tc2->message); - if (setjmp(buf) == 0) - { - CuAssertIntEquals_Msg(tc2, "some text", 42, 32); - } - CuAssertTrue(tc, tc2->failed); - CompareAsserts(tc, "CuAssertStrEquals failed", expectedMsg, tc2->message); + jmp_buf buf; + CuTest *tc2 = CuTestNew("TestAssertIntEquals", zTestFails); + const char* expected = "expected <42> but was <32>"; + const char* expectedMsg = "some text: expected <42> but was <32>"; + tc2->jumpBuf = &buf; + if (setjmp(buf) == 0) + { + CuAssertIntEquals(tc2, 42, 32); + } + CuAssertTrue(tc, tc2->failed); + CompareAsserts(tc, "CuAssertIntEquals failed", expected, tc2->message); + if (setjmp(buf) == 0) + { + CuAssertIntEquals_Msg(tc2, "some text", 42, 32); + } + CuAssertTrue(tc, tc2->failed); + CompareAsserts(tc, "CuAssertStrEquals failed", expectedMsg, tc2->message); } void TestAssertDblEquals(CuTest* tc) { - jmp_buf buf; - double x = 3.33; - double y = 10.0 / 3.0; - CuTest *tc2 = CuTestNew("TestAssertDblEquals", zTestFails); - char expected[STRING_MAX]; - char expectedMsg[STRING_MAX]; - sprintf(expected, "expected <%lf> but was <%lf>", x, y); - sprintf(expectedMsg, "some text: expected <%lf> but was <%lf>", x, y); + jmp_buf buf; + double x = 3.33; + double y = 10.0 / 3.0; + CuTest *tc2 = CuTestNew("TestAssertDblEquals", zTestFails); + char expected[STRING_MAX]; + char expectedMsg[STRING_MAX]; + sprintf(expected, "expected <%lf> but was <%lf>", x, y); + sprintf(expectedMsg, "some text: expected <%lf> but was <%lf>", x, y); - CuTestInit(tc2, "TestAssertDblEquals", TestPasses); + CuTestInit(tc2, "TestAssertDblEquals", TestPasses); - CuAssertDblEquals(tc2, x, x, 0.0); - CuAssertTrue(tc, ! tc2->failed); - CuAssertTrue(tc, NULL == tc2->message); + CuAssertDblEquals(tc2, x, x, 0.0); + CuAssertTrue(tc, ! tc2->failed); + CuAssertTrue(tc, NULL == tc2->message); - CuAssertDblEquals(tc2, x, y, 0.01); - CuAssertTrue(tc, ! tc2->failed); - CuAssertTrue(tc, NULL == tc2->message); + CuAssertDblEquals(tc2, x, y, 0.01); + CuAssertTrue(tc, ! tc2->failed); + CuAssertTrue(tc, NULL == tc2->message); - tc2->jumpBuf = &buf; - if (setjmp(buf) == 0) - { - CuAssertDblEquals(tc2, x, y, 0.001); - } - CuAssertTrue(tc, tc2->failed); - CompareAsserts(tc, "CuAssertDblEquals failed", expected, tc2->message); - tc2->jumpBuf = &buf; - if (setjmp(buf) == 0) - { - CuAssertDblEquals_Msg(tc2, "some text", x, y, 0.001); - } - CuAssertTrue(tc, tc2->failed); - CompareAsserts(tc, "CuAssertDblEquals failed", expectedMsg, tc2->message); + tc2->jumpBuf = &buf; + if (setjmp(buf) == 0) + { + CuAssertDblEquals(tc2, x, y, 0.001); + } + CuAssertTrue(tc, tc2->failed); + CompareAsserts(tc, "CuAssertDblEquals failed", expected, tc2->message); + tc2->jumpBuf = &buf; + if (setjmp(buf) == 0) + { + CuAssertDblEquals_Msg(tc2, "some text", x, y, 0.001); + } + CuAssertTrue(tc, tc2->failed); + CompareAsserts(tc, "CuAssertDblEquals failed", expectedMsg, tc2->message); } /*-------------------------------------------------------------------------* @@ -673,37 +673,37 @@ void TestAssertDblEquals(CuTest* tc) CuSuite* CuGetSuite(void) { - CuSuite* suite = CuSuiteNew(); + CuSuite* suite = CuSuiteNew(); - SUITE_ADD_TEST(suite, TestCuStringAppendFormat); - SUITE_ADD_TEST(suite, TestCuStrCopy); - SUITE_ADD_TEST(suite, TestFail); - SUITE_ADD_TEST(suite, TestAssertStrEquals); - SUITE_ADD_TEST(suite, TestAssertStrEquals_NULL); - SUITE_ADD_TEST(suite, TestAssertStrEquals_FailStrNULL); - SUITE_ADD_TEST(suite, TestAssertStrEquals_FailNULLStr); - SUITE_ADD_TEST(suite, TestAssertIntEquals); - SUITE_ADD_TEST(suite, TestAssertDblEquals); + SUITE_ADD_TEST(suite, TestCuStringAppendFormat); + SUITE_ADD_TEST(suite, TestCuStrCopy); + SUITE_ADD_TEST(suite, TestFail); + SUITE_ADD_TEST(suite, TestAssertStrEquals); + SUITE_ADD_TEST(suite, TestAssertStrEquals_NULL); + SUITE_ADD_TEST(suite, TestAssertStrEquals_FailStrNULL); + SUITE_ADD_TEST(suite, TestAssertStrEquals_FailNULLStr); + SUITE_ADD_TEST(suite, TestAssertIntEquals); + SUITE_ADD_TEST(suite, TestAssertDblEquals); - SUITE_ADD_TEST(suite, TestCuTestNew); - SUITE_ADD_TEST(suite, TestCuTestInit); - SUITE_ADD_TEST(suite, TestCuAssert); - SUITE_ADD_TEST(suite, TestCuAssertPtrEquals_Success); - SUITE_ADD_TEST(suite, TestCuAssertPtrEquals_Failure); - SUITE_ADD_TEST(suite, TestCuAssertPtrNotNull_Success); - SUITE_ADD_TEST(suite, TestCuAssertPtrNotNull_Failure); - SUITE_ADD_TEST(suite, TestCuTestRun); + SUITE_ADD_TEST(suite, TestCuTestNew); + SUITE_ADD_TEST(suite, TestCuTestInit); + SUITE_ADD_TEST(suite, TestCuAssert); + SUITE_ADD_TEST(suite, TestCuAssertPtrEquals_Success); + SUITE_ADD_TEST(suite, TestCuAssertPtrEquals_Failure); + SUITE_ADD_TEST(suite, TestCuAssertPtrNotNull_Success); + SUITE_ADD_TEST(suite, TestCuAssertPtrNotNull_Failure); + SUITE_ADD_TEST(suite, TestCuTestRun); - SUITE_ADD_TEST(suite, TestCuSuiteInit); - SUITE_ADD_TEST(suite, TestCuSuiteNew); - SUITE_ADD_TEST(suite, TestCuSuiteAddTest); - SUITE_ADD_TEST(suite, TestCuSuiteAddSuite); - SUITE_ADD_TEST(suite, TestCuSuiteRun); - SUITE_ADD_TEST(suite, TestCuSuiteSummary); - SUITE_ADD_TEST(suite, TestCuSuiteDetails_SingleFail); - SUITE_ADD_TEST(suite, TestCuSuiteDetails_SinglePass); - SUITE_ADD_TEST(suite, TestCuSuiteDetails_MultiplePasses); - SUITE_ADD_TEST(suite, TestCuSuiteDetails_MultipleFails); + SUITE_ADD_TEST(suite, TestCuSuiteInit); + SUITE_ADD_TEST(suite, TestCuSuiteNew); + SUITE_ADD_TEST(suite, TestCuSuiteAddTest); + SUITE_ADD_TEST(suite, TestCuSuiteAddSuite); + SUITE_ADD_TEST(suite, TestCuSuiteRun); + SUITE_ADD_TEST(suite, TestCuSuiteSummary); + SUITE_ADD_TEST(suite, TestCuSuiteDetails_SingleFail); + SUITE_ADD_TEST(suite, TestCuSuiteDetails_SinglePass); + SUITE_ADD_TEST(suite, TestCuSuiteDetails_MultiplePasses); + SUITE_ADD_TEST(suite, TestCuSuiteDetails_MultipleFails); - return suite; + return suite; } diff --git a/make-tests.sh b/make-tests.sh index 3988c5e..5aad7bf 100755 --- a/make-tests.sh +++ b/make-tests.sh @@ -18,28 +18,28 @@ echo ' ' -cat $FILES | grep '^void Test' | +cat $FILES | grep '^void Test' | sed -e 's/(.*$//' \ -e 's/$/(CuTest*);/' \ -e 's/^/extern /' echo \ -' + ' -void RunAllTests(void) +void RunAllTests(void) { CuString *output = CuStringNew(); CuSuite* suite = CuSuiteNew(); ' -cat $FILES | grep '^void Test' | +cat $FILES | grep '^void Test' | sed -e 's/^void //' \ -e 's/(.*$//' \ -e 's/^/ SUITE_ADD_TEST(suite, /' \ -e 's/$/);/' echo \ -' + ' CuSuiteRun(suite); CuSuiteSummary(suite, output); CuSuiteDetails(suite, output); diff --git a/style.css b/style.css index 072d888..dee60cf 100644 --- a/style.css +++ b/style.css @@ -1,21 +1,21 @@ -BODY { - font-family: "Verdana,Arial,sans-serif"; - font-size: 10pt; +BODY { + font-family: "Verdana,Arial,sans-serif"; + font-size: 10pt; } PRE.LIST { - background: #CFD9FF; - border: 1ex solid #AAAAE6; - padding: 1ex; + background: #CFD9FF; + border: 1ex solid #AAAAE6; + padding: 1ex; } PRE.SNIP { - background: #CFD9FF; - padding: 1ex; + background: #CFD9FF; + padding: 1ex; } PRE.CONSOLE { - color: #CCCCCC; - background: #000000; - font-family: "Courier New,Courier"; - padding: 1ex; + color: #CCCCCC; + background: #000000; + font-family: "Courier New,Courier"; + padding: 1ex; }