From eef7d33409c498b00bbf695a44c73e1c20f6c482 Mon Sep 17 00:00:00 2001 From: Maska989 Date: Thu, 15 Jun 2023 09:57:30 +0200 Subject: [PATCH 1/2] libc: string len and chr tests improvements JIRA: CI-232 --- libc/string/string_lenchr.c | 301 +++++++++++++++++------------------- 1 file changed, 146 insertions(+), 155 deletions(-) diff --git a/libc/string/string_lenchr.c b/libc/string/string_lenchr.c index 52b36bf2..5afc45d5 100644 --- a/libc/string/string_lenchr.c +++ b/libc/string/string_lenchr.c @@ -3,13 +3,15 @@ * * POSIX.1-2017 standard library functions tests * HEADER: - * - string.h + * - string.h * TESTED: - * - strlen() - * - strnlen() + * - strlen() + * - strnlen() * - strchr() * - strrchr() - * - memchr() + * - strchr() + * - strrchr() + * - memchr() * * Copyright 2023 Phoenix Systems * Author: Damian Modzelewski @@ -21,15 +23,14 @@ #include -#include #include -#include #include -#include #include -#include #include +#include "testdata.h" + +#define BUFF_SIZE 128 TEST_GROUP(string_len); TEST_GROUP(string_chr); @@ -52,11 +53,12 @@ TEST(string_len, ascii) torn[] = "foo\0bar", doubleNul[] = "\0\0abc", specials[] = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", - whites[] = " \v\t\r\n"; - char asciiSet[128] = { 0 }; - int sz, i; + whites[] = " \v\t\r\n", + *asciiSet; + int sz; TEST_ASSERT_EQUAL_INT(0, strlen("")); + asciiSet = testdata_createCharStr(BUFF_SIZE + 1); /* Pangram with a whole alphabet set */ sz = sizeof(pangram) - 1; @@ -96,64 +98,51 @@ TEST(string_len, ascii) TEST_ASSERT_EQUAL_INT(sz, strnlen(whites, sz + 1)); /* Checking ascii charset */ - for (i = 1; i < sizeof(asciiSet); i++) { - asciiSet[i - 1] = i; - } - sz = sizeof(asciiSet) - 1; + + sz = BUFF_SIZE; TEST_ASSERT_EQUAL_INT(sz, strlen(asciiSet)); TEST_ASSERT_EQUAL_INT(sz - 1, strnlen(asciiSet, sz - 1)); TEST_ASSERT_EQUAL_INT(sz, strnlen(asciiSet, sz)); TEST_ASSERT_EQUAL_INT(sz, strnlen(asciiSet, sz + 1)); + + free((void *)asciiSet); } TEST(string_len, not_ascii) { - const char notAsciiString[] = "♦♥♣♠◊⊗こんにちは❉❉⌨⌨⌨⌨⌨⌨⌨⌨❉❉"; - unsigned char notAsciiSet[129]; + unsigned char charSet[BUFF_SIZE] = { 0 }; int sz, i; - /* Checking ability to read the chars out of ascii charset */ - sz = sizeof(notAsciiString) - 1; - TEST_ASSERT_EQUAL_INT(sz, strlen(notAsciiString)); - TEST_ASSERT_EQUAL_INT(sz - 1, strnlen(notAsciiString, sz - 1)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(notAsciiString, sz)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(notAsciiString, sz + 1)); - - /* Checking out of ascii bytes */ - for (i = 128; i <= 255; i++) { - notAsciiSet[i - 128] = i; + /* Checking out of ASCII bytes */ + for (i = sizeof(charSet); i < sizeof(charSet) * 2 - 1; i++) { + charSet[i - sizeof(charSet)] = i; } - notAsciiSet[128] = 0; - sz = sizeof(notAsciiSet) - 1; - TEST_ASSERT_EQUAL_INT(sz, strlen((const char *)notAsciiSet)); - TEST_ASSERT_EQUAL_INT(sz - 1, strnlen((const char *)notAsciiSet, sz - 1)); - TEST_ASSERT_EQUAL_INT(sz, strnlen((const char *)notAsciiSet, sz)); - TEST_ASSERT_EQUAL_INT(sz, strnlen((const char *)notAsciiSet, sz + 1)); + sz = sizeof(charSet) - 1; + TEST_ASSERT_EQUAL_INT(sz, strlen((const char *)charSet)); + TEST_ASSERT_EQUAL_INT(sz - 1, strnlen((const char *)charSet, sz - 1)); + TEST_ASSERT_EQUAL_INT(sz, strnlen((const char *)charSet, sz)); + TEST_ASSERT_EQUAL_INT(sz, strnlen((const char *)charSet, sz + 1)); } TEST(string_len, big) { - char bigstr[PATH_MAX] = { 0 }; - int sz, i; + char bigStr[PATH_MAX] = { 0 }; + int sz; - /* The length of string is not clearly restricted, so we test one of bigger value, which may be used */ - for (i = 0; i < PATH_MAX - 1; i++) { - bigstr[i] = 'A'; - } - bigstr[i] = '\0'; + /* The length of the string is not restricted, so we test one of bigger value, which may be used */ + memset(bigStr, 1, sizeof(bigStr) - 1); - sz = sizeof(bigstr) - 1; - TEST_ASSERT_EQUAL_INT(sz, strlen(bigstr)); - TEST_ASSERT_EQUAL_INT(sz - 1, strnlen(bigstr, sz - 1)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(bigstr, sz)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(bigstr, sz + 1)); + sz = sizeof(bigStr) - 1; + TEST_ASSERT_EQUAL_INT(sz, strlen(bigStr)); + TEST_ASSERT_EQUAL_INT(sz - 1, strnlen(bigStr, sz - 1)); + TEST_ASSERT_EQUAL_INT(sz, strnlen(bigStr, sz)); + TEST_ASSERT_EQUAL_INT(sz, strnlen(bigStr, sz + 1)); } - /* //////////////////////////////////////////////////////////////////////////////////// */ @@ -177,21 +166,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)); } @@ -200,27 +189,33 @@ TEST(string_chr, big) char str[PATH_MAX] = { 0 }; /* Long string case */ - memset(str, 'a', PATH_MAX - 1); + 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))); } @@ -231,87 +226,81 @@ TEST(string_chr, special) /* * Testing did strchr don't stop if found special signs - * Getting first element from string contains only special characters + * Getting the first element from the string contains only special characters */ 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; - for (i = 1; i < sizeof(str); i++) { - str[i - 1] = i; - } + asciiStr = testdata_createCharStr(INT8_MAX + 1); + sz = INT8_MAX; - sz = sizeof(str) - 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, 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[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 / 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], 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)); + 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)); + + free((void *)asciiStr); } TEST(string_chr, not_ascii) { - const char notAsciiString[] = "♥♣♠◊⊗こんにちは❉❉⌨⌨⌨⌨⌨⌨⌨⌨❉❉♦x"; - char notAsciiSet[129]; + char charSet[BUFF_SIZE] = { 0 }; int sz, i; - /* Checking ability to read the chars out of ascii charset */ - sz = sizeof(notAsciiString) - 1; - TEST_ASSERT_EQUAL_STRING("x", strchr(notAsciiString, 'x')); - TEST_ASSERT_EQUAL_STRING("x", strrchr(notAsciiString, 'x')); - TEST_ASSERT_EQUAL_STRING("x", memchr(notAsciiString, 'x', sz)); - - /* Checking out of ascii bytes */ - for (i = 128; i <= 255; i++) { - notAsciiSet[i - 128] = i; + /* Checking out of ASCII bytes */ + for (i = sizeof(charSet); i < sizeof(charSet) * 2 - 1; i++) { + charSet[i - sizeof(charSet)] = i; } - notAsciiSet[128] = 0; /* Testing capability of functions to hold and read not ascii set */ - sz = sizeof(notAsciiSet); - TEST_ASSERT_EQUAL_STRING(notAsciiSet, strchr(notAsciiSet, notAsciiSet[0])); - TEST_ASSERT_EQUAL_STRING(notAsciiSet, strrchr(notAsciiSet, notAsciiSet[0])); - TEST_ASSERT_EQUAL_STRING(notAsciiSet, memchr(notAsciiSet, notAsciiSet[0], sz)); - - TEST_ASSERT_EQUAL_STRING(¬AsciiSet[64], strchr(notAsciiSet, notAsciiSet[64])); - TEST_ASSERT_EQUAL_STRING(¬AsciiSet[64], strrchr(notAsciiSet, notAsciiSet[64])); - TEST_ASSERT_EQUAL_STRING(¬AsciiSet[64], memchr(notAsciiSet, notAsciiSet[64], sz)); - - TEST_ASSERT_EQUAL_STRING(¬AsciiSet[sz - 1], strchr(notAsciiSet, notAsciiSet[sz - 1])); - TEST_ASSERT_EQUAL_STRING(¬AsciiSet[sz - 1], strrchr(notAsciiSet, notAsciiSet[sz - 1])); - TEST_ASSERT_EQUAL_STRING(¬AsciiSet[sz - 1], memchr(notAsciiSet, notAsciiSet[sz - 1], sz)); + sz = sizeof(charSet); + 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_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_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)); } @@ -330,9 +319,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)); } @@ -341,25 +330,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 doesn't make any interference on functions output */ + /* 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 (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 */ @@ -371,28 +355,35 @@ TEST(string_chr, whitespaces) TEST(string_chr, empty) { - int sz; - /* Checking if we can get an empty string */ - sz = 1; TEST_ASSERT_EQUAL_STRING("", strchr("", '\0')); TEST_ASSERT_EQUAL_STRING("", strrchr("", '\0')); - TEST_ASSERT_EQUAL_STRING("", memchr("", '\0', sz)); + TEST_ASSERT_EQUAL_STRING("", memchr("", '\0', 1)); } TEST(string_chr, memchr_size) { - char lorem[] = "Lorem"; - - /* Testing capability of setting size in memchr */ - TEST_ASSERT_EQUAL_STRING("rem", memchr(lorem, 'r', 6)); - TEST_ASSERT_EQUAL_STRING("rem", memchr(lorem, 'r', 5)); - TEST_ASSERT_EQUAL_STRING("rem", memchr(lorem, 'r', 4)); - TEST_ASSERT_EQUAL_STRING("rem", memchr(lorem, 'r', 3)); - TEST_ASSERT_EQUAL_STRING(NULL, memchr(lorem, 'r', 2)); - TEST_ASSERT_EQUAL_STRING(NULL, memchr(lorem, 'r', 1)); - TEST_ASSERT_EQUAL_STRING(NULL, memchr(lorem, 'r', 0)); + char charSet[BUFF_SIZE] = { 0 }; + int i; + + for (i = 0; i < sizeof(charSet); i++) { + + charSet[i] = i; + + /* + * In this case, we search the ASCII set where the stop point + * is always found and we check if memchr always returns the + * correct address + */ + TEST_ASSERT_EQUAL_PTR(&charSet[i], memchr(charSet, charSet[i], i + 1)); + /* + * In this case, the size of the search is the same as the place + * where is search char placed and memchr never meets + * the criteria to find it + */ + TEST_ASSERT_EQUAL_PTR(NULL, memchr(charSet, charSet[i], i)); + } } From 4843b64d3761b55b17d7e6b042c80ccc0422b171 Mon Sep 17 00:00:00 2001 From: Maska989 Date: Thu, 15 Jun 2023 10:00:51 +0200 Subject: [PATCH 2/2] libc: strchr tests: add test group for ASCII compare JIRA: CI-232 --- libc/string/main.c | 1 + libc/string/string_lenchr.c | 428 +++++++++++++++++++++++++++--------- 2 files changed, 327 insertions(+), 102 deletions(-) diff --git a/libc/string/main.c b/libc/string/main.c index fa2843fa..8623226e 100644 --- a/libc/string/main.c +++ b/libc/string/main.c @@ -34,6 +34,7 @@ void runner(void) RUN_TEST_GROUP(signal_psignal); RUN_TEST_GROUP(string_cat); RUN_TEST_GROUP(string_dup); + RUN_TEST_GROUP(string_spn); } diff --git a/libc/string/string_lenchr.c b/libc/string/string_lenchr.c index 5afc45d5..f449c0ca 100644 --- a/libc/string/string_lenchr.c +++ b/libc/string/string_lenchr.c @@ -7,8 +7,8 @@ * TESTED: * - strlen() * - strnlen() - * - strchr() - * - strrchr() + * - strcspn() + * - strspn() * - strchr() * - strrchr() * - memchr() @@ -34,6 +34,7 @@ TEST_GROUP(string_len); TEST_GROUP(string_chr); +TEST_GROUP(string_spn); TEST_SETUP(string_len) @@ -53,94 +54,92 @@ TEST(string_len, ascii) torn[] = "foo\0bar", doubleNul[] = "\0\0abc", specials[] = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", - whites[] = " \v\t\r\n", - *asciiSet; - int sz; + whites[] = " \v\t\r\n\f "; + char *asciiSet; + int len; TEST_ASSERT_EQUAL_INT(0, strlen("")); asciiSet = testdata_createCharStr(BUFF_SIZE + 1); /* Pangram with a whole alphabet set */ - sz = sizeof(pangram) - 1; - TEST_ASSERT_EQUAL_INT(sz, strlen(pangram)); - TEST_ASSERT_EQUAL_INT(sz - 1, strnlen(pangram, sz - 1)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(pangram, sz)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(pangram, sz + 1)); + len = sizeof(pangram) - 1; + TEST_ASSERT_EQUAL_INT(len, strlen(pangram)); + TEST_ASSERT_EQUAL_INT(len - 1, strnlen(pangram, len - 1)); + TEST_ASSERT_EQUAL_INT(len, strnlen(pangram, len)); + TEST_ASSERT_EQUAL_INT(len, strnlen(pangram, len + 1)); /* Text with null character in the middle */ - sz = sizeof(torn) / 2 - 1; - TEST_ASSERT_EQUAL_INT(sz, strlen(torn)); - TEST_ASSERT_EQUAL_INT(sz - 1, strnlen(torn, 3 - 1)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(torn, 3)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(torn, 3 + 1)); + len = sizeof(torn) / 2 - 1; + TEST_ASSERT_EQUAL_INT(len, strlen(torn)); + TEST_ASSERT_EQUAL_INT(len - 1, strnlen(torn, 3 - 1)); + TEST_ASSERT_EQUAL_INT(len, strnlen(torn, 3)); + TEST_ASSERT_EQUAL_INT(len, strnlen(torn, 3 + 1)); /* End of string */ - sz = 0; - TEST_ASSERT_EQUAL_INT(sz, strlen(doubleNul)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(doubleNul, 0)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(doubleNul, 1)); - TEST_ASSERT_EQUAL_INT(sz, strlen(doubleNul)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(empty, 0)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(empty, 1)); + len = 0; + TEST_ASSERT_EQUAL_INT(len, strlen(doubleNul)); + TEST_ASSERT_EQUAL_INT(len, strnlen(doubleNul, 0)); + TEST_ASSERT_EQUAL_INT(len, strnlen(doubleNul, 1)); + TEST_ASSERT_EQUAL_INT(len, strlen(doubleNul)); + TEST_ASSERT_EQUAL_INT(len, strnlen(empty, 0)); + TEST_ASSERT_EQUAL_INT(len, strnlen(empty, 1)); /* Special characters */ - sz = sizeof(specials) - 1; - TEST_ASSERT_EQUAL_INT(sz, strlen(specials)); - TEST_ASSERT_EQUAL_INT(sz - 1, strnlen(specials, sz - 1)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(specials, sz)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(specials, sz + 1)); + len = sizeof(specials) - 1; + TEST_ASSERT_EQUAL_INT(len, strlen(specials)); + TEST_ASSERT_EQUAL_INT(len - 1, strnlen(specials, len - 1)); + TEST_ASSERT_EQUAL_INT(len, strnlen(specials, len)); + TEST_ASSERT_EQUAL_INT(len, strnlen(specials, len + 1)); /* White spaces */ - sz = sizeof(whites) - 1; - TEST_ASSERT_EQUAL_INT(sz, strlen(whites)); - TEST_ASSERT_EQUAL_INT(sz - 1, strnlen(whites, sz - 1)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(whites, sz)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(whites, sz + 1)); + len = sizeof(whites) - 1; + TEST_ASSERT_EQUAL_INT(len, strlen(whites)); + TEST_ASSERT_EQUAL_INT(len - 1, strnlen(whites, len - 1)); + TEST_ASSERT_EQUAL_INT(len, strnlen(whites, len)); + TEST_ASSERT_EQUAL_INT(len, strnlen(whites, len + 1)); /* Checking ascii charset */ + len = BUFF_SIZE; + TEST_ASSERT_EQUAL_INT(len, strlen(asciiSet)); + TEST_ASSERT_EQUAL_INT(len - 1, strnlen(asciiSet, len - 1)); + TEST_ASSERT_EQUAL_INT(len, strnlen(asciiSet, len)); + TEST_ASSERT_EQUAL_INT(len, strnlen(asciiSet, len + 1)); - - sz = BUFF_SIZE; - TEST_ASSERT_EQUAL_INT(sz, strlen(asciiSet)); - TEST_ASSERT_EQUAL_INT(sz - 1, strnlen(asciiSet, sz - 1)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(asciiSet, sz)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(asciiSet, sz + 1)); - - free((void *)asciiSet); + free(asciiSet); } TEST(string_len, not_ascii) { unsigned char charSet[BUFF_SIZE] = { 0 }; - int sz, i; + int len, i; - /* Checking out of ASCII bytes */ + /* Checking out of ASCII bytes */ for (i = sizeof(charSet); i < sizeof(charSet) * 2 - 1; i++) { charSet[i - sizeof(charSet)] = i; } - sz = sizeof(charSet) - 1; - TEST_ASSERT_EQUAL_INT(sz, strlen((const char *)charSet)); - TEST_ASSERT_EQUAL_INT(sz - 1, strnlen((const char *)charSet, sz - 1)); - TEST_ASSERT_EQUAL_INT(sz, strnlen((const char *)charSet, sz)); - TEST_ASSERT_EQUAL_INT(sz, strnlen((const char *)charSet, sz + 1)); + len = sizeof(charSet) - 1; + TEST_ASSERT_EQUAL_INT(len, strlen((const char *)charSet)); + TEST_ASSERT_EQUAL_INT(len - 1, strnlen((const char *)charSet, len - 1)); + TEST_ASSERT_EQUAL_INT(len, strnlen((const char *)charSet, len)); + TEST_ASSERT_EQUAL_INT(len, strnlen((const char *)charSet, len + 1)); } TEST(string_len, big) { char bigStr[PATH_MAX] = { 0 }; - int sz; + int len; /* The length of the string is not restricted, so we test one of bigger value, which may be used */ memset(bigStr, 1, sizeof(bigStr) - 1); - sz = sizeof(bigStr) - 1; - TEST_ASSERT_EQUAL_INT(sz, strlen(bigStr)); - TEST_ASSERT_EQUAL_INT(sz - 1, strnlen(bigStr, sz - 1)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(bigStr, sz)); - TEST_ASSERT_EQUAL_INT(sz, strnlen(bigStr, sz + 1)); + len = sizeof(bigStr) - 1; + TEST_ASSERT_EQUAL_INT(len, strlen(bigStr)); + TEST_ASSERT_EQUAL_INT(len - 1, strnlen(bigStr, len - 1)); + TEST_ASSERT_EQUAL_INT(len, strnlen(bigStr, len)); + TEST_ASSERT_EQUAL_INT(len, strnlen(bigStr, len + 1)); } /* @@ -148,6 +147,219 @@ TEST(string_len, big) */ +TEST_SETUP(string_spn) +{ +} + + +TEST_TEAR_DOWN(string_spn) +{ +} + +TEST(string_spn, basic) +{ + const char pangram[] = " The quick brown fox jumps over the lazy dog"; + char holder[45] = { 0 }; + int len; + + /* Checking if both functions recognize the holder as a different set of elements */ + len = sizeof(pangram) - 1; + + memcpy(holder, pangram, len + 1); + + /* Checking if both functions recognize the holder as the same set of elements */ + TEST_ASSERT_EQUAL_INT(0, strcspn(pangram, holder)); + TEST_ASSERT_EQUAL_INT(len, strspn(pangram, holder)); + + TEST_ASSERT_EQUAL_INT(0, strcspn(pangram, &holder[len / 2])); + /* One because strspn found space as*/ + TEST_ASSERT_EQUAL_INT(1, strspn(pangram, &holder[len / 2])); + + TEST_ASSERT_EQUAL_INT(len, strcspn(pangram, &holder[len])); +} + + +TEST(string_spn, ascii) +{ + char supportCharSet[BUFF_SIZE] = { 0 }, + reversCharSet[BUFF_SIZE] = { 0 }, + *asciiStr; + int i; + + asciiStr = testdata_createCharStr(BUFF_SIZE + 1); + + + for (i = 1; i < BUFF_SIZE; i++) { + supportCharSet[i - 1] = i; + reversCharSet[i - 1] = BUFF_SIZE - i; + + /* + * In this case we need to use fully filled set for strcspn + * because it counts size based on elements that are not + * present in himself + */ + TEST_ASSERT_EQUAL_INT(i - 1, strcspn(&asciiStr[1], &asciiStr[i])); + TEST_ASSERT_EQUAL_INT(i, strspn(&asciiStr[1], supportCharSet)); + + /* Checking if we reverse order strcspn and strspn will find elements that are correct */ + TEST_ASSERT_EQUAL_INT(BUFF_SIZE - 1, strcspn(&asciiStr[1], &reversCharSet[i])); + + if (i == 127) { + TEST_ASSERT_EQUAL_INT(BUFF_SIZE - 1, strspn(&asciiStr[1], reversCharSet)); + } + else { + TEST_ASSERT_EQUAL_INT(0, strspn(&asciiStr[1], reversCharSet)); + } + } + + free(asciiStr); +} + + +TEST(string_spn, not_ascii) +{ + unsigned char charSet[BUFF_SIZE] = { 0 }; + int len, i; + + /* Checking out of ASCII bytes */ + for (i = sizeof(charSet); i < sizeof(charSet) * 2 - 1; i++) { + charSet[i - sizeof(charSet)] = i; + } + + len = sizeof(charSet) - 1; + TEST_ASSERT_EQUAL_INT(len, strcspn((const char *)charSet, "")); + TEST_ASSERT_EQUAL_INT(len, strspn((const char *)charSet, (const char *)charSet)); +} + + +TEST(string_spn, big) +{ + char bigstr[PATH_MAX] = { 0 }; + int len; + + /* + * The length of the string is not restricted, + * so we test one of the bigger values, which may be used + * with remembering the last element must be a null term + * zero to collect the data as the string from + * declared space, that's why we memset one place less than its size + */ + + len = sizeof(bigstr) - 1; + memset(bigstr, 'a', len); + + TEST_ASSERT_EQUAL_INT(len, strcspn(bigstr, "")); + TEST_ASSERT_EQUAL_INT(0, strcspn(bigstr, "a")); + TEST_ASSERT_EQUAL_INT(len, strcspn(bigstr, "b")); + TEST_ASSERT_EQUAL_INT(0, strcspn(bigstr, "ab")); + + TEST_ASSERT_EQUAL_INT(len, strspn(bigstr, "a")); + TEST_ASSERT_EQUAL_INT(0, strspn(bigstr, "")); + TEST_ASSERT_EQUAL_INT(0, strspn(bigstr, "b")); + TEST_ASSERT_EQUAL_INT(len, strspn(bigstr, "ab")); + + bigstr[len - 3] = 'b'; + + TEST_ASSERT_EQUAL_INT(len, strcspn(bigstr, "")); + TEST_ASSERT_EQUAL_INT(0, strcspn(bigstr, "a")); + TEST_ASSERT_EQUAL_INT(len - 3, strcspn(bigstr, "b")); + TEST_ASSERT_EQUAL_INT(0, strcspn(bigstr, "ab")); + + TEST_ASSERT_EQUAL_INT(len - 3, strspn(bigstr, "a")); + TEST_ASSERT_EQUAL_INT(0, strspn(bigstr, "")); + TEST_ASSERT_EQUAL_INT(0, strspn(bigstr, "b")); + TEST_ASSERT_EQUAL_INT(len, strspn(bigstr, "ab")); +} + + +TEST(string_spn, empty_args) +{ + TEST_ASSERT_EQUAL_INT(0, strcspn("", "abc")); + TEST_ASSERT_EQUAL_INT(0, strspn("", "abc")); + + TEST_ASSERT_EQUAL_INT(0, strcspn("", "")); + TEST_ASSERT_EQUAL_INT(0, strspn("", "")); + + TEST_ASSERT_EQUAL_INT(3, strcspn("abc", "")); + TEST_ASSERT_EQUAL_INT(0, strspn("abc", "")); +} + + +/* This case is intended to check the ability to stop at the first byte */ +TEST(string_spn, first_byte) +{ + TEST_ASSERT_EQUAL_INT(0, strspn("abc", "bc")); + TEST_ASSERT_EQUAL_INT(0, strspn("abc", "c")); + TEST_ASSERT_EQUAL_INT(0, strspn("aaaabc", "bc")); + TEST_ASSERT_EQUAL_INT(0, strspn("aaaabc", "c")); + + + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "abc")); + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "abc")); + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "ab")); + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "a")); + TEST_ASSERT_EQUAL_INT(0, strcspn("aaaabc", "ab")); + TEST_ASSERT_EQUAL_INT(0, strcspn("aaaabc", "a")); +} + + +TEST(string_spn, mixed_order) +{ + int i; + char reversStr[BUFF_SIZE], + *testStr; + + testStr = testdata_createCharStr(BUFF_SIZE); + + TEST_ASSERT_NOT_NULL(reversStr); + + for (i = 0; i < BUFF_SIZE - 1; i++) { + reversStr[i] = testStr[BUFF_SIZE - i - 2]; + } + reversStr[BUFF_SIZE - 1] = 0; + + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "cba")); + TEST_ASSERT_EQUAL_INT(3, strspn("abc", "cba")); + + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "bac")); + TEST_ASSERT_EQUAL_INT(3, strspn("abc", "bac")); + + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "bca")); + TEST_ASSERT_EQUAL_INT(3, strspn("abc", "bca")); + + TEST_ASSERT_EQUAL_INT(0, strcspn(testStr, reversStr)); + TEST_ASSERT_EQUAL_INT(BUFF_SIZE - 1, strspn(testStr, reversStr)); + + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "aa")); + TEST_ASSERT_EQUAL_INT(1, strcspn("abc", "bb")); + TEST_ASSERT_EQUAL_INT(2, strcspn("abc", "cc")); + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "aabbcc")); + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "aaaaaa")); + TEST_ASSERT_EQUAL_INT(1, strcspn("abc", "bbbbbb")); + TEST_ASSERT_EQUAL_INT(2, strcspn("abc", "cccccc")); + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "ccaabb")); + TEST_ASSERT_EQUAL_INT(0, strcspn("abc", "bbaacc")); + + + TEST_ASSERT_EQUAL_INT(1, strspn("abc", "aa")); + TEST_ASSERT_EQUAL_INT(0, strspn("abc", "bb")); + TEST_ASSERT_EQUAL_INT(0, strspn("abc", "cc")); + TEST_ASSERT_EQUAL_INT(3, strspn("abc", "aabbcc")); + TEST_ASSERT_EQUAL_INT(1, strspn("abc", "aaaaaa")); + TEST_ASSERT_EQUAL_INT(0, strspn("abc", "bbbbbb")); + TEST_ASSERT_EQUAL_INT(0, strspn("abc", "cccccc")); + TEST_ASSERT_EQUAL_INT(3, strspn("abc", "ccaabb")); + TEST_ASSERT_EQUAL_INT(3, strspn("abc", "bbaacc")); + + free(testStr); +} + + +/* +//////////////////////////////////////////////////////////////////////////////////// +*/ + + TEST_SETUP(string_chr) { } @@ -161,26 +373,26 @@ TEST_TEAR_DOWN(string_chr) TEST(string_chr, basic) { const char *lorem = "Lorem ipsum dolor sit amet, consectetur adipiscing elit y"; - int sz; + int len; - sz = strlen(lorem); + len = strlen(lorem); /* Check of proper working base */ 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_PTR(lorem, memchr(lorem, 'L', len)); 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_PTR(&lorem[14], memchr(lorem, 'l', len)); 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_PTR(NULL, memchr(lorem, 'x', len)); - 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)); + TEST_ASSERT_EQUAL_PTR(&lorem[len], strchr(lorem, lorem[len])); + TEST_ASSERT_EQUAL_PTR(&lorem[len], strrchr(lorem, lorem[len])); + TEST_ASSERT_EQUAL_PTR(&lorem[len], memchr(lorem, lorem[len], len + 1)); } @@ -222,106 +434,106 @@ TEST(string_chr, big) TEST(string_chr, special) { const char specials[] = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"; - int sz; + int len; /* * Testing did strchr don't stop if found special signs * Getting the first element from the string contains only special characters */ - sz = strlen(specials); + len = 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_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 the last element from string contains only special characters */ + TEST_ASSERT_EQUAL_PTR(&specials[len], strchr(specials, specials[len])); + TEST_ASSERT_EQUAL_PTR(&specials[len], strrchr(specials, specials[len])); + TEST_ASSERT_EQUAL_PTR(&specials[len], memchr(specials, specials[len], len + 1)); - /* Getting middle element from string contains only special characters */ - 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 the middle element from string contains only special characters */ + TEST_ASSERT_EQUAL_PTR(&specials[len / 2], strchr(specials, specials[len / 2])); + TEST_ASSERT_EQUAL_PTR(&specials[len / 2], strrchr(specials, specials[len / 2])); + TEST_ASSERT_EQUAL_PTR(&specials[len / 2], memchr(specials, specials[len / 2], len + 1)); /* Getting element which is not into string */ 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_ASSERT_EQUAL_PTR(NULL, memchr(specials, 'I', len)); } TEST(string_chr, ascii) { - int sz; + int len; char *asciiStr; asciiStr = testdata_createCharStr(INT8_MAX + 1); - sz = INT8_MAX; + len = INT8_MAX; 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_PTR(asciiStr, memchr(asciiStr, asciiStr[0], len + 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_PTR(&asciiStr[len / 2], strchr(asciiStr, asciiStr[len / 2])); + TEST_ASSERT_EQUAL_PTR(&asciiStr[len / 2], strrchr(asciiStr, asciiStr[len / 2])); + TEST_ASSERT_EQUAL_PTR(&asciiStr[len / 2], memchr(asciiStr, asciiStr[len / 2], len + 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_PTR(&asciiStr[len], strchr(asciiStr, asciiStr[len])); + TEST_ASSERT_EQUAL_PTR(&asciiStr[len], strrchr(asciiStr, asciiStr[len])); + TEST_ASSERT_EQUAL_PTR(&asciiStr[len], memchr(asciiStr, asciiStr[len], len + 1)); - free((void *)asciiStr); + free(asciiStr); } TEST(string_chr, not_ascii) { char charSet[BUFF_SIZE] = { 0 }; - int sz, i; + int len, i; - /* Checking out of ASCII bytes */ + /* Checking out of ASCII bytes */ 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); + len = sizeof(charSet); 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_PTR(charSet, memchr(charSet, charSet[0], len)); 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_PTR(&charSet[64], memchr(charSet, charSet[64], len)); - 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)); + TEST_ASSERT_EQUAL_PTR(&charSet[len - 1], strchr(charSet, charSet[len - 1])); + TEST_ASSERT_EQUAL_PTR(&charSet[len - 1], strrchr(charSet, charSet[len - 1])); + TEST_ASSERT_EQUAL_PTR(&charSet[len - 1], memchr(charSet, charSet[len - 1], len)); } TEST(string_chr, torn) { char *torn = "foo\0bar"; - int sz; + int len; /* Checking correct working of null terminating point */ - sz = strlen(torn) + 1; + len = strlen(torn) + 1; TEST_ASSERT_EQUAL_STRING("", strchr(torn, '\0')); TEST_ASSERT_EQUAL_STRING("", strrchr(torn, '\0')); - TEST_ASSERT_EQUAL_STRING("", memchr(torn, '\0', sz)); + TEST_ASSERT_EQUAL_STRING("", memchr(torn, '\0', len)); TEST_ASSERT_EQUAL_STRING("foo", strchr(torn, 'f')); TEST_ASSERT_EQUAL_STRING("foo", strrchr(torn, 'f')); - TEST_ASSERT_EQUAL_STRING("foo", memchr(torn, 'f', sz)); + TEST_ASSERT_EQUAL_STRING("foo", memchr(torn, 'f', len)); 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)); + TEST_ASSERT_EQUAL_PTR(NULL, memchr(torn, 'b', len)); } @@ -330,12 +542,12 @@ 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, i; + int len, i; /* Checking if white signs don't make any interference on functions output */ - sz = sizeof(whites) - 1; + len = sizeof(whites) - 1; - for (i = 0; i < sz; i++) { + for (i = 0; i < len; 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)); @@ -343,13 +555,13 @@ TEST(string_chr, whitespaces) 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)); + TEST_ASSERT_EQUAL_PTR(NULL, memchr(whites, 'x', len)); - sz = strlen(strWhites); + len = strlen(strWhites); /* Testing if whitespaces interference output of functions */ TEST_ASSERT_EQUAL_STRING(exp, strchr(strWhites, 'I')); TEST_ASSERT_EQUAL_STRING(exp, strrchr(strWhites, 'I')); - TEST_ASSERT_EQUAL_STRING(exp, memchr(strWhites, 'I', sz)); + TEST_ASSERT_EQUAL_STRING(exp, memchr(strWhites, 'I', len)); } @@ -379,7 +591,7 @@ TEST(string_chr, memchr_size) TEST_ASSERT_EQUAL_PTR(&charSet[i], memchr(charSet, charSet[i], i + 1)); /* * In this case, the size of the search is the same as the place - * where is search char placed and memchr never meets + * where is the search char placed and memchr never meets * the criteria to find it */ TEST_ASSERT_EQUAL_PTR(NULL, memchr(charSet, charSet[i], i)); @@ -400,6 +612,18 @@ TEST_GROUP_RUNNER(string_len) } +TEST_GROUP_RUNNER(string_spn) +{ + RUN_TEST_CASE(string_spn, basic); + RUN_TEST_CASE(string_spn, ascii); + RUN_TEST_CASE(string_spn, not_ascii); + RUN_TEST_CASE(string_spn, empty_args); + RUN_TEST_CASE(string_spn, first_byte); + RUN_TEST_CASE(string_spn, mixed_order); + RUN_TEST_CASE(string_spn, big); +} + + TEST_GROUP_RUNNER(string_chr) { RUN_TEST_CASE(string_chr, basic);