From 2b198ecebe9fd5bc499083242651b43de5f9b351 Mon Sep 17 00:00:00 2001 From: Damian Modzelewski Date: Fri, 28 Apr 2023 09:55:27 +0200 Subject: [PATCH] libc: string.h: add cmp functions tests JIRA: CI-231 --- libc/main.c | 5 +- libc/string_cmp.c | 197 ++++++++++++++++++++++++++++++++++------------ 2 files changed, 151 insertions(+), 51 deletions(-) diff --git a/libc/main.c b/libc/main.c index 9a91c6c0d..aef3657de 100644 --- a/libc/main.c +++ b/libc/main.c @@ -54,7 +54,10 @@ void runner(void) RUN_TEST_GROUP(stdio_scanf_squareBrackets); RUN_TEST_GROUP(stdio_scanf_rest); RUN_TEST_GROUP(string_chr); - RUN_TEST_GROUP(string_cmp); + RUN_TEST_GROUP(mem_cmp); + RUN_TEST_GROUP(strn_cmp); + RUN_TEST_GROUP(str_cmp); + RUN_TEST_GROUP(strcoll_cmp); } diff --git a/libc/string_cmp.c b/libc/string_cmp.c index 0b8a2ca86..c12546953 100644 --- a/libc/string_cmp.c +++ b/libc/string_cmp.c @@ -22,11 +22,8 @@ #include #include #include -#include #include -#include #include -#include #include @@ -35,50 +32,64 @@ static char asciiSet[BUFF_SIZE] = { 0 }, nonZeroAsciiSet[BUFF_SIZE] = { 0 }, empty[BUFF_SIZE] = { 0 }, + ucharSet[UCHAR_MAX] = { 0 }, + ucharEmpty[UCHAR_MAX] = { 0 }, + hugeString[INT16_MAX] = { 0 }, + hugeZeroString[INT16_MAX] = { 0 }, separated[24] = { 0, 0, 0, 0, 0, 0, 'T', 'E', 'S', 'T', 0, 0, 0 }; -TEST_GROUP(string_cmp); +TEST_GROUP(mem_cmp); +TEST_GROUP(strn_cmp); +TEST_GROUP(str_cmp); +TEST_GROUP(strcoll_cmp); +/* +//////////////////////////////////////////////////////////////////////////////////////////////////////////////// +*/ -TEST_SETUP(string_cmp) + +TEST_SETUP(mem_cmp) { + errno = 0; } -TEST_TEAR_DOWN(string_cmp) +TEST_TEAR_DOWN(mem_cmp) { } -/* -//////////////////////////////////////////////////////////////////////////////////////////////////////////////// -*/ - - -TEST(string_cmp, memcmp_basic) +TEST(mem_cmp, memcmp_basic) { TEST_ASSERT_EQUAL_INT(0, memcmp(asciiSet, asciiSet, BUFF_SIZE)); TEST_ASSERT_LESS_THAN_INT(0, memcmp(asciiSet, nonZeroAsciiSet, BUFF_SIZE)); TEST_ASSERT_GREATER_THAN_INT(0, memcmp(nonZeroAsciiSet, asciiSet, BUFF_SIZE)); - TEST_ASSERT_EQUAL_INT(0, errno); + TEST_ASSERT_LESS_THAN_INT(0, memcmp(ucharEmpty, ucharSet, UCHAR_MAX - 1)); } -TEST(string_cmp, memcmp_empty) +TEST(mem_cmp, memcmp_empty) { TEST_ASSERT_LESS_THAN_INT(0, memcmp(empty, asciiSet, BUFF_SIZE)); TEST_ASSERT_LESS_THAN_INT(0, memcmp(empty, nonZeroAsciiSet, BUFF_SIZE)); TEST_ASSERT_GREATER_THAN_INT(0, memcmp(asciiSet, empty, BUFF_SIZE)); TEST_ASSERT_EQUAL_INT(0, memcmp(empty, empty, BUFF_SIZE)); - /* memory cmp is not sensitive for NUL characters */ + /* Memory cmp is not sensitive for NUL characters */ TEST_ASSERT_NOT_EQUAL_INT(0, memcmp(empty, separated, sizeof(separated))); - TEST_ASSERT_EQUAL_INT(0, errno); +} + +TEST(mem_cmp, memcmp_big) +{ + + TEST_ASSERT_EQUAL_INT(0, memcmp(hugeString, hugeString, sizeof(hugeString))); + TEST_ASSERT_LESS_THAN_INT(0, memcmp(hugeZeroString, hugeString, sizeof(hugeString))); + TEST_ASSERT_EQUAL_INT(0, memcmp(hugeZeroString, hugeZeroString, sizeof(hugeString))); } -TEST(string_cmp, memcmp_sizes) +TEST(mem_cmp, memcmp_sizes) { int i; @@ -91,8 +102,6 @@ TEST(string_cmp, memcmp_sizes) for (i = 1; i < sizeof(asciiSet); i++) { TEST_ASSERT_LESS_THAN_INT(0, memcmp(asciiSet, nonZeroAsciiSet, i)); } - - TEST_ASSERT_EQUAL_INT(0, errno); } @@ -101,29 +110,47 @@ TEST(string_cmp, memcmp_sizes) */ -TEST(string_cmp, strncmp_basic) +TEST_SETUP(strn_cmp) +{ +} + + +TEST_TEAR_DOWN(strn_cmp) +{ +} + + +TEST(strn_cmp, strn_basic) { TEST_ASSERT_EQUAL_INT(0, strncmp(asciiSet, asciiSet, BUFF_SIZE)); TEST_ASSERT_LESS_THAN_INT(0, strncmp(asciiSet, nonZeroAsciiSet, BUFF_SIZE)); TEST_ASSERT_GREATER_THAN_INT(0, strncmp(nonZeroAsciiSet, asciiSet, BUFF_SIZE)); - TEST_ASSERT_EQUAL_INT(0, errno); + + /* We avoid the first place of ucharSet because it is a null terminator which means strncmp will stop its compare */ + TEST_ASSERT_LESS_THAN_INT(0, strncmp(&ucharEmpty[1], &ucharSet[1], UCHAR_MAX - 1)); } -TEST(string_cmp, strncmp_empty) +TEST(strn_cmp, strn_empty) { TEST_ASSERT_EQUAL_INT(0, strncmp(empty, asciiSet, BUFF_SIZE)); TEST_ASSERT_LESS_THAN_INT(0, strncmp(empty, nonZeroAsciiSet, BUFF_SIZE)); TEST_ASSERT_EQUAL_INT(0, strncmp(asciiSet, empty, BUFF_SIZE)); TEST_ASSERT_EQUAL_INT(0, strncmp(empty, empty, BUFF_SIZE)); - /* otherwise than in memcmp strncmp is NUL character sensitive and treat 0 as end of array */ + /* Otherwise than in memcmp, strncmp is NUL character sensitive and treats 0 as the end of array */ TEST_ASSERT_EQUAL_INT(0, strncmp(empty, separated, BUFF_SIZE)); - TEST_ASSERT_EQUAL_INT(0, errno); +} + +TEST(strn_cmp, strn_big) +{ + TEST_ASSERT_EQUAL_INT(0, strncmp(hugeString, hugeString, sizeof(hugeString))); + TEST_ASSERT_LESS_THAN_INT(0, strncmp(hugeZeroString, hugeString, sizeof(hugeString))); + TEST_ASSERT_EQUAL_INT(0, strncmp(hugeZeroString, hugeZeroString, sizeof(hugeString))); } -TEST(string_cmp, strncmp_sizes) +TEST(strn_cmp, strn_sizes) { int i; @@ -137,7 +164,8 @@ TEST(string_cmp, strncmp_sizes) TEST_ASSERT_LESS_THAN_INT(0, strncmp(asciiSet, nonZeroAsciiSet, i)); } - TEST_ASSERT_EQUAL_INT(0, errno); + /* Testing size bigger than string having in mind the compare will end with null terminator */ + TEST_ASSERT_EQUAL_INT(0, strncmp(asciiSet, asciiSet, SIZE_MAX)); } @@ -146,30 +174,48 @@ TEST(string_cmp, strncmp_sizes) */ -TEST(string_cmp, strcmp_basic) +TEST_SETUP(str_cmp) +{ +} + + +TEST_TEAR_DOWN(str_cmp) +{ +} + + +TEST(str_cmp, strcmp_basic) { TEST_ASSERT_EQUAL_INT(0, strcmp(asciiSet, asciiSet)); TEST_ASSERT_LESS_THAN_INT(0, strcmp(asciiSet, nonZeroAsciiSet)); TEST_ASSERT_GREATER_THAN_INT(0, strcmp(nonZeroAsciiSet, asciiSet)); - TEST_ASSERT_EQUAL_INT(0, errno); + + /* We avoid the first place of ucharSet because it is a null terminator which means strcmp will stop its compare */ + TEST_ASSERT_LESS_THAN_INT(0, strcmp(&ucharEmpty[1], &ucharSet[1])); } -TEST(string_cmp, strcmp_empty) +TEST(str_cmp, strcmp_empty) { TEST_ASSERT_EQUAL_INT(0, strcmp(empty, asciiSet)); TEST_ASSERT_LESS_THAN_INT(0, strcmp(empty, nonZeroAsciiSet)); TEST_ASSERT_EQUAL_INT(0, strcmp(asciiSet, empty)); TEST_ASSERT_EQUAL_INT(0, strcmp(empty, empty)); - TEST_ASSERT_EQUAL_INT(0, errno); } -TEST(string_cmp, strcmp_sizes) +TEST(str_cmp, strcmp_big) +{ + TEST_ASSERT_EQUAL_INT(0, strcmp(hugeString, hugeString)); + TEST_ASSERT_LESS_THAN_INT(0, strcmp(hugeZeroString, hugeString)); + TEST_ASSERT_EQUAL_INT(0, strcmp(hugeZeroString, hugeZeroString)); +} + + +TEST(str_cmp, strcmp_sizes) { TEST_ASSERT_LESS_THAN_INT(0, strcmp(&asciiSet[BUFF_SIZE / 2], &nonZeroAsciiSet[BUFF_SIZE / 2])); TEST_ASSERT_GREATER_THAN_INT(0, strcmp(&asciiSet[sizeof(asciiSet) - 1], &nonZeroAsciiSet[sizeof(nonZeroAsciiSet) - 1])); - TEST_ASSERT_EQUAL_INT(0, errno); } @@ -178,16 +224,31 @@ TEST(string_cmp, strcmp_sizes) */ -TEST(string_cmp, strcoll_basic) +TEST_SETUP(strcoll_cmp) +{ + errno = 0; +} + + +TEST_TEAR_DOWN(strcoll_cmp) +{ +} + + +TEST(strcoll_cmp, strcoll_basic) { TEST_ASSERT_EQUAL_INT(0, strcoll(asciiSet, asciiSet)); TEST_ASSERT_LESS_THAN_INT(0, strcoll(asciiSet, nonZeroAsciiSet)); TEST_ASSERT_GREATER_THAN_INT(0, strcoll(nonZeroAsciiSet, asciiSet)); + + /* We avoid the first place of ucharSet because it is a null terminator which means strcoll will stop its compare */ + TEST_ASSERT_LESS_THAN_INT(0, strcoll(&ucharEmpty[1], &ucharSet[1])); + TEST_ASSERT_EQUAL_INT(0, errno); } -TEST(string_cmp, strcoll_empty) +TEST(strcoll_cmp, strcoll_empty) { TEST_ASSERT_EQUAL_INT(0, strcoll(empty, asciiSet)); TEST_ASSERT_LESS_THAN_INT(0, strcoll(empty, nonZeroAsciiSet)); @@ -197,42 +258,78 @@ TEST(string_cmp, strcoll_empty) } -TEST(string_cmp, strcoll_sizes) +TEST(strcoll_cmp, strcoll_big) +{ + TEST_ASSERT_EQUAL_INT(0, strcoll(hugeString, hugeString)); + TEST_ASSERT_LESS_THAN_INT(0, strcoll(hugeZeroString, hugeString)); + TEST_ASSERT_EQUAL_INT(0, strcoll(hugeZeroString, hugeZeroString)); +} + + +TEST(strcoll_cmp, strcoll_sizes) { TEST_ASSERT_LESS_THAN_INT(0, strcoll(&asciiSet[BUFF_SIZE / 2], &nonZeroAsciiSet[BUFF_SIZE / 2])); TEST_ASSERT_GREATER_THAN_INT(0, strcoll(&asciiSet[sizeof(asciiSet) - 1], &nonZeroAsciiSet[sizeof(nonZeroAsciiSet) - 1])); TEST_ASSERT_EQUAL_INT(0, errno); } - /* //////////////////////////////////////////////////////////////////////////////////////////////////////////////// */ -TEST_GROUP_RUNNER(string_cmp) +TEST_GROUP_RUNNER(mem_cmp) { + /* Creating all needed data sets to run test cases */ int i; for (i = 1; i < BUFF_SIZE; i++) { nonZeroAsciiSet[i - 1] = i; asciiSet[i] = i; } - errno = 0; - RUN_TEST_CASE(string_cmp, memcmp_basic); - RUN_TEST_CASE(string_cmp, memcmp_empty); - RUN_TEST_CASE(string_cmp, memcmp_sizes); + i = 0; - RUN_TEST_CASE(string_cmp, strncmp_basic); - RUN_TEST_CASE(string_cmp, strncmp_empty); - RUN_TEST_CASE(string_cmp, strncmp_sizes); + for (; i < UCHAR_MAX - 1; i++) { + ucharSet[i] = i; + } - RUN_TEST_CASE(string_cmp, strcmp_basic); - RUN_TEST_CASE(string_cmp, strcmp_empty); - RUN_TEST_CASE(string_cmp, strcmp_sizes); + i = 0; + + for (; i < INT16_MAX - 1; i++) { + hugeString[i] = i % 256; + /* Avoid null term to get one long string */ + if (i % 256 == 0 || i == 0) { + hugeString[i] = (i % 256) + 1; + } + } - RUN_TEST_CASE(string_cmp, strcoll_basic); - RUN_TEST_CASE(string_cmp, strcoll_empty); - RUN_TEST_CASE(string_cmp, strcoll_sizes); + RUN_TEST_CASE(mem_cmp, memcmp_basic); + RUN_TEST_CASE(mem_cmp, memcmp_empty); + RUN_TEST_CASE(mem_cmp, memcmp_big); + RUN_TEST_CASE(mem_cmp, memcmp_sizes); +} + +TEST_GROUP_RUNNER(strn_cmp) +{ + RUN_TEST_CASE(strn_cmp, strn_basic); + RUN_TEST_CASE(strn_cmp, strn_empty); + RUN_TEST_CASE(strn_cmp, strn_big); + RUN_TEST_CASE(strn_cmp, strn_sizes); +} + +TEST_GROUP_RUNNER(str_cmp) +{ + RUN_TEST_CASE(str_cmp, strcmp_basic); + RUN_TEST_CASE(str_cmp, strcmp_empty); + RUN_TEST_CASE(str_cmp, strcmp_big); + RUN_TEST_CASE(str_cmp, strcmp_sizes); +} + +TEST_GROUP_RUNNER(strcoll_cmp) +{ + RUN_TEST_CASE(strcoll_cmp, strcoll_basic); + RUN_TEST_CASE(strcoll_cmp, strcoll_empty); + RUN_TEST_CASE(strcoll_cmp, strcoll_big); + RUN_TEST_CASE(strcoll_cmp, strcoll_sizes); } \ No newline at end of file