From c6c2bd4efab8644d72e8747594dc8870e10f56d9 Mon Sep 17 00:00:00 2001 From: Alexey Chernous <139914095+HGRaicer@users.noreply.github.com> Date: Fri, 24 May 2024 19:32:03 +0300 Subject: [PATCH 1/3] Add files via upload --- cstring.h | 44 +++++ main.c | 526 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 570 insertions(+) create mode 100644 main.c diff --git a/cstring.h b/cstring.h index 1a76fc5..b5ac9c0 100644 --- a/cstring.h +++ b/cstring.h @@ -102,6 +102,8 @@ void stringMapIndex(TString *s, char (*func)(size_t, char)); void stringRemove(TString *s, size_t pos, size_t len); void stringDestroy(TString *s); +void stringCapitalize(TString *s); + #endif // for testing: @@ -910,5 +912,47 @@ void stringDestroy(TString *s) { *s = (TString) {0}; } +bool charIsSep(char cur_ch){ + char sep[5] = {' ', '\t', '\n', ',', '.'}; + for (int i=0; i<5; i++){ + if (cur_ch == sep[i]) return true; + } + return false; +} + +void stringCapitalize(TString *s){ + typedef enum Tstate{ + start, + end + } Tstate; + Tstate state = start; + size_t len = s->size; + for(size_t idx=0; idxdata[idx]; + switch(state){ + case start: + if ( charIsSep(symb) ){ + state = start; + } + else{ + if ( stringCharIsAlpha(symb)){ + stringCharToUpper(symb); + state = end; + } else state = end; + } + break; + case end: + if (charIsSep(symb)){ + state = start; + } else state = end; + break; + + default: + state = end; + break; + } + } +} + #endif diff --git a/main.c b/main.c new file mode 100644 index 0000000..a00005a --- /dev/null +++ b/main.c @@ -0,0 +1,526 @@ +#include +#include +#include + +#define CSTRING_IMPLEMENTATION +#include "../cstring.h" + + +#define assertEq(X, Y) \ + while((X) != (Y)){ \ + printf("%zu vs %zu\n", (size_t)(X), (size_t)(Y)); \ + assert((X) == (Y)); \ +} + +#define assertNotEq(X, Y) \ + while((X) == (Y)){ \ + printf("%zu vs %zu\n", (size_t)(X), (size_t)(Y)); \ + assert((X) != (Y)); \ +} + + +void printGreen(const char *text) { + printf("\033[32m[ok]\033[0m %s", text); +} + +void printRed(const char *text) { + printf("\033[31m[wa] %s\033[0m", text); +} + +void test_stringStartWith() { + TString str = stringInitWithCharArr("Hello, World!"); + + TString prefix = stringInitWithCharArr("Hello"); + assertEq(stringStartWith(str, prefix), true); + + TString wrongPrefix = stringInitWithCharArr("World"); + assertEq(stringStartWith(str, wrongPrefix), false); + + stringDestroy(&str); + stringDestroy(&prefix); + stringDestroy(&wrongPrefix); + + printGreen("test_stringStartWith\n"); +} + +void test_stringStartWithCharArr() { + TString str = stringInitWithCharArr("Hello, World!"); + + assertEq(stringStartWithCharArr(str, "Hello"), true); + assertEq(stringStartWithCharArr(str, "World"), false); + + stringDestroy(&str); + + printGreen("test_stringStartWithCharArr\n"); +} + +void test_stringEndWith() { + TString str = stringInitWithCharArr("Hello, World!"); + + TString suffix = stringInitWithCharArr("World!"); + assertEq(stringEndWith(str, suffix), true); + + TString wrongSuffix = stringInitWithCharArr("Hello"); + assertEq(stringEndWith(str, wrongSuffix), false); + + stringDestroy(&str); + stringDestroy(&suffix); + stringDestroy(&wrongSuffix); + + printGreen("test_stringEndWith\n"); +} + +void test_stringEndWithCharArr() { + TString str = stringInitWithCharArr("Hello, World!"); + + assertEq(stringEndWithCharArr(str, "World!"), true); + assertEq(stringEndWithCharArr(str, "Hello"), false); + + stringDestroy(&str); + + printGreen("test_stringEndWithCharArr\n"); +} + +void test_stringLen() { + TString str = stringInitWithCharArr("Hello"); + assertEq(stringLen(str), 5); + + TString emptyString = stringInitWithCharArr(""); + assertEq(stringLen(emptyString), 0); + + stringDestroy(&str); + stringDestroy(&emptyString); + + printGreen("test_stringLen\n"); +} + +void test_stringFindFirst() { + TString str = stringInitWithCharArr("Hello, World!"); + TString pattern = stringInitWithCharArr("World"); + assertEq(stringFindFirst(str, pattern), 7); + + TString nonExistingPattern = stringInitWithCharArr("XYZ"); + assertEq(stringFindFirst(str, nonExistingPattern), -1); + + stringDestroy(&str); + stringDestroy(&pattern); + stringDestroy(&nonExistingPattern); + + printGreen("test_stringFindFirst\n"); +} + +void test_stringFindFirstCharArr() { + TString str = stringInitWithCharArr("Hello, World!"); + + assertEq(stringFindFirstCharArr(str, "World"), 7); + assertEq(stringFindFirstCharArr(str, "XYZ"), -1); + + stringDestroy(&str); + + printGreen("test_stringFindFirstCharArr\n"); +} + +void test_stringInit() { + TString str = stringInit(10); + + assertEq(str.capacity, 10); + assertEq(str.size, 0); + + stringDestroy(&str); + + printGreen("test_stringInit\n"); +} + +void test_stringInitWithCharArr() { + const char *testStr = "Test string"; + TString str = stringInitWithCharArr(testStr); + + assertEq(stringLen(str), strlen(testStr)); + assertEq(strncmp(str.data, testStr, str.size), 0); + + stringDestroy(&str); + + printGreen("test_stringInitWithCharArr\n"); +} + +void test_stringInitWithInt() { + int64_t number = 12345678; + TString str = stringInitWithInt(number); + + TString expectedString = stringInitWithCharArr("12345678"); + assertEq(stringLen(str), stringLen(expectedString)); + assertEq(strncmp(str.data, expectedString.data, str.size), 0); + + stringDestroy(&str); + stringDestroy(&expectedString); + + printGreen("test_stringInitWithInt\n"); +} + + +void test_stringCopy() { + TString original = stringInitWithCharArr("Test string for copy"); + TString copied = stringCopy(original); + + assertEq(stringLen(copied), stringLen(original)); + assertEq(strncmp(copied.data, original.data, copied.size), 0); + assertEq(copied.data, original.data); // Ensure it's a shallow copy + + stringDestroy(&original); + + printGreen("test_stringCopy\n"); +} + +void test_stringDeepCopy() { + TString original = stringInitWithCharArr("Test string for deep copy"); + TString deepCopy = stringDeepCopy(original); + + assertEq(stringLen(deepCopy), stringLen(original)); + assertEq(strncmp(deepCopy.data, original.data, deepCopy.size), 0); + assertNotEq(deepCopy.data, original.data); // Ensure it's a deep copy + + stringDestroy(&original); + stringDestroy(&deepCopy); + + printGreen("test_stringDeepCopy\n"); +} + +void test_stringSubstring() { + TString str = stringInitWithCharArr("Hello, World!"); + size_t startPos = 7; + size_t length = 5; + TString sub = stringSubstring(str, startPos, length); + TString ans = stringInitWithCharArr("World"); + + assertEq(stringLen(sub), length); + assertEq(stringIsEqual(sub, ans), true); + assertEq(strncmp(sub.data, &str.data[startPos], length), 0); + + stringDestroy(&str); + stringDestroy(&sub); + stringDestroy(&ans); + + printGreen("test_stringSubstring\n"); +} + +void test_stringConcat() { + TString str1 = stringInitWithCharArr("Hello"); + TString str2 = stringInitWithCharArr(", World!"); + TString result = stringConcat(str1, str2); + + assertEq(stringLen(result), stringLen(str1) + stringLen(str2)); + assertEq(strncmp(result.data, "Hello, World!", stringLen(result)), 0); + + stringDestroy(&str1); + stringDestroy(&str2); + stringDestroy(&result); + + printGreen("test_stringConcat\n"); +} + +void test_stringArrConcat() { + TString strs[3]; + strs[0] = stringInitWithCharArr("One"); + strs[1] = stringInitWithCharArr("Two"); + strs[2] = stringInitWithCharArr("Three"); + size_t count = sizeof(strs) / sizeof(strs[0]); + + TString result = stringArrConcat(strs, count); + + size_t expectedLength = 0; + for (size_t i = 0; i < count; ++i) { + expectedLength += stringLen(strs[i]); + } + + assertEq(stringLen(result), expectedLength); + assertEq(strncmp(result.data, "OneTwoThree", stringLen(result)), 0); + + for (size_t i = 0; i < count; ++i) { + stringDestroy(&strs[i]); + } + stringDestroy(&result); + + printGreen("test_stringArrConcat\n"); +} + +void test_stringPushBack() { + TString str = stringInitWithCharArr("hello"); + char c = '!'; + stringPushBack(&str, c); + + assertEq(stringLen(str), 6); + assertEq(str.data[stringLen(str) - 1], c); + + stringDestroy(&str); + printGreen("test_stringPushBack passed\n"); +} + +void test_stringTrim() { + TString str = stringInitWithCharArr(" hello "); + stringTrim(&str); + + assertEq(stringLen(str), 5); + assertEq(strncmp(str.data, "hello", stringLen(str)), 0); + + stringPushBack(&str, '\n'); + for (size_t i = 0; i < 100; ++i) { + stringPushBack(&str, ' '); + } + stringTrim(&str); + + assertEq(stringLen(str), 5); + assertEq(strncmp(str.data, "hello", stringLen(str)), 0); + + + stringDestroy(&str); + printGreen("test_stringTrim\n"); +} + +void test_stringReplaceAll() { + TString str = stringInitWithCharArr("hello world, world!"); + const char *oldSub = "world"; + const char *newSub = "C"; + stringReplaceAll(&str, oldSub, newSub); + + TString expected = stringInitWithCharArr("hello C, C!"); + assertEq(stringLen(str), stringLen(expected)); + assertEq(strncmp(str.data, expected.data, stringLen(expected)), 0); + + stringDestroy(&str); + stringDestroy(&expected); + printGreen("test_stringReplaceAll\n"); +} + +void test_stringReverse() { + TString str = stringInitWithCharArr("hello"); + stringReverse(&str); + + assertEq(stringLen(str), 5); + assertEq(strncmp(str.data, "olleh", stringLen(str)), 0); + + stringDestroy(&str); + printGreen("test_stringReverse\n"); +} + +void test_stringCompare() { + TString s1 = stringInitWithCharArr("hello"); + TString s2 = stringInitWithCharArr("hello"); + TString s3 = stringInitWithCharArr("heaa"); + + assertEq(stringCompare(s1, s2), 0); + assertEq(stringCompare(s1, s3), -1); + + stringDestroy(&s1); + stringDestroy(&s2); + stringDestroy(&s3); + printGreen("test_stringCompare\n"); +} + +void test_stringToUpper() { + TString s = stringInitWithCharArr("Hello World! 123\n"); + TString res = stringInitWithCharArr("HELLO WORLD! 123\n"); + stringToUpper(&s); + assertEq(stringCompare(s, res), 0); + + stringDestroy(&s); + stringDestroy(&res); + printGreen("test_stringToUpper\n"); + +} + +void test_stringToLower() { + TString s = stringInitWithCharArr("Hello World! 123\n"); + TString res = stringInitWithCharArr("hello world! 123\n"); + stringToLower(&s); + assertEq(stringCompare(s, res), 0); + + stringDestroy(&s); + stringDestroy(&res); + printGreen("test_stringToLower\n"); +} + +char func(char c) { + if ('0' <= c && c <= '9') { + return '*'; + } + return c; +} + +void test_stringMap() { + TString s = stringInitWithCharArr("He22o Wor1d! 123\n"); + TString res = stringInitWithCharArr("He**o Wor*d! ***\n"); + stringMap(&s, func); + assertEq(stringCompare(s, res), 0); + + stringDestroy(&s); + stringDestroy(&res); + printGreen("test_stringMap\n"); +} + +void test_stringContains() { + TString s = stringInitWithCharArr("hi good looo shiii po ns skj skdjl hello wgg\n"); + TString p1 = stringInitWithCharArr("hello"); + TString p2 = stringInitWithCharArr("hello1"); + + assertEq(stringContains(s, p1), true); + assertEq(stringContains(s, p2), false); + + stringDestroy(&s); + stringDestroy(&p1); + stringDestroy(&p2); + + printGreen("test_stringContains\n"); +} + +bool acceptAll(char c) { + return true; +} + +bool skipAll(char c) { + return false; +} + +bool acceptOnlyDigit(char c) { + return ('0' <= c) && (c <= '9'); +} + +void test_stringFilter() { + TString emptyString = stringInitWithCharArr(""); + stringFilter(&emptyString, acceptAll); + assertEq(stringIsEmpty(emptyString), true); + + TString s1 = stringInitWithCharArr("banana banana"); + TString s1Expected = stringDeepCopy(s1); + stringFilter(&s1, acceptAll); + assertEq(stringCompare(s1, s1Expected), 0); + + TString s2 = stringInitWithCharArr("abc123def"); + TString s2Expected = stringInitWithCharArr("123"); + stringFilter(&s2, acceptOnlyDigit); + assertEq(stringCompare(s2, s2Expected), 0); + + stringDestroy(&emptyString); + stringDestroy(&s1); + stringDestroy(&s1Expected); + stringDestroy(&s2); + stringDestroy(&s2Expected); + printGreen("test_stringFilter\n"); +} + +void test_stringIsPalindrome() { + TString emptyString = stringInitWithCharArr(""); + assertEq(stringIsPalindrome(emptyString), true); + stringDestroy(&emptyString); + + TString notPalindromeEvenSizedString = stringInitWithCharArr("banaba"); + assertEq(stringIsPalindrome(notPalindromeEvenSizedString), false); + stringDestroy(¬PalindromeEvenSizedString); + + TString palindromeEvenSizedString = stringInitWithCharArr("abba"); + assertEq(stringIsPalindrome(palindromeEvenSizedString), true); + stringDestroy(&palindromeEvenSizedString); + + TString notPalindromeOddSizedString = stringInitWithCharArr("abc"); + assertEq(stringIsPalindrome(notPalindromeOddSizedString), false); + stringDestroy(¬PalindromeOddSizedString); + + TString palindromeOddSizedString = stringInitWithCharArr("abcba"); + assertEq(stringIsPalindrome(palindromeOddSizedString), true); + stringDestroy(&palindromeOddSizedString); + + printGreen("test_stringIsPalindrome\n"); +} + +void test_stringPad() { + TString str = stringInitWithCharArr("Hello, World!"); + stringPadLeft(&str, 20, ' '); + + assertEq(stringLen(str), 20); + assertEq(strncmp(str.data, " Hello, World!", stringLen(str)), 0); + + stringPadLeft(&str, 10, ' '); + assertEq(stringLen(str), 20); + assertEq(strncmp(str.data, " Hello, World!", stringLen(str)), 0); + + stringTrim(&str); + + stringPadRight(&str, 20, ' '); + + assertEq(stringLen(str), 20); + assertEq(strncmp(str.data, "Hello, World! ", stringLen(str)), 0); + + stringPadRight(&str, 10, ' '); + assertEq(stringLen(str), 20); + assertEq(strncmp(str.data, "Hello, World! ", stringLen(str)), 0); + + stringDestroy(&str); + printGreen("test_stringPad\n"); +} + +void test_stringRemove() { + TString s = stringInitWithCharArr("Hello, World! testing remove"); + + stringRemove(&s, stringFindFirstCharArr(s, "test"), 8); + assertEq(strncmp(s.data, "Hello, World! remove", stringLen(s)), 0); + + stringRemove(&s, 0, 10000); + assertEq(stringIsEmpty(s), true); + + stringDestroy(&s); + + printGreen("test_stringRemove\n"); +} + +void test_stringCapitalize(){ + TString s1 = stringInitWithCharArr("Hello, World! testing remove"); + TString res1 = stringInitWithCharArr("Hello, World! Testing Remove"); + stringCapitalize(&s1); + assertEq(stringCompare(s1, res1), 0); + TString s2 = stringInitWithCharArr("1ello, World! testing remove"); + TString res2 = stringInitWithCharArr("1ello, World! Testing Remove"); + stringCapitalize(&s2); + assertEq(stringCompare(s2, res2), 0); + TString s3 = stringInitWithCharArr("Hello, World! tes&ting remove"); + TString res3= stringInitWithCharArr("Hello, World! Tes&ting Remove"); + stringCapitalize(&s3); + assertEq(stringCompare(s3, res3), 0); + TString s4 = stringInitWithCharArr("Hello, World!,testing remove"); + TString res4 = stringInitWithCharArr("Hello, World!,Testing Remove"); + stringCapitalize(&s4); + assertEq(stringCompare(s4, res4), 0); + + printGreen("test_stringCapitalize\n"); +} + +int main() { + test_stringStartWith(); + test_stringEndWith(); + test_stringLen(); + test_stringFindFirst(); + test_stringFindFirstCharArr(); + test_stringInit(); + test_stringInitWithInt(); + test_stringInitWithCharArr(); + test_stringCopy(); + test_stringDeepCopy(); + test_stringSubstring(); + test_stringConcat(); + test_stringArrConcat(); + test_stringPushBack(); + test_stringTrim(); + test_stringReplaceAll(); + test_stringReverse(); + test_stringCompare(); + test_stringToLower(); + test_stringToUpper(); + test_stringMap(); + test_stringContains(); + test_stringFilter(); + test_stringIsPalindrome(); + test_stringPad(); + test_stringRemove(); + test_stringCapitalize(); + return 0; +} + + From cfaede15963e98860c11ab62e88e9fb4ece5b48f Mon Sep 17 00:00:00 2001 From: Alexey Chernous <139914095+HGRaicer@users.noreply.github.com> Date: Fri, 24 May 2024 23:51:27 +0300 Subject: [PATCH 2/3] Delete main.c move in tests --- main.c | 526 --------------------------------------------------------- 1 file changed, 526 deletions(-) delete mode 100644 main.c diff --git a/main.c b/main.c deleted file mode 100644 index a00005a..0000000 --- a/main.c +++ /dev/null @@ -1,526 +0,0 @@ -#include -#include -#include - -#define CSTRING_IMPLEMENTATION -#include "../cstring.h" - - -#define assertEq(X, Y) \ - while((X) != (Y)){ \ - printf("%zu vs %zu\n", (size_t)(X), (size_t)(Y)); \ - assert((X) == (Y)); \ -} - -#define assertNotEq(X, Y) \ - while((X) == (Y)){ \ - printf("%zu vs %zu\n", (size_t)(X), (size_t)(Y)); \ - assert((X) != (Y)); \ -} - - -void printGreen(const char *text) { - printf("\033[32m[ok]\033[0m %s", text); -} - -void printRed(const char *text) { - printf("\033[31m[wa] %s\033[0m", text); -} - -void test_stringStartWith() { - TString str = stringInitWithCharArr("Hello, World!"); - - TString prefix = stringInitWithCharArr("Hello"); - assertEq(stringStartWith(str, prefix), true); - - TString wrongPrefix = stringInitWithCharArr("World"); - assertEq(stringStartWith(str, wrongPrefix), false); - - stringDestroy(&str); - stringDestroy(&prefix); - stringDestroy(&wrongPrefix); - - printGreen("test_stringStartWith\n"); -} - -void test_stringStartWithCharArr() { - TString str = stringInitWithCharArr("Hello, World!"); - - assertEq(stringStartWithCharArr(str, "Hello"), true); - assertEq(stringStartWithCharArr(str, "World"), false); - - stringDestroy(&str); - - printGreen("test_stringStartWithCharArr\n"); -} - -void test_stringEndWith() { - TString str = stringInitWithCharArr("Hello, World!"); - - TString suffix = stringInitWithCharArr("World!"); - assertEq(stringEndWith(str, suffix), true); - - TString wrongSuffix = stringInitWithCharArr("Hello"); - assertEq(stringEndWith(str, wrongSuffix), false); - - stringDestroy(&str); - stringDestroy(&suffix); - stringDestroy(&wrongSuffix); - - printGreen("test_stringEndWith\n"); -} - -void test_stringEndWithCharArr() { - TString str = stringInitWithCharArr("Hello, World!"); - - assertEq(stringEndWithCharArr(str, "World!"), true); - assertEq(stringEndWithCharArr(str, "Hello"), false); - - stringDestroy(&str); - - printGreen("test_stringEndWithCharArr\n"); -} - -void test_stringLen() { - TString str = stringInitWithCharArr("Hello"); - assertEq(stringLen(str), 5); - - TString emptyString = stringInitWithCharArr(""); - assertEq(stringLen(emptyString), 0); - - stringDestroy(&str); - stringDestroy(&emptyString); - - printGreen("test_stringLen\n"); -} - -void test_stringFindFirst() { - TString str = stringInitWithCharArr("Hello, World!"); - TString pattern = stringInitWithCharArr("World"); - assertEq(stringFindFirst(str, pattern), 7); - - TString nonExistingPattern = stringInitWithCharArr("XYZ"); - assertEq(stringFindFirst(str, nonExistingPattern), -1); - - stringDestroy(&str); - stringDestroy(&pattern); - stringDestroy(&nonExistingPattern); - - printGreen("test_stringFindFirst\n"); -} - -void test_stringFindFirstCharArr() { - TString str = stringInitWithCharArr("Hello, World!"); - - assertEq(stringFindFirstCharArr(str, "World"), 7); - assertEq(stringFindFirstCharArr(str, "XYZ"), -1); - - stringDestroy(&str); - - printGreen("test_stringFindFirstCharArr\n"); -} - -void test_stringInit() { - TString str = stringInit(10); - - assertEq(str.capacity, 10); - assertEq(str.size, 0); - - stringDestroy(&str); - - printGreen("test_stringInit\n"); -} - -void test_stringInitWithCharArr() { - const char *testStr = "Test string"; - TString str = stringInitWithCharArr(testStr); - - assertEq(stringLen(str), strlen(testStr)); - assertEq(strncmp(str.data, testStr, str.size), 0); - - stringDestroy(&str); - - printGreen("test_stringInitWithCharArr\n"); -} - -void test_stringInitWithInt() { - int64_t number = 12345678; - TString str = stringInitWithInt(number); - - TString expectedString = stringInitWithCharArr("12345678"); - assertEq(stringLen(str), stringLen(expectedString)); - assertEq(strncmp(str.data, expectedString.data, str.size), 0); - - stringDestroy(&str); - stringDestroy(&expectedString); - - printGreen("test_stringInitWithInt\n"); -} - - -void test_stringCopy() { - TString original = stringInitWithCharArr("Test string for copy"); - TString copied = stringCopy(original); - - assertEq(stringLen(copied), stringLen(original)); - assertEq(strncmp(copied.data, original.data, copied.size), 0); - assertEq(copied.data, original.data); // Ensure it's a shallow copy - - stringDestroy(&original); - - printGreen("test_stringCopy\n"); -} - -void test_stringDeepCopy() { - TString original = stringInitWithCharArr("Test string for deep copy"); - TString deepCopy = stringDeepCopy(original); - - assertEq(stringLen(deepCopy), stringLen(original)); - assertEq(strncmp(deepCopy.data, original.data, deepCopy.size), 0); - assertNotEq(deepCopy.data, original.data); // Ensure it's a deep copy - - stringDestroy(&original); - stringDestroy(&deepCopy); - - printGreen("test_stringDeepCopy\n"); -} - -void test_stringSubstring() { - TString str = stringInitWithCharArr("Hello, World!"); - size_t startPos = 7; - size_t length = 5; - TString sub = stringSubstring(str, startPos, length); - TString ans = stringInitWithCharArr("World"); - - assertEq(stringLen(sub), length); - assertEq(stringIsEqual(sub, ans), true); - assertEq(strncmp(sub.data, &str.data[startPos], length), 0); - - stringDestroy(&str); - stringDestroy(&sub); - stringDestroy(&ans); - - printGreen("test_stringSubstring\n"); -} - -void test_stringConcat() { - TString str1 = stringInitWithCharArr("Hello"); - TString str2 = stringInitWithCharArr(", World!"); - TString result = stringConcat(str1, str2); - - assertEq(stringLen(result), stringLen(str1) + stringLen(str2)); - assertEq(strncmp(result.data, "Hello, World!", stringLen(result)), 0); - - stringDestroy(&str1); - stringDestroy(&str2); - stringDestroy(&result); - - printGreen("test_stringConcat\n"); -} - -void test_stringArrConcat() { - TString strs[3]; - strs[0] = stringInitWithCharArr("One"); - strs[1] = stringInitWithCharArr("Two"); - strs[2] = stringInitWithCharArr("Three"); - size_t count = sizeof(strs) / sizeof(strs[0]); - - TString result = stringArrConcat(strs, count); - - size_t expectedLength = 0; - for (size_t i = 0; i < count; ++i) { - expectedLength += stringLen(strs[i]); - } - - assertEq(stringLen(result), expectedLength); - assertEq(strncmp(result.data, "OneTwoThree", stringLen(result)), 0); - - for (size_t i = 0; i < count; ++i) { - stringDestroy(&strs[i]); - } - stringDestroy(&result); - - printGreen("test_stringArrConcat\n"); -} - -void test_stringPushBack() { - TString str = stringInitWithCharArr("hello"); - char c = '!'; - stringPushBack(&str, c); - - assertEq(stringLen(str), 6); - assertEq(str.data[stringLen(str) - 1], c); - - stringDestroy(&str); - printGreen("test_stringPushBack passed\n"); -} - -void test_stringTrim() { - TString str = stringInitWithCharArr(" hello "); - stringTrim(&str); - - assertEq(stringLen(str), 5); - assertEq(strncmp(str.data, "hello", stringLen(str)), 0); - - stringPushBack(&str, '\n'); - for (size_t i = 0; i < 100; ++i) { - stringPushBack(&str, ' '); - } - stringTrim(&str); - - assertEq(stringLen(str), 5); - assertEq(strncmp(str.data, "hello", stringLen(str)), 0); - - - stringDestroy(&str); - printGreen("test_stringTrim\n"); -} - -void test_stringReplaceAll() { - TString str = stringInitWithCharArr("hello world, world!"); - const char *oldSub = "world"; - const char *newSub = "C"; - stringReplaceAll(&str, oldSub, newSub); - - TString expected = stringInitWithCharArr("hello C, C!"); - assertEq(stringLen(str), stringLen(expected)); - assertEq(strncmp(str.data, expected.data, stringLen(expected)), 0); - - stringDestroy(&str); - stringDestroy(&expected); - printGreen("test_stringReplaceAll\n"); -} - -void test_stringReverse() { - TString str = stringInitWithCharArr("hello"); - stringReverse(&str); - - assertEq(stringLen(str), 5); - assertEq(strncmp(str.data, "olleh", stringLen(str)), 0); - - stringDestroy(&str); - printGreen("test_stringReverse\n"); -} - -void test_stringCompare() { - TString s1 = stringInitWithCharArr("hello"); - TString s2 = stringInitWithCharArr("hello"); - TString s3 = stringInitWithCharArr("heaa"); - - assertEq(stringCompare(s1, s2), 0); - assertEq(stringCompare(s1, s3), -1); - - stringDestroy(&s1); - stringDestroy(&s2); - stringDestroy(&s3); - printGreen("test_stringCompare\n"); -} - -void test_stringToUpper() { - TString s = stringInitWithCharArr("Hello World! 123\n"); - TString res = stringInitWithCharArr("HELLO WORLD! 123\n"); - stringToUpper(&s); - assertEq(stringCompare(s, res), 0); - - stringDestroy(&s); - stringDestroy(&res); - printGreen("test_stringToUpper\n"); - -} - -void test_stringToLower() { - TString s = stringInitWithCharArr("Hello World! 123\n"); - TString res = stringInitWithCharArr("hello world! 123\n"); - stringToLower(&s); - assertEq(stringCompare(s, res), 0); - - stringDestroy(&s); - stringDestroy(&res); - printGreen("test_stringToLower\n"); -} - -char func(char c) { - if ('0' <= c && c <= '9') { - return '*'; - } - return c; -} - -void test_stringMap() { - TString s = stringInitWithCharArr("He22o Wor1d! 123\n"); - TString res = stringInitWithCharArr("He**o Wor*d! ***\n"); - stringMap(&s, func); - assertEq(stringCompare(s, res), 0); - - stringDestroy(&s); - stringDestroy(&res); - printGreen("test_stringMap\n"); -} - -void test_stringContains() { - TString s = stringInitWithCharArr("hi good looo shiii po ns skj skdjl hello wgg\n"); - TString p1 = stringInitWithCharArr("hello"); - TString p2 = stringInitWithCharArr("hello1"); - - assertEq(stringContains(s, p1), true); - assertEq(stringContains(s, p2), false); - - stringDestroy(&s); - stringDestroy(&p1); - stringDestroy(&p2); - - printGreen("test_stringContains\n"); -} - -bool acceptAll(char c) { - return true; -} - -bool skipAll(char c) { - return false; -} - -bool acceptOnlyDigit(char c) { - return ('0' <= c) && (c <= '9'); -} - -void test_stringFilter() { - TString emptyString = stringInitWithCharArr(""); - stringFilter(&emptyString, acceptAll); - assertEq(stringIsEmpty(emptyString), true); - - TString s1 = stringInitWithCharArr("banana banana"); - TString s1Expected = stringDeepCopy(s1); - stringFilter(&s1, acceptAll); - assertEq(stringCompare(s1, s1Expected), 0); - - TString s2 = stringInitWithCharArr("abc123def"); - TString s2Expected = stringInitWithCharArr("123"); - stringFilter(&s2, acceptOnlyDigit); - assertEq(stringCompare(s2, s2Expected), 0); - - stringDestroy(&emptyString); - stringDestroy(&s1); - stringDestroy(&s1Expected); - stringDestroy(&s2); - stringDestroy(&s2Expected); - printGreen("test_stringFilter\n"); -} - -void test_stringIsPalindrome() { - TString emptyString = stringInitWithCharArr(""); - assertEq(stringIsPalindrome(emptyString), true); - stringDestroy(&emptyString); - - TString notPalindromeEvenSizedString = stringInitWithCharArr("banaba"); - assertEq(stringIsPalindrome(notPalindromeEvenSizedString), false); - stringDestroy(¬PalindromeEvenSizedString); - - TString palindromeEvenSizedString = stringInitWithCharArr("abba"); - assertEq(stringIsPalindrome(palindromeEvenSizedString), true); - stringDestroy(&palindromeEvenSizedString); - - TString notPalindromeOddSizedString = stringInitWithCharArr("abc"); - assertEq(stringIsPalindrome(notPalindromeOddSizedString), false); - stringDestroy(¬PalindromeOddSizedString); - - TString palindromeOddSizedString = stringInitWithCharArr("abcba"); - assertEq(stringIsPalindrome(palindromeOddSizedString), true); - stringDestroy(&palindromeOddSizedString); - - printGreen("test_stringIsPalindrome\n"); -} - -void test_stringPad() { - TString str = stringInitWithCharArr("Hello, World!"); - stringPadLeft(&str, 20, ' '); - - assertEq(stringLen(str), 20); - assertEq(strncmp(str.data, " Hello, World!", stringLen(str)), 0); - - stringPadLeft(&str, 10, ' '); - assertEq(stringLen(str), 20); - assertEq(strncmp(str.data, " Hello, World!", stringLen(str)), 0); - - stringTrim(&str); - - stringPadRight(&str, 20, ' '); - - assertEq(stringLen(str), 20); - assertEq(strncmp(str.data, "Hello, World! ", stringLen(str)), 0); - - stringPadRight(&str, 10, ' '); - assertEq(stringLen(str), 20); - assertEq(strncmp(str.data, "Hello, World! ", stringLen(str)), 0); - - stringDestroy(&str); - printGreen("test_stringPad\n"); -} - -void test_stringRemove() { - TString s = stringInitWithCharArr("Hello, World! testing remove"); - - stringRemove(&s, stringFindFirstCharArr(s, "test"), 8); - assertEq(strncmp(s.data, "Hello, World! remove", stringLen(s)), 0); - - stringRemove(&s, 0, 10000); - assertEq(stringIsEmpty(s), true); - - stringDestroy(&s); - - printGreen("test_stringRemove\n"); -} - -void test_stringCapitalize(){ - TString s1 = stringInitWithCharArr("Hello, World! testing remove"); - TString res1 = stringInitWithCharArr("Hello, World! Testing Remove"); - stringCapitalize(&s1); - assertEq(stringCompare(s1, res1), 0); - TString s2 = stringInitWithCharArr("1ello, World! testing remove"); - TString res2 = stringInitWithCharArr("1ello, World! Testing Remove"); - stringCapitalize(&s2); - assertEq(stringCompare(s2, res2), 0); - TString s3 = stringInitWithCharArr("Hello, World! tes&ting remove"); - TString res3= stringInitWithCharArr("Hello, World! Tes&ting Remove"); - stringCapitalize(&s3); - assertEq(stringCompare(s3, res3), 0); - TString s4 = stringInitWithCharArr("Hello, World!,testing remove"); - TString res4 = stringInitWithCharArr("Hello, World!,Testing Remove"); - stringCapitalize(&s4); - assertEq(stringCompare(s4, res4), 0); - - printGreen("test_stringCapitalize\n"); -} - -int main() { - test_stringStartWith(); - test_stringEndWith(); - test_stringLen(); - test_stringFindFirst(); - test_stringFindFirstCharArr(); - test_stringInit(); - test_stringInitWithInt(); - test_stringInitWithCharArr(); - test_stringCopy(); - test_stringDeepCopy(); - test_stringSubstring(); - test_stringConcat(); - test_stringArrConcat(); - test_stringPushBack(); - test_stringTrim(); - test_stringReplaceAll(); - test_stringReverse(); - test_stringCompare(); - test_stringToLower(); - test_stringToUpper(); - test_stringMap(); - test_stringContains(); - test_stringFilter(); - test_stringIsPalindrome(); - test_stringPad(); - test_stringRemove(); - test_stringCapitalize(); - return 0; -} - - From acc2d0c5445ab35bbf3540d6a14581ee2834337f Mon Sep 17 00:00:00 2001 From: Alexey Chernous <139914095+HGRaicer@users.noreply.github.com> Date: Fri, 24 May 2024 23:51:58 +0300 Subject: [PATCH 3/3] Add files via upload --- tests/main.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/tests/main.c b/tests/main.c index fe2513c..a00005a 100644 --- a/tests/main.c +++ b/tests/main.c @@ -471,6 +471,27 @@ void test_stringRemove() { printGreen("test_stringRemove\n"); } +void test_stringCapitalize(){ + TString s1 = stringInitWithCharArr("Hello, World! testing remove"); + TString res1 = stringInitWithCharArr("Hello, World! Testing Remove"); + stringCapitalize(&s1); + assertEq(stringCompare(s1, res1), 0); + TString s2 = stringInitWithCharArr("1ello, World! testing remove"); + TString res2 = stringInitWithCharArr("1ello, World! Testing Remove"); + stringCapitalize(&s2); + assertEq(stringCompare(s2, res2), 0); + TString s3 = stringInitWithCharArr("Hello, World! tes&ting remove"); + TString res3= stringInitWithCharArr("Hello, World! Tes&ting Remove"); + stringCapitalize(&s3); + assertEq(stringCompare(s3, res3), 0); + TString s4 = stringInitWithCharArr("Hello, World!,testing remove"); + TString res4 = stringInitWithCharArr("Hello, World!,Testing Remove"); + stringCapitalize(&s4); + assertEq(stringCompare(s4, res4), 0); + + printGreen("test_stringCapitalize\n"); +} + int main() { test_stringStartWith(); test_stringEndWith(); @@ -498,6 +519,7 @@ int main() { test_stringIsPalindrome(); test_stringPad(); test_stringRemove(); + test_stringCapitalize(); return 0; }