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