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 <errno.h>
18 #include <fcntl.h>
19 #include <libgen.h>
20 #include <limits.h>
21 #include <math.h>
22 #include <pthread.h>
23 #include <stdint.h>
24 #include <stdlib.h>
25 #include <sys/types.h>
26 #include <sys/wait.h>
27 #include <unistd.h>
28
29 #include <limits>
30 #include <string>
31
32 #include <android-base/file.h>
33 #include <android-base/macros.h>
34 #include <android-base/silent_death_test.h>
35 #include <gtest/gtest.h>
36
37 #include "math_data_test.h"
38 #include "utils.h"
39
40 using namespace std::string_literals;
41
42 template <typename T = int (*)(char*)>
43 class GenericTemporaryFile {
44 public:
GenericTemporaryFile(T mk_fn=mkstemp)45 explicit GenericTemporaryFile(T mk_fn = mkstemp) : mk_fn_(mk_fn) {
46 // Since we might be running on the host or the target, and if we're
47 // running on the host we might be running under bionic or glibc,
48 // let's just try both possible temporary directories and take the
49 // first one that works.
50 init("/data/local/tmp");
51 if (fd == -1) {
52 init("/tmp");
53 }
54 }
55
~GenericTemporaryFile()56 ~GenericTemporaryFile() {
57 close(fd);
58 unlink(path);
59 }
60
61 int fd;
62 char path[1024];
63
64 private:
65 T mk_fn_;
66
init(const char * tmp_dir)67 void init(const char* tmp_dir) {
68 snprintf(path, sizeof(path), "%s/TemporaryFile-XXXXXX", tmp_dir);
69 fd = mk_fn_(path);
70 }
71
72 DISALLOW_COPY_AND_ASSIGN(GenericTemporaryFile);
73 };
74
75 typedef GenericTemporaryFile<> MyTemporaryFile;
76
77 // The random number generator tests all set the seed, get four values, reset the seed and check
78 // that they get the first two values repeated, and then reset the seed and check two more values
79 // to rule out the possibility that we're just going round a cycle of four values.
80 // TODO: factor this out.
81
TEST(stdlib,drand48)82 TEST(stdlib, drand48) {
83 srand48(0x01020304);
84 EXPECT_DOUBLE_EQ(0.65619299195623526, drand48());
85 EXPECT_DOUBLE_EQ(0.18522597229772941, drand48());
86 EXPECT_DOUBLE_EQ(0.42015087072844537, drand48());
87 EXPECT_DOUBLE_EQ(0.061637783047395089, drand48());
88 srand48(0x01020304);
89 EXPECT_DOUBLE_EQ(0.65619299195623526, drand48());
90 EXPECT_DOUBLE_EQ(0.18522597229772941, drand48());
91 srand48(0x01020304);
92 EXPECT_DOUBLE_EQ(0.65619299195623526, drand48());
93 EXPECT_DOUBLE_EQ(0.18522597229772941, drand48());
94 }
95
TEST(stdlib,erand48)96 TEST(stdlib, erand48) {
97 const unsigned short seed[3] = { 0x330e, 0xabcd, 0x1234 };
98 unsigned short xsubi[3];
99 memcpy(xsubi, seed, sizeof(seed));
100 EXPECT_DOUBLE_EQ(0.39646477376027534, erand48(xsubi));
101 EXPECT_DOUBLE_EQ(0.84048536941142515, erand48(xsubi));
102 EXPECT_DOUBLE_EQ(0.35333609724524351, erand48(xsubi));
103 EXPECT_DOUBLE_EQ(0.44658343479654405, erand48(xsubi));
104 memcpy(xsubi, seed, sizeof(seed));
105 EXPECT_DOUBLE_EQ(0.39646477376027534, erand48(xsubi));
106 EXPECT_DOUBLE_EQ(0.84048536941142515, erand48(xsubi));
107 memcpy(xsubi, seed, sizeof(seed));
108 EXPECT_DOUBLE_EQ(0.39646477376027534, erand48(xsubi));
109 EXPECT_DOUBLE_EQ(0.84048536941142515, erand48(xsubi));
110 }
111
TEST(stdlib,lcong48)112 TEST(stdlib, lcong48) {
113 unsigned short p[7] = { 0x0102, 0x0304, 0x0506, 0x0708, 0x090a, 0x0b0c, 0x0d0e };
114 lcong48(p);
115 EXPECT_EQ(1531389981, lrand48());
116 EXPECT_EQ(1598801533, lrand48());
117 EXPECT_EQ(2080534853, lrand48());
118 EXPECT_EQ(1102488897, lrand48());
119 lcong48(p);
120 EXPECT_EQ(1531389981, lrand48());
121 EXPECT_EQ(1598801533, lrand48());
122 lcong48(p);
123 EXPECT_EQ(1531389981, lrand48());
124 EXPECT_EQ(1598801533, lrand48());
125 }
126
TEST(stdlib,lrand48)127 TEST(stdlib, lrand48) {
128 srand48(0x01020304);
129 EXPECT_EQ(1409163720, lrand48());
130 EXPECT_EQ(397769746, lrand48());
131 EXPECT_EQ(902267124, lrand48());
132 EXPECT_EQ(132366131, lrand48());
133 srand48(0x01020304);
134 EXPECT_EQ(1409163720, lrand48());
135 EXPECT_EQ(397769746, lrand48());
136 srand48(0x01020304);
137 EXPECT_EQ(1409163720, lrand48());
138 EXPECT_EQ(397769746, lrand48());
139 }
140
TEST(stdlib,random)141 TEST(stdlib, random) {
142 srandom(0x01020304);
143 EXPECT_EQ(55436735, random());
144 EXPECT_EQ(1399865117, random());
145 EXPECT_EQ(2032643283, random());
146 EXPECT_EQ(571329216, random());
147 srandom(0x01020304);
148 EXPECT_EQ(55436735, random());
149 EXPECT_EQ(1399865117, random());
150 srandom(0x01020304);
151 EXPECT_EQ(55436735, random());
152 EXPECT_EQ(1399865117, random());
153 }
154
TEST(stdlib,rand)155 TEST(stdlib, rand) {
156 srand(0x01020304);
157 EXPECT_EQ(55436735, rand());
158 EXPECT_EQ(1399865117, rand());
159 EXPECT_EQ(2032643283, rand());
160 EXPECT_EQ(571329216, rand());
161 srand(0x01020304);
162 EXPECT_EQ(55436735, rand());
163 EXPECT_EQ(1399865117, rand());
164 srand(0x01020304);
165 EXPECT_EQ(55436735, rand());
166 EXPECT_EQ(1399865117, rand());
167 }
168
TEST(stdlib,mrand48)169 TEST(stdlib, mrand48) {
170 srand48(0x01020304);
171 EXPECT_EQ(-1476639856, mrand48());
172 EXPECT_EQ(795539493, mrand48());
173 EXPECT_EQ(1804534249, mrand48());
174 EXPECT_EQ(264732262, mrand48());
175 srand48(0x01020304);
176 EXPECT_EQ(-1476639856, mrand48());
177 EXPECT_EQ(795539493, mrand48());
178 srand48(0x01020304);
179 EXPECT_EQ(-1476639856, mrand48());
180 EXPECT_EQ(795539493, mrand48());
181 }
182
TEST(stdlib,jrand48_distribution)183 TEST(stdlib, jrand48_distribution) {
184 const int iterations = 4096;
185 const int pivot_low = 1536;
186 const int pivot_high = 2560;
187
188 unsigned short xsubi[3];
189 int bits[32] = {};
190
191 for (int iter = 0; iter < iterations; ++iter) {
192 long rand_val = jrand48(xsubi);
193 for (int bit = 0; bit < 32; ++bit) {
194 bits[bit] += (static_cast<unsigned long>(rand_val) >> bit) & 0x01;
195 }
196 }
197
198 // Check that bit probability is uniform
199 for (int bit = 0; bit < 32; ++bit) {
200 EXPECT_TRUE((pivot_low <= bits[bit]) && (bits[bit] <= pivot_high));
201 }
202 }
203
TEST(stdlib,mrand48_distribution)204 TEST(stdlib, mrand48_distribution) {
205 const int iterations = 4096;
206 const int pivot_low = 1536;
207 const int pivot_high = 2560;
208
209 int bits[32] = {};
210
211 for (int iter = 0; iter < iterations; ++iter) {
212 long rand_val = mrand48();
213 for (int bit = 0; bit < 32; ++bit) {
214 bits[bit] += (static_cast<unsigned long>(rand_val) >> bit) & 0x01;
215 }
216 }
217
218 // Check that bit probability is uniform
219 for (int bit = 0; bit < 32; ++bit) {
220 EXPECT_TRUE((pivot_low <= bits[bit]) && (bits[bit] <= pivot_high));
221 }
222 }
223
TEST(stdlib,posix_memalign_sweep)224 TEST(stdlib, posix_memalign_sweep) {
225 SKIP_WITH_HWASAN;
226 void* ptr;
227
228 // These should all fail.
229 for (size_t align = 0; align < sizeof(long); align++) {
230 ASSERT_EQ(EINVAL, posix_memalign(&ptr, align, 256))
231 << "Unexpected value at align " << align;
232 }
233
234 // Verify powers of 2 up to 2048 allocate, and verify that all other
235 // alignment values between the powers of 2 fail.
236 size_t last_align = sizeof(long);
237 for (size_t align = sizeof(long); align <= 2048; align <<= 1) {
238 // Try all of the non power of 2 values from the last until this value.
239 for (size_t fail_align = last_align + 1; fail_align < align; fail_align++) {
240 ASSERT_EQ(EINVAL, posix_memalign(&ptr, fail_align, 256))
241 << "Unexpected success at align " << fail_align;
242 }
243 ASSERT_EQ(0, posix_memalign(&ptr, align, 256))
244 << "Unexpected failure at align " << align;
245 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr) & (align - 1))
246 << "Did not return a valid aligned ptr " << ptr << " expected alignment " << align;
247 free(ptr);
248 last_align = align;
249 }
250 }
251
TEST(stdlib,posix_memalign_various_sizes)252 TEST(stdlib, posix_memalign_various_sizes) {
253 std::vector<size_t> sizes{1, 4, 8, 256, 1024, 65000, 128000, 256000, 1000000};
254 for (auto size : sizes) {
255 void* ptr;
256 ASSERT_EQ(0, posix_memalign(&ptr, 16, 1))
257 << "posix_memalign failed at size " << size;
258 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr) & 0xf)
259 << "Pointer not aligned at size " << size << " ptr " << ptr;
260 free(ptr);
261 }
262 }
263
TEST(stdlib,posix_memalign_overflow)264 TEST(stdlib, posix_memalign_overflow) {
265 SKIP_WITH_HWASAN;
266 void* ptr;
267 ASSERT_NE(0, posix_memalign(&ptr, 16, SIZE_MAX));
268 }
269
TEST(stdlib,aligned_alloc_sweep)270 TEST(stdlib, aligned_alloc_sweep) {
271 SKIP_WITH_HWASAN;
272 // Verify powers of 2 up to 2048 allocate, and verify that all other
273 // alignment values between the powers of 2 fail.
274 size_t last_align = 1;
275 for (size_t align = 1; align <= 2048; align <<= 1) {
276 // Try all of the non power of 2 values from the last until this value.
277 for (size_t fail_align = last_align + 1; fail_align < align; fail_align++) {
278 ASSERT_TRUE(aligned_alloc(fail_align, fail_align) == nullptr)
279 << "Unexpected success at align " << fail_align;
280 ASSERT_EQ(EINVAL, errno) << "Unexpected errno at align " << fail_align;
281 }
282 void* ptr = aligned_alloc(align, 2 * align);
283 ASSERT_TRUE(ptr != nullptr) << "Unexpected failure at align " << align;
284 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(ptr) & (align - 1))
285 << "Did not return a valid aligned ptr " << ptr << " expected alignment " << align;
286 free(ptr);
287 last_align = align;
288 }
289 }
290
TEST(stdlib,aligned_alloc_overflow)291 TEST(stdlib, aligned_alloc_overflow) {
292 SKIP_WITH_HWASAN;
293 ASSERT_TRUE(aligned_alloc(16, SIZE_MAX) == nullptr);
294 }
295
TEST(stdlib,aligned_alloc_size_not_multiple_of_alignment)296 TEST(stdlib, aligned_alloc_size_not_multiple_of_alignment) {
297 SKIP_WITH_HWASAN;
298
299 ASSERT_TRUE(aligned_alloc(2048, 1) == nullptr);
300 ASSERT_TRUE(aligned_alloc(4, 3) == nullptr);
301 ASSERT_TRUE(aligned_alloc(4, 7) == nullptr);
302 ASSERT_TRUE(aligned_alloc(16, 8) == nullptr);
303 }
304
TEST(stdlib,realpath__NULL_filename)305 TEST(stdlib, realpath__NULL_filename) {
306 errno = 0;
307 // Work around the compile-time error generated by FORTIFY here.
308 const char* path = nullptr;
309 char* p = realpath(path, nullptr);
310 ASSERT_TRUE(p == nullptr);
311 ASSERT_EQ(EINVAL, errno);
312 }
313
TEST(stdlib,realpath__empty_filename)314 TEST(stdlib, realpath__empty_filename) {
315 errno = 0;
316 char* p = realpath("", nullptr);
317 ASSERT_TRUE(p == nullptr);
318 ASSERT_EQ(ENOENT, errno);
319 }
320
TEST(stdlib,realpath__ENOENT)321 TEST(stdlib, realpath__ENOENT) {
322 errno = 0;
323 char* p = realpath("/this/directory/path/almost/certainly/does/not/exist", nullptr);
324 ASSERT_TRUE(p == nullptr);
325 ASSERT_EQ(ENOENT, errno);
326 }
327
TEST(stdlib,realpath__ELOOP)328 TEST(stdlib, realpath__ELOOP) {
329 TemporaryDir td;
330 std::string link = std::string(td.path) + "/loop";
331 ASSERT_EQ(0, symlink(link.c_str(), link.c_str()));
332
333 errno = 0;
334 char* p = realpath(link.c_str(), nullptr);
335 ASSERT_TRUE(p == nullptr);
336 ASSERT_EQ(ELOOP, errno);
337 }
338
TEST(stdlib,realpath__component_after_non_directory)339 TEST(stdlib, realpath__component_after_non_directory) {
340 errno = 0;
341 char* p = realpath("/dev/null/.", nullptr);
342 ASSERT_TRUE(p == nullptr);
343 ASSERT_EQ(ENOTDIR, errno);
344
345 errno = 0;
346 p = realpath("/dev/null/..", nullptr);
347 ASSERT_TRUE(p == nullptr);
348 ASSERT_EQ(ENOTDIR, errno);
349 }
350
TEST(stdlib,realpath)351 TEST(stdlib, realpath) {
352 // Get the name of this executable.
353 char executable_path[PATH_MAX];
354 int rc = readlink("/proc/self/exe", executable_path, sizeof(executable_path));
355 ASSERT_NE(rc, -1);
356 executable_path[rc] = '\0';
357
358 char buf[PATH_MAX + 1];
359 char* p = realpath("/proc/self/exe", buf);
360 ASSERT_STREQ(executable_path, p);
361
362 p = realpath("/proc/self/exe", nullptr);
363 ASSERT_STREQ(executable_path, p);
364 free(p);
365 }
366
TEST(stdlib,realpath__dot)367 TEST(stdlib, realpath__dot) {
368 char* p = realpath("/proc/./version", nullptr);
369 ASSERT_STREQ("/proc/version", p);
370 free(p);
371 }
372
TEST(stdlib,realpath__dot_dot)373 TEST(stdlib, realpath__dot_dot) {
374 char* p = realpath("/dev/../proc/version", nullptr);
375 ASSERT_STREQ("/proc/version", p);
376 free(p);
377 }
378
TEST(stdlib,realpath__deleted)379 TEST(stdlib, realpath__deleted) {
380 TemporaryDir td;
381
382 // Create a file "A".
383 std::string A_path = td.path + "/A"s;
384 ASSERT_TRUE(android::base::WriteStringToFile("test\n", A_path));
385
386 // Get an O_PATH fd for it.
387 android::base::unique_fd fd(open(A_path.c_str(), O_PATH));
388 ASSERT_NE(fd, -1);
389
390 // Create a file "A (deleted)".
391 android::base::unique_fd fd2(open((td.path + "/A (deleted)"s).c_str(),
392 O_CREAT | O_TRUNC | O_WRONLY, 0644));
393 ASSERT_NE(fd2, -1);
394
395 // Delete "A".
396 ASSERT_EQ(0, unlink(A_path.c_str()));
397
398 // Now realpath() on the O_PATH fd, and check we *don't* get "A (deleted)".
399 std::string path = android::base::StringPrintf("/proc/%d/fd/%d", static_cast<int>(getpid()),
400 fd.get());
401 errno = 0;
402 char* result = realpath(path.c_str(), nullptr);
403 ASSERT_EQ(nullptr, result) << result;
404 ASSERT_EQ(ENOENT, errno);
405 free(result);
406 }
407
TEST(stdlib,qsort)408 TEST(stdlib, qsort) {
409 struct s {
410 char name[16];
411 static int comparator(const void* lhs, const void* rhs) {
412 return strcmp(reinterpret_cast<const s*>(lhs)->name, reinterpret_cast<const s*>(rhs)->name);
413 }
414 };
415 s entries[3];
416 strcpy(entries[0].name, "charlie");
417 strcpy(entries[1].name, "bravo");
418 strcpy(entries[2].name, "alpha");
419
420 qsort(entries, 3, sizeof(s), s::comparator);
421 ASSERT_STREQ("alpha", entries[0].name);
422 ASSERT_STREQ("bravo", entries[1].name);
423 ASSERT_STREQ("charlie", entries[2].name);
424
425 qsort(entries, 3, sizeof(s), s::comparator);
426 ASSERT_STREQ("alpha", entries[0].name);
427 ASSERT_STREQ("bravo", entries[1].name);
428 ASSERT_STREQ("charlie", entries[2].name);
429 }
430
TestBug57421_child(void * arg)431 static void* TestBug57421_child(void* arg) {
432 pthread_t main_thread = reinterpret_cast<pthread_t>(arg);
433 pthread_join(main_thread, nullptr);
434 char* value = getenv("ENVIRONMENT_VARIABLE");
435 if (value == nullptr) {
436 setenv("ENVIRONMENT_VARIABLE", "value", 1);
437 }
438 return nullptr;
439 }
440
TestBug57421_main()441 static void TestBug57421_main() {
442 pthread_t t;
443 ASSERT_EQ(0, pthread_create(&t, nullptr, TestBug57421_child, reinterpret_cast<void*>(pthread_self())));
444 pthread_exit(nullptr);
445 }
446
447 // Even though this isn't really a death test, we have to say "DeathTest" here so gtest knows to
448 // run this test (which exits normally) in its own process.
449
450 using stdlib_DeathTest = SilentDeathTest;
451
TEST_F(stdlib_DeathTest,getenv_after_main_thread_exits)452 TEST_F(stdlib_DeathTest, getenv_after_main_thread_exits) {
453 // https://code.google.com/p/android/issues/detail?id=57421
454 ASSERT_EXIT(TestBug57421_main(), ::testing::ExitedWithCode(0), "");
455 }
456
TEST(stdlib,mkostemp64)457 TEST(stdlib, mkostemp64) {
458 MyTemporaryFile tf([](char* path) { return mkostemp64(path, O_CLOEXEC); });
459 ASSERT_TRUE(CloseOnExec(tf.fd));
460 }
461
TEST(stdlib,mkostemp)462 TEST(stdlib, mkostemp) {
463 MyTemporaryFile tf([](char* path) { return mkostemp(path, O_CLOEXEC); });
464 ASSERT_TRUE(CloseOnExec(tf.fd));
465 }
466
TEST(stdlib,mkstemp64)467 TEST(stdlib, mkstemp64) {
468 MyTemporaryFile tf(mkstemp64);
469 struct stat64 sb;
470 ASSERT_EQ(0, fstat64(tf.fd, &sb));
471 ASSERT_EQ(O_LARGEFILE, fcntl(tf.fd, F_GETFL) & O_LARGEFILE);
472 }
473
TEST(stdlib,mkstemp)474 TEST(stdlib, mkstemp) {
475 MyTemporaryFile tf(mkstemp);
476 struct stat sb;
477 ASSERT_EQ(0, fstat(tf.fd, &sb));
478 }
479
TEST(stdlib,system)480 TEST(stdlib, system) {
481 int status;
482
483 status = system("exit 0");
484 ASSERT_TRUE(WIFEXITED(status));
485 ASSERT_EQ(0, WEXITSTATUS(status));
486
487 status = system("exit 1");
488 ASSERT_TRUE(WIFEXITED(status));
489 ASSERT_EQ(1, WEXITSTATUS(status));
490 }
491
TEST(stdlib,system_NULL)492 TEST(stdlib, system_NULL) {
493 // "The system() function shall always return non-zero when command is NULL."
494 // http://pubs.opengroup.org/onlinepubs/9699919799/functions/system.html
495 ASSERT_NE(0, system(nullptr));
496 }
497
TEST(stdlib,atof)498 TEST(stdlib, atof) {
499 ASSERT_DOUBLE_EQ(1.23, atof("1.23"));
500 }
501
502 template <typename T>
CheckStrToFloat(T fn (const char * s,char ** end))503 static void CheckStrToFloat(T fn(const char* s, char** end)) {
504 FpUlpEq<0, T> pred;
505
506 EXPECT_PRED_FORMAT2(pred, 9.0, fn("9.0", nullptr));
507 EXPECT_PRED_FORMAT2(pred, 9.0, fn("0.9e1", nullptr));
508 EXPECT_PRED_FORMAT2(pred, 9.0, fn("0x1.2p3", nullptr));
509
510 const char* s = " \t\v\f\r\n9.0";
511 char* p;
512 EXPECT_PRED_FORMAT2(pred, 9.0, fn(s, &p));
513 EXPECT_EQ(s + strlen(s), p);
514
515 EXPECT_TRUE(isnan(fn("+nan", nullptr)));
516 EXPECT_TRUE(isnan(fn("nan", nullptr)));
517 EXPECT_TRUE(isnan(fn("-nan", nullptr)));
518
519 EXPECT_TRUE(isnan(fn("+nan(0xff)", nullptr)));
520 EXPECT_TRUE(isnan(fn("nan(0xff)", nullptr)));
521 EXPECT_TRUE(isnan(fn("-nan(0xff)", nullptr)));
522
523 EXPECT_TRUE(isnan(fn("+nanny", &p)));
524 EXPECT_STREQ("ny", p);
525 EXPECT_TRUE(isnan(fn("nanny", &p)));
526 EXPECT_STREQ("ny", p);
527 EXPECT_TRUE(isnan(fn("-nanny", &p)));
528 EXPECT_STREQ("ny", p);
529
530 EXPECT_EQ(0, fn("muppet", &p));
531 EXPECT_STREQ("muppet", p);
532 EXPECT_EQ(0, fn(" muppet", &p));
533 EXPECT_STREQ(" muppet", p);
534
535 EXPECT_EQ(std::numeric_limits<T>::infinity(), fn("+inf", nullptr));
536 EXPECT_EQ(std::numeric_limits<T>::infinity(), fn("inf", nullptr));
537 EXPECT_EQ(-std::numeric_limits<T>::infinity(), fn("-inf", nullptr));
538
539 EXPECT_EQ(std::numeric_limits<T>::infinity(), fn("+infinity", nullptr));
540 EXPECT_EQ(std::numeric_limits<T>::infinity(), fn("infinity", nullptr));
541 EXPECT_EQ(-std::numeric_limits<T>::infinity(), fn("-infinity", nullptr));
542
543 EXPECT_EQ(std::numeric_limits<T>::infinity(), fn("+infinitude", &p));
544 EXPECT_STREQ("initude", p);
545 EXPECT_EQ(std::numeric_limits<T>::infinity(), fn("infinitude", &p));
546 EXPECT_STREQ("initude", p);
547 EXPECT_EQ(-std::numeric_limits<T>::infinity(), fn("-infinitude", &p));
548 EXPECT_STREQ("initude", p);
549
550 // Check case-insensitivity.
551 EXPECT_EQ(std::numeric_limits<T>::infinity(), fn("InFiNiTy", nullptr));
552 EXPECT_TRUE(isnan(fn("NaN", nullptr)));
553 }
554
TEST(stdlib,strtod)555 TEST(stdlib, strtod) {
556 CheckStrToFloat(strtod);
557 }
558
TEST(stdlib,strtof)559 TEST(stdlib, strtof) {
560 CheckStrToFloat(strtof);
561 }
562
TEST(stdlib,strtold)563 TEST(stdlib, strtold) {
564 CheckStrToFloat(strtold);
565 }
566
TEST(stdlib,strtof_2206701)567 TEST(stdlib, strtof_2206701) {
568 ASSERT_EQ(0.0f, strtof("7.0064923216240853546186479164495e-46", nullptr));
569 ASSERT_EQ(1.4e-45f, strtof("7.0064923216240853546186479164496e-46", nullptr));
570 }
571
TEST(stdlib,strtod_largest_subnormal)572 TEST(stdlib, strtod_largest_subnormal) {
573 // This value has been known to cause javac and java to infinite loop.
574 // http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/
575 ASSERT_EQ(2.2250738585072014e-308, strtod("2.2250738585072012e-308", nullptr));
576 ASSERT_EQ(2.2250738585072014e-308, strtod("0.00022250738585072012e-304", nullptr));
577 ASSERT_EQ(2.2250738585072014e-308, strtod("00000002.2250738585072012e-308", nullptr));
578 ASSERT_EQ(2.2250738585072014e-308, strtod("2.225073858507201200000e-308", nullptr));
579 ASSERT_EQ(2.2250738585072014e-308, strtod("2.2250738585072012e-00308", nullptr));
580 ASSERT_EQ(2.2250738585072014e-308, strtod("2.22507385850720129978001e-308", nullptr));
581 ASSERT_EQ(-2.2250738585072014e-308, strtod("-2.2250738585072012e-308", nullptr));
582 }
583
TEST(stdlib,quick_exit)584 TEST(stdlib, quick_exit) {
585 pid_t pid = fork();
586 ASSERT_NE(-1, pid) << strerror(errno);
587
588 if (pid == 0) {
589 quick_exit(99);
590 }
591
592 AssertChildExited(pid, 99);
593 }
594
595 static int quick_exit_status = 0;
596
quick_exit_1(void)597 static void quick_exit_1(void) {
598 ASSERT_EQ(quick_exit_status, 0);
599 quick_exit_status = 1;
600 }
601
quick_exit_2(void)602 static void quick_exit_2(void) {
603 ASSERT_EQ(quick_exit_status, 1);
604 }
605
not_run(void)606 static void not_run(void) {
607 FAIL();
608 }
609
TEST(stdlib,at_quick_exit)610 TEST(stdlib, at_quick_exit) {
611 pid_t pid = fork();
612 ASSERT_NE(-1, pid) << strerror(errno);
613
614 if (pid == 0) {
615 ASSERT_EQ(at_quick_exit(quick_exit_2), 0);
616 ASSERT_EQ(at_quick_exit(quick_exit_1), 0);
617 atexit(not_run);
618 quick_exit(99);
619 }
620
621 AssertChildExited(pid, 99);
622 }
623
TEST(unistd,_Exit)624 TEST(unistd, _Exit) {
625 pid_t pid = fork();
626 ASSERT_NE(-1, pid) << strerror(errno);
627
628 if (pid == 0) {
629 _Exit(99);
630 }
631
632 AssertChildExited(pid, 99);
633 }
634
TEST(stdlib,pty_smoke)635 TEST(stdlib, pty_smoke) {
636 // getpt returns a pty with O_RDWR|O_NOCTTY.
637 int fd = getpt();
638 ASSERT_NE(-1, fd);
639
640 // grantpt is a no-op.
641 ASSERT_EQ(0, grantpt(fd));
642
643 // ptsname_r should start "/dev/pts/".
644 char name_r[128];
645 ASSERT_EQ(0, ptsname_r(fd, name_r, sizeof(name_r)));
646 name_r[9] = 0;
647 ASSERT_STREQ("/dev/pts/", name_r);
648
649 close(fd);
650 }
651
TEST(stdlib,posix_openpt)652 TEST(stdlib, posix_openpt) {
653 int fd = posix_openpt(O_RDWR|O_NOCTTY|O_CLOEXEC);
654 ASSERT_NE(-1, fd);
655 close(fd);
656 }
657
TEST(stdlib,ptsname_r_ENOTTY)658 TEST(stdlib, ptsname_r_ENOTTY) {
659 errno = 0;
660 char buf[128];
661 ASSERT_EQ(ENOTTY, ptsname_r(STDOUT_FILENO, buf, sizeof(buf)));
662 ASSERT_EQ(ENOTTY, errno);
663 }
664
TEST(stdlib,ptsname_r_EINVAL)665 TEST(stdlib, ptsname_r_EINVAL) {
666 int fd = getpt();
667 ASSERT_NE(-1, fd);
668 errno = 0;
669 char* buf = nullptr;
670 ASSERT_EQ(EINVAL, ptsname_r(fd, buf, 128));
671 ASSERT_EQ(EINVAL, errno);
672 close(fd);
673 }
674
TEST(stdlib,ptsname_r_ERANGE)675 TEST(stdlib, ptsname_r_ERANGE) {
676 int fd = getpt();
677 ASSERT_NE(-1, fd);
678 errno = 0;
679 char buf[1];
680 ASSERT_EQ(ERANGE, ptsname_r(fd, buf, sizeof(buf)));
681 ASSERT_EQ(ERANGE, errno);
682 close(fd);
683 }
684
TEST(stdlib,ttyname)685 TEST(stdlib, ttyname) {
686 int fd = getpt();
687 ASSERT_NE(-1, fd);
688
689 // ttyname returns "/dev/ptmx" for a pty.
690 ASSERT_STREQ("/dev/ptmx", ttyname(fd));
691
692 close(fd);
693 }
694
TEST(stdlib,ttyname_r)695 TEST(stdlib, ttyname_r) {
696 int fd = getpt();
697 ASSERT_NE(-1, fd);
698
699 // ttyname_r returns "/dev/ptmx" for a pty.
700 char name_r[128];
701 ASSERT_EQ(0, ttyname_r(fd, name_r, sizeof(name_r)));
702 ASSERT_STREQ("/dev/ptmx", name_r);
703
704 close(fd);
705 }
706
TEST(stdlib,ttyname_r_ENOTTY)707 TEST(stdlib, ttyname_r_ENOTTY) {
708 int fd = open("/dev/null", O_WRONLY);
709 errno = 0;
710 char buf[128];
711 ASSERT_EQ(ENOTTY, ttyname_r(fd, buf, sizeof(buf)));
712 ASSERT_EQ(ENOTTY, errno);
713 close(fd);
714 }
715
TEST(stdlib,ttyname_r_EINVAL)716 TEST(stdlib, ttyname_r_EINVAL) {
717 int fd = getpt();
718 ASSERT_NE(-1, fd);
719 errno = 0;
720 char* buf = nullptr;
721 ASSERT_EQ(EINVAL, ttyname_r(fd, buf, 128));
722 ASSERT_EQ(EINVAL, errno);
723 close(fd);
724 }
725
TEST(stdlib,ttyname_r_ERANGE)726 TEST(stdlib, ttyname_r_ERANGE) {
727 int fd = getpt();
728 ASSERT_NE(-1, fd);
729 errno = 0;
730 char buf[1];
731 ASSERT_EQ(ERANGE, ttyname_r(fd, buf, sizeof(buf)));
732 ASSERT_EQ(ERANGE, errno);
733 close(fd);
734 }
735
TEST(stdlib,unlockpt_ENOTTY)736 TEST(stdlib, unlockpt_ENOTTY) {
737 int fd = open("/dev/null", O_WRONLY);
738 errno = 0;
739 ASSERT_EQ(-1, unlockpt(fd));
740 ASSERT_EQ(ENOTTY, errno);
741 close(fd);
742 }
743
TEST(stdlib,getsubopt)744 TEST(stdlib, getsubopt) {
745 char* const tokens[] = {
746 const_cast<char*>("a"),
747 const_cast<char*>("b"),
748 const_cast<char*>("foo"),
749 nullptr
750 };
751 std::string input = "a,b,foo=bar,a,unknown";
752 char* subopts = &input[0];
753 char* value = nullptr;
754
755 ASSERT_EQ(0, getsubopt(&subopts, tokens, &value));
756 ASSERT_EQ(nullptr, value);
757 ASSERT_EQ(1, getsubopt(&subopts, tokens, &value));
758 ASSERT_EQ(nullptr, value);
759 ASSERT_EQ(2, getsubopt(&subopts, tokens, &value));
760 ASSERT_STREQ("bar", value);
761 ASSERT_EQ(0, getsubopt(&subopts, tokens, &value));
762 ASSERT_EQ(nullptr, value);
763
764 ASSERT_EQ(-1, getsubopt(&subopts, tokens, &value));
765 }
766
TEST(stdlib,mblen)767 TEST(stdlib, mblen) {
768 // "If s is a null pointer, mblen() shall return a non-zero or 0 value, if character encodings,
769 // respectively, do or do not have state-dependent encodings." We're always UTF-8.
770 EXPECT_EQ(0, mblen(nullptr, 1));
771
772 ASSERT_STREQ("C.UTF-8", setlocale(LC_ALL, "C.UTF-8"));
773
774 // 1-byte UTF-8.
775 EXPECT_EQ(1, mblen("abcdef", 6));
776 // 2-byte UTF-8.
777 EXPECT_EQ(2, mblen("\xc2\xa2" "cdef", 6));
778 // 3-byte UTF-8.
779 EXPECT_EQ(3, mblen("\xe2\x82\xac" "def", 6));
780 // 4-byte UTF-8.
781 EXPECT_EQ(4, mblen("\xf0\xa4\xad\xa2" "ef", 6));
782
783 // Illegal over-long sequence.
784 ASSERT_EQ(-1, mblen("\xf0\x82\x82\xac" "ef", 6));
785
786 // "mblen() shall ... return 0 (if s points to the null byte)".
787 EXPECT_EQ(0, mblen("", 1));
788 }
789
790 template <typename T>
CheckStrToInt(T fn (const char * s,char ** end,int base))791 static void CheckStrToInt(T fn(const char* s, char** end, int base)) {
792 char* end_p;
793
794 // Negative base => invalid.
795 errno = 0;
796 ASSERT_EQ(T(0), fn("123", &end_p, -1));
797 ASSERT_EQ(EINVAL, errno);
798
799 // Base 1 => invalid (base 0 means "please guess").
800 errno = 0;
801 ASSERT_EQ(T(0), fn("123", &end_p, 1));
802 ASSERT_EQ(EINVAL, errno);
803
804 // Base > 36 => invalid.
805 errno = 0;
806 ASSERT_EQ(T(0), fn("123", &end_p, 37));
807 ASSERT_EQ(EINVAL, errno);
808
809 // Both leading + or - are always allowed (even for the strtou* family).
810 ASSERT_EQ(T(-123), fn("-123", &end_p, 10));
811 ASSERT_EQ(T(123), fn("+123", &end_p, 10));
812
813 // If we see "0x" *not* followed by a hex digit, we shouldn't swallow the 'x'.
814 ASSERT_EQ(T(0), fn("0xy", &end_p, 16));
815 ASSERT_EQ('x', *end_p);
816
817 // Hexadecimal (both the 0x and the digits) is case-insensitive.
818 ASSERT_EQ(T(0xab), fn("0xab", &end_p, 0));
819 ASSERT_EQ(T(0xab), fn("0Xab", &end_p, 0));
820 ASSERT_EQ(T(0xab), fn("0xAB", &end_p, 0));
821 ASSERT_EQ(T(0xab), fn("0XAB", &end_p, 0));
822 ASSERT_EQ(T(0xab), fn("0xAb", &end_p, 0));
823 ASSERT_EQ(T(0xab), fn("0XAb", &end_p, 0));
824
825 // Octal lives! (Sadly.)
826 ASSERT_EQ(T(0666), fn("0666", &end_p, 0));
827
828 if (std::numeric_limits<T>::is_signed) {
829 // Minimum (such as -128).
830 std::string min{std::to_string(std::numeric_limits<T>::min())};
831 end_p = nullptr;
832 errno = 0;
833 ASSERT_EQ(std::numeric_limits<T>::min(), fn(min.c_str(), &end_p, 0));
834 ASSERT_EQ(0, errno);
835 ASSERT_EQ('\0', *end_p);
836 // Too negative (such as -129).
837 min.back() = (min.back() + 1);
838 end_p = nullptr;
839 errno = 0;
840 ASSERT_EQ(std::numeric_limits<T>::min(), fn(min.c_str(), &end_p, 0));
841 ASSERT_EQ(ERANGE, errno);
842 ASSERT_EQ('\0', *end_p);
843 }
844
845 // Maximum (such as 127).
846 std::string max{std::to_string(std::numeric_limits<T>::max())};
847 end_p = nullptr;
848 errno = 0;
849 ASSERT_EQ(std::numeric_limits<T>::max(), fn(max.c_str(), &end_p, 0));
850 ASSERT_EQ(0, errno);
851 ASSERT_EQ('\0', *end_p);
852 // Too positive (such as 128).
853 max.back() = (max.back() + 1);
854 end_p = nullptr;
855 errno = 0;
856 ASSERT_EQ(std::numeric_limits<T>::max(), fn(max.c_str(), &end_p, 0));
857 ASSERT_EQ(ERANGE, errno);
858 ASSERT_EQ('\0', *end_p);
859
860 // In case of overflow, strto* leaves us pointing past the end of the number,
861 // not at the digit that overflowed.
862 end_p = nullptr;
863 errno = 0;
864 ASSERT_EQ(std::numeric_limits<T>::max(),
865 fn("99999999999999999999999999999999999999999999999999999abc", &end_p, 0));
866 ASSERT_EQ(ERANGE, errno);
867 ASSERT_STREQ("abc", end_p);
868 if (std::numeric_limits<T>::is_signed) {
869 end_p = nullptr;
870 errno = 0;
871 ASSERT_EQ(std::numeric_limits<T>::min(),
872 fn("-99999999999999999999999999999999999999999999999999999abc", &end_p, 0));
873 ASSERT_EQ(ERANGE, errno);
874 ASSERT_STREQ("abc", end_p);
875 }
876 }
877
TEST(stdlib,strtol_smoke)878 TEST(stdlib, strtol_smoke) {
879 CheckStrToInt(strtol);
880 }
881
TEST(stdlib,strtoll_smoke)882 TEST(stdlib, strtoll_smoke) {
883 CheckStrToInt(strtoll);
884 }
885
TEST(stdlib,strtoul_smoke)886 TEST(stdlib, strtoul_smoke) {
887 CheckStrToInt(strtoul);
888 }
889
TEST(stdlib,strtoull_smoke)890 TEST(stdlib, strtoull_smoke) {
891 CheckStrToInt(strtoull);
892 }
893
TEST(stdlib,strtoimax_smoke)894 TEST(stdlib, strtoimax_smoke) {
895 CheckStrToInt(strtoimax);
896 }
897
TEST(stdlib,strtoumax_smoke)898 TEST(stdlib, strtoumax_smoke) {
899 CheckStrToInt(strtoumax);
900 }
901
TEST(stdlib,atoi)902 TEST(stdlib, atoi) {
903 // Implemented using strtol in bionic, so extensive testing unnecessary.
904 ASSERT_EQ(123, atoi("123four"));
905 ASSERT_EQ(0, atoi("hello"));
906 }
907
TEST(stdlib,atol)908 TEST(stdlib, atol) {
909 // Implemented using strtol in bionic, so extensive testing unnecessary.
910 ASSERT_EQ(123L, atol("123four"));
911 ASSERT_EQ(0L, atol("hello"));
912 }
913
TEST(stdlib,abs)914 TEST(stdlib, abs) {
915 ASSERT_EQ(INT_MAX, abs(-INT_MAX));
916 ASSERT_EQ(INT_MAX, abs(INT_MAX));
917 }
918
TEST(stdlib,labs)919 TEST(stdlib, labs) {
920 ASSERT_EQ(LONG_MAX, labs(-LONG_MAX));
921 ASSERT_EQ(LONG_MAX, labs(LONG_MAX));
922 }
923
TEST(stdlib,llabs)924 TEST(stdlib, llabs) {
925 ASSERT_EQ(LLONG_MAX, llabs(-LLONG_MAX));
926 ASSERT_EQ(LLONG_MAX, llabs(LLONG_MAX));
927 }
928
TEST(stdlib,getloadavg)929 TEST(stdlib, getloadavg) {
930 double load[3];
931
932 // The second argument should have been size_t.
933 ASSERT_EQ(-1, getloadavg(load, -1));
934 ASSERT_EQ(-1, getloadavg(load, INT_MIN));
935
936 // Zero is a no-op.
937 ASSERT_EQ(0, getloadavg(load, 0));
938
939 // The Linux kernel doesn't support more than 3 (but you can ask for fewer).
940 ASSERT_EQ(1, getloadavg(load, 1));
941 ASSERT_EQ(2, getloadavg(load, 2));
942 ASSERT_EQ(3, getloadavg(load, 3));
943 ASSERT_EQ(3, getloadavg(load, 4));
944 ASSERT_EQ(3, getloadavg(load, INT_MAX));
945
946 // Read /proc/loadavg and check that it's "close enough".
947 double expected[3];
948 std::unique_ptr<FILE, decltype(&fclose)> fp{fopen("/proc/loadavg", "re"), fclose};
949 ASSERT_EQ(3, fscanf(fp.get(), "%lf %lf %lf", &expected[0], &expected[1], &expected[2]));
950 load[0] = load[1] = load[2] = nan("");
951 ASSERT_EQ(3, getloadavg(load, 3));
952
953 // Check that getloadavg(3) at least overwrote the NaNs.
954 ASSERT_FALSE(isnan(load[0]));
955 ASSERT_FALSE(isnan(load[1]));
956 ASSERT_FALSE(isnan(load[2]));
957 // And that the difference between /proc/loadavg and getloadavg(3) is "small".
958 ASSERT_TRUE(fabs(expected[0] - load[0]) < 0.5) << expected[0] << ' ' << load[0];
959 ASSERT_TRUE(fabs(expected[1] - load[1]) < 0.5) << expected[1] << ' ' << load[1];
960 ASSERT_TRUE(fabs(expected[2] - load[2]) < 0.5) << expected[2] << ' ' << load[2];
961 }
962
TEST(stdlib,getprogname)963 TEST(stdlib, getprogname) {
964 #if defined(__GLIBC__)
965 GTEST_SKIP() << "glibc doesn't have getprogname()";
966 #else
967 // You should always have a name.
968 ASSERT_TRUE(getprogname() != nullptr);
969 // The name should never have a slash in it.
970 ASSERT_TRUE(strchr(getprogname(), '/') == nullptr);
971 #endif
972 }
973
TEST(stdlib,setprogname)974 TEST(stdlib, setprogname) {
975 #if defined(__GLIBC__)
976 GTEST_SKIP() << "glibc doesn't have setprogname()";
977 #else
978 // setprogname() only takes the basename of what you give it.
979 setprogname("/usr/bin/muppet");
980 ASSERT_STREQ("muppet", getprogname());
981 #endif
982 }
983