/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <errno.h>
#include <math.h>
#include <string.h>
#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));
ASSERT_STREQ("Operation not permitted", strerror(1));
// Invalid.
ASSERT_STREQ("Unknown error -1", strerror(-1));
ASSERT_STREQ("Unknown error 1234", strerror(1234));
}
#if __BIONIC__ // glibc's strerror isn't thread safe, only its strsignal.
static void* ConcurrentStrErrorFn(void*) {
bool equal = (strcmp("Unknown error 2002", strerror(2002)) == 0);
return reinterpret_cast<void*>(equal);
}
TEST(string, strerror_concurrent) {
const char* strerror1001 = strerror(1001);
ASSERT_STREQ("Unknown error 1001", strerror1001);
pthread_t t;
ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentStrErrorFn, NULL));
void* result;
ASSERT_EQ(0, pthread_join(t, &result));
ASSERT_TRUE(static_cast<bool>(result));
ASSERT_STREQ("Unknown error 1001", strerror1001);
}
#endif
#if __BIONIC__ // glibc's strerror_r doesn't even have the same signature as the POSIX one.
TEST(string, strerror_r) {
char buf[256];
// Valid.
ASSERT_EQ(0, strerror_r(0, buf, sizeof(buf)));
ASSERT_STREQ("Success", buf);
ASSERT_EQ(0, strerror_r(1, buf, sizeof(buf)));
ASSERT_STREQ("Operation not permitted", buf);
// Invalid.
ASSERT_EQ(0, strerror_r(-1, buf, sizeof(buf)));
ASSERT_STREQ("Unknown error -1", buf);
ASSERT_EQ(0, strerror_r(1234, buf, sizeof(buf)));
ASSERT_STREQ("Unknown error 1234", buf);
// Buffer too small.
ASSERT_EQ(-1, strerror_r(0, buf, 2));
ASSERT_EQ(ERANGE, errno);
}
#endif
TEST(string, strsignal) {
// A regular signal.
ASSERT_STREQ("Hangup", strsignal(1));
// A real-time signal.
#ifdef __GLIBC__ // glibc reserves real-time signals for internal use, and doesn't count those.
ASSERT_STREQ("Real-time signal 14", strsignal(48));
#else
ASSERT_STREQ("Real-time signal 16", strsignal(48));
#endif
// Errors.
ASSERT_STREQ("Unknown signal -1", strsignal(-1)); // Too small.
ASSERT_STREQ("Unknown signal 0", strsignal(0)); // Still too small.
ASSERT_STREQ("Unknown signal 1234", strsignal(1234)); // Too large.
}
static void* ConcurrentStrSignalFn(void*) {
bool equal = (strcmp("Unknown signal 2002", strsignal(2002)) == 0);
return reinterpret_cast<void*>(equal);
}
TEST(string, strsignal_concurrent) {
const char* strsignal1001 = strsignal(1001);
ASSERT_STREQ("Unknown signal 1001", strsignal1001);
pthread_t t;
ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentStrSignalFn, NULL));
void* result;
ASSERT_EQ(0, pthread_join(t, &result));
ASSERT_TRUE(static_cast<bool>(result));
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.
template<class Character>
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<Character*>(valloc(2 * sizeof(Character) * MAX_LEN + max_alignment));
glob_ptr1 = reinterpret_cast<Character*>(valloc(2 * sizeof(Character) * MAX_LEN + max_alignment));
glob_ptr2 = reinterpret_cast<Character*>(valloc(2 * sizeof(Character) * 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;
Character *ptr, *ptr1, *ptr2;
size_t n;
int len[ITER + 1];
private:
Character *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<char> 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);
}
}
}
// one byte target with "\0" source
TEST(string, strcpy2) {
char buf[1];
char* orig = strdup("");
strcpy(buf, orig);
ASSERT_EQ('\0', buf[0]);
free(orig);
}
// multibyte target where we under fill target
TEST(string, strcpy3) {
char buf[10];
char* orig = strdup("12345");
memset(buf, 'A', sizeof(buf));
strcpy(buf, orig);
ASSERT_EQ('1', buf[0]);
ASSERT_EQ('2', buf[1]);
ASSERT_EQ('3', buf[2]);
ASSERT_EQ('4', buf[3]);
ASSERT_EQ('5', buf[4]);
ASSERT_EQ('\0', buf[5]);
ASSERT_EQ('A', buf[6]);
ASSERT_EQ('A', buf[7]);
ASSERT_EQ('A', buf[8]);
ASSERT_EQ('A', buf[9]);
free(orig);
}
// multibyte target where we fill target exactly
TEST(string, strcpy4) {
char buf[10];
char* orig = strdup("123456789");
memset(buf, 'A', sizeof(buf));
strcpy(buf, orig);
ASSERT_EQ('1', buf[0]);
ASSERT_EQ('2', buf[1]);
ASSERT_EQ('3', buf[2]);
ASSERT_EQ('4', buf[3]);
ASSERT_EQ('5', buf[4]);
ASSERT_EQ('6', buf[5]);
ASSERT_EQ('7', buf[6]);
ASSERT_EQ('8', buf[7]);
ASSERT_EQ('9', buf[8]);
ASSERT_EQ('\0', buf[9]);
free(orig);
}
TEST(string, strcat2) {
char buf[10];
memset(buf, 'A', sizeof(buf));
buf[0] = 'a';
buf[1] = '\0';
char* res = strcat(buf, "01234");
ASSERT_EQ(buf, res);
ASSERT_EQ('a', buf[0]);
ASSERT_EQ('0', buf[1]);
ASSERT_EQ('1', buf[2]);
ASSERT_EQ('2', buf[3]);
ASSERT_EQ('3', buf[4]);
ASSERT_EQ('4', buf[5]);
ASSERT_EQ('\0', buf[6]);
ASSERT_EQ('A', buf[7]);
ASSERT_EQ('A', buf[8]);
ASSERT_EQ('A', buf[9]);
}
TEST(string, strcat3) {
char buf[10];
memset(buf, 'A', sizeof(buf));
buf[0] = 'a';
buf[1] = '\0';
char* res = strcat(buf, "01234567");
ASSERT_EQ(buf, res);
ASSERT_EQ('a', buf[0]);
ASSERT_EQ('0', buf[1]);
ASSERT_EQ('1', buf[2]);
ASSERT_EQ('2', buf[3]);
ASSERT_EQ('3', buf[4]);
ASSERT_EQ('4', buf[5]);
ASSERT_EQ('5', buf[6]);
ASSERT_EQ('6', buf[7]);
ASSERT_EQ('7', buf[8]);
ASSERT_EQ('\0', buf[9]);
}
TEST(string, strncat2) {
char buf[10];
memset(buf, 'A', sizeof(buf));
buf[0] = 'a';
buf[1] = '\0';
char* res = strncat(buf, "01234", sizeof(buf) - strlen(buf) - 1);
ASSERT_EQ(buf, res);
ASSERT_EQ('a', buf[0]);
ASSERT_EQ('0', buf[1]);
ASSERT_EQ('1', buf[2]);
ASSERT_EQ('2', buf[3]);
ASSERT_EQ('3', buf[4]);
ASSERT_EQ('4', buf[5]);
ASSERT_EQ('\0', buf[6]);
ASSERT_EQ('A', buf[7]);
ASSERT_EQ('A', buf[8]);
ASSERT_EQ('A', buf[9]);
}
TEST(string, strncat3) {
char buf[10];
memset(buf, 'A', sizeof(buf));
buf[0] = 'a';
buf[1] = '\0';
char* res = strncat(buf, "0123456789", 5);
ASSERT_EQ(buf, res);
ASSERT_EQ('a', buf[0]);
ASSERT_EQ('0', buf[1]);
ASSERT_EQ('1', buf[2]);
ASSERT_EQ('2', buf[3]);
ASSERT_EQ('3', buf[4]);
ASSERT_EQ('4', buf[5]);
ASSERT_EQ('\0', buf[6]);
ASSERT_EQ('A', buf[7]);
ASSERT_EQ('A', buf[8]);
ASSERT_EQ('A', buf[9]);
}
TEST(string, strncat4) {
char buf[10];
memset(buf, 'A', sizeof(buf));
buf[0] = 'a';
buf[1] = '\0';
char* res = strncat(buf, "01234567", 8);
ASSERT_EQ(buf, res);
ASSERT_EQ('a', buf[0]);
ASSERT_EQ('0', buf[1]);
ASSERT_EQ('1', buf[2]);
ASSERT_EQ('2', buf[3]);
ASSERT_EQ('3', buf[4]);
ASSERT_EQ('4', buf[5]);
ASSERT_EQ('5', buf[6]);
ASSERT_EQ('6', buf[7]);
ASSERT_EQ('7', buf[8]);
ASSERT_EQ('\0', buf[9]);
}
TEST(string, strncat5) {
char buf[10];
memset(buf, 'A', sizeof(buf));
buf[0] = 'a';
buf[1] = '\0';
char* res = strncat(buf, "01234567", 9);
ASSERT_EQ(buf, res);
ASSERT_EQ('a', buf[0]);
ASSERT_EQ('0', buf[1]);
ASSERT_EQ('1', buf[2]);
ASSERT_EQ('2', buf[3]);
ASSERT_EQ('3', buf[4]);
ASSERT_EQ('4', buf[5]);
ASSERT_EQ('5', buf[6]);
ASSERT_EQ('6', buf[7]);
ASSERT_EQ('7', buf[8]);
ASSERT_EQ('\0', buf[9]);
}
TEST(string, strchr_with_0) {
char buf[10];
const char* s = "01234";
memcpy(buf, s, strlen(s) + 1);
EXPECT_TRUE(strchr(buf, '\0') == (buf + strlen(s)));
}
TEST(string, strchr) {
int seek_char = random() & 255;
StringTestState<char> 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<char> 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<char> 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<char> 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<char> 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<char> 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<char> 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<char> 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<char> 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<char> 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<char> 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<char> 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<int>(c1) - static_cast<int>(c2));
int actual = memcmp(state.ptr1, state.ptr2, state.MAX_LEN);
ASSERT_EQ(signum(expected), signum(actual));
}
}
}
#if defined(__BIONIC__)
extern "C" int __memcmp16(const unsigned short *ptr1, const unsigned short *ptr2, size_t n);
TEST(string, __memcmp16) {
StringTestState<unsigned short> state(SMALL);
for (size_t i = 0; i < state.n; i++) {
for (size_t j = 0; j < POS_ITER; j++) {
state.NewIteration();
unsigned short mask = 0xffff;
unsigned short c1 = rand() & mask;
unsigned short c2 = rand() & mask;
std::fill(state.ptr1, state.ptr1 + state.MAX_LEN, c1);
std::fill(state.ptr2, state.ptr2 + state.MAX_LEN, c1);
int pos = (state.len[i] == 0) ? 0 : (random() % state.len[i]);
state.ptr2[pos] = c2;
int expected = (static_cast<unsigned short>(c1) - static_cast<unsigned short>(c2));
int actual = __memcmp16(state.ptr1, state.ptr2, (size_t) state.MAX_LEN);
ASSERT_EQ(expected, actual);
}
}
}
#endif
TEST(string, wmemcmp) {
StringTestState<wchar_t> state(SMALL);
for (size_t i = 0; i < state.n; i++) {
for (size_t j = 0; j < POS_ITER; j++) {
state.NewIteration();
long long mask = ((long long) 1 << 8 * sizeof(wchar_t)) - 1;
int c1 = rand() & mask;
int c2 = rand() & mask;
wmemset(state.ptr1, c1, state.MAX_LEN);
wmemset(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<int>(c1) - static_cast<int>(c2));
int actual = wmemcmp(state.ptr1, state.ptr2, (size_t) state.MAX_LEN);
ASSERT_EQ(signum(expected), signum(actual));
}
}
}
TEST(string, memcpy) {
StringTestState<char> 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<char> 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<char> 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<char> 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<char> 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));
}
}