1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <gtest/gtest.h> 18 19 #include <errno.h> 20 #include <fcntl.h> 21 #include <limits.h> 22 #include <math.h> 23 #include <stdio.h> 24 #include <sys/types.h> 25 #include <sys/stat.h> 26 #include <unistd.h> 27 #include <wchar.h> 28 #include <locale.h> 29 30 #include <vector> 31 32 #include "BionicDeathTest.h" 33 #include "TemporaryFile.h" 34 #include "utils.h" 35 36 #if defined(NOFORTIFY) 37 #define STDIO_TEST stdio_nofortify 38 #define STDIO_DEATHTEST stdio_nofortify_DeathTest 39 #else 40 #define STDIO_TEST stdio 41 #define STDIO_DEATHTEST stdio_DeathTest 42 #endif 43 44 class stdio_DeathTest : public BionicDeathTest {}; 45 class stdio_nofortify_DeathTest : public BionicDeathTest {}; 46 47 static void AssertFileIs(FILE* fp, const char* expected, bool is_fmemopen = false) { 48 rewind(fp); 49 50 char line[1024]; 51 memset(line, 0xff, sizeof(line)); 52 ASSERT_EQ(line, fgets(line, sizeof(line), fp)); 53 ASSERT_STREQ(expected, line); 54 55 if (is_fmemopen) { 56 // fmemopen appends a trailing NUL byte, which probably shouldn't show up as an 57 // extra empty line, but does on every C library I tested... 58 ASSERT_EQ(line, fgets(line, sizeof(line), fp)); 59 ASSERT_STREQ("", line); 60 } 61 62 // Make sure there isn't anything else in the file. 63 ASSERT_EQ(nullptr, fgets(line, sizeof(line), fp)) << "junk at end of file: " << line; 64 } 65 66 TEST(STDIO_TEST, flockfile_18208568_stderr) { 67 // Check that we have a _recursive_ mutex for flockfile. 68 flockfile(stderr); 69 feof(stderr); // We don't care about the result, but this needs to take the lock. 70 funlockfile(stderr); 71 } 72 73 TEST(STDIO_TEST, flockfile_18208568_regular) { 74 // We never had a bug for streams other than stdin/stdout/stderr, but test anyway. 75 FILE* fp = fopen("/dev/null", "w"); 76 ASSERT_TRUE(fp != NULL); 77 flockfile(fp); 78 feof(fp); 79 funlockfile(fp); 80 fclose(fp); 81 } 82 83 TEST(STDIO_TEST, tmpfile_fileno_fprintf_rewind_fgets) { 84 FILE* fp = tmpfile(); 85 ASSERT_TRUE(fp != NULL); 86 87 int fd = fileno(fp); 88 ASSERT_NE(fd, -1); 89 90 struct stat sb; 91 int rc = fstat(fd, &sb); 92 ASSERT_NE(rc, -1); 93 ASSERT_EQ(sb.st_mode & 0777, 0600U); 94 95 rc = fprintf(fp, "hello\n"); 96 ASSERT_EQ(rc, 6); 97 98 AssertFileIs(fp, "hello\n"); 99 fclose(fp); 100 } 101 102 TEST(STDIO_TEST, tmpfile64) { 103 FILE* fp = tmpfile64(); 104 ASSERT_TRUE(fp != nullptr); 105 fclose(fp); 106 } 107 108 TEST(STDIO_TEST, dprintf) { 109 TemporaryFile tf; 110 111 int rc = dprintf(tf.fd, "hello\n"); 112 ASSERT_EQ(rc, 6); 113 114 lseek(tf.fd, 0, SEEK_SET); 115 FILE* tfile = fdopen(tf.fd, "r"); 116 ASSERT_TRUE(tfile != NULL); 117 118 AssertFileIs(tfile, "hello\n"); 119 fclose(tfile); 120 } 121 122 TEST(STDIO_TEST, getdelim) { 123 FILE* fp = tmpfile(); 124 ASSERT_TRUE(fp != NULL); 125 126 const char* line_written = "This is a test"; 127 int rc = fprintf(fp, "%s", line_written); 128 ASSERT_EQ(rc, static_cast<int>(strlen(line_written))); 129 130 rewind(fp); 131 132 char* word_read = NULL; 133 size_t allocated_length = 0; 134 135 const char* expected[] = { "This ", " ", "is ", "a ", "test" }; 136 for (size_t i = 0; i < 5; ++i) { 137 ASSERT_FALSE(feof(fp)); 138 ASSERT_EQ(getdelim(&word_read, &allocated_length, ' ', fp), static_cast<int>(strlen(expected[i]))); 139 ASSERT_GE(allocated_length, strlen(expected[i])); 140 ASSERT_STREQ(expected[i], word_read); 141 } 142 // The last read should have set the end-of-file indicator for the stream. 143 ASSERT_TRUE(feof(fp)); 144 clearerr(fp); 145 146 // getdelim returns -1 but doesn't set errno if we're already at EOF. 147 // It should set the end-of-file indicator for the stream, though. 148 errno = 0; 149 ASSERT_EQ(getdelim(&word_read, &allocated_length, ' ', fp), -1); 150 ASSERT_EQ(0, errno); 151 ASSERT_TRUE(feof(fp)); 152 153 free(word_read); 154 fclose(fp); 155 } 156 157 TEST(STDIO_TEST, getdelim_invalid) { 158 FILE* fp = tmpfile(); 159 ASSERT_TRUE(fp != NULL); 160 161 char* buffer = NULL; 162 size_t buffer_length = 0; 163 164 // The first argument can't be NULL. 165 errno = 0; 166 ASSERT_EQ(getdelim(NULL, &buffer_length, ' ', fp), -1); 167 ASSERT_EQ(EINVAL, errno); 168 169 // The second argument can't be NULL. 170 errno = 0; 171 ASSERT_EQ(getdelim(&buffer, NULL, ' ', fp), -1); 172 ASSERT_EQ(EINVAL, errno); 173 174 // The underlying fd can't be closed. 175 ASSERT_EQ(0, close(fileno(fp))); 176 errno = 0; 177 ASSERT_EQ(getdelim(&buffer, &buffer_length, ' ', fp), -1); 178 ASSERT_EQ(EBADF, errno); 179 fclose(fp); 180 } 181 182 TEST(STDIO_TEST, getdelim_directory) { 183 FILE* fp = fopen("/proc", "r"); 184 ASSERT_TRUE(fp != NULL); 185 char* word_read; 186 size_t allocated_length; 187 ASSERT_EQ(-1, getdelim(&word_read, &allocated_length, ' ', fp)); 188 fclose(fp); 189 } 190 191 TEST(STDIO_TEST, getline) { 192 FILE* fp = tmpfile(); 193 ASSERT_TRUE(fp != NULL); 194 195 const char* line_written = "This is a test for getline\n"; 196 const size_t line_count = 5; 197 198 for (size_t i = 0; i < line_count; ++i) { 199 int rc = fprintf(fp, "%s", line_written); 200 ASSERT_EQ(rc, static_cast<int>(strlen(line_written))); 201 } 202 203 rewind(fp); 204 205 char* line_read = NULL; 206 size_t allocated_length = 0; 207 208 size_t read_line_count = 0; 209 ssize_t read_char_count; 210 while ((read_char_count = getline(&line_read, &allocated_length, fp)) != -1) { 211 ASSERT_EQ(read_char_count, static_cast<int>(strlen(line_written))); 212 ASSERT_GE(allocated_length, strlen(line_written)); 213 ASSERT_STREQ(line_written, line_read); 214 ++read_line_count; 215 } 216 ASSERT_EQ(read_line_count, line_count); 217 218 // The last read should have set the end-of-file indicator for the stream. 219 ASSERT_TRUE(feof(fp)); 220 clearerr(fp); 221 222 // getline returns -1 but doesn't set errno if we're already at EOF. 223 // It should set the end-of-file indicator for the stream, though. 224 errno = 0; 225 ASSERT_EQ(getline(&line_read, &allocated_length, fp), -1); 226 ASSERT_EQ(0, errno); 227 ASSERT_TRUE(feof(fp)); 228 229 free(line_read); 230 fclose(fp); 231 } 232 233 TEST(STDIO_TEST, getline_invalid) { 234 FILE* fp = tmpfile(); 235 ASSERT_TRUE(fp != NULL); 236 237 char* buffer = NULL; 238 size_t buffer_length = 0; 239 240 // The first argument can't be NULL. 241 errno = 0; 242 ASSERT_EQ(getline(NULL, &buffer_length, fp), -1); 243 ASSERT_EQ(EINVAL, errno); 244 245 // The second argument can't be NULL. 246 errno = 0; 247 ASSERT_EQ(getline(&buffer, NULL, fp), -1); 248 ASSERT_EQ(EINVAL, errno); 249 250 // The underlying fd can't be closed. 251 ASSERT_EQ(0, close(fileno(fp))); 252 errno = 0; 253 ASSERT_EQ(getline(&buffer, &buffer_length, fp), -1); 254 ASSERT_EQ(EBADF, errno); 255 fclose(fp); 256 } 257 258 TEST(STDIO_TEST, printf_ssize_t) { 259 // http://b/8253769 260 ASSERT_EQ(sizeof(ssize_t), sizeof(long int)); 261 ASSERT_EQ(sizeof(ssize_t), sizeof(size_t)); 262 // For our 32-bit ABI, we had a ssize_t definition that confuses GCC into saying: 263 // error: format '%zd' expects argument of type 'signed size_t', 264 // but argument 4 has type 'ssize_t {aka long int}' [-Werror=format] 265 ssize_t v = 1; 266 char buf[32]; 267 snprintf(buf, sizeof(buf), "%zd", v); 268 } 269 270 // https://code.google.com/p/android/issues/detail?id=64886 271 TEST(STDIO_TEST, snprintf_a) { 272 char buf[BUFSIZ]; 273 EXPECT_EQ(23, snprintf(buf, sizeof(buf), "<%a>", 9990.235)); 274 EXPECT_STREQ("<0x1.3831e147ae148p+13>", buf); 275 } 276 277 TEST(STDIO_TEST, snprintf_lc) { 278 char buf[BUFSIZ]; 279 wint_t wc = L'a'; 280 EXPECT_EQ(3, snprintf(buf, sizeof(buf), "<%lc>", wc)); 281 EXPECT_STREQ("<a>", buf); 282 } 283 284 TEST(STDIO_TEST, snprintf_ls) { 285 char buf[BUFSIZ]; 286 wchar_t* ws = NULL; 287 EXPECT_EQ(8, snprintf(buf, sizeof(buf), "<%ls>", ws)); 288 EXPECT_STREQ("<(null)>", buf); 289 290 wchar_t chars[] = { L'h', L'i', 0 }; 291 ws = chars; 292 EXPECT_EQ(4, snprintf(buf, sizeof(buf), "<%ls>", ws)); 293 EXPECT_STREQ("<hi>", buf); 294 } 295 296 TEST(STDIO_TEST, snprintf_n) { 297 #if defined(__BIONIC__) 298 // http://b/14492135 299 char buf[32]; 300 int i = 1234; 301 EXPECT_EQ(5, snprintf(buf, sizeof(buf), "a %n b", &i)); 302 EXPECT_EQ(1234, i); 303 EXPECT_STREQ("a n b", buf); 304 #else 305 GTEST_LOG_(INFO) << "This test does nothing on glibc.\n"; 306 #endif 307 } 308 309 TEST(STDIO_TEST, snprintf_smoke) { 310 char buf[BUFSIZ]; 311 312 snprintf(buf, sizeof(buf), "a"); 313 EXPECT_STREQ("a", buf); 314 315 snprintf(buf, sizeof(buf), "%%"); 316 EXPECT_STREQ("%", buf); 317 318 snprintf(buf, sizeof(buf), "01234"); 319 EXPECT_STREQ("01234", buf); 320 321 snprintf(buf, sizeof(buf), "a%sb", "01234"); 322 EXPECT_STREQ("a01234b", buf); 323 324 char* s = NULL; 325 snprintf(buf, sizeof(buf), "a%sb", s); 326 EXPECT_STREQ("a(null)b", buf); 327 328 snprintf(buf, sizeof(buf), "aa%scc", "bb"); 329 EXPECT_STREQ("aabbcc", buf); 330 331 snprintf(buf, sizeof(buf), "a%cc", 'b'); 332 EXPECT_STREQ("abc", buf); 333 334 snprintf(buf, sizeof(buf), "a%db", 1234); 335 EXPECT_STREQ("a1234b", buf); 336 337 snprintf(buf, sizeof(buf), "a%db", -8123); 338 EXPECT_STREQ("a-8123b", buf); 339 340 snprintf(buf, sizeof(buf), "a%hdb", static_cast<short>(0x7fff0010)); 341 EXPECT_STREQ("a16b", buf); 342 343 snprintf(buf, sizeof(buf), "a%hhdb", static_cast<char>(0x7fffff10)); 344 EXPECT_STREQ("a16b", buf); 345 346 snprintf(buf, sizeof(buf), "a%lldb", 0x1000000000LL); 347 EXPECT_STREQ("a68719476736b", buf); 348 349 snprintf(buf, sizeof(buf), "a%ldb", 70000L); 350 EXPECT_STREQ("a70000b", buf); 351 352 snprintf(buf, sizeof(buf), "a%pb", reinterpret_cast<void*>(0xb0001234)); 353 EXPECT_STREQ("a0xb0001234b", buf); 354 355 snprintf(buf, sizeof(buf), "a%xz", 0x12ab); 356 EXPECT_STREQ("a12abz", buf); 357 358 snprintf(buf, sizeof(buf), "a%Xz", 0x12ab); 359 EXPECT_STREQ("a12ABz", buf); 360 361 snprintf(buf, sizeof(buf), "a%08xz", 0x123456); 362 EXPECT_STREQ("a00123456z", buf); 363 364 snprintf(buf, sizeof(buf), "a%5dz", 1234); 365 EXPECT_STREQ("a 1234z", buf); 366 367 snprintf(buf, sizeof(buf), "a%05dz", 1234); 368 EXPECT_STREQ("a01234z", buf); 369 370 snprintf(buf, sizeof(buf), "a%8dz", 1234); 371 EXPECT_STREQ("a 1234z", buf); 372 373 snprintf(buf, sizeof(buf), "a%-8dz", 1234); 374 EXPECT_STREQ("a1234 z", buf); 375 376 snprintf(buf, sizeof(buf), "A%-11sZ", "abcdef"); 377 EXPECT_STREQ("Aabcdef Z", buf); 378 379 snprintf(buf, sizeof(buf), "A%s:%dZ", "hello", 1234); 380 EXPECT_STREQ("Ahello:1234Z", buf); 381 382 snprintf(buf, sizeof(buf), "a%03d:%d:%02dz", 5, 5, 5); 383 EXPECT_STREQ("a005:5:05z", buf); 384 385 void* p = NULL; 386 snprintf(buf, sizeof(buf), "a%d,%pz", 5, p); 387 #if defined(__BIONIC__) 388 EXPECT_STREQ("a5,0x0z", buf); 389 #else // __BIONIC__ 390 EXPECT_STREQ("a5,(nil)z", buf); 391 #endif // __BIONIC__ 392 393 snprintf(buf, sizeof(buf), "a%lld,%d,%d,%dz", 0x1000000000LL, 6, 7, 8); 394 EXPECT_STREQ("a68719476736,6,7,8z", buf); 395 396 snprintf(buf, sizeof(buf), "a_%f_b", 1.23f); 397 EXPECT_STREQ("a_1.230000_b", buf); 398 399 snprintf(buf, sizeof(buf), "a_%g_b", 3.14); 400 EXPECT_STREQ("a_3.14_b", buf); 401 402 snprintf(buf, sizeof(buf), "%1$s %1$s", "print_me_twice"); 403 EXPECT_STREQ("print_me_twice print_me_twice", buf); 404 } 405 406 template <typename T> 407 static void CheckInfNan(int snprintf_fn(T*, size_t, const T*, ...), 408 int sscanf_fn(const T*, const T*, ...), 409 const T* fmt_string, const T* fmt, const T* fmt_plus, 410 const T* minus_inf, const T* inf_, const T* plus_inf, 411 const T* minus_nan, const T* nan_, const T* plus_nan) { 412 T buf[BUFSIZ]; 413 float f; 414 415 // NaN. 416 417 snprintf_fn(buf, sizeof(buf), fmt, nanf("")); 418 EXPECT_STREQ(nan_, buf) << fmt; 419 EXPECT_EQ(1, sscanf_fn(buf, fmt, &f)); 420 EXPECT_TRUE(isnan(f)); 421 422 snprintf_fn(buf, sizeof(buf), fmt, -nanf("")); 423 EXPECT_STREQ(minus_nan, buf) << fmt; 424 EXPECT_EQ(1, sscanf_fn(buf, fmt, &f)); 425 EXPECT_TRUE(isnan(f)); 426 427 snprintf_fn(buf, sizeof(buf), fmt_plus, nanf("")); 428 EXPECT_STREQ(plus_nan, buf) << fmt_plus; 429 EXPECT_EQ(1, sscanf_fn(buf, fmt, &f)); 430 EXPECT_TRUE(isnan(f)); 431 432 snprintf_fn(buf, sizeof(buf), fmt_plus, -nanf("")); 433 EXPECT_STREQ(minus_nan, buf) << fmt_plus; 434 EXPECT_EQ(1, sscanf_fn(buf, fmt, &f)); 435 EXPECT_TRUE(isnan(f)); 436 437 // Inf. 438 439 snprintf_fn(buf, sizeof(buf), fmt, HUGE_VALF); 440 EXPECT_STREQ(inf_, buf) << fmt; 441 EXPECT_EQ(1, sscanf_fn(buf, fmt, &f)); 442 EXPECT_EQ(HUGE_VALF, f); 443 444 snprintf_fn(buf, sizeof(buf), fmt, -HUGE_VALF); 445 EXPECT_STREQ(minus_inf, buf) << fmt; 446 EXPECT_EQ(1, sscanf_fn(buf, fmt, &f)); 447 EXPECT_EQ(-HUGE_VALF, f); 448 449 snprintf_fn(buf, sizeof(buf), fmt_plus, HUGE_VALF); 450 EXPECT_STREQ(plus_inf, buf) << fmt_plus; 451 EXPECT_EQ(1, sscanf_fn(buf, fmt, &f)); 452 EXPECT_EQ(HUGE_VALF, f); 453 454 snprintf_fn(buf, sizeof(buf), fmt_plus, -HUGE_VALF); 455 EXPECT_STREQ(minus_inf, buf) << fmt_plus; 456 EXPECT_EQ(1, sscanf_fn(buf, fmt, &f)); 457 EXPECT_EQ(-HUGE_VALF, f); 458 459 // Check case-insensitivity. 460 snprintf_fn(buf, sizeof(buf), fmt_string, "[InFiNiTy]"); 461 EXPECT_EQ(1, sscanf_fn(buf, fmt, &f)) << buf; 462 EXPECT_EQ(HUGE_VALF, f); 463 snprintf_fn(buf, sizeof(buf), fmt_string, "[NaN]"); 464 EXPECT_EQ(1, sscanf_fn(buf, fmt, &f)) << buf; 465 EXPECT_TRUE(isnan(f)); 466 } 467 468 TEST(STDIO_TEST, snprintf_sscanf_inf_nan) { 469 CheckInfNan(snprintf, sscanf, "%s", 470 "[%a]", "[%+a]", 471 "[-inf]", "[inf]", "[+inf]", 472 "[-nan]", "[nan]", "[+nan]"); 473 CheckInfNan(snprintf, sscanf, "%s", 474 "[%A]", "[%+A]", 475 "[-INF]", "[INF]", "[+INF]", 476 "[-NAN]", "[NAN]", "[+NAN]"); 477 CheckInfNan(snprintf, sscanf, "%s", 478 "[%e]", "[%+e]", 479 "[-inf]", "[inf]", "[+inf]", 480 "[-nan]", "[nan]", "[+nan]"); 481 CheckInfNan(snprintf, sscanf, "%s", 482 "[%E]", "[%+E]", 483 "[-INF]", "[INF]", "[+INF]", 484 "[-NAN]", "[NAN]", "[+NAN]"); 485 CheckInfNan(snprintf, sscanf, "%s", 486 "[%f]", "[%+f]", 487 "[-inf]", "[inf]", "[+inf]", 488 "[-nan]", "[nan]", "[+nan]"); 489 CheckInfNan(snprintf, sscanf, "%s", 490 "[%F]", "[%+F]", 491 "[-INF]", "[INF]", "[+INF]", 492 "[-NAN]", "[NAN]", "[+NAN]"); 493 CheckInfNan(snprintf, sscanf, "%s", 494 "[%g]", "[%+g]", 495 "[-inf]", "[inf]", "[+inf]", 496 "[-nan]", "[nan]", "[+nan]"); 497 CheckInfNan(snprintf, sscanf, "%s", 498 "[%G]", "[%+G]", 499 "[-INF]", "[INF]", "[+INF]", 500 "[-NAN]", "[NAN]", "[+NAN]"); 501 } 502 503 TEST(STDIO_TEST, swprintf_swscanf_inf_nan) { 504 CheckInfNan(swprintf, swscanf, L"%s", 505 L"[%a]", L"[%+a]", 506 L"[-inf]", L"[inf]", L"[+inf]", 507 L"[-nan]", L"[nan]", L"[+nan]"); 508 CheckInfNan(swprintf, swscanf, L"%s", 509 L"[%A]", L"[%+A]", 510 L"[-INF]", L"[INF]", L"[+INF]", 511 L"[-NAN]", L"[NAN]", L"[+NAN]"); 512 CheckInfNan(swprintf, swscanf, L"%s", 513 L"[%e]", L"[%+e]", 514 L"[-inf]", L"[inf]", L"[+inf]", 515 L"[-nan]", L"[nan]", L"[+nan]"); 516 CheckInfNan(swprintf, swscanf, L"%s", 517 L"[%E]", L"[%+E]", 518 L"[-INF]", L"[INF]", L"[+INF]", 519 L"[-NAN]", L"[NAN]", L"[+NAN]"); 520 CheckInfNan(swprintf, swscanf, L"%s", 521 L"[%f]", L"[%+f]", 522 L"[-inf]", L"[inf]", L"[+inf]", 523 L"[-nan]", L"[nan]", L"[+nan]"); 524 CheckInfNan(swprintf, swscanf, L"%s", 525 L"[%F]", L"[%+F]", 526 L"[-INF]", L"[INF]", L"[+INF]", 527 L"[-NAN]", L"[NAN]", L"[+NAN]"); 528 CheckInfNan(swprintf, swscanf, L"%s", 529 L"[%g]", L"[%+g]", 530 L"[-inf]", L"[inf]", L"[+inf]", 531 L"[-nan]", L"[nan]", L"[+nan]"); 532 CheckInfNan(swprintf, swscanf, L"%s", 533 L"[%G]", L"[%+G]", 534 L"[-INF]", L"[INF]", L"[+INF]", 535 L"[-NAN]", L"[NAN]", L"[+NAN]"); 536 } 537 538 TEST(STDIO_TEST, snprintf_d_INT_MAX) { 539 char buf[BUFSIZ]; 540 snprintf(buf, sizeof(buf), "%d", INT_MAX); 541 EXPECT_STREQ("2147483647", buf); 542 } 543 544 TEST(STDIO_TEST, snprintf_d_INT_MIN) { 545 char buf[BUFSIZ]; 546 snprintf(buf, sizeof(buf), "%d", INT_MIN); 547 EXPECT_STREQ("-2147483648", buf); 548 } 549 550 TEST(STDIO_TEST, snprintf_ld_LONG_MAX) { 551 char buf[BUFSIZ]; 552 snprintf(buf, sizeof(buf), "%ld", LONG_MAX); 553 #if defined(__LP64__) 554 EXPECT_STREQ("9223372036854775807", buf); 555 #else 556 EXPECT_STREQ("2147483647", buf); 557 #endif 558 } 559 560 TEST(STDIO_TEST, snprintf_ld_LONG_MIN) { 561 char buf[BUFSIZ]; 562 snprintf(buf, sizeof(buf), "%ld", LONG_MIN); 563 #if defined(__LP64__) 564 EXPECT_STREQ("-9223372036854775808", buf); 565 #else 566 EXPECT_STREQ("-2147483648", buf); 567 #endif 568 } 569 570 TEST(STDIO_TEST, snprintf_lld_LLONG_MAX) { 571 char buf[BUFSIZ]; 572 snprintf(buf, sizeof(buf), "%lld", LLONG_MAX); 573 EXPECT_STREQ("9223372036854775807", buf); 574 } 575 576 TEST(STDIO_TEST, snprintf_lld_LLONG_MIN) { 577 char buf[BUFSIZ]; 578 snprintf(buf, sizeof(buf), "%lld", LLONG_MIN); 579 EXPECT_STREQ("-9223372036854775808", buf); 580 } 581 582 TEST(STDIO_TEST, snprintf_e) { 583 char buf[BUFSIZ]; 584 585 snprintf(buf, sizeof(buf), "%e", 1.5); 586 EXPECT_STREQ("1.500000e+00", buf); 587 588 snprintf(buf, sizeof(buf), "%Le", 1.5l); 589 EXPECT_STREQ("1.500000e+00", buf); 590 } 591 592 TEST(STDIO_TEST, snprintf_negative_zero_5084292) { 593 char buf[BUFSIZ]; 594 595 snprintf(buf, sizeof(buf), "%e", -0.0); 596 EXPECT_STREQ("-0.000000e+00", buf); 597 snprintf(buf, sizeof(buf), "%E", -0.0); 598 EXPECT_STREQ("-0.000000E+00", buf); 599 snprintf(buf, sizeof(buf), "%f", -0.0); 600 EXPECT_STREQ("-0.000000", buf); 601 snprintf(buf, sizeof(buf), "%F", -0.0); 602 EXPECT_STREQ("-0.000000", buf); 603 snprintf(buf, sizeof(buf), "%g", -0.0); 604 EXPECT_STREQ("-0", buf); 605 snprintf(buf, sizeof(buf), "%G", -0.0); 606 EXPECT_STREQ("-0", buf); 607 snprintf(buf, sizeof(buf), "%a", -0.0); 608 EXPECT_STREQ("-0x0p+0", buf); 609 snprintf(buf, sizeof(buf), "%A", -0.0); 610 EXPECT_STREQ("-0X0P+0", buf); 611 } 612 613 TEST(STDIO_TEST, snprintf_utf8_15439554) { 614 locale_t cloc = newlocale(LC_ALL, "C.UTF-8", 0); 615 locale_t old_locale = uselocale(cloc); 616 617 // http://b/15439554 618 char buf[BUFSIZ]; 619 620 // 1-byte character. 621 snprintf(buf, sizeof(buf), "%dx%d", 1, 2); 622 EXPECT_STREQ("1x2", buf); 623 // 2-byte character. 624 snprintf(buf, sizeof(buf), "%d\xc2\xa2%d", 1, 2); 625 EXPECT_STREQ("12", buf); 626 // 3-byte character. 627 snprintf(buf, sizeof(buf), "%d\xe2\x82\xac%d", 1, 2); 628 EXPECT_STREQ("12", buf); 629 // 4-byte character. 630 snprintf(buf, sizeof(buf), "%d\xf0\xa4\xad\xa2%d", 1, 2); 631 EXPECT_STREQ("12", buf); 632 633 uselocale(old_locale); 634 freelocale(cloc); 635 } 636 637 static void* snprintf_small_stack_fn(void*) { 638 // Make life (realistically) hard for ourselves by allocating our own buffer for the result. 639 char buf[PATH_MAX]; 640 snprintf(buf, sizeof(buf), "/proc/%d", getpid()); 641 return nullptr; 642 } 643 644 TEST(STDIO_TEST, snprintf_small_stack) { 645 // Is it safe to call snprintf on a thread with a small stack? 646 // (The snprintf implementation puts some pretty large buffers on the stack.) 647 pthread_attr_t a; 648 ASSERT_EQ(0, pthread_attr_init(&a)); 649 ASSERT_EQ(0, pthread_attr_setstacksize(&a, PTHREAD_STACK_MIN)); 650 651 pthread_t t; 652 ASSERT_EQ(0, pthread_create(&t, &a, snprintf_small_stack_fn, nullptr)); 653 ASSERT_EQ(0, pthread_join(t, nullptr)); 654 } 655 656 TEST(STDIO_TEST, snprintf_asterisk_overflow) { 657 char buf[128]; 658 ASSERT_EQ(5, snprintf(buf, sizeof(buf), "%.*s%c", 4, "hello world", '!')); 659 ASSERT_EQ(12, snprintf(buf, sizeof(buf), "%.*s%c", INT_MAX/2, "hello world", '!')); 660 ASSERT_EQ(12, snprintf(buf, sizeof(buf), "%.*s%c", INT_MAX-1, "hello world", '!')); 661 ASSERT_EQ(12, snprintf(buf, sizeof(buf), "%.*s%c", INT_MAX, "hello world", '!')); 662 ASSERT_EQ(12, snprintf(buf, sizeof(buf), "%.*s%c", -1, "hello world", '!')); 663 664 // INT_MAX-1, INT_MAX, INT_MAX+1. 665 ASSERT_EQ(12, snprintf(buf, sizeof(buf), "%.2147483646s%c", "hello world", '!')); 666 ASSERT_EQ(12, snprintf(buf, sizeof(buf), "%.2147483647s%c", "hello world", '!')); 667 ASSERT_EQ(-1, snprintf(buf, sizeof(buf), "%.2147483648s%c", "hello world", '!')); 668 ASSERT_EQ(ENOMEM, errno); 669 } 670 671 TEST(STDIO_TEST, fprintf) { 672 TemporaryFile tf; 673 674 FILE* tfile = fdopen(tf.fd, "r+"); 675 ASSERT_TRUE(tfile != nullptr); 676 677 ASSERT_EQ(7, fprintf(tfile, "%d %s", 123, "abc")); 678 AssertFileIs(tfile, "123 abc"); 679 fclose(tfile); 680 } 681 682 TEST(STDIO_TEST, fprintf_failures_7229520) { 683 // http://b/7229520 684 FILE* fp; 685 686 // Unbuffered case where the fprintf(3) itself fails. 687 ASSERT_NE(nullptr, fp = tmpfile()); 688 setbuf(fp, NULL); 689 ASSERT_EQ(4, fprintf(fp, "epic")); 690 ASSERT_EQ(0, close(fileno(fp))); 691 ASSERT_EQ(-1, fprintf(fp, "fail")); 692 ASSERT_EQ(-1, fclose(fp)); 693 694 // Buffered case where we won't notice until the fclose(3). 695 // It's likely this is what was actually seen in http://b/7229520, 696 // and that expecting fprintf to fail is setting yourself up for 697 // disappointment. Remember to check fclose(3)'s return value, kids! 698 ASSERT_NE(nullptr, fp = tmpfile()); 699 ASSERT_EQ(4, fprintf(fp, "epic")); 700 ASSERT_EQ(0, close(fileno(fp))); 701 ASSERT_EQ(4, fprintf(fp, "fail")); 702 ASSERT_EQ(-1, fclose(fp)); 703 } 704 705 TEST(STDIO_TEST, popen) { 706 FILE* fp = popen("cat /proc/version", "r"); 707 ASSERT_TRUE(fp != NULL); 708 709 char buf[16]; 710 char* s = fgets(buf, sizeof(buf), fp); 711 buf[13] = '\0'; 712 ASSERT_STREQ("Linux version", s); 713 714 ASSERT_EQ(0, pclose(fp)); 715 } 716 717 TEST(STDIO_TEST, getc) { 718 FILE* fp = fopen("/proc/version", "r"); 719 ASSERT_TRUE(fp != NULL); 720 ASSERT_EQ('L', getc(fp)); 721 ASSERT_EQ('i', getc(fp)); 722 ASSERT_EQ('n', getc(fp)); 723 ASSERT_EQ('u', getc(fp)); 724 ASSERT_EQ('x', getc(fp)); 725 fclose(fp); 726 } 727 728 TEST(STDIO_TEST, putc) { 729 FILE* fp = fopen("/proc/version", "r"); 730 ASSERT_TRUE(fp != NULL); 731 ASSERT_EQ(EOF, putc('x', fp)); 732 fclose(fp); 733 } 734 735 TEST(STDIO_TEST, sscanf_swscanf) { 736 struct stuff { 737 char s1[123]; 738 int i1; 739 double d1; 740 float f1; 741 char s2[123]; 742 743 void Check() { 744 ASSERT_STREQ("hello", s1); 745 ASSERT_EQ(123, i1); 746 ASSERT_DOUBLE_EQ(1.23, d1); 747 ASSERT_FLOAT_EQ(9.0f, f1); 748 ASSERT_STREQ("world", s2); 749 } 750 } s; 751 752 memset(&s, 0, sizeof(s)); 753 ASSERT_EQ(5, sscanf(" hello 123 1.23 0x1.2p3 world", 754 "%s %i %lf %f %s", 755 s.s1, &s.i1, &s.d1, &s.f1, s.s2)); 756 s.Check(); 757 758 memset(&s, 0, sizeof(s)); 759 ASSERT_EQ(5, swscanf(L" hello 123 1.23 0x1.2p3 world", 760 L"%s %i %lf %f %s", 761 s.s1, &s.i1, &s.d1, &s.f1, s.s2)); 762 s.Check(); 763 } 764 765 TEST(STDIO_TEST, cantwrite_EBADF) { 766 // If we open a file read-only... 767 FILE* fp = fopen("/proc/version", "r"); 768 769 // ...all attempts to write to that file should return failure. 770 771 // They should also set errno to EBADF. This isn't POSIX, but it's traditional. 772 // glibc gets the wide-character functions wrong. 773 774 errno = 0; 775 EXPECT_EQ(EOF, putc('x', fp)); 776 EXPECT_EQ(EBADF, errno); 777 778 errno = 0; 779 EXPECT_EQ(EOF, fprintf(fp, "hello")); 780 EXPECT_EQ(EBADF, errno); 781 782 errno = 0; 783 EXPECT_EQ(EOF, fwprintf(fp, L"hello")); 784 #if defined(__BIONIC__) 785 EXPECT_EQ(EBADF, errno); 786 #endif 787 788 errno = 0; 789 EXPECT_EQ(0U, fwrite("hello", 1, 2, fp)); 790 EXPECT_EQ(EBADF, errno); 791 792 errno = 0; 793 EXPECT_EQ(EOF, fputs("hello", fp)); 794 EXPECT_EQ(EBADF, errno); 795 796 errno = 0; 797 EXPECT_EQ(WEOF, fputwc(L'x', fp)); 798 #if defined(__BIONIC__) 799 EXPECT_EQ(EBADF, errno); 800 #endif 801 } 802 803 // Tests that we can only have a consistent and correct fpos_t when using 804 // f*pos functions (i.e. fpos doesn't get inside a multi byte character). 805 TEST(STDIO_TEST, consistent_fpos_t) { 806 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8")); 807 uselocale(LC_GLOBAL_LOCALE); 808 809 FILE* fp = tmpfile(); 810 ASSERT_TRUE(fp != NULL); 811 812 wchar_t mb_one_bytes = L'h'; 813 wchar_t mb_two_bytes = 0x00a2; 814 wchar_t mb_three_bytes = 0x20ac; 815 wchar_t mb_four_bytes = 0x24b62; 816 817 // Write to file. 818 ASSERT_EQ(mb_one_bytes, static_cast<wchar_t>(fputwc(mb_one_bytes, fp))); 819 ASSERT_EQ(mb_two_bytes, static_cast<wchar_t>(fputwc(mb_two_bytes, fp))); 820 ASSERT_EQ(mb_three_bytes, static_cast<wchar_t>(fputwc(mb_three_bytes, fp))); 821 ASSERT_EQ(mb_four_bytes, static_cast<wchar_t>(fputwc(mb_four_bytes, fp))); 822 823 rewind(fp); 824 825 // Record each character position. 826 fpos_t pos1; 827 fpos_t pos2; 828 fpos_t pos3; 829 fpos_t pos4; 830 fpos_t pos5; 831 EXPECT_EQ(0, fgetpos(fp, &pos1)); 832 ASSERT_EQ(mb_one_bytes, static_cast<wchar_t>(fgetwc(fp))); 833 EXPECT_EQ(0, fgetpos(fp, &pos2)); 834 ASSERT_EQ(mb_two_bytes, static_cast<wchar_t>(fgetwc(fp))); 835 EXPECT_EQ(0, fgetpos(fp, &pos3)); 836 ASSERT_EQ(mb_three_bytes, static_cast<wchar_t>(fgetwc(fp))); 837 EXPECT_EQ(0, fgetpos(fp, &pos4)); 838 ASSERT_EQ(mb_four_bytes, static_cast<wchar_t>(fgetwc(fp))); 839 EXPECT_EQ(0, fgetpos(fp, &pos5)); 840 841 #if defined(__BIONIC__) 842 // Bionic's fpos_t is just an alias for off_t. This is inherited from OpenBSD 843 // upstream. Glibc differs by storing the mbstate_t inside its fpos_t. In 844 // Bionic (and upstream OpenBSD) the mbstate_t is stored inside the FILE 845 // structure. 846 ASSERT_EQ(0, static_cast<off_t>(pos1)); 847 ASSERT_EQ(1, static_cast<off_t>(pos2)); 848 ASSERT_EQ(3, static_cast<off_t>(pos3)); 849 ASSERT_EQ(6, static_cast<off_t>(pos4)); 850 ASSERT_EQ(10, static_cast<off_t>(pos5)); 851 #endif 852 853 // Exercise back and forth movements of the position. 854 ASSERT_EQ(0, fsetpos(fp, &pos2)); 855 ASSERT_EQ(mb_two_bytes, static_cast<wchar_t>(fgetwc(fp))); 856 ASSERT_EQ(0, fsetpos(fp, &pos1)); 857 ASSERT_EQ(mb_one_bytes, static_cast<wchar_t>(fgetwc(fp))); 858 ASSERT_EQ(0, fsetpos(fp, &pos4)); 859 ASSERT_EQ(mb_four_bytes, static_cast<wchar_t>(fgetwc(fp))); 860 ASSERT_EQ(0, fsetpos(fp, &pos3)); 861 ASSERT_EQ(mb_three_bytes, static_cast<wchar_t>(fgetwc(fp))); 862 ASSERT_EQ(0, fsetpos(fp, &pos5)); 863 ASSERT_EQ(WEOF, fgetwc(fp)); 864 865 fclose(fp); 866 } 867 868 // Exercise the interaction between fpos and seek. 869 TEST(STDIO_TEST, fpos_t_and_seek) { 870 ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8")); 871 uselocale(LC_GLOBAL_LOCALE); 872 873 // In glibc-2.16 fseek doesn't work properly in wide mode 874 // (https://sourceware.org/bugzilla/show_bug.cgi?id=14543). One workaround is 875 // to close and re-open the file. We do it in order to make the test pass 876 // with all glibcs. 877 878 TemporaryFile tf; 879 FILE* fp = fdopen(tf.fd, "w+"); 880 ASSERT_TRUE(fp != NULL); 881 882 wchar_t mb_two_bytes = 0x00a2; 883 wchar_t mb_three_bytes = 0x20ac; 884 wchar_t mb_four_bytes = 0x24b62; 885 886 // Write to file. 887 ASSERT_EQ(mb_two_bytes, static_cast<wchar_t>(fputwc(mb_two_bytes, fp))); 888 ASSERT_EQ(mb_three_bytes, static_cast<wchar_t>(fputwc(mb_three_bytes, fp))); 889 ASSERT_EQ(mb_four_bytes, static_cast<wchar_t>(fputwc(mb_four_bytes, fp))); 890 891 fflush(fp); 892 fclose(fp); 893 894 fp = fopen(tf.filename, "r"); 895 ASSERT_TRUE(fp != NULL); 896 897 // Store a valid position. 898 fpos_t mb_two_bytes_pos; 899 ASSERT_EQ(0, fgetpos(fp, &mb_two_bytes_pos)); 900 901 // Move inside mb_four_bytes with fseek. 902 long offset_inside_mb = 6; 903 ASSERT_EQ(0, fseek(fp, offset_inside_mb, SEEK_SET)); 904 905 // Store the "inside multi byte" position. 906 fpos_t pos_inside_mb; 907 ASSERT_EQ(0, fgetpos(fp, &pos_inside_mb)); 908 #if defined(__BIONIC__) 909 ASSERT_EQ(offset_inside_mb, static_cast<off_t>(pos_inside_mb)); 910 #endif 911 912 // Reading from within a byte should produce an error. 913 ASSERT_EQ(WEOF, fgetwc(fp)); 914 ASSERT_EQ(EILSEQ, errno); 915 916 // Reverting to a valid position should work. 917 ASSERT_EQ(0, fsetpos(fp, &mb_two_bytes_pos)); 918 ASSERT_EQ(mb_two_bytes, static_cast<wchar_t>(fgetwc(fp))); 919 920 // Moving withing a multi byte with fsetpos should work but reading should 921 // produce an error. 922 ASSERT_EQ(0, fsetpos(fp, &pos_inside_mb)); 923 ASSERT_EQ(WEOF, fgetwc(fp)); 924 ASSERT_EQ(EILSEQ, errno); 925 926 fclose(fp); 927 } 928 929 TEST(STDIO_TEST, fmemopen) { 930 char buf[16]; 931 memset(buf, 0, sizeof(buf)); 932 FILE* fp = fmemopen(buf, sizeof(buf), "r+"); 933 ASSERT_EQ('<', fputc('<', fp)); 934 ASSERT_NE(EOF, fputs("abc>\n", fp)); 935 fflush(fp); 936 937 ASSERT_STREQ("<abc>\n", buf); 938 939 AssertFileIs(fp, "<abc>\n", true); 940 fclose(fp); 941 } 942 943 TEST(STDIO_TEST, KNOWN_FAILURE_ON_BIONIC(fmemopen_NULL)) { 944 FILE* fp = fmemopen(nullptr, 128, "r+"); 945 ASSERT_NE(EOF, fputs("xyz\n", fp)); 946 947 AssertFileIs(fp, "xyz\n", true); 948 fclose(fp); 949 } 950 951 TEST(STDIO_TEST, fmemopen_EINVAL) { 952 char buf[16]; 953 954 // Invalid size. 955 errno = 0; 956 ASSERT_EQ(nullptr, fmemopen(buf, 0, "r+")); 957 ASSERT_EQ(EINVAL, errno); 958 959 // No '+' with NULL buffer. 960 errno = 0; 961 ASSERT_EQ(nullptr, fmemopen(nullptr, 0, "r")); 962 ASSERT_EQ(EINVAL, errno); 963 } 964 965 TEST(STDIO_TEST, open_memstream) { 966 char* p = nullptr; 967 size_t size = 0; 968 FILE* fp = open_memstream(&p, &size); 969 ASSERT_NE(EOF, fputs("hello, world!", fp)); 970 fclose(fp); 971 972 ASSERT_STREQ("hello, world!", p); 973 ASSERT_EQ(strlen("hello, world!"), size); 974 free(p); 975 } 976 977 TEST(STDIO_TEST, open_memstream_EINVAL) { 978 #if defined(__BIONIC__) 979 char* p; 980 size_t size; 981 982 // Invalid buffer. 983 errno = 0; 984 ASSERT_EQ(nullptr, open_memstream(nullptr, &size)); 985 ASSERT_EQ(EINVAL, errno); 986 987 // Invalid size. 988 errno = 0; 989 ASSERT_EQ(nullptr, open_memstream(&p, nullptr)); 990 ASSERT_EQ(EINVAL, errno); 991 #else 992 GTEST_LOG_(INFO) << "This test does nothing on glibc.\n"; 993 #endif 994 } 995 996 TEST(STDIO_TEST, fdopen_CLOEXEC) { 997 int fd = open("/proc/version", O_RDONLY); 998 ASSERT_TRUE(fd != -1); 999 1000 // This fd doesn't have O_CLOEXEC... 1001 int flags = fcntl(fd, F_GETFD); 1002 ASSERT_TRUE(flags != -1); 1003 ASSERT_EQ(0, flags & FD_CLOEXEC); 1004 1005 FILE* fp = fdopen(fd, "re"); 1006 ASSERT_TRUE(fp != NULL); 1007 1008 // ...but the new one does. 1009 flags = fcntl(fileno(fp), F_GETFD); 1010 ASSERT_TRUE(flags != -1); 1011 ASSERT_EQ(FD_CLOEXEC, flags & FD_CLOEXEC); 1012 1013 fclose(fp); 1014 close(fd); 1015 } 1016 1017 TEST(STDIO_TEST, freopen_CLOEXEC) { 1018 FILE* fp = fopen("/proc/version", "r"); 1019 ASSERT_TRUE(fp != NULL); 1020 1021 // This FILE* doesn't have O_CLOEXEC... 1022 int flags = fcntl(fileno(fp), F_GETFD); 1023 ASSERT_TRUE(flags != -1); 1024 ASSERT_EQ(0, flags & FD_CLOEXEC); 1025 1026 fp = freopen("/proc/version", "re", fp); 1027 1028 // ...but the new one does. 1029 flags = fcntl(fileno(fp), F_GETFD); 1030 ASSERT_TRUE(flags != -1); 1031 ASSERT_EQ(FD_CLOEXEC, flags & FD_CLOEXEC); 1032 1033 fclose(fp); 1034 } 1035 1036 TEST(STDIO_TEST, fopen64_freopen64) { 1037 FILE* fp = fopen64("/proc/version", "r"); 1038 ASSERT_TRUE(fp != nullptr); 1039 fp = freopen64("/proc/version", "re", fp); 1040 ASSERT_TRUE(fp != nullptr); 1041 fclose(fp); 1042 } 1043 1044 // https://code.google.com/p/android/issues/detail?id=81155 1045 // http://b/18556607 1046 TEST(STDIO_TEST, fread_unbuffered_pathological_performance) { 1047 FILE* fp = fopen("/dev/zero", "r"); 1048 ASSERT_TRUE(fp != NULL); 1049 1050 // Make this stream unbuffered. 1051 setvbuf(fp, 0, _IONBF, 0); 1052 1053 char buf[65*1024]; 1054 memset(buf, 0xff, sizeof(buf)); 1055 1056 time_t t0 = time(NULL); 1057 for (size_t i = 0; i < 1024; ++i) { 1058 ASSERT_EQ(1U, fread(buf, 64*1024, 1, fp)); 1059 } 1060 time_t t1 = time(NULL); 1061 1062 fclose(fp); 1063 1064 // 1024 64KiB reads should have been very quick. 1065 ASSERT_LE(t1 - t0, 1); 1066 1067 for (size_t i = 0; i < 64*1024; ++i) { 1068 ASSERT_EQ('\0', buf[i]); 1069 } 1070 for (size_t i = 64*1024; i < 65*1024; ++i) { 1071 ASSERT_EQ('\xff', buf[i]); 1072 } 1073 } 1074 1075 TEST(STDIO_TEST, fread_EOF) { 1076 std::string digits("0123456789"); 1077 FILE* fp = fmemopen(&digits[0], digits.size(), "r"); 1078 1079 // Try to read too much, but little enough that it still fits in the FILE's internal buffer. 1080 char buf1[4 * 4]; 1081 memset(buf1, 0, sizeof(buf1)); 1082 ASSERT_EQ(2U, fread(buf1, 4, 4, fp)); 1083 ASSERT_STREQ("0123456789", buf1); 1084 ASSERT_TRUE(feof(fp)); 1085 1086 rewind(fp); 1087 1088 // Try to read way too much so stdio tries to read more direct from the stream. 1089 char buf2[4 * 4096]; 1090 memset(buf2, 0, sizeof(buf2)); 1091 ASSERT_EQ(2U, fread(buf2, 4, 4096, fp)); 1092 ASSERT_STREQ("0123456789", buf2); 1093 ASSERT_TRUE(feof(fp)); 1094 1095 fclose(fp); 1096 } 1097 1098 static void test_fread_from_write_only_stream(size_t n) { 1099 FILE* fp = fopen("/dev/null", "w"); 1100 std::vector<char> buf(n, 0); 1101 errno = 0; 1102 ASSERT_EQ(0U, fread(&buf[0], n, 1, fp)); 1103 ASSERT_EQ(EBADF, errno); 1104 ASSERT_TRUE(ferror(fp)); 1105 ASSERT_FALSE(feof(fp)); 1106 fclose(fp); 1107 } 1108 1109 TEST(STDIO_TEST, fread_from_write_only_stream_slow_path) { 1110 test_fread_from_write_only_stream(1); 1111 } 1112 1113 TEST(STDIO_TEST, fread_from_write_only_stream_fast_path) { 1114 test_fread_from_write_only_stream(64*1024); 1115 } 1116 1117 static void test_fwrite_after_fread(size_t n) { 1118 TemporaryFile tf; 1119 1120 FILE* fp = fdopen(tf.fd, "w+"); 1121 ASSERT_EQ(1U, fwrite("1", 1, 1, fp)); 1122 fflush(fp); 1123 1124 // We've flushed but not rewound, so there's nothing to read. 1125 std::vector<char> buf(n, 0); 1126 ASSERT_EQ(0U, fread(&buf[0], 1, buf.size(), fp)); 1127 ASSERT_TRUE(feof(fp)); 1128 1129 // But hitting EOF doesn't prevent us from writing... 1130 errno = 0; 1131 ASSERT_EQ(1U, fwrite("2", 1, 1, fp)) << strerror(errno); 1132 1133 // And if we rewind, everything's there. 1134 rewind(fp); 1135 ASSERT_EQ(2U, fread(&buf[0], 1, buf.size(), fp)); 1136 ASSERT_EQ('1', buf[0]); 1137 ASSERT_EQ('2', buf[1]); 1138 1139 fclose(fp); 1140 } 1141 1142 TEST(STDIO_TEST, fwrite_after_fread_slow_path) { 1143 test_fwrite_after_fread(16); 1144 } 1145 1146 TEST(STDIO_TEST, fwrite_after_fread_fast_path) { 1147 test_fwrite_after_fread(64*1024); 1148 } 1149 1150 // http://b/19172514 1151 TEST(STDIO_TEST, fread_after_fseek) { 1152 TemporaryFile tf; 1153 1154 FILE* fp = fopen(tf.filename, "w+"); 1155 ASSERT_TRUE(fp != nullptr); 1156 1157 char file_data[12288]; 1158 for (size_t i = 0; i < 12288; i++) { 1159 file_data[i] = i; 1160 } 1161 ASSERT_EQ(12288U, fwrite(file_data, 1, 12288, fp)); 1162 fclose(fp); 1163 1164 fp = fopen(tf.filename, "r"); 1165 ASSERT_TRUE(fp != nullptr); 1166 1167 char buffer[8192]; 1168 size_t cur_location = 0; 1169 // Small read to populate internal buffer. 1170 ASSERT_EQ(100U, fread(buffer, 1, 100, fp)); 1171 ASSERT_EQ(memcmp(file_data, buffer, 100), 0); 1172 1173 cur_location = static_cast<size_t>(ftell(fp)); 1174 // Large read to force reading into the user supplied buffer and bypassing 1175 // the internal buffer. 1176 ASSERT_EQ(8192U, fread(buffer, 1, 8192, fp)); 1177 ASSERT_EQ(memcmp(file_data+cur_location, buffer, 8192), 0); 1178 1179 // Small backwards seek to verify fseek does not reuse the internal buffer. 1180 ASSERT_EQ(0, fseek(fp, -22, SEEK_CUR)) << strerror(errno); 1181 cur_location = static_cast<size_t>(ftell(fp)); 1182 ASSERT_EQ(22U, fread(buffer, 1, 22, fp)); 1183 ASSERT_EQ(memcmp(file_data+cur_location, buffer, 22), 0); 1184 1185 fclose(fp); 1186 } 1187 1188 // https://code.google.com/p/android/issues/detail?id=184847 1189 TEST(STDIO_TEST, fread_EOF_184847) { 1190 TemporaryFile tf; 1191 char buf[6] = {0}; 1192 1193 FILE* fw = fopen(tf.filename, "w"); 1194 ASSERT_TRUE(fw != nullptr); 1195 1196 FILE* fr = fopen(tf.filename, "r"); 1197 ASSERT_TRUE(fr != nullptr); 1198 1199 fwrite("a", 1, 1, fw); 1200 fflush(fw); 1201 ASSERT_EQ(1U, fread(buf, 1, 1, fr)); 1202 ASSERT_STREQ("a", buf); 1203 1204 // 'fr' is now at EOF. 1205 ASSERT_EQ(0U, fread(buf, 1, 1, fr)); 1206 ASSERT_TRUE(feof(fr)); 1207 1208 // Write some more... 1209 fwrite("z", 1, 1, fw); 1210 fflush(fw); 1211 1212 // ...and check that we can read it back. 1213 // (BSD thinks that once a stream has hit EOF, it must always return EOF. SysV disagrees.) 1214 ASSERT_EQ(1U, fread(buf, 1, 1, fr)); 1215 ASSERT_STREQ("z", buf); 1216 1217 // But now we're done. 1218 ASSERT_EQ(0U, fread(buf, 1, 1, fr)); 1219 1220 fclose(fr); 1221 fclose(fw); 1222 } 1223 1224 TEST(STDIO_TEST, fclose_invalidates_fd) { 1225 // The typical error we're trying to help people catch involves accessing 1226 // memory after it's been freed. But we know that stdin/stdout/stderr are 1227 // special and don't get deallocated, so this test uses stdin. 1228 ASSERT_EQ(0, fclose(stdin)); 1229 1230 // Even though using a FILE* after close is undefined behavior, I've closed 1231 // this bug as "WAI" too many times. We shouldn't hand out stale fds, 1232 // especially because they might actually correspond to a real stream. 1233 errno = 0; 1234 ASSERT_EQ(-1, fileno(stdin)); 1235 ASSERT_EQ(EBADF, errno); 1236 } 1237 1238 TEST(STDIO_TEST, fseek_ftell_unseekable) { 1239 #if defined(__BIONIC__) // glibc has fopencookie instead. 1240 auto read_fn = [](void*, char*, int) { return -1; }; 1241 FILE* fp = funopen(nullptr, read_fn, nullptr, nullptr, nullptr); 1242 ASSERT_TRUE(fp != nullptr); 1243 1244 // Check that ftell balks on an unseekable FILE*. 1245 errno = 0; 1246 ASSERT_EQ(-1, ftell(fp)); 1247 ASSERT_EQ(ESPIPE, errno); 1248 1249 // SEEK_CUR is rewritten as SEEK_SET internally... 1250 errno = 0; 1251 ASSERT_EQ(-1, fseek(fp, 0, SEEK_CUR)); 1252 ASSERT_EQ(ESPIPE, errno); 1253 1254 // ...so it's worth testing the direct seek path too. 1255 errno = 0; 1256 ASSERT_EQ(-1, fseek(fp, 0, SEEK_SET)); 1257 ASSERT_EQ(ESPIPE, errno); 1258 1259 fclose(fp); 1260 #else 1261 GTEST_LOG_(INFO) << "glibc uses fopencookie instead.\n"; 1262 #endif 1263 } 1264 1265 TEST(STDIO_TEST, funopen_EINVAL) { 1266 #if defined(__BIONIC__) 1267 errno = 0; 1268 ASSERT_EQ(nullptr, funopen(nullptr, nullptr, nullptr, nullptr, nullptr)); 1269 ASSERT_EQ(EINVAL, errno); 1270 #else 1271 GTEST_LOG_(INFO) << "glibc uses fopencookie instead.\n"; 1272 #endif 1273 } 1274 1275 TEST(STDIO_TEST, funopen_seek) { 1276 #if defined(__BIONIC__) 1277 auto read_fn = [](void*, char*, int) { return -1; }; 1278 1279 auto seek_fn = [](void*, fpos_t, int) -> fpos_t { return 0xfedcba12; }; 1280 auto seek64_fn = [](void*, fpos64_t, int) -> fpos64_t { return 0xfedcba12345678; }; 1281 1282 FILE* fp = funopen(nullptr, read_fn, nullptr, seek_fn, nullptr); 1283 ASSERT_TRUE(fp != nullptr); 1284 fpos_t pos; 1285 #if defined(__LP64__) 1286 EXPECT_EQ(0, fgetpos(fp, &pos)) << strerror(errno); 1287 EXPECT_EQ(0xfedcba12LL, pos); 1288 #else 1289 EXPECT_EQ(-1, fgetpos(fp, &pos)) << strerror(errno); 1290 EXPECT_EQ(EOVERFLOW, errno); 1291 #endif 1292 1293 FILE* fp64 = funopen64(nullptr, read_fn, nullptr, seek64_fn, nullptr); 1294 ASSERT_TRUE(fp64 != nullptr); 1295 fpos64_t pos64; 1296 EXPECT_EQ(0, fgetpos64(fp64, &pos64)) << strerror(errno); 1297 EXPECT_EQ(0xfedcba12345678, pos64); 1298 #else 1299 GTEST_LOG_(INFO) << "glibc uses fopencookie instead.\n"; 1300 #endif 1301 } 1302 1303 TEST(STDIO_TEST, lots_of_concurrent_files) { 1304 std::vector<TemporaryFile*> tfs; 1305 std::vector<FILE*> fps; 1306 1307 for (size_t i = 0; i < 256; ++i) { 1308 TemporaryFile* tf = new TemporaryFile; 1309 tfs.push_back(tf); 1310 FILE* fp = fopen(tf->filename, "w+"); 1311 fps.push_back(fp); 1312 fprintf(fp, "hello %zu!\n", i); 1313 fflush(fp); 1314 } 1315 1316 for (size_t i = 0; i < 256; ++i) { 1317 char expected[BUFSIZ]; 1318 snprintf(expected, sizeof(expected), "hello %zu!\n", i); 1319 1320 AssertFileIs(fps[i], expected); 1321 fclose(fps[i]); 1322 delete tfs[i]; 1323 } 1324 } 1325 1326 static void AssertFileOffsetAt(FILE* fp, off64_t offset) { 1327 EXPECT_EQ(offset, ftell(fp)); 1328 EXPECT_EQ(offset, ftello(fp)); 1329 EXPECT_EQ(offset, ftello64(fp)); 1330 fpos_t pos; 1331 fpos64_t pos64; 1332 EXPECT_EQ(0, fgetpos(fp, &pos)); 1333 EXPECT_EQ(0, fgetpos64(fp, &pos64)); 1334 #if defined(__BIONIC__) 1335 EXPECT_EQ(offset, static_cast<off64_t>(pos)); 1336 EXPECT_EQ(offset, static_cast<off64_t>(pos64)); 1337 #else 1338 GTEST_LOG_(INFO) << "glibc's fpos_t is opaque.\n"; 1339 #endif 1340 } 1341 1342 TEST(STDIO_TEST, seek_tell_family_smoke) { 1343 TemporaryFile tf; 1344 FILE* fp = fdopen(tf.fd, "w+"); 1345 1346 // Initially we should be at 0. 1347 AssertFileOffsetAt(fp, 0); 1348 1349 // Seek to offset 8192. 1350 ASSERT_EQ(0, fseek(fp, 8192, SEEK_SET)); 1351 AssertFileOffsetAt(fp, 8192); 1352 fpos_t eight_k_pos; 1353 ASSERT_EQ(0, fgetpos(fp, &eight_k_pos)); 1354 1355 // Seek forward another 8192... 1356 ASSERT_EQ(0, fseek(fp, 8192, SEEK_CUR)); 1357 AssertFileOffsetAt(fp, 8192 + 8192); 1358 fpos64_t sixteen_k_pos64; 1359 ASSERT_EQ(0, fgetpos64(fp, &sixteen_k_pos64)); 1360 1361 // Seek back 8192... 1362 ASSERT_EQ(0, fseek(fp, -8192, SEEK_CUR)); 1363 AssertFileOffsetAt(fp, 8192); 1364 1365 // Since we haven't written anything, the end is also at 0. 1366 ASSERT_EQ(0, fseek(fp, 0, SEEK_END)); 1367 AssertFileOffsetAt(fp, 0); 1368 1369 // Check that our fpos64_t from 16KiB works... 1370 ASSERT_EQ(0, fsetpos64(fp, &sixteen_k_pos64)); 1371 AssertFileOffsetAt(fp, 8192 + 8192); 1372 // ...as does our fpos_t from 8192. 1373 ASSERT_EQ(0, fsetpos(fp, &eight_k_pos)); 1374 AssertFileOffsetAt(fp, 8192); 1375 1376 // Do fseeko and fseeko64 work too? 1377 ASSERT_EQ(0, fseeko(fp, 1234, SEEK_SET)); 1378 AssertFileOffsetAt(fp, 1234); 1379 ASSERT_EQ(0, fseeko64(fp, 5678, SEEK_SET)); 1380 AssertFileOffsetAt(fp, 5678); 1381 1382 fclose(fp); 1383 } 1384 1385 TEST(STDIO_TEST, fseek_fseeko_EINVAL) { 1386 TemporaryFile tf; 1387 FILE* fp = fdopen(tf.fd, "w+"); 1388 1389 // Bad whence. 1390 errno = 0; 1391 ASSERT_EQ(-1, fseek(fp, 0, 123)); 1392 ASSERT_EQ(EINVAL, errno); 1393 errno = 0; 1394 ASSERT_EQ(-1, fseeko(fp, 0, 123)); 1395 ASSERT_EQ(EINVAL, errno); 1396 errno = 0; 1397 ASSERT_EQ(-1, fseeko64(fp, 0, 123)); 1398 ASSERT_EQ(EINVAL, errno); 1399 1400 // Bad offset. 1401 errno = 0; 1402 ASSERT_EQ(-1, fseek(fp, -1, SEEK_SET)); 1403 ASSERT_EQ(EINVAL, errno); 1404 errno = 0; 1405 ASSERT_EQ(-1, fseeko(fp, -1, SEEK_SET)); 1406 ASSERT_EQ(EINVAL, errno); 1407 errno = 0; 1408 ASSERT_EQ(-1, fseeko64(fp, -1, SEEK_SET)); 1409 ASSERT_EQ(EINVAL, errno); 1410 1411 fclose(fp); 1412 } 1413 1414 TEST(STDIO_TEST, ctermid) { 1415 ASSERT_STREQ("/dev/tty", ctermid(nullptr)); 1416 1417 char buf[L_ctermid] = {}; 1418 ASSERT_EQ(buf, ctermid(buf)); 1419 ASSERT_STREQ("/dev/tty", buf); 1420 } 1421 1422 TEST(STDIO_TEST, remove) { 1423 struct stat sb; 1424 1425 TemporaryFile tf; 1426 ASSERT_EQ(0, remove(tf.filename)); 1427 ASSERT_EQ(-1, lstat(tf.filename, &sb)); 1428 ASSERT_EQ(ENOENT, errno); 1429 1430 TemporaryDir td; 1431 ASSERT_EQ(0, remove(td.dirname)); 1432 ASSERT_EQ(-1, lstat(td.dirname, &sb)); 1433 ASSERT_EQ(ENOENT, errno); 1434 1435 errno = 0; 1436 ASSERT_EQ(-1, remove(tf.filename)); 1437 ASSERT_EQ(ENOENT, errno); 1438 1439 errno = 0; 1440 ASSERT_EQ(-1, remove(td.dirname)); 1441 ASSERT_EQ(ENOENT, errno); 1442 } 1443 1444 TEST(STDIO_DEATHTEST, snprintf_30445072_known_buffer_size) { 1445 char buf[16]; 1446 ASSERT_EXIT(snprintf(buf, atol("-1"), "hello"), 1447 testing::KilledBySignal(SIGABRT), 1448 #if defined(NOFORTIFY) 1449 "FORTIFY: vsnprintf: size .* > SSIZE_MAX" 1450 #else 1451 "FORTIFY: vsnprintf: prevented .*-byte write into 16-byte buffer" 1452 #endif 1453 ); 1454 } 1455 1456 TEST(STDIO_DEATHTEST, snprintf_30445072_unknown_buffer_size) { 1457 std::string buf = "world"; 1458 ASSERT_EXIT(snprintf(&buf[0], atol("-1"), "hello"), 1459 testing::KilledBySignal(SIGABRT), 1460 "FORTIFY: vsnprintf: size .* > SSIZE_MAX"); 1461 } 1462 1463 TEST(STDIO_TEST, sprintf_30445072) { 1464 std::string buf = "world"; 1465 sprintf(&buf[0], "hello"); 1466 ASSERT_EQ(buf, "hello"); 1467 } 1468
