diff --git a/libc/string/string_cmp.c b/libc/string/string_cmp.c index c4a5f7ae7..aa74eaceb 100644 --- a/libc/string/string_cmp.c +++ b/libc/string/string_cmp.c @@ -26,18 +26,19 @@ #include #include +#include "testdata.h" + #define BUFF_SIZE 128 -static char asciiSet[BUFF_SIZE] = { 0 }, - nonZeroAsciiSet[BUFF_SIZE] = { 0 }, - outOfAsciiSet[UCHAR_MAX] = { 0 }, - empty[BUFF_SIZE] = { 0 }, - ucharSet[UCHAR_MAX] = { 0 }, - ucharEmpty[UCHAR_MAX] = { 0 }, - hugeString[INT16_MAX] = { 0 }, +static char empty[BUFF_SIZE] = { 0 }, + support[BUFF_SIZE] = { 0 }, hugeZeroString[INT16_MAX] = { 0 }, - separated[24] = { 0, 0, 0, 0, 0, 0, 'T', 'E', 'S', 'T', 0, 0, 0 }; + charEdgeValue[1] = { 0 }, + separated[24] = { 0, 0, 0, 0, 0, 0, 'T', 'E', 'S', 'T', 0, 0, 0 }, + *asciiSet, + *hugeString, + *nonZeroAsciiSet; TEST_GROUP(string_memcmp); @@ -65,31 +66,32 @@ TEST(string_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_LESS_THAN_INT(0, memcmp(ucharEmpty, ucharSet, UCHAR_MAX)); } TEST(string_memcmp, unsignedChar) { - char holderOutOfAscii[UCHAR_MAX] = { 0 }; - /* - * Loop for creating a buffer similar to ucharSet but with negative values - * to check the ability of memcmp to convert elements to unsigned char + * Checking do memcmp convert elements of input to unsigned char + * If we get a value less than 0 that means memcmp treats the value of s1 as + * signed char and return diff between -127 and 0 + * otherwise it will calculate the difference between 254 and 0 and memcmp will return + * negative value */ - for (int i = 0; i < sizeof(holderOutOfAscii); i++) { - holderOutOfAscii[i] = outOfAsciiSet[sizeof(outOfAsciiSet) - 1 - i]; - } + charEdgeValue[0] = CHAR_MIN + 1; + TEST_ASSERT_GREATER_THAN_INT(0, memcmp(charEdgeValue, "\0", 1)); - TEST_ASSERT_EQUAL_INT(0, memcmp(ucharSet, holderOutOfAscii, sizeof(holderOutOfAscii))); + charEdgeValue[0] = CHAR_MAX + 1; + TEST_ASSERT_GREATER_THAN_INT(0, memcmp(charEdgeValue, "\0", 1)); } TEST(string_memcmp, emptyInput) { 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_LESS_THAN_INT(0, memcmp(empty, nonZeroAsciiSet, BUFF_SIZE)); + TEST_ASSERT_GREATER_THAN_INT(0, memcmp(nonZeroAsciiSet, empty, BUFF_SIZE)); TEST_ASSERT_EQUAL_INT(0, memcmp(empty, empty, BUFF_SIZE)); /* Memory cmp is not sensitive for NUL characters */ @@ -99,24 +101,29 @@ TEST(string_memcmp, emptyInput) TEST(string_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_GREATER_THAN_INT(0, memcmp(hugeString, hugeZeroString, sizeof(hugeString))); - TEST_ASSERT_EQUAL_INT(0, memcmp(hugeZeroString, hugeZeroString, sizeof(hugeString))); + TEST_ASSERT_EQUAL_INT(0, memcmp(hugeString, hugeString, INT16_MAX)); + TEST_ASSERT_LESS_THAN_INT(0, memcmp(hugeZeroString, hugeString, INT16_MAX)); + TEST_ASSERT_GREATER_THAN_INT(0, memcmp(hugeString, hugeZeroString, INT16_MAX)); + TEST_ASSERT_EQUAL_INT(0, memcmp(hugeZeroString, hugeZeroString, INT16_MAX)); } -TEST(string_memcmp, sizes) +TEST(string_memcmp, various_sizes) { int i; - /* Memory cmp is not sensitive for NUL characters */ - TEST_ASSERT_NOT_EQUAL_INT(0, memcmp(empty, separated, sizeof(separated))); - - - /* Loop which changes the size of compared space to place where asciSet ends */ - for (i = 1; i < sizeof(asciiSet); i++) { + for (i = 1; i < BUFF_SIZE; i++) { + /* Checking various sizes of compare passed to memcmp */ TEST_ASSERT_LESS_THAN_INT(0, memcmp(asciiSet, nonZeroAsciiSet, i)); + + /* + * The testing compares elements that value are every time on a different spot + * and will check if the placement of the dataset on s1 and s2 will not impact on this + */ + support[i] = 1; + TEST_ASSERT_LESS_THAN_INT(0, memcmp(empty, support, BUFF_SIZE)); + TEST_ASSERT_GREATER_THAN_INT(0, memcmp(support, empty, BUFF_SIZE)); + support[i] = 0; } } @@ -125,33 +132,43 @@ TEST(string_memcmp, offsets) { char dataSet[4000] = { 0 }, - supportSet[4000] = { 0 }; - int s1, s2, szOffset, sz = sizeof(dataSet); + supportSet[4000] = { 0 }, + *diffDataSetMemPlace; + int s1Offs, s2Offs, szOffset, sz = sizeof(dataSet); - for (s1 = 0; s1 < sz; s1++) { - dataSet[s1] = (unsigned char)s1; - supportSet[s1] = (unsigned char)s1; + for (s1Offs = 0; s1Offs < sz; s1Offs++) { + dataSet[s1Offs] = s1Offs; + supportSet[s1Offs] = s1Offs; } - /*Testing different offset of data blocks*/ - for (s1 = 0; s1 < 8; s1++) { - for (s2 = 0; s2 < 8; s2++) { + diffDataSetMemPlace = malloc(sizeof(char) * sz + 1); + memcpy(diffDataSetMemPlace, dataSet, sz); + + /*Testing different offset of data blocks with same space or different*/ + for (s1Offs = 0; s1Offs < 8; s1Offs++) { + for (s2Offs = 0; s2Offs < 8; s2Offs++) { for (szOffset = 0; szOffset < 8; szOffset++) { - if (s2 < s1) { - TEST_ASSERT_GREATER_THAN_INT(0, memcmp(&dataSet[s1], &dataSet[s2], sz - (s1 + szOffset))); - TEST_ASSERT_GREATER_THAN_INT(0, memcmp(&dataSet[s1], &supportSet[s2], sz - (s1 + szOffset))); + + if (s2Offs < s1Offs) { + TEST_ASSERT_GREATER_THAN_INT(0, memcmp(&dataSet[s1Offs], &dataSet[s2Offs], sz - (s1Offs + szOffset))); + TEST_ASSERT_GREATER_THAN_INT(0, memcmp(&dataSet[s1Offs], &supportSet[s2Offs], sz - (s1Offs + szOffset))); + TEST_ASSERT_GREATER_THAN_INT(0, memcmp(&diffDataSetMemPlace[s1Offs], &supportSet[s2Offs], sz - (s1Offs + szOffset))); } - else if (s2 == s1) { - TEST_ASSERT_EQUAL_INT(0, memcmp(&dataSet[s1], &dataSet[s2], sz - (s1 + s2 + szOffset))); - TEST_ASSERT_EQUAL_INT(0, memcmp(&dataSet[s1], &supportSet[s2], sz - (s1 + s2 + szOffset))); + else if (s2Offs == s1Offs) { + TEST_ASSERT_EQUAL_INT(0, memcmp(&dataSet[s1Offs], &dataSet[s2Offs], sz - (s1Offs + s2Offs + szOffset))); + TEST_ASSERT_EQUAL_INT(0, memcmp(&dataSet[s1Offs], &supportSet[s2Offs], sz - (s1Offs + s2Offs + szOffset))); + TEST_ASSERT_EQUAL_INT(0, memcmp(&diffDataSetMemPlace[s1Offs], &supportSet[s2Offs], sz - (s1Offs + s2Offs + szOffset))); } else { - TEST_ASSERT_LESS_THAN_INT(0, memcmp(&dataSet[s1], &dataSet[s2], sz - (s2 + szOffset))); - TEST_ASSERT_LESS_THAN_INT(0, memcmp(&dataSet[s1], &supportSet[s2], sz - (s2 + szOffset))); + TEST_ASSERT_LESS_THAN_INT(0, memcmp(&dataSet[s1Offs], &dataSet[s2Offs], sz - (s2Offs + szOffset))); + TEST_ASSERT_LESS_THAN_INT(0, memcmp(&dataSet[s1Offs], &supportSet[s2Offs], sz - (s2Offs + szOffset))); + TEST_ASSERT_LESS_THAN_INT(0, memcmp(&diffDataSetMemPlace[s1Offs], &supportSet[s2Offs], sz - (s2Offs + szOffset))); } } } } + + free(diffDataSetMemPlace); } @@ -175,36 +192,32 @@ TEST(string_strncmp, 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)); - - /* - * We avoid the first place of ucharSet and set size smaller of that place - * 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_strncmp, unsignedChar) { - char holderOutOfAscii[UCHAR_MAX] = { 0 }; - /* - * Loop for creating a buffer similar to ucharSet but with negative values - * to check the ability of strncmp to convert elements to unsigned char + * Checking do strncmp convert elements of input to unsigned char + * If we get a value less than 0 that means strncmp treats the value of s1 as + * signed char and return diff between -127 and 0 + * otherwise it will calculate the difference between 254 and 0 and strncmp will return + * negative value */ - for (int i = 0; i < sizeof(holderOutOfAscii); i++) { - holderOutOfAscii[i] = outOfAsciiSet[sizeof(outOfAsciiSet) - 1 - i]; - } + charEdgeValue[0] = CHAR_MIN + 1; + TEST_ASSERT_GREATER_THAN_INT(0, strncmp(charEdgeValue, "\0", 1)); - TEST_ASSERT_EQUAL_INT(0, strncmp(ucharSet, holderOutOfAscii, sizeof(holderOutOfAscii))); + charEdgeValue[0] = CHAR_MAX + 1; + TEST_ASSERT_GREATER_THAN_INT(0, strncmp(charEdgeValue, "\0", 1)); } TEST(string_strncmp, emptyInput) { 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_LESS_THAN_INT(0, strncmp(empty, nonZeroAsciiSet, BUFF_SIZE)); + TEST_ASSERT_GREATER_THAN_INT(0, strncmp(nonZeroAsciiSet, empty, BUFF_SIZE)); TEST_ASSERT_EQUAL_INT(0, strncmp(empty, empty, BUFF_SIZE)); /* Otherwise than in memcmp, strncmp is NUL character sensitive and treats 0 as the end of array */ @@ -213,24 +226,24 @@ TEST(string_strncmp, emptyInput) TEST(string_strncmp, 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_ASSERT_EQUAL_INT(0, strncmp(hugeString, hugeString, INT16_MAX)); + TEST_ASSERT_LESS_THAN_INT(0, strncmp(hugeZeroString, hugeString, INT16_MAX)); + TEST_ASSERT_EQUAL_INT(0, strncmp(hugeZeroString, hugeZeroString, INT16_MAX)); } -TEST(string_strncmp, sizes) +TEST(string_strncmp, various_sizes) { int i; - TEST_ASSERT_LESS_THAN_INT(0, strncmp(&asciiSet[BUFF_SIZE / 2], &nonZeroAsciiSet[BUFF_SIZE / 2], BUFF_SIZE / 2)); - TEST_ASSERT_GREATER_THAN_INT(0, strncmp(&asciiSet[sizeof(asciiSet) - 1], &nonZeroAsciiSet[sizeof(nonZeroAsciiSet) - 1], 1)); - TEST_ASSERT_LESS_THAN_INT(0, strncmp(&nonZeroAsciiSet[BUFF_SIZE - 1], &asciiSet[BUFF_SIZE - 1], 1)); - TEST_ASSERT_EQUAL_INT(0, strncmp(&nonZeroAsciiSet[sizeof(nonZeroAsciiSet) - 1], &nonZeroAsciiSet[sizeof(nonZeroAsciiSet) - 1], BUFF_SIZE - 1)); + TEST_ASSERT_EQUAL_INT(0, strncmp(&asciiSet[BUFF_SIZE / 2], &nonZeroAsciiSet[BUFF_SIZE / 2], BUFF_SIZE / 2)); + TEST_ASSERT_EQUAL_INT(0, strncmp(&asciiSet[BUFF_SIZE - 1], &nonZeroAsciiSet[BUFF_SIZE - 1], 1)); + TEST_ASSERT_EQUAL_INT(0, strncmp(&nonZeroAsciiSet[BUFF_SIZE - 1], &asciiSet[BUFF_SIZE - 1], 1)); + TEST_ASSERT_EQUAL_INT(0, strncmp(&nonZeroAsciiSet[BUFF_SIZE - 1], &nonZeroAsciiSet[BUFF_SIZE - 1], BUFF_SIZE - 1)); TEST_ASSERT_EQUAL_INT(0, strncmp(asciiSet, nonZeroAsciiSet, 0)); /* Loop which changes the size of compared space to place where asciSet ends */ - for (i = 1; i < sizeof(asciiSet); i++) { + for (i = 1; i < BUFF_SIZE - 1; i++) { TEST_ASSERT_LESS_THAN_INT(0, strncmp(asciiSet, nonZeroAsciiSet, i)); } @@ -259,41 +272,32 @@ TEST(string_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)); - - /* 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_strcmp, unsignedChar) { - char holderOutOfAscii[UCHAR_MAX] = { 0 }; - - /* - * Loop for creating a buffer similar to ucharSet but with negative values - * to check the ability of strcmp to convert elements to unsigned char - */ - for (int i = 0; i < sizeof(holderOutOfAscii); i++) { - holderOutOfAscii[i] = outOfAsciiSet[sizeof(outOfAsciiSet) - 1 - i]; - } - /* - * From lack of defined space size on which CMP is done we are forced to - * set up the last elements of arrays as NULL terms to indicate - * stop point + * Checking do strcmp convert elements of input to unsigned char + * If we get a value less than 0 that means strcmp treats the value of s1 as + * signed char and return diff between -127 and 0 + * otherwise it will calculate the difference between 254 and 0 and strcmp will return + * negative value */ - ucharSet[sizeof(ucharSet) - 1] = 0; - holderOutOfAscii[sizeof(holderOutOfAscii) - 1] = 0; + charEdgeValue[0] = CHAR_MIN + 1; + TEST_ASSERT_GREATER_THAN_INT(0, strcmp(charEdgeValue, "\0")); - TEST_ASSERT_EQUAL_INT(0, strcmp(ucharSet, holderOutOfAscii)); + charEdgeValue[0] = CHAR_MAX + 1; + TEST_ASSERT_GREATER_THAN_INT(0, strcmp(charEdgeValue, "\0")); } TEST(string_strcmp, emptyInput) { 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_LESS_THAN_INT(0, strcmp(empty, nonZeroAsciiSet)); + TEST_ASSERT_GREATER_THAN_INT(0, strcmp(nonZeroAsciiSet, empty)); TEST_ASSERT_EQUAL_INT(0, strcmp(empty, empty)); } @@ -306,10 +310,10 @@ TEST(string_strcmp, big) } -TEST(string_strcmp, sizes) +TEST(string_strcmp, various_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, strcmp(&asciiSet[BUFF_SIZE / 2], &nonZeroAsciiSet[BUFF_SIZE / 2])); + TEST_ASSERT_EQUAL_INT(0, strcmp(&asciiSet[BUFF_SIZE - 1], &nonZeroAsciiSet[BUFF_SIZE - 1])); } @@ -335,9 +339,6 @@ TEST(string_strcoll, basic) 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); } @@ -362,8 +363,8 @@ TEST(string_strcoll, big) TEST(string_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, strcoll(&asciiSet[BUFF_SIZE / 2], &nonZeroAsciiSet[BUFF_SIZE / 2])); + TEST_ASSERT_EQUAL_INT(0, strcoll(&asciiSet[BUFF_SIZE - 1], &nonZeroAsciiSet[BUFF_SIZE - 1])); TEST_ASSERT_EQUAL_INT(0, errno); } @@ -376,31 +377,18 @@ TEST(string_strcoll, sizes) TEST_GROUP_RUNNER(string_memcmp) { /* 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; - } + nonZeroAsciiSet = testdata_createCharStr(BUFF_SIZE); + asciiSet = testdata_createCharStr(BUFF_SIZE); + hugeString = testdata_createCharStr(INT16_MAX); + asciiSet[0] = 0; - for (i = 1; i < UCHAR_MAX + 1; i++) { - ucharSet[i - 1] = i; - outOfAsciiSet[i - 1] = i * -1; - } - - for (i = 0; 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_memcmp, basic); RUN_TEST_CASE(string_memcmp, unsignedChar); RUN_TEST_CASE(string_memcmp, emptyInput); RUN_TEST_CASE(string_memcmp, big); - RUN_TEST_CASE(string_memcmp, sizes); + RUN_TEST_CASE(string_memcmp, various_sizes); RUN_TEST_CASE(string_memcmp, offsets); } @@ -410,7 +398,7 @@ TEST_GROUP_RUNNER(string_strncmp) RUN_TEST_CASE(string_strncmp, unsignedChar); RUN_TEST_CASE(string_strncmp, emptyInput); RUN_TEST_CASE(string_strncmp, big); - RUN_TEST_CASE(string_strncmp, sizes); + RUN_TEST_CASE(string_strncmp, various_sizes); } TEST_GROUP_RUNNER(string_strcmp) @@ -419,7 +407,7 @@ TEST_GROUP_RUNNER(string_strcmp) RUN_TEST_CASE(string_strcmp, unsignedChar); RUN_TEST_CASE(string_strcmp, emptyInput); RUN_TEST_CASE(string_strcmp, big); - RUN_TEST_CASE(string_strcmp, sizes); + RUN_TEST_CASE(string_strcmp, various_sizes); } TEST_GROUP_RUNNER(string_strcoll) @@ -428,4 +416,8 @@ TEST_GROUP_RUNNER(string_strcoll) RUN_TEST_CASE(string_strcoll, emptyInput); RUN_TEST_CASE(string_strcoll, big); RUN_TEST_CASE(string_strcoll, sizes); + + free(nonZeroAsciiSet); + free(asciiSet); + free(hugeString); }