[libc][NFC] Put definitions of stdout and friends into their own object files.

[sivachandra]

Summary

This is done so that tests which only require platform file but not the
platform streams can be run as unit tests. The tests which use platform
streams can only be hermetic tests to avoid conflicts with the
system-libc streams.

Fixes:
https://github.com/llvm/llvm-project/issues/64663
https://github.com/llvm/llvm-project/issues/63558

[jhuber6]

Here's a list of changes I had to make to get all tests passing with a local build, I use glibc version 2.37

diff --git a/libc/test/src/__support/File/CMakeLists.txt b/libc/test/src/__support/File/CMakeLists.txt
index 5ef8de1d6f7a..8b00427ae1ae 100644
--- a/libc/test/src/__support/File/CMakeLists.txt
+++ b/libc/test/src/__support/File/CMakeLists.txt
@@ -34,6 +34,7 @@ foreach(target IN LISTS platform_file_targets)
         libc.src.__support.File.file
         libc.src.__support.File.${target}
         libc.include.stdio
+      HERMETIC_TEST_ONLY
     )
   endif()
 endforeach()
diff --git a/libc/test/src/stdio/CMakeLists.txt b/libc/test/src/stdio/CMakeLists.txt
index f29c21079959..ccdf778475ec 100644
--- a/libc/test/src/stdio/CMakeLists.txt
+++ b/libc/test/src/stdio/CMakeLists.txt
@@ -151,75 +151,6 @@ else()
  set(fprintf_test_copts "-DLIBC_COPT_PRINTF_USE_SYSTEM_FILE")
 endif()
 
-add_libc_unittest(
-  fprintf_test
-  SUITE
-    libc_stdio_unittests
-  SRCS
-    fprintf_test.cpp
-  DEPENDS
-    libc.src.stdio.fprintf
-    ${fprintf_test_deps}
-  COMPILE_OPTIONS
-    ${fprintf_test_copts}
-)
-
-add_libc_unittest(
-  printf_test
-  ${hermetic_test_only}
-  SUITE
-    libc_stdio_unittests
-  SRCS
-    printf_test.cpp
-  DEPENDS
-    libc.src.stdio.printf
-)
-
-add_fp_unittest(
-  vsprintf_test
-  UNIT_TEST_ONLY
-  SUITE
-    libc_stdio_unittests
-  SRCS
-    vsprintf_test.cpp
-  DEPENDS
-    libc.src.stdio.vsprintf
-)
-
-add_libc_unittest(
-  vsnprintf_test
-  SUITE
-    libc_stdio_unittests
-  SRCS
-    vsnprintf_test.cpp
-  DEPENDS
-    libc.src.stdio.vsnprintf
-)
-
-add_libc_unittest(
-  vfprintf_test
-  SUITE
-    libc_stdio_unittests
-  SRCS
-    vfprintf_test.cpp
-  DEPENDS
-    libc.src.stdio.vfprintf
-    ${fprintf_test_deps}
-  COMPILE_OPTIONS
-    ${fprintf_test_copts}
-)
-
-add_libc_unittest(
-  vprintf_test
-  ${hermetic_test_only}
-  SUITE
-    libc_stdio_unittests
-  SRCS
-    vprintf_test.cpp
-  DEPENDS
-    libc.src.stdio.vprintf
-)
-
 add_libc_unittest(
   fscanf_test
   SUITE
diff --git a/libc/test/src/unistd/CMakeLists.txt b/libc/test/src/unistd/CMakeLists.txt
index ceee888669b7..ca2b1b05ba18 100644
--- a/libc/test/src/unistd/CMakeLists.txt
+++ b/libc/test/src/unistd/CMakeLists.txt
@@ -429,16 +429,3 @@ add_libc_unittest(
     libc.include.unistd
     libc.src.unistd.sysconf
 )
-
-add_libc_unittest(
-  getopt_test
-  SUITE
-    libc_unistd_unittests
-  SRCS
-    getopt_test.cpp
-  DEPENDS
-    libc.src.unistd.getopt
-    libc.src.__support.CPP.array
-    libc.src.stdio.fopencookie
-    libc.src.stdio.fflush
-)

The platform file tests need to be made hermetic as they link in the libc file handle which overrides it. The other tests that fail are all the printf variants and getopt weirdly enough. I think the common factor here is fflush? Since when I ran the debugger it seemed to crash somewhere in that call to the system libc.

[sivachandra]

Mark more tests are hermetic only.

[mikhail.ramalho]

This also fixes the crash I'm seeing in rv32 with glibc 2.37

[sivachandra]

Remove the use of function static variables in getopt_test so that it can be a hermetic test.

[jhuber6]

Fixes all the issues, thanks.

libc/src/__support/File/CMakeLists.txt

DEPENDS
     libc.src.__support.threads.mutex
 )
 
 if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
   return()
 endif()
 
 add_subdirectory(${LIBC_TARGET_OS})
-set(target_file libc.src.__support.File.${LIBC_TARGET_OS}.${LIBC_TARGET_OS}_file)
-set(target_dir libc.src.__support.File.${LIBC_TARGET_OS}.${LIBC_TARGET_OS}_dir)
-if((NOT TARGET ${target_file}) OR (NOT TARGET ${target_dir}))
-  return()
-endif()
 
+set(target_file libc.src.__support.File.${LIBC_TARGET_OS}.file)
+set(target_stdout libc.src.__support.File.${LIBC_TARGET_OS}.stdout)
+set(target_stderr libc.src.__support.File.${LIBC_TARGET_OS}.stderr)
+set(target_stdin libc.src.__support.File.${LIBC_TARGET_OS}.stdin)
+
+set(file_targets "${target_file};${target_stdout};${target_stdin};${target_stderr}")
+set(file_aliases "platform_file;platform_stdout;platform_stdin;platform_stderr")
+
+foreach(alias target IN ZIP_LISTS file_aliases file_targets)
+  if(TARGET ${target})
     add_object_library(
-  platform_file
+      ${alias}
       ALIAS
-    ${target_file}
+        ${target}
       DEPENDS
-    ${target_file}
+        ${target}
     )
+  endif()
+endforeach()
+
+set(target_dir libc.src.__support.File.${LIBC_TARGET_OS}.${LIBC_TARGET_OS}_dir)
+if(NOT TARGET ${target_dir})
+  return()
+endif()
 
 add_object_library(
   platform_dir
   ALIAS
     ${target_dir}
   DEPENDS
     ${target_dir}
 )

libc/src/__support/File/linux/CMakeLists.txt

 add_object_library(
-  linux_file
+  file
   SRCS
     file.cpp
+  HDRS
+    file.h
   DEPENDS
     libc.include.fcntl
     libc.include.stdio
     libc.include.sys_syscall
     libc.src.__support.CPP.new
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
     libc.src.__support.error_or
     libc.src.__support.File.file
 )
 
 add_object_library(
+  stdout
+  SRCS
+    stdout.cpp
+  DEPENDS
+    .file
+)
+
+add_object_library(
+  stdin
+  SRCS
+    stdin.cpp
+  DEPENDS
+    .file
+)
+
+add_object_library(
+  stderr
+  SRCS
+    stderr.cpp
+  DEPENDS
+    .file
+)
+
+add_object_library(
   linux_dir
   SRCS
     dir.cpp
   DEPENDS
     libc.include.fcntl
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
     libc.src.__support.error_or
     libc.src.errno.errno
     libc.src.__support.File.dir
 )

libc/src/__support/File/linux/file.h

+//===--- Linux specialization of the File data structure ------------------===//
+//
+// 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/__support/File/file.h"
+
+namespace __llvm_libc {
+
+FileIOResult linux_file_write(File *, const void *, size_t);
+FileIOResult linux_file_read(File *, void *, size_t);
+ErrorOr<long> linux_file_seek(File *, long, int);
+int linux_file_close(File *);
+
+class LinuxFile : public File {
+  int fd;
+
+public:
+  constexpr LinuxFile(int file_descriptor, uint8_t *buffer, size_t buffer_size,
+                      int buffer_mode, bool owned, File::ModeFlags modeflags)
+      : File(&linux_file_write, &linux_file_read, &linux_file_seek,
+             &linux_file_close, buffer, buffer_size, buffer_mode, owned,
+             modeflags),
+        fd(file_descriptor) {}
+
+  int get_fd() const { return fd; }
+};
+
+} // namespace __llvm_libc

libc/src/__support/File/linux/file.cpp

-//===--- Linux specialization of the File data structure ------------------===//
+//===--- Implementation of the Linux specialization of File ---------------===//
 //
 // 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 "file.h"
+
 #include "src/__support/File/file.h"
 
 #include "src/__support/CPP/new.h"
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/errno/libc_errno.h"         // For error macros
 
 #include <fcntl.h> // For mode_t and other flags to the open syscall
 #include <stdio.h>
 #include <sys/syscall.h> // For syscall numbers
 
 namespace __llvm_libc {
 
-namespace {
-
-FileIOResult write_func(File *, const void *, size_t);
-FileIOResult read_func(File *, void *, size_t);
-ErrorOr<long> seek_func(File *, long, int);
-int close_func(File *);
-
-} // anonymous namespace
-
-class LinuxFile : public File {
-  int fd;
-
-public:
-  constexpr LinuxFile(int file_descriptor, uint8_t *buffer, size_t buffer_size,
-                      int buffer_mode, bool owned, File::ModeFlags modeflags)
-      : File(&write_func, &read_func, &seek_func, &close_func, buffer,
-             buffer_size, buffer_mode, owned, modeflags),
-        fd(file_descriptor) {}
-
-  int get_fd() const { return fd; }
-};
-
-namespace {
-
-FileIOResult write_func(File *f, const void *data, size_t size) {
+FileIOResult linux_file_write(File *f, const void *data, size_t size) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
   int ret = __llvm_libc::syscall_impl<int>(SYS_write, lf->get_fd(), data, size);
   if (ret < 0) {
     return {0, -ret};
   }
   return ret;
 }
 
-FileIOResult read_func(File *f, void *buf, size_t size) {
+FileIOResult linux_file_read(File *f, void *buf, size_t size) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
   int ret = __llvm_libc::syscall_impl<int>(SYS_read, lf->get_fd(), buf, size);
   if (ret < 0) {
     return {0, -ret};
   }
   return ret;
 }
 
-ErrorOr<long> seek_func(File *f, long offset, int whence) {
+ErrorOr<long> linux_file_seek(File *f, long offset, int whence) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
   long result;
 #ifdef SYS_lseek
   int ret =
       __llvm_libc::syscall_impl<int>(SYS_lseek, lf->get_fd(), offset, whence);
   result = ret;
 #elif defined(SYS_llseek)
   int ret = __llvm_libc::syscall_impl<int>(SYS_llseek, lf->get_fd(),

 #endif
 
   if (ret < 0)
     return Error(-ret);
 
   return result;
 }
 
-int close_func(File *f) {
+int linux_file_close(File *f) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
   int ret = __llvm_libc::syscall_impl<int>(SYS_close, lf->get_fd());
   if (ret < 0) {
     return -ret;
   }
   delete lf;
   return 0;
 }
 
-} // anonymous namespace
-
 ErrorOr<File *> openfile(const char *path, const char *mode) {
   using ModeFlags = File::ModeFlags;
   auto modeflags = File::mode_flags(mode);
   if (modeflags == 0) {
     // return {nullptr, EINVAL};
     return Error(EINVAL);
   }
   long open_flags = 0;
#endif
   return file;
 }
 
 int get_fileno(File *f) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
   return lf->get_fd();
 }
 
-constexpr size_t STDIN_BUFFER_SIZE = 512;
-uint8_t stdin_buffer[STDIN_BUFFER_SIZE];
-static LinuxFile StdIn(0, stdin_buffer, STDIN_BUFFER_SIZE, _IOFBF, false,
-                       File::ModeFlags(File::OpenMode::READ));
-File *stdin = &StdIn;
-
-constexpr size_t STDOUT_BUFFER_SIZE = 1024;
-uint8_t stdout_buffer[STDOUT_BUFFER_SIZE];
-static LinuxFile StdOut(1, stdout_buffer, STDOUT_BUFFER_SIZE, _IOLBF, false,
-                        File::ModeFlags(File::OpenMode::APPEND));
-File *stdout = &StdOut;
-
-constexpr size_t STDERR_BUFFER_SIZE = 0;
-static LinuxFile StdErr(2, nullptr, STDERR_BUFFER_SIZE, _IONBF, false,
-                        File::ModeFlags(File::OpenMode::APPEND));
-File *stderr = &StdErr;
-
 } // namespace __llvm_libc
-
-// Provide the external defintitions of the standard IO streams.
-extern "C" {
-FILE *stdin = reinterpret_cast<FILE *>(&__llvm_libc::StdIn);
-FILE *stderr = reinterpret_cast<FILE *>(&__llvm_libc::StdErr);
-FILE *stdout = reinterpret_cast<FILE *>(&__llvm_libc::StdOut);
-}

libc/src/__support/File/linux/stderr.cpp

+//===--- Definition of Linux stderr ---------------------------------------===//
+//
+// 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 "file.h"
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+constexpr size_t STDERR_BUFFER_SIZE = 0;
+static LinuxFile StdErr(2, nullptr, STDERR_BUFFER_SIZE, _IONBF, false,
+                        File::ModeFlags(File::OpenMode::APPEND));
+File *stderr = &StdErr;
+
+} // namespace __llvm_libc
+
+extern "C" {
+FILE *stderr = reinterpret_cast<FILE *>(&__llvm_libc::StdErr);
+}

libc/src/__support/File/linux/stdin.cpp

+//===--- Definition of Linux stdin ----------------------------------------===//
+//
+// 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 "file.h"
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+constexpr size_t STDIN_BUFFER_SIZE = 512;
+uint8_t stdin_buffer[STDIN_BUFFER_SIZE];
+static LinuxFile StdIn(0, stdin_buffer, STDIN_BUFFER_SIZE, _IOFBF, false,
+                       File::ModeFlags(File::OpenMode::READ));
+File *stdin = &StdIn;
+
+} // namespace __llvm_libc
+
+extern "C" {
+FILE *stdin = reinterpret_cast<FILE *>(&__llvm_libc::StdIn);
+} // extern "C"

libc/src/__support/File/linux/stdout.cpp

+//===--- Definition of Linux stdout ---------------------------------------===//
+//
+// 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 "file.h"
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+constexpr size_t STDOUT_BUFFER_SIZE = 1024;
+uint8_t stdout_buffer[STDOUT_BUFFER_SIZE];
+static LinuxFile StdOut(1, stdout_buffer, STDOUT_BUFFER_SIZE, _IOLBF, false,
+                        File::ModeFlags(File::OpenMode::APPEND));
+File *stdout = &StdOut;
+
+} // namespace __llvm_libc
+
+extern "C" {
+FILE *stdout = reinterpret_cast<FILE *>(&__llvm_libc::StdOut);
+} // extern "C"

libc/src/stdio/CMakeLists.txt

 list(APPEND printf_deps
       libc.src.__support.arg_list
       libc.src.stdio.printf_core.vfprintf_internal
 )
 if(LLVM_LIBC_FULL_BUILD)
  list(APPEND printf_deps
       libc.src.__support.File.file
       libc.src.__support.File.platform_file
+      libc.src.__support.File.platform_stdout
   )
 else()
  set(printf_copts "-DLIBC_COPT_PRINTF_USE_SYSTEM_FILE")
 endif()
 
 add_entrypoint_object(
   printf
   SRCS

libc/src/stdio/generic/CMakeLists.txt

add_entrypoint_object(
   SRCS
     puts.cpp
   HDRS
     ../puts.h
   DEPENDS
     libc.src.errno.errno
     libc.include.stdio
     libc.src.__support.File.file
-    libc.src.__support.File.platform_file
+    libc.src.__support.File.platform_stdout
 )
 
 add_entrypoint_object(
   stdin
   SRCS
     stdin.cpp
   HDRS
     ../stdin.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
-    libc.src.__support.File.platform_file
+    libc.src.__support.File.platform_stdin
 )
 
 add_entrypoint_object(
   stdout
   SRCS
     stdout.cpp
   HDRS
     ../stdout.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
-    libc.src.__support.File.platform_file
+    libc.src.__support.File.platform_stdout
 )
 
 add_entrypoint_object(
   stderr
   SRCS
     stderr.cpp
   HDRS
     ../stderr.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
-    libc.src.__support.File.platform_file
+    libc.src.__support.File.platform_stderr
 )

libc/src/unistd/CMakeLists.txt

SRCS
     getopt.cpp
   HDRS
     getopt.h
   DEPENDS
     libc.include.unistd
     libc.src.__support.CPP.optional
     libc.src.__support.CPP.string_view
     libc.src.__support.File.file
+    libc.src.__support.File.platform_stderr
     libc.src.stdio.fprintf
 )
 
 add_entrypoint_object(
   swab
   SRCS
     swab.cpp
   HDRS

libc/test/src/__support/File/CMakeLists.txt

add_libc_test(
   DEPENDS
     libc.include.errno
     libc.include.stdio
     libc.include.stdlib
     libc.src.__support.CPP.new
     libc.src.__support.File.file
 )
 
-if (TARGET libc.src.__support.File.platform_file)
-  add_libc_test(
-    platform_file_test
-    SUITE
-      libc-support-tests
-    SRCS
-      platform_file_test.cpp
-    DEPENDS
-      libc.src.__support.File.file
-      libc.src.__support.File.platform_file
-      libc.include.stdio
-  )
+
+set(platform_stream_targets "platform_stdout;platform_stdin;platform_stderr")
+foreach(target IN LISTS platform_file_targets)
+  if(TARGET libc.src.__support.File.${target})
+    add_libc_test(
+      ${target}_test
+      HERMETIC_TEST_ONLY
+      SUITE
+        libc-support-tests
+      SRCS
+        ${target}_test.cpp
+      DEPENDS
+        libc.src.__support.File.file
+        libc.src.__support.File.${target}
+        libc.include.stdio
+    )
   endif()
+endforeach()
 
 add_subdirectory(testdata)

libc/test/src/__support/File/platform_file_test.cpp

TEST(LlvmLibcPlatformFileTest, IncorrectOperation) {
 
   file = openfile(FILENAME, "a");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(file->read(data, 1).value, size_t(0)); // Cannot read
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
   ASSERT_EQ(file->close(), 0);
 }
-
-TEST(LlvmLibcPlatformFileTest, StdOutStdErrSmokeTest) {
-  EXPECT_FALSE(__llvm_libc::stdout == nullptr);
-  EXPECT_FALSE(__llvm_libc::stderr == nullptr);
-}

libc/test/src/__support/File/platform_stderr_test.cpp

+// 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/__support/File/file.h"
+#include "test/UnitTest/Test.h"
+
+TEST(LlvmLibcPlatformStreamTest, StdErrSmokeTest) {
+  EXPECT_FALSE(__llvm_libc::stderr == nullptr);
+}

libc/test/src/__support/File/platform_stdin_test.cpp

+// 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/__support/File/file.h"
+#include "test/UnitTest/Test.h"
+
+TEST(LlvmLibcPlatformStreamTest, StdInSmokeTest) {
+  EXPECT_FALSE(__llvm_libc::stdin == nullptr);
+}

libc/test/src/__support/File/platform_stdout_test.cpp

+// 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/__support/File/file.h"
+#include "test/UnitTest/Test.h"
+
+TEST(LlvmLibcPlatformStreamTest, StdOutSmokeTest) {
+  EXPECT_FALSE(__llvm_libc::stdout == nullptr);
+}

libc/test/src/stdio/CMakeLists.txt

SUITE
     libc_stdio_unittests
   SRCS
     snprintf_test.cpp
   DEPENDS
     libc.src.stdio.snprintf
 )
 
 if(LLVM_LIBC_FULL_BUILD)
   # In fullbuild mode, fprintf's tests use the internal FILE for other functions.
   list(APPEND fprintf_test_deps
        libc.src.stdio.fclose
        libc.src.stdio.ferror
        libc.src.stdio.fopen
        libc.src.stdio.fread
   )
+  # This is to be used for tests which write to libc's platform streams
+  # under full build but write to system-lib's streams otherwise.
+  set(hermetic_test_only HERMETIC_TEST_ONLY)
 else()
 # Else in overlay mode they use the system's FILE.
  set(fprintf_test_copts "-DLIBC_COPT_PRINTF_USE_SYSTEM_FILE")
 endif()
 
 add_libc_unittest(
   fprintf_test
   SUITE
     libc_stdio_unittests
   SRCS
     fprintf_test.cpp
   DEPENDS
     libc.src.stdio.fprintf
     ${fprintf_test_deps}
   COMPILE_OPTIONS
     ${fprintf_test_copts}
 )
 
-add_libc_unittest(
+add_libc_test(
   printf_test
+  ${hermetic_test_only}
   SUITE
     libc_stdio_unittests
   SRCS
     printf_test.cpp
   DEPENDS
     libc.src.stdio.printf
 )
 
SRCS
     vfprintf_test.cpp
   DEPENDS
     libc.src.stdio.vfprintf
     ${fprintf_test_deps}
   COMPILE_OPTIONS
     ${fprintf_test_copts}
 )
 
-add_libc_unittest(
+add_libc_test(
   vprintf_test
+  ${hermetic_test_only}
   SUITE
     libc_stdio_unittests
   SRCS
     vprintf_test.cpp
   DEPENDS
     libc.src.stdio.vprintf
 )
 
add_libc_unittest(
   DEPENDS
     libc.src.stdio.sscanf
   LINK_LIBRARIES
     LibcFPTestHelpers
 )
 
 add_libc_test(
   puts_test
+  HERMETIC_TEST_ONLY # writes to libc's stdout
   SUITE
     libc_stdio_unittests
   SRCS
     puts_test.cpp
   DEPENDS
     libc.src.stdio.puts
 )
 
 add_libc_test(
   fputs_test
+  HERMETIC_TEST_ONLY # writes to libc's stdout and stderr
   SUITE
     libc_stdio_unittests
   SRCS
     fputs_test.cpp
   DEPENDS
     libc.src.stdio.fputs
     libc.src.stdio.stdout
     libc.src.stdio.stderr

libc/test/src/unistd/CMakeLists.txt

SUITE
     libc_unistd_unittests
   SRCS
     sysconf_test.cpp
   DEPENDS
     libc.include.unistd
     libc.src.unistd.sysconf
 )
 
-add_libc_unittest(
+add_libc_test(
   getopt_test
+  HERMETIC_TEST_ONLY # Uses libc's own stderr
   SUITE
     libc_unistd_unittests
   SRCS
     getopt_test.cpp
   DEPENDS
     libc.src.unistd.getopt
     libc.src.__support.CPP.array
     libc.src.stdio.fopencookie
     libc.src.stdio.fflush
 )

libc/test/src/unistd/getopt_test.cpp

 // This can't be a constructor because it will get run before the constructor
 // which sets the default state in getopt.
 void set_state(FILE *errstream) {
   __llvm_libc::impl::set_getopt_state(
       &test_globals::optarg, &test_globals::optind, &test_globals::optopt,
       &test_globals::optpos, &test_globals::opterr, errstream);
 }
 
-// TODO: <stdio> could be either llvm-libc's or the system libc's. The former
-// doesn't currently support fmemopen but does have fopencookie. In the future
-// just use that instead. This memopen does no error checking for the size
-// of the buffer, etc.
-FILE *memopen(char **pos) {
-  static auto memcpy = [](char *dest, const char *src, size_t size) {
-    for (size_t i = 0; i < size; i++)
-      dest[i] = src[i];
-  };
+static void my_memcpy(char *dest, const char *src, size_t size) {
+}
 
-  static auto *write =
-      +[](void *cookie, const char *buf, size_t size) -> ssize_t {
-    char **pos = static_cast<char **>(cookie);
-    memcpy(*pos, buf, size);
-    *pos += size;
-    return size;
-  };
-
-  static cookie_io_functions_t cookie{nullptr, write, nullptr, nullptr};
-  return __llvm_libc::fopencookie(pos, "w", cookie);
+ssize_t cookie_write(void *cookie, const char *buf, size_t size) {
+  my_memcpy(*pos, buf, size);
 }
 
+static cookie_io_functions_t cookie{nullptr, &cookie_write, nullptr, nullptr};
+
+// TODO: <stdio> could be either llvm-libc's or the system libc's. The former
+// doesn't currently support fmemopen but does have fopencookie. In the future
+// just use that instead. This memopen does no error checking for the size
+// of the buffer, etc.
+FILE *memopen(char **pos) { return __llvm_libc::fopencookie(pos, "w", cookie); }
+
 struct LlvmLibcGetoptTest : public __llvm_libc::testing::Test {
   FILE *errstream;
   char buf[256];
   char *pos = buf;
 
   void reset_errstream() { pos = buf; }
   const char *get_error_msg() {
     __llvm_libc::fflush(errstream);