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