42 #include "CUnit/Basic.h" 79 static int TestCompareN(
const char* actual,
const char* expected,
size_t count)
83 if ((! actual) && (! expected)) {
86 else if (actual && (! expected)) {
89 else if ((! actual) && expected) {
93 ok = (memcmp(actual, expected, count) == 0);
99 static int TestCompare(
const char* actual,
const char* expected)
103 if ((! actual) && (! expected)) {
106 else if (actual && (! expected)) {
109 else if ((! actual) && expected) {
113 ok = (strcmp(actual, expected) == 0);
138 static void TestStrStrdupExecute(
const char* test)
141 CU_ASSERT_TRUE(TestCompare(testdup, test == NULL ?
"" : test));
147 static void TestStrStrdup(
void)
149 TestStrStrdupExecute(NULL);
150 TestStrStrdupExecute(
"");
151 TestStrStrdupExecute(
" ");
152 TestStrStrdupExecute(
"a test string");
159 static void TestStrStrncpyExecute(
const char* test,
const char* expected,
164 CU_ASSERT_TRUE(TestCompare(dest, expected));
168 static void TestStrStrncpy(
void)
171 static const char* TEST =
"A dummy string";
173 TestStrStrncpyExecute(
"alpha",
"alpha", 100);
174 TestStrStrncpyExecute(
"beta",
"beta", 5);
175 TestStrStrncpyExecute(
"gamma",
"gamm", 5);
176 TestStrStrncpyExecute(
"delta",
"d", 2);
177 TestStrStrncpyExecute(
"epsilon",
"", 1);
183 CU_ASSERT_STRING_EQUAL(dummy,
"");
187 CU_ASSERT_STRING_EQUAL(dummy, TEST);
201 static void TestStrStrncatExecute(
const char* dst,
const char* src,
202 size_t dstlen,
const char* expected)
211 CU_ASSERT_TRUE(TestCompare(newdst, expected));
216 static void TestStrStrncat(
void)
218 TestStrStrncatExecute(
"alpha",
"beta", 100,
"alphabeta");
219 TestStrStrncatExecute(
"alpha",
"beta", 6,
"alpha");
220 TestStrStrncatExecute(
"alpha",
"beta", 7,
"alphab");
221 TestStrStrncatExecute(
"alpha",
"beta", 8,
"alphabe");
222 TestStrStrncatExecute(
"alpha",
"beta", 9,
"alphabet");
223 TestStrStrncatExecute(
"alpha",
"beta", 10,
"alphabeta");
224 TestStrStrncatExecute(
"alpha",
"beta", 11,
"alphabeta");
226 TestStrStrncatExecute(
"alpha ",
"beta", 9,
"alpha be");
227 TestStrStrncatExecute(
"alpha ",
"beta", 10,
"alpha bet");
228 TestStrStrncatExecute(
"alpha ",
"beta", 11,
"alpha beta");
229 TestStrStrncatExecute(
"alpha ",
"beta", 12,
"alpha beta");
231 TestStrStrncatExecute(
"",
"beta", 1,
"");
232 TestStrStrncatExecute(
"",
"beta", 2,
"b");
233 TestStrStrncatExecute(
"",
"beta", 3,
"be");
234 TestStrStrncatExecute(
"",
"beta", 4,
"bet");
235 TestStrStrncatExecute(
"",
"beta", 5,
"beta");
236 TestStrStrncatExecute(
"",
"beta", 6,
"beta");
238 TestStrStrncatExecute(NULL,
"gamma", 6, NULL);
245 static void TestStrUncommentExecute(
const char* test,
const char* expected)
247 char* testdup = test ? strdup(test) : NULL;
250 CU_ASSERT_TRUE(TestCompare(testdup, expected));
257 static void TestStrUncomment(
void)
259 TestStrUncommentExecute(NULL, NULL);
260 TestStrUncommentExecute(
"",
"");
261 TestStrUncommentExecute(
" \t ",
" \t ");
262 TestStrUncommentExecute(
"This is a string with a #comment",
263 "This is a string with a ");
264 TestStrUncommentExecute(
"This is a string with a # ## comment",
265 "This is a string with a ");
266 TestStrUncommentExecute(
"#This is a leading comment",
"");
267 TestStrUncommentExecute(
"\t\t#comment",
"\t\t");
268 TestStrUncommentExecute(
"A string with no comment",
269 "A string with no comment");
276 static void TestStrWhitespaceExecute(
const char* test,
const char* expected)
278 char* testdup = test ? strdup(test) : NULL;
281 CU_ASSERT_TRUE(TestCompare(testdup, expected));
288 static void TestStrWhitespace(
void)
290 TestStrWhitespaceExecute(NULL, NULL);
291 TestStrWhitespaceExecute(
"",
"");
292 TestStrWhitespaceExecute(
" \t ",
" ");
293 TestStrWhitespaceExecute(
" \r\n",
" ");
294 TestStrWhitespaceExecute(
"A\tstring\twith\tembedded\ttabs",
295 "A string with embedded tabs");
296 TestStrWhitespaceExecute(
"no_whitespace",
"no_whitespace");
297 TestStrWhitespaceExecute(
"\r\nwhitespace\t\t",
" whitespace ");
304 static void TestStrTrimRExecute(
const char* test,
const char* expected)
306 char* testdup = test ? strdup(test) : NULL;
309 CU_ASSERT_TRUE(TestCompare(testdup, expected));
316 static void TestStrTrimR(
void)
318 TestStrTrimRExecute(NULL, NULL);
319 TestStrTrimRExecute(
"",
"");
320 TestStrTrimRExecute(
"\t\tabc",
"\t\tabc");
321 TestStrTrimRExecute(
"abc\t\t",
"abc");
322 TestStrTrimRExecute(
" alpha ",
" alpha");
323 TestStrTrimRExecute(
" alpha beta\n",
" alpha beta");
330 static void TestStrTrimLExecute(
const char* test,
const char* expected)
332 char* testdup = test ? strdup(test) : NULL;
335 CU_ASSERT_TRUE(TestCompare(trimmed, expected));
342 static void TestStrTrimL(
void)
344 TestStrTrimLExecute(NULL, NULL);
345 TestStrTrimLExecute(
"",
"");
346 TestStrTrimLExecute(
"\t\tabc",
"abc");
347 TestStrTrimLExecute(
"abc\t\t",
"abc\t\t");
348 TestStrTrimLExecute(
" alpha ",
"alpha ");
349 TestStrTrimLExecute(
" alpha beta\n",
"alpha beta\n");
356 static void TestStrTrimExecute(
const char* test,
const char* expected)
358 char* testdup = test ? strdup(test) : NULL;
360 char* modstr =
StrTrim(testdup);
361 CU_ASSERT_TRUE(TestCompare(modstr, expected));
368 static void TestStrTrim(
void)
370 TestStrTrimExecute(NULL, NULL);
371 TestStrTrimExecute(
"",
"");
372 TestStrTrimExecute(
"\t\tabc",
"abc");
373 TestStrTrimExecute(
"abc\t\t",
"abc");
374 TestStrTrimExecute(
" alpha ",
"alpha");
375 TestStrTrimExecute(
" alpha beta\n",
"alpha beta");
382 static void TestStrToLowerExecute(
const char* test,
const char* expected)
384 char* testdup = test ? strdup(test) : NULL;
387 CU_ASSERT_TRUE(TestCompare(testdup, expected));
389 CU_ASSERT_EQUAL(length, strlen(expected));
392 CU_ASSERT_EQUAL(length, 0);
400 static void TestStrToLower(
void)
402 TestStrToLowerExecute(NULL, NULL);
403 TestStrToLowerExecute(
"abc",
"abc");
404 TestStrToLowerExecute(
"ABC",
"abc");
405 TestStrToLowerExecute(
"AbC",
"abc");
406 TestStrToLowerExecute(
"AbC d e F",
"abc d e f");
414 static void TestStrToUpperExecute(
const char* test,
const char* expected)
416 char* testdup = test ? strdup(test) : NULL;
419 CU_ASSERT_TRUE(TestCompare(testdup, expected));
421 CU_ASSERT_EQUAL(length, strlen(expected));
424 CU_ASSERT_EQUAL(length, 0);
432 static void TestStrToUpper(
void)
434 TestStrToUpperExecute(NULL, NULL);
435 TestStrToUpperExecute(
"abc",
"ABC");
436 TestStrToUpperExecute(
"ABC",
"ABC");
437 TestStrToUpperExecute(
"AbC",
"ABC");
438 TestStrToUpperExecute(
"AbC d e F",
"ABC D E F");
446 static void TestStrReplaceCharExecute(
const char* test,
const char* expected,
447 char search,
char replace,
int expected_count)
449 char* testdup = test ? strdup(test) : NULL;
452 CU_ASSERT_TRUE(TestCompare(testdup, expected));
453 CU_ASSERT_EQUAL(count, expected_count);
460 static void TestStrReplaceChar(
void)
462 TestStrReplaceCharExecute(NULL, NULL,
'a',
'b', 0);
463 TestStrReplaceCharExecute(
"ABCDEF",
"ABCDEF",
'a',
'b', 0);
464 TestStrReplaceCharExecute(
",abc",
"@abc",
',',
'@', 1);
465 TestStrReplaceCharExecute(
"abc,",
"abc@",
',',
'@', 1);
466 TestStrReplaceCharExecute(
",abc,",
"@abc@",
',',
'@', 2);
467 TestStrReplaceCharExecute(
"ab,c",
"ab@c",
',',
'@', 1);
468 TestStrReplaceCharExecute(
"abacadae",
"ebecedee",
'a',
'e', 4);
476 static void TestStrReplaceCharNExecute(
const char* test,
size_t testlen,
477 const char* expected,
char search,
char replace,
int expected_count)
480 char* testdup = NULL;
484 memcpy(testdup, test, testlen);
485 testdup[testlen] =
'\0';
489 CU_ASSERT_TRUE(TestCompareN(testdup, expected, testlen));
490 CU_ASSERT_EQUAL(count, expected_count);
498 static void TestStrReplaceCharN(
void)
500 TestStrReplaceCharNExecute(NULL, 5, NULL,
'a',
'b', 0);
501 TestStrReplaceCharNExecute(
"ABCDEF", 6,
"ABCDEF",
'a',
'b', 0);
502 TestStrReplaceCharNExecute(
"ABCDEF", 6,
"BBCDEF",
'A',
'B', 1);
503 TestStrReplaceCharNExecute(
"ABC\0EF", 6,
"ABCCEF",
'\0',
'C', 1);
504 TestStrReplaceCharNExecute(
"ABC\0EF\0", 7,
"ABCCEFC",
'\0',
'C', 2);
505 TestStrReplaceCharNExecute(
"\0", 1,
" ",
'\0',
' ', 1);
513 static void TestStrTrimmedLengthExecute(
const char* test,
size_t expected)
520 static void TestStrTrimmedLength(
void)
522 TestStrTrimmedLengthExecute(NULL, 0);
523 TestStrTrimmedLengthExecute(
"", 0);
524 TestStrTrimmedLengthExecute(
" ", 0);
525 TestStrTrimmedLengthExecute(
"\n\n\r\t", 0);
526 TestStrTrimmedLengthExecute(
"abc", 3);
527 TestStrTrimmedLengthExecute(
" abc", 3);
528 TestStrTrimmedLengthExecute(
"defg \n", 4);
529 TestStrTrimmedLengthExecute(
"\t\tabcdef\t ", 6);
530 TestStrTrimmedLengthExecute(
" abcdefg ", 7);
531 TestStrTrimmedLengthExecute(
" a b c d e f ", 11);
532 TestStrTrimmedLengthExecute(
" a\r\tb", 4);
533 TestStrTrimmedLengthExecute(
" xy zzy ", 6);
558 {
"StrReplaceCharN", TestStrReplaceCharN},
559 {
"StrReplaceChar", TestStrReplaceChar},
560 {
"StrStrdup", TestStrStrdup},
561 {
"StrStrncpy", TestStrStrncpy},
562 {
"StrStrncat", TestStrStrncat},
563 {
"StrToLower", TestStrToLower},
564 {
"StrToUpper", TestStrToUpper},
565 {
"StrTrimL", TestStrTrimL},
566 {
"StrTrimR", TestStrTrimR},
567 {
"StrTrim", TestStrTrim},
568 {
"StrTrimmedLength",TestStrTrimmedLength},
569 {
"StrUncomment", TestStrUncomment},
570 {
"StrWhitespace", TestStrWhitespace},
int TcuCreateSuite(const char *title, int(*init)(), int(*teardown)(), struct test_testdef *tests)
void StrWhitespace(char *line)
char * StrStrdup(const char *string)
void StrStrncpy(char *dest, const char *src, size_t destlen)
void StrStrncat(char *dest, const char *src, size_t destlen)
void StrTrimR(char *text)
size_t StrToLower(char *text)
size_t StrReplaceChar(char *string, char search, char replace)
void StrUncomment(char *line)
char * StrTrimL(char *text)
size_t StrReplaceCharN(char *string, size_t len, char search, char replace)
size_t StrTrimmedLength(const char *string)
char * StrTrim(char *text)
void * MemMalloc(size_t size)
size_t StrToUpper(char *text)