[libc++] Introduce a setting to remove fstream from the library

[ldionne]

Summary

This allows porting the library to platforms that are able to support
<iostream> but that do not have a notion of a filesystem, and where it
hence doesn't make sense to support std::fstream (and never will).

Also, remove reliance on <fstream> in various tests that didn't
actually need it.

[ldionne]

Generate files

[philnik]

Why does this need it's own flag, and isn't just under _LIBCPP_HAS_NO_FILESYSTEM?

[ldionne]

In D138327#3939014, @philnik wrote:

Why does this need it's own flag, and isn't just under _LIBCPP_HAS_NO_FILESYSTEM?

Because _LIBCPP_HAS_NO_FILESYSTEM has been used to control whether we ship <filesystem>, and is for example disabled by default on Windows. See the comment in libcxx/CMakeLists.txt.

Rolling this setting into _LIBCPP_HAS_NO_FILESYSTEM will need to wait for https://reviews.llvm.org/D134912 to land and then I'll have to make sure that no other users of _LIBCPP_HAS_NO_FILESYSTEM are broken by also disabling fstream in that configuration, which will require a bit more time. So I am pursuing both at the same time because I don't want to wait that long to get this configuration, but notice how I did not document this new flag (this is on purpose so that people don't start depending on it).

[ldionne]

Fix various tests that used <fstream> as an implementation detail. The only one I gave up on is libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp.

[ldionne]

Ignore non-ASCII inside a new test file.

[tschuett]

The LLVM libc has a porting guide for new targets: https://libc.llvm.org/porting.html. libcxx seems to hide these options in CMake.

[ldionne]

In D138327#3939320, @tschuett wrote:

The LLVM libc has a porting guide for new targets: https://libc.llvm.org/porting.html. libcxx seems to hide these options in CMake.

Can you please expand? Are you suggesting that we handle these configuration options differently? How?

[tschuett]

IDK. Maybe a document how to port libcxx on a new C library.

[ldionne]

AIX is stuck, everything else is green.

libcxx/CMakeLists.txt

option(LIBCXX_ENABLE_RANDOM_DEVICE
    supported, most of <random> will still be available, but std::random_device
    will not." ON)
 option(LIBCXX_ENABLE_LOCALIZATION
   "Whether to include support for localization in the library. Disabling
    localization can be useful when porting to platforms that don't support
    the C locale API (e.g. embedded). When localization is not supported,
    several parts of the library will be disabled: <iostream>, <regex>, <locale>
    will be completely unusable, and other parts may be only partly available." ON)
+option(LIBCXX_ENABLE_FSTREAM
+   "Whether to include support for <fstream>." ON) # TODO: Consider rolling that into LIBCXX_ENABLE_FILESYSTEM
 option(LIBCXX_ENABLE_UNICODE
   "Whether to include support for Unicode in the library. Disabling Unicode can
    be useful when porting to platforms that don't support UTF-8 encoding (e.g.
    embedded)." ON)
 option(LIBCXX_ENABLE_WIDE_CHARACTERS
   "Whether to include support for wide characters in the library. Disabling
    wide character support can be useful when porting to platforms that don't
    support the C functionality for wide characters. When wide characters are

 config_define_if(LIBCXX_HAS_WIN32_THREAD_API _LIBCPP_HAS_THREAD_API_WIN32)
 config_define_if(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY _LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL)
 config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
 config_define_if(LIBCXX_NO_VCRUNTIME _LIBCPP_NO_VCRUNTIME)
 config_define_if(LIBCXX_ENABLE_PARALLEL_ALGORITHMS _LIBCPP_HAS_PARALLEL_ALGORITHMS)
 config_define_if_not(LIBCXX_ENABLE_FILESYSTEM _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 config_define_if_not(LIBCXX_ENABLE_RANDOM_DEVICE _LIBCPP_HAS_NO_RANDOM_DEVICE)
 config_define_if_not(LIBCXX_ENABLE_LOCALIZATION _LIBCPP_HAS_NO_LOCALIZATION)
+config_define_if_not(LIBCXX_ENABLE_FSTREAM _LIBCPP_HAS_NO_FSTREAM)
 config_define_if_not(LIBCXX_ENABLE_UNICODE _LIBCPP_HAS_NO_UNICODE)
 config_define_if_not(LIBCXX_ENABLE_WIDE_CHARACTERS _LIBCPP_HAS_NO_WIDE_CHARACTERS)
 config_define_if_not(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
 config_define_if(LIBCXX_ENABLE_DEBUG_MODE _LIBCPP_ENABLE_DEBUG_MODE)
 if (LIBCXX_ENABLE_ASSERTIONS)
   config_define(1 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT)
 else()
   config_define(0 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT)

libcxx/cmake/caches/Generic-no-fstream.cmake

+set(LIBCXX_ENABLE_FSTREAM OFF CACHE BOOL "")

libcxx/include/CMakeLists.txt

set(files
   valarray
   variant
   vector
   version
   wchar.h
   wctype.h
   )
 
-foreach(feature LIBCXX_ENABLE_FILESYSTEM LIBCXX_ENABLE_LOCALIZATION LIBCXX_ENABLE_THREADS LIBCXX_ENABLE_WIDE_CHARACTERS)
+foreach(feature LIBCXX_ENABLE_FILESYSTEM LIBCXX_ENABLE_LOCALIZATION LIBCXX_ENABLE_FSTREAM LIBCXX_ENABLE_THREADS LIBCXX_ENABLE_WIDE_CHARACTERS)
   if (NOT ${${feature}})
     set(requires_${feature} "requires LIBCXX_CONFIGURED_WITHOUT_SUPPORT_FOR_THIS_HEADER")
   endif()
 endforeach()
 
 configure_file("__config_site.in" "${LIBCXX_GENERATED_INCLUDE_TARGET_DIR}/__config_site" @ONLY)
 configure_file("module.modulemap.in" "${LIBCXX_GENERATED_INCLUDE_DIR}/module.modulemap" @ONLY)
 

libcxx/include/__config_site.in

 #cmakedefine _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_NO_VCRUNTIME
 #cmakedefine _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION @_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION@
 #cmakedefine _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
 #cmakedefine _LIBCPP_HAS_PARALLEL_ALGORITHMS
 #cmakedefine _LIBCPP_HAS_NO_RANDOM_DEVICE
 #cmakedefine _LIBCPP_HAS_NO_LOCALIZATION
+#cmakedefine _LIBCPP_HAS_NO_FSTREAM
 #cmakedefine _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #cmakedefine01 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT
 #cmakedefine _LIBCPP_ENABLE_DEBUG_MODE
 
 // __USE_MINGW_ANSI_STDIO gets redefined on MinGW
 #ifdef __clang__
 #  pragma clang diagnostic push
 #  pragma clang diagnostic ignored "-Wmacro-redefined"

libcxx/include/fstream

 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #if defined(_LIBCPP_MSVCRT) || defined(_NEWLIB_VERSION)
 #  define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS
 #endif
 
+#if !defined(_LIBCPP_HAS_NO_FSTREAM)
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS basic_filebuf
     : public basic_streambuf<_CharT, _Traits>
 {
 public:
     typedef _CharT                           char_type;

 #if defined(_LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1)
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ifstream<char>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ofstream<char>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_filebuf<char>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // _LIBCPP_HAS_NO_FSTREAM
+
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <iosfwd>
 #  include <limits>
 #  include <new>
 #  include <stdexcept>
 #endif
 
 #endif // _LIBCPP_FSTREAM

libcxx/include/module.modulemap.in

module std [system] {
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *
   }
   module fstream {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
+    @requires_LIBCXX_ENABLE_FSTREAM@
     header "fstream"
     export *
   }
   module functional {
     header "functional"
     export *
 
     module __functional {

libcxx/src/ios.instantiations.cpp

 #endif
 
 // Additional instantiations added later. Whether programs rely on these being
 // available is protected by _LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1.
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_stringbuf<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_stringstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ostringstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_istringstream<char>;
+
+#ifndef _LIBCPP_HAS_NO_FSTREAM
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ifstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ofstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_filebuf<char>;
+#endif
 
 // Add more here if needed...
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/test/libcxx/assertions/headers_declare_verbose_abort.sh.cpp

 
 // RUN: %{build} -DTEST_50
 #if defined(TEST_50)
 #   include <forward_list>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_51
-#if defined(TEST_51) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if defined(TEST_51) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)
 #   include <fstream>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_52
 #if defined(TEST_52)
 #   include <functional>
     using HandlerType = decltype(std::__libcpp_verbose_abort);

libcxx/test/libcxx/clang_tidy.sh.cpp

 #include <execution>
 #include <fenv.h>
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
 #endif
 #include <float.h>
 #include <format>
 #include <forward_list>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)
 #   include <fstream>
 #endif
 #include <functional>
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #   include <future>
 #endif
 #include <initializer_list>
 #include <inttypes.h>

libcxx/test/libcxx/double_include.sh.cpp

 #include <execution>
 #include <fenv.h>
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
 #endif
 #include <float.h>
 #include <format>
 #include <forward_list>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)
 #   include <fstream>
 #endif
 #include <functional>
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #   include <future>
 #endif
 #include <initializer_list>
 #include <inttypes.h>

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

 TEST_MACROS();
 #endif
 #include <float.h>
 TEST_MACROS();
 #include <format>
 TEST_MACROS();
 #include <forward_list>
 TEST_MACROS();
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)
 #   include <fstream>
 TEST_MACROS();
 #endif
 #include <functional>
 TEST_MACROS();
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #   include <future>
 TEST_MACROS();

libcxx/test/libcxx/modules_include.sh.cpp

 #if defined(TEST_49)
 #include <format>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_50
 #if defined(TEST_50)
 #include <forward_list>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_51
-#if defined(TEST_51) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if defined(TEST_51) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)
 #include <fstream>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_52
 #if defined(TEST_52)
 #include <functional>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_53
 #if defined(TEST_53) && !defined(_LIBCPP_HAS_NO_THREADS)

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

 #include <execution>
 #include <fenv.h>
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
 #endif
 #include <float.h>
 #include <format>
 #include <forward_list>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)
 #   include <fstream>
 #endif
 #include <functional>
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #   include <future>
 #endif
 #include <initializer_list>
 #include <inttypes.h>

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

 #include <execution>
 #include <fenv.h>
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
 #endif
 #include <float.h>
 #include <format>
 #include <forward_list>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)
 #   include <fstream>
 #endif
 #include <functional>
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 #   include <future>
 #endif
 #include <initializer_list>
 #include <inttypes.h>

libcxx/test/std/input.output/file.streams/fstreams/filebuf.virtuals/seekoff.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <fstream>
 
 // pos_type seekoff(off_type off, ios_base::seekdir way,
 //                  ios_base::openmode which = ios_base::in | ios_base::out);
 // pos_type seekpos(pos_type sp,
 //                  ios_base::openmode which = ios_base::in | ios_base::out);
 
-// FILE_DEPENDENCIES: underflow.dat
-
 #include <fstream>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/input.output/file.streams/lit.local.cfg

 # All non-trivial uses of iostreams require localization support
 if 'no-localization' in config.available_features:
   config.unsupported = True
+
+if 'no-fstream' in config.available_features:
+  config.unsupported = True

libcxx/test/std/input.output/stream.buffers/streambuf/streambuf.virtuals/streambuf.virt.put/xsputn.PR14074.pass.cpp

 // class basic_streambuf;
 
 // streamsize xsputn(const char_type* s, streamsize n);
 
 // Test https://llvm.org/PR14074. The bug is really inside
 // basic_streambuf, but I can't seem to reproduce without going through one
 // of its derived classes.
 
+// UNSUPPORTED: no-fstream
+
 #include <cassert>
 #include <cstddef>
 #include <cstdio>
 #include <fstream>
 #include <sstream>
 #include <string>
 #include "test_macros.h"
 #include "platform_support.h"

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/overflow.pass.cpp

 
 // int_type overflow(int_type c = traits::eof());
 
 // This test is not entirely portable
 
 // XFAIL: no-wide-characters
 
 #include <locale>
+#include <cassert>
 #include <codecvt>
 #include <fstream>
-#include <cassert>
+#include <sstream>
 
 #include "test_macros.h"
 
 struct test_buf
     : public std::wbuffer_convert<std::codecvt_utf8<wchar_t> >
 {
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > base;
     typedef base::char_type   char_type;
     typedef base::int_type    int_type;
     typedef base::traits_type traits_type;
 
     explicit test_buf(std::streambuf* sb) : base(sb) {}
 
     char_type* pbase() const {return base::pbase();}
     char_type* pptr()  const {return base::pptr();}
     char_type* epptr() const {return base::epptr();}
     void gbump(int n) {base::gbump(n);}
 
     virtual int_type overflow(int_type c = traits_type::eof()) {return base::overflow(c);}
 };
 
 int main(int, char**)
 {
     {
-        std::ofstream bs("overflow.dat");
-        test_buf f(bs.rdbuf());
+        std::string s;
+        {
+            std::ostringstream out;
+            test_buf f(out.rdbuf());
             assert(f.pbase() == 0);
             assert(f.pptr() == 0);
             assert(f.epptr() == 0);
             assert(f.overflow(L'a') == L'a');
             assert(f.pbase() != 0);
             assert(f.pptr() == f.pbase());
             assert(f.epptr() - f.pbase() == 4095);
+            s = out.str();
         }
         {
-        std::ifstream bs("overflow.dat");
-        test_buf f(bs.rdbuf());
+            std::istringstream in(s);
+            test_buf f(in.rdbuf());
             assert(f.sgetc() == L'a');
         }
-    std::remove("overflow.dat");
+    }
     {
-        std::ofstream bs("overflow.dat");
-        test_buf f(bs.rdbuf());
+        std::string s;
+        {
+            std::ostringstream out;
+            test_buf f(out.rdbuf());
             f.pubsetbuf(0, 0);
             assert(f.pbase() == 0);
             assert(f.pptr() == 0);
             assert(f.epptr() == 0);
             assert(f.overflow('a') == 'a');
             assert(f.pbase() == 0);
             assert(f.pptr() == 0);
             assert(f.epptr() == 0);
+            s = out.str();
         }
         {
-        std::ifstream bs("overflow.dat");
-        test_buf f(bs.rdbuf());
+            std::istringstream in(s);
+            test_buf f(in.rdbuf());
             assert(f.sgetc() == L'a');
         }
-    std::remove("overflow.dat");
+    }
+    // TODO: Move this to std::stringstream once https://llvm.org/PR59083 has been resolved
+#ifndef TEST_HAS_NO_FSTREAM
+    {
         {
             std::ofstream bs("overflow.dat");
             test_buf f(bs.rdbuf());
             assert(f.sputc(0x4E51) == 0x4E51);
             assert(f.sputc(0x4E52) == 0x4E52);
             assert(f.sputc(0x4E53) == 0x4E53);
         }
         {
             std::ifstream f("overflow.dat");
             assert(f.is_open());
             assert(f.get() == 0xE4);
             assert(f.get() == 0xB9);
             assert(f.get() == 0x91);
             assert(f.get() == 0xE4);
             assert(f.get() == 0xB9);
             assert(f.get() == 0x92);
             assert(f.get() == 0xE4);
             assert(f.get() == 0xB9);
             assert(f.get() == 0x93);
             assert(f.get() == -1);
         }
         std::remove("overflow.dat");
+    }
+#endif // TEST_HAS_NO_FSTREAM
 
     return 0;
 }

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/pbackfail.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: underflow.dat
-
 // <locale>
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 // wbuffer_convert<Codecvt, Elem, Tr>
 
 // int_type pbackfail(int_type c = traits::eof());
 
 // This test is not entirely portable
 
 // XFAIL: no-wide-characters
 
 #include <locale>
-#include <codecvt>
-#include <fstream>
 #include <cassert>
-
-#include "test_macros.h"
+#include <codecvt>
+#include <sstream>
 
 struct test_buf
     : public std::wbuffer_convert<std::codecvt_utf8<wchar_t> >
 {
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > base;
     typedef base::char_type   char_type;
     typedef base::int_type    int_type;
     typedef base::traits_type traits_type;
 
     explicit test_buf(std::streambuf* sb) : base(sb) {}
 
     char_type* eback() const {return base::eback();}
     char_type* gptr()  const {return base::gptr();}
     char_type* egptr() const {return base::egptr();}
     void gbump(int n) {base::gbump(n);}
 
     virtual int_type pbackfail(int_type c = traits_type::eof()) {return base::pbackfail(c);}
 };
 
 int main(int, char**)
 {
+    std::string const s = "123456789";
     {
-        std::ifstream bs("underflow.dat");
-        test_buf f(bs.rdbuf());
+        std::istringstream in(s);
+        test_buf f(in.rdbuf());
         assert(f.sbumpc() == L'1');
         assert(f.sgetc() == L'2');
         assert(f.pbackfail(L'a') == test_buf::traits_type::eof());
     }
     {
-        std::fstream bs("underflow.dat");
-        test_buf f(bs.rdbuf());
+        std::istringstream in(s);
+        test_buf f(in.rdbuf());
         assert(f.sbumpc() == L'1');
         assert(f.sgetc() == L'2');
         assert(f.pbackfail(L'a') == test_buf::traits_type::eof());
         assert(f.sbumpc() == L'2');
         assert(f.sgetc() == L'3');
     }
 
   return 0;
 }

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/seekoff.pass.cpp

 //                  ios_base::openmode which = ios_base::in | ios_base::out);
 // pos_type seekpos(pos_type sp,
 //                  ios_base::openmode which = ios_base::in | ios_base::out);
 
 // This test is not entirely portable
 
 // XFAIL: no-wide-characters
 
+// TODO: Avoid using <fstream> in this test.
+// XFAIL: no-fstream
+
 #include <locale>
 #include <codecvt>
 #include <fstream>
 #include <cassert>
 
-#include "test_macros.h"
-
 class test_codecvt
     : public std::codecvt<wchar_t, char, std::mbstate_t>
 {
     typedef std::codecvt<wchar_t, char, std::mbstate_t> base;
 public:
     explicit test_codecvt(std::size_t refs = 0) : base(refs) {}
     ~test_codecvt() {}
 };

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/test.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 // wbuffer_convert<Codecvt, Elem, Tr>
 
 // XFAIL: no-wide-characters
 
-#include <fstream>
-#include <locale>
-#include <codecvt>
 #include <cassert>
+#include <codecvt>
+#include <locale>
+#include <sstream>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
+int main(int, char**) {
+    std::string storage;
     {
-        std::ofstream bytestream("myfile.txt");
+        std::ostringstream bytestream;
         std::wbuffer_convert<std::codecvt_utf8<wchar_t> > mybuf(bytestream.rdbuf());
         std::wostream mystr(&mybuf);
         mystr << L"Hello" << std::endl;
+        storage = bytestream.str();
     }
     {
-        std::ifstream bytestream("myfile.txt");
+        std::istringstream bytestream(storage);
         std::wbuffer_convert<std::codecvt_utf8<wchar_t> > mybuf(bytestream.rdbuf());
         std::wistream mystr(&mybuf);
         std::wstring ws;
         mystr >> ws;
         assert(ws == L"Hello");
     }
-    std::remove("myfile.txt");
 
     return 0;
 }

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.dat

-123456789
 

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow.pass.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
 //
 //===----------------------------------------------------------------------===//
 
-// FILE_DEPENDENCIES: underflow.dat, underflow_utf8.dat
-
 // <locale>
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 // wbuffer_convert<Codecvt, Elem, Tr>
 
 // int_type underflow();
 
 // This test is not entirely portable
 
 // XFAIL: no-wide-characters
 
 #include <locale>
-#include <codecvt>
-#include <fstream>
 #include <cassert>
+#include <codecvt>
+#include <sstream>
 
 #include "test_macros.h"
 
 struct test_buf
     : public std::wbuffer_convert<std::codecvt_utf8<wchar_t> >
 {
     typedef std::wbuffer_convert<std::codecvt_utf8<wchar_t> > base;
     typedef base::char_type   char_type;
     typedef base::int_type    int_type;
     typedef base::traits_type traits_type;
 
     explicit test_buf(std::streambuf* sb) : base(sb) {}
 
     char_type* eback() const {return base::eback();}
     char_type* gptr()  const {return base::gptr();}
     char_type* egptr() const {return base::egptr();}
     void gbump(int n) {base::gbump(n);}
 
     virtual int_type underflow() {return base::underflow();}
 };
 
 int main(int, char**)
 {
     {
-        std::ifstream bs("underflow.dat");
+        std::string s = "123456789";
+        std::istringstream bs(s);
         test_buf f(bs.rdbuf());
         assert(f.eback() == 0);
         assert(f.gptr() == 0);
         assert(f.egptr() == 0);
         assert(f.underflow() == L'1');
         assert(f.eback() != 0);
         assert(f.eback() == f.gptr());
         assert(*f.gptr() == L'1');
         assert(f.egptr() - f.eback() == 9);
     }
     {
-        std::ifstream bs("underflow.dat");
+        std::string s = "123456789";
+        std::istringstream bs(s);
         test_buf f(bs.rdbuf());
         assert(f.eback() == 0);
         assert(f.gptr() == 0);
         assert(f.egptr() == 0);
         assert(f.underflow() == L'1');
         assert(f.eback() != 0);
         assert(f.eback() == f.gptr());
         assert(*f.gptr() == L'1');
         assert(f.egptr() - f.eback() == 9);
         f.gbump(8);
         assert(f.sgetc() == L'9');
         assert(f.eback()[0] == L'1');
         assert(f.eback()[1] == L'2');
         assert(f.eback()[2] == L'3');
         assert(f.eback()[3] == L'4');
         assert(f.gptr() - f.eback() == 8);
         assert(*f.gptr() == L'9');
         assert(f.egptr() - f.gptr() == 1);
     }
     {
-        std::ifstream bs("underflow_utf8.dat");
+        std::string s = "乑乒乓";
+        std::istringstream bs(s);
         test_buf f(bs.rdbuf());
         assert(f.sbumpc() == 0x4E51);
         assert(f.sbumpc() == 0x4E52);
         assert(f.sbumpc() == 0x4E53);
         assert(f.sbumpc() == test_buf::traits_type::eof());
     }
 
     return 0;
 }

libcxx/test/std/localization/locales/locale.convenience/conversions/conversions.buffer/underflow_utf8.dat

-乑乒乓
 

libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp

 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include "test.hpp"
 
 #include <algorithm>
 #include <array>
 #include <assert.h>
 #include <charconv>
 #include <chrono>
 #include <cmath>
-#include <fstream>
 #include <functional>
 #include <iterator>
 #include <limits>
 #include <locale>
 #include <optional>
 #include <random>
 #include <set>
 #include <stdint.h>

 #include "float_from_chars_test_cases.hpp"
 #include "float_general_precision_to_chars_test_cases.hpp"
 #include "float_hex_precision_to_chars_test_cases.hpp"
 #include "float_scientific_precision_to_chars_test_cases.hpp"
 #include "float_to_chars_test_cases.hpp"
 
 using namespace std;
 
-void initialize_randomness(mt19937_64& mt64, const int argc, char** const argv) {
+void initialize_randomness(mt19937_64& mt64, const int argc, char** const /*argv*/) {
     constexpr size_t n = mt19937_64::state_size;
     constexpr size_t w = mt19937_64::word_size;
     static_assert(w % 32 == 0);
     constexpr size_t k = w / 32;
 
     vector<uint32_t> vec(n * k);
 
     puts("USAGE:");
     puts("test.exe              : generates seed data from random_device.");
-    puts("test.exe filename.txt : loads seed data from a given text file.");
 
     if (argc == 1) {
         random_device rd;
         generate(vec.begin(), vec.end(), ref(rd));
         puts("Generated seed data.");
-    } else if (argc == 2) {
-        const char* const filename = argv[1];
-
-        ifstream file(filename);
-
-        if (!file) {
-            printf("ERROR: Can't open %s.\n", filename);
-            abort();
-        }
-
-        for (auto& elem : vec) {
-            file >> elem;
-
-            if (!file) {
-                printf("ERROR: Can't read seed data from %s.\n", filename);
-                abort();
-            }
-        }
-
-        printf("Loaded seed data from %s.\n", filename);
     } else {
         puts("ERROR: Too many command-line arguments.");
         abort();
     }
 
     puts("SEED DATA:");
     for (const auto& elem : vec) {
         printf("%zu ", static_cast<size_t>(elem));

libcxx/test/support/test_macros.h

 #if defined(_LIBCPP_HAS_NO_THREADS)
 #  define TEST_HAS_NO_THREADS
 #endif
 
 #if defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #  define TEST_HAS_NO_FILESYSTEM_LIBRARY
 #endif
 
+#if defined(_LIBCPP_HAS_NO_FSTREAM)
+#  define TEST_HAS_NO_FSTREAM
+#endif
+
 #if defined(_LIBCPP_HAS_NO_FGETPOS_FSETPOS)
 #  define TEST_HAS_NO_FGETPOS_FSETPOS
 #endif
 
 #if defined(_LIBCPP_HAS_NO_C8RTOMB_MBRTOC8)
 #  define TEST_HAS_NO_C8RTOMB_MBRTOC8
 #endif
 

libcxx/utils/ci/buildkite-pipeline.yml

- label: "No random device"
         queue: "libcxx-builders"
         os: "linux"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2
       timeout_in_minutes: 120
 
+    - label: "No fstream"
+      command: "libcxx/utils/ci/run-buildbot generic-no-fstream"
+      artifact_paths:
+        - "**/test-results.xml"
+        - "**/*.abilist"
+      env:
+          CC: "clang-${LLVM_HEAD_VERSION}"
+          CXX: "clang++-${LLVM_HEAD_VERSION}"
+      agents:
+        queue: "libcxx-builders"
+        os: "linux"
+      retry:
+        automatic:
+          - exit_status: -1  # Agent was lost
+            limit: 2
+      timeout_in_minutes: 120
+
     - label: "No locale"
       command: "libcxx/utils/ci/run-buildbot generic-no-localization"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       env:
           CC: "clang-${LLVM_HEAD_VERSION}"
           CXX: "clang++-${LLVM_HEAD_VERSION}"

libcxx/utils/ci/run-buildbot

! grep -rn '[^ -~]' libcxx/include libcxx/src libcxx/test libcxx/benchmarks \
            --exclude '*.dat' \
            --exclude 'escaped_output.*.pass.cpp' \
            --exclude 'format_tests.h' \
            --exclude 'formatter.*.pass.cpp' \
            --exclude 'grep.pass.cpp' \
            --exclude 'locale-specific_form.pass.cpp' \
            --exclude 'ostream.pass.cpp' \
            --exclude 'std_format_spec_string_unicode.bench.cpp' \
+           --exclude 'underflow.pass.cpp' \
            || false
 
     # Reject code with trailing whitespace
     ! grep -rn '[[:blank:]]$' libcxx/include libcxx/src libcxx/test libcxx/benchmarks || false
 ;;
 generic-cxx03)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-cxx03.cmake"
generic-no-filesystem)
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-filesystem.cmake"
     check-runtimes
 ;;
 generic-no-random_device)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-random_device.cmake"
     check-runtimes
 ;;
+generic-no-fstream)
+    clean
+    generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-fstream.cmake"
+    check-runtimes
+;;
 generic-no-localization)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-localization.cmake"
     check-runtimes
 ;;
 generic-no-unicode)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-unicode.cmake"

libcxx/utils/generate_header_tests.py

header_restrictions = {
     "shared_mutex": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "stdatomic.h": "__cplusplus > 202002L && !defined(_LIBCPP_HAS_NO_THREADS)",
     "thread": "!defined(_LIBCPP_HAS_NO_THREADS)",
 
     "filesystem": "!defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)",
 
     "clocale": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "codecvt": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "fstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
+    "fstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)",
     "iomanip": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "ios": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "iostream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "istream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "locale.h": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "locale": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "ostream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "regex": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",

libcxx/utils/libcxx/test/features.py

macros = {
   '_LIBCPP_HAS_NO_THREADS': 'no-threads',
   '_LIBCPP_HAS_THREAD_API_EXTERNAL': 'libcpp-has-thread-api-external',
   '_LIBCPP_HAS_THREAD_API_PTHREAD': 'libcpp-has-thread-api-pthread',
   '_LIBCPP_NO_VCRUNTIME': 'libcpp-no-vcruntime',
   '_LIBCPP_ABI_VERSION': 'libcpp-abi-version',
   '_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY': 'no-filesystem',
   '_LIBCPP_HAS_NO_RANDOM_DEVICE': 'no-random-device',
   '_LIBCPP_HAS_NO_LOCALIZATION': 'no-localization',
+  '_LIBCPP_HAS_NO_FSTREAM': 'no-fstream',
   '_LIBCPP_HAS_NO_WIDE_CHARACTERS': 'no-wide-characters',
   '_LIBCPP_HAS_NO_UNICODE': 'libcpp-has-no-unicode',
   '_LIBCPP_ENABLE_DEBUG_MODE': 'libcpp-has-debug-mode',
 }
 for macro, feature in macros.items():
   DEFAULT_FEATURES.append(
     Feature(name=lambda cfg, m=macro, f=feature: f + ('={}'.format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ''),
             when=lambda cfg, m=macro: m in compilerMacros(cfg))