diff --git a/libc/string/main.c b/libc/string/main.c index fa2843fa3..36a4f60fc 100644 --- a/libc/string/main.c +++ b/libc/string/main.c @@ -34,6 +34,10 @@ void runner(void) RUN_TEST_GROUP(signal_psignal); RUN_TEST_GROUP(string_cat); RUN_TEST_GROUP(string_dup); + RUN_TEST_GROUP(string_tok); + RUN_TEST_GROUP(string_tok_r); + RUN_TEST_GROUP(string_str); + RUN_TEST_GROUP(string_pbrk); } diff --git a/libc/string/string_tokpbrkstr.c b/libc/string/string_tokpbrkstr.c new file mode 100644 index 000000000..f4b14a467 --- /dev/null +++ b/libc/string/string_tokpbrkstr.c @@ -0,0 +1,695 @@ +/* + * Phoenix-RTOS + * + * POSIX.1-2017 standard library functions tests + * HEADER: + * - string.h + * TESTED: + * - strpbrk() + * - strstr() + * - strtok() + * + * Copyright 2023 Phoenix Systems + * Author: Damian Modzelewski + * + * This file is part of Phoenix-RTOS. + * + * %LICENSE% + */ + +#include +#include +#include +#include +#include +#include "testdata.h" + +#define ASCII_LENGTH 128 +#define EXTENDED_ASCII_LENGTH 256 +#define BUFFSIZE 24 +#define LOREM_IPSUM "Lorem Ipsum Dolor" + + +TEST_GROUP(string_tok); +TEST_GROUP(string_tok_r); +TEST_GROUP(string_str); +TEST_GROUP(string_pbrk); + + +static char *create_extAscii_set(void) +{ + int i; + char *hold = malloc(EXTENDED_ASCII_LENGTH); + + for (i = 1; i < EXTENDED_ASCII_LENGTH; i++) { + hold[i - 1] = i; + } + hold[i - 1] = 0; + + return hold; +} + + +TEST_SETUP(string_tok) +{ +} + + +TEST_TEAR_DOWN(string_tok) +{ +} + + +TEST(string_tok, basic) +{ + char str[] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas eleifend elementum tellum."; + const char *separators = ", ."; + char *token; + + TEST_ASSERT_EQUAL_PTR(str, (token = strtok(str, separators))); + TEST_ASSERT_EQUAL_STRING("Lorem", token); + + TEST_ASSERT_EQUAL_PTR(&str[6], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("ipsum", token); + + TEST_ASSERT_EQUAL_PTR(&str[12], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("dolor", token); + + TEST_ASSERT_EQUAL_PTR(&str[18], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("sit", token); + + TEST_ASSERT_EQUAL_PTR(&str[22], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("amet", token); + + TEST_ASSERT_EQUAL_PTR(&str[28], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("consectetur", token); + + TEST_ASSERT_EQUAL_PTR(&str[40], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("adipiscing", token); + + TEST_ASSERT_EQUAL_PTR(&str[51], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("elit", token); + + TEST_ASSERT_EQUAL_PTR(&str[57], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("Maecenas", token); + + TEST_ASSERT_EQUAL_PTR(&str[66], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("eleifend", token); + + TEST_ASSERT_EQUAL_PTR(&str[75], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("elementum", token); + + TEST_ASSERT_EQUAL_PTR(&str[85], (token = strtok(NULL, separators))); + TEST_ASSERT_EQUAL_STRING("tellum", token); + + TEST_ASSERT_EQUAL_PTR(NULL, strtok(NULL, separators)); +} + + +/* assert that looking for tokens stops after encountering even one NUL term */ +TEST(string_tok, torn) +{ + char str[] = "Lor\0em ipsum"; + const char *separators = " "; + char *tok; + TEST_ASSERT_EQUAL_PTR(str, (tok = strtok(str, separators))); + TEST_ASSERT_EQUAL_STRING("Lor", tok); + TEST_ASSERT_EQUAL_PTR(NULL, (tok = strtok(NULL, separators))); +} + + +TEST(string_tok, empty_args) +{ + char empty[] = { 0 }; + + /* Different scenarios of acquiring null pointer as output*/ + TEST_ASSERT_EQUAL_PTR(NULL, strtok("", "d")); + TEST_ASSERT_EQUAL_PTR(NULL, strtok(NULL, "")); + + TEST_ASSERT_EQUAL_PTR(NULL, strtok(empty, "")); + TEST_ASSERT_EQUAL_PTR(NULL, strtok(NULL, "")); + + TEST_ASSERT_EQUAL_PTR(NULL, strtok(empty, "\0")); + TEST_ASSERT_EQUAL_PTR(NULL, strtok(NULL, "\0")); + + TEST_ASSERT_EQUAL_PTR(NULL, strtok("abc\0", "abc")); + TEST_ASSERT_EQUAL_PTR(NULL, strtok(NULL, "abc")); +} + + +TEST(string_tok, multi_call) +{ + char loremStr[20] = LOREM_IPSUM, + asciiSep[2] = { 0 }, + sep[] = "ImDr"; + int i; + + /* + * In this case we are checking if it is possible to + * pass different stop points in each call to + * get desired tokens + */ + TEST_ASSERT_EQUAL_PTR(loremStr, strtok(loremStr, "I")); + TEST_ASSERT_EQUAL_PTR(&loremStr[7], strtok(NULL, "m")); + TEST_ASSERT_EQUAL_PTR(&loremStr[11], strtok(NULL, "D")); + TEST_ASSERT_EQUAL_PTR(&loremStr[13], strtok(NULL, "r")); + TEST_ASSERT_EQUAL_PTR(NULL, strtok(NULL, sep)); + + /* + * strtok() changes the content of a string, + * that's why we have to set it once again + */ + memcpy(loremStr, LOREM_IPSUM, sizeof(LOREM_IPSUM)); + + /* + * After passing all delimiters we cannot avoid misplaced tokens because + * strtok looks for all elements in "ImDr" and breaks a string + * in points where the first occurrence found + */ + TEST_ASSERT_EQUAL_PTR(loremStr, strtok(loremStr, sep)); + TEST_ASSERT_EQUAL_PTR(&loremStr[3], strtok(NULL, sep)); + TEST_ASSERT_EQUAL_PTR(&loremStr[5], strtok(NULL, sep)); + TEST_ASSERT_EQUAL_PTR(&loremStr[7], strtok(NULL, sep)); + TEST_ASSERT_EQUAL_PTR(&loremStr[11], strtok(NULL, sep)); + TEST_ASSERT_EQUAL_PTR(&loremStr[13], strtok(NULL, sep)); + TEST_ASSERT_EQUAL_PTR(NULL, strtok(NULL, sep)); + + char *asciiStr; + asciiStr = testdata_createCharStr(ASCII_LENGTH); + + /* + * In this case, we tokenize the whole ASCII set using jump-over by + * 2 elements. We are forced to jump over 2 places because strtok set + * divider placed as a null term and in this case, we are unable to + * cover the whole set. Jumping over 2 places guarantees us output in the form + * of one element form ascii set to do an assert with the place where + * strtok has saved the stopping place + */ + TEST_ASSERT_EQUAL_PTR(&asciiStr[1], strtok(&asciiStr[1], "\2")); + for (i = 4; i < ASCII_LENGTH; i += 2) { + asciiSep[0] = i; + TEST_ASSERT_EQUAL_PTR(&asciiStr[i - 1], strtok(NULL, &asciiSep[0])); + } + + /* Checking if set is empty */ + TEST_ASSERT_EQUAL_PTR(NULL, strtok(NULL, &asciiSep[0])); + free(asciiStr); +} + + +TEST(string_tok, out_of_ascii) +{ + char *extAsciiStr = create_extAscii_set(); + + char divider[6] = { 0 }, + separator[ASCII_LENGTH]; + int i; + + divider[0] = extAsciiStr[0]; + divider[1] = extAsciiStr[64]; + divider[2] = extAsciiStr[128]; + divider[3] = extAsciiStr[192]; + divider[4] = extAsciiStr[254]; + + + /* Checking ability for tokenize element above standard charset */ + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[1], strtok(extAsciiStr, divider)); + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[65], strtok(NULL, divider)); + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[129], strtok(NULL, divider)); + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[193], strtok(NULL, divider)); + + /* 256 is not taken as a token because on element after it is a null term and it is recognized as the end of set */ + TEST_ASSERT_EQUAL_PTR(NULL, strtok(NULL, divider)); + + extAsciiStr = create_extAscii_set(); + /* + * Checking available tokenization on all elements + * from outside of ASCII charset one by one, with + * the first separator set as the first element of the set + */ + TEST_ASSERT_EQUAL_PTR(extAsciiStr, strtok(extAsciiStr, "\128")); + for (i = ASCII_LENGTH + 1; i < sizeof(separator); i++) { + separator[i - ASCII_LENGTH] = i; + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[i - ASCII_LENGTH], strtok(NULL, &separator[i - ASCII_LENGTH])); + } + + free(extAsciiStr); +} + + +/* +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +*/ + + +TEST_SETUP(string_tok_r) +{ +} + + +TEST_TEAR_DOWN(string_tok_r) +{ +} + + +TEST(string_tok_r, basic) +{ +#ifdef __phoenix__ + TEST_IGNORE(); +#else + + /* + * There needed to be two copies of the same element as strtok_r works + * on the same space where the variable is settled when even using restrict + */ + char *restState1 = NULL, + *restState2 = NULL; + char str1[] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas eleifend elementum tellum.", + str2[sizeof(str1)]; + const char *separators = ", ."; + char *token; + + memcpy(str2, str1, sizeof(str1)); + + TEST_ASSERT_EQUAL_PTR(str1, (token = strtok_r(str1, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("Lorem", token); + TEST_ASSERT_EQUAL_PTR(str2, (token = strtok_r(str2, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("Lorem", token); + + TEST_ASSERT_EQUAL_PTR(&str1[6], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("ipsum", token); + TEST_ASSERT_EQUAL_PTR(&str2[6], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("ipsum", token); + + TEST_ASSERT_EQUAL_PTR(&str1[12], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("dolor", token); + TEST_ASSERT_EQUAL_PTR(&str2[12], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("dolor", token); + + TEST_ASSERT_EQUAL_PTR(&str1[18], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("sit", token); + TEST_ASSERT_EQUAL_PTR(&str2[18], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("sit", token); + + TEST_ASSERT_EQUAL_PTR(&str1[22], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("amet", token); + TEST_ASSERT_EQUAL_PTR(&str2[22], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("amet", token); + + TEST_ASSERT_EQUAL_PTR(&str1[28], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("consectetur", token); + TEST_ASSERT_EQUAL_PTR(&str2[28], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("consectetur", token); + + TEST_ASSERT_EQUAL_PTR(&str1[40], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("adipiscing", token); + TEST_ASSERT_EQUAL_PTR(&str2[40], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("adipiscing", token); + + TEST_ASSERT_EQUAL_PTR(&str1[51], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("elit", token); + TEST_ASSERT_EQUAL_PTR(&str2[51], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("elit", token); + + TEST_ASSERT_EQUAL_PTR(&str1[57], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("Maecenas", token); + TEST_ASSERT_EQUAL_PTR(&str2[57], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("Maecenas", token); + + TEST_ASSERT_EQUAL_PTR(&str1[66], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("eleifend", token); + TEST_ASSERT_EQUAL_PTR(&str2[66], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("eleifend", token); + + TEST_ASSERT_EQUAL_PTR(&str1[75], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("elementum", token); + TEST_ASSERT_EQUAL_PTR(&str2[75], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("elementum", token); + + TEST_ASSERT_EQUAL_PTR(&str1[85], (token = strtok_r(NULL, separators, &restState1))); + TEST_ASSERT_EQUAL_STRING("tellum", token); + TEST_ASSERT_EQUAL_PTR(&str2[85], (token = strtok_r(NULL, separators, &restState2))); + TEST_ASSERT_EQUAL_STRING("tellum", token); + + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(NULL, separators, &restState1)); + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(NULL, separators, &restState2)); +#endif +} + + +TEST(string_tok_r, torn) +{ +#ifdef __phoenix__ + TEST_IGNORE(); +#else + char *rest = NULL, + *tok, + str[] = "Lor\0em ipsum"; + const char *separators = " "; + + TEST_ASSERT_EQUAL_PTR(str, (tok = strtok_r(str, separators, &rest))); + TEST_ASSERT_EQUAL_STRING("Lor", tok); + TEST_ASSERT_EQUAL_PTR(NULL, (tok = strtok_r(NULL, separators, &rest))); +#endif +} + + +TEST(string_tok_r, empty_args) +{ +#ifdef __phoenix__ + TEST_IGNORE(); +#else + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wrestrict" + + char empty[] = { 0 }, + *rest; + + /* Different scenarios of acquiring null pointer as output*/ + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r("", "d", &rest)); + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(NULL, "", &rest)); + + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(empty, "", &rest)); + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(NULL, "", &rest)); + + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(empty, "\0", &rest)); + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(NULL, "\0", &rest)); + + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r("abc\0", "abc", &rest)); + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(NULL, "abc", &rest)); + +#pragma GCC diagnostic pop +#endif +} + + +TEST(string_tok_r, multi_call) +{ +#ifdef __phoenix__ + TEST_IGNORE(); +#else + + char loremStr[20] = LOREM_IPSUM, + asciiSep[2] = { 0 }, + sep[] = "ImDr", + *rest; + int i; + + /* + * In this case we are checking if it is possible to + * pass different stop points in each call to + * get desired tokens + */ + TEST_ASSERT_EQUAL_PTR(loremStr, strtok_r(loremStr, "I", &rest)); + TEST_ASSERT_EQUAL_PTR(&loremStr[7], strtok_r(NULL, "m", &rest)); + TEST_ASSERT_EQUAL_PTR(&loremStr[11], strtok_r(NULL, "D", &rest)); + TEST_ASSERT_EQUAL_PTR(&loremStr[13], strtok_r(NULL, "r", &rest)); + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(NULL, sep, &rest)); + + /* + * strtok() changes the content of a string, + * that's why we have to set it once again + */ + memcpy(loremStr, LOREM_IPSUM, sizeof(LOREM_IPSUM)); + + /* + * After passing all delimiters we cannot avoid misplaced tokens because + * strtok looks for all elements in "ImDr" and breaks a string + * in points where the first occurrence of it is found + */ + TEST_ASSERT_EQUAL_PTR(loremStr, strtok_r(loremStr, sep, &rest)); + TEST_ASSERT_EQUAL_PTR(&loremStr[3], strtok_r(NULL, sep, &rest)); + TEST_ASSERT_EQUAL_PTR(&loremStr[5], strtok_r(NULL, sep, &rest)); + TEST_ASSERT_EQUAL_PTR(&loremStr[7], strtok_r(NULL, sep, &rest)); + TEST_ASSERT_EQUAL_PTR(&loremStr[11], strtok_r(NULL, sep, &rest)); + TEST_ASSERT_EQUAL_PTR(&loremStr[13], strtok_r(NULL, sep, &rest)); + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(NULL, sep, &rest)); + + char *asciiStr; + asciiStr = testdata_createCharStr(ASCII_LENGTH); + + /* + * In this case, we tokenize the whole ASCII set using jump-over by + * 2 elements. We are forced to jump over 2 places because strtok set + * divider placed as a null term and in this case, we are unable to + * cover the whole set. Jumping over 2 places guarantees us output in the form + * of one element form ascii set to do an assert with the place where + * strtok has saved the stopping place + */ + TEST_ASSERT_EQUAL_PTR(&asciiStr[1], strtok_r(&asciiStr[1], "\2", &rest)); + for (i = 4; i < ASCII_LENGTH; i += 2) { + asciiSep[0] = i; + TEST_ASSERT_EQUAL_PTR(&asciiStr[i - 1], strtok_r(NULL, &asciiSep[0], &rest)); + } + + /* Checking if set is empty */ + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(NULL, &asciiSep[0], &rest)); + + free(asciiStr); +#endif +} + + +TEST(string_tok_r, out_of_ascii) +{ +#ifdef __phoenix__ + TEST_IGNORE(); +#else + + char *extAsciiStr = create_extAscii_set(); + + char divider[6] = { 0 }, + separator[ASCII_LENGTH], + *rest; + int i; + + divider[0] = extAsciiStr[0]; + divider[1] = extAsciiStr[64]; + divider[2] = extAsciiStr[128]; + divider[3] = extAsciiStr[192]; + divider[4] = extAsciiStr[254]; + + /* Checking ability for tokenize element above standard charset */ + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[1], strtok_r(extAsciiStr, divider, &rest)); + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[65], strtok_r(NULL, divider, &rest)); + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[129], strtok_r(NULL, divider, &rest)); + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[193], strtok_r(NULL, divider, &rest)); + + /* 256 is not taken as a token because on element after it is a null term and it is recognized as the end of set */ + TEST_ASSERT_EQUAL_PTR(NULL, strtok_r(NULL, divider, &rest)); + + extAsciiStr = create_extAscii_set(); + /* + * Checking available tokenization on all elements + * from outside of ASCII charset one by one, with + * the first separator set as the first element of the set + */ + TEST_ASSERT_EQUAL_PTR(extAsciiStr, strtok_r(extAsciiStr, "\128", &rest)); + for (i = ASCII_LENGTH + 1; i < sizeof(separator); i++) { + separator[i - ASCII_LENGTH] = i; + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[i - ASCII_LENGTH], strtok_r(NULL, &separator[i - ASCII_LENGTH], &rest)); + } + + free(extAsciiStr); +#endif +} + + +TEST(string_tok_r, restriction) +{ +#ifdef __phoenix__ + TEST_IGNORE(); +#else + + char *rest[ASCII_LENGTH] = { 0 }, + *tok; + + int i; + + char *asciiStr; + asciiStr = testdata_createCharStr(ASCII_LENGTH); + + for (i = 1; i < ASCII_LENGTH - 1; i++) { + TEST_ASSERT_EQUAL_PTR(&asciiStr[1], tok = strtok_r(&asciiStr[1], &asciiStr[i + 1], &rest[i])); + TEST_ASSERT_EQUAL_CHAR_ARRAY(&asciiStr[1], tok, i); + TEST_ASSERT_NOT_NULL(rest[i]); + } + free(asciiStr); +#endif +} + + +/* +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +*/ + + +TEST_SETUP(string_str) +{ +} + + +TEST_TEAR_DOWN(string_str) +{ +} + + +TEST(string_str, basic) +{ + char loremIpsum[BUFFSIZE] = LOREM_IPSUM; + + char *asciiStr; + asciiStr = testdata_createCharStr(ASCII_LENGTH); + + /* Standard use of strstr on arrays */ + TEST_ASSERT_EQUAL_PTR(loremIpsum, strstr(loremIpsum, "Lorem")); + TEST_ASSERT_EQUAL_PTR(&loremIpsum[6], strstr(loremIpsum, "Ipsum")); + TEST_ASSERT_EQUAL_PTR(&loremIpsum[12], strstr(loremIpsum, "Dolor")); + + /* Simple usage of strstr with ascii set */ + TEST_ASSERT_EQUAL_PTR(asciiStr, strstr(asciiStr, asciiStr)); + TEST_ASSERT_EQUAL_STRING(&asciiStr[ASCII_LENGTH / 4], strstr(asciiStr, &asciiStr[ASCII_LENGTH / 4])); + TEST_ASSERT_EQUAL_STRING(&asciiStr[ASCII_LENGTH / 3], strstr(asciiStr, &asciiStr[ASCII_LENGTH / 3])); + TEST_ASSERT_EQUAL_STRING(&asciiStr[ASCII_LENGTH / 2], strstr(asciiStr, &asciiStr[ASCII_LENGTH / 2])); + + /* Passing an empty string as the second parameter to get first */ + TEST_ASSERT_EQUAL_STRING(&asciiStr[ASCII_LENGTH / 2], strstr(&asciiStr[ASCII_LENGTH / 2], "")); + + free(asciiStr); +} + + +TEST(string_str, empty_args) +{ + /* Different scenarios of using empty input or output*/ + TEST_ASSERT_NOT_NULL(strstr("", "")); + TEST_ASSERT_NOT_NULL(strstr("abc", "\0")); + + TEST_ASSERT_NULL(strstr("", "abc")); + TEST_ASSERT_NULL(strstr("\0", "abc")); + TEST_ASSERT_NULL(strstr("abc", "def")); +} + + +TEST(string_str, out_of_ascii) +{ + int i; + + char *extAsciiStr = create_extAscii_set(); + + for (i = 1; i < sizeof(extAsciiStr); i++) { + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[i], strstr(extAsciiStr, &extAsciiStr[i])); + } + free(extAsciiStr); +} + + +/* +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +*/ + + +TEST_SETUP(string_pbrk) +{ +} + + +TEST_TEAR_DOWN(string_pbrk) +{ +} + + +TEST(string_pbrk, basic) +{ + char loremIpsum[BUFFSIZE] = LOREM_IPSUM; + + char *asciiStr; + asciiStr = testdata_createCharStr(ASCII_LENGTH); + + TEST_ASSERT_EQUAL_PTR(loremIpsum, strpbrk(loremIpsum, "Lorem")); + + /* + * strpbrk is sensitive to all elements in the array where + * is looking up which means 'm' is the first element of array 'loremIpsum' that strpbrk found + */ + TEST_ASSERT_EQUAL_PTR(&loremIpsum[4], strpbrk(loremIpsum, "Ipsum")); + + /* Like in the case before strpbrk found 'o' at second place in the array and his output point at second place in the array*/ + TEST_ASSERT_EQUAL_PTR(&loremIpsum[1], strpbrk(loremIpsum, "Dolor")); + + /* Simple usage of strpbrk with ascii set */ + TEST_ASSERT_EQUAL_PTR(asciiStr, strpbrk(asciiStr, asciiStr)); + TEST_ASSERT_EQUAL_STRING(&asciiStr[ASCII_LENGTH / 4], strpbrk(asciiStr, &asciiStr[ASCII_LENGTH / 4])); + TEST_ASSERT_EQUAL_STRING(&asciiStr[ASCII_LENGTH / 3], strpbrk(asciiStr, &asciiStr[ASCII_LENGTH / 3])); + TEST_ASSERT_EQUAL_STRING(&asciiStr[ASCII_LENGTH / 2], strpbrk(asciiStr, &asciiStr[ASCII_LENGTH / 2])); + + free(asciiStr); +} + + +TEST(string_pbrk, empty_args) +{ + /* Different scenarios to acquire null pointer as output*/ + TEST_ASSERT_NULL(strpbrk("", "abc")); + TEST_ASSERT_NULL(strpbrk("\0", "abc")); + TEST_ASSERT_NULL(strpbrk("\0", "\0")); + TEST_ASSERT_NULL(strpbrk("abc", "def")); +} + + +TEST(string_pbrk, out_of_ascii) +{ + int i; + + char *extAsciiStr = create_extAscii_set(); + + /* Checking the ability of strpbrk to use chars from 0 to 255 as elements of arrays in search*/ + for (i = 0; i < sizeof(extAsciiStr) - 1; i++) { + TEST_ASSERT_EQUAL_PTR(&extAsciiStr[i], strpbrk(extAsciiStr, &extAsciiStr[i])); + } + + free(extAsciiStr); +} + + +/* +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +*/ + + +TEST_GROUP_RUNNER(string_tok) +{ + RUN_TEST_CASE(string_tok, basic); + RUN_TEST_CASE(string_tok, torn); + RUN_TEST_CASE(string_tok, empty_args); + RUN_TEST_CASE(string_tok, multi_call); + RUN_TEST_CASE(string_tok, out_of_ascii); +} + + +TEST_GROUP_RUNNER(string_tok_r) +{ + RUN_TEST_CASE(string_tok_r, basic); + RUN_TEST_CASE(string_tok_r, torn); + RUN_TEST_CASE(string_tok_r, empty_args); + RUN_TEST_CASE(string_tok_r, multi_call); + RUN_TEST_CASE(string_tok_r, out_of_ascii); + RUN_TEST_CASE(string_tok_r, restriction); +} + + +TEST_GROUP_RUNNER(string_str) +{ + RUN_TEST_CASE(string_str, basic); + RUN_TEST_CASE(string_str, empty_args); + RUN_TEST_CASE(string_str, out_of_ascii); +} + + +TEST_GROUP_RUNNER(string_pbrk) +{ + RUN_TEST_CASE(string_pbrk, basic); + RUN_TEST_CASE(string_pbrk, empty_args); + RUN_TEST_CASE(string_pbrk, out_of_ascii); +}