44 #include "CUnit/Basic.h"
81 static int TestCompareN(
const char* actual,
const char* expected,
size_t count)
85 if ((! actual) && (! expected)) {
88 else if (actual && (! expected)) {
91 else if ((! actual) && expected) {
95 ok = (memcmp(actual, expected, count) == 0);
101 static int TestCompare(
const char* actual,
const char* expected)
105 if ((! actual) && (! expected)) {
108 else if (actual && (! expected)) {
111 else if ((! actual) && expected) {
115 ok = (strcmp(actual, expected) == 0);
140 static void TestStrStrdupExecute(
const char* test)
143 CU_ASSERT_TRUE(TestCompare(testdup, test == NULL ?
"" : test));
149 static void TestStrStrdup(
void)
151 TestStrStrdupExecute(NULL);
152 TestStrStrdupExecute(
"");
153 TestStrStrdupExecute(
" ");
154 TestStrStrdupExecute(
"a test string");
161 static void TestStrStrncpyExecute(
const char* test,
const char* expected,
166 CU_ASSERT_TRUE(TestCompare(dest, expected));
170 static void TestStrStrncpy(
void)
173 static const char* TEST =
"A dummy string";
175 TestStrStrncpyExecute(
"alpha",
"alpha", 100);
176 TestStrStrncpyExecute(
"beta",
"beta", 5);
177 TestStrStrncpyExecute(
"gamma",
"gamm", 5);
178 TestStrStrncpyExecute(
"delta",
"d", 2);
179 TestStrStrncpyExecute(
"epsilon",
"", 1);
185 CU_ASSERT_STRING_EQUAL(dummy,
"");
189 CU_ASSERT_STRING_EQUAL(dummy, TEST);
203 static void TestStrStrncatExecute(
const char* dst,
const char* src,
204 size_t dstlen,
const char* expected)
213 CU_ASSERT_TRUE(TestCompare(newdst, expected));
218 static void TestStrStrncat(
void)
220 TestStrStrncatExecute(
"alpha",
"beta", 100,
"alphabeta");
221 TestStrStrncatExecute(
"alpha",
"beta", 6,
"alpha");
222 TestStrStrncatExecute(
"alpha",
"beta", 7,
"alphab");
223 TestStrStrncatExecute(
"alpha",
"beta", 8,
"alphabe");
224 TestStrStrncatExecute(
"alpha",
"beta", 9,
"alphabet");
225 TestStrStrncatExecute(
"alpha",
"beta", 10,
"alphabeta");
226 TestStrStrncatExecute(
"alpha",
"beta", 11,
"alphabeta");
228 TestStrStrncatExecute(
"alpha ",
"beta", 9,
"alpha be");
229 TestStrStrncatExecute(
"alpha ",
"beta", 10,
"alpha bet");
230 TestStrStrncatExecute(
"alpha ",
"beta", 11,
"alpha beta");
231 TestStrStrncatExecute(
"alpha ",
"beta", 12,
"alpha beta");
233 TestStrStrncatExecute(
"",
"beta", 1,
"");
234 TestStrStrncatExecute(
"",
"beta", 2,
"b");
235 TestStrStrncatExecute(
"",
"beta", 3,
"be");
236 TestStrStrncatExecute(
"",
"beta", 4,
"bet");
237 TestStrStrncatExecute(
"",
"beta", 5,
"beta");
238 TestStrStrncatExecute(
"",
"beta", 6,
"beta");
240 TestStrStrncatExecute(NULL,
"gamma", 6, NULL);
247 static void TestStrUncommentExecute(
const char* test,
const char* expected)
249 char* testdup = test ? strdup(test) : NULL;
252 CU_ASSERT_TRUE(TestCompare(testdup, expected));
259 static void TestStrUncomment(
void)
261 TestStrUncommentExecute(NULL, NULL);
262 TestStrUncommentExecute(
"",
"");
263 TestStrUncommentExecute(
" \t ",
" \t ");
264 TestStrUncommentExecute(
"This is a string with a #comment",
265 "This is a string with a ");
266 TestStrUncommentExecute(
"This is a string with a # ## comment",
267 "This is a string with a ");
268 TestStrUncommentExecute(
"#This is a leading comment",
"");
269 TestStrUncommentExecute(
"\t\t#comment",
"\t\t");
270 TestStrUncommentExecute(
"A string with no comment",
271 "A string with no comment");
278 static void TestStrWhitespaceExecute(
const char* test,
const char* expected)
280 char* testdup = test ? strdup(test) : NULL;
283 CU_ASSERT_TRUE(TestCompare(testdup, expected));
290 static void TestStrWhitespace(
void)
292 TestStrWhitespaceExecute(NULL, NULL);
293 TestStrWhitespaceExecute(
"",
"");
294 TestStrWhitespaceExecute(
" \t ",
" ");
295 TestStrWhitespaceExecute(
" \r\n",
" ");
296 TestStrWhitespaceExecute(
"A\tstring\twith\tembedded\ttabs",
297 "A string with embedded tabs");
298 TestStrWhitespaceExecute(
"no_whitespace",
"no_whitespace");
299 TestStrWhitespaceExecute(
"\r\nwhitespace\t\t",
" whitespace ");
306 static void TestStrTrimRExecute(
const char* test,
const char* expected)
308 char* testdup = test ? strdup(test) : NULL;
311 CU_ASSERT_TRUE(TestCompare(testdup, expected));
318 static void TestStrTrimR(
void)
320 TestStrTrimRExecute(NULL, NULL);
321 TestStrTrimRExecute(
"",
"");
322 TestStrTrimRExecute(
"\t\tabc",
"\t\tabc");
323 TestStrTrimRExecute(
"abc\t\t",
"abc");
324 TestStrTrimRExecute(
" alpha ",
" alpha");
325 TestStrTrimRExecute(
" alpha beta\n",
" alpha beta");
332 static void TestStrTrimLExecute(
const char* test,
const char* expected)
334 char* testdup = test ? strdup(test) : NULL;
337 CU_ASSERT_TRUE(TestCompare(trimmed, expected));
344 static void TestStrTrimL(
void)
346 TestStrTrimLExecute(NULL, NULL);
347 TestStrTrimLExecute(
"",
"");
348 TestStrTrimLExecute(
"\t\tabc",
"abc");
349 TestStrTrimLExecute(
"abc\t\t",
"abc\t\t");
350 TestStrTrimLExecute(
" alpha ",
"alpha ");
351 TestStrTrimLExecute(
" alpha beta\n",
"alpha beta\n");
358 static void TestStrTrimExecute(
const char* test,
const char* expected)
360 char* testdup = test ? strdup(test) : NULL;
362 char* modstr =
StrTrim(testdup);
363 CU_ASSERT_TRUE(TestCompare(modstr, expected));
370 static void TestStrTrim(
void)
372 TestStrTrimExecute(NULL, NULL);
373 TestStrTrimExecute(
"",
"");
374 TestStrTrimExecute(
"\t\tabc",
"abc");
375 TestStrTrimExecute(
"abc\t\t",
"abc");
376 TestStrTrimExecute(
" alpha ",
"alpha");
377 TestStrTrimExecute(
" alpha beta\n",
"alpha beta");
384 static void TestStrToLowerExecute(
const char* test,
const char* expected)
386 char* testdup = test ? strdup(test) : NULL;
389 CU_ASSERT_TRUE(TestCompare(testdup, expected));
391 CU_ASSERT_EQUAL(length, strlen(expected));
394 CU_ASSERT_EQUAL(length, 0);
402 static void TestStrToLower(
void)
404 TestStrToLowerExecute(NULL, NULL);
405 TestStrToLowerExecute(
"abc",
"abc");
406 TestStrToLowerExecute(
"ABC",
"abc");
407 TestStrToLowerExecute(
"AbC",
"abc");
408 TestStrToLowerExecute(
"AbC d e F",
"abc d e f");
416 static void TestStrToUpperExecute(
const char* test,
const char* expected)
418 char* testdup = test ? strdup(test) : NULL;
421 CU_ASSERT_TRUE(TestCompare(testdup, expected));
423 CU_ASSERT_EQUAL(length, strlen(expected));
426 CU_ASSERT_EQUAL(length, 0);
434 static void TestStrToUpper(
void)
436 TestStrToUpperExecute(NULL, NULL);
437 TestStrToUpperExecute(
"abc",
"ABC");
438 TestStrToUpperExecute(
"ABC",
"ABC");
439 TestStrToUpperExecute(
"AbC",
"ABC");
440 TestStrToUpperExecute(
"AbC d e F",
"ABC D E F");
448 static void TestStrReplaceCharExecute(
const char* test,
const char* expected,
449 char search,
char replace,
int expected_count)
451 char* testdup = test ? strdup(test) : NULL;
454 CU_ASSERT_TRUE(TestCompare(testdup, expected));
455 CU_ASSERT_EQUAL(count, expected_count);
462 static void TestStrReplaceChar(
void)
464 TestStrReplaceCharExecute(NULL, NULL,
'a',
'b', 0);
465 TestStrReplaceCharExecute(
"ABCDEF",
"ABCDEF",
'a',
'b', 0);
466 TestStrReplaceCharExecute(
",abc",
"@abc",
',',
'@', 1);
467 TestStrReplaceCharExecute(
"abc,",
"abc@",
',',
'@', 1);
468 TestStrReplaceCharExecute(
",abc,",
"@abc@",
',',
'@', 2);
469 TestStrReplaceCharExecute(
"ab,c",
"ab@c",
',',
'@', 1);
470 TestStrReplaceCharExecute(
"abacadae",
"ebecedee",
'a',
'e', 4);
478 static void TestStrReplaceCharNExecute(
const char* test,
size_t testlen,
479 const char* expected,
char search,
char replace,
int expected_count)
482 char* testdup = NULL;
486 memcpy(testdup, test, testlen);
487 testdup[testlen] =
'\0';
491 CU_ASSERT_TRUE(TestCompareN(testdup, expected, testlen));
492 CU_ASSERT_EQUAL(count, expected_count);
500 static void TestStrReplaceCharN(
void)
502 TestStrReplaceCharNExecute(NULL, 5, NULL,
'a',
'b', 0);
503 TestStrReplaceCharNExecute(
"ABCDEF", 6,
"ABCDEF",
'a',
'b', 0);
504 TestStrReplaceCharNExecute(
"ABCDEF", 6,
"BBCDEF",
'A',
'B', 1);
505 TestStrReplaceCharNExecute(
"ABC\0EF", 6,
"ABCCEF",
'\0',
'C', 1);
506 TestStrReplaceCharNExecute(
"ABC\0EF\0", 7,
"ABCCEFC",
'\0',
'C', 2);
507 TestStrReplaceCharNExecute(
"\0", 1,
" ",
'\0',
' ', 1);
515 static void TestStrTrimmedLengthExecute(
const char* test,
size_t expected)
522 static void TestStrTrimmedLength(
void)
524 TestStrTrimmedLengthExecute(NULL, 0);
525 TestStrTrimmedLengthExecute(
"", 0);
526 TestStrTrimmedLengthExecute(
" ", 0);
527 TestStrTrimmedLengthExecute(
"\n\n\r\t", 0);
528 TestStrTrimmedLengthExecute(
"abc", 3);
529 TestStrTrimmedLengthExecute(
" abc", 3);
530 TestStrTrimmedLengthExecute(
"defg \n", 4);
531 TestStrTrimmedLengthExecute(
"\t\tabcdef\t ", 6);
532 TestStrTrimmedLengthExecute(
" abcdefg ", 7);
533 TestStrTrimmedLengthExecute(
" a b c d e f ", 11);
534 TestStrTrimmedLengthExecute(
" a\r\tb", 4);
535 TestStrTrimmedLengthExecute(
" xy zzy ", 6);
560 {
"StrReplaceCharN", TestStrReplaceCharN},
561 {
"StrReplaceChar", TestStrReplaceChar},
562 {
"StrStrdup", TestStrStrdup},
563 {
"StrStrncpy", TestStrStrncpy},
564 {
"StrStrncat", TestStrStrncat},
565 {
"StrToLower", TestStrToLower},
566 {
"StrToUpper", TestStrToUpper},
567 {
"StrTrimL", TestStrTrimL},
568 {
"StrTrimR", TestStrTrimR},
569 {
"StrTrim", TestStrTrim},
570 {
"StrTrimmedLength",TestStrTrimmedLength},
571 {
"StrUncomment", TestStrUncomment},
572 {
"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)