[libc++] Expand the contents of LIBCXX_ENABLE_FILESYSTEM

[ldionne]

Summary

Since LIBCXX_ENABLE_FILESYSTEM now truly represents whether the
platform supports a filesystem (as opposed to whether the <filesystem>
library is provided), we can provide a few additional classes from
the <filesystem> library even when the platform does not have support
for a filesystem. For example, this allows performing path manipulations
using std::filesystem::path even on platforms where there is no actual
filesystem.

rdar://107061236

[ldionne]

This one isn't ready for review yet. I'm uploading it so that folks can see the end goal I'm driving towards with the long stack of patches.

[ldionne]

Rebase onto main and complete patch (to my knowledge, CI will tell).

[ldionne]

Rebase after editing parent revisions to poke CI

[ldionne]

Rebase after fixing format.

[ldionne]

Add missing includes

[ldionne]

Fix modular CI

[Mordante]

Thanks for working on this! In general LGTM, but a I have some questions.

libcxx/include/__filesystem/copy_options.h

22

I think it makes sense to mention this in the release notes.

libcxx/include/__filesystem/directory_options.h

24

Why can this be removed here and not in other places?

libcxx/include/fstream

199

Did you see the comments in D152168 and the patch D153327?

[ldionne]

libcxx/include/__filesystem/directory_options.h

24

It's removed here because it does not fundamentally depend on anything in the dylib. Originally, I had marked everything in <filesystem> with availability macros using this PUSH macro. When <filesystem> was split out, the PUSH was copied to all the sub-headers, even though some parts of <filesystem> did not technically require it because they don't depend on anything in the dylib.

libcxx/include/fstream

199

I did not until now, but thanks for the heads up.

[ldionne]

Rebase and update w/ release note.

[ldionne]

Fix Windows and back-deployment issues.

[ldionne]

Add missing backdeployment annotations and rebase.

[ldionne]

Rebase and fix CI issues in added tests.

[Prabhuk]

Hi! This patch seems to break some of the Fuchsia builders. Please find the URL for the failed build below:

https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8777129470970901217/+/u/clang/install/stdout

[16/25](2) Building CXX object libcxx/src/CMakeFiles/cxx_static.dir/filesystem/filesystem_clock.cpp.obj
FAILED: libcxx/src/CMakeFiles/cxx_static.dir/filesystem/filesystem_clock.cpp.obj 
/b/s/w/ir/x/w/staging/llvm_build/./bin/clang-cl --target=x86_64-pc-windows-msvc  /nologo -TP -DUNICODE -D_ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH -D_ALLOW_MSC_VER_MISMATCH -D_CRTBLD -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_CRT_STDIO_ISO_WIDE_SPECIFIERS -D_GLIBCXX_ASSERTIONS -D_LIBCPP_BUILDING_LIBRARY -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS="" -D_LIBCPP_ENABLE_ASSERTIONS -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -D_LIBCPP_REMOVE_TRANSITIVE_INCLUDES -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -I/b/s/w/ir/x/w/llvm-llvm-project/libcxx/src -I/b/s/w/ir/x/w/staging/llvm_build/include/c++/v1 -I/b/s/w/ir/x/w/staging/llvm_build/include/x86_64-pc-windows-msvc/c++/v1 -Xclang -ivfsoverlay -Xclang /b/s/w/ir/cache/windows_sdk/llvm-vfsoverlay.yaml /winsysroot /b/s/w/ir/cache/windows_sdk /Zc:inline /Zc:__cplusplus /Oi /bigobj /permissive- /W4 -wd4141 -wd4146 -wd4244 -wd4267 -wd4291 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd5105 -wd4324 -w14062 -we4238 /Gw -no-canonical-prefixes /MD /Zi /O2 /Ob1 -std:c++20 -UNDEBUG -W4 -Wextra -Wnewline-eof -Wshadow -Wwrite-strings -Wno-unused-parameter -Wno-long-long -Werror=return-type -Wextra-semi -Wundef -Wunused-template -Wformat-nonliteral -Wno-user-defined-literals -Wno-covered-switch-default -Wno-suggest-override -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-c++11-compat -Wno-undef -Wno-reserved-id-macro -Wno-gnu-include-next -Wno-gcc-compat -Wno-zero-as-null-pointer-constant -Wno-deprecated-dynamic-exception-spec -Wno-sign-conversion -Wno-old-style-cast -Wno-deprecated -Wno-shift-sign-overflow -Wno-double-promotion -Wno-error -EHsc /showIncludes /Folibcxx/src/CMakeFiles/cxx_static.dir/filesystem/filesystem_clock.cpp.obj /Fdlibcxx/src/CMakeFiles/cxx_static.dir/cxx_static.pdb -c -- /b/s/w/ir/x/w/llvm-llvm-project/libcxx/src/filesystem/filesystem_clock.cpp
In file included from /b/s/w/ir/x/w/llvm-llvm-project/libcxx/src/filesystem/filesystem_clock.cpp:14:
/b/s/w/ir/x/w/llvm-llvm-project/libcxx/src/filesystem/posix_compat.h(362,28): error: use of undeclared identifier 'status'
  362 |     const file_status st = status(dir, local_ec);
      |                            ^
/b/s/w/ir/x/w/llvm-llvm-project/libcxx/src/filesystem/posix_compat.h(363,10): error: use of undeclared identifier 'exists'; did you mean 'exit'?
  363 |     if (!exists(st) || is_directory(st))
      |          ^~~~~~
      |          exit
/b/s/w/ir/x/w/staging/llvm_build/include/c++/v1/cstdlib(126,9): note: 'exit' declared here
  126 | using ::exit _LIBCPP_USING_IF_EXISTS;
      |         ^
In file included from /b/s/w/ir/x/w/llvm-llvm-project/libcxx/src/filesystem/filesystem_clock.cpp:14:
/b/s/w/ir/x/w/llvm-llvm-project/libcxx/src/filesystem/posix_compat.h(363,17): error: no viable conversion from 'const file_status' to 'int'
  363 |     if (!exists(st) || is_directory(st))
      |                 ^~
/b/s/w/ir/cache/windows_sdk/Windows Kits/10/Include/10.0.19041.0/ucrt/stdlib.h(56,62): note: passing argument to parameter '_Code' here
   56 |     _ACRTIMP __declspec(noreturn) void __cdecl exit(_In_ int _Code);
      |                                                              ^
In file included from /b/s/w/ir/x/w/llvm-llvm-project/libcxx/src/filesystem/filesystem_clock.cpp:14:
/b/s/w/ir/x/w/llvm-llvm-project/libcxx/src/filesystem/posix_compat.h(363,24): error: use of undeclared identifier 'is_directory'
  363 |     if (!exists(st) || is_directory(st))
      |                        ^
4 errors generated.
[17/25](1) Building CXX object compiler-rt/lib/fuzzer/CMakeFiles/RTfuzzer.x86_64.dir/FuzzerUtilWindows.cpp.obj
[18/25](0) Building CXX object compiler-rt/lib/orc/CMakeFiles/RTOrc.x86_64.dir/coff_platform.cpp.obj
In file included from /b/s/w/ir/x/w/llvm-llvm-project/compiler-rt/lib/orc/coff_platform.cpp:20:

We are investigating this from our end as well.

[phosek]

We reproduced the issue. We currently disable filesystem support on Windows by setting LIBCXX_ENABLE_FILESYSTEM to OFF, see https://github.com/llvm/llvm-project/blob/7075f9d926c93efefacb72caf17e93ae00b3703b/clang/cmake/caches/Fuchsia-stage2.cmake#L122. Even when filesystem is disabled, libc++ still builds filesystem_clock.cpp (https://github.com/llvm/llvm-project/blob/be02f912d6b9b515a1d1b30cf06dfff1c085ea34/libcxx/src/CMakeLists.txt#L15) and filesystem_clock.cpp includes posix_compat.h (https://github.com/llvm/llvm-project/blob/be02f912d6b9b515a1d1b30cf06dfff1c085ea34/libcxx/src/filesystem/filesystem_clock.cpp#L14) which on Windows calls functions like status (https://github.com/llvm/llvm-project/blob/be02f912d6b9b515a1d1b30cf06dfff1c085ea34/libcxx/src/filesystem/posix_compat.h#L362), but that function is declared in __filesystem/operations.h (https://github.com/llvm/llvm-project/blob/be02f912d6b9b515a1d1b30cf06dfff1c085ea34/libcxx/include/__filesystem/operations.h#L187) but after this change, all those declarations aren't omitted when LIBCXX_ENABLE_FILESYSTEM is disabled (https://github.com/llvm/llvm-project/blob/be02f912d6b9b515a1d1b30cf06dfff1c085ea34/libcxx/include/__filesystem/operations.h#L31).

Can we either revert this change, or at least undo the change to __filesystem/operations.h?

[phosek]

@ldionne Ping?

[glandium]

This also affects wasi for the same reason (filesystem_clock.cpp still being compiled), but a different cause: wasi doesn't have sys/statvfs.h, so the failure is

libcxx/src/filesystem/posix_compat.h:42:11: fatal error: 'sys/statvfs.h' file not found

[barannikov88]

In D152382#4462610, @glandium wrote:

This also affects wasi for the same reason (filesystem_clock.cpp still being compiled), but a different cause: wasi doesn't have sys/statvfs.h, so the failure is

libcxx/src/filesystem/posix_compat.h:42:11: fatal error: 'sys/statvfs.h' file not found

Same issue for me.

[ldionne]

The fix here would probably be to split TimeSpec out of posix_compat.h so that it can be included from filesystem_clock.cpp without pulling in all of posix_compat.h. Or we could also conditionalize the definition of some things inside posix_compat.h based on _LIBCPP_HAS_NO_FILESYSTEM.

TBH, it's kind of hard for me to formulate a patch without seeing exactly what the issue is and being able to reproduce, given that those are not part of our CI configurations. I think it would be a lot easier if one of the affected folks came up with that patch -- I'll be happy to review it, it's just that I'll be shooting blind if I try to fix this issue for you folks without being able to see it first hand.

[barannikov88]

In D152382#4468473, @ldionne wrote:

The fix here would probably be to split TimeSpec out of posix_compat.h so that it can be included from filesystem_clock.cpp without pulling in all of posix_compat.h. Or we could also conditionalize the definition of some things inside posix_compat.h based on _LIBCPP_HAS_NO_FILESYSTEM.

TBH, it's kind of hard for me to formulate a patch without seeing exactly what the issue is and being able to reproduce, given that those are not part of our CI configurations. I think it would be a lot easier if one of the affected folks came up with that patch -- I'll be happy to review it, it's just that I'll be shooting blind if I try to fix this issue for you folks without being able to see it first hand.

If that helps, our setup is baremetal newlib (custom target). Newlib provides some sys headers, but apparently not this one https://cygwin.com/git/?p=newlib-cygwin.git;a=tree;f=newlib/libc/include/sys.
I guess it would be the same with picolibc https://github.com/picolibc/picolibc/tree/main/newlib/libc/include/sys.

[ldionne]

In D152382#4468599, @barannikov88 wrote:

If that helps, our setup is baremetal newlib (custom target). Newlib provides some sys headers, but apparently not this one https://cygwin.com/git/?p=newlib-cygwin.git;a=tree;f=newlib/libc/include/sys.
I guess it would be the same with picolibc https://github.com/picolibc/picolibc/tree/main/newlib/libc/include/sys.

https://reviews.llvm.org/D154246 doesn't seem to have run into the same issues (so far).

Anyway, I'm trying something out in D154390 but it's a bit of a blind attempt.

[glandium]

In D152382#4469614, @ldionne wrote:

Anyway, I'm trying something out in D154390 but it's a bit of a blind attempt.

FWIW, that fixes the issue for wasi.

[barannikov88]

In D152382#4469614, @ldionne wrote:

In D152382#4468599, @barannikov88 wrote:

If that helps, our setup is baremetal newlib (custom target). Newlib provides some sys headers, but apparently not this one https://cygwin.com/git/?p=newlib-cygwin.git;a=tree;f=newlib/libc/include/sys.
I guess it would be the same with picolibc https://github.com/picolibc/picolibc/tree/main/newlib/libc/include/sys.

https://reviews.llvm.org/D154246 doesn't seem to have run into the same issues (so far).

https://reviews.llvm.org/D154246#4468049

Anyway, I'm trying something out in D154390 but it's a bit of a blind attempt.

Thanks!

[michaelplatings]

In D152382#4469614, @ldionne wrote:

Anyway, I'm trying something out in D154390

This doesn't yet fix the issue when building with picolibc. It fails with:

filesystem_clock.cpp:42:12: error: use of undeclared identifier 'clock_gettime'

I think an option is needed in libcxx/CMakeLists.txt to disable building filesystem_clock.cpp.

In D152382#4469614, @ldionne wrote:

it's a bit of a blind attempt.

To help with this you can apply the patch from D154246 and run CXX=clang++ CC=clang libcxx/utils/ci/run-buildbot armv6m-picolibc.

[ldionne]

In D152382#4470740, @michaelplatings wrote:

In D152382#4469614, @ldionne wrote:

Anyway, I'm trying something out in D154390

This doesn't yet fix the issue when building with picolibc. It fails with:

filesystem_clock.cpp:42:12: error: use of undeclared identifier 'clock_gettime'

I think an option is needed in libcxx/CMakeLists.txt to disable building filesystem_clock.cpp.

Does that mean the platform doesn't provide a way to check the time, or is it that the API it provides is just different? How is e.g. std::system_clock implemented on that platform?

[barannikov88]

FWIW this looks related: D88825

[michaelplatings]

Does that mean the platform doesn't provide a way to check the time, or is it that the API it provides is just different? How is e.g. std::system_clock implemented on that platform?

From chrono.cpp:

#if !defined(__APPLE__) && defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0
# define _LIBCPP_USE_CLOCK_GETTIME
#endif

...

#elif defined(CLOCK_REALTIME) && defined(_LIBCPP_USE_CLOCK_GETTIME)

...

#else

static system_clock::time_point __libcpp_system_clock_now() {
    timeval tv;
    gettimeofday(&tv, 0);
    return system_clock::time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
}

#endif

Picolibc does not define _POSIX_TIMERS so it looks like gettimeofday is used. Perhaps the same could be done in filesystem_clock.cpp?

[ldionne]

See D154457.

libcxx/docs/ReleaseNotes.rst

 - `D122780 <https://reviews.llvm.org/D122780>`_ Improved the performance of ``std::sort`` and ``std::ranges::sort``
   by up to 50% for arithmetic types and by approximately 10% for other types.
 
 - The ``<format>`` header is no longer considered experimental. Some
   ``std::formatter`` specializations are not yet available since the class used
   in the specialization has not been implemented in libc++. This prevents the
   feature-test macro to be set.
 
+- Platforms that don't have support for a filesystem can now still take advantage of some parts of ``<filesystem>``.
+  Anything that does not rely on having an actual filesystem available will now work, such as ``std::filesystem::path``,
+  ``std::filesystem::perms`` and similar classes.
+
 Deprecations and Removals
 -------------------------
 
 - The ``<experimental/coroutine>`` header has been removed in this release. The ``<coroutine>`` header
   has been shipping since LLVM 14, so the Coroutines TS implementation is being removed per our policy
   for removing TSes.
 
 - Several incidental transitive includes have been removed from libc++. Those

libcxx/include/__filesystem/copy_options.h

 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
-
 enum class _LIBCPP_ENUM_VIS copy_options : unsigned short {
   none = 0,
   skip_existing = 1,
   overwrite_existing = 2,
   update_existing = 4,
   recursive = 8,
   copy_symlinks = 16,
   skip_symlinks = 32,
inline copy_options& operator|=(copy_options& __lhs, copy_options __rhs) {
   return __lhs = __lhs | __rhs;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline copy_options& operator^=(copy_options& __lhs, copy_options __rhs) {
   return __lhs = __lhs ^ __rhs;
 }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_COPY_OPTIONS_H

libcxx/include/__filesystem/directory_entry.h

 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-#ifndef _LIBCPP_CXX03_LANG
+#if !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
-
 class directory_entry {
   typedef _VSTD_FS::path _Path;
 
 public:
   // constructors and destructors
   _LIBCPP_HIDE_FROM_ABI directory_entry() noexcept = default;
   _LIBCPP_HIDE_FROM_ABI directory_entry(directory_entry const&) = default;
   _LIBCPP_HIDE_FROM_ABI directory_entry(directory_entry&&) noexcept = default;
_LIBCPP_HIDE_FROM_ABI __dir_element_proxy(__dir_element_proxy&& __o)
       : __elem_(_VSTD::move(__o.__elem_)) {}
   directory_entry __elem_;
 };
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FILESYSTEM_DIRECTORY_ENTRY_H

libcxx/include/__filesystem/directory_iterator.h

 #include <__system_error/error_code.h>
 #include <__utility/move.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
 class _LIBCPP_HIDDEN __dir_stream;
 class directory_iterator {
 public:

 inline constexpr bool _VSTD::ranges::enable_borrowed_range<_VSTD_FS::directory_iterator> = true;
 
 template <>
 _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
 inline constexpr bool _VSTD::ranges::enable_view<_VSTD_FS::directory_iterator> = true;
 
 #endif // _LIBCPP_STD_VER >= 20
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 #endif // _LIBCPP___FILESYSTEM_DIRECTORY_ITERATOR_H

libcxx/include/__filesystem/directory_options.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
-
 enum class _LIBCPP_ENUM_VIS directory_options : unsigned char {
   none = 0,
   follow_directory_symlink = 1,
   skip_permission_denied = 2
 };
 
 _LIBCPP_INLINE_VISIBILITY
 inline constexpr directory_options operator&(directory_options __lhs,

 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline directory_options& operator^=(directory_options& __lhs,
                                      directory_options __rhs) {
   return __lhs = __lhs ^ __rhs;
 }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_DIRECTORY_OPTIONS_H

libcxx/include/__filesystem/file_status.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
-
 class _LIBCPP_EXPORTED_FROM_ABI file_status {
 public:
   // constructors
   _LIBCPP_INLINE_VISIBILITY
   file_status() noexcept : file_status(file_type::none) {}
   _LIBCPP_INLINE_VISIBILITY
   explicit file_status(file_type __ft, perms __prms = perms::unknown) noexcept
       : __ft_(__ft),

 
 #  endif
 
 private:
   file_type __ft_;
   perms __prms_;
 };
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_FILE_STATUS_H

libcxx/include/__filesystem/filesystem_error.h

struct _LIBCPP_HIDDEN _Storage {
 
     path __p1_;
     path __p2_;
     string __what_;
   };
   shared_ptr<_Storage> __storage_;
 };
 
-// TODO(ldionne): We need to pop the pragma and push it again after
-//                filesystem_error to work around PR41078.
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
-
 #  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 template <class... _Args>
-_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_filesystem_error(_Args&&... __args) {
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY void
+__throw_filesystem_error(_Args&&... __args) {
   throw filesystem_error(_VSTD::forward<_Args>(__args)...);
 }
 #  else
 template <class... _Args>
-_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_filesystem_error(_Args&&...) {
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY void
+__throw_filesystem_error(_Args&&...) {
   _LIBCPP_VERBOSE_ABORT("filesystem_error was thrown in -fno-exceptions mode");
 }
 #  endif
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H

libcxx/include/__filesystem/operations.h

 #include <__filesystem/space_info.h>
 #include <__system_error/error_code.h>
 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
 _LIBCPP_EXPORTED_FROM_ABI path __absolute(const path&, error_code* __ec = nullptr);
 _LIBCPP_EXPORTED_FROM_ABI path __canonical(const path&, error_code* __ec = nullptr);
 _LIBCPP_EXPORTED_FROM_ABI bool __copy_file(const path& __from, const path& __to, copy_options __opt, error_code* __ec = nullptr);

 inline _LIBCPP_HIDE_FROM_ABI path temp_directory_path(error_code& __ec) { return __temp_directory_path(&__ec); }
 inline _LIBCPP_HIDE_FROM_ABI path weakly_canonical(path const& __p) { return __weakly_canonical(__p); }
 inline _LIBCPP_HIDE_FROM_ABI path weakly_canonical(path const& __p, error_code& __ec) { return __weakly_canonical(__p, &__ec); }
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 #endif // _LIBCPP___FILESYSTEM_OPERATIONS_H

libcxx/include/__filesystem/path_iterator.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
-
 class _LIBCPP_EXPORTED_FROM_ABI path::iterator {
 public:
   enum _ParserState : unsigned char {
     _Singular,
     _BeforeBegin,
     _InRootName,
     _InRootDir,
     _InFilenames,
private:
   iterator& __decrement();
 
   path __stashed_elem_;
   const path* __path_ptr_;
   path::__string_view __entry_;
   _ParserState __state_;
 };
 
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
 inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path::iterator& __lhs,
                                                  const path::iterator& __rhs) {
   return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
          __lhs.__entry_.data() == __rhs.__entry_.data();
 }
 
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
 inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs,
                                                  const path::iterator& __rhs) {
   return !(__lhs == __rhs);
 }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_PATH_ITERATOR_H

libcxx/include/__filesystem/perm_options.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
-
 enum class _LIBCPP_ENUM_VIS perm_options : unsigned char {
   replace = 1,
   add = 2,
   remove = 4,
   nofollow = 8
 };
 
 _LIBCPP_INLINE_VISIBILITY
inline perm_options& operator|=(perm_options& __lhs, perm_options __rhs) {
   return __lhs = __lhs | __rhs;
 }
 
 _LIBCPP_INLINE_VISIBILITY
 inline perm_options& operator^=(perm_options& __lhs, perm_options __rhs) {
   return __lhs = __lhs ^ __rhs;
 }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_PERM_OPTIONS_H

libcxx/include/__filesystem/perms.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
-
 // On Windows, these permission bits map to one single readonly flag per
 // file, and the executable bit is always returned as set. When setting
 // permissions, as long as the write bit is set for either owner, group or
 // others, the readonly flag is cleared.
 enum class _LIBCPP_ENUM_VIS perms : unsigned {
   none = 0,
 
   owner_read = 0400,

 inline perms& operator&=(perms& __lhs, perms __rhs) { return __lhs = __lhs & __rhs; }
 
 _LIBCPP_INLINE_VISIBILITY
 inline perms& operator|=(perms& __lhs, perms __rhs) { return __lhs = __lhs | __rhs; }
 
 _LIBCPP_INLINE_VISIBILITY
 inline perms& operator^=(perms& __lhs, perms __rhs) { return __lhs = __lhs ^ __rhs; }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_PERMS_H

libcxx/include/__filesystem/recursive_directory_iterator.h

 #include <__system_error/error_code.h>
 #include <__utility/move.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
 class recursive_directory_iterator {
 public:
   using value_type = directory_entry;

 inline constexpr bool _VSTD::ranges::enable_borrowed_range<_VSTD_FS::recursive_directory_iterator> = true;
 
 template <>
 _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
 inline constexpr bool _VSTD::ranges::enable_view<_VSTD_FS::recursive_directory_iterator> = true;
 
 #endif // _LIBCPP_STD_VER >= 20
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 #endif // _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H

libcxx/include/__filesystem/space_info.h

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
-
 struct _LIBCPP_EXPORTED_FROM_ABI space_info {
   uintmax_t capacity;
   uintmax_t free;
   uintmax_t available;
 
 #  if _LIBCPP_STD_VER >= 20
   friend _LIBCPP_HIDE_FROM_ABI bool operator==(const space_info&, const space_info&) = default;
 #  endif
 };
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 #endif // _LIBCPP_CXX03_LANG
 
 #endif // _LIBCPP___FILESYSTEM_SPACE_INFO_H

libcxx/include/filesystem

 #include <__filesystem/u8path.h>
 #include <version>
 
 // standard-mandated includes
 
 // [fs.filesystem.syn]
 #include <compare>
 
-#if defined(_LIBCPP_HAS_NO_FILESYSTEM)
-# error "The <filesystem> library is not supported since libc++ has been configured without support for a filesystem."
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstdlib>
 #  include <system_error>
 #endif
 
 #endif // _LIBCPP_FILESYSTEM

libcxx/include/fstream

 #include <__availability>
 #include <__config>
 #include <__fwd/fstream.h>
 #include <__locale>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <cstdio>
+#include <filesystem>
 #include <istream>
 #include <ostream>
 #include <typeinfo>
 #include <version>
 
-#if !defined(_LIBCPP_HAS_NO_FILESYSTEM)
-#   include <filesystem>
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 #if defined(_LIBCPP_MSVCRT) || defined(_NEWLIB_VERSION)

libcxx/include/module.modulemap.in

module __filesystem {
       module file_time_type               { private header "__filesystem/file_time_type.h" }
       module file_type                    { private header "__filesystem/file_type.h" }
       module filesystem_error             { private header "__filesystem/filesystem_error.h" }
       module operations                   { private header "__filesystem/operations.h" }
       module path                         {
         private header "__filesystem/path.h"
         export functional.__functional.hash
         export functional.__functional.unary_function
+        export string
       }
       module path_iterator                { private header "__filesystem/path_iterator.h" }
       module perm_options                 { private header "__filesystem/perm_options.h" }
       module perms                        { private header "__filesystem/perms.h" }
       module recursive_directory_iterator { private header "__filesystem/recursive_directory_iterator.h" }
       module space_info                   { private header "__filesystem/space_info.h" }
       module u8path                       { private header "__filesystem/u8path.h" }
     }

libcxx/src/CMakeLists.txt

 set(LIBCXX_LIB_CMAKEFILES_DIR "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}"  PARENT_SCOPE)
 
 # Get sources
 set(LIBCXX_SOURCES
   algorithm.cpp
   any.cpp
   atomic.cpp
   barrier.cpp
   bind.cpp
   charconv.cpp
   chrono.cpp
   condition_variable.cpp
   condition_variable_destructor.cpp
   exception.cpp
+  filesystem/filesystem_clock.cpp
+  filesystem/filesystem_error.cpp
+  filesystem/path_parser.h
+  filesystem/path.cpp
   functional.cpp
   future.cpp
   hash.cpp
   include/apple_availability.h
   include/atomic_support.h
   include/config_elast.h
   include/refstring.h
   include/ryu/common.h
list(APPEND LIBCXX_SOURCES
     )
 endif()
 
 if (LIBCXX_ENABLE_FILESYSTEM)
   list(APPEND LIBCXX_SOURCES
     filesystem/directory_entry.cpp
     filesystem/directory_iterator.cpp
     filesystem/file_descriptor.h
-    filesystem/filesystem_clock.cpp
-    filesystem/filesystem_error.cpp
     filesystem/operations.cpp
-    filesystem/path_parser.h
-    filesystem/path.cpp
     filesystem/posix_compat.h
     filesystem/time_utils.h
     )
   # Filesystem uses __int128_t, which requires a definition of __muloi4 when
   # compiled with UBSAN. This definition is not provided by libgcc_s, but is
   # provided by compiler-rt. So we need to disable it to avoid having multiple
   # definitions. See filesystem/int128_builtins.cpp.
   if (NOT LIBCXX_USE_COMPILER_RT)

libcxx/test/libcxx/input.output/file.streams/fstreams/fstream.close.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>
 
 // template <class charT, class traits = char_traits<charT> >
 // class basic_fstream
 
 // close();
 
 // Inspired by PR#38052 - std::fstream still good after closing and updating content

libcxx/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
+// UNSUPPORTED: no-filesystem
 // ADDITIONAL_COMPILE_FLAGS: -I %S/../../../../../../src
 
 // This test relies on calling functions from the libcxx internal headers
 // of <filesystem>; the Windows implementation uses different
 // internals and doesn't provide the same set_file_times function as for
 // other platforms.
 // UNSUPPORTED: windows
 

libcxx/test/libcxx/input.output/filesystems/class.path/path.member/path.native.obs/string_alloc.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // These tests require locale for non-char paths
 // UNSUPPORTED: no-localization
 
 // <filesystem>
 
 // class path
 
 // template <class ECharT, class Traits = char_traits<ECharT>,
 //           class Allocator = allocator<ECharT>>
 // basic_string<ECharT, Traits, Allocator>
 // string(const Allocator& a = Allocator()) const;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
-#include "test_macros.h"
-#include "test_iterators.h"
 #include "count_new.h"
+#include "make_string.h"
 #include "min_allocator.h"
-#include "filesystem_test_helper.h"
+#include "test_iterators.h"
+#include "test_macros.h"
 
 
 // the SSO is always triggered for strings of size 2.
 MultiStringType shortString = MKSTR("a");
 MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
 template <class CharT>
 void doShortStringTest(MultiStringType const& MS) {

libcxx/test/libcxx/input.output/filesystems/convert_file_time.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // typedef TrivialClock file_time_type;
 
 // ADDITIONAL_COMPILE_FLAGS: -I %S/../../../../src -Wno-macro-redefined
 
 #include <cassert>

libcxx/test/libcxx/input.output/filesystems/lit.local.cfg

-# Load the same local configuration as the filesystem tests in libcxx/test/std
-import os
-
-std_filesystem_tests = os.path.join(
-    config.test_source_root, "std", "input.output", "filesystems"
-)
-config.load_from_path(os.path.join(std_filesystem_tests, "lit.local.cfg"), lit_config)

libcxx/test/libcxx/transitive_includes.gen.py

for header in public_headers:
 
     # Escape slashes for the awk command below
     escaped_header = header.replace('/', '\/')
 
     print(f"""\
 //--- {header}.sh.cpp
 {lit_header_restrictions.get(header, '')}
 
-// TODO: Fix this test to make it work with filesystem, localization or wide characters disabled
-// UNSUPPORTED{BLOCKLIT}: no-filesystem, no-localization, no-wide-characters
+// TODO: Fix this test to make it work with localization or wide characters disabled
+// UNSUPPORTED{BLOCKLIT}: no-localization, no-wide-characters
 
 // When built with modules, this test doesn't work because --trace-includes doesn't
 // report the stack of includes correctly.
 // UNSUPPORTED{BLOCKLIT}: modules-build
 
 // This test uses --trace-includes, which is not supported by GCC.
 // UNSUPPORTED{BLOCKLIT}: gcc
 

libcxx/test/std/containers/iterator.rel_ops.compile.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: no-filesystem
 // XFAIL: availability-filesystem-missing
 
 // Make sure the various containers' iterators are not broken by the use of `std::rel_ops`.
 
 #include <utility> // for std::rel_ops
 
 #include <array>
 #include <deque>
+#include <filesystem>
 #include <forward_list>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "test_macros.h"
 
-#if TEST_STD_VER >= 11
-#include "filesystem_include.h"
-#endif
-
 #if TEST_STD_VER >= 17
 #include <string_view>
 #endif
 
 #if TEST_STD_VER >= 20
 #include <span>
 #endif
 

 template void test_forward<std::set<int> >();
 template void test_random_access<std::string>();
 template void test_forward<std::unordered_map<int, int> >();
 template void test_forward<std::unordered_multimap<int, int> >();
 template void test_forward<std::unordered_multiset<int> >();
 template void test_forward<std::unordered_set<int> >();
 template void test_random_access<std::vector<int> >();
 
-#if TEST_STD_VER >= 11
+#if TEST_STD_VER >= 17
 void test_directory_iterators() {
-    fs::directory_iterator it;
+#ifndef TEST_HAS_NO_FILESYSTEM
+    std::filesystem::directory_iterator it;
     test_eq(it, it);
 
-    fs::recursive_directory_iterator rdit;
+    std::filesystem::recursive_directory_iterator rdit;
     test_eq(rdit, rdit);
+#endif
 }
 
-template void test_forward<fs::path>();
+template void test_forward<std::filesystem::path>();
 #endif
 
 #if TEST_STD_VER >= 17
 template void test_random_access<std::string_view>();
 #endif
 
 #if TEST_STD_VER >= 20
 void test_span() {
     std::span<int> c;
     std::span<int>::iterator it = c.begin();  // span has no const_iterator
     test_eq(it, it);
     test_lt(it, it);
 }
 #endif

libcxx/test/std/input.output/file.streams/fstreams/filebuf.members/open_path.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: no-filesystem
 
 // UNSUPPORTED: availability-filesystem-missing
 
 // <fstream>
 
 // basic_filebuf<charT,traits>* open(const filesystem::path& p, ios_base::openmode mode);
 
 #include <fstream>

libcxx/test/std/input.output/file.streams/fstreams/fstream.cons/path.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: no-filesystem
 
 // UNSUPPORTED: availability-filesystem-missing
 
 // <fstream>
 
 // plate <class charT, class traits = char_traits<charT> >
 // class basic_fstream
 

libcxx/test/std/input.output/file.streams/fstreams/fstream.members/open_path.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: no-filesystem
 
 // UNSUPPORTED: availability-filesystem-missing
 
 // <fstream>
 
 // plate <class charT, class traits = char_traits<charT> >
 // class basic_fstream
 

libcxx/test/std/input.output/file.streams/fstreams/ifstream.cons/path.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: no-filesystem
 
 // UNSUPPORTED: availability-filesystem-missing
 
 // FILE_DEPENDENCIES: test.dat
 
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >

libcxx/test/std/input.output/file.streams/fstreams/ifstream.members/open_path.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: no-filesystem
 
 // UNSUPPORTED: availability-filesystem-missing
 
 // FILE_DEPENDENCIES: test.dat
 
 // <fstream>
 
 // template <class charT, class traits = char_traits<charT> >

libcxx/test/std/input.output/file.streams/fstreams/ofstream.cons/path.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: no-filesystem
 
 // UNSUPPORTED: availability-filesystem-missing
 
 // <fstream>
 
 // plate <class charT, class traits = char_traits<charT> >
 // class basic_ofstream
 

libcxx/test/std/input.output/file.streams/fstreams/ofstream.members/open_path.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: no-filesystem
 
 // UNSUPPORTED: availability-filesystem-missing
 
 // <fstream>
 
 // plate <class charT, class traits = char_traits<charT> >
 // class basic_ofstream
 

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator(directory_iterator const&);
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator& operator=(directory_iterator const&);
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 // explicit directory_iterator(const path& p);
 // directory_iterator(const path& p, directory_options options);
 // directory_iterator(const path& p, error_code& ec);

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/default_ctor.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator::directory_iterator() noexcept
 
 

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/equal.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 // bool operator==(default_sentinel_t) const noexcept {           // since C++20
 //   return *this == directory_iterator();
 // }

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator& operator++();
 // directory_iterator& increment(error_code& ec);
 

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator(directory_iterator&&) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator& operator=(directory_iterator const&);
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 // directory_iterator begin(directory_iterator iter) noexcept;
 // directory_iterator end(directory_iterator iter) noexcept;
 

libcxx/test/std/input.output/filesystems/class.directory_iterator/iterator_concept_conformance.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // directory_iterator, recursive_directory_iterator
 
 #include "filesystem_include.h"
 
 #include <iterator>
 
 using value_type = fs::directory_entry;

libcxx/test/std/input.output/filesystems/class.directory_iterator/range_concept_conformance.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // directory_iterator
 
 #include "filesystem_include.h"
 
 #include <concepts>
 #include <ranges>
 

libcxx/test/std/input.output/filesystems/class.directory_iterator/types.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 // typedef ... value_type;
 // typedef ... difference_type;
 // typedef ... pointer;

libcxx/test/std/input.output/filesystems/class.filesystem_error/filesystem_error.members.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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: availability-filesystem-missing
 // UNSUPPORTED: c++03
 
 // <filesystem>
 
 // class filesystem_error
 
 // filesystem_error(const string& what_arg, error_code ec);
 // filesystem_error(const string& what_arg, const path& p1, error_code ec);

libcxx/test/std/input.output/filesystems/class.path/path.itr/iterator.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // template <class Source>
 //      path(const Source& source);
 // template <class InputIterator>
 //      path(InputIterator first, InputIterator last);
 
 
 #include "filesystem_include.h"
 #include <cassert>
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
-#include "filesystem_test_helper.h"
+
+template <class Iter1, class Iter2>
+bool checkCollectionsEqual(
+    Iter1 start1, Iter1 const end1
+  , Iter2 start2, Iter2 const end2
+  )
+{
+    while (start1 != end1 && start2 != end2) {
+        if (*start1 != *start2) {
+            return false;
+        }
+        ++start1; ++start2;
+    }
+    return (start1 == end1 && start2 == end2);
+}
+
+template <class Iter1, class Iter2>
+bool checkCollectionsEqualBackwards(
+    Iter1 const start1, Iter1 end1
+  , Iter2 const start2, Iter2 end2
+  )
+{
+    while (start1 != end1 && start2 != end2) {
+        --end1; --end2;
+        if (*end1 != *end2) {
+            return false;
+        }
+    }
+    return (start1 == end1 && start2 == end2);
+}
 
 void checkIteratorConcepts() {
   using namespace fs;
   using It = path::iterator;
   using Traits = std::iterator_traits<It>;
   ASSERT_SAME_TYPE(path::const_iterator, It);
 #if TEST_STD_VER > 17
   static_assert(std::bidirectional_iterator<It>);

libcxx/test/std/input.output/filesystems/class.path/path.member/path.hash_enabled.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // Test that <filesystem> provides all of the arithmetic, enum, and pointer
 // hash specializations.
 
 #include "filesystem_include.h"
 #include "poisoned_hash_helper.h"
 
 int main(int, char**) {
   test_library_hash_specializations_available();
   test_hash_enabled_for_type<fs::path>();
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // These tests require locale for non-char paths
 // UNSUPPORTED: no-localization
 
 // <filesystem>
 
 // class path
 

 #include <type_traits>
 #include <string_view>
 #include <cassert>
 
 // On Windows, the append function converts all inputs (pointers, iterators)
 // to an intermediate path object, causing allocations in cases where no
 // allocations are done on other platforms.
 
-#include "test_macros.h"
-#include "test_iterators.h"
+#include "../path_helper.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
-
+#include "make_string.h"
+#include "test_iterators.h"
+#include "test_macros.h"
 
 struct AppendOperatorTestcase {
   MultiStringType lhs;
   MultiStringType rhs;
   MultiStringType expect_posix;
   MultiStringType expect_windows;
 
   MultiStringType const& expected_result() const {

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path& operator=(path const&);
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/move.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path& operator=(path&&) noexcept
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.path/path.member/path.assign/source.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // These tests require locale for non-char paths
 // UNSUPPORTED: no-localization
 
 // <filesystem>
 
 // class path
 

 #include "filesystem_include.h"
 #include <type_traits>
 #include <string_view>
 #include <cassert>
 
 // On Windows, charset conversions cause allocations in the path class in
 // cases where no allocations are done on other platforms.
 
-#include "test_macros.h"
-#include "test_iterators.h"
+#include "../../path_helper.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
+#include "make_string.h"
+#include "test_iterators.h"
+#include "test_macros.h"
 
 
 template <class CharT>
 void RunTestCase(MultiStringType const& MS) {
   using namespace fs;
   const fs::path::value_type* Expect = MS;
   const CharT* TestPath = MS;
   const CharT* TestPathEnd = StrEnd(TestPath);

libcxx/test/std/input.output/filesystems/class.path/path.member/path.charconv.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 // <filesystem>
 
 // class path
 
 // Test constructors, accessors and modifiers that convert from/to various
 // character encodings. Constructors and modifiers (append, concat,

 // names.
 
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "filesystem_test_helper.h"
+
+#ifdef _WIN32
+#  include <windows.h> // SetFileApisToANSI & friends
+#endif
 
 // Test conversion with strings that fit within the latin1 charset, that fit
 // within one code point in UTF-16, and that can be expressible in certain
 // one-byte code pages.
 static void test_latin_unicode()
 {
   const char16_t u16str[] = { 0xe5, 0xe4, 0xf6, 0x00 };
   const char32_t u32str[] = { 0xe5, 0xe4, 0xf6, 0x00 };

libcxx/test/std/input.output/filesystems/class.path/path.member/path.compare.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // int compare(path const&) const noexcept;
 // int compare(string_type const&) const;
 // int compare(value_type const*) const;
 //
 // bool operator==(path const&, path const&) noexcept;
 // bool operator!=(path const&, path const&) noexcept;
 // bool operator< (path const&, path const&) noexcept;
 // bool operator<=(path const&, path const&) noexcept;
 // bool operator> (path const&, path const&) noexcept;
 // bool operator>=(path const&, path const&) noexcept;
 // strong_ordering operator<=>(path const&, path const&) noexcept;
 //
 // size_t hash_value(path const&) noexcept;
 // template<> struct hash<filesystem::path>;
 
 #include "filesystem_include.h"
+#include <cassert>
+#include <string>
 #include <type_traits>
 #include <vector>
-#include <cassert>
 
-#include "test_macros.h"
+#include "assert_macros.h"
+#include "count_new.h"
 #include "test_comparisons.h"
 #include "test_iterators.h"
-#include "count_new.h"
-#include "filesystem_test_helper.h"
+#include "test_macros.h"
 
 struct PathCompareTest {
   const char* LHS;
   const char* RHS;
   int expect;
 };
 
 #define LONGA "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"

libcxx/test/std/input.output/filesystems/class.path/path.member/path.concat.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // These tests require locale for non-char paths
 // UNSUPPORTED: no-localization
 
 // <filesystem>
 
 // class path
 

 #include <type_traits>
 #include <string>
 #include <string_view>
 #include <cassert>
 
 // On Windows, charset conversions cause allocations in the path class in
 // cases where no allocations are done on other platforms.
 
-#include "test_macros.h"
-#include "test_iterators.h"
+#include "../path_helper.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
+#include "make_string.h"
+#include "test_iterators.h"
+#include "test_macros.h"
 
 
 struct ConcatOperatorTestcase {
   MultiStringType lhs;
   MultiStringType rhs;
   MultiStringType expect;
 };
 

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path(path const&)
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/default.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path() noexcept
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/move.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path(path&&) noexcept
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // These tests require locale for non-char paths
 // UNSUPPORTED: no-localization
 
 // <filesystem>
 
 // class path
 
 // template <class Source>
 //      path(const Source& source);
 // template <class InputIterator>
 //      path(InputIterator first, InputIterator last);
 
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
-#include "test_macros.h"
-#include "test_iterators.h"
+#include "../../path_helper.h"
+#include "make_string.h"
 #include "min_allocator.h"
-#include "filesystem_test_helper.h"
+#include "test_iterators.h"
+#include "test_macros.h"
 
 
 template <class CharT, class ...Args>
 void RunTestCaseImpl(MultiStringType const& MS, Args... args) {
   using namespace fs;
   const fs::path::value_type* Expect = MS;
   const CharT* TestPath = MS;
   const CharT* TestPathEnd = StrEnd(TestPath);

libcxx/test/std/input.output/filesystems/class.path/path.member/path.decompose/empty.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // <filesystem>
 
 // class path
 
 // bool empty() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: availability-filesystem-missing
 
 #include "filesystem_include.h"
 
 void f() {
     fs::path c;
     c.empty(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // 8.4.9 path decomposition [path.decompose]
 //------------------------------------------
 // path root_name() const;

 // iterator end() const;
 
 
 #include "filesystem_include.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <iterator>
+#include <string>
 #include <type_traits>
 #include <vector>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
 
 struct ComparePathExact {
   bool operator()(fs::path const& LHS, std::string const& RHS) const {
     return LHS.string() == RHS;
   }
 };
 
 struct PathDecomposeTestcase

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path lexically_normal() const;
 
 #include "filesystem_include.h"
 #include <cstdio>
 #include <string>
 
-#include "test_macros.h"
+#include "../../path_helper.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
+#include "test_macros.h"
 
 
 int main(int, char**) {
   // clang-format off
   struct {
     std::string input;
     std::string expect;
   } TestCases[] = {

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path lexically_relative(const path& p) const;
 // path lexically_proximate(const path& p) const;
 
 #include "filesystem_include.h"
 #include <cstdio>
 #include <string>
 
-#include "test_macros.h"
+#include "../../path_helper.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
-
+#include "test_macros.h"
 
 int main(int, char**) {
   // clang-format off
   struct {
     std::string input;
     std::string base;
     std::string expect;
   } TestCases[] = {

libcxx/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/generic_string_alloc.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // These tests require locale for non-char paths
 // UNSUPPORTED: no-localization
 
 // <filesystem>
 
 // class path
 
 // template <class ECharT, class Traits = char_traits<ECharT>,
 //           class Allocator = allocator<ECharT>>
 // basic_string<ECharT, Traits, Allocator>
 // generic_string(const Allocator& a = Allocator()) const;
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
-#include "test_macros.h"
-#include "test_iterators.h"
 #include "count_new.h"
+#include "make_string.h"
 #include "min_allocator.h"
-#include "filesystem_test_helper.h"
+#include "test_iterators.h"
+#include "test_macros.h"
 
-MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
+MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
 // generic_string<C, T, A> forwards to string<C, T, A>. Tests for
 // string<C, T, A>() are in "path.native.obs/string_alloc.pass.cpp".
 // generic_string is minimally tested here.
 template <class CharT>
 void doAllocTest()
 {
   using namespace fs;

libcxx/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // These tests require locale for non-char paths
 // UNSUPPORTED: no-localization
 
 // <filesystem>
 
 // class path
 
 // std::string  generic_string() const;
 // std::wstring generic_wstring() const;
 // std::u8string  generic_u8string() const;
 // std::u16string generic_u16string() const;
 // std::u32string generic_u32string() const;
 
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
-#include "test_macros.h"
-#include "test_iterators.h"
 #include "count_new.h"
+#include "make_string.h"
 #include "min_allocator.h"
-#include "filesystem_test_helper.h"
+#include "test_iterators.h"
+#include "test_macros.h"
 
 MultiStringType input = MKSTR("c:\\foo\\bar");
 #ifdef _WIN32
 // On windows, the generic_* accessors return a path with forward slashes
 MultiStringType ref = MKSTR("c:/foo/bar");
 #else
 // On posix, the input string is returned as-is
 MultiStringType ref = MKSTR("c:\\foo\\bar");

libcxx/test/std/input.output/filesystems/class.path/path.member/path.modifiers/clear.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // void clear() noexcept
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <type_traits>
 
-#include "test_macros.h"
-#include "test_iterators.h"
+#include "assert_macros.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
+#include "test_iterators.h"
 
 
 int main(int, char**) {
   using namespace fs;
   {
     path p;
     ASSERT_NOEXCEPT(p.clear());
     ASSERT_SAME_TYPE(void, decltype(p.clear()));

libcxx/test/std/input.output/filesystems/class.path/path.member/path.modifiers/make_preferred.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path& make_preferred()
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
-#include "test_macros.h"
 #include "test_iterators.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
 
 
 struct MakePreferredTestcase {
   const char* value;
   const char* expected_posix;
   const char* expected_windows;
 };
 

libcxx/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path& remove_filename()
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
-#include "test_macros.h"
 #include "test_iterators.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
 
 struct RemoveFilenameTestcase {
   const char* value;
   const char* expect;
 };
 
 const RemoveFilenameTestcase TestCases[] =
   {

libcxx/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_extension.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path& replace_extension(path const& p = path())
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
-#include "test_macros.h"
-#include "test_iterators.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
+#include "test_iterators.h"
 
 
 struct ReplaceExtensionTestcase {
   const char* value;
   const char* expect;
   const char* extension;
 };
 

libcxx/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // path& replace_filename( const path& replacement );
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
-#include "test_macros.h"
 #include "test_iterators.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
 
 struct ReplaceFilenameTestcase {
   const char* value;
   const char* expect;
   const char* filename;
 };
 
 const ReplaceFilenameTestcase TestCases[] =

libcxx/test/std/input.output/filesystems/class.path/path.member/path.modifiers/swap.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // void swap(path& rhs) noexcept;
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <type_traits>
 
-#include "test_macros.h"
-#include "test_iterators.h"
+#include "assert_macros.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
+#include "test_iterators.h"
 
 
 struct SwapTestcase {
   const char* value1;
   const char* value2;
 };
 
 #define LONG_STR1 "_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG"

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/c_str.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // const value_type* c_str() const noexcept;
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
 #include "assert_macros.h"
 #include "test_macros.h"
-#include "filesystem_test_helper.h"
 
 
-int main(int, char**)
-{
+int main(int, char**) {
   using namespace fs;
   const char* const value = "hello world";
   const std::string str_value = value;
   const fs::path::string_type pathstr_value(str_value.begin(), str_value.end());
   { // Check signature
     path p(value);
     ASSERT_SAME_TYPE(path::value_type const*, decltype(p.c_str()));
     ASSERT_NOEXCEPT(p.c_str());

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // These tests require locale for non-char paths
 // UNSUPPORTED: no-localization
 
 // <filesystem>
 
 // class path
 
 // std::string  string() const;
 // std::wstring wstring() const;
 // std::u8string  u8string() const;
 // std::u16string u16string() const;
 // std::u32string u32string() const;
 
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
-#include "test_macros.h"
-#include "test_iterators.h"
+#include "assert_macros.h"
 #include "count_new.h"
+#include "make_string.h"
 #include "min_allocator.h"
-#include "filesystem_test_helper.h"
+#include "test_iterators.h"
+#include "test_macros.h"
 
 
 MultiStringType longString = MKSTR("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/123456789/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
 int main(int, char**)
 {
   using namespace fs;
   auto const& MS = longString;

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/native.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // const string_type& native() const noexcept;
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
+#include "assert_macros.h"
 #include "test_macros.h"
-#include "filesystem_test_helper.h"
 
 
-int main(int, char**)
-{
+int main(int, char**) {
   using namespace fs;
   const char* const value = "hello world";
   std::string value_str(value);
   fs::path::string_type pathstr_value(value_str.begin(), value_str.end());
   { // Check signature
     path p(value);
     ASSERT_SAME_TYPE(path::string_type const&, decltype(p.native()));
     ASSERT_NOEXCEPT(p.native());
   }
   { // native() is tested elsewhere
     path p(value);
     assert(p.native() == pathstr_value);
   }
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/operator_string.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // operator string_type() const;
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
+#include "assert_macros.h"
 #include "test_macros.h"
-#include "filesystem_test_helper.h"
 
 
-int main(int, char**)
-{
+int main(int, char**) {
   using namespace fs;
   using string_type = path::string_type;
   const char* const value = "hello world";
   std::string value_str(value);
   fs::path::string_type pathstr_value(value_str.begin(), value_str.end());
   { // Check signature
     path p(value);
     static_assert(std::is_convertible<path, string_type>::value, "");

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/append_op.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 #include "filesystem_include.h"
 
 using namespace fs;
 
 struct ConvToPath {

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/append_op.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // path operator/(path const&, path const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "filesystem_test_helper.h"
 
 // This is mainly tested via the member append functions.
-int main(int, char**)
-{
+int main(int, char**) {
   using namespace fs;
   path p1("abc");
   path p2("def");
   path p3 = p1 / p2;
   assert(p3 == "abc/def");
 
   path p4 = p1 / "def";
   assert(p4 == "abc/def");
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/comparison_ops.fail.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
-
 #include "filesystem_include.h"
 
 using namespace fs;
 
 struct ConvToPath {
   operator fs::path() const {
     return "";
   }

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // template <class Source>
 //    path u8path(Source const&);
 // template <class InputIter>
 //   path u8path(InputIter, InputIter);
 
 #include "filesystem_include.h"
-#include <type_traits>
 #include <cassert>
+#include <string>
+#include <type_traits>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
 
 
 int main(int, char**)
 {
   using namespace fs;
   const char* In1 = "abcd/efg";
   const std::string In2(In1);
   const auto In3 = In2.begin();

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.io.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: no-localization
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os, const path& p);
 //
 // template <class charT, class traits>
 // basic_istream<charT, traits>&
 // operator>>(basic_istream<charT, traits>& is, path& p)
 //
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <sstream>
 #include <cassert>
 #include <iostream>
 
-#include "test_macros.h"
-#include "test_iterators.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
+#include "make_string.h"
+#include "test_iterators.h"
+#include "test_macros.h"
 
 MultiStringType InStr =  MKSTR("abcdefg/\"hijklmnop\"/qrstuvwxyz/123456789");
 MultiStringType OutStr = MKSTR("\"abcdefg/\\\"hijklmnop\\\"/qrstuvwxyz/123456789\"");
 
 template <class CharT>
 void doIOTest() {
   using namespace fs;
   using Ptr = const CharT*;

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.io.unicode_bug.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // template <class charT, class traits>
 // basic_ostream<charT, traits>&
 // operator<<(basic_ostream<charT, traits>& os, const path& p);

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/swap.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // void swap(path& lhs, path& rhs) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
-#include "filesystem_test_helper.h"
 
 // NOTE: this is tested in path.members/path.modifiers via the member swap.
 int main(int, char**)
 {
   using namespace fs;
   const char* value1 = "foo/bar/baz";
   const char* value2 = "_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG_THIS_IS_LONG";
   {

libcxx/test/std/input.output/filesystems/class.path/path_helper.h

+// -*- 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 TEST_STD_INPUT_OUTPUT_FILESYSTEMS_CLASS_PATH_PATH_HELPER_H
+#define TEST_STD_INPUT_OUTPUT_FILESYSTEMS_CLASS_PATH_PATH_HELPER_H
+
+#include <cstddef>
+#include <iterator>
+
+#include "filesystem_include.h"
+#include "make_string.h"
+
+// Testing the allocation behavior of the code_cvt functions requires
+// *knowing* that the allocation was not done by "path::__str_".
+// This hack forces path to allocate enough memory.
+inline void PathReserve(fs::path& p, std::size_t N) {
+  auto const& native_ref = p.native();
+  const_cast<fs::path::string_type&>(native_ref).reserve(N);
+}
+
+inline bool PathEq(fs::path const& LHS, fs::path const& RHS) {
+  return LHS.native() == RHS.native();
+}
+
+inline bool PathEqIgnoreSep(fs::path LHS, fs::path RHS) {
+  LHS.make_preferred();
+  RHS.make_preferred();
+  return LHS.native() == RHS.native();
+}
+
+template <class Iter>
+Iter IterEnd(Iter B) {
+  using VT = typename std::iterator_traits<Iter>::value_type;
+  for (; *B != VT{}; ++B)
+    ;
+  return B;
+}
+
+template <class CharT>
+const CharT* StrEnd(CharT const* P) {
+    return IterEnd(P);
+}
+
+template <class CharT>
+std::size_t StrLen(CharT const* P) {
+    return StrEnd(P) - P;
+}
+
+const MultiStringType PathList[] = {
+        MKSTR(""),
+        MKSTR(" "),
+        MKSTR("//"),
+        MKSTR("."),
+        MKSTR(".."),
+        MKSTR("foo"),
+        MKSTR("/"),
+        MKSTR("/foo"),
+        MKSTR("foo/"),
+        MKSTR("/foo/"),
+        MKSTR("foo/bar"),
+        MKSTR("/foo/bar"),
+        MKSTR("//net"),
+        MKSTR("//net/foo"),
+        MKSTR("///foo///"),
+        MKSTR("///foo///bar"),
+        MKSTR("/."),
+        MKSTR("./"),
+        MKSTR("/.."),
+        MKSTR("../"),
+        MKSTR("foo/."),
+        MKSTR("foo/.."),
+        MKSTR("foo/./"),
+        MKSTR("foo/./bar"),
+        MKSTR("foo/../"),
+        MKSTR("foo/../bar"),
+        MKSTR("c:"),
+        MKSTR("c:/"),
+        MKSTR("c:foo"),
+        MKSTR("c:/foo"),
+        MKSTR("c:foo/"),
+        MKSTR("c:/foo/"),
+        MKSTR("c:/foo/bar"),
+        MKSTR("prn:"),
+        MKSTR("c:\\"),
+        MKSTR("c:\\foo"),
+        MKSTR("c:foo\\"),
+        MKSTR("c:\\foo\\"),
+        MKSTR("c:\\foo/"),
+        MKSTR("c:/foo\\bar"),
+        MKSTR("//"),
+        MKSTR("/finally/we/need/one/really/really/really/really/really/really/really/long/string")
+};
+const unsigned PathListSize = sizeof(PathList) / sizeof(MultiStringType);
+
+#endif // TEST_STD_INPUT_OUTPUT_FILESYSTEMS_CLASS_PATH_PATH_HELPER_H

libcxx/test/std/input.output/filesystems/class.path/range_concept_conformance.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: availability-filesystem-missing
 
 // path
 
 #include "filesystem_include.h"
 
 #include <concepts>
 #include <ranges>
 
 
-
 static_assert(std::same_as<std::ranges::iterator_t<fs::path>, fs::path::iterator>);
 static_assert(std::ranges::common_range<fs::path>);
 static_assert(std::ranges::bidirectional_range<fs::path>);
 static_assert(!std::ranges::view<fs::path>);
 static_assert(!std::ranges::random_access_range<fs::path>);
 static_assert(!std::ranges::sized_range<fs::path>);
 static_assert(!std::ranges::borrowed_range<fs::path>);
 static_assert(std::ranges::viewable_range<fs::path>);

libcxx/test/std/input.output/filesystems/class.path/synop.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path
 
 // typedef ... value_type;
 // typedef basic_string<value_type> string_type;
 // static constexpr value_type preferred_separator = ...;

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/range_concept_conformance.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // recursive_directory_iterator
 
 #include "filesystem_include.h"
 
 #include <concepts>
 #include <ranges>
 

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_recursive_directory_iterator(recursive_recursive_directory_iterator const&);
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy_assign.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class directory_iterator
 
 //
 // explicit recursive_directory_iterator(const path& p);
 // recursive_directory_iterator(const path& p, directory_options options);

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/depth.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // int depth() const
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // void disable_recursion_pending();
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/equal.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // bool operator==(default_sentinel_t) const noexcept {           // since C++20
 //   return *this == recursive_directory_iterator();
 // }

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/increment.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator& operator++();
 // recursive_directory_iterator& increment(error_code& ec) noexcept;
 

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator(recursive_directory_iterator&&) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move_assign.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/pop.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // void pop();
 // void pop(error_code& ec);
 

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // bool recursion_pending() const;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class recursive_directory_iterator
 
 // recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
 // recursive_directory_iterator end(recursive_directory_iterator iter) noexcept;
 

libcxx/test/std/input.output/filesystems/fs.enum/enum.path.format.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // class path;
 // enum class format;
 
 #include "filesystem_include.h"
 #include <type_traits>

libcxx/test/std/input.output/filesystems/fs.filesystem.synopsis/enable_borrowed_range.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // template <>
 // inline constexpr bool ranges::enable_borrowed_range<filesystem::directory_iterator> = true;
 // template <>
 // inline constexpr bool ranges::enable_borrowed_range<filesystem::recursive_directory_iterator> = true;
 

libcxx/test/std/input.output/filesystems/fs.filesystem.synopsis/enable_view.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // template <>
 // inline constexpr bool ranges::enable_view<filesystem::directory_iterator> = true;
 // template <>
 // inline constexpr bool ranges::enable_view<filesystem::recursive_directory_iterator> = true;
 

libcxx/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // typedef TrivialClock file_time_type;
 
 #include "filesystem_include.h"
 #include <chrono>
 #include <type_traits>

libcxx/test/std/input.output/filesystems/fs.filesystem.synopsis/file_time_type_resolution.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, windows
+// UNSUPPORTED: availability-filesystem-missing
 
 // MS STL and libstdc++ use the native windows file timestamp resolution,
 // with 100 ns resolution.
 
 // <filesystem>
 
 // typedef TrivialClock file_time_type;
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // uintmax_t hard_link_count(const path& p);
 // uintmax_t hard_link_count(const path& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.absolute/absolute.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // path absolute(const path& p, const path& base=current_path());
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "filesystem_test_helper.h"
+#include "../../class.path/path_helper.h"
 
 using namespace fs;
 
 static void absolute_signature_test()
 {
     const path p; ((void)p);
     std::error_code ec;
     ASSERT_NOT_NOEXCEPT(absolute(p));

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.canonical/canonical.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // path canonical(const path& p);
 // path canonical(const path& p, error_code& ec);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "assert_macros.h"
 #include "test_macros.h"
 #include "filesystem_test_helper.h"
+#include "../../class.path/path_helper.h"
 
 using namespace fs;
 
 static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(canonical(p));

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy/copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // void copy(const path& from, const path& to);
 // void copy(const path& from, const path& to, error_code& ec);
 // void copy(const path& from, const path& to, copy_options options);
 // void copy(const path& from, const path& to, copy_options options,
 //           error_code& ec);

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // The string reported on errors changed, which makes those tests fail when run
 // against already-released libc++'s.
 // XFAIL: stdlib=apple-libc++ && target={{.+}}-apple-macosx{{10.15|11.0}}
 
 // <filesystem>
 
 // bool copy_file(const path& from, const path& to);

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file_large.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // REQUIRES: long_tests
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool copy_file(const path& from, const path& to);
 // bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
 // bool copy_file(const path& from, const path& to, copy_options options);
 // bool copy_file(const path& from, const path& to, copy_options options,
 //           error_code& ec) noexcept;

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_symlink/copy_symlink.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // void copy_symlink(const path& existing_symlink, const path& new_symlink);
 // void copy_symlink(const path& existing_symlink, const path& new_symlink,
 //                   error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directories/create_directories.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // This test requires the dylib support introduced in D92769.
 // XFAIL: stdlib=apple-libc++ && target={{.+}}-apple-macosx{{10.15|11.0}}
 
 // <filesystem>
 
 // bool create_directories(const path& p);
 // bool create_directories(const path& p, error_code& ec) noexcept;

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // This test requires the dylib support introduced in http://llvm.org/D92769.
 // XFAIL: stdlib=apple-libc++ && target={{.+}}-apple-macosx{{10.15|11.0}}
 
 // <filesystem>
 
 // bool create_directory(const path& p);
 // bool create_directory(const path& p, error_code& ec) noexcept;

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // This test requires the dylib support introduced in http://llvm.org/D92769.
 // XFAIL: stdlib=apple-libc++ && target={{.+}}-apple-macosx{{10.15|11.0}}
 
 // <filesystem>
 
 // bool create_directory(const path& p, const path& attr);
 // bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // void create_directory_symlink(const path& existing_symlink, const path& new_symlink);
 // void create_directory_symlink(const path& existing_symlink, const path& new_symlink,
 //                   error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_hard_link/create_hard_link.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // void create_hard_link(const path& existing_symlink, const path& new_symlink);
 // void create_hard_link(const path& existing_symlink, const path& new_symlink,
 //                   error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_symlink/create_symlink.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // void create_symlink(const path& existing_symlink, const path& new_symlink);
 // void create_symlink(const path& existing_symlink, const path& new_symlink,
 //                   error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.current_path/current_path.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // path current_path();
 // path current_path(error_code& ec);
 // void current_path(path const&);
 // void current_path(path const&, std::error_code& ec) noexcept;
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.equivalent/equivalent.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool equivalent(path const& lhs, path const& rhs);
 // bool equivalent(path const& lhs, path const& rhs, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.exists/exists.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool exists(file_status s) noexcept
 // bool exists(path const& p);
 // bool exists(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.file_size/file_size.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // The string reported on errors changed, which makes those tests fail when run
 // against already-released libc++'s.
 // XFAIL: stdlib=apple-libc++ && target={{.+}}-apple-macosx{{10.15|11.0}}
 
 // <filesystem>
 
 // uintmax_t file_size(const path& p);

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_block_file/is_block_file.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool is_block_file(file_status s) noexcept
 // bool is_block_file(path const& p);
 // bool is_block_file(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_char_file/is_character_file.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool is_character_file(file_status s) noexcept
 // bool is_character_file(path const& p);
 // bool is_character_file(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_directory/is_directory.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool is_directory(file_status s) noexcept
 // bool is_directory(path const& p);
 // bool is_directory(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_empty/is_empty.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool is_empty(path const& p);
 // bool is_empty(path const& p, std::error_code& ec);
 
 #include "filesystem_include.h"
 #include <type_traits>

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_fifo/is_fifo.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool is_fifo(file_status s) noexcept
 // bool is_fifo(path const& p);
 // bool is_fifo(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_other/is_other.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool is_other(file_status s) noexcept
 // bool is_other(path const& p);
 // bool is_other(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_regular_file/is_regular_file.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool is_regular_file(file_status s) noexcept
 // bool is_regular_file(path const& p);
 // bool is_regular_file(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_socket/is_socket.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool is_socket(file_status s) noexcept
 // bool is_socket(path const& p);
 // bool is_socket(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_symlink/is_symlink.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool is_symlink(file_status s) noexcept
 // bool is_symlink(path const& p);
 // bool is_symlink(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // The string reported on errors changed, which makes those tests fail when run
 // against already-released libc++'s.
 // XFAIL: stdlib=apple-libc++ && target={{.+}}-apple-macosx{{10.15|11.0}}
 
 // <filesystem>
 
 // file_time_type last_write_time(const path& p);

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.permissions/permissions.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // void permissions(const path& p, perms prms,
 //                  perm_options opts = perm_options::replace);
 // void permissions(const path& p, perms prms, std::error_code& ec) noexcept;
 // void permissions(const path& p, perms prms, perm_options opts, std::error_code);
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // path proximate(const path& p, error_code &ec)
 // path proximate(const path& p, const path& base = current_path())
 // path proximate(const path& p, const path& base, error_code& ec);
 
 #include "filesystem_include.h"
 #include <cassert>
 #include <cstdio>
 
 #include "test_macros.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
-
+#include "../../class.path/path_helper.h"
 
 static int count_path_elems(const fs::path& p) {
   int count = 0;
   for (auto&& elem : p) {
     if (elem != p.root_name() && elem != "/" && elem != "")
       ++count;
   }
   return count;

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.read_symlink/read_symlink.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // path read_symlink(const path& p);
 // path read_symlink(const path& p, error_code& ec);
 
 #include "filesystem_include.h"
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // path proximate(const path& p, error_code &ec)
 // path proximate(const path& p, const path& base = current_path())
 // path proximate(const path& p, const path& base, error_code& ec);
 
 #include "filesystem_include.h"

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove/remove.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool remove(const path& p);
 // bool remove(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/remove_all.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
 //
 //===----------------------------------------------------------------------===//
 
 // XFAIL: LIBCXX-FREEBSD-FIXME
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // uintmax_t remove_all(const path& p);
 // uintmax_t remove_all(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/toctou.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: no-localization
 // UNSUPPORTED: no-threads
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // Test for a time-of-check to time-of-use issue with std::filesystem::remove_all.
 //
 // Scenario:
 // The attacker wants to get directory contents deleted, to which he does not have access.
 // He has a way to get a privileged binary call `std::filesystem::remove_all()` on a

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.rename/rename.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // void rename(const path& old_p, const path& new_p);
 // void rename(const path& old_p,  const path& new_p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.resize_file/resize_file.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // void resize_file(const path& p, uintmax_t new_size);
 // void resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.space/space.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // space_info space(const path& p);
 // space_info space(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.status/status.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // file_status status(const path& p);
 // file_status status(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.status_known/status_known.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // bool status_known(file_status s) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.symlink_status/symlink_status.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // file_status symlink_status(const path& p);
 // file_status symlink_status(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // path temp_directory_path();
 // path temp_directory_path(error_code& ec);
 
 #include "filesystem_include.h"
 #include <memory>

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.weakly_canonical/weakly_canonical.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: no-filesystem
+// UNSUPPORTED: availability-filesystem-missing
 
 // <filesystem>
 
 // path weakly_canonical(const path& p);
 // path weakly_canonical(const path& p, error_code& ec);
 
 #include "filesystem_include.h"
 #include <cstdio>
 #include <string>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
-
+#include "../../class.path/path_helper.h"
 
 int main(int, char**) {
 
   static_test_env static_env;
 
   fs::path root = fs::current_path().root_path();
   // clang-format off
   struct {

libcxx/test/std/input.output/filesystems/fs.req.namespace/namespace.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: no-filesystem
 
 // <filesystem>
 
 // namespace std::filesystem
 
 #include <filesystem>
 
 namespace fs = std::filesystem;

libcxx/test/std/input.output/filesystems/fs.req.namespace/namespace.verify.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: c++03 || c++11 || c++14
+// UNSUPPORTED: no-filesystem
 
 // <filesystem>
 
 // namespace std::filesystem
 
 #include <filesystem>
 
 namespace fs = std::filesystem; // expected-error-re {{{{(no namespace named 'filesystem' in namespace 'std';)|(expected namespace name)}}}}

libcxx/test/std/time/time.clock/time.clock.file/now.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: no-filesystem
 
 // UNSUPPORTED: availability-filesystem-missing
 
 // <chrono>
 
 // file_clock
 
 // static time_point now() noexcept;

libcxx/test/std/time/time.clock/time.clock.file/to_from_sys.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: no-filesystem
 
 // UNSUPPORTED: availability-filesystem-missing
 
 // <chrono>
 //
 // file_clock
 //
 // template<class Duration>

libcxx/test/std/utilities/format/format.formattable/concept.formattable.compile.pass.cpp

 
 #include <array>
 #include <bitset>
 #include <bitset>
 #include <chrono>
 #include <complex>
 #include <concepts>
 #include <deque>
+#include <filesystem>
 #include <format>
 #include <forward_list>
 #include <list>
-#include <memory>
 #include <map>
+#include <memory>
 #include <optional>
 #include <queue>
 #include <set>
-#include <stack>
 #include <span>
+#include <stack>
 #include <tuple>
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <valarray>
 #include <variant>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
-#ifndef TEST_HAS_NO_FILESYSTEM
-#  include <filesystem>
-#endif
 #ifndef TEST_HAS_NO_LOCALIZATION
 #  include <regex>
 #endif
 #ifndef TEST_HAS_NO_THREADS
 #  include <thread>
 #endif
 
 template <class T, class CharT>

 // Note the paper has been abandoned, the types are kept since other papers may
 // introduce these formatters.
 template <class CharT>
 void test_P1636() {
   assert_is_not_formattable<std::basic_streambuf<CharT>, CharT>();
   assert_is_not_formattable<std::bitset<42>, CharT>();
   assert_is_not_formattable<std::complex<double>, CharT>();
   assert_is_not_formattable<std::error_code, CharT>();
-#ifndef TEST_HAS_NO_FILESYSTEM
   assert_is_not_formattable<std::filesystem::path, CharT>();
-#endif
   assert_is_not_formattable<std::shared_ptr<int>, CharT>();
 #ifndef TEST_HAS_NO_LOCALIZATION
   if constexpr (!std::same_as<CharT, int>) // sub_match only works with proper character types
     assert_is_not_formattable<std::sub_match<CharT*>, CharT>();
 #endif
 #ifndef TEST_HAS_NO_THREADS
   assert_is_formattable<std::thread::id, CharT>();
 #endif

libcxx/test/std/utilities/format/format.range/format.range.fmtkind/format_kind.compile.pass.cpp

 // template<ranges::input_range R>
 //     requires same_as<R, remove_cvref_t<R>>
 //  constexpr range_format format_kind<R> = see below;
 
 #include <format>
 
 #include <array>
 #include <deque>
+#include <filesystem>
 #include <format>
 #include <forward_list>
 #include <iterator>
 #include <list>
 #include <map>
 #include <ranges>
 #include <set>
 #include <span>
-#include <vector>
 #include <unordered_map>
 #include <unordered_set>
 #include <valarray>
+#include <vector>
 
 #include "test_macros.h"
 
-#ifndef TEST_HAS_NO_FILESYSTEM
-#  include <filesystem>
-#endif
-
 // [format.range.fmtkind]
 // If same_as<remove_cvref_t<ranges::range_reference_t<R>>, R> is true,
 // format_kind<R> is range_format::disabled.
 // [Note 1: This prevents constraint recursion for ranges whose reference type
 // is the same range type. For example, std::filesystem::path is a range of
 // std::filesystem::path. - end note]
 struct recursive_range {
   struct iterator {
struct recursive_range {
 
   iterator begin();
   iterator end();
 };
 
 static_assert(std::ranges::input_range<recursive_range>, "format_kind requires an input range");
 static_assert(std::format_kind<recursive_range> == std::range_format::disabled);
 
-#ifndef TEST_HAS_NO_FILESYSTEM
 static_assert(std::format_kind<std::filesystem::path> == std::range_format::disabled);
-#endif
 
 static_assert(std::format_kind<std::map<int, int>> == std::range_format::map);
 static_assert(std::format_kind<std::multimap<int, int>> == std::range_format::map);
 static_assert(std::format_kind<std::unordered_map<int, int>> == std::range_format::map);
 static_assert(std::format_kind<std::unordered_multimap<int, int>> == std::range_format::map);
 
 static_assert(std::format_kind<std::set<int>> == std::range_format::set);
 static_assert(std::format_kind<std::multiset<int>> == std::range_format::set);

libcxx/test/support/filesystem_test_helper.h

~CWDGuard() {
     int ret = ::chdir(oldCwd_.c_str());
     assert(ret == 0 && "chdir failed");
   }
 
   CWDGuard(CWDGuard const&) = delete;
   CWDGuard& operator=(CWDGuard const&) = delete;
 };
 
-// Misc test types
-
-const MultiStringType PathList[] = {
-        MKSTR(""),
-        MKSTR(" "),
-        MKSTR("//"),
-        MKSTR("."),
-        MKSTR(".."),
-        MKSTR("foo"),
-        MKSTR("/"),
-        MKSTR("/foo"),
-        MKSTR("foo/"),
-        MKSTR("/foo/"),
-        MKSTR("foo/bar"),
-        MKSTR("/foo/bar"),
-        MKSTR("//net"),
-        MKSTR("//net/foo"),
-        MKSTR("///foo///"),
-        MKSTR("///foo///bar"),
-        MKSTR("/."),
-        MKSTR("./"),
-        MKSTR("/.."),
-        MKSTR("../"),
-        MKSTR("foo/."),
-        MKSTR("foo/.."),
-        MKSTR("foo/./"),
-        MKSTR("foo/./bar"),
-        MKSTR("foo/../"),
-        MKSTR("foo/../bar"),
-        MKSTR("c:"),
-        MKSTR("c:/"),
-        MKSTR("c:foo"),
-        MKSTR("c:/foo"),
-        MKSTR("c:foo/"),
-        MKSTR("c:/foo/"),
-        MKSTR("c:/foo/bar"),
-        MKSTR("prn:"),
-        MKSTR("c:\\"),
-        MKSTR("c:\\foo"),
-        MKSTR("c:foo\\"),
-        MKSTR("c:\\foo\\"),
-        MKSTR("c:\\foo/"),
-        MKSTR("c:/foo\\bar"),
-        MKSTR("//"),
-        MKSTR("/finally/we/need/one/really/really/really/really/really/really/really/long/string")
-};
-const unsigned PathListSize = sizeof(PathList) / sizeof(MultiStringType);
-
-template <class Iter>
-Iter IterEnd(Iter B) {
-  using VT = typename std::iterator_traits<Iter>::value_type;
-  for (; *B != VT{}; ++B)
-    ;
-  return B;
-}
-
-template <class CharT>
-const CharT* StrEnd(CharT const* P) {
-    return IterEnd(P);
-}
-
-template <class CharT>
-std::size_t StrLen(CharT const* P) {
-    return StrEnd(P) - P;
-}
-
-// Testing the allocation behavior of the code_cvt functions requires
-// *knowing* that the allocation was not done by "path::__str_".
-// This hack forces path to allocate enough memory.
-inline void PathReserve(fs::path& p, std::size_t N) {
-  auto const& native_ref = p.native();
-  const_cast<fs::path::string_type&>(native_ref).reserve(N);
-}
-
-template <class Iter1, class Iter2>
-bool checkCollectionsEqual(
-    Iter1 start1, Iter1 const end1
-  , Iter2 start2, Iter2 const end2
-  )
-{
-    while (start1 != end1 && start2 != end2) {
-        if (*start1 != *start2) {
-            return false;
-        }
-        ++start1; ++start2;
-    }
-    return (start1 == end1 && start2 == end2);
-}
-
-
-template <class Iter1, class Iter2>
-bool checkCollectionsEqualBackwards(
-    Iter1 const start1, Iter1 end1
-  , Iter2 const start2, Iter2 end2
-  )
-{
-    while (start1 != end1 && start2 != end2) {
-        --end1; --end2;
-        if (*end1 != *end2) {
-            return false;
-        }
-    }
-    return (start1 == end1 && start2 == end2);
-}
-
 // We often need to test that the error_code was cleared if no error occurs
 // this function returns an error_code which is set to an error that will
 // never be returned by the filesystem functions.
 inline std::error_code GetTestEC(unsigned Idx = 0) {
   using std::errc;
   auto GetErrc = [&]() {
     switch (Idx) {
     case 0:

 #else
     using Clock = steady_clock;
 #endif
     const auto wake_time = Clock::now() + dur;
     while (Clock::now() < wake_time)
         ;
 }
 
-inline bool PathEq(fs::path const& LHS, fs::path const& RHS) {
-  return LHS.native() == RHS.native();
-}
-
-inline bool PathEqIgnoreSep(fs::path LHS, fs::path RHS) {
-  LHS.make_preferred();
-  RHS.make_preferred();
-  return LHS.native() == RHS.native();
-}
-
 inline fs::perms NormalizeExpectedPerms(fs::perms P) {
 #ifdef _WIN32
   // On Windows, fs::perms only maps down to one bit stored in the filesystem,
   // a boolean readonly flag.
   // Normalize permissions to the format it gets returned; all fs entries are
   // read+exec for all users; writable ones also have the write bit set for
   // all users.
   P |= fs::perms::owner_read | fs::perms::group_read | fs::perms::others_read;

libcxx/utils/data/ignore_format.txt

 libcxx/include/experimental/type_traits
 libcxx/include/experimental/unordered_map
 libcxx/include/experimental/unordered_set
 libcxx/include/experimental/utility
 libcxx/include/ext/__hash
 libcxx/include/ext/hash_map
 libcxx/include/ext/hash_set
 libcxx/include/fenv.h
-libcxx/include/filesystem
 libcxx/include/__filesystem/copy_options.h
 libcxx/include/__filesystem/directory_entry.h
 libcxx/include/__filesystem/directory_iterator.h
 libcxx/include/__filesystem/directory_options.h
 libcxx/include/__filesystem/file_status.h
 libcxx/include/__filesystem/file_type.h
 libcxx/include/__filesystem/operations.h
 libcxx/include/__filesystem/path.h