Skip to content

Commit

Permalink
libc: string.h: add cmp functions tests
Browse files Browse the repository at this point in the history 
JIRA: CI-231
  • Loading branch information
@maska989
maska989 committed May 29, 2023
1 parent 8ea3b64 commit 2b198ec
Show file tree
Hide file tree
Showing 2 changed files with 151 additions and 51 deletions.
5 changes: 4 additions & 1 deletion libc/main.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}


Expand Down
197 changes: 147 additions & 50 deletions libc/string_cmp.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -22,11 +22,8 @@
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include <limits.h>
#include <unity_fixture.h>


Expand All @@ -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;

Expand All @@ -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);
}


Expand All @@ -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;

Expand All @@ -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));
}


Expand All @@ -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);
}


Expand All @@ -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));
Expand All @@ -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);
}

0 comments on commit 2b198ec

Please sign in to comment.