From 036154b0c2d64d618aded8674f2e13cbbb2867e2 Mon Sep 17 00:00:00 2001 From: Anna Tikhonova Date: Fri, 5 Oct 2012 15:21:11 +0400 Subject: [PATCH] Tests for string routines. Change-Id: I24068a228f59df1c3b758c5b2026a09720490616 Signed-off-by: Anna Tikhonova --- tests/string_test.cpp | 555 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 555 insertions(+) diff --git a/tests/string_test.cpp b/tests/string_test.cpp index 472aacb0e..71998d877 100644 --- a/tests/string_test.cpp +++ b/tests/string_test.cpp @@ -17,8 +17,22 @@ #include #include +#include #include +#define KB 1024 +#define SMALL 1*KB +#define LARGE 64*KB + +static int signum(int i) { + if (i < 0) { + return -1; + } else if (i > 0) { + return 1; + } + return 0; +} + TEST(string, strerror) { // Valid. ASSERT_STREQ("Success", strerror(0)); @@ -107,3 +121,544 @@ TEST(string, strsignal_concurrent) { ASSERT_STREQ("Unknown signal 1001", strsignal1001); } + +// TODO: where did these numbers come from? +#define POS_ITER 10 +#define ITER 500 + +// For every length we want to test, vary and change alignment +// of allocated memory, fill it with some values, calculate +// expected result and then run function and compare what we got. +// These tests contributed by Intel Corporation. +// TODO: make these tests more intention-revealing and less random. +struct StringTestState { + StringTestState(size_t MAX_LEN) : MAX_LEN(MAX_LEN) { + int max_alignment = 64; + + // TODO: fix the tests to not sometimes use twice their specified "MAX_LEN". + glob_ptr = reinterpret_cast(valloc(2 * MAX_LEN + max_alignment)); + glob_ptr1 = reinterpret_cast(valloc(2 * MAX_LEN + max_alignment)); + glob_ptr2 = reinterpret_cast(valloc(2 * MAX_LEN + max_alignment)); + + InitLenArray(); + + srandom(1234); + } + + ~StringTestState() { + free(glob_ptr); + free(glob_ptr1); + free(glob_ptr2); + } + + void NewIteration() { + int alignments[] = { 24, 32, 16, 48, 1, 2, 3, 0, 5, 11 }; + int usable_alignments = 10; + int align1 = alignments[random() % (usable_alignments - 1)]; + int align2 = alignments[random() % (usable_alignments - 1)]; + + ptr = glob_ptr + align1; + ptr1 = glob_ptr1 + align1; + ptr2 = glob_ptr2 + align2; + } + + const size_t MAX_LEN; + char *ptr, *ptr1, *ptr2; + size_t n; + int len[ITER + 1]; + + private: + char *glob_ptr, *glob_ptr1, *glob_ptr2; + + // Calculate input lengths and fill state.len with them. + // Test small lengths with more density than big ones. Manually push + // smallest (0) and biggest (MAX_LEN) lengths. Avoid repeats. + // Return number of lengths to test. + void InitLenArray() { + n = 0; + len[n++] = 0; + for (size_t i = 1; i < ITER; ++i) { + int l = (int) exp(log((double) MAX_LEN) * i / ITER); + if (l != len[n - 1]) { + len[n++] = l; + } + } + len[n++] = MAX_LEN; + } +}; + +TEST(string, strcat) { + StringTestState state(SMALL); + for (size_t i = 1; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + memset(state.ptr2, '\2', state.MAX_LEN); + state.ptr2[state.MAX_LEN - 1] = '\0'; + memcpy(state.ptr, state.ptr2, 2 * state.MAX_LEN); + + memset(state.ptr1, random() & 255, state.len[i]); + state.ptr1[random() % state.len[i]] = '\0'; + state.ptr1[state.len[i] - 1] = '\0'; + + strcpy(state.ptr + state.MAX_LEN - 1, state.ptr1); + + EXPECT_TRUE(strcat(state.ptr2, state.ptr1) == state.ptr2); + EXPECT_TRUE(memcmp(state.ptr, state.ptr2, 2 * state.MAX_LEN) == 0); + } + } +} + +TEST(string, strchr) { + int seek_char = random() & 255; + + StringTestState state(SMALL); + for (size_t i = 1; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + if (~seek_char > 0) { + memset(state.ptr1, ~seek_char, state.len[i]); + } else { + memset(state.ptr1, '\1', state.len[i]); + } + state.ptr1[state.len[i] - 1] = '\0'; + + int pos = random() % state.MAX_LEN; + char* expected; + if (pos >= state.len[i] - 1) { + if (seek_char == 0) { + expected = state.ptr1 + state.len[i] - 1; + } else { + expected = NULL; + } + } else { + state.ptr1[pos] = seek_char; + expected = state.ptr1 + pos; + } + + ASSERT_TRUE(strchr(state.ptr1, seek_char) == expected); + } + } +} + +TEST(string, strcmp) { + StringTestState state(SMALL); + for (size_t i = 1; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + memset(state.ptr1, 'v', state.MAX_LEN); + memset(state.ptr2, 'n', state.MAX_LEN); + state.ptr1[state.len[i] - 1] = '\0'; + state.ptr2[state.len[i] - 1] = '\0'; + + int pos = 1 + (random() % (state.MAX_LEN - 1)); + int actual; + int expected; + if (pos >= state.len[i] - 1) { + memcpy(state.ptr1, state.ptr2, state.len[i]); + expected = 0; + actual = strcmp(state.ptr1, state.ptr2); + } else { + memcpy(state.ptr1, state.ptr2, pos); + if (state.ptr1[pos] > state.ptr2[pos]) { + expected = 1; + } else if (state.ptr1[pos] == state.ptr2[pos]) { + state.ptr1[pos + 1] = '\0'; + state.ptr2[pos + 1] = '\0'; + expected = 0; + } else { + expected = -1; + } + actual = strcmp(state.ptr1, state.ptr2); + } + + ASSERT_EQ(expected, signum(actual)); + } + } +} + +TEST(string, strcpy) { + StringTestState state(SMALL); + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + size_t pos = random() % state.MAX_LEN; + + memset(state.ptr1, '\2', pos); + state.ptr1[pos] = '\0'; + state.ptr1[state.MAX_LEN - 1] = '\0'; + + memcpy(state.ptr, state.ptr1, state.MAX_LEN); + + memset(state.ptr2, '\1', state.MAX_LEN); + state.ptr2[state.MAX_LEN - 1] = '\0'; + + memset(state.ptr + state.MAX_LEN, '\1', state.MAX_LEN); + memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1); + state.ptr[2 * state.MAX_LEN - 1] = '\0'; + + ASSERT_TRUE(strcpy(state.ptr2, state.ptr1) == state.ptr2); + ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN)) != 0 || + (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0)); + } +} + +#if __BIONIC__ +TEST(string, strlcat) { + StringTestState state(SMALL); + for (size_t i = 0; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + memset(state.ptr2, '\2', state.MAX_LEN + state.len[i]); + state.ptr2[state.MAX_LEN - 1] = '\0'; + memcpy(state.ptr, state.ptr2, state.MAX_LEN + state.len[i]); + + int pos = random() % state.MAX_LEN; + memset(state.ptr1, '\3', pos); + state.ptr1[pos] = '\0'; + if (pos < state.len[i]) { + memcpy(state.ptr + state.MAX_LEN - 1, state.ptr1, pos + 1); + } else { + memcpy(state.ptr + state.MAX_LEN - 1, state.ptr1, state.len[i]); + state.ptr[state.MAX_LEN + state.len[i] - 1] = '\0'; + } + + strlcat(state.ptr2, state.ptr1, state.MAX_LEN + state.len[i]); + + ASSERT_TRUE(memcmp(state.ptr, state.ptr2, state.MAX_LEN + state.len[i]) == 0); + } + } +} +#endif + +#if __BIONIC__ +TEST(string, strlcpy) { + StringTestState state(SMALL); + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + int rand = random() & 255; + if (rand < 1) { + rand = 1; + } + memset(state.ptr1, rand, state.MAX_LEN); + + size_t pos = random() % state.MAX_LEN; + if (pos < state.MAX_LEN) { + state.ptr1[pos] = '\0'; + } + memcpy(state.ptr, state.ptr1, state.MAX_LEN); + + memset(state.ptr2, random() & 255, state.MAX_LEN); + memcpy(state.ptr + state.MAX_LEN, state.ptr2, state.MAX_LEN); + + if (pos > state.MAX_LEN - 1) { + memcpy(state.ptr + state.MAX_LEN, state.ptr1, state.MAX_LEN); + state.ptr[2 * state.MAX_LEN - 1] = '\0'; + } else { + memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1); + } + + ASSERT_EQ(strlcpy(state.ptr2, state.ptr1, state.MAX_LEN), strlen(state.ptr1)); + ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN) != 0) || + (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0)); + } +} +#endif + +TEST(string, strncat) { + StringTestState state(SMALL); + for (size_t i = 1; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + memset(state.ptr2, '\2', state.MAX_LEN); + state.ptr2[state.MAX_LEN - 1] = '\0'; + memcpy(state.ptr, state.ptr2, 2 * state.MAX_LEN); + + memset(state.ptr1, random() & 255, state.len[i]); + state.ptr1[random() % state.len[i]] = '\0'; + state.ptr1[state.len[i] - 1] = '\0'; + + size_t pos = strlen(state.ptr1); + + size_t actual = random() % state.len[i]; + strncpy(state.ptr + state.MAX_LEN - 1, state.ptr1, std::min(actual, pos)); + state.ptr[state.MAX_LEN + std::min(actual, pos) - 1] = '\0'; + + ASSERT_TRUE(strncat(state.ptr2, state.ptr1, actual) == state.ptr2); + ASSERT_EQ(memcmp(state.ptr, state.ptr2, 2 * state.MAX_LEN), 0); + } + } +} + +TEST(string, strncmp) { + StringTestState state(SMALL); + for (size_t i = 1; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + memset(state.ptr1, 'v', state.MAX_LEN); + memset(state.ptr2, 'n', state.MAX_LEN); + state.ptr1[state.len[i] - 1] = '\0'; + state.ptr2[state.len[i] - 1] = '\0'; + + int pos = 1 + (random() % (state.MAX_LEN - 1)); + int actual; + int expected; + if (pos >= state.len[i] - 1) { + memcpy(state.ptr1, state.ptr2, state.len[i]); + expected = 0; + actual = strncmp(state.ptr1, state.ptr2, state.len[i]); + } else { + memcpy(state.ptr1, state.ptr2, pos); + if (state.ptr1[pos] > state.ptr2[pos]) { + expected = 1; + } else if (state.ptr1[pos] == state.ptr2[pos]) { + state.ptr1[pos + 1] = '\0'; + state.ptr2[pos + 1] = '\0'; + expected = 0; + } else { + expected = -1; + } + actual = strncmp(state.ptr1, state.ptr2, state.len[i]); + } + + ASSERT_EQ(expected, signum(actual)); + } + } +} + +TEST(string, strncpy) { + StringTestState state(SMALL); + for (size_t j = 0; j < ITER; j++) { + state.NewIteration(); + + memset(state.ptr1, random() & 255, state.MAX_LEN); + state.ptr1[random () % state.MAX_LEN] = '\0'; + memcpy(state.ptr, state.ptr1, state.MAX_LEN); + + memset(state.ptr2, '\1', state.MAX_LEN); + + size_t pos; + if (memchr(state.ptr1, 0, state.MAX_LEN)) { + pos = strlen(state.ptr1); + } else { + pos = state.MAX_LEN - 1; + } + + memset(state.ptr + state.MAX_LEN, '\0', state.MAX_LEN); + memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1); + + ASSERT_TRUE(strncpy(state.ptr2, state.ptr1, state.MAX_LEN) == state.ptr2); + ASSERT_FALSE(memcmp(state.ptr1, state.ptr, state.MAX_LEN) != 0 || + memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0); + } +} + +TEST(string, strrchr) { + int seek_char = random() & 255; + StringTestState state(SMALL); + for (size_t i = 1; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + if (~seek_char > 0) { + memset(state.ptr1, ~seek_char, state.len[i]); + } else { + memset(state.ptr1, '\1', state.len[i]); + } + state.ptr1[state.len[i] - 1] = '\0'; + + int pos = random() % state.MAX_LEN; + char* expected; + if (pos >= state.len[i] - 1) { + if (seek_char == 0) { + expected = state.ptr1 + state.len[i] - 1; + } else { + expected = NULL; + } + } else { + state.ptr1[pos] = seek_char; + expected = state.ptr1 + pos; + } + + ASSERT_TRUE(strrchr(state.ptr1, seek_char) == expected); + } + } +} + +TEST(string, memchr) { + int seek_char = random() & 255; + StringTestState state(SMALL); + for (size_t i = 0; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + memset(state.ptr1, ~seek_char, state.len[i]); + + int pos = random() % state.MAX_LEN; + char* expected; + if (pos >= state.len[i]) { + expected = NULL; + } else { + state.ptr1[pos] = seek_char; + expected = state.ptr1 + pos; + } + + ASSERT_TRUE(memchr(state.ptr1, seek_char, state.len[i]) == expected); + } + } +} + +TEST(string, memrchr) { + int seek_char = random() & 255; + StringTestState state(SMALL); + for (size_t i = 0; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + memset(state.ptr1, ~seek_char, state.len[i]); + + int pos = random() % state.MAX_LEN; + char* expected; + if (pos >= state.len[i]) { + expected = NULL; + } else { + state.ptr1[pos] = seek_char; + expected = state.ptr1 + pos; + } + + ASSERT_TRUE(memrchr(state.ptr1, seek_char, state.len[i]) == expected); + } + } +} + +TEST(string, memcmp) { + StringTestState state(SMALL); + for (size_t i = 0; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + int c1 = random() & 0xff; + int c2 = random() & 0xff; + memset(state.ptr1, c1, state.MAX_LEN); + memset(state.ptr2, c1, state.MAX_LEN); + + int pos = (state.len[i] == 0) ? 0 : (random() % state.len[i]); + state.ptr2[pos] = c2; + + int expected = (static_cast(c1) - static_cast(c2)); + int actual = memcmp(state.ptr1, state.ptr2, state.MAX_LEN); + + ASSERT_EQ(signum(expected), signum(actual)); + } + } +} + +TEST(string, memcpy) { + StringTestState state(LARGE); + int rand = random() & 255; + for (size_t i = 0; i < state.n - 1; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + size_t pos = random() % (state.MAX_LEN - state.len[i]); + + memset(state.ptr1, rand, state.len[i]); + memset(state.ptr1 + state.len[i], ~rand, state.MAX_LEN - state.len[i]); + + memset(state.ptr2, rand, state.len[i]); + memset(state.ptr2 + state.len[i], ~rand, state.MAX_LEN - state.len[i]); + memset(state.ptr2 + pos, '\0', state.len[i]); + + ASSERT_FALSE(memcpy(state.ptr2 + pos, state.ptr1 + pos, state.len[i]) != state.ptr2 + pos); + ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN)); + } + } +} + +TEST(string, memset) { + StringTestState state(LARGE); + char ch = random () & 255; + for (size_t i = 0; i < state.n - 1; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + memset(state.ptr1, ~ch, state.MAX_LEN); + memcpy(state.ptr2, state.ptr1, state.MAX_LEN); + + size_t pos = random () % (state.MAX_LEN - state.len[i]); + for (size_t k = pos; k < pos + state.len[i]; k++) { + state.ptr1[k] = ch; + } + + ASSERT_TRUE(memset(state.ptr2 + pos, ch, state.len[i]) == state.ptr2 + pos); + + ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN)); + } + } +} + +TEST(string, memmove) { + StringTestState state(LARGE); + for (size_t i = 0; i < state.n - 1; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + memset(state.ptr1, random() & 255, 2 * state.MAX_LEN); + + size_t pos = random() % (state.MAX_LEN - state.len[i]); + + memset(state.ptr1, random() & 255, state.len[i]); + memcpy(state.ptr2, state.ptr1, 2 * state.MAX_LEN); + memcpy(state.ptr, state.ptr1, state.len[i]); + memcpy(state.ptr1 + pos, state.ptr, state.len[i]); + + ASSERT_TRUE(memmove(state.ptr2 + pos, state.ptr2, state.len[i]) == state.ptr2 + pos); + ASSERT_EQ(0, memcmp(state.ptr2, state.ptr1, 2 * state.MAX_LEN)); + } + } +} + +TEST(string, bcopy) { + StringTestState state(LARGE); + for (size_t i = 0; i < state.n; i++) { + for (size_t j = 0; j < POS_ITER; j++) { + state.NewIteration(); + + memset(state.ptr1, random() & 255, state.MAX_LEN); + memset(state.ptr1 + state.MAX_LEN, random() & 255, state.MAX_LEN); + memcpy(state.ptr2, state.ptr1, 2 * state.MAX_LEN); + + size_t start = random() % (2 * state.MAX_LEN - state.len[i]); + memcpy(state.ptr2 + start, state.ptr1, state.len[i]); + + bcopy(state.ptr1, state.ptr1 + start, state.len[i]); + ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, 2 * state.MAX_LEN)); + } + } +} + +TEST(string, bzero) { + StringTestState state(LARGE); + for (size_t j = 0; j < ITER; j++) { + state.NewIteration(); + + memset(state.ptr1, random() & 255, state.MAX_LEN); + + size_t start = random() % state.MAX_LEN; + size_t end = start + random() % (state.MAX_LEN - start); + + memcpy(state.ptr2, state.ptr1, start); + memset(state.ptr2 + start, '\0', end - start); + memcpy(state.ptr2 + end, state.ptr1 + end, state.MAX_LEN - end); + + bzero(state.ptr1 + start, end - start); + + ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN)); + } +}