Skip to content

Commit

Permalink
libc: strchr tests: add test group for ASCII compare
Browse files Browse the repository at this point in the history 
JIRA: CI-232
  • Loading branch information
@maska989
maska989 committed Jun 15, 2023
1 parent 82201d9 commit 73a7370
Showing 1 changed file with 82 additions and 83 deletions.
165 changes: 82 additions & 83 deletions libc/string_lenchr.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -375,21 +375,21 @@ TEST(string_chr, basic)
sz = strlen(lorem);

/* Check of proper working base */
TEST_ASSERT_EQUAL_STRING(lorem, strchr(lorem, 'L'));
TEST_ASSERT_EQUAL_STRING(lorem, strrchr(lorem, 'L'));
TEST_ASSERT_EQUAL_STRING(lorem, memchr(lorem, 'L', sz));
TEST_ASSERT_EQUAL_PTR(lorem, strchr(lorem, 'L'));
TEST_ASSERT_EQUAL_PTR(lorem, strrchr(lorem, 'L'));
TEST_ASSERT_EQUAL_PTR(lorem, memchr(lorem, 'L', sz));

TEST_ASSERT_EQUAL_STRING("lor sit amet, consectetur adipiscing elit y", strchr(lorem, 'l'));
TEST_ASSERT_EQUAL_STRING("lit y", strrchr(lorem, 'l'));
TEST_ASSERT_EQUAL_STRING("lor sit amet, consectetur adipiscing elit y", memchr(lorem, 'l', sz));
TEST_ASSERT_EQUAL_PTR(&lorem[14], strchr(lorem, 'l'));
TEST_ASSERT_EQUAL_PTR(&lorem[52], strrchr(lorem, 'l'));
TEST_ASSERT_EQUAL_PTR(&lorem[14], memchr(lorem, 'l', sz));

TEST_ASSERT_EQUAL_STRING(NULL, strchr(lorem, 'x'));
TEST_ASSERT_EQUAL_STRING(NULL, strrchr(lorem, 'x'));
TEST_ASSERT_EQUAL_STRING(NULL, memchr(lorem, 'x', sz));
TEST_ASSERT_EQUAL_PTR(NULL, strchr(lorem, 'x'));
TEST_ASSERT_EQUAL_PTR(NULL, strrchr(lorem, 'x'));
TEST_ASSERT_EQUAL_PTR(NULL, memchr(lorem, 'x', sz));

TEST_ASSERT_EQUAL_STRING(&lorem[sz], strchr(lorem, lorem[sz]));
TEST_ASSERT_EQUAL_STRING(&lorem[sz], strrchr(lorem, lorem[sz]));
TEST_ASSERT_EQUAL_STRING(&lorem[sz], memchr(lorem, lorem[sz], sz + 1));
TEST_ASSERT_EQUAL_PTR(&lorem[sz], strchr(lorem, lorem[sz]));
TEST_ASSERT_EQUAL_PTR(&lorem[sz], strrchr(lorem, lorem[sz]));
TEST_ASSERT_EQUAL_PTR(&lorem[sz], memchr(lorem, lorem[sz], sz + 1));
}


Expand All @@ -401,24 +401,30 @@ TEST(string_chr, big)
memset(str, 'a', sizeof(str) - 1);
str[PATH_MAX - 5] = 'b';

TEST_ASSERT_EQUAL_STRING("baaa", strchr(str, 'b'));
TEST_ASSERT_EQUAL_STRING("baaa", strrchr(str, 'b'));
TEST_ASSERT_EQUAL_STRING("baaa", memchr(str, 'b', sizeof(str)));
TEST_ASSERT_EQUAL_PTR(&str[PATH_MAX - 5], strchr(str, 'b'));
TEST_ASSERT_EQUAL_PTR(&str[PATH_MAX - 5], strrchr(str, 'b'));
TEST_ASSERT_EQUAL_PTR(&str[PATH_MAX - 5], memchr(str, 'b', sizeof(str)));

str[PATH_MAX - 5] = 'a';
str[5] = 'b';

TEST_ASSERT_EQUAL_STRING(&str[5], strchr(str, 'b'));
TEST_ASSERT_EQUAL_STRING(&str[5], strrchr(str, 'b'));
TEST_ASSERT_EQUAL_STRING(&str[5], memchr(str, 'b', sizeof(str)));
TEST_ASSERT_EQUAL_PTR(&str[5], strchr(str, 'b'));
TEST_ASSERT_EQUAL_PTR(&str[5], strrchr(str, 'b'));
TEST_ASSERT_EQUAL_PTR(&str[5], memchr(str, 'b', sizeof(str)));

TEST_ASSERT_EQUAL_STRING(str, strchr(str, 'a'));
TEST_ASSERT_EQUAL_STRING("a", strrchr(str, 'a'));
TEST_ASSERT_EQUAL_STRING(str, memchr(str, 'a', sizeof(str)));
TEST_ASSERT_EQUAL_PTR(str, strchr(str, 'a'));
/*
* In this scenario we must point to 2 places before the end of
* the size of 'str' because the first of them is a NULL terminator
* and the second place is where intentionally strrchr will point
* because it returns the last byte before NULL
*/
TEST_ASSERT_EQUAL_PTR(&str[sizeof(str) - 2], strrchr(str, 'a'));
TEST_ASSERT_EQUAL_PTR(str, memchr(str, 'a', sizeof(str)));

TEST_ASSERT_EQUAL_STRING(NULL, strchr(str, 'x'));
TEST_ASSERT_EQUAL_STRING(NULL, strrchr(str, 'x'));
TEST_ASSERT_EQUAL_STRING(NULL, memchr(str, 'x', sizeof(str)));
TEST_ASSERT_EQUAL_PTR(NULL, strchr(str, 'x'));
TEST_ASSERT_EQUAL_PTR(NULL, strrchr(str, 'x'));
TEST_ASSERT_EQUAL_PTR(NULL, memchr(str, 'x', sizeof(str)));
}


Expand All @@ -434,75 +440,76 @@ TEST(string_chr, special)

sz = strlen(specials);

TEST_ASSERT_EQUAL_STRING(specials, strchr(specials, specials[0]));
TEST_ASSERT_EQUAL_STRING(specials, strrchr(specials, specials[0]));
TEST_ASSERT_EQUAL_STRING(specials, memchr(specials, specials[0], strlen(specials)));
TEST_ASSERT_EQUAL_PTR(specials, strchr(specials, specials[0]));
TEST_ASSERT_EQUAL_PTR(specials, strrchr(specials, specials[0]));
TEST_ASSERT_EQUAL_PTR(specials, memchr(specials, specials[0], strlen(specials)));

/* Getting last element from string contains only special characters */
TEST_ASSERT_EQUAL_STRING(&specials[sz], strchr(specials, specials[sz]));
TEST_ASSERT_EQUAL_STRING(&specials[sz], strrchr(specials, specials[sz]));
TEST_ASSERT_EQUAL_STRING(&specials[sz], memchr(specials, specials[sz], sz + 1));
TEST_ASSERT_EQUAL_PTR(&specials[sz], strchr(specials, specials[sz]));
TEST_ASSERT_EQUAL_PTR(&specials[sz], strrchr(specials, specials[sz]));
TEST_ASSERT_EQUAL_PTR(&specials[sz], memchr(specials, specials[sz], sz + 1));

/* Getting middle element from string contains only special characters */
TEST_ASSERT_EQUAL_STRING(&specials[sz / 2], strchr(specials, specials[sz / 2]));
TEST_ASSERT_EQUAL_STRING(&specials[sz / 2], strrchr(specials, specials[sz / 2]));
TEST_ASSERT_EQUAL_STRING(&specials[sz / 2], memchr(specials, specials[sz / 2], sz + 1));
TEST_ASSERT_EQUAL_PTR(&specials[sz / 2], strchr(specials, specials[sz / 2]));
TEST_ASSERT_EQUAL_PTR(&specials[sz / 2], strrchr(specials, specials[sz / 2]));
TEST_ASSERT_EQUAL_PTR(&specials[sz / 2], memchr(specials, specials[sz / 2], sz + 1));

/* Getting element which is not into string */
TEST_ASSERT_EQUAL_STRING(NULL, strchr(specials, 'I'));
TEST_ASSERT_EQUAL_STRING(NULL, strrchr(specials, 'I'));
TEST_ASSERT_EQUAL_STRING(NULL, memchr(specials, 'I', sz));
TEST_ASSERT_EQUAL_PTR(NULL, strchr(specials, 'I'));
TEST_ASSERT_EQUAL_PTR(NULL, strrchr(specials, 'I'));
TEST_ASSERT_EQUAL_PTR(NULL, memchr(specials, 'I', sz));
}


TEST(string_chr, ascii)
{
int sz, i;
char str[INT8_MAX] = { 0 };
int sz;
char *asciiStr;

asciiStr = testdata_createCharStr(INT8_MAX + 1);
sz = INT8_MAX;

for (i = 1; i < sizeof(str); i++) {
str[i - 1] = i;
}

sz = sizeof(str) - 1;
TEST_ASSERT_EQUAL_PTR(asciiStr, strchr(asciiStr, asciiStr[0]));
/* In this scenario we need to use second place of array because testdata create string with 0 and replace it with 1 */
TEST_ASSERT_EQUAL_PTR(&asciiStr[1], strrchr(asciiStr, asciiStr[0]));
TEST_ASSERT_EQUAL_PTR(asciiStr, memchr(asciiStr, asciiStr[0], sz + 1));

TEST_ASSERT_EQUAL_STRING(str, strchr(str, str[0]));
TEST_ASSERT_EQUAL_STRING(str, strrchr(str, str[0]));
TEST_ASSERT_EQUAL_STRING(str, memchr(str, str[0], sz + 1));
TEST_ASSERT_EQUAL_PTR(&asciiStr[sz / 2], strchr(asciiStr, asciiStr[sz / 2]));
TEST_ASSERT_EQUAL_PTR(&asciiStr[sz / 2], strrchr(asciiStr, asciiStr[sz / 2]));
TEST_ASSERT_EQUAL_PTR(&asciiStr[sz / 2], memchr(asciiStr, asciiStr[sz / 2], sz + 1));

TEST_ASSERT_EQUAL_STRING(&str[sz / 2], strchr(str, str[sz / 2]));
TEST_ASSERT_EQUAL_STRING(&str[sz / 2], strrchr(str, str[sz / 2]));
TEST_ASSERT_EQUAL_STRING(&str[sz / 2], memchr(str, str[sz / 2], sz + 1));
TEST_ASSERT_EQUAL_PTR(&asciiStr[sz], strchr(asciiStr, asciiStr[sz]));
TEST_ASSERT_EQUAL_PTR(&asciiStr[sz], strrchr(asciiStr, asciiStr[sz]));
TEST_ASSERT_EQUAL_PTR(&asciiStr[sz], memchr(asciiStr, asciiStr[sz], sz + 1));

TEST_ASSERT_EQUAL_STRING(&str[sz], strchr(str, str[sz]));
TEST_ASSERT_EQUAL_STRING(&str[sz], strrchr(str, str[sz]));
TEST_ASSERT_EQUAL_STRING(&str[sz], memchr(str, str[sz], sz + 1));
free((void *)asciiStr);
}


TEST(string_chr, not_ascii)
{
char charSet[129] = { 0 };
char charSet[BUFF_SIZE] = { 0 };
int sz, i;

/* Checking out of ASCII bytes */
for (i = 128; i <= 255; i++) {
charSet[i - 128] = i;
for (i = sizeof(charSet); i < sizeof(charSet) * 2 - 1; i++) {
charSet[i - sizeof(charSet)] = i;
}

/* Testing capability of functions to hold and read not ascii set */
sz = sizeof(charSet);
TEST_ASSERT_EQUAL_STRING(charSet, strchr(charSet, charSet[0]));
TEST_ASSERT_EQUAL_STRING(charSet, strrchr(charSet, charSet[0]));
TEST_ASSERT_EQUAL_STRING(charSet, memchr(charSet, charSet[0], sz));
TEST_ASSERT_EQUAL_PTR(charSet, strchr(charSet, charSet[0]));
TEST_ASSERT_EQUAL_PTR(charSet, strrchr(charSet, charSet[0]));
TEST_ASSERT_EQUAL_PTR(charSet, memchr(charSet, charSet[0], sz));

TEST_ASSERT_EQUAL_STRING(&charSet[64], strchr(charSet, charSet[64]));
TEST_ASSERT_EQUAL_STRING(&charSet[64], strrchr(charSet, charSet[64]));
TEST_ASSERT_EQUAL_STRING(&charSet[64], memchr(charSet, charSet[64], sz));
TEST_ASSERT_EQUAL_PTR(&charSet[64], strchr(charSet, charSet[64]));
TEST_ASSERT_EQUAL_PTR(&charSet[64], strrchr(charSet, charSet[64]));
TEST_ASSERT_EQUAL_PTR(&charSet[64], memchr(charSet, charSet[64], sz));

TEST_ASSERT_EQUAL_STRING(&charSet[sz - 1], strchr(charSet, charSet[sz - 1]));
TEST_ASSERT_EQUAL_STRING(&charSet[sz - 1], strrchr(charSet, charSet[sz - 1]));
TEST_ASSERT_EQUAL_STRING(&charSet[sz - 1], memchr(charSet, charSet[sz - 1], sz));
TEST_ASSERT_EQUAL_PTR(&charSet[sz - 1], strchr(charSet, charSet[sz - 1]));
TEST_ASSERT_EQUAL_PTR(&charSet[sz - 1], strrchr(charSet, charSet[sz - 1]));
TEST_ASSERT_EQUAL_PTR(&charSet[sz - 1], memchr(charSet, charSet[sz - 1], sz));
}


Expand All @@ -521,9 +528,9 @@ TEST(string_chr, torn)
TEST_ASSERT_EQUAL_STRING("foo", strrchr(torn, 'f'));
TEST_ASSERT_EQUAL_STRING("foo", memchr(torn, 'f', sz));

TEST_ASSERT_EQUAL_STRING(NULL, strchr(torn, 'b'));
TEST_ASSERT_EQUAL_STRING(NULL, strrchr(torn, 'b'));
TEST_ASSERT_EQUAL_STRING(NULL, memchr(torn, 'b', sz));
TEST_ASSERT_EQUAL_PTR(NULL, strchr(torn, 'b'));
TEST_ASSERT_EQUAL_PTR(NULL, strrchr(torn, 'b'));
TEST_ASSERT_EQUAL_PTR(NULL, memchr(torn, 'b', sz));
}


Expand All @@ -532,28 +539,20 @@ TEST(string_chr, whitespaces)
const char *exp = "Ipsum",
*strWhites = "Lorem \n\t\e\r\b\v\f\\ Ipsum",
whites[] = " \n\t\e\r\b\v\f\\";
int sz;
int sz, i;

/* Checking if white signs don't make any interference on functions output */
sz = sizeof(whites) - 1;
TEST_ASSERT_EQUAL_STRING(&whites[sz], strchr(whites, whites[sz]));
TEST_ASSERT_EQUAL_STRING(&whites[sz], strrchr(whites, whites[sz]));
TEST_ASSERT_EQUAL_STRING(&whites[sz], memchr(whites, whites[sz], sz + 1));

TEST_ASSERT_EQUAL_STRING(&whites[sz / 2], strchr(whites, whites[sz / 2]));
TEST_ASSERT_EQUAL_STRING(&whites[sz / 2], strrchr(whites, whites[sz / 2]));
TEST_ASSERT_EQUAL_STRING(&whites[sz / 2], memchr(whites, whites[sz / 2], sz + 1));

TEST_ASSERT_EQUAL_STRING(&whites[0], strchr(whites, whites[0]));
TEST_ASSERT_EQUAL_STRING(&whites[0], strrchr(whites, whites[0]));
TEST_ASSERT_EQUAL_STRING(&whites[0], memchr(whites, whites[0], sz + 1));

for (int i = 0; i < sizeof(whites); i++) {
for (i = 0; i < sz; i++) {
TEST_ASSERT_EQUAL_PTR(&whites[i], strchr(whites, whites[i]));
TEST_ASSERT_EQUAL_PTR(&whites[i], strrchr(whites, whites[i]));
TEST_ASSERT_EQUAL_PTR(&whites[i], memchr(whites, whites[i], i + 1));
}

TEST_ASSERT_EQUAL_STRING(NULL, strchr(whites, 'x'));
TEST_ASSERT_EQUAL_STRING(NULL, strrchr(whites, 'x'));
TEST_ASSERT_EQUAL_STRING(NULL, memchr(whites, 'x', sz));
TEST_ASSERT_EQUAL_PTR(NULL, strchr(whites, 'x'));
TEST_ASSERT_EQUAL_PTR(NULL, strrchr(whites, 'x'));
TEST_ASSERT_EQUAL_PTR(NULL, memchr(whites, 'x', sz));

sz = strlen(strWhites);
/* Testing if whitespaces interference output of functions */
Expand All @@ -574,7 +573,7 @@ TEST(string_chr, empty)

TEST(string_chr, memchr_size)
{
char charSet[128] = { 0 };
char charSet[BUFF_SIZE] = { 0 };
int i;

for (i = 0; i < sizeof(charSet); i++) {
Expand Down

0 comments on commit 73a7370

Please sign in to comment.