tests/stdio_test.cpp

   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 "TemporaryFile.h"
  31
  32 TEST(stdio, tmpfile_fileno_fprintf_rewind_fgets) {
  33   FILE* fp = tmpfile();
  34   ASSERT_TRUE(fp != NULL);
  35
  36   int fd = fileno(fp);
  37   ASSERT_NE(fd, -1);
  38
  39   struct stat sb;
  40   int rc = fstat(fd, &sb);
  41   ASSERT_NE(rc, -1);
  42   ASSERT_EQ(sb.st_mode & 0777, 0600U);
  43
  44   rc = fprintf(fp, "hello\n");
  45   ASSERT_EQ(rc, 6);
  46
  47   rewind(fp);
  48
  49   char buf[16];
  50   char* s = fgets(buf, sizeof(buf), fp);
  51   ASSERT_TRUE(s != NULL);
  52   ASSERT_STREQ("hello\n", s);
  53
  54   fclose(fp);
  55 }
  56
  57 TEST(stdio, dprintf) {
  58   TemporaryFile tf;
  59
  60   int rc = dprintf(tf.fd, "hello\n");
  61   ASSERT_EQ(rc, 6);
  62
  63   lseek(tf.fd, SEEK_SET, 0);
  64   FILE* tfile = fdopen(tf.fd, "r");
  65   ASSERT_TRUE(tfile != NULL);
  66
  67   char buf[7];
  68   ASSERT_EQ(buf, fgets(buf, sizeof(buf), tfile));
  69   ASSERT_STREQ("hello\n", buf);
  70   // Make sure there isn't anything else in the file.
  71   ASSERT_EQ(NULL, fgets(buf, sizeof(buf), tfile));
  72   fclose(tfile);
  73 }
  74
  75 TEST(stdio, getdelim) {
  76   FILE* fp = tmpfile();
  77   ASSERT_TRUE(fp != NULL);
  78
  79   const char* line_written = "This  is a test";
  80   int rc = fprintf(fp, "%s", line_written);
  81   ASSERT_EQ(rc, static_cast<int>(strlen(line_written)));
  82
  83   rewind(fp);
  84
  85   char* word_read = NULL;
  86   size_t allocated_length = 0;
  87
  88   const char* expected[] = { "This ", " ", "is ", "a ", "test" };
  89   for (size_t i = 0; i < 5; ++i) {
  90     ASSERT_FALSE(feof(fp));
  91     ASSERT_EQ(getdelim(&word_read, &allocated_length, ' ', fp), static_cast<int>(strlen(expected[i])));
  92     ASSERT_GE(allocated_length, strlen(expected[i]));
  93     ASSERT_STREQ(word_read, expected[i]);
  94   }
  95   // The last read should have set the end-of-file indicator for the stream.
  96   ASSERT_TRUE(feof(fp));
  97   clearerr(fp);
  98
  99   // getdelim returns -1 but doesn't set errno if we're already at EOF.
 100   // It should set the end-of-file indicator for the stream, though.
 101   errno = 0;
 102   ASSERT_EQ(getdelim(&word_read, &allocated_length, ' ', fp), -1);
 103   ASSERT_EQ(0, errno);
 104   ASSERT_TRUE(feof(fp));
 105
 106   free(word_read);
 107   fclose(fp);
 108 }
 109
 110 TEST(stdio, getdelim_invalid) {
 111   FILE* fp = tmpfile();
 112   ASSERT_TRUE(fp != NULL);
 113
 114   char* buffer = NULL;
 115   size_t buffer_length = 0;
 116
 117   // The first argument can't be NULL.
 118   errno = 0;
 119   ASSERT_EQ(getdelim(NULL, &buffer_length, ' ', fp), -1);
 120   ASSERT_EQ(EINVAL, errno);
 121
 122   // The second argument can't be NULL.
 123   errno = 0;
 124   ASSERT_EQ(getdelim(&buffer, NULL, ' ', fp), -1);
 125   ASSERT_EQ(EINVAL, errno);
 126
 127   // The underlying fd can't be closed.
 128   ASSERT_EQ(0, close(fileno(fp)));
 129   errno = 0;
 130   ASSERT_EQ(getdelim(&buffer, &buffer_length, ' ', fp), -1);
 131   ASSERT_EQ(EBADF, errno);
 132   fclose(fp);
 133 }
 134
 135 TEST(stdio, getline) {
 136   FILE* fp = tmpfile();
 137   ASSERT_TRUE(fp != NULL);
 138
 139   const char* line_written = "This is a test for getline\n";
 140   const size_t line_count = 5;
 141
 142   for (size_t i = 0; i < line_count; ++i) {
 143     int rc = fprintf(fp, "%s", line_written);
 144     ASSERT_EQ(rc, static_cast<int>(strlen(line_written)));
 145   }
 146
 147   rewind(fp);
 148
 149   char* line_read = NULL;
 150   size_t allocated_length = 0;
 151
 152   size_t read_line_count = 0;
 153   ssize_t read_char_count;
 154   while ((read_char_count = getline(&line_read, &allocated_length, fp)) != -1) {
 155     ASSERT_EQ(read_char_count, static_cast<int>(strlen(line_written)));
 156     ASSERT_GE(allocated_length, strlen(line_written));
 157     ASSERT_STREQ(line_read, line_written);
 158     ++read_line_count;
 159   }
 160   ASSERT_EQ(read_line_count, line_count);
 161
 162   // The last read should have set the end-of-file indicator for the stream.
 163   ASSERT_TRUE(feof(fp));
 164   clearerr(fp);
 165
 166   // getline returns -1 but doesn't set errno if we're already at EOF.
 167   // It should set the end-of-file indicator for the stream, though.
 168   errno = 0;
 169   ASSERT_EQ(getline(&line_read, &allocated_length, fp), -1);
 170   ASSERT_EQ(0, errno);
 171   ASSERT_TRUE(feof(fp));
 172
 173   free(line_read);
 174   fclose(fp);
 175 }
 176
 177 TEST(stdio, getline_invalid) {
 178   FILE* fp = tmpfile();
 179   ASSERT_TRUE(fp != NULL);
 180
 181   char* buffer = NULL;
 182   size_t buffer_length = 0;
 183
 184   // The first argument can't be NULL.
 185   errno = 0;
 186   ASSERT_EQ(getline(NULL, &buffer_length, fp), -1);
 187   ASSERT_EQ(EINVAL, errno);
 188
 189   // The second argument can't be NULL.
 190   errno = 0;
 191   ASSERT_EQ(getline(&buffer, NULL, fp), -1);
 192   ASSERT_EQ(EINVAL, errno);
 193
 194   // The underlying fd can't be closed.
 195   ASSERT_EQ(0, close(fileno(fp)));
 196   errno = 0;
 197   ASSERT_EQ(getline(&buffer, &buffer_length, fp), -1);
 198   ASSERT_EQ(EBADF, errno);
 199   fclose(fp);
 200 }
 201
 202 TEST(stdio, printf_ssize_t) {
 203   // http://b/8253769
 204   ASSERT_EQ(sizeof(ssize_t), sizeof(long int));
 205   ASSERT_EQ(sizeof(ssize_t), sizeof(size_t));
 206   // For our 32-bit ABI, we had a ssize_t definition that confuses GCC into saying:
 207   // error: format '%zd' expects argument of type 'signed size_t',
 208   //     but argument 4 has type 'ssize_t {aka long int}' [-Werror=format]
 209   ssize_t v = 1;
 210   char buf[32];
 211   snprintf(buf, sizeof(buf), "%zd", v);
 212 }
 213
 214 // https://code.google.com/p/android/issues/detail?id=64886
 215 TEST(stdio, snprintf_a) {
 216   char buf[BUFSIZ];
 217   EXPECT_EQ(23, snprintf(buf, sizeof(buf), "<%a>", 9990.235));
 218   EXPECT_STREQ("<0x1.3831e147ae148p+13>", buf);
 219 }
 220
 221 TEST(stdio, snprintf_lc) {
 222   char buf[BUFSIZ];
 223   wint_t wc = L'a';
 224   EXPECT_EQ(3, snprintf(buf, sizeof(buf), "<%lc>", wc));
 225   EXPECT_STREQ("<a>", buf);
 226 }
 227
 228 TEST(stdio, snprintf_ls) {
 229   char buf[BUFSIZ];
 230   wchar_t* ws = NULL;
 231   EXPECT_EQ(8, snprintf(buf, sizeof(buf), "<%ls>", ws));
 232   EXPECT_STREQ("<(null)>", buf);
 233
 234   wchar_t chars[] = { L'h', L'i', 0 };
 235   ws = chars;
 236   EXPECT_EQ(4, snprintf(buf, sizeof(buf), "<%ls>", ws));
 237   EXPECT_STREQ("<hi>", buf);
 238 }
 239
 240 TEST(stdio, snprintf_n) {
 241 #if defined(__BIONIC__)
 242   // http://b/14492135
 243   char buf[32];
 244   int i = 1234;
 245   EXPECT_EQ(5, snprintf(buf, sizeof(buf), "a %n b", &i));
 246   EXPECT_EQ(1234, i);
 247   EXPECT_STREQ("a n b", buf);
 248 #else
 249   GTEST_LOG_(INFO) << "This test does nothing.\n";
 250 #endif
 251 }
 252
 253 TEST(stdio, snprintf_smoke) {
 254   char buf[BUFSIZ];
 255
 256   snprintf(buf, sizeof(buf), "a");
 257   EXPECT_STREQ("a", buf);
 258
 259   snprintf(buf, sizeof(buf), "%%");
 260   EXPECT_STREQ("%", buf);
 261
 262   snprintf(buf, sizeof(buf), "01234");
 263   EXPECT_STREQ("01234", buf);
 264
 265   snprintf(buf, sizeof(buf), "a%sb", "01234");
 266   EXPECT_STREQ("a01234b", buf);
 267
 268   char* s = NULL;
 269   snprintf(buf, sizeof(buf), "a%sb", s);
 270   EXPECT_STREQ("a(null)b", buf);
 271
 272   snprintf(buf, sizeof(buf), "aa%scc", "bb");
 273   EXPECT_STREQ("aabbcc", buf);
 274
 275   snprintf(buf, sizeof(buf), "a%cc", 'b');
 276   EXPECT_STREQ("abc", buf);
 277
 278   snprintf(buf, sizeof(buf), "a%db", 1234);
 279   EXPECT_STREQ("a1234b", buf);
 280
 281   snprintf(buf, sizeof(buf), "a%db", -8123);
 282   EXPECT_STREQ("a-8123b", buf);
 283
 284   snprintf(buf, sizeof(buf), "a%hdb", static_cast<short>(0x7fff0010));
 285   EXPECT_STREQ("a16b", buf);
 286
 287   snprintf(buf, sizeof(buf), "a%hhdb", static_cast<char>(0x7fffff10));
 288   EXPECT_STREQ("a16b", buf);
 289
 290   snprintf(buf, sizeof(buf), "a%lldb", 0x1000000000LL);
 291   EXPECT_STREQ("a68719476736b", buf);
 292
 293   snprintf(buf, sizeof(buf), "a%ldb", 70000L);
 294   EXPECT_STREQ("a70000b", buf);
 295
 296   snprintf(buf, sizeof(buf), "a%pb", reinterpret_cast<void*>(0xb0001234));
 297   EXPECT_STREQ("a0xb0001234b", buf);
 298
 299   snprintf(buf, sizeof(buf), "a%xz", 0x12ab);
 300   EXPECT_STREQ("a12abz", buf);
 301
 302   snprintf(buf, sizeof(buf), "a%Xz", 0x12ab);
 303   EXPECT_STREQ("a12ABz", buf);
 304
 305   snprintf(buf, sizeof(buf), "a%08xz", 0x123456);
 306   EXPECT_STREQ("a00123456z", buf);
 307
 308   snprintf(buf, sizeof(buf), "a%5dz", 1234);
 309   EXPECT_STREQ("a 1234z", buf);
 310
 311   snprintf(buf, sizeof(buf), "a%05dz", 1234);
 312   EXPECT_STREQ("a01234z", buf);
 313
 314   snprintf(buf, sizeof(buf), "a%8dz", 1234);
 315   EXPECT_STREQ("a    1234z", buf);
 316
 317   snprintf(buf, sizeof(buf), "a%-8dz", 1234);
 318   EXPECT_STREQ("a1234    z", buf);
 319
 320   snprintf(buf, sizeof(buf), "A%-11sZ", "abcdef");
 321   EXPECT_STREQ("Aabcdef     Z", buf);
 322
 323   snprintf(buf, sizeof(buf), "A%s:%dZ", "hello", 1234);
 324   EXPECT_STREQ("Ahello:1234Z", buf);
 325
 326   snprintf(buf, sizeof(buf), "a%03d:%d:%02dz", 5, 5, 5);
 327   EXPECT_STREQ("a005:5:05z", buf);
 328
 329   void* p = NULL;
 330   snprintf(buf, sizeof(buf), "a%d,%pz", 5, p);
 331 #if defined(__BIONIC__)
 332   EXPECT_STREQ("a5,0x0z", buf);
 333 #else // __BIONIC__
 334   EXPECT_STREQ("a5,(nil)z", buf);
 335 #endif // __BIONIC__
 336
 337   snprintf(buf, sizeof(buf), "a%lld,%d,%d,%dz", 0x1000000000LL, 6, 7, 8);
 338   EXPECT_STREQ("a68719476736,6,7,8z", buf);
 339
 340   snprintf(buf, sizeof(buf), "a_%f_b", 1.23f);
 341   EXPECT_STREQ("a_1.230000_b", buf);
 342
 343   snprintf(buf, sizeof(buf), "a_%g_b", 3.14);
 344   EXPECT_STREQ("a_3.14_b", buf);
 345
 346   snprintf(buf, sizeof(buf), "%1$s %1$s", "print_me_twice");
 347   EXPECT_STREQ("print_me_twice print_me_twice", buf);
 348 }
 349
 350 TEST(stdio, snprintf_f_special) {
 351   char buf[BUFSIZ];
 352   snprintf(buf, sizeof(buf), "%f", nanf(""));
 353   EXPECT_STRCASEEQ("NaN", buf);
 354
 355   snprintf(buf, sizeof(buf), "%f", HUGE_VALF);
 356   EXPECT_STRCASEEQ("Inf", buf);
 357 }
 358
 359 TEST(stdio, snprintf_g_special) {
 360   char buf[BUFSIZ];
 361   snprintf(buf, sizeof(buf), "%g", nan(""));
 362   EXPECT_STRCASEEQ("NaN", buf);
 363
 364   snprintf(buf, sizeof(buf), "%g", HUGE_VAL);
 365   EXPECT_STRCASEEQ("Inf", buf);
 366 }
 367
 368 TEST(stdio, snprintf_d_INT_MAX) {
 369   char buf[BUFSIZ];
 370   snprintf(buf, sizeof(buf), "%d", INT_MAX);
 371   EXPECT_STREQ("2147483647", buf);
 372 }
 373
 374 TEST(stdio, snprintf_d_INT_MIN) {
 375   char buf[BUFSIZ];
 376   snprintf(buf, sizeof(buf), "%d", INT_MIN);
 377   EXPECT_STREQ("-2147483648", buf);
 378 }
 379
 380 TEST(stdio, snprintf_ld_LONG_MAX) {
 381   char buf[BUFSIZ];
 382   snprintf(buf, sizeof(buf), "%ld", LONG_MAX);
 383 #if __LP64__
 384   EXPECT_STREQ("9223372036854775807", buf);
 385 #else
 386   EXPECT_STREQ("2147483647", buf);
 387 #endif
 388 }
 389
 390 TEST(stdio, snprintf_ld_LONG_MIN) {
 391   char buf[BUFSIZ];
 392   snprintf(buf, sizeof(buf), "%ld", LONG_MIN);
 393 #if __LP64__
 394   EXPECT_STREQ("-9223372036854775808", buf);
 395 #else
 396   EXPECT_STREQ("-2147483648", buf);
 397 #endif
 398 }
 399
 400 TEST(stdio, snprintf_lld_LLONG_MAX) {
 401   char buf[BUFSIZ];
 402   snprintf(buf, sizeof(buf), "%lld", LLONG_MAX);
 403   EXPECT_STREQ("9223372036854775807", buf);
 404 }
 405
 406 TEST(stdio, snprintf_lld_LLONG_MIN) {
 407   char buf[BUFSIZ];
 408   snprintf(buf, sizeof(buf), "%lld", LLONG_MIN);
 409   EXPECT_STREQ("-9223372036854775808", buf);
 410 }
 411
 412 TEST(stdio, snprintf_e) {
 413   char buf[BUFSIZ];
 414
 415   snprintf(buf, sizeof(buf), "%e", 1.5);
 416   EXPECT_STREQ("1.500000e+00", buf);
 417
 418   snprintf(buf, sizeof(buf), "%Le", 1.5l);
 419   EXPECT_STREQ("1.500000e+00", buf);
 420 }
 421
 422 TEST(stdio, snprintf_negative_zero_5084292) {
 423   char buf[BUFSIZ];
 424
 425   snprintf(buf, sizeof(buf), "%f", -0.0);
 426   EXPECT_STREQ("-0.000000", buf);
 427 }
 428
 429 TEST(stdio, snprintf_utf8_15439554) {
 430   locale_t cloc = newlocale(LC_ALL, "C.UTF-8", 0);
 431   locale_t old_locale = uselocale(cloc);
 432
 433   // http://b/15439554
 434   char buf[BUFSIZ];
 435
 436   // 1-byte character.
 437   snprintf(buf, sizeof(buf), "%dx%d", 1, 2);
 438   EXPECT_STREQ("1x2", buf);
 439   // 2-byte character.
 440   snprintf(buf, sizeof(buf), "%d\xc2\xa2%d", 1, 2);
 441   EXPECT_STREQ("1¢2", buf);
 442   // 3-byte character.
 443   snprintf(buf, sizeof(buf), "%d\xe2\x82\xac%d", 1, 2);
 444   EXPECT_STREQ("1€2", buf);
 445   // 4-byte character.
 446   snprintf(buf, sizeof(buf), "%d\xf0\xa4\xad\xa2%d", 1, 2);
 447   EXPECT_STREQ("1𤭢2", buf);
 448
 449   uselocale(old_locale);
 450   freelocale(cloc);
 451 }
 452
 453 TEST(stdio, fprintf_failures_7229520) {
 454   // http://b/7229520
 455   FILE* fp;
 456
 457   // Unbuffered case where the fprintf(3) itself fails.
 458   ASSERT_NE(nullptr, fp = tmpfile());
 459   setbuf(fp, NULL);
 460   ASSERT_EQ(4, fprintf(fp, "epic"));
 461   ASSERT_EQ(0, close(fileno(fp)));
 462   ASSERT_EQ(-1, fprintf(fp, "fail"));
 463   ASSERT_EQ(-1, fclose(fp));
 464
 465   // Buffered case where we won't notice until the fclose(3).
 466   // It's likely this is what was actually seen in http://b/7229520,
 467   // and that expecting fprintf to fail is setting yourself up for
 468   // disappointment. Remember to check fclose(3)'s return value, kids!
 469   ASSERT_NE(nullptr, fp = tmpfile());
 470   ASSERT_EQ(4, fprintf(fp, "epic"));
 471   ASSERT_EQ(0, close(fileno(fp)));
 472   ASSERT_EQ(4, fprintf(fp, "fail"));
 473   ASSERT_EQ(-1, fclose(fp));
 474 }
 475
 476 TEST(stdio, popen) {
 477   FILE* fp = popen("cat /proc/version", "r");
 478   ASSERT_TRUE(fp != NULL);
 479
 480   char buf[16];
 481   char* s = fgets(buf, sizeof(buf), fp);
 482   buf[13] = '\0';
 483   ASSERT_STREQ("Linux version", s);
 484
 485   ASSERT_EQ(0, pclose(fp));
 486 }
 487
 488 TEST(stdio, getc) {
 489   FILE* fp = fopen("/proc/version", "r");
 490   ASSERT_TRUE(fp != NULL);
 491   ASSERT_EQ('L', getc(fp));
 492   ASSERT_EQ('i', getc(fp));
 493   ASSERT_EQ('n', getc(fp));
 494   ASSERT_EQ('u', getc(fp));
 495   ASSERT_EQ('x', getc(fp));
 496   fclose(fp);
 497 }
 498
 499 TEST(stdio, putc) {
 500   FILE* fp = fopen("/proc/version", "r");
 501   ASSERT_TRUE(fp != NULL);
 502   ASSERT_EQ(EOF, putc('x', fp));
 503   fclose(fp);
 504 }
 505
 506 TEST(stdio, sscanf) {
 507   char s1[123];
 508   int i1;
 509   double d1;
 510   char s2[123];
 511   ASSERT_EQ(3, sscanf("  hello 123 1.23 ", "%s %i %lf %s", s1, &i1, &d1, s2));
 512   ASSERT_STREQ("hello", s1);
 513   ASSERT_EQ(123, i1);
 514   ASSERT_DOUBLE_EQ(1.23, d1);
 515 }
 516
 517 TEST(stdio, cantwrite_EBADF) {
 518   // If we open a file read-only...
 519   FILE* fp = fopen("/proc/version", "r");
 520
 521   // ...all attempts to write to that file should return failure.
 522
 523   // They should also set errno to EBADF. This isn't POSIX, but it's traditional.
 524   // glibc gets the wide-character functions wrong.
 525
 526   errno = 0;
 527   EXPECT_EQ(EOF, putc('x', fp));
 528   EXPECT_EQ(EBADF, errno);
 529
 530   errno = 0;
 531   EXPECT_EQ(EOF, fprintf(fp, "hello"));
 532   EXPECT_EQ(EBADF, errno);
 533
 534   errno = 0;
 535   EXPECT_EQ(EOF, fwprintf(fp, L"hello"));
 536 #if defined(__BIONIC__)
 537   EXPECT_EQ(EBADF, errno);
 538 #endif
 539
 540   errno = 0;
 541   EXPECT_EQ(0U, fwrite("hello", 1, 2, fp));
 542   EXPECT_EQ(EBADF, errno);
 543
 544   errno = 0;
 545   EXPECT_EQ(EOF, fputs("hello", fp));
 546   EXPECT_EQ(EBADF, errno);
 547
 548   errno = 0;
 549   EXPECT_EQ(WEOF, fputwc(L'x', fp));
 550 #if defined(__BIONIC__)
 551   EXPECT_EQ(EBADF, errno);
 552 #endif
 553 }
 554
 555 // Tests that we can only have a consistent and correct fpos_t when using
 556 // f*pos functions (i.e. fpos doesn't get inside a multi byte character).
 557 TEST(stdio, consistent_fpos_t) {
 558   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
 559   uselocale(LC_GLOBAL_LOCALE);
 560
 561   FILE* fp = tmpfile();
 562   ASSERT_TRUE(fp != NULL);
 563
 564   wchar_t mb_one_bytes = L'h';
 565   wchar_t mb_two_bytes = 0x00a2;
 566   wchar_t mb_three_bytes = 0x20ac;
 567   wchar_t mb_four_bytes = 0x24b62;
 568
 569   // Write to file.
 570   ASSERT_EQ(mb_one_bytes, static_cast<wchar_t>(fputwc(mb_one_bytes, fp)));
 571   ASSERT_EQ(mb_two_bytes, static_cast<wchar_t>(fputwc(mb_two_bytes, fp)));
 572   ASSERT_EQ(mb_three_bytes, static_cast<wchar_t>(fputwc(mb_three_bytes, fp)));
 573   ASSERT_EQ(mb_four_bytes, static_cast<wchar_t>(fputwc(mb_four_bytes, fp)));
 574
 575   rewind(fp);
 576
 577   // Record each character position.
 578   fpos_t pos1;
 579   fpos_t pos2;
 580   fpos_t pos3;
 581   fpos_t pos4;
 582   fpos_t pos5;
 583   EXPECT_EQ(0, fgetpos(fp, &pos1));
 584   ASSERT_EQ(mb_one_bytes, static_cast<wchar_t>(fgetwc(fp)));
 585   EXPECT_EQ(0, fgetpos(fp, &pos2));
 586   ASSERT_EQ(mb_two_bytes, static_cast<wchar_t>(fgetwc(fp)));
 587   EXPECT_EQ(0, fgetpos(fp, &pos3));
 588   ASSERT_EQ(mb_three_bytes, static_cast<wchar_t>(fgetwc(fp)));
 589   EXPECT_EQ(0, fgetpos(fp, &pos4));
 590   ASSERT_EQ(mb_four_bytes, static_cast<wchar_t>(fgetwc(fp)));
 591   EXPECT_EQ(0, fgetpos(fp, &pos5));
 592
 593 #if defined(__BIONIC__)
 594   // Bionic's fpos_t is just an alias for off_t. This is inherited from OpenBSD
 595   // upstream. Glibc differs by storing the mbstate_t inside its fpos_t. In
 596   // Bionic (and upstream OpenBSD) the mbstate_t is stored inside the FILE
 597   // structure.
 598   ASSERT_EQ(0, static_cast<off_t>(pos1));
 599   ASSERT_EQ(1, static_cast<off_t>(pos2));
 600   ASSERT_EQ(3, static_cast<off_t>(pos3));
 601   ASSERT_EQ(6, static_cast<off_t>(pos4));
 602   ASSERT_EQ(10, static_cast<off_t>(pos5));
 603 #endif
 604
 605   // Exercise back and forth movements of the position.
 606   ASSERT_EQ(0, fsetpos(fp, &pos2));
 607   ASSERT_EQ(mb_two_bytes, static_cast<wchar_t>(fgetwc(fp)));
 608   ASSERT_EQ(0, fsetpos(fp, &pos1));
 609   ASSERT_EQ(mb_one_bytes, static_cast<wchar_t>(fgetwc(fp)));
 610   ASSERT_EQ(0, fsetpos(fp, &pos4));
 611   ASSERT_EQ(mb_four_bytes, static_cast<wchar_t>(fgetwc(fp)));
 612   ASSERT_EQ(0, fsetpos(fp, &pos3));
 613   ASSERT_EQ(mb_three_bytes, static_cast<wchar_t>(fgetwc(fp)));
 614   ASSERT_EQ(0, fsetpos(fp, &pos5));
 615   ASSERT_EQ(WEOF, fgetwc(fp));
 616
 617   fclose(fp);
 618 }
 619
 620 // Exercise the interaction between fpos and seek.
 621 TEST(stdio, fpos_t_and_seek) {
 622   ASSERT_STREQ("C.UTF-8", setlocale(LC_CTYPE, "C.UTF-8"));
 623   uselocale(LC_GLOBAL_LOCALE);
 624
 625   // In glibc-2.16 fseek doesn't work properly in wide mode
 626   // (https://sourceware.org/bugzilla/show_bug.cgi?id=14543). One workaround is
 627   // to close and re-open the file. We do it in order to make the test pass
 628   // with all glibcs.
 629
 630   TemporaryFile tf;
 631   FILE* fp = fdopen(tf.fd, "w+");
 632   ASSERT_TRUE(fp != NULL);
 633
 634   wchar_t mb_two_bytes = 0x00a2;
 635   wchar_t mb_three_bytes = 0x20ac;
 636   wchar_t mb_four_bytes = 0x24b62;
 637
 638   // Write to file.
 639   ASSERT_EQ(mb_two_bytes, static_cast<wchar_t>(fputwc(mb_two_bytes, fp)));
 640   ASSERT_EQ(mb_three_bytes, static_cast<wchar_t>(fputwc(mb_three_bytes, fp)));
 641   ASSERT_EQ(mb_four_bytes, static_cast<wchar_t>(fputwc(mb_four_bytes, fp)));
 642
 643   fflush(fp);
 644   fclose(fp);
 645
 646   fp = fopen(tf.filename, "r");
 647   ASSERT_TRUE(fp != NULL);
 648
 649   // Store a valid position.
 650   fpos_t mb_two_bytes_pos;
 651   ASSERT_EQ(0, fgetpos(fp, &mb_two_bytes_pos));
 652
 653   // Move inside mb_four_bytes with fseek.
 654   long offset_inside_mb = 6;
 655   ASSERT_EQ(0, fseek(fp, offset_inside_mb, SEEK_SET));
 656
 657   // Store the "inside multi byte" position.
 658   fpos_t pos_inside_mb;
 659   ASSERT_EQ(0, fgetpos(fp, &pos_inside_mb));
 660 #if defined(__BIONIC__)
 661   ASSERT_EQ(offset_inside_mb, static_cast<off_t>(pos_inside_mb));
 662 #endif
 663
 664   // Reading from within a byte should produce an error.
 665   ASSERT_EQ(WEOF, fgetwc(fp));
 666   ASSERT_EQ(EILSEQ, errno);
 667
 668   // Reverting to a valid position should work.
 669   ASSERT_EQ(0, fsetpos(fp, &mb_two_bytes_pos));
 670   ASSERT_EQ(mb_two_bytes, static_cast<wchar_t>(fgetwc(fp)));
 671
 672   // Moving withing a multi byte with fsetpos should work but reading should
 673   // produce an error.
 674   ASSERT_EQ(0, fsetpos(fp, &pos_inside_mb));
 675   ASSERT_EQ(WEOF, fgetwc(fp));
 676   ASSERT_EQ(EILSEQ, errno);
 677
 678   fclose(fp);
 679 }