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 #define _GNU_SOURCE 1
18 
19 #include <string.h>
20 
21 #include <errno.h>
22 #include <gtest/gtest.h>
23 #include <malloc.h>
24 #include <math.h>
25 #include <stdint.h>
26 
27 #include <algorithm>
28 #include <vector>
29 
30 #include "buffer_tests.h"
31 
32 #if defined(NOFORTIFY)
33 #define STRING_TEST string_nofortify
34 #else
35 #define STRING_TEST string
36 #endif
37 
38 #if defined(__BIONIC__)
39 #define STRLCPY_SUPPORTED
40 #define STRLCAT_SUPPORTED
41 #endif
42 
43 constexpr auto KB = 1024;
44 constexpr auto SMALL = 1 * KB;
45 constexpr auto MEDIUM = 4 * KB;
46 constexpr auto LARGE = 64 * KB;
47 
signum(int i)48 static int signum(int i) {
49   if (i < 0) {
50     return -1;
51   } else if (i > 0) {
52     return 1;
53   }
54   return 0;
55 }
56 
TEST(STRING_TEST,strerror)57 TEST(STRING_TEST, strerror) {
58   // Valid.
59   ASSERT_STREQ("Success", strerror(0));
60   ASSERT_STREQ("Operation not permitted", strerror(1));
61 
62   // Invalid.
63   ASSERT_STREQ("Unknown error -1", strerror(-1));
64   ASSERT_STREQ("Unknown error 134", strerror(EHWPOISON + 1));
65 }
66 
TEST(STRING_TEST,strerror_l)67 TEST(STRING_TEST, strerror_l) {
68   // bionic just forwards to strerror(3).
69   ASSERT_STREQ("Success", strerror_l(0, LC_GLOBAL_LOCALE));
70 }
71 
72 #if defined(__BIONIC__)
ConcurrentStrErrorFn(void *)73 static void* ConcurrentStrErrorFn(void*) {
74   bool equal = (strcmp("Unknown error 2002", strerror(2002)) == 0);
75   return reinterpret_cast<void*>(equal);
76 }
77 #endif // __BIONIC__
78 
79 // glibc's strerror isn't thread safe, only its strsignal.
TEST(STRING_TEST,strerror_concurrent)80 TEST(STRING_TEST, strerror_concurrent) {
81 #if defined(__BIONIC__)
82   const char* strerror1001 = strerror(1001);
83   ASSERT_STREQ("Unknown error 1001", strerror1001);
84 
85   pthread_t t;
86   ASSERT_EQ(0, pthread_create(&t, nullptr, ConcurrentStrErrorFn, nullptr));
87   void* result;
88   ASSERT_EQ(0, pthread_join(t, &result));
89   ASSERT_TRUE(static_cast<bool>(result));
90 
91   ASSERT_STREQ("Unknown error 1001", strerror1001);
92 #else // __BIONIC__
93   GTEST_SKIP() << "thread-safe strerror not available";
94 #endif // __BIONIC__
95 }
96 
TEST(STRING_TEST,gnu_strerror_r)97 TEST(STRING_TEST, gnu_strerror_r) {
98   char buf[256];
99 
100   // Note that glibc doesn't necessarily write into the buffer.
101 
102   // Valid.
103   ASSERT_STREQ("Success", strerror_r(0, buf, sizeof(buf)));
104 #if defined(__BIONIC__)
105   ASSERT_STREQ("Success", buf);
106 #endif
107   ASSERT_STREQ("Operation not permitted", strerror_r(1, buf, sizeof(buf)));
108 #if defined(__BIONIC__)
109   ASSERT_STREQ("Operation not permitted", buf);
110 #endif
111 
112   // Invalid.
113   ASSERT_STREQ("Unknown error -1", strerror_r(-1, buf, sizeof(buf)));
114   ASSERT_STREQ("Unknown error -1", buf);
115   ASSERT_STREQ("Unknown error 1234", strerror_r(1234, buf, sizeof(buf)));
116   ASSERT_STREQ("Unknown error 1234", buf);
117 
118   // Buffer too small.
119   errno = 0;
120   memset(buf, 0, sizeof(buf));
121   ASSERT_EQ(buf, strerror_r(4567, buf, 2));
122   ASSERT_STREQ("U", buf);
123   // The GNU strerror_r doesn't set errno (the POSIX one sets it to ERANGE).
124   ASSERT_EQ(0, errno);
125 }
126 
TEST(STRING_TEST,strsignal)127 TEST(STRING_TEST, strsignal) {
128   // A regular signal.
129   ASSERT_STREQ("Hangup", strsignal(1));
130 
131   // A real-time signal.
132   ASSERT_STREQ("Real-time signal 14", strsignal(SIGRTMIN + 14));
133   // One of the signals the C library keeps to itself.
134   ASSERT_STREQ("Unknown signal 32", strsignal(__SIGRTMIN));
135 
136   // Errors.
137   ASSERT_STREQ("Unknown signal -1", strsignal(-1)); // Too small.
138   ASSERT_STREQ("Unknown signal 0", strsignal(0)); // Still too small.
139   ASSERT_STREQ("Unknown signal 1234", strsignal(1234)); // Too large.
140 }
141 
ConcurrentStrSignalFn(void *)142 static void* ConcurrentStrSignalFn(void*) {
143   bool equal = (strcmp("Unknown signal 2002", strsignal(2002)) == 0);
144   return reinterpret_cast<void*>(equal);
145 }
146 
TEST(STRING_TEST,strsignal_concurrent)147 TEST(STRING_TEST, strsignal_concurrent) {
148   const char* strsignal1001 = strsignal(1001);
149   ASSERT_STREQ("Unknown signal 1001", strsignal1001);
150 
151   pthread_t t;
152   ASSERT_EQ(0, pthread_create(&t, nullptr, ConcurrentStrSignalFn, nullptr));
153   void* result;
154   ASSERT_EQ(0, pthread_join(t, &result));
155   ASSERT_TRUE(static_cast<bool>(result));
156 
157   ASSERT_STREQ("Unknown signal 1001", strsignal1001);
158 }
159 
160 // TODO: where did this number come from?
161 #define ITER        500
162 
163 // For every length we want to test, vary and change alignment
164 // of allocated memory, fill it with some values, calculate
165 // expected result and then run function and compare what we got.
166 // These tests contributed by Intel Corporation.
167 // TODO: make these tests more intention-revealing and less random.
168 template<class Character>
169 class StringTestState {
170  public:
StringTestState(size_t MAX_LEN)171   explicit StringTestState(size_t MAX_LEN) : MAX_LEN(MAX_LEN), align1_index_(0), align2_index_(0) {
172     int max_alignment = 64;
173 
174     // TODO: fix the tests to not sometimes use twice their specified "MAX_LEN".
175     glob_ptr = reinterpret_cast<Character*>(memalign(sysconf(_SC_PAGESIZE), 2 * sizeof(Character) * MAX_LEN + max_alignment));
176     glob_ptr1 = reinterpret_cast<Character*>(memalign(sysconf(_SC_PAGESIZE), 2 * sizeof(Character) * MAX_LEN + max_alignment));
177     glob_ptr2 = reinterpret_cast<Character*>(memalign(sysconf(_SC_PAGESIZE), 2 * sizeof(Character) * MAX_LEN + max_alignment));
178 
179     InitLenArray();
180 
181     srandom(1234);
182   }
183 
~StringTestState()184   ~StringTestState() {
185     free(glob_ptr);
186     free(glob_ptr1);
187     free(glob_ptr2);
188   }
189 
BeginIterations()190   void BeginIterations() {
191     align1_index_ = 0;
192     align2_index_ = 0;
193 
194     ResetPointers();
195   }
196 
HasNextIteration()197   bool HasNextIteration() {
198     return (align1_index_ != (alignments_size - 1) || align2_index_ != (alignments_size - 1));
199   }
200 
NextIteration()201   void NextIteration() {
202     if (align1_index_ == (alignments_size - 1) && align2_index_ == (alignments_size - 1)) {
203       return;
204     }
205 
206     if (align1_index_ == (alignments_size - 1)) {
207       align1_index_ = 0;
208       align2_index_++;
209     } else {
210       align1_index_++;
211     }
212 
213     ResetPointers();
214   }
215 
216   const size_t MAX_LEN;
217   Character *ptr, *ptr1, *ptr2;
218   size_t n;
219   size_t len[ITER + 1];
220 
221  private:
222   static size_t alignments[];
223   static size_t alignments_size;
224   Character *glob_ptr, *glob_ptr1, *glob_ptr2;
225   size_t align1_index_, align2_index_;
226 
227   // Calculate input lengths and fill state.len with them.
228   // Test small lengths with more density than big ones. Manually push
229   // smallest (0) and biggest (MAX_LEN) lengths. Avoid repeats.
230   // Return number of lengths to test.
InitLenArray()231   void InitLenArray() {
232     n = 0;
233     len[n++] = 0;
234     for (size_t i = 1; i < ITER; ++i) {
235       size_t l = static_cast<size_t>(exp(log(static_cast<double>(MAX_LEN)) * i / ITER));
236       if (l != len[n - 1]) {
237         len[n++] = l;
238       }
239     }
240     len[n++] = MAX_LEN;
241   }
242 
ResetPointers()243   void ResetPointers() {
244     if (align1_index_ == alignments_size || align2_index_ == alignments_size) {
245       ptr = ptr1 = ptr2 = nullptr;
246     } else {
247       ptr = glob_ptr + alignments[align1_index_];
248       ptr1 = glob_ptr1 + alignments[align1_index_];
249       ptr2 = glob_ptr2 + alignments[align2_index_];
250     }
251   }
252 };
253 
254 template<class Character>
255 size_t StringTestState<Character>::alignments[] = { 24, 32, 16, 48, 0, 1, 2, 3, 4, 5, 6, 7, 11 };
256 
257 template<class Character>
258 size_t StringTestState<Character>::alignments_size = sizeof(alignments)/sizeof(size_t);
259 
TEST(STRING_TEST,strcat)260 TEST(STRING_TEST, strcat) {
261   StringTestState<char> state(SMALL);
262   for (size_t i = 1; i < state.n; i++) {
263     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
264       memset(state.ptr2, '\2', state.MAX_LEN);
265       state.ptr2[state.MAX_LEN - 1] = '\0';
266       memcpy(state.ptr, state.ptr2, 2 * state.MAX_LEN);
267 
268       memset(state.ptr1, 'L', state.len[i]);
269       state.ptr1[random() % state.len[i]] = '\0';
270       state.ptr1[state.len[i] - 1] = '\0';
271 
272       strcpy(state.ptr + state.MAX_LEN - 1, state.ptr1);
273 
274       EXPECT_TRUE(strcat(state.ptr2, state.ptr1) == state.ptr2);
275       EXPECT_TRUE(memcmp(state.ptr, state.ptr2, 2 * state.MAX_LEN) == 0);
276     }
277   }
278 }
279 
280 // one byte target with "\0" source
TEST(STRING_TEST,strcpy2)281 TEST(STRING_TEST, strcpy2) {
282   char buf[1];
283   char* orig = strdup("");
284   ASSERT_EQ(buf, strcpy(buf, orig));
285   ASSERT_EQ('\0', buf[0]);
286   free(orig);
287 }
288 
289 // multibyte target where we under fill target
TEST(STRING_TEST,strcpy3)290 TEST(STRING_TEST, strcpy3) {
291   char buf[10];
292   char* orig = strdup("12345");
293   memset(buf, 'A', sizeof(buf));
294   ASSERT_EQ(buf, strcpy(buf, orig));
295   ASSERT_STREQ("12345", buf);
296   ASSERT_EQ('A',  buf[6]);
297   ASSERT_EQ('A',  buf[7]);
298   ASSERT_EQ('A',  buf[8]);
299   ASSERT_EQ('A',  buf[9]);
300   free(orig);
301 }
302 
303 // multibyte target where we fill target exactly
TEST(STRING_TEST,strcpy4)304 TEST(STRING_TEST, strcpy4) {
305   char buf[10];
306   char* orig = strdup("123456789");
307   memset(buf, 'A', sizeof(buf));
308   ASSERT_EQ(buf, strcpy(buf, orig));
309   ASSERT_STREQ("123456789", buf);
310   free(orig);
311 }
312 
313 // one byte target with "\0" source
TEST(STRING_TEST,stpcpy2)314 TEST(STRING_TEST, stpcpy2) {
315   char buf[1];
316   char* orig = strdup("");
317   ASSERT_EQ(buf, stpcpy(buf, orig));
318   ASSERT_EQ('\0', buf[0]);
319   free(orig);
320 }
321 
322 // multibyte target where we under fill target
TEST(STRING_TEST,stpcpy3)323 TEST(STRING_TEST, stpcpy3) {
324   char buf[10];
325   char* orig = strdup("12345");
326   memset(buf, 'A', sizeof(buf));
327   ASSERT_EQ(buf+strlen(orig), stpcpy(buf, orig));
328   ASSERT_STREQ("12345", buf);
329   ASSERT_EQ('A',  buf[6]);
330   ASSERT_EQ('A',  buf[7]);
331   ASSERT_EQ('A',  buf[8]);
332   ASSERT_EQ('A',  buf[9]);
333   free(orig);
334 }
335 
336 // multibyte target where we fill target exactly
TEST(STRING_TEST,stpcpy4)337 TEST(STRING_TEST, stpcpy4) {
338   char buf[10];
339   char* orig = strdup("123456789");
340   memset(buf, 'A', sizeof(buf));
341   ASSERT_EQ(buf+strlen(orig), stpcpy(buf, orig));
342   ASSERT_STREQ("123456789", buf);
343   free(orig);
344 }
345 
TEST(STRING_TEST,strcat2)346 TEST(STRING_TEST, strcat2) {
347   char buf[10];
348   memset(buf, 'A', sizeof(buf));
349   buf[0] = 'a';
350   buf[1] = '\0';
351   char* res = strcat(buf, "01234");
352   ASSERT_EQ(buf, res);
353   ASSERT_STREQ("a01234", buf);
354   ASSERT_EQ('A',  buf[7]);
355   ASSERT_EQ('A',  buf[8]);
356   ASSERT_EQ('A',  buf[9]);
357 }
358 
TEST(STRING_TEST,strcat3)359 TEST(STRING_TEST, strcat3) {
360   char buf[10];
361   memset(buf, 'A', sizeof(buf));
362   buf[0] = 'a';
363   buf[1] = '\0';
364   char* res = strcat(buf, "01234567");
365   ASSERT_EQ(buf, res);
366   ASSERT_STREQ("a01234567", buf);
367 }
368 
TEST(STRING_TEST,strncat2)369 TEST(STRING_TEST, strncat2) {
370   char buf[10];
371   memset(buf, 'A', sizeof(buf));
372   buf[0] = 'a';
373   buf[1] = '\0';
374   char* res = strncat(buf, "01234", sizeof(buf) - strlen(buf) - 1);
375   ASSERT_EQ(buf, res);
376   ASSERT_STREQ("a01234", buf);
377   ASSERT_EQ('A',  buf[7]);
378   ASSERT_EQ('A',  buf[8]);
379   ASSERT_EQ('A',  buf[9]);
380 }
381 
TEST(STRING_TEST,strncat3)382 TEST(STRING_TEST, strncat3) {
383   char buf[10];
384   memset(buf, 'A', sizeof(buf));
385   buf[0] = 'a';
386   buf[1] = '\0';
387   char* res = strncat(buf, "0123456789", 5);
388   ASSERT_EQ(buf, res);
389   ASSERT_STREQ("a01234", buf);
390   ASSERT_EQ('A',  buf[7]);
391   ASSERT_EQ('A',  buf[8]);
392   ASSERT_EQ('A',  buf[9]);
393 }
394 
TEST(STRING_TEST,strncat4)395 TEST(STRING_TEST, strncat4) {
396   char buf[10];
397   memset(buf, 'A', sizeof(buf));
398   buf[0] = 'a';
399   buf[1] = '\0';
400   char* res = strncat(buf, "01234567", 8);
401   ASSERT_EQ(buf, res);
402   ASSERT_STREQ("a01234567", buf);
403 }
404 
TEST(STRING_TEST,strncat5)405 TEST(STRING_TEST, strncat5) {
406   char buf[10];
407   memset(buf, 'A', sizeof(buf));
408   buf[0] = 'a';
409   buf[1] = '\0';
410   char* res = strncat(buf, "01234567", 9);
411   ASSERT_EQ(buf, res);
412   ASSERT_STREQ("a01234567", buf);
413 }
414 
TEST(STRING_TEST,strchr_with_0)415 TEST(STRING_TEST, strchr_with_0) {
416   char buf[10];
417   const char* s = "01234";
418   memcpy(buf, s, strlen(s) + 1);
419   EXPECT_TRUE(strchr(buf, '\0') == (buf + strlen(s)));
420 }
421 
TEST(STRING_TEST,strchr_multiple)422 TEST(STRING_TEST, strchr_multiple) {
423   char str[128];
424   memset(str, 'a', sizeof(str) - 1);
425   str[sizeof(str)-1] = '\0';
426 
427   // Verify that strchr finds the first occurrence of 'a' in a string
428   // filled with 'a' characters. Iterate over the string putting
429   // non 'a' characters at the front of the string during each iteration
430   // and continue to verify that strchr can find the first occurrence
431   // properly. The idea is to cover all possible alignments of the location
432   // of the first occurrence of the 'a' character and which includes
433   // other 'a' characters close by.
434   for (size_t i = 0; i < sizeof(str) - 1; i++) {
435     EXPECT_EQ(&str[i], strchr(str, 'a'));
436     str[i] = 'b';
437   }
438 }
439 
TEST(STRING_TEST,strchr)440 TEST(STRING_TEST, strchr) {
441   int seek_char = 'R';
442 
443   StringTestState<char> state(SMALL);
444   for (size_t i = 1; i < state.n; i++) {
445     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
446       if (~seek_char > 0) {
447         memset(state.ptr1, ~seek_char, state.len[i]);
448       } else {
449         memset(state.ptr1, '\1', state.len[i]);
450       }
451       state.ptr1[state.len[i] - 1] = '\0';
452 
453       size_t pos = random() % state.MAX_LEN;
454       char* expected;
455       if (pos >= state.len[i] - 1) {
456         if (seek_char == 0) {
457           expected = state.ptr1 + state.len[i] - 1;
458         } else {
459           expected = nullptr;
460         }
461       } else {
462         state.ptr1[pos] = seek_char;
463         expected = state.ptr1 + pos;
464       }
465 
466       ASSERT_TRUE(strchr(state.ptr1, seek_char) == expected);
467     }
468   }
469 }
470 
TEST(STRING_TEST,strchrnul)471 TEST(STRING_TEST, strchrnul) {
472   const char* s = "01234222";
473   EXPECT_TRUE(strchrnul(s, '2') == &s[2]);
474   EXPECT_TRUE(strchrnul(s, '8') == (s + strlen(s)));
475   EXPECT_TRUE(strchrnul(s, '\0') == (s + strlen(s)));
476 }
477 
TEST(STRING_TEST,strcmp)478 TEST(STRING_TEST, strcmp) {
479   StringTestState<char> state(SMALL);
480   for (size_t i = 1; i < state.n; i++) {
481     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
482       memset(state.ptr1, 'v', state.MAX_LEN);
483       memset(state.ptr2, 'n', state.MAX_LEN);
484       state.ptr1[state.len[i] - 1] = '\0';
485       state.ptr2[state.len[i] - 1] = '\0';
486 
487       size_t pos = 1 + (random() % (state.MAX_LEN - 1));
488       int actual;
489       int expected;
490       if (pos >= state.len[i] - 1) {
491         memcpy(state.ptr1, state.ptr2, state.len[i]);
492         expected = 0;
493         actual = strcmp(state.ptr1, state.ptr2);
494       } else {
495         memcpy(state.ptr1, state.ptr2, pos);
496         if (state.ptr1[pos] > state.ptr2[pos]) {
497           expected = 1;
498         } else if (state.ptr1[pos] == state.ptr2[pos]) {
499           state.ptr1[pos + 1] = '\0';
500           state.ptr2[pos + 1] = '\0';
501           expected = 0;
502         } else {
503           expected = -1;
504         }
505         actual = strcmp(state.ptr1, state.ptr2);
506       }
507 
508       ASSERT_EQ(expected, signum(actual));
509     }
510   }
511 }
512 
TEST(STRING_TEST,stpcpy)513 TEST(STRING_TEST, stpcpy) {
514   StringTestState<char> state(SMALL);
515   for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
516     size_t pos = random() % state.MAX_LEN;
517 
518     memset(state.ptr1, '\2', pos);
519     state.ptr1[pos] = '\0';
520     state.ptr1[state.MAX_LEN - 1] = '\0';
521 
522     memcpy(state.ptr, state.ptr1, state.MAX_LEN);
523 
524     memset(state.ptr2, '\1', state.MAX_LEN);
525     state.ptr2[state.MAX_LEN - 1] = '\0';
526 
527     memset(state.ptr + state.MAX_LEN, '\1', state.MAX_LEN);
528     memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1);
529     state.ptr[2 * state.MAX_LEN - 1] = '\0';
530 
531     ASSERT_TRUE(stpcpy(state.ptr2, state.ptr1) == state.ptr2 + strlen(state.ptr1));
532     ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN)) != 0 ||
533                  (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0));
534   }
535 }
536 
TEST(STRING_TEST,strcpy)537 TEST(STRING_TEST, strcpy) {
538   StringTestState<char> state(SMALL);
539   for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
540     size_t pos = random() % state.MAX_LEN;
541 
542     memset(state.ptr1, '\2', pos);
543     state.ptr1[pos] = '\0';
544     state.ptr1[state.MAX_LEN - 1] = '\0';
545 
546     memcpy(state.ptr, state.ptr1, state.MAX_LEN);
547 
548     memset(state.ptr2, '\1', state.MAX_LEN);
549     state.ptr2[state.MAX_LEN - 1] = '\0';
550 
551     memset(state.ptr + state.MAX_LEN, '\1', state.MAX_LEN);
552     memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1);
553     state.ptr[2 * state.MAX_LEN - 1] = '\0';
554 
555     ASSERT_TRUE(strcpy(state.ptr2, state.ptr1) == state.ptr2);
556     ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN)) != 0 ||
557                  (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0));
558   }
559 }
560 
TEST(STRING_TEST,strlcat)561 TEST(STRING_TEST, strlcat) {
562 #if defined(STRLCAT_SUPPORTED)
563   StringTestState<char> state(SMALL);
564   for (size_t i = 0; i < state.n; i++) {
565     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
566       memset(state.ptr2, '\2', state.MAX_LEN + state.len[i]);
567       state.ptr2[state.MAX_LEN - 1] = '\0';
568       memcpy(state.ptr, state.ptr2, state.MAX_LEN + state.len[i]);
569 
570       size_t pos = random() % state.MAX_LEN;
571       memset(state.ptr1, '\3', pos);
572       state.ptr1[pos] = '\0';
573       if (pos < state.len[i]) {
574         memcpy(state.ptr + state.MAX_LEN - 1, state.ptr1, pos + 1);
575       } else {
576         memcpy(state.ptr + state.MAX_LEN - 1, state.ptr1, state.len[i]);
577         state.ptr[state.MAX_LEN + state.len[i] - 1] = '\0';
578       }
579 
580       strlcat(state.ptr2, state.ptr1, state.MAX_LEN + state.len[i]);
581 
582       ASSERT_TRUE(memcmp(state.ptr, state.ptr2, state.MAX_LEN + state.len[i]) == 0);
583     }
584   }
585 #else
586   GTEST_SKIP() << "strlcat not available";
587 #endif
588 }
589 
TEST(STRING_TEST,strlcpy)590 TEST(STRING_TEST, strlcpy) {
591 #if defined(STRLCPY_SUPPORTED)
592   StringTestState<char> state(SMALL);
593   for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
594     int rand = 'O';
595     memset(state.ptr1, rand, state.MAX_LEN);
596 
597     size_t pos = random() % state.MAX_LEN;
598     if (pos < state.MAX_LEN) {
599       state.ptr1[pos] = '\0';
600     }
601     memcpy(state.ptr, state.ptr1, state.MAX_LEN);
602 
603     memset(state.ptr2, 'I', state.MAX_LEN);
604     memcpy(state.ptr + state.MAX_LEN, state.ptr2, state.MAX_LEN);
605 
606     if (pos > state.MAX_LEN - 1) {
607       memcpy(state.ptr + state.MAX_LEN, state.ptr1, state.MAX_LEN);
608       state.ptr[2 * state.MAX_LEN - 1] = '\0';
609     } else {
610       memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1);
611     }
612 
613     ASSERT_EQ(strlcpy(state.ptr2, state.ptr1, state.MAX_LEN), strlen(state.ptr1));
614     ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN) != 0) ||
615                  (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0));
616   }
617 #else
618   GTEST_SKIP() << "strlcpy not available";
619 #endif
620 }
621 
TEST(STRING_TEST,strncat)622 TEST(STRING_TEST, strncat) {
623   StringTestState<char> state(SMALL);
624   for (size_t i = 1; i < state.n; i++) {
625     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
626       memset(state.ptr2, '\2', state.MAX_LEN);
627       state.ptr2[state.MAX_LEN - 1] = '\0';
628       memcpy(state.ptr, state.ptr2, 2 * state.MAX_LEN);
629 
630       memset(state.ptr1, 'I', state.len[i]);
631       state.ptr1[random() % state.len[i]] = '\0';
632       state.ptr1[state.len[i] - 1] = '\0';
633 
634       size_t pos = strlen(state.ptr1);
635 
636       size_t actual = random() % state.len[i];
637       strncpy(state.ptr + state.MAX_LEN - 1, state.ptr1, std::min(actual, pos));
638       state.ptr[state.MAX_LEN + std::min(actual, pos) - 1] = '\0';
639 
640       ASSERT_TRUE(strncat(state.ptr2, state.ptr1, actual) == state.ptr2);
641       ASSERT_EQ(memcmp(state.ptr, state.ptr2, 2 * state.MAX_LEN), 0);
642     }
643   }
644 }
645 
TEST(STRING_TEST,strncmp)646 TEST(STRING_TEST, strncmp) {
647   StringTestState<char> state(SMALL);
648   for (size_t i = 1; i < state.n; i++) {
649     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
650       memset(state.ptr1, 'v', state.MAX_LEN);
651       memset(state.ptr2, 'n', state.MAX_LEN);
652       state.ptr1[state.len[i] - 1] = '\0';
653       state.ptr2[state.len[i] - 1] = '\0';
654 
655       size_t pos = 1 + (random() % (state.MAX_LEN - 1));
656       int actual;
657       int expected;
658       if (pos >= state.len[i] - 1) {
659         memcpy(state.ptr1, state.ptr2, state.len[i]);
660         expected = 0;
661         actual = strncmp(state.ptr1, state.ptr2, state.len[i]);
662       } else {
663         memcpy(state.ptr1, state.ptr2, pos);
664         if (state.ptr1[pos] > state.ptr2[pos]) {
665           expected = 1;
666         } else if (state.ptr1[pos] == state.ptr2[pos]) {
667           state.ptr1[pos + 1] = '\0';
668           state.ptr2[pos + 1] = '\0';
669           expected = 0;
670         } else {
671           expected = -1;
672         }
673         actual = strncmp(state.ptr1, state.ptr2, state.len[i]);
674       }
675 
676       ASSERT_EQ(expected, signum(actual));
677     }
678   }
679 }
680 
TEST(STRING_TEST,stpncpy)681 TEST(STRING_TEST, stpncpy) {
682   StringTestState<char> state(SMALL);
683   for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
684     memset(state.ptr1, 'J', state.MAX_LEN);
685     // Choose a random size for our src buffer.
686     size_t ptr1_len = random() % state.MAX_LEN;
687     state.ptr1[ptr1_len] = '\0';
688     // Copy ptr1 into ptr, used to verify that ptr1 does not get modified.
689     memcpy(state.ptr, state.ptr1, state.MAX_LEN);
690     // Init ptr2 to a set value.
691     memset(state.ptr2, '\1', state.MAX_LEN);
692 
693     // Choose a random amount of data to copy.
694     size_t copy_len = random() % state.MAX_LEN;
695 
696     // Set the second half of ptr to the expected pattern in ptr2.
697     memset(state.ptr + state.MAX_LEN, '\1', state.MAX_LEN);
698     memcpy(state.ptr + state.MAX_LEN, state.ptr1, copy_len);
699     size_t expected_end;
700     if (copy_len > ptr1_len) {
701       memset(state.ptr + state.MAX_LEN + ptr1_len, '\0', copy_len - ptr1_len);
702       expected_end = ptr1_len;
703     } else {
704       expected_end = copy_len;
705     }
706 
707     ASSERT_EQ(state.ptr2 + expected_end, stpncpy(state.ptr2, state.ptr1, copy_len));
708 
709     // Verify ptr1 was not modified.
710     ASSERT_EQ(0, memcmp(state.ptr1, state.ptr, state.MAX_LEN));
711     // Verify ptr2 contains the expected data.
712     ASSERT_EQ(0, memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN));
713   }
714 }
715 
TEST(STRING_TEST,strncpy)716 TEST(STRING_TEST, strncpy) {
717   StringTestState<char> state(SMALL);
718   for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
719     // Choose a random value to fill the string, except \0 (string terminator),
720     // or \1 (guarantees it's different from anything in ptr2).
721     memset(state.ptr1, 'K', state.MAX_LEN);
722     // Choose a random size for our src buffer.
723     size_t ptr1_len = random() % state.MAX_LEN;
724     state.ptr1[ptr1_len] = '\0';
725     // Copy ptr1 into ptr, used to verify that ptr1 does not get modified.
726     memcpy(state.ptr, state.ptr1, state.MAX_LEN);
727     // Init ptr2 to a set value.
728     memset(state.ptr2, '\1', state.MAX_LEN);
729 
730     // Choose a random amount of data to copy.
731     size_t copy_len = random() % state.MAX_LEN;
732 
733     // Set the second half of ptr to the expected pattern in ptr2.
734     memset(state.ptr + state.MAX_LEN, '\1', state.MAX_LEN);
735     memcpy(state.ptr + state.MAX_LEN, state.ptr1, copy_len);
736     size_t expected_end;
737     if (copy_len > ptr1_len) {
738       memset(state.ptr + state.MAX_LEN + ptr1_len, '\0', copy_len - ptr1_len);
739       expected_end = ptr1_len;
740     } else {
741       expected_end = copy_len;
742     }
743 
744     ASSERT_EQ(state.ptr2 + expected_end, stpncpy(state.ptr2, state.ptr1, copy_len));
745 
746     // Verify ptr1 was not modified.
747     ASSERT_EQ(0, memcmp(state.ptr1, state.ptr, state.MAX_LEN));
748     // Verify ptr2 contains the expected data.
749     ASSERT_EQ(0, memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN));
750   }
751 }
752 
TEST(STRING_TEST,strrchr)753 TEST(STRING_TEST, strrchr) {
754   int seek_char = 'M';
755   StringTestState<char> state(SMALL);
756   for (size_t i = 1; i < state.n; i++) {
757     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
758       if (~seek_char > 0) {
759         memset(state.ptr1, ~seek_char, state.len[i]);
760       } else {
761         memset(state.ptr1, '\1', state.len[i]);
762       }
763       state.ptr1[state.len[i] - 1] = '\0';
764 
765       size_t pos = random() % state.MAX_LEN;
766       char* expected;
767       if (pos >= state.len[i] - 1) {
768         if (seek_char == 0) {
769           expected = state.ptr1 + state.len[i] - 1;
770         } else {
771           expected = nullptr;
772         }
773       } else {
774         state.ptr1[pos] = seek_char;
775         expected = state.ptr1 + pos;
776       }
777 
778       ASSERT_TRUE(strrchr(state.ptr1, seek_char) == expected);
779     }
780   }
781 }
782 
TEST(STRING_TEST,memchr)783 TEST(STRING_TEST, memchr) {
784   int seek_char = 'N';
785   StringTestState<char> state(SMALL);
786   for (size_t i = 0; i < state.n; i++) {
787     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
788       memset(state.ptr1, ~seek_char, state.len[i]);
789 
790       size_t pos = random() % state.MAX_LEN;
791       char* expected;
792       if (pos >= state.len[i]) {
793         expected = nullptr;
794       } else {
795         state.ptr1[pos] = seek_char;
796         expected = state.ptr1 + pos;
797       }
798 
799       ASSERT_TRUE(memchr(state.ptr1, seek_char, state.len[i]) == expected);
800     }
801   }
802 }
803 
TEST(STRING_TEST,memchr_zero)804 TEST(STRING_TEST, memchr_zero) {
805   uint8_t* buffer;
806   ASSERT_EQ(0, posix_memalign(reinterpret_cast<void**>(&buffer), 64, 64));
807   memset(buffer, 10, 64);
808   ASSERT_TRUE(nullptr == memchr(buffer, 5, 0));
809   ASSERT_TRUE(nullptr == memchr(buffer, 10, 0));
810 }
811 
TEST(STRING_TEST,memrchr)812 TEST(STRING_TEST, memrchr) {
813   int seek_char = 'P';
814   StringTestState<char> state(SMALL);
815   for (size_t i = 0; i < state.n; i++) {
816     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
817       memset(state.ptr1, ~seek_char, state.len[i]);
818 
819       size_t pos = random() % state.MAX_LEN;
820       char* expected;
821       if (pos >= state.len[i]) {
822         expected = nullptr;
823       } else {
824         state.ptr1[pos] = seek_char;
825         expected = state.ptr1 + pos;
826       }
827 
828       ASSERT_TRUE(memrchr(state.ptr1, seek_char, state.len[i]) == expected);
829     }
830   }
831 }
832 
TEST(STRING_TEST,memcmp)833 TEST(STRING_TEST, memcmp) {
834   StringTestState<char> state(SMALL);
835   for (size_t i = 0; i < state.n; i++) {
836     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
837       int c1 = 'A';
838       int c2 = 'N';
839       memset(state.ptr1, c1, state.MAX_LEN);
840       memset(state.ptr2, c1, state.MAX_LEN);
841 
842       int pos = (state.len[i] == 0) ? 0 : (random() % state.len[i]);
843       state.ptr2[pos] = c2;
844 
845       int expected = (static_cast<int>(c1) - static_cast<int>(c2));
846       int actual = memcmp(state.ptr1, state.ptr2, state.MAX_LEN);
847 
848       ASSERT_EQ(signum(expected), signum(actual));
849     }
850   }
851 }
852 
TEST(STRING_TEST,wmemcmp)853 TEST(STRING_TEST, wmemcmp) {
854   StringTestState<wchar_t> state(SMALL);
855 
856   for (size_t i = 0; i < state.n; i++) {
857     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
858       long long mask = ((long long) 1 << 8 * sizeof(wchar_t)) - 1;
859       int c1 = rand() & mask;
860       int c2 = rand() & mask;
861       wmemset(state.ptr1, c1, state.MAX_LEN);
862       wmemset(state.ptr2, c1, state.MAX_LEN);
863 
864       int pos = (state.len[i] == 0) ? 0 : (random() % state.len[i]);
865       state.ptr2[pos] = c2;
866 
867       int expected = (static_cast<int>(c1) - static_cast<int>(c2));
868       int actual = wmemcmp(state.ptr1, state.ptr2, (size_t) state.MAX_LEN);
869 
870       ASSERT_EQ(signum(expected), signum(actual));
871     }
872   }
873 }
874 
TEST(STRING_TEST,memcpy)875 TEST(STRING_TEST, memcpy) {
876   StringTestState<char> state(LARGE);
877   int rand = 4;
878   for (size_t i = 0; i < state.n - 1; i++) {
879     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
880       size_t pos = random() % (state.MAX_LEN - state.len[i]);
881 
882       memset(state.ptr1, rand, state.len[i]);
883       memset(state.ptr1 + state.len[i], ~rand, state.MAX_LEN - state.len[i]);
884 
885       memset(state.ptr2, rand, state.len[i]);
886       memset(state.ptr2 + state.len[i], ~rand, state.MAX_LEN - state.len[i]);
887       memset(state.ptr2 + pos, '\0', state.len[i]);
888 
889       ASSERT_FALSE(memcpy(state.ptr2 + pos, state.ptr1 + pos, state.len[i]) != state.ptr2 + pos);
890       ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN));
891     }
892   }
893 }
894 
TEST(STRING_TEST,memset)895 TEST(STRING_TEST, memset) {
896   StringTestState<char> state(LARGE);
897   char ch = 'P';
898   for (size_t i = 0; i < state.n - 1; i++) {
899     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
900       memset(state.ptr1, ~ch, state.MAX_LEN);
901       memcpy(state.ptr2, state.ptr1, state.MAX_LEN);
902 
903       size_t pos = random () % (state.MAX_LEN - state.len[i]);
904       for (size_t k = pos; k < pos + state.len[i]; k++) {
905         state.ptr1[k] = ch;
906       }
907 
908       ASSERT_TRUE(memset(state.ptr2 + pos, ch, state.len[i]) == state.ptr2 + pos);
909 
910       ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN));
911     }
912   }
913 }
914 
TEST(STRING_TEST,memmove)915 TEST(STRING_TEST, memmove) {
916   StringTestState<char> state(LARGE);
917   for (size_t i = 0; i < state.n - 1; i++) {
918     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
919       memset(state.ptr1, 'Q', 2 * state.MAX_LEN);
920 
921       size_t pos = random() % (state.MAX_LEN - state.len[i]);
922 
923       memset(state.ptr1, 'R', state.len[i]);
924       memcpy(state.ptr2, state.ptr1, 2 * state.MAX_LEN);
925       memcpy(state.ptr, state.ptr1, state.len[i]);
926       memcpy(state.ptr1 + pos, state.ptr, state.len[i]);
927 
928       ASSERT_TRUE(memmove(state.ptr2 + pos, state.ptr2, state.len[i]) == state.ptr2 + pos);
929       ASSERT_EQ(0, memcmp(state.ptr2, state.ptr1, 2 * state.MAX_LEN));
930     }
931   }
932 }
933 
TEST(STRING_TEST,memmove_cache_size)934 TEST(STRING_TEST, memmove_cache_size) {
935   size_t len = 600000;
936   int max_alignment = 31;
937   int alignments[] = {0, 5, 11, 29, 30};
938   char* ptr = reinterpret_cast<char*>(malloc(sizeof(char) * len));
939   char* ptr1 = reinterpret_cast<char*>(malloc(2 * sizeof(char) * len));
940   char* glob_ptr2 = reinterpret_cast<char*>(malloc(2 * sizeof(char) * len + max_alignment));
941   size_t pos = 64;
942 
943   ASSERT_TRUE(ptr != nullptr);
944   ASSERT_TRUE(ptr1 != nullptr);
945   ASSERT_TRUE(glob_ptr2 != nullptr);
946 
947   for (int i = 0; i < 5; i++) {
948     char* ptr2 = glob_ptr2 + alignments[i];
949     memset(ptr1, 'S', 2 * len);
950     memset(ptr1, 'T', len);
951     memcpy(ptr2, ptr1, 2 * len);
952     memcpy(ptr, ptr1, len);
953     memcpy(ptr1 + pos, ptr, len);
954 
955     ASSERT_TRUE(memmove(ptr2 + pos, ptr, len) == ptr2 + pos);
956     ASSERT_EQ(0, memcmp(ptr2, ptr1, 2 * len));
957   }
958   free(ptr);
959   free(ptr1);
960   free(glob_ptr2);
961 }
962 
verify_memmove(char * src_copy,char * dst,char * src,size_t size)963 static void verify_memmove(char* src_copy, char* dst, char* src, size_t size) {
964   memset(dst, 0, size);
965   memcpy(src, src_copy, size);
966   ASSERT_EQ(dst, memmove(dst, src, size));
967   ASSERT_EQ(0, memcmp(dst, src_copy, size));
968 }
969 
970 #define MEMMOVE_DATA_SIZE (1024*1024*3)
971 
TEST(STRING_TEST,memmove_check)972 TEST(STRING_TEST, memmove_check) {
973   char* buffer = reinterpret_cast<char*>(malloc(MEMMOVE_DATA_SIZE));
974   ASSERT_TRUE(buffer != nullptr);
975 
976   char* src_data = reinterpret_cast<char*>(malloc(MEMMOVE_DATA_SIZE));
977   ASSERT_TRUE(src_data != nullptr);
978   // Initialize to a known pattern to copy into src for each test and
979   // to compare dst against.
980   for (size_t i = 0; i < MEMMOVE_DATA_SIZE; i++) {
981     src_data[i] = (i + 1) % 255;
982   }
983 
984   // Check all different dst offsets between 0 and 127 inclusive.
985   char* src = buffer;
986   for (size_t i = 0; i < 127; i++) {
987     char* dst = buffer + 256 + i;
988     // Small copy.
989     verify_memmove(src_data, dst, src, 1024);
990 
991     // Medium copy.
992     verify_memmove(src_data, dst, src, 64 * 1024);
993 
994     // Medium copy.
995     verify_memmove(src_data, dst, src, 1024 * 1024 + 128 * 1024);
996   }
997 
998   // Check all leftover size offsets between 1 and 127 inclusive.
999   char* dst = buffer + 256;
1000   src = buffer;
1001   for (size_t size = 1; size < 127; size++) {
1002     // Small copy.
1003     verify_memmove(src_data, dst, src, 1024);
1004 
1005     // Medium copy.
1006     verify_memmove(src_data, dst, src, 64 * 1024);
1007 
1008     // Large copy.
1009     verify_memmove(src_data, dst, src, 1024 * 1024 + 128 * 1024);
1010   }
1011 }
1012 
TEST(STRING_TEST,bcopy)1013 TEST(STRING_TEST, bcopy) {
1014   StringTestState<char> state(LARGE);
1015   for (size_t i = 0; i < state.n; i++) {
1016     for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
1017       memset(state.ptr1, '4', state.MAX_LEN);
1018       memset(state.ptr1 + state.MAX_LEN, 'a', state.MAX_LEN);
1019       memcpy(state.ptr2, state.ptr1, 2 * state.MAX_LEN);
1020 
1021       size_t start = random() % (2 * state.MAX_LEN - state.len[i]);
1022       memcpy(state.ptr2 + start, state.ptr1, state.len[i]);
1023 
1024       bcopy(state.ptr1, state.ptr1 + start, state.len[i]);
1025       ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, 2 * state.MAX_LEN));
1026     }
1027   }
1028 }
1029 
TEST(STRING_TEST,bzero)1030 TEST(STRING_TEST, bzero) {
1031   StringTestState<char> state(LARGE);
1032   for (state.BeginIterations(); state.HasNextIteration(); state.NextIteration()) {
1033     memset(state.ptr1, 'R', state.MAX_LEN);
1034 
1035     size_t start = random() % state.MAX_LEN;
1036     size_t end = start + random() % (state.MAX_LEN - start);
1037 
1038     memcpy(state.ptr2, state.ptr1, start);
1039     memset(state.ptr2 + start, '\0', end - start);
1040     memcpy(state.ptr2 + end, state.ptr1 + end, state.MAX_LEN - end);
1041 
1042     bzero(state.ptr1 + start, end - start);
1043 
1044     ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN));
1045   }
1046 }
1047 
DoMemcpyTest(uint8_t * src,uint8_t * dst,size_t len)1048 static void DoMemcpyTest(uint8_t* src, uint8_t* dst, size_t len) {
1049   memset(src, (len % 255) + 1, len);
1050   memset(dst, 0, len);
1051 
1052   ASSERT_EQ(dst, memcpy(dst, src, len));
1053   ASSERT_TRUE(memcmp(src, dst, len) == 0);
1054 }
1055 
TEST(STRING_TEST,memcpy_align)1056 TEST(STRING_TEST, memcpy_align) {
1057   RunSrcDstBufferAlignTest(LARGE, DoMemcpyTest);
1058 }
1059 
TEST(STRING_TEST,memcpy_overread)1060 TEST(STRING_TEST, memcpy_overread) {
1061   RunSrcDstBufferOverreadTest(DoMemcpyTest);
1062 }
1063 
DoMemmoveTest(uint8_t * src,uint8_t * dst,size_t len)1064 static void DoMemmoveTest(uint8_t* src, uint8_t* dst, size_t len) {
1065   memset(src, (len % 255) + 1, len);
1066   memset(dst, 0, len);
1067 
1068   ASSERT_EQ(dst, memmove(dst, src, len));
1069   ASSERT_TRUE(memcmp(src, dst, len) == 0);
1070 }
1071 
TEST(STRING_TEST,memmove_align)1072 TEST(STRING_TEST, memmove_align) {
1073   RunSrcDstBufferAlignTest(LARGE, DoMemmoveTest);
1074 }
1075 
TEST(STRING_TEST,memmove_overread)1076 TEST(STRING_TEST, memmove_overread) {
1077   RunSrcDstBufferOverreadTest(DoMemmoveTest);
1078 }
1079 
DoMemsetTest(uint8_t * buf,size_t len)1080 static void DoMemsetTest(uint8_t* buf, size_t len) {
1081   for (size_t i = 0; i < len; i++) {
1082     buf[i] = 0;
1083   }
1084   int value = (len % 255) + 1;
1085   ASSERT_EQ(buf, memset(buf, value, len));
1086   for (size_t i = 0; i < len; i++) {
1087     ASSERT_EQ(value, buf[i]);
1088   }
1089 }
1090 
TEST(STRING_TEST,memset_align)1091 TEST(STRING_TEST, memset_align) {
1092   RunSingleBufferAlignTest(LARGE, DoMemsetTest);
1093 }
1094 
DoStrlenTest(uint8_t * buf,size_t len)1095 static void DoStrlenTest(uint8_t* buf, size_t len) {
1096   if (len >= 1) {
1097     memset(buf, (32 + (len % 96)), len - 1);
1098     buf[len-1] = '\0';
1099     ASSERT_EQ(len-1, strlen(reinterpret_cast<char*>(buf)));
1100   }
1101 }
1102 
TEST(STRING_TEST,strlen_align)1103 TEST(STRING_TEST, strlen_align) {
1104   RunSingleBufferAlignTest(LARGE, DoStrlenTest);
1105 }
1106 
TEST(STRING_TEST,strlen_overread)1107 TEST(STRING_TEST, strlen_overread) {
1108   RunSingleBufferOverreadTest(DoStrlenTest);
1109 }
1110 
DoStrcpyTest(uint8_t * src,uint8_t * dst,size_t len)1111 static void DoStrcpyTest(uint8_t* src, uint8_t* dst, size_t len) {
1112   if (len >= 1) {
1113     memset(src, (32 + (len % 96)), len - 1);
1114     src[len-1] = '\0';
1115     memset(dst, 0, len);
1116     ASSERT_EQ(dst, reinterpret_cast<uint8_t*>(strcpy(reinterpret_cast<char*>(dst),
1117                                                      reinterpret_cast<char*>(src))));
1118     ASSERT_TRUE(memcmp(src, dst, len) == 0);
1119   }
1120 }
1121 
TEST(STRING_TEST,strcpy_align)1122 TEST(STRING_TEST, strcpy_align) {
1123   RunSrcDstBufferAlignTest(LARGE, DoStrcpyTest);
1124 }
1125 
TEST(STRING_TEST,strcpy_overread)1126 TEST(STRING_TEST, strcpy_overread) {
1127   RunSrcDstBufferOverreadTest(DoStrcpyTest);
1128 }
1129 
1130 #if defined(STRLCPY_SUPPORTED)
DoStrlcpyTest(uint8_t * src,uint8_t * dst,size_t len)1131 static void DoStrlcpyTest(uint8_t* src, uint8_t* dst, size_t len) {
1132   if (len >= 1) {
1133     memset(src, (32 + (len % 96)), len - 1);
1134     src[len-1] = '\0';
1135     memset(dst, 0, len);
1136     ASSERT_EQ(len-1, strlcpy(reinterpret_cast<char*>(dst),
1137                              reinterpret_cast<char*>(src), len));
1138     ASSERT_TRUE(memcmp(src, dst, len) == 0);
1139   }
1140 }
1141 #endif
1142 
TEST(STRING_TEST,strlcpy_align)1143 TEST(STRING_TEST, strlcpy_align) {
1144 #if defined(STRLCPY_SUPPORTED)
1145   RunSrcDstBufferAlignTest(LARGE, DoStrlcpyTest);
1146 #else
1147   GTEST_SKIP() << "strlcpy not available";
1148 #endif
1149 }
1150 
TEST(STRING_TEST,strlcpy_overread)1151 TEST(STRING_TEST, strlcpy_overread) {
1152 #if defined(STRLCPY_SUPPORTED)
1153   RunSrcDstBufferOverreadTest(DoStrlcpyTest);
1154 #else
1155   GTEST_SKIP() << "strlcpy not available";
1156 #endif
1157 }
1158 
1159 
DoStpcpyTest(uint8_t * src,uint8_t * dst,size_t len)1160 static void DoStpcpyTest(uint8_t* src, uint8_t* dst, size_t len) {
1161   if (len >= 1) {
1162     memset(src, (32 + (len % 96)), len - 1);
1163     src[len-1] = '\0';
1164     memset(dst, 0, len);
1165     ASSERT_EQ(dst+len-1, reinterpret_cast<uint8_t*>(stpcpy(reinterpret_cast<char*>(dst),
1166                                                            reinterpret_cast<char*>(src))));
1167     ASSERT_TRUE(memcmp(src, dst, len) == 0);
1168   }
1169 }
1170 
TEST(STRING_TEST,stpcpy_align)1171 TEST(STRING_TEST, stpcpy_align) {
1172   RunSrcDstBufferAlignTest(LARGE, DoStpcpyTest);
1173 }
1174 
TEST(STRING_TEST,stpcpy_overread)1175 TEST(STRING_TEST, stpcpy_overread) {
1176   RunSrcDstBufferOverreadTest(DoStpcpyTest);
1177 }
1178 
1179 // Use our own incrementer to cut down on the total number of calls.
LargeSetIncrement(size_t len)1180 static size_t LargeSetIncrement(size_t len) {
1181   if (len >= 4096) {
1182     return 4096;
1183   } else if (len >= 1024) {
1184     return 1024;
1185   } else if (len >= 256) {
1186     return 256;
1187   }
1188   return 1;
1189 }
1190 
1191 #define STRCAT_DST_LEN  64
1192 
DoStrcatTest(uint8_t * src,uint8_t * dst,size_t len)1193 static void DoStrcatTest(uint8_t* src, uint8_t* dst, size_t len) {
1194   if (len >= 1) {
1195     int value = 32 + (len % 96);
1196     memset(src, value, len - 1);
1197     src[len-1] = '\0';
1198 
1199     if (len >= STRCAT_DST_LEN) {
1200       // Create a small buffer for doing quick compares in each loop.
1201       uint8_t cmp_buf[STRCAT_DST_LEN];
1202       // Make sure dst string contains a different value then the src string.
1203       int value2 = 32 + (value + 2) % 96;
1204       memset(cmp_buf, value2, sizeof(cmp_buf));
1205 
1206       for (size_t i = 1; i <= STRCAT_DST_LEN;) {
1207         memset(dst, value2, i-1);
1208         memset(dst+i-1, 0, len-i);
1209         src[len-i] = '\0';
1210         ASSERT_EQ(dst, reinterpret_cast<uint8_t*>(strcat(reinterpret_cast<char*>(dst),
1211                                                          reinterpret_cast<char*>(src))));
1212         ASSERT_TRUE(memcmp(dst, cmp_buf, i-1) == 0);
1213         ASSERT_TRUE(memcmp(src, dst+i-1, len-i+1) == 0);
1214         // This is an expensive loop, so don't loop through every value,
1215         // get to a certain size and then start doubling.
1216         if (i < 16) {
1217           i++;
1218         } else {
1219           i <<= 1;
1220         }
1221       }
1222     } else {
1223       dst[0] = '\0';
1224       ASSERT_EQ(dst, reinterpret_cast<uint8_t*>(strcat(reinterpret_cast<char*>(dst),
1225                                                        reinterpret_cast<char*>(src))));
1226       ASSERT_TRUE(memcmp(src, dst, len) == 0);
1227     }
1228   }
1229 }
1230 
TEST(STRING_TEST,strcat_align)1231 TEST(STRING_TEST, strcat_align) {
1232   RunSrcDstBufferAlignTest(MEDIUM, DoStrcatTest, LargeSetIncrement);
1233 }
1234 
TEST(STRING_TEST,strcat_overread)1235 TEST(STRING_TEST, strcat_overread) {
1236   RunSrcDstBufferOverreadTest(DoStrcatTest);
1237 }
1238 
1239 #if defined(STRLCAT_SUPPORTED)
DoStrlcatTest(uint8_t * src,uint8_t * dst,size_t len)1240 static void DoStrlcatTest(uint8_t* src, uint8_t* dst, size_t len) {
1241   if (len >= 1) {
1242     int value = 32 + (len % 96);
1243     memset(src, value, len - 1);
1244     src[len-1] = '\0';
1245 
1246     if (len >= STRCAT_DST_LEN) {
1247       // Create a small buffer for doing quick compares in each loop.
1248       uint8_t cmp_buf[STRCAT_DST_LEN];
1249       // Make sure dst string contains a different value then the src string.
1250       int value2 = 32 + (value + 2) % 96;
1251       memset(cmp_buf, value2, sizeof(cmp_buf));
1252 
1253       for (size_t i = 1; i <= STRCAT_DST_LEN;) {
1254         memset(dst, value2, i-1);
1255         memset(dst+i-1, 0, len-i);
1256         src[len-i] = '\0';
1257         ASSERT_EQ(len-1, strlcat(reinterpret_cast<char*>(dst),
1258                                  reinterpret_cast<char*>(src), len));
1259         ASSERT_TRUE(memcmp(dst, cmp_buf, i-1) == 0);
1260         ASSERT_TRUE(memcmp(src, dst+i-1, len-i+1) == 0);
1261         // This is an expensive loop, so don't loop through every value,
1262         // get to a certain size and then start doubling.
1263         if (i < 16) {
1264           i++;
1265         } else {
1266           i <<= 1;
1267         }
1268       }
1269     } else {
1270       dst[0] = '\0';
1271       ASSERT_EQ(len-1, strlcat(reinterpret_cast<char*>(dst),
1272                                reinterpret_cast<char*>(src), len));
1273       ASSERT_TRUE(memcmp(src, dst, len) == 0);
1274     }
1275   }
1276 }
1277 #endif
1278 
TEST(STRING_TEST,strlcat_align)1279 TEST(STRING_TEST, strlcat_align) {
1280 #if defined(STRLCAT_SUPPORTED)
1281   RunSrcDstBufferAlignTest(MEDIUM, DoStrlcatTest, LargeSetIncrement);
1282 #else
1283   GTEST_SKIP() << "strlcat not available";
1284 #endif
1285 }
1286 
TEST(STRING_TEST,strlcat_overread)1287 TEST(STRING_TEST, strlcat_overread) {
1288 #if defined(STRLCAT_SUPPORTED)
1289   RunSrcDstBufferOverreadTest(DoStrlcatTest);
1290 #else
1291   GTEST_SKIP() << "strlcat not available";
1292 #endif
1293 }
1294 
DoStrcmpTest(uint8_t * buf1,uint8_t * buf2,size_t len)1295 static void DoStrcmpTest(uint8_t* buf1, uint8_t* buf2, size_t len) {
1296   if (len >= 1) {
1297     memset(buf1, (32 + (len % 96)), len - 1);
1298     buf1[len-1] = '\0';
1299     memset(buf2, (32 + (len % 96)), len - 1);
1300     buf2[len-1] = '\0';
1301     ASSERT_EQ(0, strcmp(reinterpret_cast<char*>(buf1),
1302                         reinterpret_cast<char*>(buf2)));
1303   }
1304 }
1305 
DoStrcmpFailTest(uint8_t * buf1,uint8_t * buf2,size_t len1,size_t len2)1306 static void DoStrcmpFailTest(uint8_t* buf1, uint8_t* buf2, size_t len1, size_t len2) {
1307   // Do string length differences.
1308   int c = (32 + (len1 % 96));
1309   memset(buf1, c, len1 - 1);
1310   buf1[len1-1] = '\0';
1311   memset(buf2, c, len2 - 1);
1312   buf2[len2-1] = '\0';
1313   ASSERT_NE(0, strcmp(reinterpret_cast<char*>(buf1),
1314                       reinterpret_cast<char*>(buf2)));
1315 
1316   // Do single character differences.
1317   size_t len;
1318   if (len1 > len2) {
1319     len = len2;
1320   } else {
1321     len = len1;
1322   }
1323   // Need at least a two character buffer to do this test.
1324   if (len > 1) {
1325     buf1[len-1] = '\0';
1326     buf2[len-1] = '\0';
1327     int diff_c = (c + 1) % 96;
1328 
1329     buf1[len-2] = diff_c;
1330     ASSERT_NE(0, strcmp(reinterpret_cast<char*>(buf1),
1331                         reinterpret_cast<char*>(buf2)));
1332 
1333     buf1[len-2] = c;
1334     buf2[len-2] = diff_c;
1335     ASSERT_NE(0, strcmp(reinterpret_cast<char*>(buf1),
1336                         reinterpret_cast<char*>(buf2)));
1337   }
1338 }
1339 
TEST(STRING_TEST,strcmp_align)1340 TEST(STRING_TEST, strcmp_align) {
1341   RunCmpBufferAlignTest(MEDIUM, DoStrcmpTest, DoStrcmpFailTest, LargeSetIncrement);
1342 }
1343 
TEST(STRING_TEST,strcmp_overread)1344 TEST(STRING_TEST, strcmp_overread) {
1345   RunCmpBufferOverreadTest(DoStrcmpTest, DoStrcmpFailTest);
1346 }
1347 
DoMemcmpTest(uint8_t * buf1,uint8_t * buf2,size_t len)1348 static void DoMemcmpTest(uint8_t* buf1, uint8_t* buf2, size_t len) {
1349   memset(buf1, len+1, len);
1350   memset(buf2, len+1, len);
1351   ASSERT_EQ(0, memcmp(buf1, buf2, len));
1352 }
1353 
DoMemcmpFailTest(uint8_t * buf1,uint8_t * buf2,size_t len1,size_t len2)1354 static void DoMemcmpFailTest(uint8_t* buf1, uint8_t* buf2, size_t len1, size_t len2) {
1355   size_t len;
1356   if (len1 > len2) {
1357     len = len2;
1358   } else {
1359     len = len1;
1360   }
1361 
1362   memset(buf1, len2+1, len);
1363   buf1[len-1] = len2;
1364   memset(buf2, len2+1, len);
1365   ASSERT_NE(0, memcmp(buf1, buf2, len));
1366 
1367   buf1[len-1] = len2+1;
1368   buf2[len-1] = len2;
1369   ASSERT_NE(0, memcmp(buf1, buf2, len));
1370 }
1371 
TEST(STRING_TEST,memcmp_align)1372 TEST(STRING_TEST, memcmp_align) {
1373   RunCmpBufferAlignTest(MEDIUM, DoMemcmpTest, DoMemcmpFailTest, LargeSetIncrement);
1374 }
1375 
TEST(STRING_TEST,memcmp_overread)1376 TEST(STRING_TEST, memcmp_overread) {
1377   RunCmpBufferOverreadTest(DoMemcmpTest, DoMemcmpFailTest);
1378 }
1379 
DoMemchrTest(uint8_t * buf,size_t len)1380 static void DoMemchrTest(uint8_t* buf, size_t len) {
1381   if (len >= 1) {
1382     int value = len % 128;
1383     int search_value = (len % 128) + 1;
1384     memset(buf, value, len);
1385     // The buffer does not contain the search value.
1386     ASSERT_EQ(nullptr, memchr(buf, search_value, len));
1387     if (len >= 2) {
1388       buf[0] = search_value;
1389       // The search value is the first element in the buffer.
1390       ASSERT_EQ(&buf[0], memchr(buf, search_value, len));
1391 
1392       buf[0] = value;
1393       buf[len - 1] = search_value;
1394       // The search value is the last element in the buffer.
1395       ASSERT_EQ(&buf[len - 1], memchr(buf, search_value, len));
1396     }
1397   }
1398 }
1399 
TEST(STRING_TEST,memchr_align)1400 TEST(STRING_TEST, memchr_align) {
1401   RunSingleBufferAlignTest(MEDIUM, DoMemchrTest);
1402 }
1403 
TEST(STRING_TEST,memchr_overread)1404 TEST(STRING_TEST, memchr_overread) {
1405   RunSingleBufferOverreadTest(DoMemchrTest);
1406 }
1407 
DoStrchrTest(uint8_t * buf,size_t len)1408 static void DoStrchrTest(uint8_t* buf, size_t len) {
1409   if (len >= 1) {
1410     char value = 32 + (len % 96);
1411     char search_value = 33 + (len % 96);
1412     memset(buf, value, len - 1);
1413     buf[len - 1] = '\0';
1414     // The buffer does not contain the search value.
1415     ASSERT_EQ(nullptr, strchr(reinterpret_cast<char*>(buf), search_value));
1416     // Search for the special '\0' character.
1417     ASSERT_EQ(reinterpret_cast<char*>(&buf[len - 1]), strchr(reinterpret_cast<char*>(buf), '\0'));
1418     if (len >= 2) {
1419       buf[0] = search_value;
1420       // The search value is the first element in the buffer.
1421       ASSERT_EQ(reinterpret_cast<char*>(&buf[0]), strchr(reinterpret_cast<char*>(buf),
1422                                                          search_value));
1423 
1424       buf[0] = value;
1425       buf[len - 2] = search_value;
1426       // The search value is the second to last element in the buffer.
1427       // The last element is the '\0' character.
1428       ASSERT_EQ(reinterpret_cast<char*>(&buf[len - 2]), strchr(reinterpret_cast<char*>(buf),
1429                                                                search_value));
1430     }
1431   }
1432 }
1433 
TEST(STRING_TEST,strchr_align)1434 TEST(STRING_TEST, strchr_align) {
1435   RunSingleBufferAlignTest(MEDIUM, DoStrchrTest);
1436 }
1437 
TEST(STRING_TEST,strchr_overread)1438 TEST(STRING_TEST, strchr_overread) {
1439   RunSingleBufferOverreadTest(DoStrchrTest);
1440 }
1441 
DoStrrchrTest(uint8_t * buf,size_t len)1442 static void DoStrrchrTest(uint8_t* buf, size_t len) {
1443   if (len >= 1) {
1444     char value = 32 + (len % 96);
1445     char search_value = 33 + (len % 96);
1446     memset(buf, value, len - 1);
1447     buf[len - 1] = '\0';
1448     // The buffer does not contain the search value.
1449     ASSERT_EQ(nullptr, strrchr(reinterpret_cast<char*>(buf), search_value));
1450     // Search for the special '\0' character.
1451     ASSERT_EQ(reinterpret_cast<char*>(&buf[len - 1]), strrchr(reinterpret_cast<char*>(buf), '\0'));
1452     if (len >= 2) {
1453       buf[0] = search_value;
1454       // The search value is the first element in the buffer.
1455       ASSERT_EQ(reinterpret_cast<char*>(&buf[0]), strrchr(reinterpret_cast<char*>(buf),
1456                                                           search_value));
1457 
1458       buf[0] = value;
1459       buf[len - 2] = search_value;
1460       // The search value is the second to last element in the buffer.
1461       // The last element is the '\0' character.
1462       ASSERT_EQ(reinterpret_cast<char*>(&buf[len - 2]), strrchr(reinterpret_cast<char*>(buf),
1463                                                                 search_value));
1464     }
1465   }
1466 }
1467 
TEST(STRING_TEST,strrchr_align)1468 TEST(STRING_TEST, strrchr_align) {
1469   RunSingleBufferAlignTest(MEDIUM, DoStrrchrTest);
1470 }
1471 
TEST(STRING_TEST,strrchr_overread)1472 TEST(STRING_TEST, strrchr_overread) {
1473   RunSingleBufferOverreadTest(DoStrrchrTest);
1474 }
1475 
TestBasename(const char * in,const char * expected_out)1476 static void TestBasename(const char* in, const char* expected_out) {
1477   errno = 0;
1478   const char* out = basename(in);
1479   ASSERT_STREQ(expected_out, out) << in;
1480   ASSERT_EQ(0, errno) << in;
1481 }
1482 
TEST(STRING_TEST,__gnu_basename)1483 TEST(STRING_TEST, __gnu_basename) {
1484   TestBasename("", "");
1485   TestBasename("/usr/lib", "lib");
1486   TestBasename("/usr/", "");
1487   TestBasename("usr", "usr");
1488   TestBasename("/", "");
1489   TestBasename(".", ".");
1490   TestBasename("..", "..");
1491   TestBasename("///", "");
1492   TestBasename("//usr//lib//", "");
1493 }
1494 
TEST(STRING_TEST,strnlen_147048)1495 TEST(STRING_TEST, strnlen_147048) {
1496   // https://code.google.com/p/android/issues/detail?id=147048
1497   char stack_src[64] = {0};
1498   EXPECT_EQ(0U, strnlen(stack_src, 1024*1024*1024));
1499   char* heap_src = new char[1];
1500   *heap_src = '\0';
1501   EXPECT_EQ(0U, strnlen(heap_src, 1024*1024*1024));
1502   delete[] heap_src;
1503 }
1504 
TEST(STRING_TEST,strnlen_74741)1505 TEST(STRING_TEST, strnlen_74741) {
1506   ASSERT_EQ(4U, strnlen("test", SIZE_MAX));
1507 }
1508 
TEST(STRING_TEST,mempcpy)1509 TEST(STRING_TEST, mempcpy) {
1510   char dst[6];
1511   ASSERT_EQ(&dst[4], reinterpret_cast<char*>(mempcpy(dst, "hello", 4)));
1512 }
1513 
1514 // clang depends on the fact that a memcpy where src and dst is the same
1515 // still operates correctly. This test verifies that this assumption
1516 // holds true.
1517 // See https://llvm.org/bugs/show_bug.cgi?id=11763 for more information.
1518 static std::vector<uint8_t> g_memcpy_same_buffer;
1519 
DoMemcpySameTest(uint8_t * buffer,size_t len)1520 static void DoMemcpySameTest(uint8_t* buffer, size_t len) {
1521   memcpy(buffer, g_memcpy_same_buffer.data(), len);
1522   ASSERT_EQ(buffer, memcpy(buffer, buffer, len));
1523   ASSERT_TRUE(memcmp(buffer, g_memcpy_same_buffer.data(), len) == 0);
1524 }
1525 
TEST(STRING_TEST,memcpy_src_dst_same)1526 TEST(STRING_TEST, memcpy_src_dst_same) {
1527   g_memcpy_same_buffer.resize(MEDIUM);
1528   for (size_t i = 0; i < MEDIUM; i++) {
1529     g_memcpy_same_buffer[i] = i;
1530   }
1531   RunSingleBufferAlignTest(MEDIUM, DoMemcpySameTest);
1532 }
1533 
TEST(STRING_TEST,memmem_strstr_empty_needle)1534 TEST(STRING_TEST, memmem_strstr_empty_needle) {
1535   const char* some_haystack = "haystack";
1536   const char* empty_haystack = "";
1537 
1538   ASSERT_EQ(some_haystack, memmem(some_haystack, 8, "", 0));
1539   ASSERT_EQ(empty_haystack, memmem(empty_haystack, 0, "", 0));
1540 
1541   ASSERT_EQ(some_haystack, strstr(some_haystack, ""));
1542   ASSERT_EQ(empty_haystack, strstr(empty_haystack, ""));
1543 }
1544 
TEST(STRING_TEST,memmem_smoke)1545 TEST(STRING_TEST, memmem_smoke) {
1546   const char haystack[] = "big\0daddy/giant\0haystacks!";
1547 
1548   // The current memmem() implementation has special cases for needles of
1549   // lengths 0, 1, 2, 3, and 4, plus a long needle case. We test matches at the
1550   // beginning, middle, and end of the haystack.
1551 
1552   ASSERT_EQ(haystack + 0, memmem(haystack, sizeof(haystack), "", 0));
1553 
1554   ASSERT_EQ(haystack + 0, memmem(haystack, sizeof(haystack), "b", 1));
1555   ASSERT_EQ(haystack + 0, memmem(haystack, sizeof(haystack), "bi", 2));
1556   ASSERT_EQ(haystack + 0, memmem(haystack, sizeof(haystack), "big", 3));
1557   ASSERT_EQ(haystack + 0, memmem(haystack, sizeof(haystack), "big\0", 4));
1558   ASSERT_EQ(haystack + 0, memmem(haystack, sizeof(haystack), "big\0d", 5));
1559 
1560   ASSERT_EQ(haystack + 2, memmem(haystack, sizeof(haystack), "g", 1));
1561   ASSERT_EQ(haystack + 10, memmem(haystack, sizeof(haystack), "gi", 2));
1562   ASSERT_EQ(haystack + 10, memmem(haystack, sizeof(haystack), "gia", 3));
1563   ASSERT_EQ(haystack + 10, memmem(haystack, sizeof(haystack), "gian", 4));
1564   ASSERT_EQ(haystack + 10, memmem(haystack, sizeof(haystack), "giant", 5));
1565 
1566   ASSERT_EQ(haystack + 25, memmem(haystack, sizeof(haystack), "!", 1));
1567   ASSERT_EQ(haystack + 24, memmem(haystack, sizeof(haystack), "s!", 2));
1568   ASSERT_EQ(haystack + 23, memmem(haystack, sizeof(haystack), "ks!", 3));
1569   ASSERT_EQ(haystack + 22, memmem(haystack, sizeof(haystack), "cks!", 4));
1570   ASSERT_EQ(haystack + 21, memmem(haystack, sizeof(haystack), "acks!", 5));
1571 }
1572 
TEST(STRING_TEST,strstr_smoke)1573 TEST(STRING_TEST, strstr_smoke) {
1574   const char* haystack = "big daddy/giant haystacks!";
1575 
1576   // The current strstr() implementation has special cases for needles of
1577   // lengths 0, 1, 2, 3, and 4, plus a long needle case. We test matches at the
1578   // beginning, middle, and end of the haystack.
1579 
1580   ASSERT_EQ(haystack + 0, strstr(haystack, ""));
1581 
1582   ASSERT_EQ(haystack + 0, strstr(haystack, "b"));
1583   ASSERT_EQ(haystack + 0, strstr(haystack, "bi"));
1584   ASSERT_EQ(haystack + 0, strstr(haystack, "big"));
1585   ASSERT_EQ(haystack + 0, strstr(haystack, "big "));
1586   ASSERT_EQ(haystack + 0, strstr(haystack, "big d"));
1587 
1588   ASSERT_EQ(haystack + 2, strstr(haystack, "g"));
1589   ASSERT_EQ(haystack + 10, strstr(haystack, "gi"));
1590   ASSERT_EQ(haystack + 10, strstr(haystack, "gia"));
1591   ASSERT_EQ(haystack + 10, strstr(haystack, "gian"));
1592   ASSERT_EQ(haystack + 10, strstr(haystack, "giant"));
1593 
1594   ASSERT_EQ(haystack + 25, strstr(haystack, "!"));
1595   ASSERT_EQ(haystack + 24, strstr(haystack, "s!"));
1596   ASSERT_EQ(haystack + 23, strstr(haystack, "ks!"));
1597   ASSERT_EQ(haystack + 22, strstr(haystack, "cks!"));
1598   ASSERT_EQ(haystack + 21, strstr(haystack, "acks!"));
1599 }
1600 
TEST(STRING_TEST,strcasestr_smoke)1601 TEST(STRING_TEST, strcasestr_smoke) {
1602   const char* haystack = "bIg dAdDy/gIaNt hAyStAcKs";
1603   ASSERT_EQ(haystack, strcasestr(haystack, ""));
1604   ASSERT_EQ(haystack + 0, strcasestr(haystack, "B"));
1605   ASSERT_EQ(haystack + 1, strcasestr(haystack, "i"));
1606   ASSERT_EQ(haystack + 4, strcasestr(haystack, "Da"));
1607 }
1608 
TEST(STRING_TEST,strcoll_smoke)1609 TEST(STRING_TEST, strcoll_smoke) {
1610   ASSERT_TRUE(strcoll("aab", "aac") < 0);
1611   ASSERT_TRUE(strcoll("aab", "aab") == 0);
1612   ASSERT_TRUE(strcoll("aac", "aab") > 0);
1613 }
1614 
TEST(STRING_TEST,strcoll_l_smoke)1615 TEST(STRING_TEST, strcoll_l_smoke) {
1616   // bionic just forwards to strcoll(3).
1617   ASSERT_TRUE(strcoll_l("aab", "aac", LC_GLOBAL_LOCALE) < 0);
1618   ASSERT_TRUE(strcoll_l("aab", "aab", LC_GLOBAL_LOCALE) == 0);
1619   ASSERT_TRUE(strcoll_l("aac", "aab", LC_GLOBAL_LOCALE) > 0);
1620 }
1621 
TEST(STRING_TEST,strxfrm_smoke)1622 TEST(STRING_TEST, strxfrm_smoke) {
1623   const char* src1 = "aab";
1624   char dst1[16] = {};
1625   // Dry run.
1626   ASSERT_EQ(strxfrm(dst1, src1, 0), 3U);
1627   ASSERT_STREQ(dst1, "");
1628   // Really do it.
1629   ASSERT_EQ(strxfrm(dst1, src1, sizeof(dst1)), 3U);
1630 
1631   const char* src2 = "aac";
1632   char dst2[16] = {};
1633   // Dry run.
1634   ASSERT_EQ(strxfrm(dst2, src2, 0), 3U);
1635   ASSERT_STREQ(dst2, "");
1636   // Really do it.
1637   ASSERT_EQ(strxfrm(dst2, src2, sizeof(dst2)), 3U);
1638 
1639   // The "transform" of two different strings should cause different outputs.
1640   ASSERT_TRUE(strcmp(dst1, dst2) < 0);
1641 }
1642 
TEST(STRING_TEST,strxfrm_l_smoke)1643 TEST(STRING_TEST, strxfrm_l_smoke) {
1644   // bionic just forwards to strxfrm(3), so this is a subset of the
1645   // strxfrm test.
1646   const char* src1 = "aab";
1647   char dst1[16] = {};
1648   ASSERT_EQ(strxfrm_l(dst1, src1, 0, LC_GLOBAL_LOCALE), 3U);
1649   ASSERT_STREQ(dst1, "");
1650   ASSERT_EQ(strxfrm_l(dst1, src1, sizeof(dst1), LC_GLOBAL_LOCALE), 3U);
1651 }
1652 
TEST(STRING_TEST,memccpy_smoke)1653 TEST(STRING_TEST, memccpy_smoke) {
1654   char dst[32];
1655 
1656   memset(dst, 0, sizeof(dst));
1657   char* p = static_cast<char*>(memccpy(dst, "hello world", ' ', 32));
1658   ASSERT_STREQ("hello ", dst);
1659   ASSERT_EQ(ptrdiff_t(6), p - dst);
1660 
1661   memset(dst, 0, sizeof(dst));
1662   ASSERT_EQ(nullptr, memccpy(dst, "hello world", ' ', 4));
1663   ASSERT_STREQ("hell", dst);
1664 }
1665