[libc] Add implementations of feof, ferror and clearerr.

[sivachandra]

Summary

The corresponding _unlocked functions have also been added.

[michaelrj]

lgtm

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     # stdlib.h entrypoints
     libc.src.stdlib._Exit
     # libc.src.stdlib.abort
     libc.src.stdlib.atexit
     libc.src.stdlib.exit
     libc.src.stdlib.getenv
 
     # stdio.h entrypoints
+    libc.src.stdio.clearerr
+    libc.src.stdio.clearerr_unlocked
     libc.src.stdio.fclose
     libc.src.stdio.flockfile
+    libc.src.stdio.feof
+    libc.src.stdio.feof_unlocked
+    libc.src.stdio.ferror
+    libc.src.stdio.ferror_unlocked
     libc.src.stdio.fflush
     libc.src.stdio.fopen
     libc.src.stdio.fopencookie
     libc.src.stdio.fread
     libc.src.stdio.fread_unlocked
     libc.src.stdio.fseek
     libc.src.stdio.funlockfile
     libc.src.stdio.fwrite

libc/spec/gnu_ext.td

def GnuExtensions : StandardSpec<"GNUExtensions"> {
 
   HeaderSpec StdIO = HeaderSpec<
       "stdio.h",
       [], // Macros
       [CookieIOFunctionsT], // Types
       [], // Enumerations
       [
           FunctionSpec<
+              "clearerr_unlocked",
+              RetValSpec<VoidType>,
+              [ArgSpec<FILEPtr>]
+          >,
+          FunctionSpec<
+              "feof_unlocked",
+              RetValSpec<IntType>,
+              [ArgSpec<FILEPtr>]
+          >,
+          FunctionSpec<
+              "ferror_unlocked",
+              RetValSpec<IntType>,
+              [ArgSpec<FILEPtr>]
+          >,
+          FunctionSpec<
               "fopencookie",
               RetValSpec<FILEPtr>,
               [ArgSpec<VoidPtr>, ArgSpec<ConstCharPtr>, ArgSpec<CookieIOFunctionsT>]
           >,
           FunctionSpec<
               "fread_unlocked",
               RetValSpec<SizeTType>,
               [ArgSpec<VoidRestrictedPtr>,

libc/spec/stdc.td

HeaderSpec StdIO = HeaderSpec<
       [], // Macros
       [ // Types
           SizeTType,
           FILE,
       ],
       [], // Enumerations
       [
           FunctionSpec<
+              "clearerr",
+              RetValSpec<VoidType>,
+              [ArgSpec<FILEPtr>]
+          >,
+          FunctionSpec<
               "fclose",
               RetValSpec<IntType>,
               [ArgSpec<FILEPtr>]
           >,
           FunctionSpec<
+              "feof",
+              RetValSpec<IntType>,
+              [ArgSpec<FILEPtr>]
+          >,
+          FunctionSpec<
+              "ferror",
+              RetValSpec<IntType>,
+              [ArgSpec<FILEPtr>]
+          >,
+          FunctionSpec<
               "fflush",
               RetValSpec<IntType>,
               [ArgSpec<FILEPtr>]
           >,
           FunctionSpec<
               "fopen",
               RetValSpec<FILEPtr>,
               [ArgSpec<ConstCharPtr>,

libc/src/__support/File/file.h

private:
 
   // When the buffer is used as a read buffer, read_limit is the upper limit
   // of the index to which the buffer can be read until.
   size_t read_limit;
 
   bool eof;
   bool err;
 
+  // This is a convenience RAII class to lock and unlock file objects.
+  class FileLock {
+    File *file;
+
+  public:
+    explicit FileLock(File *f) : file(f) { file->lock(); }
+
+    ~FileLock() { file->unlock(); }
+
+    FileLock(const FileLock &) = delete;
+    FileLock(FileLock &&) = delete;
+  };
+
 protected:
   bool write_allowed() const {
     return mode & (static_cast<ModeFlags>(OpenMode::WRITE) |
                    static_cast<ModeFlags>(OpenMode::APPEND) |
                    static_cast<ModeFlags>(OpenMode::PLUS));
   }
 
   bool read_allowed() const {
static void init(File *f, WriteFunc *wf, ReadFunc *rf, SeekFunc *sf,
     f->eof = f->err = false;
   }
 
   // Buffered write of |len| bytes from |data| without the file lock.
   size_t write_unlocked(const void *data, size_t len);
 
   // Buffered write of |len| bytes from |data| under the file lock.
   size_t write(const void *data, size_t len) {
-    lock();
-    size_t ret = write_unlocked(data, len);
-    unlock();
-    return ret;
+    FileLock l(this);
+    return write_unlocked(data, len);
   }
 
   // Buffered read of |len| bytes into |data| without the file lock.
   size_t read_unlocked(void *data, size_t len);
 
   // Buffered read of |len| bytes into |data| under the file lock.
   size_t read(void *data, size_t len) {
-    lock();
-    size_t ret = read_unlocked(data, len);
-    unlock();
-    return ret;
+    FileLock l(this);
+    return read_unlocked(data, len);
   }
 
   int seek(long offset, int whence);
 
   // If buffer has data written to it, flush it out. Does nothing if the
   // buffer is currently being used as a read buffer.
   int flush();
 
   // Sets the internal buffer to |buffer| with buffering mode |mode|.
   // |size| is the size of |buffer|. This new |buffer| is owned by the
   // stream only if |owned| is true.
   void set_buffer(void *buffer, size_t size, bool owned);
 
   // Closes the file stream and frees up all resources owned by it.
   int close();
 
   void lock() { mutex.lock(); }
   void unlock() { mutex.unlock(); }
 
-  bool error() const { return err; }
-  void clearerr() { err = false; }
-  bool iseof() const { return eof; }
+  bool error_unlocked() const { return err; }
 
-  // Returns an bit map of flags corresponding to enumerations of
-  // OpenMode, ContentType and CreateType.
-  static ModeFlags mode_flags(const char *mode);
-};
+  bool error() {
+    FileLock l(this);
+    return error_unlocked();
+  }
 
-// This is a convenience RAII class to lock and unlock file objects.
-class FileLock {
-  File *file;
+  void clearerr_unlocked() { err = false; }
 
-public:
-  explicit FileLock(File *f) : file(f) { file->lock(); }
+  void clearerr() {
+    FileLock l(this);
+    clearerr_unlocked();
+  }
 
-  ~FileLock() { file->unlock(); }
+  bool iseof_unlocked() { return eof; }
 
-  FileLock(const FileLock &) = delete;
-  FileLock(FileLock &&) = delete;
+  bool iseof() {
+    FileLock l(this);
+    return iseof_unlocked();
+  }
+
+  // Returns an bit map of flags corresponding to enumerations of
+  // OpenMode, ContentType and CreateType.
+  static ModeFlags mode_flags(const char *mode);
 };
 
 // The implementaiton of this function is provided by the platfrom_file
 // library.
 File *openfile(const char *path, const char *mode);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H

libc/src/stdio/CMakeLists.txt

HDRS
     fclose.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
+  clearerr
+  SRCS
+    clearerr.cpp
+  HDRS
+    clearerr.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+add_entrypoint_object(
+  clearerr_unlocked
+  SRCS
+    clearerr_unlocked.cpp
+  HDRS
+    clearerr_unlocked.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+add_entrypoint_object(
+  feof
+  SRCS
+    feof.cpp
+  HDRS
+    feof.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+add_entrypoint_object(
+  feof_unlocked
+  SRCS
+    feof_unlocked.cpp
+  HDRS
+    feof_unlocked.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+add_entrypoint_object(
+  ferror
+  SRCS
+    ferror.cpp
+  HDRS
+    ferror.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+add_entrypoint_object(
+  ferror_unlocked
+  SRCS
+    ferror_unlocked.cpp
+  HDRS
+    ferror_unlocked.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.__support.File.file
+    libc.src.__support.File.platform_file
+)
+
+add_entrypoint_object(
   fflush
   SRCS
     fflush.cpp
   HDRS
     fflush.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file

libc/src/stdio/clearerr.h

+//===-- Implementation header of clearerr -----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDIO_CLEARERR_H
+#define LLVM_LIBC_SRC_STDIO_CLEARERR_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+void clearerr(::FILE *stream);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_CLEARERR_H

libc/src/stdio/clearerr.cpp

+//===-- Implementation of clearerr ----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/stdio/clearerr.h"
+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(void, clearerr, (::FILE * stream)) {
+  reinterpret_cast<__llvm_libc::File *>(stream)->clearerr();
+}
+
+} // namespace __llvm_libc

libc/src/stdio/clearerr_unlocked.h

+//===-- Implementation header of clearerr_unlocked --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDIO_CLEARERR_UNLOCKED_H
+#define LLVM_LIBC_SRC_STDIO_CLEARERR_UNLOCKED_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+void clearerr_unlocked(::FILE *stream);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_CLEARERR_UNLOCKED_H

libc/src/stdio/clearerr_unlocked.cpp

+//===-- Implementation of clearerr_unlocked -------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/stdio/clearerr_unlocked.h"
+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(void, clearerr_unlocked, (::FILE * stream)) {
+  reinterpret_cast<__llvm_libc::File *>(stream)->clearerr_unlocked();
+}
+
+} // namespace __llvm_libc

libc/src/stdio/feof.h

+//===-- Implementation header of feof ---------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDIO_FEOF_H
+#define LLVM_LIBC_SRC_STDIO_FEOF_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+int feof(::FILE *stream);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_FEOF_H

libc/src/stdio/feof.cpp

+//===-- Implementation of feof --------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/stdio/feof.h"
+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, feof, (::FILE * stream)) {
+  return reinterpret_cast<__llvm_libc::File *>(stream)->iseof();
+}
+
+} // namespace __llvm_libc

libc/src/stdio/feof_unlocked.h

+//===-- Implementation header of feof_unlocked ------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDIO_FEOF_UNLOCKED_H
+#define LLVM_LIBC_SRC_STDIO_FEOF_UNLOCKED_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+int feof_unlocked(::FILE *stream);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_FEOF_UNLOCKED_H

libc/src/stdio/feof_unlocked.cpp

+//===-- Implementation of feof_unlocked -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/stdio/feof_unlocked.h"
+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, feof_unlocked, (::FILE * stream)) {
+  return reinterpret_cast<__llvm_libc::File *>(stream)->iseof_unlocked();
+}
+
+} // namespace __llvm_libc

libc/src/stdio/ferror.h

+//===-- Implementation header of ferror -------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDIO_FERROR_H
+#define LLVM_LIBC_SRC_STDIO_FERROR_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+int ferror(::FILE *stream);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_FERROR_H

libc/src/stdio/ferror.cpp

+//===-- Implementation of ferror ------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/stdio/ferror.h"
+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, ferror, (::FILE * stream)) {
+  return reinterpret_cast<__llvm_libc::File *>(stream)->error();
+}
+
+} // namespace __llvm_libc

libc/src/stdio/ferror_unlocked.h

+//===-- Implementation header of ferror_unlocked ----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDIO_FERROR_UNLOCKED_H
+#define LLVM_LIBC_SRC_STDIO_FERROR_UNLOCKED_H
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+int ferror_unlocked(::FILE *stream);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_FERROR_UNLOCKED_H

libc/src/stdio/ferror_unlocked.cpp

+//===-- Implementation of ferror_unlocked ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/stdio/ferror_unlocked.h"
+#include "src/__support/File/file.h"
+
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, ferror_unlocked, (::FILE * stream)) {
+  return reinterpret_cast<__llvm_libc::File *>(stream)->error_unlocked();
+}
+
+} // namespace __llvm_libc

libc/test/src/stdio/CMakeLists.txt

 add_libc_testsuite(libc_stdio_unittests)
 
 add_libc_unittest(
   fileop_test
   SUITE
     libc_stdio_unittests
   SRCS
     fileop_test.cpp
   DEPENDS
+    libc.include.errno
+    libc.include.stdio
+    libc.src.stdio.clearerr
     libc.src.stdio.fclose
+    libc.src.stdio.feof
+    libc.src.stdio.ferror
     libc.src.stdio.fflush
     libc.src.stdio.fopen
     libc.src.stdio.fread
     libc.src.stdio.fseek
     libc.src.stdio.fwrite
 )
 
 add_libc_unittest(
   unlocked_fileop_test
   SUITE
     libc_stdio_unittests
   SRCS
     unlocked_fileop_test.cpp
   DEPENDS
+    libc.include.errno
+    libc.include.stdio
+    libc.src.stdio.clearerr_unlocked
     libc.src.stdio.fclose
+    libc.src.stdio.feof_unlocked
+    libc.src.stdio.ferror_unlocked
     libc.src.stdio.flockfile
     libc.src.stdio.fopen
     libc.src.stdio.fread_unlocked
     libc.src.stdio.funlockfile
     libc.src.stdio.fwrite_unlocked
 )
 
 add_libc_unittest(
   fopencookie_test
   SUITE
     libc_stdio_unittests
   SRCS
     fopencookie_test.cpp
   DEPENDS
     libc.include.errno
     libc.include.stdio
     libc.include.stdlib
+    libc.src.stdio.clearerr
     libc.src.stdio.fclose
+    libc.src.stdio.feof
+    libc.src.stdio.ferror
     libc.src.stdio.fflush
     libc.src.stdio.fopencookie
     libc.src.stdio.fread
     libc.src.stdio.fseek
     libc.src.stdio.fwrite
 )
 
 target_link_libraries(
   libc.test.src.stdio.fopencookie_test PRIVATE LibcMemoryHelpers
 )
 
 add_subdirectory(printf_core)
 
 add_subdirectory(testdata)

libc/test/src/stdio/fileop_test.cpp

 //===-- Unittests for file operations like fopen, flcose etc --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "src/stdio/clearerr.h"
 #include "src/stdio/fclose.h"
+#include "src/stdio/feof.h"
+#include "src/stdio/ferror.h"
 #include "src/stdio/fflush.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fread.h"
 #include "src/stdio/fseek.h"
 #include "src/stdio/fwrite.h"
 #include "utils/UnitTest/Test.h"
 
+#include <errno.h>
 #include <stdio.h>
 
-TEST(LlvmLibcStdio, SimpleOperations) {
+TEST(LlvmLibcFILETest, SimpleFileOperations) {
   constexpr char FILENAME[] = "testdata/simple_operations.test";
   ::FILE *file = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   constexpr char CONTENT[] = "1234567890987654321";
   ASSERT_EQ(sizeof(CONTENT) - 1,
             __llvm_libc::fwrite(CONTENT, 1, sizeof(CONTENT) - 1, file));
+
+  // This is not a readable file.
+  char read_data[sizeof(CONTENT)];
+  ASSERT_EQ(__llvm_libc::fread(read_data, 1, sizeof(CONTENT), file), size_t(0));
+  ASSERT_NE(__llvm_libc::ferror(file), 0);
+  EXPECT_NE(errno, 0);
+  errno = 0;
+
+  __llvm_libc::clearerr(file);
+  ASSERT_EQ(__llvm_libc::ferror(file), 0);
+
   ASSERT_EQ(0, __llvm_libc::fclose(file));
 
   file = __llvm_libc::fopen(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
 
   constexpr size_t READ_SIZE = 5;
   char data[READ_SIZE];
   data[READ_SIZE - 1] = '\0';
   ASSERT_EQ(__llvm_libc::fread(data, 1, READ_SIZE - 1, file), READ_SIZE - 1);
   ASSERT_STREQ(data, "1234");
   ASSERT_EQ(__llvm_libc::fseek(file, 5, SEEK_CUR), 0);
   ASSERT_EQ(__llvm_libc::fread(data, 1, READ_SIZE - 1, file), READ_SIZE - 1);
   ASSERT_STREQ(data, "0987");
   ASSERT_EQ(__llvm_libc::fseek(file, -5, SEEK_CUR), 0);
   ASSERT_EQ(__llvm_libc::fread(data, 1, READ_SIZE - 1, file), READ_SIZE - 1);
   ASSERT_STREQ(data, "9098");
 
+  // Reading another time should trigger eof.
+  ASSERT_NE(sizeof(CONTENT),
+            __llvm_libc::fread(read_data, 1, sizeof(CONTENT), file));
+  ASSERT_NE(__llvm_libc::feof(file), 0);
+
+  // Should be an error to write.
+  ASSERT_EQ(size_t(0), __llvm_libc::fwrite(CONTENT, 1, sizeof(CONTENT), file));
+  ASSERT_NE(__llvm_libc::ferror(file), 0);
+  ASSERT_NE(errno, 0);
+  errno = 0;
+
+  __llvm_libc::clearerr(file);
+  ASSERT_EQ(__llvm_libc::ferror(file), 0);
+
   ASSERT_EQ(__llvm_libc::fclose(file), 0);
 }
 
-TEST(LlvmLibcFILE, FFlushTest) {
+TEST(LlvmLibcFILETest, FFlush) {
   constexpr char FILENAME[] = "testdata/fflush.test";
   ::FILE *file = __llvm_libc::fopen(FILENAME, "w+");
   ASSERT_FALSE(file == nullptr);
   constexpr char CONTENT[] = "1234567890987654321";
   ASSERT_EQ(sizeof(CONTENT),
             __llvm_libc::fwrite(CONTENT, 1, sizeof(CONTENT), file));
 
   // Flushing at this point should write the data to disk. So, we should be

libc/test/src/stdio/fopencookie_test.cpp

 //===-- Unittests for the fopencookie function ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "src/stdio/clearerr.h"
 #include "src/stdio/fclose.h"
+#include "src/stdio/feof.h"
+#include "src/stdio/ferror.h"
 #include "src/stdio/fflush.h"
 #include "src/stdio/fopencookie.h"
 #include "src/stdio/fread.h"
 #include "src/stdio/fseek.h"
 #include "src/stdio/fwrite.h"
 #include "utils/UnitTest/MemoryMatcher.h"
 #include "utils/UnitTest/Test.h"
 
TEST(LlvmLibcFOpenCookie, ReadOnlyCookieTest) {
 
   ::FILE *f = __llvm_libc::fopencookie(ss, "r", STRING_STREAM_FUNCS);
   ASSERT_TRUE(f != nullptr);
   char read_data[sizeof(CONTENT)];
   ASSERT_EQ(sizeof(CONTENT),
             __llvm_libc::fread(read_data, 1, sizeof(CONTENT), f));
   ASSERT_STREQ(read_data, CONTENT);
 
+  // Reading another time should trigger eof.
+  ASSERT_NE(sizeof(CONTENT),
+            __llvm_libc::fread(read_data, 1, sizeof(CONTENT), f));
+  ASSERT_NE(__llvm_libc::feof(f), 0);
+
   ASSERT_EQ(0, __llvm_libc::fseek(f, 0, SEEK_SET));
   // Should be an error to write.
   ASSERT_EQ(size_t(0), __llvm_libc::fwrite(CONTENT, 1, sizeof(CONTENT), f));
-  ASSERT_EQ(errno, EBADF);
+  ASSERT_NE(__llvm_libc::ferror(f), 0);
+  ASSERT_NE(errno, 0);
   errno = 0;
 
+  __llvm_libc::clearerr(f);
+  ASSERT_EQ(__llvm_libc::ferror(f), 0);
+
   ASSERT_EQ(0, __llvm_libc::fclose(f));
   free(ss);
 }
 
 TEST(LlvmLibcFOpenCookie, WriteOnlyCookieTest) {
   size_t INIT_BUFSIZE = 32;
   auto *ss = reinterpret_cast<StringStream *>(malloc(sizeof(StringStream)));
   ss->buf = reinterpret_cast<char *>(malloc(INIT_BUFSIZE));
TEST(LlvmLibcFOpenCookie, WriteOnlyCookieTest) {
   // Flushing will ensure the data to be written to the string stream.
   ASSERT_EQ(0, __llvm_libc::fflush(f));
   ASSERT_STREQ(WRITE_DATA, ss->buf);
 
   ASSERT_EQ(0, __llvm_libc::fseek(f, 0, SEEK_SET));
   char read_data[sizeof(WRITE_DATA)];
   // Should be an error to read.
   ASSERT_EQ(size_t(0), __llvm_libc::fread(read_data, 1, sizeof(WRITE_DATA), f));
+  ASSERT_NE(__llvm_libc::ferror(f), 0);
   ASSERT_EQ(errno, EBADF);
   errno = 0;
 
+  __llvm_libc::clearerr(f);
+  ASSERT_EQ(__llvm_libc::ferror(f), 0);
+
   ASSERT_EQ(0, __llvm_libc::fclose(f));
   free(ss);
 }
 
 TEST(LlvmLibcFOpenCookie, AppendOnlyCookieTest) {
   constexpr char INITIAL_CONTENT[] = "1234567890987654321";
   constexpr char WRITE_DATA[] = "append";
   auto *ss = reinterpret_cast<StringStream *>(malloc(sizeof(StringStream)));
   ss->buf = reinterpret_cast<char *>(malloc(sizeof(INITIAL_CONTENT)));
   ss->bufsize = sizeof(INITIAL_CONTENT);
   ss->offset = ss->bufsize; // We want to open the file in append mode.
   ss->endpos = ss->bufsize;
   for (size_t i = 0; i < sizeof(INITIAL_CONTENT); ++i)
     ss->buf[i] = INITIAL_CONTENT[i];
 
   ::FILE *f = __llvm_libc::fopencookie(ss, "a", STRING_STREAM_FUNCS);
   ASSERT_TRUE(f != nullptr);
 
   constexpr size_t READ_SIZE = 5;
   char read_data[READ_SIZE];
   // This is not a readable file.
   ASSERT_EQ(__llvm_libc::fread(read_data, 1, READ_SIZE, f), size_t(0));
+  ASSERT_NE(__llvm_libc::ferror(f), 0);
   EXPECT_NE(errno, 0);
   errno = 0;
 
+  __llvm_libc::clearerr(f);
+  ASSERT_EQ(__llvm_libc::ferror(f), 0);
+
   ASSERT_EQ(__llvm_libc::fwrite(WRITE_DATA, 1, sizeof(WRITE_DATA), f),
             sizeof(WRITE_DATA));
   EXPECT_EQ(__llvm_libc::fflush(f), 0);
   EXPECT_EQ(ss->endpos, sizeof(WRITE_DATA) + sizeof(INITIAL_CONTENT));
 
   ASSERT_EQ(__llvm_libc::fclose(f), 0);
   free(ss);
 }

libc/test/src/stdio/unlocked_fileop_test.cpp

-//===-- Unittests for file operations like fopen, flcose etc --------------===//
+//===-- Unittests for f operations like fopen, flcose etc --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "src/stdio/clearerr_unlocked.h"
 #include "src/stdio/fclose.h"
+#include "src/stdio/feof_unlocked.h"
+#include "src/stdio/ferror_unlocked.h"
 #include "src/stdio/flockfile.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fread_unlocked.h"
 #include "src/stdio/funlockfile.h"
 #include "src/stdio/fwrite_unlocked.h"
 #include "utils/UnitTest/Test.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 TEST(LlvmLibcFILETest, UnlockedReadAndWrite) {
-  constexpr char FILENAME[] = "testdata/unlocked_read_and_write.test";
-  ::FILE *file = __llvm_libc::fopen(FILENAME, "w");
-  ASSERT_FALSE(file == nullptr);
+  constexpr char fNAME[] = "testdata/unlocked_read_and_write.test";
+  ::FILE *f = __llvm_libc::fopen(fNAME, "w");
+  ASSERT_FALSE(f == nullptr);
   constexpr char CONTENT[] = "1234567890987654321";
-  __llvm_libc::flockfile(file);
-  ASSERT_EQ(sizeof(CONTENT) - 1, __llvm_libc::fwrite_unlocked(
-                                     CONTENT, 1, sizeof(CONTENT) - 1, file));
-  __llvm_libc::funlockfile(file);
-  ASSERT_EQ(0, __llvm_libc::fclose(file));
-
-  file = __llvm_libc::fopen(FILENAME, "r");
-  ASSERT_FALSE(file == nullptr);
-
+  __llvm_libc::flockfile(f);
+  ASSERT_EQ(sizeof(CONTENT) - 1,
+            __llvm_libc::fwrite_unlocked(CONTENT, 1, sizeof(CONTENT) - 1, f));
+  // Should be an error to read.
   constexpr size_t READ_SIZE = 5;
   char data[READ_SIZE * 2 + 1];
   data[READ_SIZE * 2] = '\0';
-  __llvm_libc::flockfile(file);
-  ASSERT_EQ(__llvm_libc::fread_unlocked(data, 1, READ_SIZE, file), READ_SIZE);
-  ASSERT_EQ(__llvm_libc::fread_unlocked(data + READ_SIZE, 1, READ_SIZE, file),
+
+  ASSERT_EQ(size_t(0),
+            __llvm_libc::fread_unlocked(data, 1, sizeof(READ_SIZE), f));
+  ASSERT_NE(__llvm_libc::ferror_unlocked(f), 0);
+  ASSERT_NE(errno, 0);
+  errno = 0;
+
+  __llvm_libc::clearerr_unlocked(f);
+  ASSERT_EQ(__llvm_libc::ferror_unlocked(f), 0);
+
+  __llvm_libc::funlockfile(f);
+  ASSERT_EQ(0, __llvm_libc::fclose(f));
+
+  f = __llvm_libc::fopen(fNAME, "r");
+  ASSERT_FALSE(f == nullptr);
+
+  __llvm_libc::flockfile(f);
+  ASSERT_EQ(__llvm_libc::fread_unlocked(data, 1, READ_SIZE, f), READ_SIZE);
+  ASSERT_EQ(__llvm_libc::fread_unlocked(data + READ_SIZE, 1, READ_SIZE, f),
             READ_SIZE);
-  __llvm_libc::funlockfile(file);
+
+  // Should be an error to write.
+  ASSERT_EQ(size_t(0),
+            __llvm_libc::fwrite_unlocked(CONTENT, 1, sizeof(CONTENT), f));
+  ASSERT_NE(__llvm_libc::ferror_unlocked(f), 0);
+  ASSERT_NE(errno, 0);
+  errno = 0;
+
+  __llvm_libc::clearerr_unlocked(f);
+  ASSERT_EQ(__llvm_libc::ferror_unlocked(f), 0);
+
+  // Reading more should trigger eof.
+  char large_data[sizeof(CONTENT)];
+  ASSERT_NE(sizeof(CONTENT),
+            __llvm_libc::fread_unlocked(large_data, 1, sizeof(CONTENT), f));
+  ASSERT_NE(__llvm_libc::feof_unlocked(f), 0);
+
+  __llvm_libc::funlockfile(f);
   ASSERT_STREQ(data, "1234567890");
 
-  ASSERT_EQ(__llvm_libc::fclose(file), 0);
+  ASSERT_EQ(__llvm_libc::fclose(f), 0);
 }