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 
AssertFileIs(FILE * fp,const char * expected,bool is_fmemopen=false)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 
TEST(STDIO_TEST,flockfile_18208568_stderr)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 
TEST(STDIO_TEST,flockfile_18208568_regular)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 
TEST(STDIO_TEST,tmpfile_fileno_fprintf_rewind_fgets)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 
TEST(STDIO_TEST,tmpfile64)102 TEST(STDIO_TEST, tmpfile64) {
103   FILE* fp = tmpfile64();
104   ASSERT_TRUE(fp != nullptr);
105   fclose(fp);
106 }
107 
TEST(STDIO_TEST,dprintf)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 
TEST(STDIO_TEST,getdelim)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 
TEST(STDIO_TEST,getdelim_invalid)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 
TEST(STDIO_TEST,getdelim_directory)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 
TEST(STDIO_TEST,getline)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 
TEST(STDIO_TEST,getline_invalid)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 
TEST(STDIO_TEST,printf_ssize_t)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
TEST(STDIO_TEST,snprintf_a)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 
TEST(STDIO_TEST,snprintf_lc)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 
TEST(STDIO_TEST,snprintf_ls)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 
TEST(STDIO_TEST,snprintf_n)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 
TEST(STDIO_TEST,snprintf_smoke)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>
CheckInfNan(int snprintf_fn (T *,size_t,const T *,...),int sscanf_fn (const T *,const T *,...),const T * fmt_string,const T * fmt,const T * fmt_plus,const T * minus_inf,const T * inf_,const T * plus_inf,const T * minus_nan,const T * nan_,const T * plus_nan)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 
TEST(STDIO_TEST,snprintf_sscanf_inf_nan)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 
TEST(STDIO_TEST,swprintf_swscanf_inf_nan)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 
TEST(STDIO_TEST,snprintf_d_INT_MAX)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 
TEST(STDIO_TEST,snprintf_d_INT_MIN)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 
TEST(STDIO_TEST,snprintf_ld_LONG_MAX)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 
TEST(STDIO_TEST,snprintf_ld_LONG_MIN)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 
TEST(STDIO_TEST,snprintf_lld_LLONG_MAX)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 
TEST(STDIO_TEST,snprintf_lld_LLONG_MIN)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 
TEST(STDIO_TEST,snprintf_e)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 
TEST(STDIO_TEST,snprintf_negative_zero_5084292)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 
TEST(STDIO_TEST,snprintf_utf8_15439554)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("1¢2", buf);
626   // 3-byte character.
627   snprintf(buf, sizeof(buf), "%d\xe2\x82\xac%d", 1, 2);
628   EXPECT_STREQ("1€2", buf);
629   // 4-byte character.
630   snprintf(buf, sizeof(buf), "%d\xf0\xa4\xad\xa2%d", 1, 2);
631   EXPECT_STREQ("1��2", buf);
632 
633   uselocale(old_locale);
634   freelocale(cloc);
635 }
636 
snprintf_small_stack_fn(void *)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 
TEST(STDIO_TEST,snprintf_small_stack)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 
TEST(STDIO_TEST,snprintf_asterisk_overflow)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 
TEST(STDIO_TEST,fprintf)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 
TEST(STDIO_TEST,fprintf_failures_7229520)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 
TEST(STDIO_TEST,popen)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 
TEST(STDIO_TEST,getc)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 
TEST(STDIO_TEST,putc)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 
TEST(STDIO_TEST,sscanf_swscanf)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 
TEST(STDIO_TEST,cantwrite_EBADF)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).
TEST(STDIO_TEST,consistent_fpos_t)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.
TEST(STDIO_TEST,fpos_t_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 
TEST(STDIO_TEST,fmemopen)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 
TEST(STDIO_TEST,KNOWN_FAILURE_ON_BIONIC (fmemopen_NULL))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 
TEST(STDIO_TEST,fmemopen_EINVAL)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 
TEST(STDIO_TEST,open_memstream)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 
TEST(STDIO_TEST,open_memstream_EINVAL)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 
TEST(STDIO_TEST,fdopen_CLOEXEC)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 
TEST(STDIO_TEST,freopen_CLOEXEC)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 
TEST(STDIO_TEST,fopen64_freopen64)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
TEST(STDIO_TEST,fread_unbuffered_pathological_performance)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 
TEST(STDIO_TEST,fread_EOF)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 
test_fread_from_write_only_stream(size_t n)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 
TEST(STDIO_TEST,fread_from_write_only_stream_slow_path)1109 TEST(STDIO_TEST, fread_from_write_only_stream_slow_path) {
1110   test_fread_from_write_only_stream(1);
1111 }
1112 
TEST(STDIO_TEST,fread_from_write_only_stream_fast_path)1113 TEST(STDIO_TEST, fread_from_write_only_stream_fast_path) {
1114   test_fread_from_write_only_stream(64*1024);
1115 }
1116 
test_fwrite_after_fread(size_t n)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 
TEST(STDIO_TEST,fwrite_after_fread_slow_path)1142 TEST(STDIO_TEST, fwrite_after_fread_slow_path) {
1143   test_fwrite_after_fread(16);
1144 }
1145 
TEST(STDIO_TEST,fwrite_after_fread_fast_path)1146 TEST(STDIO_TEST, fwrite_after_fread_fast_path) {
1147   test_fwrite_after_fread(64*1024);
1148 }
1149 
1150 // http://b/19172514
TEST(STDIO_TEST,fread_after_fseek)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
TEST(STDIO_TEST,fread_EOF_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 
TEST(STDIO_TEST,fclose_invalidates_fd)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 
TEST(STDIO_TEST,fseek_ftell_unseekable)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 
TEST(STDIO_TEST,funopen_EINVAL)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 
TEST(STDIO_TEST,funopen_seek)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 
TEST(STDIO_TEST,lots_of_concurrent_files)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 
AssertFileOffsetAt(FILE * fp,off64_t offset)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 
TEST(STDIO_TEST,seek_tell_family_smoke)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 
TEST(STDIO_TEST,fseek_fseeko_EINVAL)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 
TEST(STDIO_TEST,ctermid)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 
TEST(STDIO_TEST,remove)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 
TEST(STDIO_DEATHTEST,snprintf_30445072_known_buffer_size)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 
TEST(STDIO_DEATHTEST,snprintf_30445072_unknown_buffer_size)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 
TEST(STDIO_TEST,sprintf_30445072)1463 TEST(STDIO_TEST, sprintf_30445072) {
1464   std::string buf = "world";
1465   sprintf(&buf[0], "hello");
1466   ASSERT_EQ(buf, "hello");
1467 }
1468