string_test.cpp revision 24614b4729a4c8665193f5793b93019b37f779b1 
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <gtest/gtest.h>
18
19#include <errno.h>
20#include <math.h>
21#include <string.h>
22
23#include "buffer_tests.h"
24
25#define KB 1024
26#define SMALL 1*KB
27#define MEDIUM 4*KB
28#define LARGE 64*KB
29
30static int signum(int i) {
31  if (i < 0) {
32    return -1;
33  } else if (i > 0) {
34    return 1;
35  }
36  return 0;
37}
38
39TEST(string, strerror) {
40  // Valid.
41  ASSERT_STREQ("Success", strerror(0));
42  ASSERT_STREQ("Operation not permitted", strerror(1));
43
44  // Invalid.
45  ASSERT_STREQ("Unknown error -1", strerror(-1));
46  ASSERT_STREQ("Unknown error 1234", strerror(1234));
47}
48
49#if defined(__BIONIC__)
50static void* ConcurrentStrErrorFn(void*) {
51  bool equal = (strcmp("Unknown error 2002", strerror(2002)) == 0);
52  return reinterpret_cast<void*>(equal);
53}
54#endif // __BIONIC__
55
56// glibc's strerror isn't thread safe, only its strsignal.
57TEST(string, strerror_concurrent) {
58#if defined(__BIONIC__)
59  const char* strerror1001 = strerror(1001);
60  ASSERT_STREQ("Unknown error 1001", strerror1001);
61
62  pthread_t t;
63  ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentStrErrorFn, NULL));
64  void* result;
65  ASSERT_EQ(0, pthread_join(t, &result));
66  ASSERT_TRUE(static_cast<bool>(result));
67
68  ASSERT_STREQ("Unknown error 1001", strerror1001);
69#else // __BIONIC__
70  GTEST_LOG_(INFO) << "This test does nothing.\n";
71#endif // __BIONIC__
72}
73
74TEST(string, strerror_r) {
75#if defined(__BIONIC__) // glibc's strerror_r doesn't even have the same signature as the POSIX one.
76  char buf[256];
77
78  // Valid.
79  ASSERT_EQ(0, strerror_r(0, buf, sizeof(buf)));
80  ASSERT_STREQ("Success", buf);
81  ASSERT_EQ(0, strerror_r(1, buf, sizeof(buf)));
82  ASSERT_STREQ("Operation not permitted", buf);
83
84  // Invalid.
85  ASSERT_EQ(0, strerror_r(-1, buf, sizeof(buf)));
86  ASSERT_STREQ("Unknown error -1", buf);
87  ASSERT_EQ(0, strerror_r(1234, buf, sizeof(buf)));
88  ASSERT_STREQ("Unknown error 1234", buf);
89
90  // Buffer too small.
91  ASSERT_EQ(-1, strerror_r(0, buf, 2));
92  ASSERT_EQ(ERANGE, errno);
93#else // __BIONIC__
94  GTEST_LOG_(INFO) << "This test does nothing.\n";
95#endif // __BIONIC__
96}
97
98TEST(string, strsignal) {
99  // A regular signal.
100  ASSERT_STREQ("Hangup", strsignal(1));
101
102  // A real-time signal.
103  ASSERT_STREQ("Real-time signal 14", strsignal(SIGRTMIN + 14));
104  // One of the signals the C library keeps to itself.
105  ASSERT_STREQ("Unknown signal 32", strsignal(__SIGRTMIN));
106
107  // Errors.
108  ASSERT_STREQ("Unknown signal -1", strsignal(-1)); // Too small.
109  ASSERT_STREQ("Unknown signal 0", strsignal(0)); // Still too small.
110  ASSERT_STREQ("Unknown signal 1234", strsignal(1234)); // Too large.
111}
112
113static void* ConcurrentStrSignalFn(void*) {
114  bool equal = (strcmp("Unknown signal 2002", strsignal(2002)) == 0);
115  return reinterpret_cast<void*>(equal);
116}
117
118TEST(string, strsignal_concurrent) {
119  const char* strsignal1001 = strsignal(1001);
120  ASSERT_STREQ("Unknown signal 1001", strsignal1001);
121
122  pthread_t t;
123  ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentStrSignalFn, NULL));
124  void* result;
125  ASSERT_EQ(0, pthread_join(t, &result));
126  ASSERT_TRUE(static_cast<bool>(result));
127
128  ASSERT_STREQ("Unknown signal 1001", strsignal1001);
129}
130
131// TODO: where did these numbers come from?
132#define POS_ITER    10
133#define ITER        500
134
135// For every length we want to test, vary and change alignment
136// of allocated memory, fill it with some values, calculate
137// expected result and then run function and compare what we got.
138// These tests contributed by Intel Corporation.
139// TODO: make these tests more intention-revealing and less random.
140template<class Character>
141struct StringTestState {
142  StringTestState(size_t MAX_LEN) : MAX_LEN(MAX_LEN) {
143    int max_alignment = 64;
144
145    // TODO: fix the tests to not sometimes use twice their specified "MAX_LEN".
146    glob_ptr = reinterpret_cast<Character*>(valloc(2 * sizeof(Character) * MAX_LEN + max_alignment));
147    glob_ptr1 = reinterpret_cast<Character*>(valloc(2 * sizeof(Character) * MAX_LEN + max_alignment));
148    glob_ptr2 = reinterpret_cast<Character*>(valloc(2 * sizeof(Character) * MAX_LEN + max_alignment));
149
150    InitLenArray();
151
152    srandom(1234);
153  }
154
155  ~StringTestState() {
156    free(glob_ptr);
157    free(glob_ptr1);
158    free(glob_ptr2);
159  }
160
161  void NewIteration() {
162    int alignments[] = { 24, 32, 16, 48, 1, 2, 3, 0, 5, 11 };
163    int usable_alignments = 10;
164    int align1 = alignments[random() % (usable_alignments - 1)];
165    int align2 = alignments[random() % (usable_alignments - 1)];
166
167    ptr = glob_ptr + align1;
168    ptr1 = glob_ptr1 + align1;
169    ptr2 = glob_ptr2 + align2;
170  }
171
172  const size_t MAX_LEN;
173  Character *ptr, *ptr1, *ptr2;
174  size_t n;
175  int len[ITER + 1];
176
177 private:
178  Character *glob_ptr, *glob_ptr1, *glob_ptr2;
179
180  // Calculate input lengths and fill state.len with them.
181  // Test small lengths with more density than big ones. Manually push
182  // smallest (0) and biggest (MAX_LEN) lengths. Avoid repeats.
183  // Return number of lengths to test.
184  void InitLenArray() {
185    n = 0;
186    len[n++] = 0;
187    for (size_t i = 1; i < ITER; ++i) {
188      int l = (int) exp(log((double) MAX_LEN) * i / ITER);
189      if (l != len[n - 1]) {
190        len[n++] = l;
191      }
192    }
193    len[n++] = MAX_LEN;
194  }
195};
196
197TEST(string, strcat) {
198  StringTestState<char> state(SMALL);
199  for (size_t i = 1; i < state.n; i++) {
200    for (size_t j = 0; j < POS_ITER; j++) {
201      state.NewIteration();
202
203      memset(state.ptr2, '\2', state.MAX_LEN);
204      state.ptr2[state.MAX_LEN - 1] = '\0';
205      memcpy(state.ptr, state.ptr2, 2 * state.MAX_LEN);
206
207      memset(state.ptr1, random() & 255, state.len[i]);
208      state.ptr1[random() % state.len[i]] = '\0';
209      state.ptr1[state.len[i] - 1] = '\0';
210
211      strcpy(state.ptr + state.MAX_LEN - 1, state.ptr1);
212
213      EXPECT_TRUE(strcat(state.ptr2, state.ptr1) == state.ptr2);
214      EXPECT_TRUE(memcmp(state.ptr, state.ptr2, 2 * state.MAX_LEN) == 0);
215    }
216  }
217}
218
219// one byte target with "\0" source
220TEST(string, strcpy2) {
221  char buf[1];
222  char* orig = strdup("");
223  ASSERT_EQ(buf, strcpy(buf, orig));
224  ASSERT_EQ('\0', buf[0]);
225  free(orig);
226}
227
228// multibyte target where we under fill target
229TEST(string, strcpy3) {
230  char buf[10];
231  char* orig = strdup("12345");
232  memset(buf, 'A', sizeof(buf));
233  ASSERT_EQ(buf, strcpy(buf, orig));
234  ASSERT_STREQ("12345", buf);
235  ASSERT_EQ('A',  buf[6]);
236  ASSERT_EQ('A',  buf[7]);
237  ASSERT_EQ('A',  buf[8]);
238  ASSERT_EQ('A',  buf[9]);
239  free(orig);
240}
241
242// multibyte target where we fill target exactly
243TEST(string, strcpy4) {
244  char buf[10];
245  char* orig = strdup("123456789");
246  memset(buf, 'A', sizeof(buf));
247  ASSERT_EQ(buf, strcpy(buf, orig));
248  ASSERT_STREQ("123456789", buf);
249  free(orig);
250}
251
252// one byte target with "\0" source
253TEST(string, stpcpy2) {
254  char buf[1];
255  char* orig = strdup("");
256  ASSERT_EQ(buf, stpcpy(buf, orig));
257  ASSERT_EQ('\0', buf[0]);
258  free(orig);
259}
260
261// multibyte target where we under fill target
262TEST(string, stpcpy3) {
263  char buf[10];
264  char* orig = strdup("12345");
265  memset(buf, 'A', sizeof(buf));
266  ASSERT_EQ(buf+strlen(orig), stpcpy(buf, orig));
267  ASSERT_STREQ("12345", buf);
268  ASSERT_EQ('A',  buf[6]);
269  ASSERT_EQ('A',  buf[7]);
270  ASSERT_EQ('A',  buf[8]);
271  ASSERT_EQ('A',  buf[9]);
272  free(orig);
273}
274
275// multibyte target where we fill target exactly
276TEST(string, stpcpy4) {
277  char buf[10];
278  char* orig = strdup("123456789");
279  memset(buf, 'A', sizeof(buf));
280  ASSERT_EQ(buf+strlen(orig), stpcpy(buf, orig));
281  ASSERT_STREQ("123456789", buf);
282  free(orig);
283}
284
285TEST(string, strcat2) {
286  char buf[10];
287  memset(buf, 'A', sizeof(buf));
288  buf[0] = 'a';
289  buf[1] = '\0';
290  char* res = strcat(buf, "01234");
291  ASSERT_EQ(buf, res);
292  ASSERT_STREQ("a01234", buf);
293  ASSERT_EQ('A',  buf[7]);
294  ASSERT_EQ('A',  buf[8]);
295  ASSERT_EQ('A',  buf[9]);
296}
297
298TEST(string, strcat3) {
299  char buf[10];
300  memset(buf, 'A', sizeof(buf));
301  buf[0] = 'a';
302  buf[1] = '\0';
303  char* res = strcat(buf, "01234567");
304  ASSERT_EQ(buf, res);
305  ASSERT_STREQ("a01234567", buf);
306}
307
308TEST(string, strncat2) {
309  char buf[10];
310  memset(buf, 'A', sizeof(buf));
311  buf[0] = 'a';
312  buf[1] = '\0';
313  char* res = strncat(buf, "01234", sizeof(buf) - strlen(buf) - 1);
314  ASSERT_EQ(buf, res);
315  ASSERT_STREQ("a01234", buf);
316  ASSERT_EQ('A',  buf[7]);
317  ASSERT_EQ('A',  buf[8]);
318  ASSERT_EQ('A',  buf[9]);
319}
320
321TEST(string, strncat3) {
322  char buf[10];
323  memset(buf, 'A', sizeof(buf));
324  buf[0] = 'a';
325  buf[1] = '\0';
326  char* res = strncat(buf, "0123456789", 5);
327  ASSERT_EQ(buf, res);
328  ASSERT_STREQ("a01234", buf);
329  ASSERT_EQ('A',  buf[7]);
330  ASSERT_EQ('A',  buf[8]);
331  ASSERT_EQ('A',  buf[9]);
332}
333
334TEST(string, strncat4) {
335  char buf[10];
336  memset(buf, 'A', sizeof(buf));
337  buf[0] = 'a';
338  buf[1] = '\0';
339  char* res = strncat(buf, "01234567", 8);
340  ASSERT_EQ(buf, res);
341  ASSERT_STREQ("a01234567", buf);
342}
343
344TEST(string, strncat5) {
345  char buf[10];
346  memset(buf, 'A', sizeof(buf));
347  buf[0] = 'a';
348  buf[1] = '\0';
349  char* res = strncat(buf, "01234567", 9);
350  ASSERT_EQ(buf, res);
351  ASSERT_STREQ("a01234567", buf);
352}
353
354TEST(string, strchr_with_0) {
355  char buf[10];
356  const char* s = "01234";
357  memcpy(buf, s, strlen(s) + 1);
358  EXPECT_TRUE(strchr(buf, '\0') == (buf + strlen(s)));
359}
360
361TEST(string, strchr) {
362  int seek_char = random() & 255;
363
364  StringTestState<char> state(SMALL);
365  for (size_t i = 1; i < state.n; i++) {
366    for (size_t j = 0; j < POS_ITER; j++) {
367      state.NewIteration();
368
369      if (~seek_char > 0) {
370        memset(state.ptr1, ~seek_char, state.len[i]);
371      } else {
372        memset(state.ptr1, '\1', state.len[i]);
373      }
374      state.ptr1[state.len[i] - 1] = '\0';
375
376      int pos = random() % state.MAX_LEN;
377      char* expected;
378      if (pos >= state.len[i] - 1) {
379        if (seek_char == 0) {
380          expected = state.ptr1 + state.len[i] - 1;
381        } else {
382          expected = NULL;
383        }
384      } else {
385        state.ptr1[pos] = seek_char;
386        expected = state.ptr1 + pos;
387      }
388
389      ASSERT_TRUE(strchr(state.ptr1, seek_char) == expected);
390    }
391  }
392}
393
394TEST(string, strcmp) {
395  StringTestState<char> state(SMALL);
396  for (size_t i = 1; i < state.n; i++) {
397    for (size_t j = 0; j < POS_ITER; j++) {
398      state.NewIteration();
399
400      memset(state.ptr1, 'v', state.MAX_LEN);
401      memset(state.ptr2, 'n', state.MAX_LEN);
402      state.ptr1[state.len[i] - 1] = '\0';
403      state.ptr2[state.len[i] - 1] = '\0';
404
405      int pos = 1 + (random() % (state.MAX_LEN - 1));
406      int actual;
407      int expected;
408      if (pos >= state.len[i] - 1) {
409        memcpy(state.ptr1, state.ptr2, state.len[i]);
410        expected = 0;
411        actual = strcmp(state.ptr1, state.ptr2);
412      } else {
413        memcpy(state.ptr1, state.ptr2, pos);
414        if (state.ptr1[pos] > state.ptr2[pos]) {
415          expected = 1;
416        } else if (state.ptr1[pos] == state.ptr2[pos]) {
417          state.ptr1[pos + 1] = '\0';
418          state.ptr2[pos + 1] = '\0';
419          expected = 0;
420        } else {
421          expected = -1;
422        }
423        actual = strcmp(state.ptr1, state.ptr2);
424      }
425
426      ASSERT_EQ(expected, signum(actual));
427    }
428  }
429}
430
431TEST(string, stpcpy) {
432  StringTestState<char> state(SMALL);
433  for (size_t j = 0; j < POS_ITER; j++) {
434    state.NewIteration();
435
436    size_t pos = random() % state.MAX_LEN;
437
438    memset(state.ptr1, '\2', pos);
439    state.ptr1[pos] = '\0';
440    state.ptr1[state.MAX_LEN - 1] = '\0';
441
442    memcpy(state.ptr, state.ptr1, state.MAX_LEN);
443
444    memset(state.ptr2, '\1', state.MAX_LEN);
445    state.ptr2[state.MAX_LEN - 1] = '\0';
446
447    memset(state.ptr + state.MAX_LEN, '\1', state.MAX_LEN);
448    memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1);
449    state.ptr[2 * state.MAX_LEN - 1] = '\0';
450
451    ASSERT_TRUE(stpcpy(state.ptr2, state.ptr1) == state.ptr2 + strlen(state.ptr1));
452    ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN)) != 0 ||
453                 (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0));
454  }
455}
456
457TEST(string, strcpy) {
458  StringTestState<char> state(SMALL);
459  for (size_t j = 0; j < POS_ITER; j++) {
460    state.NewIteration();
461
462    size_t pos = random() % state.MAX_LEN;
463
464    memset(state.ptr1, '\2', pos);
465    state.ptr1[pos] = '\0';
466    state.ptr1[state.MAX_LEN - 1] = '\0';
467
468    memcpy(state.ptr, state.ptr1, state.MAX_LEN);
469
470    memset(state.ptr2, '\1', state.MAX_LEN);
471    state.ptr2[state.MAX_LEN - 1] = '\0';
472
473    memset(state.ptr + state.MAX_LEN, '\1', state.MAX_LEN);
474    memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1);
475    state.ptr[2 * state.MAX_LEN - 1] = '\0';
476
477    ASSERT_TRUE(strcpy(state.ptr2, state.ptr1) == state.ptr2);
478    ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN)) != 0 ||
479                 (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0));
480  }
481}
482
483TEST(string, strlcat) {
484#if defined(__BIONIC__)
485  StringTestState<char> state(SMALL);
486  for (size_t i = 0; i < state.n; i++) {
487    for (size_t j = 0; j < POS_ITER; j++) {
488      state.NewIteration();
489
490      memset(state.ptr2, '\2', state.MAX_LEN + state.len[i]);
491      state.ptr2[state.MAX_LEN - 1] = '\0';
492      memcpy(state.ptr, state.ptr2, state.MAX_LEN + state.len[i]);
493
494      int pos = random() % state.MAX_LEN;
495      memset(state.ptr1, '\3', pos);
496      state.ptr1[pos] = '\0';
497      if (pos < state.len[i]) {
498        memcpy(state.ptr + state.MAX_LEN - 1, state.ptr1, pos + 1);
499      } else {
500        memcpy(state.ptr + state.MAX_LEN - 1, state.ptr1, state.len[i]);
501        state.ptr[state.MAX_LEN + state.len[i] - 1] = '\0';
502      }
503
504      strlcat(state.ptr2, state.ptr1, state.MAX_LEN + state.len[i]);
505
506      ASSERT_TRUE(memcmp(state.ptr, state.ptr2, state.MAX_LEN + state.len[i]) == 0);
507    }
508  }
509#else // __BIONIC__
510  GTEST_LOG_(INFO) << "This test does nothing.\n";
511#endif // __BIONIC__
512}
513
514TEST(string, strlcpy) {
515#if defined(__BIONIC__)
516  StringTestState<char> state(SMALL);
517  for (size_t j = 0; j < POS_ITER; j++) {
518    state.NewIteration();
519
520    int rand = random() & 255;
521    if (rand < 1) {
522      rand = 1;
523    }
524    memset(state.ptr1, rand, state.MAX_LEN);
525
526    size_t pos = random() % state.MAX_LEN;
527    if (pos < state.MAX_LEN) {
528      state.ptr1[pos] = '\0';
529    }
530    memcpy(state.ptr, state.ptr1, state.MAX_LEN);
531
532    memset(state.ptr2, random() & 255, state.MAX_LEN);
533    memcpy(state.ptr + state.MAX_LEN, state.ptr2, state.MAX_LEN);
534
535    if (pos > state.MAX_LEN - 1) {
536      memcpy(state.ptr + state.MAX_LEN, state.ptr1, state.MAX_LEN);
537      state.ptr[2 * state.MAX_LEN - 1] = '\0';
538    } else {
539      memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1);
540    }
541
542    ASSERT_EQ(strlcpy(state.ptr2, state.ptr1, state.MAX_LEN), strlen(state.ptr1));
543    ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN) != 0) ||
544                 (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0));
545  }
546#else // __BIONIC__
547  GTEST_LOG_(INFO) << "This test does nothing.\n";
548#endif // __BIONIC__
549}
550
551TEST(string, strncat) {
552  StringTestState<char> state(SMALL);
553  for (size_t i = 1; i < state.n; i++) {
554    for (size_t j = 0; j < POS_ITER; j++) {
555      state.NewIteration();
556
557      memset(state.ptr2, '\2', state.MAX_LEN);
558      state.ptr2[state.MAX_LEN - 1] = '\0';
559      memcpy(state.ptr, state.ptr2, 2 * state.MAX_LEN);
560
561      memset(state.ptr1, random() & 255, state.len[i]);
562      state.ptr1[random() % state.len[i]] = '\0';
563      state.ptr1[state.len[i] - 1] = '\0';
564
565      size_t pos = strlen(state.ptr1);
566
567      size_t actual = random() % state.len[i];
568      strncpy(state.ptr + state.MAX_LEN - 1, state.ptr1, std::min(actual, pos));
569      state.ptr[state.MAX_LEN + std::min(actual, pos) - 1] = '\0';
570
571      ASSERT_TRUE(strncat(state.ptr2, state.ptr1, actual) == state.ptr2);
572      ASSERT_EQ(memcmp(state.ptr, state.ptr2, 2 * state.MAX_LEN), 0);
573    }
574  }
575}
576
577TEST(string, strncmp) {
578  StringTestState<char> state(SMALL);
579  for (size_t i = 1; i < state.n; i++) {
580    for (size_t j = 0; j < POS_ITER; j++) {
581      state.NewIteration();
582
583      memset(state.ptr1, 'v', state.MAX_LEN);
584      memset(state.ptr2, 'n', state.MAX_LEN);
585      state.ptr1[state.len[i] - 1] = '\0';
586      state.ptr2[state.len[i] - 1] = '\0';
587
588      int pos = 1 + (random() % (state.MAX_LEN - 1));
589      int actual;
590      int expected;
591      if (pos >= state.len[i] - 1) {
592        memcpy(state.ptr1, state.ptr2, state.len[i]);
593        expected = 0;
594        actual = strncmp(state.ptr1, state.ptr2, state.len[i]);
595      } else {
596        memcpy(state.ptr1, state.ptr2, pos);
597        if (state.ptr1[pos] > state.ptr2[pos]) {
598          expected = 1;
599        } else if (state.ptr1[pos] == state.ptr2[pos]) {
600          state.ptr1[pos + 1] = '\0';
601          state.ptr2[pos + 1] = '\0';
602          expected = 0;
603        } else {
604          expected = -1;
605        }
606        actual = strncmp(state.ptr1, state.ptr2, state.len[i]);
607      }
608
609      ASSERT_EQ(expected, signum(actual));
610    }
611  }
612}
613
614TEST(string, stpncpy) {
615  StringTestState<char> state(SMALL);
616  for (size_t j = 0; j < ITER; j++) {
617    state.NewIteration();
618
619    // Choose a random value to fill the string, except \0 (string terminator),
620    // or \1 (guarantees it's different from anything in ptr2).
621    memset(state.ptr1, (random() % 254) + 2, state.MAX_LEN);
622    // Choose a random size for our src buffer.
623    size_t ptr1_len = random() % state.MAX_LEN;
624    state.ptr1[ptr1_len] = '\0';
625    // Copy ptr1 into ptr, used to verify that ptr1 does not get modified.
626    memcpy(state.ptr, state.ptr1, state.MAX_LEN);
627    // Init ptr2 to a set value.
628    memset(state.ptr2, '\1', state.MAX_LEN);
629
630    // Choose a random amount of data to copy.
631    size_t copy_len = random() % state.MAX_LEN;
632
633    // Set the second half of ptr to the expected pattern in ptr2.
634    memset(state.ptr + state.MAX_LEN, '\1', state.MAX_LEN);
635    memcpy(state.ptr + state.MAX_LEN, state.ptr1, copy_len);
636    size_t expected_end;
637    if (copy_len > ptr1_len) {
638      memset(state.ptr + state.MAX_LEN + ptr1_len, '\0', copy_len - ptr1_len);
639      expected_end = ptr1_len;
640    } else {
641      expected_end = copy_len;
642    }
643
644    ASSERT_EQ(state.ptr2 + expected_end, stpncpy(state.ptr2, state.ptr1, copy_len));
645
646    // Verify ptr1 was not modified.
647    ASSERT_EQ(0, memcmp(state.ptr1, state.ptr, state.MAX_LEN));
648    // Verify ptr2 contains the expected data.
649    ASSERT_EQ(0, memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN));
650  }
651}
652
653TEST(string, strncpy) {
654  StringTestState<char> state(SMALL);
655  for (size_t j = 0; j < ITER; j++) {
656    state.NewIteration();
657
658    // Choose a random value to fill the string, except \0 (string terminator),
659    // or \1 (guarantees it's different from anything in ptr2).
660    memset(state.ptr1, (random() % 254) + 2, state.MAX_LEN);
661    // Choose a random size for our src buffer.
662    size_t ptr1_len = random() % state.MAX_LEN;
663    state.ptr1[ptr1_len] = '\0';
664    // Copy ptr1 into ptr, used to verify that ptr1 does not get modified.
665    memcpy(state.ptr, state.ptr1, state.MAX_LEN);
666    // Init ptr2 to a set value.
667    memset(state.ptr2, '\1', state.MAX_LEN);
668
669    // Choose a random amount of data to copy.
670    size_t copy_len = random() % state.MAX_LEN;
671
672    // Set the second half of ptr to the expected pattern in ptr2.
673    memset(state.ptr + state.MAX_LEN, '\1', state.MAX_LEN);
674    memcpy(state.ptr + state.MAX_LEN, state.ptr1, copy_len);
675    size_t expected_end;
676    if (copy_len > ptr1_len) {
677      memset(state.ptr + state.MAX_LEN + ptr1_len, '\0', copy_len - ptr1_len);
678      expected_end = ptr1_len;
679    } else {
680      expected_end = copy_len;
681    }
682
683    ASSERT_EQ(state.ptr2 + expected_end, stpncpy(state.ptr2, state.ptr1, copy_len));
684
685    // Verify ptr1 was not modified.
686    ASSERT_EQ(0, memcmp(state.ptr1, state.ptr, state.MAX_LEN));
687    // Verify ptr2 contains the expected data.
688    ASSERT_EQ(0, memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN));
689  }
690}
691
692TEST(string, strrchr) {
693  int seek_char = random() & 255;
694  StringTestState<char> state(SMALL);
695  for (size_t i = 1; i < state.n; i++) {
696    for (size_t j = 0; j < POS_ITER; j++) {
697      state.NewIteration();
698
699      if (~seek_char > 0) {
700        memset(state.ptr1, ~seek_char, state.len[i]);
701      } else {
702        memset(state.ptr1, '\1', state.len[i]);
703      }
704      state.ptr1[state.len[i] - 1] = '\0';
705
706      int pos = random() % state.MAX_LEN;
707      char* expected;
708      if (pos >= state.len[i] - 1) {
709        if (seek_char == 0) {
710          expected = state.ptr1 + state.len[i] - 1;
711        } else {
712          expected = NULL;
713        }
714      } else {
715        state.ptr1[pos] = seek_char;
716        expected = state.ptr1 + pos;
717      }
718
719      ASSERT_TRUE(strrchr(state.ptr1, seek_char) == expected);
720    }
721  }
722}
723
724TEST(string, memchr) {
725  int seek_char = random() & 255;
726  StringTestState<char> state(SMALL);
727  for (size_t i = 0; i < state.n; i++) {
728    for (size_t j = 0; j < POS_ITER; j++) {
729      state.NewIteration();
730
731      memset(state.ptr1, ~seek_char, state.len[i]);
732
733      int pos = random() % state.MAX_LEN;
734      char* expected;
735      if (pos >= state.len[i]) {
736        expected = NULL;
737      } else {
738        state.ptr1[pos] = seek_char;
739        expected = state.ptr1 + pos;
740      }
741
742      ASSERT_TRUE(memchr(state.ptr1, seek_char, state.len[i]) == expected);
743    }
744  }
745}
746
747TEST(string, memrchr) {
748  int seek_char = random() & 255;
749  StringTestState<char> state(SMALL);
750  for (size_t i = 0; i < state.n; i++) {
751    for (size_t j = 0; j < POS_ITER; j++) {
752      state.NewIteration();
753
754      memset(state.ptr1, ~seek_char, state.len[i]);
755
756      int pos = random() % state.MAX_LEN;
757      char* expected;
758      if (pos >= state.len[i]) {
759        expected = NULL;
760      } else {
761        state.ptr1[pos] = seek_char;
762        expected = state.ptr1 + pos;
763      }
764
765      ASSERT_TRUE(memrchr(state.ptr1, seek_char, state.len[i]) == expected);
766    }
767  }
768}
769
770TEST(string, memcmp) {
771  StringTestState<char> state(SMALL);
772  for (size_t i = 0; i < state.n; i++) {
773    for (size_t j = 0; j < POS_ITER; j++) {
774      state.NewIteration();
775
776      int c1 = random() & 0xff;
777      int c2 = random() & 0xff;
778      memset(state.ptr1, c1, state.MAX_LEN);
779      memset(state.ptr2, c1, state.MAX_LEN);
780
781      int pos = (state.len[i] == 0) ? 0 : (random() % state.len[i]);
782      state.ptr2[pos] = c2;
783
784      int expected = (static_cast<int>(c1) - static_cast<int>(c2));
785      int actual = memcmp(state.ptr1, state.ptr2, state.MAX_LEN);
786
787      ASSERT_EQ(signum(expected), signum(actual));
788    }
789  }
790}
791
792TEST(string, wmemcmp) {
793  StringTestState<wchar_t> state(SMALL);
794
795  for (size_t i = 0; i < state.n; i++) {
796    for (size_t j = 0; j < POS_ITER; j++) {
797      state.NewIteration();
798
799      long long mask = ((long long) 1 << 8 * sizeof(wchar_t)) - 1;
800      int c1 = rand() & mask;
801      int c2 = rand() & mask;
802      wmemset(state.ptr1, c1, state.MAX_LEN);
803      wmemset(state.ptr2, c1, state.MAX_LEN);
804
805      int pos = (state.len[i] == 0) ? 0 : (random() % state.len[i]);
806      state.ptr2[pos] = c2;
807
808      int expected = (static_cast<int>(c1) - static_cast<int>(c2));
809      int actual = wmemcmp(state.ptr1, state.ptr2, (size_t) state.MAX_LEN);
810
811      ASSERT_EQ(signum(expected), signum(actual));
812    }
813  }
814}
815
816TEST(string, memcpy) {
817  StringTestState<char> state(LARGE);
818  int rand = random() & 255;
819  for (size_t i = 0; i < state.n - 1; i++) {
820    for (size_t j = 0; j < POS_ITER; j++) {
821      state.NewIteration();
822
823      size_t pos = random() % (state.MAX_LEN - state.len[i]);
824
825      memset(state.ptr1, rand, state.len[i]);
826      memset(state.ptr1 + state.len[i], ~rand, state.MAX_LEN - state.len[i]);
827
828      memset(state.ptr2, rand, state.len[i]);
829      memset(state.ptr2 + state.len[i], ~rand, state.MAX_LEN - state.len[i]);
830      memset(state.ptr2 + pos, '\0', state.len[i]);
831
832      ASSERT_FALSE(memcpy(state.ptr2 + pos, state.ptr1 + pos, state.len[i]) != state.ptr2 + pos);
833      ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN));
834    }
835  }
836}
837
838TEST(string, memset) {
839  StringTestState<char> state(LARGE);
840  char ch = random () & 255;
841  for (size_t i = 0; i < state.n - 1; i++) {
842    for (size_t j = 0; j < POS_ITER; j++) {
843      state.NewIteration();
844
845      memset(state.ptr1, ~ch, state.MAX_LEN);
846      memcpy(state.ptr2, state.ptr1, state.MAX_LEN);
847
848      size_t pos = random () % (state.MAX_LEN - state.len[i]);
849      for (size_t k = pos; k < pos + state.len[i]; k++) {
850        state.ptr1[k] = ch;
851      }
852
853      ASSERT_TRUE(memset(state.ptr2 + pos, ch, state.len[i]) == state.ptr2 + pos);
854
855      ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN));
856    }
857  }
858}
859
860TEST(string, memmove) {
861  StringTestState<char> state(LARGE);
862  for (size_t i = 0; i < state.n - 1; i++) {
863    for (size_t j = 0; j < POS_ITER; j++) {
864      state.NewIteration();
865
866      memset(state.ptr1, random() & 255, 2 * state.MAX_LEN);
867
868      size_t pos = random() % (state.MAX_LEN - state.len[i]);
869
870      memset(state.ptr1, random() & 255, state.len[i]);
871      memcpy(state.ptr2, state.ptr1, 2 * state.MAX_LEN);
872      memcpy(state.ptr, state.ptr1, state.len[i]);
873      memcpy(state.ptr1 + pos, state.ptr, state.len[i]);
874
875      ASSERT_TRUE(memmove(state.ptr2 + pos, state.ptr2, state.len[i]) == state.ptr2 + pos);
876      ASSERT_EQ(0, memcmp(state.ptr2, state.ptr1, 2 * state.MAX_LEN));
877    }
878  }
879}
880
881TEST(string, memmove_cache_size) {
882  size_t len = 600000;
883  int max_alignment = 31;
884  int alignments[] = {0, 5, 11, 29, 30};
885  char* ptr = reinterpret_cast<char*>(malloc(sizeof(char) * len));
886  char* ptr1 = reinterpret_cast<char*>(malloc(2 * sizeof(char) * len));
887  char* glob_ptr2 = reinterpret_cast<char*>(malloc(2 * sizeof(char) * len + max_alignment));
888  size_t pos = 64;
889
890  ASSERT_TRUE(ptr != NULL);
891  ASSERT_TRUE(ptr1 != NULL);
892  ASSERT_TRUE(glob_ptr2 != NULL);
893
894  for (int i = 0; i < 5; i++) {
895    char* ptr2 = glob_ptr2 + alignments[i];
896    memset(ptr1, random() & 255, 2 * len);
897    memset(ptr1, random() & 255, len);
898    memcpy(ptr2, ptr1, 2 * len);
899    memcpy(ptr, ptr1, len);
900    memcpy(ptr1 + pos, ptr, len);
901
902    ASSERT_TRUE(memmove(ptr2 + pos, ptr, len) == ptr2 + pos);
903    ASSERT_EQ(0, memcmp(ptr2, ptr1, 2 * len));
904  }
905  free(ptr);
906  free(ptr1);
907  free(glob_ptr2);
908}
909
910static void verify_memmove(char* src_copy, char* dst, char* src, size_t size) {
911  memset(dst, 0, size);
912  memcpy(src, src_copy, size);
913  ASSERT_EQ(dst, memmove(dst, src, size));
914  ASSERT_EQ(0, memcmp(dst, src_copy, size));
915}
916
917#define MEMMOVE_DATA_SIZE (1024*1024*3)
918
919TEST(string, memmove_check) {
920  char* buffer = reinterpret_cast<char*>(malloc(MEMMOVE_DATA_SIZE));
921  ASSERT_TRUE(buffer != NULL);
922
923  char* src_data = reinterpret_cast<char*>(malloc(MEMMOVE_DATA_SIZE));
924  ASSERT_TRUE(src_data != NULL);
925  // Initialize to a known pattern to copy into src for each test and
926  // to compare dst against.
927  for (size_t i = 0; i < MEMMOVE_DATA_SIZE; i++) {
928    src_data[i] = (i + 1) % 255;
929  }
930
931  // Check all different dst offsets between 0 and 127 inclusive.
932  char* src = buffer;
933  for (size_t i = 0; i < 127; i++) {
934    char* dst = buffer + 256 + i;
935    // Small copy.
936    verify_memmove(src_data, dst, src, 1024);
937
938    // Medium copy.
939    verify_memmove(src_data, dst, src, 64 * 1024);
940
941    // Medium copy.
942    verify_memmove(src_data, dst, src, 1024 * 1024 + 128 * 1024);
943  }
944
945  // Check all leftover size offsets between 1 and 127 inclusive.
946  char* dst = buffer + 256;
947  src = buffer;
948  for (size_t size = 1; size < 127; size++) {
949    // Small copy.
950    verify_memmove(src_data, dst, src, 1024);
951
952    // Medium copy.
953    verify_memmove(src_data, dst, src, 64 * 1024);
954
955    // Large copy.
956    verify_memmove(src_data, dst, src, 1024 * 1024 + 128 * 1024);
957  }
958}
959
960TEST(string, bcopy) {
961  StringTestState<char> state(LARGE);
962  for (size_t i = 0; i < state.n; i++) {
963    for (size_t j = 0; j < POS_ITER; j++) {
964      state.NewIteration();
965
966      memset(state.ptr1, random() & 255, state.MAX_LEN);
967      memset(state.ptr1 + state.MAX_LEN, random() & 255, state.MAX_LEN);
968      memcpy(state.ptr2, state.ptr1, 2 * state.MAX_LEN);
969
970      size_t start = random() % (2 * state.MAX_LEN - state.len[i]);
971      memcpy(state.ptr2 + start, state.ptr1, state.len[i]);
972
973      bcopy(state.ptr1, state.ptr1 + start, state.len[i]);
974      ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, 2 * state.MAX_LEN));
975    }
976  }
977}
978
979TEST(string, bzero) {
980  StringTestState<char> state(LARGE);
981  for (size_t j = 0; j < ITER; j++) {
982    state.NewIteration();
983
984    memset(state.ptr1, random() & 255, state.MAX_LEN);
985
986    size_t start = random() % state.MAX_LEN;
987    size_t end = start + random() % (state.MAX_LEN - start);
988
989    memcpy(state.ptr2, state.ptr1, start);
990    memset(state.ptr2 + start, '\0', end - start);
991    memcpy(state.ptr2 + end, state.ptr1 + end, state.MAX_LEN - end);
992
993    bzero(state.ptr1 + start, end - start);
994
995    ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN));
996  }
997}
998
999static void DoMemcpyTest(uint8_t* src, uint8_t* dst, size_t len) {
1000  memset(src, (len % 255) + 1, len);
1001  memset(dst, 0, len);
1002
1003  ASSERT_EQ(dst, memcpy(dst, src, len));
1004  ASSERT_TRUE(memcmp(src, dst, len) == 0);
1005}
1006
1007TEST(string, memcpy_align) {
1008  RunSrcDstBufferAlignTest(LARGE, DoMemcpyTest);
1009}
1010
1011TEST(string, memcpy_overread) {
1012  RunSrcDstBufferOverreadTest(DoMemcpyTest);
1013}
1014
1015static void DoMemmoveTest(uint8_t* src, uint8_t* dst, size_t len) {
1016  memset(src, (len % 255) + 1, len);
1017  memset(dst, 0, len);
1018
1019  ASSERT_EQ(dst, memmove(dst, src, len));
1020  ASSERT_TRUE(memcmp(src, dst, len) == 0);
1021}
1022
1023TEST(string, memmove_align) {
1024  RunSrcDstBufferAlignTest(LARGE, DoMemmoveTest);
1025}
1026
1027TEST(string, memmove_overread) {
1028  RunSrcDstBufferOverreadTest(DoMemmoveTest);
1029}
1030
1031static void DoMemsetTest(uint8_t* buf, size_t len) {
1032  for (size_t i = 0; i < len; i++) {
1033    buf[i] = 0;
1034  }
1035  int value = (len % 255) + 1;
1036  ASSERT_EQ(buf, memset(buf, value, len));
1037  for (size_t i = 0; i < len; i++) {
1038    ASSERT_EQ(value, buf[i]);
1039  }
1040}
1041
1042TEST(string, memset_align) {
1043  RunSingleBufferAlignTest(LARGE, DoMemsetTest);
1044}
1045
1046static void DoStrlenTest(uint8_t* buf, size_t len) {
1047  if (len >= 1) {
1048    memset(buf, (32 + (len % 96)), len - 1);
1049    buf[len-1] = '\0';
1050    ASSERT_EQ(len-1, strlen(reinterpret_cast<char*>(buf)));
1051  }
1052}
1053
1054TEST(string, strlen_align) {
1055  RunSingleBufferAlignTest(LARGE, DoStrlenTest);
1056}
1057
1058TEST(string, strlen_overread) {
1059  RunSingleBufferOverreadTest(DoStrlenTest);
1060}
1061
1062static void DoStrcpyTest(uint8_t* src, uint8_t* dst, size_t len) {
1063  if (len >= 1) {
1064    memset(src, (32 + (len % 96)), len - 1);
1065    src[len-1] = '\0';
1066    memset(dst, 0, len);
1067    ASSERT_EQ(dst, reinterpret_cast<uint8_t*>(strcpy(reinterpret_cast<char*>(dst),
1068                                                     reinterpret_cast<char*>(src))));
1069    ASSERT_TRUE(memcmp(src, dst, len) == 0);
1070  }
1071}
1072
1073TEST(string, strcpy_align) {
1074  RunSrcDstBufferAlignTest(LARGE, DoStrcpyTest);
1075}
1076
1077TEST(string, strcpy_overread) {
1078  RunSrcDstBufferOverreadTest(DoStrcpyTest);
1079}
1080
1081static void DoStpcpyTest(uint8_t* src, uint8_t* dst, size_t len) {
1082  if (len >= 1) {
1083    memset(src, (32 + (len % 96)), len - 1);
1084    src[len-1] = '\0';
1085    memset(dst, 0, len);
1086    ASSERT_EQ(dst+len-1, reinterpret_cast<uint8_t*>(stpcpy(reinterpret_cast<char*>(dst),
1087                                                           reinterpret_cast<char*>(src))));
1088    ASSERT_TRUE(memcmp(src, dst, len) == 0);
1089  }
1090}
1091
1092TEST(string, stpcpy_align) {
1093  RunSrcDstBufferAlignTest(LARGE, DoStpcpyTest);
1094}
1095
1096TEST(string, stpcpy_overread) {
1097  RunSrcDstBufferOverreadTest(DoStpcpyTest);
1098}
1099
1100// Use our own incrementer to cut down on the total number of calls.
1101static size_t LargeSetIncrement(size_t len) {
1102  if (len >= 4096) {
1103    return 4096;
1104  } else if (len >= 1024) {
1105    return 1024;
1106  } else if (len >= 256) {
1107    return 256;
1108  }
1109  return 1;
1110}
1111
1112#define STRCAT_DST_LEN  128
1113
1114static void DoStrcatTest(uint8_t* src, uint8_t* dst, size_t len) {
1115  if (len >= 1) {
1116    int value = 32 + (len % 96);
1117    memset(src, value, len - 1);
1118    src[len-1] = '\0';
1119
1120    if (len >= STRCAT_DST_LEN) {
1121      // Create a small buffer for doing quick compares in each loop.
1122      uint8_t cmp_buf[STRCAT_DST_LEN];
1123      // Make sure dst string contains a different value then the src string.
1124      int value2 = 32 + (value + 2) % 96;
1125      memset(cmp_buf, value2, sizeof(cmp_buf));
1126
1127      for (size_t i = 1; i <= STRCAT_DST_LEN; i++) {
1128        memset(dst, value2, i-1);
1129        memset(dst+i-1, 0, len-i);
1130        src[len-i] = '\0';
1131        ASSERT_EQ(dst, reinterpret_cast<uint8_t*>(strcat(reinterpret_cast<char*>(dst),
1132                                                         reinterpret_cast<char*>(src))));
1133        ASSERT_TRUE(memcmp(dst, cmp_buf, i-1) == 0);
1134        ASSERT_TRUE(memcmp(src, dst+i-1, len-i+1) == 0);
1135      }
1136    } else {
1137      dst[0] = '\0';
1138      ASSERT_EQ(dst, reinterpret_cast<uint8_t*>(strcat(reinterpret_cast<char*>(dst),
1139                                                       reinterpret_cast<char*>(src))));
1140      ASSERT_TRUE(memcmp(src, dst, len) == 0);
1141    }
1142  }
1143}
1144
1145TEST(string, strcat_align) {
1146  RunSrcDstBufferAlignTest(MEDIUM, DoStrcatTest, LargeSetIncrement);
1147}
1148
1149TEST(string, strcat_overread) {
1150  RunSrcDstBufferOverreadTest(DoStrcatTest);
1151}
1152
1153static void DoStrcmpTest(uint8_t* buf1, uint8_t* buf2, size_t len) {
1154  if (len >= 1) {
1155    memset(buf1, (32 + (len % 96)), len - 1);
1156    buf1[len-1] = '\0';
1157    memset(buf2, (32 + (len % 96)), len - 1);
1158    buf2[len-1] = '\0';
1159    ASSERT_EQ(0, strcmp(reinterpret_cast<char*>(buf1),
1160                        reinterpret_cast<char*>(buf2)));
1161  }
1162}
1163
1164static void DoStrcmpFailTest(uint8_t* buf1, uint8_t* buf2, size_t len1, size_t len2) {
1165  // Do string length differences.
1166  int c = (32 + (len1 % 96));
1167  memset(buf1, c, len1 - 1);
1168  buf1[len1-1] = '\0';
1169  memset(buf2, c, len2 - 1);
1170  buf2[len2-1] = '\0';
1171  ASSERT_NE(0, strcmp(reinterpret_cast<char*>(buf1),
1172                      reinterpret_cast<char*>(buf2)));
1173
1174  // Do single character differences.
1175  size_t len;
1176  if (len1 > len2) {
1177    len = len2;
1178  } else {
1179    len = len1;
1180  }
1181  // Need at least a two character buffer to do this test.
1182  if (len > 1) {
1183    buf1[len-1] = '\0';
1184    buf2[len-1] = '\0';
1185    int diff_c = (c + 1) % 96;
1186
1187    buf1[len-2] = diff_c;
1188    ASSERT_NE(0, strcmp(reinterpret_cast<char*>(buf1),
1189                        reinterpret_cast<char*>(buf2)));
1190
1191    buf1[len-2] = c;
1192    buf2[len-2] = diff_c;
1193    ASSERT_NE(0, strcmp(reinterpret_cast<char*>(buf1),
1194                        reinterpret_cast<char*>(buf2)));
1195  }
1196}
1197
1198TEST(string, strcmp_align) {
1199  RunCmpBufferAlignTest(MEDIUM, DoStrcmpTest, DoStrcmpFailTest, LargeSetIncrement);
1200}
1201
1202TEST(string, strcmp_overread) {
1203  RunCmpBufferOverreadTest(DoStrcmpTest, DoStrcmpFailTest);
1204}
1205
1206static void DoMemcmpTest(uint8_t* buf1, uint8_t* buf2, size_t len) {
1207  memset(buf1, len+1, len);
1208  memset(buf2, len+1, len);
1209  ASSERT_EQ(0, memcmp(buf1, buf2, len));
1210}
1211
1212static void DoMemcmpFailTest(uint8_t* buf1, uint8_t* buf2, size_t len1, size_t len2) {
1213  size_t len;
1214  if (len1 > len2) {
1215    len = len2;
1216  } else {
1217    len = len1;
1218  }
1219
1220  memset(buf1, len2+1, len);
1221  buf1[len-1] = len2;
1222  memset(buf2, len2+1, len);
1223  ASSERT_NE(0, memcmp(buf1, buf2, len));
1224
1225  buf1[len-1] = len2+1;
1226  buf2[len-1] = len2;
1227  ASSERT_NE(0, memcmp(buf1, buf2, len));
1228}
1229
1230TEST(string, memcmp_align) {
1231  RunCmpBufferAlignTest(MEDIUM, DoMemcmpTest, DoMemcmpFailTest, LargeSetIncrement);
1232}
1233
1234TEST(string, memcmp_overread) {
1235  RunCmpBufferOverreadTest(DoMemcmpTest, DoMemcmpFailTest);
1236}
1237