2025-12-07 09:16:39 +08:00
18 changed files with 2547 additions and 7314 deletions
--- a/.cirrus.yml
+++ b/.cirrus.yml
@ -1,6 +1,6 @@
 freebsd_task:
  freebsd_instance:
-    image_family: freebsd-14-0
+    image_family: freebsd-12-1
  install_script: |
    pkg install -y cmake
    pw groupadd testgrp
@ -11,24 +11,25 @@ freebsd_task:
  test_script: |
    sudo -u testuser .ci/unix-test.sh

-rockylinux8_task:
+centos7_task:
  container:
-    image: docker.io/rockylinux:8
+    image: centos:7
  install_script: |
-    dnf group install -y "Development Tools"
-    dnf install cmake -y
+    yum install -y centos-release-scl
+    yum install -y devtoolset-9
+    curl -L https://github.com/Kitware/CMake/releases/download/v3.16.4/cmake-3.16.4-Linux-x86_64.tar.gz | tar xzvf - -C /usr/local --strip-components 1
  build_script: |
-    .ci/unix-build.sh
+    source /opt/rh/devtoolset-9/enable && PATH=$PATH:/usr/local/bin .ci/unix-build.sh
  test_script: |
-    .ci/unix-test.sh
+    PATH=$PATH:/usr/local/bin .ci/unix-test.sh

-rockylinux9_task:
+centos8_task:
  container:
-    image: docker.io/rockylinux:9
+    image: centos:8
  install_script: |
-    dnf group install -y "Development Tools"
-    dnf install cmake -y
+    yum group install -y "Development Tools"
+    curl -L https://github.com/Kitware/CMake/releases/download/v3.16.4/cmake-3.16.4-Linux-x86_64.tar.gz | tar xzvf - -C /usr/local --strip-components 1
  build_script: |
-    .ci/unix-build.sh
+    PATH=$PATH:/usr/local/bin .ci/unix-build.sh
  test_script: |
-    .ci/unix-test.sh
+    PATH=$PATH:/usr/local/bin .ci/unix-test.sh
--- a/.drone.yml-disabled
+++ b/.drone.yml-disabled
--- a/.github/workflows/build_cmake.yml
+++ b/.github/workflows/build_cmake.yml
@ -1,170 +0,0 @@
-name: CMake Build Matrix
-
-on: [ push, pull_request ]
-
-jobs:
-  build:
-    name: ${{ matrix.config.name }}
-    runs-on: ${{ matrix.config.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        config:
-          - name: "Ubuntu 22.04 GCC 11"
-            os: ubuntu-22.04
-            build_type: Release
-            packages: ninja-build
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: gcc
-            cxx: g++
-
-          - name: "Ubuntu 22.04 Clang 13.0"
-            os: ubuntu-22.04
-            build_type: Release
-            packages: ninja-build libc++-13-dev libc++abi-13-dev
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: clang-13
-            cxx: clang++-13
-
-          - name: "Ubuntu 22.04 Clang 15.0"
-            os: ubuntu-22.04
-            build_type: Release
-            packages: ninja-build libc++-15-dev libc++abi-15-dev
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: clang-15
-            cxx: clang++-15
-
-          - name: "Ubuntu 22.04 GCC 11 coverage"
-            os: ubuntu-22.04
-            build_type: Debug
-            packages: ninja-build lcov
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: gcc
-            cxx: g++
-
-          - name: "Ubuntu 20.04 GCC 9.3"
-            os: ubuntu-20.04
-            build_type: Release
-            packages: ninja-build
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: gcc
-            cxx: g++
-
-          - name: "Ubuntu 20.04 Clang 10.0"
-            os: ubuntu-20.04
-            build_type: Release
-            packages: ninja-build
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: clang-10
-            cxx: clang++-10
-
-          - name: "Ubuntu 20.04 Clang 11.0"
-            os: ubuntu-20.04
-            build_type: Release
-            packages: ninja-build clang-11 libc++-11-dev libc++abi-11-dev
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: clang-11
-            cxx: clang++-11
-
-          - name: "Ubuntu 20.04 GCC 9.3 coverage"
-            os: ubuntu-20.04
-            build_type: Debug
-            packages: ninja-build lcov
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: gcc
-            cxx: g++
-
-          - name: "Windows MSVC 2019"
-            os: windows-2019
-            build_type: Release
-            packages: ninja
-            generator: "Visual Studio 16 2019"
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: cl
-            cxx: cl
-
-          - name: "macOS 13 AppleClang"
-            os: macos-13
-            build_type: Release
-            packages: ninja
-            generator: Ninja
-            compatibility: "cxx_std_11;cxx_std_17;cxx_std_20"
-            cc: clang
-            cxx: clang++
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: print environment
-        run: |
-          echo github.event.action: ${{ github.event.action }}
-          echo github.event_name: ${{ github.event_name }}
-
-      - name: Install dependencies on Ubuntu
-        if: startsWith(matrix.config.os, 'ubuntu')
-        shell: bash
-        run: |
-          sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
-          sudo apt update
-          sudo apt install ${{ matrix.config.packages }}
-
-      - name: Install dependencies on windows
-        if: startsWith(matrix.config.os, 'windows')
-        run: |
-          choco install ${{ matrix.config.packages }}
-
-      - name: Install dependencies on macOS
-        if: startsWith(matrix.config.os, 'macos')
-        run: |
-          brew install ${{ matrix.config.packages }}
-
-      - name: Configure project
-        shell: bash
-        run: |
-          export CC=${{ matrix.config.cc }}
-          export CXX=${{ matrix.config.cxx }}
-          ninja --version
-          cmake --version
-          mkdir build
-          mkdir install
-          if [[ "${{ matrix.config.build_type }}" == "Debug" ]]; then
-            cmake -G "${{ matrix.config.generator }}" -S . -B build -DCMAKE_BUILD_TYPE=Debug -DGHC_COVERAGE=ON -DGHC_FILESYSTEM_TEST_COMPILE_FEATURES="${{ matrix.config.compatibility }}" -DCMAKE_INSTALL_PREFIX:PATH=install
-          else
-            cmake -G "${{ matrix.config.generator }}" -S . -B build -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} -DGHC_FILESYSTEM_TEST_COMPILE_FEATURES="${{ matrix.config.compatibility }}" -DCMAKE_INSTALL_PREFIX:PATH=install
-          fi
-
-      - name: Build project
-        shell: bash
-        run: |
-          cmake --build build --config ${{ matrix.config.build_type }}
-
-      - name: Run tests
-        run: |
-          cd build && ctest -C ${{ matrix.config.build_type }}
-
-      - name: Collect coverage info
-        if: startsWith(matrix.config.build_type, 'Debug')
-        run: |
-          cd build
-          lcov --compat-libtool --directory . --capture --output-file coverage_output.info
-          lcov --remove coverage_output.info '/usr/*' '*/c++/*' '*.h' '*/catch.hpp' -o coverage.info
-          # sed -i 's|SF:/.*/filesystem/|SF:../|g' coverage.info
-
-      - name: Upload coverage info
-        if: startsWith(matrix.config.build_type, 'Debug')
-        env:
-          COVERALLS_DEBUG: true
-          NODE_COVERALLS_DEBUG: 1
-        uses: coverallsapp/github-action@master
-        with:
-          path-to-lcov: ${{ github.workspace }}/build/coverage.info
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,100 @@
+language: cpp
+
+dist: xenial # default distribution
+os: linux # default os
+sudo: false
+
+
+matrix:
+  fast_finish: true
+  include:
+    - env: MATRIX_EVAL="CC=gcc-5 && CXX=g++-5 && GENERATOR='Unix Makefiles' && CONFIG=Release"
+      addons: { apt: { packages: ["g++-5"], sources: ["ubuntu-toolchain-r-test"] } }
+
+    - env: MATRIX_EVAL="CC=gcc-6 && CXX=g++-6 && GENERATOR='Unix Makefiles' && CONFIG=Release"
+      addons: { apt: { packages: ["g++-6"], sources: ["ubuntu-toolchain-r-test"] } }
+
+    - env: MATRIX_EVAL="CC=gcc-7 && CXX=g++-7 && GENERATOR='Unix Makefiles' && CONFIG=Release"
+      addons: { apt: { packages: ["g++-7"], sources: ["ubuntu-toolchain-r-test"] } }
+
+    - env: MATRIX_EVAL="CC=gcc-7 && CXX=g++-7 && GENERATOR='Unix Makefiles' && CONFIG=Debug && GHC_COVERAGE=1"
+      addons: { apt: { packages: ["g++-7", "lcov"], sources: ["ubuntu-toolchain-r-test"] } }
+
+    - env: MATRIX_EVAL="CC=gcc-8 && CXX=g++-8 && GENERATOR='Unix Makefiles' && CONFIG=Release"
+      addons: { apt: { packages: ["g++-8"], sources: ["ubuntu-toolchain-r-test"] } }
+
+    - env: MATRIX_EVAL="CC=gcc-9 && CXX=g++-9 && GENERATOR='Unix Makefiles' && CONFIG=Release"
+      addons: { apt: { packages: ["g++-9"], sources: ["ubuntu-toolchain-r-test"] } }
+
+    - env: MATRIX_EVAL="CC=clang-5.0 && CXX=clang++-5.0 && GENERATOR='Unix Makefiles' && CONFIG=Release"
+      addons: { apt: { packages: ["clang-5.0"] } }
+
+    - env: MATRIX_EVAL="CC=clang-6.0 && CXX=clang++-6.0 && GENERATOR='Unix Makefiles' && CONFIG=Release"
+      addons: { apt: { packages: ["clang-6.0"] } }
+
+    - env: MATRIX_EVAL="CC=clang-7 && CXX=clang++-7 && GENERATOR='Unix Makefiles' && CONFIG=Release"
+      addons: { apt: { packages: ["clang-7", "libc++-7-dev", "libc++abi-7-dev"], sources: ["llvm-toolchain-xenial-7"] } }
+
+    - env: MATRIX_EVAL="CC=clang-8 && CXX=clang++-8 && GENERATOR='Unix Makefiles' && CONFIG=Release"
+      addons: { apt: { packages: ["clang-8", "libc++-8-dev", "libc++abi-8-dev"], sources: ["llvm-toolchain-xenial-8"] } }
+
+    - env: MATRIX_EVAL="CC=clang-9 && CXX=clang++-9 && GENERATOR='Unix Makefiles' && CONFIG=Release"
+      addons: { apt: { packages: ["clang-9", "libc++-9-dev", "libc++abi-9-dev"], sources: [{sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main', key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'}] } }
+
+    - os: osx
+      env: MATRIX_EVAL="CC=clang && CXX=clang++ && GENERATOR=Xcode && CONFIG=Release"
+      osx_image: xcode9.2
+
+    - os: osx
+      env: MATRIX_EVAL="CC=clang && CXX=clang++ && GENERATOR=Xcode && CONFIG=Release"
+      osx_image: xcode10.1
+
+    - os: osx
+      env: MATRIX_EVAL="CC=clang && CXX=clang++ && GENERATOR=Xcode && CONFIG=Release"
+      osx_image: xcode11.3
+
+install:
+  - eval "${MATRIX_EVAL}"
+  - |
+    if [ "${GHC_COVERAGE}" = "1" ]; then
+      gem install coveralls-lcov
+    fi
+  - $CC --version
+  - $CXX --version
+  - cmake --version
+
+before_script:
+  - eval "${MATRIX_EVAL}"
+  - mkdir build
+  - cd build
+  - export VERBOSE=1
+  - |
+    if [ "${CONFIG}" = "Debug" ]; then
+      cmake -G"${GENERATOR}" -DCMAKE_CXX_COMPILER=${CXX} -DCMAKE_C_COMPILER=${CC} -DCMAKE_BUILD_TYPE=${CONFIG} -DGHC_COVERAGE=ON ..
+    else
+      cmake -G"${GENERATOR}" -DCMAKE_CXX_COMPILER=${CXX} -DCMAKE_C_COMPILER=${CC} -DCMAKE_BUILD_TYPE=${CONFIG} ..
+    fi
+
+script:
+  - export VERBOSE=1
+  - cmake --build . --config ${CONFIG} --target filesystem_test
+  - |
+    if [ "${GHC_COVERAGE}" = "1" ]; then
+      cmake --build . --config ${CONFIG} --target filesystem_test
+      test/filesystem_test
+    else
+      cmake --build . --config ${CONFIG}
+      ctest -C ${CONFIG} -E Windows
+      if [ -f "test/std_filesystem_test" ]; then
+        test/std_filesystem_test || true
+      fi
+    fi
+
+after_success:
+  - |
+    if [ "${GHC_COVERAGE}" = "1" ]; then
+      lcov --compat-libtool --directory . --capture --output-file coverage_output.info
+      lcov --remove coverage_output.info '/usr/*' '*/c++/*' '*.h' '*/catch.hpp' -o coverage.info
+      sed -i 's|SF:/.*/filesystem/|SF:../|g' coverage.info
+      coveralls-lcov coverage.info
+    fi
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,8 +1,5 @@
 cmake_minimum_required(VERSION 3.7.2)
-project(
-   ghcfilesystem,
-   VERSION 1.5.15
-)
+project(ghcfilesystem)

 if (POLICY CMP0077)
    cmake_policy(SET CMP0077 NEW)
@ -18,7 +15,7 @@ if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
 else()
    option(GHC_FILESYSTEM_BUILD_EXAMPLES "Build examples" OFF)
    option(GHC_FILESYSTEM_BUILD_TESTING "Enable tests" OFF)
-    option(GHC_FILESYSTEM_WITH_INSTALL "With install target" OFF)
+    option(GHC_FILESYSTEM_WITH_INSTALL "With install target" ON)
 endif()
 option(GHC_FILESYSTEM_BUILD_STD_TESTING "Enable STD tests" ${GHC_FILESYSTEM_BUILD_TESTING})
 if(NOT DEFINED GHC_FILESYSTEM_TEST_COMPILE_FEATURES)
@ -35,14 +32,8 @@ endif()
 if(CMAKE_CXX_STANDARD LESS 11)
    message(FATAL_ERROR "CMAKE_CXX_STANDARD is less than 11, ghc::filesystem only works with C++11 and above.")
 endif()
-if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-    message(STATUS "System name: ${CMAKE_SYSTEM_NAME}")
-    message(STATUS "Compiler ID: ${CMAKE_CXX_COMPILER_ID}")
-    message(STATUS "CMAKE_CXX_COMPILE_FEATURES: ${CMAKE_CXX_COMPILE_FEATURES}")
-endif()

 add_library(ghc_filesystem INTERFACE)
-add_library(ghcFilesystem::ghc_filesystem ALIAS ghc_filesystem)
 target_include_directories(ghc_filesystem INTERFACE
    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    $<INSTALL_INTERFACE:include>)
@ -76,15 +67,7 @@ if(GHC_FILESYSTEM_WITH_INSTALL)
        "${PROJECT_BINARY_DIR}/cmake/ghc_filesystem-config.cmake"
        INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/ghc_filesystem"
        PATH_VARS CMAKE_INSTALL_INCLUDEDIR)
-    write_basic_package_version_file(
-        "${PROJECT_BINARY_DIR}/cmake/ghc_filesystem-config-version.cmake"
-        VERSION ${PROJECT_VERSION}
-        COMPATIBILITY SameMinorVersion
-    )
-    install(
-        FILES
-            "${PROJECT_BINARY_DIR}/cmake/ghc_filesystem-config.cmake"
-            "${PROJECT_BINARY_DIR}/cmake/ghc_filesystem-config-version.cmake"
-        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/ghc_filesystem"
-    )
+    install(FILES "${PROJECT_BINARY_DIR}/cmake/ghc_filesystem-config.cmake"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/ghc_filesystem")
+    add_library(ghcFilesystem::ghc_filesystem ALIAS ghc_filesystem)
 endif()
--- a/README.md
+++ b/README.md
@ -1,56 +1,23 @@
 ![Supported Platforms](https://img.shields.io/badge/platform-macOS%20%7C%20Linux%20%7C%20Windows%20%7C%20FreeBSD-blue.svg)
 ![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
-[![CMake Build Matrix](https://github.com/gulrak/filesystem/actions/workflows/build_cmake.yml/badge.svg?branch=master)](https://github.com/gulrak/filesystem/actions/workflows/build_cmake.yml)
+[![Build Status](https://travis-ci.org/gulrak/filesystem.svg?branch=master)](https://travis-ci.org/gulrak/filesystem)
 [![Build Status](https://ci.appveyor.com/api/projects/status/t07wp3k2cddo0hpo/branch/master?svg=true)](https://ci.appveyor.com/project/gulrak/filesystem)
 [![Build Status](https://api.cirrus-ci.com/github/gulrak/filesystem.svg?branch=master)](https://cirrus-ci.com/github/gulrak/filesystem)
+[![Build Status](https://cloud.drone.io/api/badges/gulrak/filesystem/status.svg?ref=refs/heads/master)](https://cloud.drone.io/gulrak/filesystem)
 [![Coverage Status](https://coveralls.io/repos/github/gulrak/filesystem/badge.svg?branch=master)](https://coveralls.io/github/gulrak/filesystem?branch=master)
-[![Latest Release Tag](https://img.shields.io/github/tag/gulrak/filesystem.svg)](https://github.com/gulrak/filesystem/tree/v1.5.14)
-<!-- [![Build Status](https://cloud.drone.io/api/badges/gulrak/filesystem/status.svg?ref=refs/heads/master)](https://cloud.drone.io/gulrak/filesystem) -->
-
-
-<!-- TOC -->
-* [Filesystem](#filesystem)
-  * [Motivation](#motivation)
-  * [Why the namespace GHC?](#why-the-namespace-ghc)
-  * [Platforms](#platforms)
-  * [Tests](#tests)
-  * [Usage](#usage)
-    * [Downloads](#downloads)
-    * [Using it as Single-File-Header](#using-it-as-single-file-header)
-    * [Using it as Forwarding-/Implementation-Header](#using-it-as-forwarding-implementation-header)
-    * [Git Submodule and CMake](#git-submodule-and-cmake)
-    * [Versioning](#versioning)
-  * [Documentation](#documentation)
-    * [`ghc::filesystem::ifstream`, `ghc::filesystem::ofstream`, `ghc::filesystem::fstream`](#ghcfilesystemifstream--ghcfilesystemofstream--ghcfilesystemfstream)
-    * [`ghc::filesystem::u8arguments`](#ghcfilesystemu8arguments)
-  * [Differences](#differences)
-    * [LWG Defects](#lwg-defects)
-    * [Not Implemented on C++ before C++17](#not-implemented-on-c-before-c17)
-    * [Differences in API](#differences-in-api)
-      * [Differences of Specific Interfaces](#differences-of-specific-interfaces)
-    * [Differences in Behavior](#differences-in-behavior)
-      * [fs.path (ref)](#fspath--ref-)
-  * [Open Issues](#open-issues)
-    * [Windows](#windows)
-      * [Symbolic Links on Windows](#symbolic-links-on-windows)
-      * [Permissions](#permissions)
-  * [Release Notes](#release-notes)
-<!-- TOC -->
+[![Latest Release Tag](https://img.shields.io/github/tag/gulrak/filesystem.svg)](https://github.com/gulrak/filesystem/tree/v1.5.4)

 # Filesystem

 This is a header-only single-file `std::filesystem` compatible helper library,
 based on the C++17 and C++20 specs, but implemented for C++11, C++14, C++17 or C++20
 (tightly following  the C++17 standard with very few documented exceptions). It is currently tested on
-macOS 10.12/10.14/10.15/11.6, Windows 10, Ubuntu 18.04, Ubuntu 20.04, CentOS 7, CentOS 8, FreeBSD 12,
-Alpine ARM/ARM64 Linux and Solaris 10 but should work on other systems too, as long as you have
+macOS 10.12/10.14/10.15, Windows 10, Ubuntu 18.04, CentOS 7, CentOS 8, FreeBSD 12
+and Alpine ARM/ARM64 Linux but should work on other systems too, as long as you have
 at least a C++11 compatible compiler. It should work with Android NDK, Emscripten and I even
-had reports of it being used on iOS (within sandboxing constraints) and with v1.5.6 there
-is experimental support for QNX. The support of Android NDK, Emscripten, QNX, and since 1.5.14
-GNU/Hurd and Haiku is not backed up by automated testing but PRs and bug reports are welcome
-for those too and they are reported to work.
-It is of course in its own namespace `ghc::filesystem` to not interfere with a regular `std::filesystem`
-should you use it in a mixed C++17 environment (which is possible).
+had reports of it being used on iOS (within sandboxing constraints).
+It is of course in its own namespace `ghc::filesystem` to not interfere with a regular `std::filesystem` should you use it in a mixed C++17
+environment (which is possible).

 *Test coverage is well above 90%, and starting with v1.3.6 and in v1.5.0
 more time was invested in benchmarking and optimizing parts of the library. I'll try
@ -91,15 +58,15 @@ to do with Haskell**, sorry for the name clash).
 ## Platforms

 `ghc::filesystem` is developed on macOS but CI tested on macOS, Windows,
-various Linux Distributions, FreeBSD and starting with v1.5.12 on Solaris.
-It should work on any of these with a C++11-capable  compiler. Also there are some
-checks to hopefully better work on Android, but  as I currently don't test with the
-Android NDK, I wouldn't call it a  supported platform yet, same is valid for using
-it with Emscripten. It is now  part of the detected platforms, I fixed the obvious
-issues and ran some tests with  it, so it should be fine. All in all, I don't see it
-replacing `std::filesystem` where full C++17 or C++20 is available, it doesn't try
-to be a "better" `std::filesystem`, just an almost drop-in if you can't use it
-(with the exception  of the UTF-8 preference).
+various Linux Distributions and FreeBSD. It should work on any of these with a C++11-capable
+compiler. Also there are some checks to hopefully better work on Android, but
+as I currently don't test with the Android NDK, I wouldn't call it a
+supported platform yet, same is valid for using it with Emscripten. It is now
+part of the detected platforms, I fixed the obvious issues and ran some tests with
+it, so it should be fine. All in all, I don't see it replacing `std::filesystem`
+where full C++17 or C++20 is available, it doesn't try to be a "better"
+`std::filesystem`, just an almost drop-in if you can't use it (with the exception
+of the UTF-8 preference).

 :information_source: **Important:** _This implementation is following the ["UTF-8 Everywhere" philosophy](https://utf8everywhere.org/) in that all
 `std::string` instances will be interpreted the same as `std::u8string` encoding
@ -108,13 +75,11 @@ for more information._

 Unit tests are currently run with:

-* macOS 10.12: Xcode 9.2 (clang-900.0.39.2), GCC 9.2, Clang 9.0, macOS 10.13: Xcode 10.1, macOS 10.14: Xcode 11.2, macOS 10.15: Xcode 11.6, Xcode 12.4
+* macOS 10.12: Xcode 9.2 (clang-900.0.39.2), GCC 9.2, Clang 9.0, macOS 10.13: Xcode 10.1, macOS 10.14: Xcode 11.2, macOS 10.15: Xcode 11.6
 * Windows: Visual Studio 2017, Visual Studio 2015, Visual Studio 2019, MinGW GCC 6.3 (Win32), GCC 7.2 (Win64), Cygwin GCC 10.2 (no CI yet)
 * Linux (Ubuntu): GCC (5.5, 6.5, 7.4, 8.3, 9.2), Clang (5.0, 6.0, 7.1, 8.0, 9.0)
-* ~~Linux (Alpine ARM/ARM64): GCC 9.2.0~~ (The Drone build scripts stopped working,
-  as they where a contribution, I couldn't figure out what went wrong, any help appreciated.)
+* Linux (Alpine ARM/ARM64): GCC 9.2.0
 * FreeBSD: Clang 8.0
-* Solaris: GCC 5.5 


 ## Tests
@ -154,8 +119,8 @@ in the standard, and there might be issues in these implementations too.

 ### Downloads

-The latest release version is [v1.5.14](https://github.com/gulrak/filesystem/tree/v1.5.14) and
-source archives can be found [here](https://github.com/gulrak/filesystem/releases/tag/v1.5.14).
+The latest release version is [v1.5.4](https://github.com/gulrak/filesystem/tree/v1.5.4) and
+source archives can be found [here](https://github.com/gulrak/filesystem/releases/tag/v1.5.4).

 The latest pre-native-backend version is [v1.4.0](https://github.com/gulrak/filesystem/tree/v1.4.0) and
 source archives can be found [here](https://github.com/gulrak/filesystem/releases/tag/v1.4.0).
@ -176,97 +141,63 @@ Everything is in the namespace `ghc::filesystem`, so one way to use it only as
 a fallback could be:

 ```cpp
-#if _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __TV_OS_VERSION_MIN_REQUIRED && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __WATCH_OS_VERSION_MAX_ALLOWED && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif  
-        #endif
-    #endif
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
+#define GHC_USE_STD_FS
+#include <filesystem>
+namespace fs = std::filesystem;
 #endif
-
-#ifdef GHC_USE_STD_FS
-    #include <filesystem>
-    namespace fs = std::filesystem;
-#else
-    #include "filesystem.hpp"
-    namespace fs = ghc::filesystem;
+#endif
+#ifndef GHC_USE_STD_FS
+#include <ghc/filesystem.hpp>
+namespace fs = ghc::filesystem;
 #endif
 ```

+**Note that this code uses a two-stage preprocessor condition because Visual Studio 2015
+doesn't like the `(<...>)` syntax, even if it could cut evaluation early before. This code also
+used the minimum deployment target to detect if `std::filesystem` really is available on macOS
+compilation.**
+
+**Note also, this detection now works on MSVC versions prior to 15.7 on, or without setting
+the `/Zc:__cplusplus` compile switch that would fix `__cplusplus` on MSVC. (Without the switch
+the compiler always reports `199711L`
+([see](https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/)),
+but `_MSVC_LANG` works without it.**
+
 If you want to also use the `fstream` wrapper with `path` support as fallback,
 you might use:

 ```cpp
-#if _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __TV_OS_VERSION_MIN_REQUIRED && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __WATCH_OS_VERSION_MAX_ALLOWED && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif  
-        #endif
-    #endif
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
+#define GHC_USE_STD_FS
+#include <filesystem>
+namespace fs {
+using namespace std::filesystem;
+using ifstream = std::ifstream;
+using ofstream = std::ofstream;
+using fstream = std::fstream;
+}
 #endif
-
-#ifdef GHC_USE_STD_FS
-    #include <filesystem>
-    namespace fs {
-        using namespace std::filesystem;
-        using ifstream = std::ifstream;
-        using ofstream = std::ofstream;
-        using fstream = std::fstream;
-    }
-#else
-    #include "filesystem.hpp"
-    namespace fs {
-        using namespace ghc::filesystem;
-        using ifstream = ghc::filesystem::ifstream;
-        using ofstream = ghc::filesystem::ofstream;
-        using fstream = ghc::filesystem::fstream;
-    }
+#endif
+#ifndef GHC_USE_STD_FS
+#include <ghc/filesystem.hpp>
+namespace fs {
+using namespace ghc::filesystem;
+using ifstream = ghc::filesystem::ifstream;
+using ofstream = ghc::filesystem::ofstream;
+using fstream = ghc::filesystem::fstream;
+}
 #endif
 ```

 Now you have e.g. `fs::ofstream out(somePath);` and it is either the wrapper or
 the C++17 `std::ofstream`.

-:information_source: **Be aware, as a header-only library, it is not hiding the fact, that it
+**Be aware, as a header-only library, it is not hiding the fact, that it
 uses system includes, so they "pollute" your global namespace. Use the
-forwarding-/implementation-header based approach (see below) to avoid this.
-For Windows it needs `Windows.h` and it might be a good idea to define
-`WIN32_LEAN_AND_MEAN` or `NOMINMAX` prior to including `filesystem.hpp` or
-`fs_std.hpp` headers  to reduce pollution of your global namespace and compile
-time. They are not defined by `ghc::filesystem` to allow combination with contexts
-where the full `Windows.h`is needed, e.g. for UI elements.**
+forwarding-/implementation-header based approach (see below) to avoid this.**

 :information_source: **Hint:** There is an additional header named `ghc/fs_std.hpp` that implements this
 dynamic selection of a filesystem implementation, that you can include
@ -280,8 +211,8 @@ Alternatively, starting from v1.1.0 `ghc::filesystem` can also be used by
 including one of two additional wrapper headers. These allow to include
 a forwarded version in most places (`ghc/fs_fwd.hpp`) while hiding the
 implementation details in a single cpp file that includes `ghc/fs_impl.hpp` to
-implement the needed code. Using `ghc::filesystem` this way makes sure
-system includes are only visible from inside the cpp file, all other places are clean.
+implement the needed code. That way system includes are only visible from
+inside the cpp file, all other places are clean.

 Be aware, that it is currently not supported to hide the implementation
 into a Windows-DLL, as a DLL interface with C++ standard templates in interfaces
@ -292,46 +223,26 @@ If you use the forwarding/implementation approach, you can still use the dynamic
 switching like this:

 ```cpp
-#if _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __TV_OS_VERSION_MIN_REQUIRED && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __WATCH_OS_VERSION_MAX_ALLOWED && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif  
-        #endif
-    #endif
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
+#define GHC_USE_STD_FS
+#include <filesystem>
+namespace fs {
+using namespace std::filesystem;
+using ifstream = std::ifstream;
+using ofstream = std::ofstream;
+using fstream = std::fstream;
+}
 #endif
-
-#ifdef GHC_USE_STD_FS
-    #include <filesystem>
-    namespace fs {
-        using namespace std::filesystem;
-        using ifstream = std::ifstream;
-        using ofstream = std::ofstream;
-        using fstream = std::fstream;
-    }
-#else
-    #include "fs_fwd.hpp"
-    namespace fs {
-        using namespace ghc::filesystem;
-        using ifstream = ghc::filesystem::ifstream;
-        using ofstream = ghc::filesystem::ofstream;
-        using fstream = ghc::filesystem::fstream;
-    }
+#endif
+#ifndef GHC_USE_STD_FS
+#include <ghc/fs-fwd.hpp>
+namespace fs {
+using namespace ghc::filesystem;
+using ifstream = ghc::filesystem::ifstream;
+using ofstream = ghc::filesystem::ofstream;
+using fstream = ghc::filesystem::fstream;
+}
 #endif
 ```

@ -339,38 +250,22 @@ and in the implementation hiding cpp, you might use (before any include that inc
 to take precedence:

 ```cpp
-#if _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __TV_OS_VERSION_MIN_REQUIRED && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || __WATCH_OS_VERSION_MAX_ALLOWED && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif  
-        #endif
-    #endif
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
+#define GHC_USE_STD_FS
+#endif
 #endif
-
 #ifndef GHC_USE_STD_FS
-    #include "fs_impl.hpp"
+#define GHC_FILESYSTEM_IMPLEMENTATION
+#include <ghc/filesystem.hpp>
 #endif
 ```

 :information_source: **Hint:** There are additional helper headers, named `ghc/fs_std_fwd.hpp` and
 `ghc/fs_std_impl.hpp` that use this technique, so you can simply include them
-if you want to dynamically select the filesystem implementation.
+if you want to dynamically select the filesystem implementation. they also
+enable the `wchar_t` support on `ghc::filesystem` on Windows, so the resulting
+implementation in the `fs` namespace will be compatible.



@ -397,10 +292,6 @@ The `CMakeLists.txt` offers a few options to customize its behavior:
  `CMAKE_CXX_COMPILE_FEATURES` when the detection of C++17 or C++20 for additional tests
  is not working (e.g. `cxx_std_20` to enforce building a `filesystem_test_cpp20` with C++20).

-### Bazel
-
-Please use [hedronvision/bazel-cc-filesystem-backport](https://github.com/hedronvision/bazel-cc-filesystem-backport), which will automatically set everything up for you.
-
 ### Versioning

 There is a version macro `GHC_FILESYSTEM_VERSION` defined in case future changes
@ -466,7 +357,7 @@ int main(int argc, char* argv[])
        exit(EXIT_FAILURE);
    }

-    // now use argc/argv as usual, they have utf-8 encoding on windows
+    // now use argc/argv as usual, they have utf-8 enconding on windows
    // ...

    return 0;
@ -631,7 +522,7 @@ the standard.
 As symbolic links on Windows, while being supported more or less since
 Windows Vista (with some strict security constraints) and fully since some earlier
 build of Windows 10, when "Developer Mode" is activated, are at time of writing
-(2018) rarely used, still they are supported wiit th this implementation.
+(2018) rarely used, still they are supported with this implementation.

 #### Permissions

@ -646,114 +537,9 @@ to the expected behavior.

 ## Release Notes

-### v1.5.15 (wip)
-
-* Fix for [#166](https://github.com/gulrak/filesystem/issues/166),
-  `extension()` did return non empty result for the directory name
-  `".."`
-
-###  [v1.5.14](https://github.com/gulrak/filesystem/releases/tag/v1.5.14)
-
-* Pull request [#163](https://github.com/gulrak/filesystem/pull/163), build
-  support for Haiku (also fixes [#159](https://github.com/gulrak/filesystem/issues/159))
-* Pull request [#162](https://github.com/gulrak/filesystem/pull/162), fix for
-  directory iterator treating all files subsequent to a symlink as symlink
-  on Windows
-* Pull request [#161](https://github.com/gulrak/filesystem/pull/161), the
-  CMake alias `ghcFilesystem::ghc_filesystem` is now set unconditionally 
-* Fix for [#160](https://github.com/gulrak/filesystem/issues/160), the cmake
-  config now only sets install targets by default if the project is no
-  subproject, as documented
-* Fix for [#157](https://github.com/gulrak/filesystem/issues/157), suppress
-  C4191 warning on MSVC for GetProcAddress casts
-* Fix for [#156](https://github.com/gulrak/filesystem/issues/156), on POSIX
-  `stem()`, `filename()` and `extension()` of `fs::path` would return wrong
-  result if a colon was in the filename
-* Pull request [#154](https://github.com/gulrak/filesystem/pull/145), build
-  support for GNU/Hurd
-* Pull request [#153](https://github.com/gulrak/filesystem/pull/153), fixed
-  `fs::last_write_time(path, time, ec)` setter on iOS, tvOS and watchOS
-* Fix for [#151](https://github.com/gulrak/filesystem/issues/156),
-  `fs::directory_entry::refresh()` now, consistently with `status()` will not
-  throw on symlinks to non-existing targets, but make the entry have
-  `file_type::not_found` as the type
-* Pull request [#149](https://github.com/gulrak/filesystem/pull/149), add
-  version to CMake project and export it
-* Fix for [#146](https://github.com/gulrak/filesystem/issues/146), handle `EINTR`
-  on POSIX directory iteration and file copy to avoid errors on network
-  filesystems 
-* Pull request [#145](https://github.com/gulrak/filesystem/pull/145), fix for
-  Y2038 bug in timeToFILETIME on Windows
-* Pull request [#144](https://github.com/gulrak/filesystem/pull/144), `fs::copy_file()`
-  now also copies the permissions
-* Pull request [#143](https://github.com/gulrak/filesystem/pull/143), fix
-  for `fs::copy_file()` ignoring the `skip_existing` option.
-
-### [v1.5.12](https://github.com/gulrak/filesystem/releases/tag/v1.5.12)
-
-* Fix for [#142](https://github.com/gulrak/filesystem/issues/142), removed need
-  for `GHC_NO_DIRENT_D_TYPE` on systems that don't support `dirent::d_type` and
-  fixed build configuration and tests to support Solaris as new platform.
-* Pull request [#138](https://github.com/gulrak/filesystem/pull/138), if the
-  platform uses the POSIX backend and has no `PATH_MAX`, one is defined.
-* Pull request [#137](https://github.com/gulrak/filesystem/pull/137), update
-  of Catch2 to version v2.13.7
-* Added macOS 11 to the automatically tested platforms.
-
-### [v1.5.10](https://github.com/gulrak/filesystem/releases/tag/v1.5.10)
-
-* Pull request [#136](https://github.com/gulrak/filesystem/pull/136), the Windows
-  implementation used some unnecessary expensive shared pointer for resource
-  management and these where replaced by a dedicated code.
-* Fix for [#132](https://github.com/gulrak/filesystem/issues/132), pull request
-  [#135](https://github.com/gulrak/filesystem/pull/135), `fs::remove_all` now
-  just deletes symbolic links instead of following them.
-* Pull request [#133](https://github.com/gulrak/filesystem/pull/133), fix for
-  `fs::space` where a numerical overflow could happen in a multiplication.
-* Replaced _travis-ci.org_  with GitHub Workflow for the configurations:
-  Ubuntu 20.04: GCC 9.3, Ubuntu 18.04: GCC 7.5, GCC 8.4, macOS 10.15: Xcode 12.4,
-  Windows 10: Visual Studio 2019
-
-### [v1.5.8](https://github.com/gulrak/filesystem/releases/tag/v1.5.8)
-
-* Fix for [#125](https://github.com/gulrak/filesystem/issues/124), where
-  `fs::create_directories` on Windows no longer breaks on long filenames.
-
-### [v1.5.6](https://github.com/gulrak/filesystem/releases/tag/v1.5.6)
-
-* Fix for [#124](https://github.com/gulrak/filesystem/issues/124),
-  `ghc::filesystem` treated mounted folder/volumes erroneously as symlinks,
-  leading `fs::canonical` to fail on paths containing those.
-* Fix for [#122](https://github.com/gulrak/filesystem/issues/122), incrementing
-  the `recursive_directory_iterator` will not try to enter dead symlinks.
-* Fix for [#121](https://github.com/gulrak/filesystem/issues/121), on Windows
-  backend the `fs::remove` failed when the path pointed to a read-only entry,
-  see also ([microsoft/STL#1511](https://github.com/microsoft/STL/issues/1511))
-  for the corresponding issue in `std::fs` on windows.
-* Fix for [#119](https://github.com/gulrak/filesystem/issues/119), added missing
-  support for char16_t and char32_t and on C++20 char8_t literals.
-* Pull request [#118](https://github.com/gulrak/filesystem/pull/118), when
-  running tests as root, disable tests that would not work.
-* Pull request [#117](https://github.com/gulrak/filesystem/pull/117), added
-  checks to tests to detect the clang/libstdc++ combination.
-* Fix for [#116](https://github.com/gulrak/filesystem/issues/116), internal
-  macro `GHC_NO_DIRENT_D_TYPE` allows os detection to support systems without
-  the `dirent.d_type` member, experimental first QNX compile support as
-  initial use case, fixed issue with filesystems returning DT_UNKNOWN
-  (e.g. reiserfs).
-* Pull request [#115](https://github.com/gulrak/filesystem/pull/115), added
-  `string_view` support when clang with libstdc++ is detected.
-* Fix for [#114](https://github.com/gulrak/filesystem/issues/114), for macOS
-  the pre-Catalina deployment target detection worked only if `<Availability.h>`
-  was included before `<ghc/fs_std.hpp>` or `<ghc/fs_std_fwd.hpp>`/`<ghc/fs_std_impl.hpp>`.
-* Fix for [#113](https://github.com/gulrak/filesystem/issues/113), the use of
-  standard chapter numbers was misleading since C++17 and C++20 `std::filesystem`
-  features are supported, and was replaced by the tag-like chapter names that
-  stay (mostly) consistent over the versions.
-
 ### [v1.5.4](https://github.com/gulrak/filesystem/releases/tag/v1.5.4)

-* Pull request [#112](https://github.com/gulrak/filesystem/pull/112), lots
+* Pull request [#112](https://github.com/gulrak/filesystem/issues/112), lots
  of cleanup work on the readme, thanks!
 * Enhancement for [#111](https://github.com/gulrak/filesystem/issues/111),
  further optimization of directory iteration, performance for
@ -764,15 +550,15 @@ to the expected behavior.
  made to allow the tests to compile and run successfully (tested with GCC
  10.2.0), feedback and additional PRs welcome as it is currently not
  part of the CI configuration.
-* Pull request [#109](https://github.com/gulrak/filesystem/pull/109), various
+* Pull request [#109](https://github.com/gulrak/filesystem/issues/109), various
  spelling errors in error messages and comments fixed.
-* Pull request [#108](https://github.com/gulrak/filesystem/pull/108), old
+* Pull request [#108](https://github.com/gulrak/filesystem/issues/108), old
  style casts removed.
 * Fix for [#107](https://github.com/gulrak/filesystem/issues/107), the error
  handling for status calls was suppressing errors on symlink targets.
-* Pull request [#106](https://github.com/gulrak/filesystem/pull/106), fixed
+* Pull request [#106](https://github.com/gulrak/filesystem/issues/106), fixed
  detection of AppleClang for compile options.
-* Pull request [#105](https://github.com/gulrak/filesystem/pull/105), added
+* Pull request [#105](https://github.com/gulrak/filesystem/issues/105), added
  option `GHC_FILESYSTEM_BUILD_STD_TESTING` to override additional build of
  `std::filesystem` versions of the tests for comparison and the possibility
  to use `GHC_FILESYSTEM_TEST_COMPILE_FEATURES` to prefill the used compile
--- a/cmake/GhcHelper.cmake
+++ b/cmake/GhcHelper.cmake
@ -1,5 +1,6 @@
 macro(AddExecutableWithStdFS targetName)
-if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 7.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0))
+
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 7.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0))
    if(APPLE)
        include_directories(/usr/local/opt/llvm/include)
        link_directories(/usr/local/opt/llvm/lib)
@ -19,12 +20,6 @@ if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND (CMAKE_CXX_COMPILER_VERSION V
            target_link_libraries(${targetName} -stdlib=libc++)
        endif()
    endif()
-    if(${CMAKE_SYSTEM_NAME} MATCHES "(SunOS|Solaris)")
-        target_link_libraries(filesystem_test xnet)
-    endif()
-    if(${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
-        target_link_libraries(filesystem_test network)
-    endif()
    target_compile_definitions(${targetName} PRIVATE USE_STD_FS)
 endif()

@ -34,12 +29,6 @@ if (CMAKE_COMPILER_IS_GNUCXX AND (CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 8.0 O
    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.0)
        target_link_libraries(${targetName} -lstdc++fs)
    endif()
-    if(${CMAKE_SYSTEM_NAME} MATCHES "(SunOS|Solaris)")
-        target_link_libraries(${targetName} xnet)
-    endif()
-    if(${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
-        target_link_libraries(${targetName} network)
-    endif()
    target_compile_options(${targetName} PRIVATE $<$<BOOL:${CYGWIN}>:-Wa,-mbig-obj>)
    target_compile_definitions(${targetName} PRIVATE USE_STD_FS)
 endif()
@ -58,19 +47,12 @@ macro(AddTestExecutableWithStdCpp cppStd)
    add_executable(filesystem_test_cpp${cppStd} ${ARGN})
    set_property(TARGET filesystem_test_cpp${cppStd} PROPERTY CXX_STANDARD ${cppStd})
    target_link_libraries(filesystem_test_cpp${cppStd} ghc_filesystem)
-    if(${CMAKE_SYSTEM_NAME} MATCHES "(SunOS|Solaris)")
-        target_link_libraries(filesystem_test_cpp${cppStd} xnet)
-    endif()
-    if(${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
-        target_link_libraries(filesystem_test_cpp${cppStd} network)
-    endif()
    target_compile_options(filesystem_test_cpp${cppStd} PRIVATE
            $<$<BOOL:${EMSCRIPTEN}>:-s DISABLE_EXCEPTION_CATCHING=0>
            $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Werror -Wno-error=deprecated-declarations>
            $<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Wno-psabi -Werror -Wno-error=deprecated-declarations>
            $<$<CXX_COMPILER_ID:MSVC>:/WX /wd4996>
-            $<$<BOOL:${CYGWIN}>:-Wa,-mbig-obj>
-            $<$<BOOL:${GHC_COVERAGE}>:--coverage>)
+            $<$<BOOL:${CYGWIN}>:-Wa,-mbig-obj>)
    if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
        target_compile_definitions(filesystem_test_cpp${cppStd} PRIVATE _CRT_SECURE_NO_WARNINGS)
    endif()
--- a/include/ghc/filesystem.hpp
+++ b/include/ghc/filesystem.hpp
--- a/include/ghc/fs_fwd.hpp
+++ b/include/ghc/fs_fwd.hpp
@ -25,7 +25,7 @@
 // SOFTWARE.
 //
 //---------------------------------------------------------------------------------------
-// fs_fwd.hpp - The forwarding header for the header/implementation separated usage of
+// fs_fwd.hpp - The forwarding header for the header/implementation seperated usage of
 //              ghc::filesystem.
 // This file can be include at any place, where ghc::filesystem api is needed while
 // not bleeding implementation details (e.g. system includes) into the global namespace,
@ -34,5 +34,5 @@
 #ifndef GHC_FILESYSTEM_FWD_H
 #define GHC_FILESYSTEM_FWD_H
 #define GHC_FILESYSTEM_FWD
-#include "filesystem.hpp"
+#include <ghc/filesystem.hpp>
 #endif // GHC_FILESYSTEM_FWD_H
--- a/include/ghc/fs_impl.hpp
+++ b/include/ghc/fs_impl.hpp
@ -25,11 +25,11 @@
 // SOFTWARE.
 //
 //---------------------------------------------------------------------------------------
-// fs_impl.hpp - The implementation header for the header/implementation separated usage of
+// fs_impl.hpp - The implementation header for the header/implementation seperated usage of
 //               ghc::filesystem.
 // This file can be used to hide the implementation of ghc::filesystem into a single cpp.
 // The cpp has to include this before including fs_fwd.hpp directly or via a different
 // header to work.
 //---------------------------------------------------------------------------------------
 #define GHC_FILESYSTEM_IMPLEMENTATION
-#include "filesystem.hpp"
+#include <ghc/filesystem.hpp>
--- a/include/ghc/fs_std.hpp
+++ b/include/ghc/fs_std.hpp
@ -30,48 +30,27 @@
 //              namespace fs.
 //---------------------------------------------------------------------------------------
 #ifndef GHC_FILESYSTEM_STD_H
-#define GHC_FILESYSTEM_STD_H
-
-#if defined(_MSVC_LANG) && _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__TV_OS_VERSION_MIN_REQUIRED) && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__WATCH_OS_VERSION_MAX_ALLOWED) && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif
-        #endif
-    #endif
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
+#define GHC_USE_STD_FS
+#include <filesystem>
+namespace fs {
+using namespace std::filesystem;
+using ifstream = std::ifstream;
+using ofstream = std::ofstream;
+using fstream = std::fstream;
+}
 #endif
-
-#ifdef GHC_USE_STD_FS
-    #include <filesystem>
-    namespace fs {
-        using namespace std::filesystem;
-        using ifstream = std::ifstream;
-        using ofstream = std::ofstream;
-        using fstream = std::fstream;
-    }
-#else
-    #include "filesystem.hpp"
-    namespace fs {
-        using namespace ghc::filesystem;
-        using ifstream = ghc::filesystem::ifstream;
-        using ofstream = ghc::filesystem::ofstream;
-        using fstream = ghc::filesystem::fstream;
-    }
 #endif
-
+#ifndef GHC_USE_STD_FS
+//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
+#include <ghc/filesystem.hpp>
+namespace fs {
+using namespace ghc::filesystem;
+using ifstream = ghc::filesystem::ifstream;
+using ofstream = ghc::filesystem::ofstream;
+using fstream = ghc::filesystem::fstream;
+} 
+#endif
 #endif // GHC_FILESYSTEM_STD_H
+
--- a/include/ghc/fs_std_fwd.hpp
+++ b/include/ghc/fs_std_fwd.hpp
@ -25,7 +25,7 @@
 // SOFTWARE.
 //
 //---------------------------------------------------------------------------------------
-// fs_std_fwd.hpp - The forwarding header for the header/implementation separated usage of
+// fs_std_fwd.hpp - The forwarding header for the header/implementation seperated usage of
 //                  ghc::filesystem that uses std::filesystem if it detects it.
 // This file can be include at any place, where fs::filesystem api is needed while
 // not bleeding implementation details (e.g. system includes) into the global namespace,
@ -33,47 +33,28 @@
 //---------------------------------------------------------------------------------------
 #ifndef GHC_FILESYSTEM_STD_FWD_H
 #define GHC_FILESYSTEM_STD_FWD_H
-
-#if defined(_MSVC_LANG) && _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__TV_OS_VERSION_MIN_REQUIRED) && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__WATCH_OS_VERSION_MAX_ALLOWED) && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif
-        #endif
-    #endif
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
+#define GHC_USE_STD_FS
+#include <filesystem>
+namespace fs {
+using namespace std::filesystem;
+using ifstream = std::ifstream;
+using ofstream = std::ofstream;
+using fstream = std::fstream;
+}
 #endif
-
-#ifdef GHC_USE_STD_FS
-    #include <filesystem>
-    namespace fs {
-        using namespace std::filesystem;
-        using ifstream = std::ifstream;
-        using ofstream = std::ofstream;
-        using fstream = std::fstream;
-    }
-#else
-    #include "fs_fwd.hpp"
-    namespace fs {
-        using namespace ghc::filesystem;
-        using ifstream = ghc::filesystem::ifstream;
-        using ofstream = ghc::filesystem::ofstream;
-        using fstream = ghc::filesystem::fstream;
-    }
 #endif
-
+#ifndef GHC_USE_STD_FS
+//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
+#define GHC_FILESYSTEM_FWD
+#include <ghc/filesystem.hpp>
+namespace fs {
+using namespace ghc::filesystem;
+using ifstream = ghc::filesystem::ifstream;
+using ofstream = ghc::filesystem::ofstream;
+using fstream = ghc::filesystem::fstream;
+} 
+#endif
 #endif // GHC_FILESYSTEM_STD_FWD_H
+
--- a/include/ghc/fs_std_impl.hpp
+++ b/include/ghc/fs_std_impl.hpp
@ -25,36 +25,19 @@
 // SOFTWARE.
 //
 //---------------------------------------------------------------------------------------
-// fs_std_impl.hpp - The implementation header for the header/implementation separated usage of
+// fs_std_impl.hpp - The implementation header for the header/implementation seperated usage of
 //                   ghc::filesystem that does nothing if std::filesystem is detected.
 // This file can be used to hide the implementation of ghc::filesystem into a single cpp.
 // The cpp has to include this before including fs_std_fwd.hpp directly or via a different
 // header to work.
 //---------------------------------------------------------------------------------------
-#if defined(_MSVC_LANG) && _MSVC_LANG >= 201703L || __cplusplus >= 201703L && defined(__has_include)
-    // ^ Supports MSVC prior to 15.7 without setting /Zc:__cplusplus to fix __cplusplus
-    // _MSVC_LANG works regardless. But without the switch, the compiler always reported 199711L: https://blogs.msdn.microsoft.com/vcblog/2018/04/09/msvc-now-correctly-reports-__cplusplus/
-    #if __has_include(<filesystem>) // Two stage __has_include needed for MSVC 2015 and per https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005finclude.html
-        #define GHC_USE_STD_FS
-
-        // Old Apple OSs don't support std::filesystem, though the header is available at compile
-        // time. In particular, std::filesystem is unavailable before macOS 10.15, iOS/tvOS 13.0,
-        // and watchOS 6.0.
-        #ifdef __APPLE__
-            #include <Availability.h>
-            // Note: This intentionally uses std::filesystem on any new Apple OS, like visionOS
-            // released after std::filesystem, where std::filesystem is always available.
-            // (All other __<platform>_VERSION_MIN_REQUIREDs will be undefined and thus 0.)
-            #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 \
-             || defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__TV_OS_VERSION_MIN_REQUIRED) && __TV_OS_VERSION_MIN_REQUIRED < 130000 \
-             || defined(__WATCH_OS_VERSION_MAX_ALLOWED) && __WATCH_OS_VERSION_MAX_ALLOWED < 60000
-                #undef GHC_USE_STD_FS
-            #endif
-        #endif
-    #endif
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
+#define GHC_USE_STD_FS
+#endif
 #endif
-
 #ifndef GHC_USE_STD_FS
-    #include "fs_impl.hpp"
+//#define GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE
+#define GHC_FILESYSTEM_IMPLEMENTATION
+#include <ghc/filesystem.hpp>
 #endif
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -3,20 +3,6 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
 set(PARSE_CATCH_TESTS_ADD_TO_CONFIGURE_DEPENDS ON)
 include(ParseAndAddCatchTests)

-if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" AND UNIX AND NOT APPLE AND NOT BSD)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
-    set(CMAKE_EXE_LINKER_FLAGS "-lc++abi")
-endif()
-
-function(SetTestCompileOptions target_name)
-    target_compile_options(${target_name} PRIVATE
-        $<$<BOOL:${EMSCRIPTEN}>:-s DISABLE_EXCEPTION_CATCHING=0>
-        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Werror -Wno-deprecated-declarations>
-        $<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Wno-psabi -Werror -Wno-deprecated-declarations>
-        $<$<CXX_COMPILER_ID:MSVC>:/WX /wd4996>
-        $<$<BOOL:${CYGWIN}>:-Wa,-mbig-obj>)
-endfunction()
-
 if(GHC_COVERAGE)
    message("Generating test runner for coverage run...")
    set(CMAKE_EXE_LINKER_FLAGS "${CMCMAKE_EXE_LINKER_FLAGS} --coverage") 
@ -27,31 +13,18 @@ if(GHC_COVERAGE)
        target_compile_options(filesystem_test PUBLIC --coverage)
    endif()
    target_link_libraries(filesystem_test PUBLIC ghc_filesystem --coverage)
-    if(${CMAKE_SYSTEM_NAME} MATCHES "(SunOS|Solaris)")
-        target_link_libraries(filesystem_test PUBLIC xnet)
-    endif()
-    if(${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
-        target_link_libraries(filesystem_test PUBLIC network)
-    endif()
-    if("cxx_std_17" IN_LIST GHC_FILESYSTEM_TEST_COMPILE_FEATURES)
-        AddTestExecutableWithStdCpp(17 filesystem_test.cpp catch.hpp)
-    endif()
-    if("cxx_std_20" IN_LIST GHC_FILESYSTEM_TEST_COMPILE_FEATURES)
-        AddTestExecutableWithStdCpp(20 filesystem_test.cpp catch.hpp)
-    endif()
 else()
    message("Generating test runner for normal test...")
    add_executable(filesystem_test filesystem_test.cpp catch.hpp)
    target_link_libraries(filesystem_test ghc_filesystem)
-    if(${CMAKE_SYSTEM_NAME} MATCHES "(SunOS|Solaris)")
-        target_link_libraries(filesystem_test xnet)
-    endif()
-    if(${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
-        target_link_libraries(filesystem_test network)
-    endif()
-    SetTestCompileOptions(filesystem_test)
+    target_compile_options(filesystem_test PRIVATE
+        $<$<BOOL:${EMSCRIPTEN}>:-s DISABLE_EXCEPTION_CATCHING=0>
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Werror>
+        $<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Wno-psabi -Werror>
+        $<$<CXX_COMPILER_ID:MSVC>:/WX>
+        $<$<BOOL:${CYGWIN}>:-Wa,-mbig-obj>)
    if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
-        target_compile_definitions(filesystem_test PRIVATE _CRT_SECURE_NO_WARNINGS WIN32_LEAN_AND_MEAN NOMINMAX)
+        target_compile_definitions(filesystem_test PRIVATE _CRT_SECURE_NO_WARNINGS)
    endif()
    if(EMSCRIPTEN)
        set_target_properties(filesystem_test PROPERTIES LINK_FLAGS "-g4 -s DISABLE_EXCEPTION_CATCHING=0 -s ALLOW_MEMORY_GROWTH=1")
@ -63,7 +36,10 @@ else()
    if(WIN32)
        add_executable(filesystem_test_char filesystem_test.cpp catch.hpp)
        target_link_libraries(filesystem_test_char ghc_filesystem)
-        SetTestCompileOptions(filesystem_test_char)
+        target_compile_options(filesystem_test_char PRIVATE
+            $<$<CXX_COMPILER_ID:Clang>:-Wall -Wextra -Werror>
+            $<$<CXX_COMPILER_ID:GNU>:-Wall -Werror>
+            $<$<CXX_COMPILER_ID:MSVC>:/WX>)
        if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
 		target_compile_definitions(filesystem_test_char PRIVATE _CRT_SECURE_NO_WARNINGS GHC_WIN_DISABLE_WSTRING_STORAGE_TYPE)
        else()
@ -85,15 +61,14 @@ add_test(multifile_test multifile_test)

 add_executable(fwd_impl_test fwd_test.cpp impl_test.cpp)
 target_link_libraries(fwd_impl_test ghc_filesystem)
-if(${CMAKE_SYSTEM_NAME} MATCHES "(SunOS|Solaris)")
-    target_link_libraries(fwd_impl_test xnet)
-endif()
-if(${CMAKE_SYSTEM_NAME} MATCHES "Haiku")
-    target_link_libraries(fwd_impl_test network)
-endif()
-SetTestCompileOptions(fwd_impl_test)
+target_compile_options(fwd_impl_test PRIVATE
+        $<$<BOOL:${EMSCRIPTEN}>:-s DISABLE_EXCEPTION_CATCHING=0>
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Werror>
+        $<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Wno-psabi -Werror>
+        $<$<CXX_COMPILER_ID:MSVC>:/WX>
+        $<$<BOOL:${CYGWIN}>:-Wa,-mbig-obj>)
 if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
-	target_compile_definitions(fwd_impl_test PRIVATE _CRT_SECURE_NO_WARNINGS WIN32_LEAN_AND_MEAN NOMINMAX)
+    target_compile_definitions(fwd_impl_test PRIVATE _CRT_SECURE_NO_WARNINGS)
 endif()
 add_test(fwd_impl_test fwd_impl_test)

@ -102,4 +77,9 @@ if(NOT MSVC)
    target_compile_options(exception PRIVATE -fno-exceptions)
 endif()
 target_include_directories(exception PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../include)
-SetTestCompileOptions(exception)
+target_compile_options(exception PRIVATE
+        $<$<BOOL:${EMSCRIPTEN}>:-s DISABLE_EXCEPTION_CATCHING=0>
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Werror>
+        $<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Wno-psabi -Werror>
+        $<$<CXX_COMPILER_ID:MSVC>:/WX>
+        $<$<BOOL:${CYGWIN}>:-Wa,-mbig-obj>)
--- a/test/catch.hpp
+++ b/test/catch.hpp
--- a/test/filesystem_test.cpp
+++ b/test/filesystem_test.cpp
@ -76,7 +76,6 @@ using fstream = ghc::filesystem::fstream;
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/un.h>
-#include <unistd.h>
 #endif

 #ifndef GHC_FILESYSTEM_FWD_TEST
@ -99,7 +98,7 @@ using fstream = ghc::filesystem::fstream;
 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

 template <typename TP>
-static std::time_t to_time_t(TP tp)
+std::time_t to_time_t(TP tp)
 {
    using namespace std::chrono;
    auto sctp = time_point_cast<system_clock::duration>(tp - TP::clock::now() + system_clock::now());
@ -107,7 +106,7 @@ static std::time_t to_time_t(TP tp)
 }

 template <typename TP>
-static TP from_time_t(std::time_t t)
+TP from_time_t(std::time_t t)
 {
    using namespace std::chrono;
    auto sctp = system_clock::from_time_t(t);
@ -214,8 +213,7 @@ static void generateFile(const fs::path& pathname, int withSize = -1)
 }

 #ifdef GHC_OS_WINDOWS
-#if !defined(_WIN64) && defined(KEY_WOW64_64KEY)
-static bool isWow64Proc()
+inline bool isWow64Proc()
 {
    typedef BOOL(WINAPI * IsWow64Process_t)(HANDLE, PBOOL);
    BOOL bIsWow64 = FALSE;
@ -227,7 +225,6 @@ static bool isWow64Proc()
    }
    return bIsWow64 == TRUE;
 }
-#endif

 static bool is_symlink_creation_supported()
 {
@ -305,13 +302,13 @@ public:
 };

 template <class T, class U>
-static bool operator==(TestAllocator<T> const&, TestAllocator<U> const&) noexcept
+bool operator==(TestAllocator<T> const&, TestAllocator<U> const&) noexcept
 {
    return true;
 }

 template <class T, class U>
-static bool operator!=(TestAllocator<T> const& x, TestAllocator<U> const& y) noexcept
+bool operator!=(TestAllocator<T> const& x, TestAllocator<U> const& y) noexcept
 {
    return !(x == y);
 }
@ -365,7 +362,7 @@ TEST_CASE("fs::detail::toUtf8", "[filesystem][fs.detail.utf8]")
 }
 #endif

-TEST_CASE("fs.path.generic - path::preferred_separator", "[filesystem][path][fs.path.generic]")
+TEST_CASE("30.10.8.1 path::preferred_separator", "[filesystem][path][fs.path.generic]")
 {
 #ifdef GHC_OS_WINDOWS
    CHECK(fs::path::preferred_separator == '\\');
@ -375,7 +372,7 @@ TEST_CASE("fs.path.generic - path::preferred_separator", "[filesystem][path][fs.
 }

 #ifndef GHC_OS_WINDOWS
-TEST_CASE("fs.path.generic - path(\"//host\").has_root_name()", "[filesystem][path][fs.path.generic]")
+TEST_CASE("30.10.8.1 path(\"//host\").has_root_name()", "[filesystem][path][fs.path.generic]")
 {
    if (!has_host_root_name_support()) {
        WARN("This implementation doesn't support path(\"//host\").has_root_name() == true [C++17 30.12.8.1 par. 4] on this platform, tests based on this are skipped. (Should be okay.)");
@ -383,26 +380,15 @@ TEST_CASE("fs.path.generic - path(\"//host\").has_root_name()", "[filesystem][pa
 }
 #endif

-TEST_CASE("fs.path.construct - path constructors and destructor", "[filesystem][path][fs.path.construct]")
+TEST_CASE("30.10.8.4.1 path constructors and destructor", "[filesystem][path][fs.path.construct]")
 {
    CHECK("/usr/local/bin" == fs::path("/usr/local/bin").generic_string());
    std::string str = "/usr/local/bin";
-#if defined(__cpp_lib_char8_t) && !defined(GHC_FILESYSTEM_ENFORCE_CPP17_API)
-    std::u8string u8str = u8"/usr/local/bin";
-#endif
    std::u16string u16str = u"/usr/local/bin";
    std::u32string u32str = U"/usr/local/bin";
-#if defined(__cpp_lib_char8_t) && !defined(GHC_FILESYSTEM_ENFORCE_CPP17_API)
-    CHECK(u8str == fs::path(u8str).generic_u8string());
-#endif
-    CHECK(u16str == fs::path(u16str).generic_u16string());
-    CHECK(u32str == fs::path(u32str).generic_u32string());
    CHECK(str == fs::path(str, fs::path::format::generic_format));
    CHECK(str == fs::path(str.begin(), str.end()));
    CHECK(fs::path(std::wstring(3, 67)) == "CCC");
-#if defined(__cpp_lib_char8_t) && !defined(GHC_FILESYSTEM_ENFORCE_CPP17_API)
-    CHECK(str == fs::path(u8str.begin(), u8str.end()));
-#endif
    CHECK(str == fs::path(u16str.begin(), u16str.end()));
    CHECK(str == fs::path(u32str.begin(), u32str.end()));
 #ifdef GHC_FILESYSTEM_VERSION
@ -419,7 +405,7 @@ TEST_CASE("fs.path.construct - path constructors and destructor", "[filesystem][
        CHECK("//host/foo/bar" == fs::path("//host/foo/bar"));
    }

-#if !defined(GHC_OS_WINDOWS) && !(defined(__GLIBCXX__) && !(defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE >= 8))) && !defined(USE_STD_FS)
+#if !defined(GHC_OS_WINDOWS) && !(defined(GCC_VERSION) && GCC_VERSION < 80100) && !defined(USE_STD_FS)
    std::locale loc;
    bool testUTF8Locale = false;
    try {
@ -446,7 +432,7 @@ TEST_CASE("fs.path.construct - path constructors and destructor", "[filesystem][
 #endif
 }

-TEST_CASE("fs.path.assign - path assignments", "[filesystem][path][fs.path.assign]")
+TEST_CASE("30.10.8.4.2 path assignments", "[filesystem][path][fs.path.assign]")
 {
    fs::path p1{"/foo/bar"};
    fs::path p2{"/usr/local"};
@ -481,7 +467,7 @@ TEST_CASE("fs.path.assign - path assignments", "[filesystem][path][fs.path.assig
    REQUIRE(p2 == p3);
 }

-TEST_CASE("fs.path.append - path appends", "[filesystem][path][fs.path.append]")
+TEST_CASE("30.10.8.4.3 path appends", "[filesystem][path][fs.path.append]")
 {
 #ifdef GHC_OS_WINDOWS
    CHECK(fs::path("foo") / "c:/bar" == "c:/bar");
@ -507,7 +493,7 @@ TEST_CASE("fs.path.append - path appends", "[filesystem][path][fs.path.append]")
    // TODO: append(first, last)
 }

-TEST_CASE("fs.path.concat - path concatenation", "[filesystem][path][fs.path.concat]")
+TEST_CASE("30.10.8.4.4 path concatenation", "[filesystem][path][fs.path.concat]")
 {
    CHECK((fs::path("foo") += fs::path("bar")) == "foobar");
    CHECK((fs::path("foo") += fs::path("/bar")) == "foo/bar");
@ -546,7 +532,7 @@ TEST_CASE("fs.path.concat - path concatenation", "[filesystem][path][fs.path.con
    // TODO: contat(first, last)
 }

-TEST_CASE("fs.path.modifiers - path modifiers", "[filesystem][path][fs.path.modifiers]")
+TEST_CASE("30.10.8.4.5 path modifiers", "[filesystem][path][fs.path.modifiers]")
 {
    fs::path p = fs::path("/foo/bar");
    p.clear();
@ -585,7 +571,7 @@ TEST_CASE("fs.path.modifiers - path modifiers", "[filesystem][path][fs.path.modi
    CHECK(p2 == "foo");
 }

-TEST_CASE("fs.path.native.obs - path native format observers", "[filesystem][path][fs.path.native.obs]")
+TEST_CASE("30.10.8.4.6 path native format observers", "[filesystem][path][fs.path.native.obs]")
 {
 #ifdef GHC_OS_WINDOWS
 #if defined(IS_WCHAR_PATH) || defined(GHC_USE_WCHAR_T)
@ -623,7 +609,7 @@ TEST_CASE("fs.path.native.obs - path native format observers", "[filesystem][pat
 #endif
 }

-TEST_CASE("fs.path.generic.obs - path generic format observers", "[filesystem][path][fs.path.generic.obs]")
+TEST_CASE("30.10.8.4.7 path generic format observers", "[filesystem][path][fs.path.generic.obs]")
 {
 #ifdef GHC_OS_WINDOWS
 #ifndef IS_WCHAR_PATH
@ -658,7 +644,7 @@ TEST_CASE("fs.path.generic.obs - path generic format observers", "[filesystem][p
 #endif
 }

-TEST_CASE("fs.path.compare - path compare", "[filesystem][path][fs.path.compare]")
+TEST_CASE("30.10.8.4.8 path compare", "[filesystem][path][fs.path.compare]")
 {
    CHECK(fs::path("/foo/b").compare("/foo/a") > 0);
    CHECK(fs::path("/foo/b").compare("/foo/b") == 0);
@ -684,7 +670,7 @@ TEST_CASE("fs.path.compare - path compare", "[filesystem][path][fs.path.compare]
 #endif // LWG_2936_BEHAVIOUR
 }

-TEST_CASE("fs.path.decompose - path decomposition", "[filesystem][path][fs.path.decompose]")
+TEST_CASE("30.10.8.4.9 path decomposition", "[filesystem][path][fs.path.decompose]")
 {
    // root_name()
    CHECK(fs::path("").root_name() == "");
@ -792,9 +778,6 @@ TEST_CASE("fs.path.decompose - path decomposition", "[filesystem][path][fs.path.
    CHECK(fs::path("C:/foo").filename() == "foo");
    CHECK(fs::path("C:\\foo").filename() == "foo");
    CHECK(fs::path("C:foo").filename() == "foo");
-    CHECK(fs::path("t:est.txt").filename() == "est.txt");
-#else
-    CHECK(fs::path("t:est.txt").filename() == "t:est.txt");
 #endif

    // stem()
@ -812,13 +795,6 @@ TEST_CASE("fs.path.decompose - path decomposition", "[filesystem][path][fs.path.
    CHECK(fs::path("/foo/.profile").stem() == ".profile");
    CHECK(fs::path(".bar").stem() == ".bar");
    CHECK(fs::path("..bar").stem() == ".");
-#ifdef GHC_OS_WINDOWS
-    CHECK(fs::path("t:est.txt").stem() == "est");
-#else
-    CHECK(fs::path("t:est.txt").stem() == "t:est");
-#endif
-    CHECK(fs::path("/foo/.").stem() == ".");
-    CHECK(fs::path("/foo/..").stem() == "..");

    // extension()
    CHECK(fs::path("/foo/bar.txt").extension() == ".txt");
@ -826,9 +802,6 @@ TEST_CASE("fs.path.decompose - path decomposition", "[filesystem][path][fs.path.
    CHECK(fs::path("/foo/.profile").extension() == "");
    CHECK(fs::path(".bar").extension() == "");
    CHECK(fs::path("..bar").extension() == ".bar");
-    CHECK(fs::path("t:est.txt").extension() == ".txt");
-    CHECK(fs::path("/foo/.").extension() == "");
-    CHECK(fs::path("/foo/..").extension() == "");

    if (has_host_root_name_support()) {
        // //host-based root-names
@ -847,7 +820,7 @@ TEST_CASE("fs.path.decompose - path decomposition", "[filesystem][path][fs.path.
    }
 }

-TEST_CASE("fs.path.query - path query", "[fielsystem][path][fs.path.query]")
+TEST_CASE("30.10.8.4.10 path query", "[fielsystem][path][fs.path.query]")
 {
    // empty
    CHECK(fs::path("").empty());
@ -945,7 +918,7 @@ TEST_CASE("fs.path.query - path query", "[fielsystem][path][fs.path.query]")
    }
 }

-TEST_CASE("fs.path.gen - path generation", "[filesystem][path][fs.path.gen]")
+TEST_CASE("30.10.8.4.11 path generation", "[filesystem][path][fs.path.gen]")
 {
    // lexically_normal()
    CHECK(fs::path("foo/./bar/..").lexically_normal() == "foo/");
@ -965,10 +938,6 @@ TEST_CASE("fs.path.gen - path generation", "[filesystem][path][fs.path.gen]")
    // lexically_relative()
    CHECK(fs::path("/a/d").lexically_relative("/a/b/c") == "../../d");
    CHECK(fs::path("/a/b/c").lexically_relative("/a/d") == "../b/c");
-    CHECK(fs::path("/a/b/c").lexically_relative("/a/b/c/d/..") == ".");
-    CHECK(fs::path("/a/b/c/").lexically_relative("/a/b/c/d/..") == ".");
-    CHECK(fs::path("").lexically_relative("/a/..") == "");
-    CHECK(fs::path("").lexically_relative("a/..") == ".");
    CHECK(fs::path("a/b/c").lexically_relative("a") == "b/c");
    CHECK(fs::path("a/b/c").lexically_relative("a/b/c/x/y") == "../..");
    CHECK(fs::path("a/b/c").lexically_relative("a/b/c") == ".");
@ -1036,7 +1005,7 @@ static std::string reverseIterateResult(const fs::path& path)
    return result.str();
 }

-TEST_CASE("fs.path.itr - path iterators", "[filesystem][path][fs.path.itr]")
+TEST_CASE("30.10.8.5 path iterators", "[filesystem][path][fs.path.itr]")
 {
    CHECK(iterateResult(fs::path()).empty());
    CHECK("." == iterateResult(fs::path(".")));
@ -1119,7 +1088,7 @@ TEST_CASE("fs.path.itr - path iterators", "[filesystem][path][fs.path.itr]")
    }
 }

-TEST_CASE("fs.path.nonmember - path non-member functions", "[filesystem][path][fs.path.nonmember]")
+TEST_CASE("30.10.8.6 path non-member functions", "[filesystem][path][fs.path.nonmember]")
 {
    fs::path p1("foo/bar");
    fs::path p2("some/other");
@ -1141,7 +1110,7 @@ TEST_CASE("fs.path.nonmember - path non-member functions", "[filesystem][path][f
    CHECK(p1 / p2 == "some/other/foo/bar");
 }

-TEST_CASE("fs.path.io - path inserter and extractor", "[filesystem][path][fs.path.io]")
+TEST_CASE("30.10.8.6.1 path inserter and extractor", "[filesystem][path][fs.path.io]")
 {
    {
        std::ostringstream os;
@ -1191,7 +1160,7 @@ TEST_CASE("fs.path.io - path inserter and extractor", "[filesystem][path][fs.pat
    }
 }

-TEST_CASE("fs.path.factory - path factory functions", "[filesystem][path][fs.path.factory]")
+TEST_CASE("30.10.8.6.2 path factory functions", "[filesystem][path][fs.path.factory]")
 {
    CHECK(fs::u8path("foo/bar") == fs::path("foo/bar"));
    CHECK(fs::u8path("foo/bar") == fs::path("foo/bar"));
@ -1199,7 +1168,7 @@ TEST_CASE("fs.path.factory - path factory functions", "[filesystem][path][fs.pat
    CHECK(fs::u8path(str.begin(), str.end()) == str);
 }

-TEST_CASE("fs.class.filesystem_error - class filesystem_error", "[filesystem][filesystem_error][fs.class.filesystem_error]")
+TEST_CASE("30.10.9 class filesystem_error", "[filesystem][filesystem_error][fs.class.filesystem_error]")
 {
    std::error_code ec(1, std::system_category());
    fs::filesystem_error fse("None", std::error_code());
@ -1218,12 +1187,12 @@ TEST_CASE("fs.class.filesystem_error - class filesystem_error", "[filesystem][fi
    CHECK(fse.path2() == "some/other");
 }

-static constexpr fs::perms constExprOwnerAll()
+constexpr fs::perms constExprOwnerAll()
 {
    return fs::perms::owner_read | fs::perms::owner_write | fs::perms::owner_exec;
 }

-TEST_CASE("fs.enum - enum class perms", "[filesystem][enum][fs.enum]")
+TEST_CASE("30.10.10.4 enum class perms", "[filesystem][enum][fs.enum]")
 {
    static_assert(constExprOwnerAll() == fs::perms::owner_all, "constexpr didn't result in owner_all");
    CHECK((fs::perms::owner_read | fs::perms::owner_write | fs::perms::owner_exec) == fs::perms::owner_all);
@ -1233,7 +1202,7 @@ TEST_CASE("fs.enum - enum class perms", "[filesystem][enum][fs.enum]")
    CHECK((fs::perms::all | fs::perms::set_uid | fs::perms::set_gid | fs::perms::sticky_bit) == fs::perms::mask);
 }

-TEST_CASE("fs.class.file_status - class file_status", "[filesystem][file_status][fs.class.file_status]")
+TEST_CASE("30.10.11 class file_status", "[filesystem][file_status][fs.class.file_status]")
 {
    {
        fs::file_status fs;
@ -1281,7 +1250,7 @@ TEST_CASE("fs.class.file_status - class file_status", "[filesystem][file_status]
 #endif
 }

-TEST_CASE("fs.dir.entry - class directory_entry", "[filesystem][directory_entry][fs.dir.entry]")
+TEST_CASE("30.10.12 class directory_entry", "[filesystem][directory_entry][fs.dir.entry]")
 {
    TemporaryDirectory t;
    std::error_code ec;
@ -1396,19 +1365,9 @@ TEST_CASE("fs.dir.entry - class directory_entry", "[filesystem][directory_entry]
    CHECK(!(d2 != d2));
    CHECK(d1 == d1);
    CHECK(!(d1 == d2));
-    if(is_symlink_creation_supported()) {
-        fs::create_symlink(t.path() / "nonexistent", t.path() / "broken");
-        for (auto d3 : fs::directory_iterator(t.path())) {
-            CHECK_NOTHROW(d3.symlink_status());
-            CHECK_NOTHROW(d3.status());
-            CHECK_NOTHROW(d3.refresh());
-        }
-        fs::directory_entry entry(t.path() / "broken");
-        CHECK_NOTHROW(entry.refresh());
-    }
 }

-TEST_CASE("fs.class.directory_iterator - class directory_iterator", "[filesystem][directory_iterator][fs.class.directory_iterator]")
+TEST_CASE("30.10.13 class directory_iterator", "[filesystem][directory_iterator][fs.class.directory_iterator]")
 {
    {
        TemporaryDirectory t;
@ -1469,7 +1428,7 @@ TEST_CASE("fs.class.directory_iterator - class directory_iterator", "[filesystem
    }
 }

-TEST_CASE("fs.class.rec.dir.itr - class recursive_directory_iterator", "[filesystem][recursive_directory_iterator][fs.class.rec.dir.itr]")
+TEST_CASE("30.10.14 class recursive_directory_iterator", "[filesystem][recursive_directory_iterator][fs.class.rec.dir.itr]")
 {
    {
        auto iter = fs::recursive_directory_iterator(".");
@ -1625,40 +1584,9 @@ TEST_CASE("fs.class.rec.dir.itr - class recursive_directory_iterator", "[filesys
        }
        CHECK(os.str() == "[./a,0],[./d1,0],[./d1/d2,1],[./e,0],");
    }
-    if (is_symlink_creation_supported()) {
-        TemporaryDirectory t(TempOpt::change_path);
-        fs::create_directory("d1");
-        generateFile("d1/a");
-        fs::create_directory("d2");
-        generateFile("d2/b");
-        fs::create_directory_symlink("../d1", "d2/ds1");
-        fs::create_directory_symlink("d3", "d2/ds2");
-        std::multiset<std::string> result;
-        REQUIRE_NOTHROW([&](){
-            for (const auto& de : fs::recursive_directory_iterator("d2", fs::directory_options::follow_directory_symlink)) {
-                result.insert(de.path().generic_string());
-            }
-        }());
-        std::stringstream os;
-        for(const auto& p : result) {
-            os << p << ",";
-        }
-        CHECK(os.str() == "d2/b,d2/ds1,d2/ds1/a,d2/ds2,");
-        os.str("");
-        result.clear();
-        REQUIRE_NOTHROW([&](){
-          for (const auto& de : fs::recursive_directory_iterator("d2")) {
-              result.insert(de.path().generic_string());
-          }
-        }());
-         for(const auto& p : result) {
-            os << p << ",";
-        }
-        CHECK(os.str() == "d2/b,d2/ds1,d2/ds2,");
-    }
 }

-TEST_CASE("fs.op.absolute - absolute", "[filesystem][operations][fs.op.absolute]")
+TEST_CASE("30.10.15.1 absolute", "[filesystem][operations][fs.op.absolute]")
 {
    CHECK(fs::absolute("") == fs::current_path() / "");
    CHECK(fs::absolute(fs::current_path()) == fs::current_path());
@ -1672,7 +1600,7 @@ TEST_CASE("fs.op.absolute - absolute", "[filesystem][operations][fs.op.absolute]
    CHECK(!ec);
 }

-TEST_CASE("fs.op.canonical - canonical", "[filesystem][operations][fs.op.canonical]")
+TEST_CASE("30.10.15.2 canonical", "[filesystem][operations][fs.op.canonical]")
 {
    CHECK_THROWS_AS(fs::canonical(""), fs::filesystem_error);
    {
@ -1715,7 +1643,7 @@ TEST_CASE("fs.op.canonical - canonical", "[filesystem][operations][fs.op.canonic
    }
 }

-TEST_CASE("fs.op.copy - copy", "[filesystem][operations][fs.op.copy]")
+TEST_CASE("30.10.15.3 copy", "[filesystem][operations][fs.op.copy]")
 {
    {
        TemporaryDirectory t(TempOpt::change_path);
@ -1784,7 +1712,7 @@ TEST_CASE("fs.op.copy - copy", "[filesystem][operations][fs.op.copy]")
 #endif
 }

-TEST_CASE("fs.op.copy_file - copy_file", "[filesystem][operations][fs.op.copy_file]")
+TEST_CASE("30.10.15.4 copy_file", "[filesystem][operations][fs.op.copy_file]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -1807,22 +1735,9 @@ TEST_CASE("fs.op.copy_file - copy_file", "[filesystem][operations][fs.op.copy_fi
    CHECK_NOTHROW(fs::copy_file("foobar", "foobar2", ec));
    CHECK(ec);
    CHECK(!fs::exists("foobar"));
-    fs::path file1("temp1.txt");
-    fs::path file2("temp2.txt");
-    generateFile(file1, 200);
-    generateFile(file2, 200);
-    auto allWrite = fs::perms::owner_write | fs::perms::group_write | fs::perms::others_write;
-    CHECK_NOTHROW(fs::permissions(file1, allWrite, fs::perm_options::remove));
-    CHECK((fs::status(file1).permissions() & fs::perms::owner_write) != fs::perms::owner_write);
-    CHECK_NOTHROW(fs::permissions(file2, allWrite, fs::perm_options::add));
-    CHECK((fs::status(file2).permissions() & fs::perms::owner_write) == fs::perms::owner_write);
-    fs::copy_file(file1, file2, fs::copy_options::overwrite_existing);
-    CHECK((fs::status(file2).permissions() & fs::perms::owner_write) != fs::perms::owner_write);
-    CHECK_NOTHROW(fs::permissions(file1, allWrite, fs::perm_options::add));
-    CHECK_NOTHROW(fs::permissions(file2, allWrite, fs::perm_options::add));
 }

-TEST_CASE("fs.op.copy_symlink - copy_symlink", "[filesystem][operations][fs.op.copy_symlink]")
+TEST_CASE("30.10.15.5 copy_symlink", "[filesystem][operations][fs.op.copy_symlink]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -1847,7 +1762,7 @@ TEST_CASE("fs.op.copy_symlink - copy_symlink", "[filesystem][operations][fs.op.c
    CHECK(ec);
 }

-TEST_CASE("fs.op.create_directories - create_directories", "[filesystem][operations][fs.op.create_directories]")
+TEST_CASE("30.10.15.6 create_directories", "[filesystem][operations][fs.op.create_directories]")
 {
    TemporaryDirectory t;
    fs::path p = t.path() / "testdir";
@ -1894,7 +1809,7 @@ TEST_CASE("fs.op.create_directories - create_directories", "[filesystem][operati
 #endif
 }

-TEST_CASE("fs.op.create_directory - create_directory", "[filesystem][operations][fs.op.create_directory]")
+TEST_CASE("30.10.15.7 create_directory", "[filesystem][operations][fs.op.create_directory]")
 {
    TemporaryDirectory t;
    fs::path p = t.path() / "testdir";
@ -1941,7 +1856,7 @@ TEST_CASE("fs.op.create_directory - create_directory", "[filesystem][operations]
 #endif
 }

-TEST_CASE("fs.op.create_directory_symlink - create_directory_symlink", "[filesystem][operations][fs.op.create_directory_symlink]")
+TEST_CASE("30.10.15.8 create_directory_symlink", "[filesystem][operations][fs.op.create_directory_symlink]")
 {
    if (is_symlink_creation_supported()) {
        TemporaryDirectory t;
@ -1960,7 +1875,7 @@ TEST_CASE("fs.op.create_directory_symlink - create_directory_symlink", "[filesys
    }
 }

-TEST_CASE("fs.op.create_hard_link - create_hard_link", "[filesystem][operations][fs.op.create_hard_link]")
+TEST_CASE("30.10.15.9 create_hard_link", "[filesystem][operations][fs.op.create_hard_link]")
 {
 #ifndef GHC_OS_WEB
    TemporaryDirectory t(TempOpt::change_path);
@ -1979,7 +1894,7 @@ TEST_CASE("fs.op.create_hard_link - create_hard_link", "[filesystem][operations]
 #endif
 }

-TEST_CASE("fs.op.create_symlink - create_symlink", "[filesystem][operations][fs.op.create_symlink]")
+TEST_CASE("30.10.15.10 create_symlink", "[filesystem][operations][fs.op.create_symlink]")
 {
    if (is_symlink_creation_supported()) {
        TemporaryDirectory t;
@ -1998,7 +1913,7 @@ TEST_CASE("fs.op.create_symlink - create_symlink", "[filesystem][operations][fs.
    }
 }

-TEST_CASE("fs.op.current_path - current_path", "[filesystem][operations][fs.op.current_path]")
+TEST_CASE("30.10.15.11 current_path", "[filesystem][operations][fs.op.current_path]")
 {
    TemporaryDirectory t;
    std::error_code ec;
@ -2013,7 +1928,7 @@ TEST_CASE("fs.op.current_path - current_path", "[filesystem][operations][fs.op.c
    CHECK(ec);
 }

-TEST_CASE("fs.op.equivalent - equivalent", "[filesystem][operations][fs.op.equivalent]")
+TEST_CASE("30.10.15.12 equivalent", "[filesystem][operations][fs.op.equivalent]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    generateFile("foo", 1234);
@ -2067,7 +1982,7 @@ TEST_CASE("fs.op.equivalent - equivalent", "[filesystem][operations][fs.op.equiv
 #endif
 }

-TEST_CASE("fs.op.exists - exists", "[filesystem][operations][fs.op.exists]")
+TEST_CASE("30.10.15.13 exists", "[filesystem][operations][fs.op.exists]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2077,9 +1992,6 @@ TEST_CASE("fs.op.exists - exists", "[filesystem][operations][fs.op.exists]")
    CHECK(!ec);
    ec = std::error_code(42, std::system_category());
    CHECK(!fs::exists("foo", ec));
-#if defined(__cpp_lib_char8_t) && !defined(GHC_FILESYSTEM_ENFORCE_CPP17_API)
-    CHECK(!fs::exists(u8"foo"));
-#endif
    CHECK(!ec);
    ec.clear();
    CHECK(fs::exists(t.path()));
@ -2095,7 +2007,7 @@ TEST_CASE("fs.op.exists - exists", "[filesystem][operations][fs.op.exists]")
 #endif
 }

-TEST_CASE("fs.op.file_size - file_size", "[filesystem][operations][fs.op.file_size]")
+TEST_CASE("30.10.15.14 file_size", "[filesystem][operations][fs.op.file_size]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2126,7 +2038,7 @@ static uintmax_t getHardlinkCount(const fs::path& p)
 }
 #endif

-TEST_CASE("fs.op.hard_link_count - hard_link_count", "[filesystem][operations][fs.op.hard_link_count]")
+TEST_CASE("30.10.15.15 hard_link_count", "[filesystem][operations][fs.op.hard_link_count]")
 {
 #ifndef GHC_OS_WEB
    TemporaryDirectory t(TempOpt::change_path);
@ -2205,7 +2117,6 @@ public:

    fs::path character_path() const
    {
-#ifndef GHC_OS_SOLARIS
        std::error_code ec;
        if (fs::exists("/dev/null", ec)) {
            return "/dev/null";
@ -2213,7 +2124,6 @@ public:
        else if (fs::exists("NUL", ec)) {
            return "NUL";
        }
-#endif
        return fs::path();
    }
    fs::path temp_path() const { return _t.path(); }
@ -2224,7 +2134,7 @@ private:
    bool _hasSocket;
 };

-TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_block_file - is_block_file", "[filesystem][operations][fs.op.is_block_file]")
+TEST_CASE_METHOD(FileTypeMixFixture, "30.10.15.16 is_block_file", "[filesystem][operations][fs.op.is_block_file]")
 {
    std::error_code ec;
    CHECK(!fs::is_block_file("directory"));
@ -2253,7 +2163,7 @@ TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_block_file - is_block_file", "[fi
    CHECK(!fs::is_block_file(fs::file_status(fs::file_type::unknown)));
 }

-TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_character_file - is_character_file", "[filesystem][operations][fs.op.is_character_file]")
+TEST_CASE_METHOD(FileTypeMixFixture, "30.10.15.17 is_character_file", "[filesystem][operations][fs.op.is_character_file]")
 {
    std::error_code ec;
    CHECK(!fs::is_character_file("directory"));
@ -2282,7 +2192,7 @@ TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_character_file - is_character_fil
    CHECK(!fs::is_character_file(fs::file_status(fs::file_type::unknown)));
 }

-TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_directory - is_directory", "[filesystem][operations][fs.op.is_directory]")
+TEST_CASE_METHOD(FileTypeMixFixture, "30.10.15.18 is_directory", "[filesystem][operations][fs.op.is_directory]")
 {
    std::error_code ec;
    CHECK(fs::is_directory("directory"));
@ -2311,7 +2221,7 @@ TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_directory - is_directory", "[file
    CHECK(!fs::is_directory(fs::file_status(fs::file_type::unknown)));
 }

-TEST_CASE("fs.op.is_empty - is_empty", "[filesystem][operations][fs.op.is_empty]")
+TEST_CASE("30.10.15.19 is_empty", "[filesystem][operations][fs.op.is_empty]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2333,7 +2243,7 @@ TEST_CASE("fs.op.is_empty - is_empty", "[filesystem][operations][fs.op.is_empty]
    CHECK(ec);
 }

-TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_fifo - is_fifo", "[filesystem][operations][fs.op.is_fifo]")
+TEST_CASE_METHOD(FileTypeMixFixture, "30.10.15.20 is_fifo", "[filesystem][operations][fs.op.is_fifo]")
 {
    std::error_code ec;
    CHECK(!fs::is_fifo("directory"));
@ -2362,7 +2272,7 @@ TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_fifo - is_fifo", "[filesystem][op
    CHECK(!fs::is_fifo(fs::file_status(fs::file_type::unknown)));
 }

-TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_other - is_other", "[filesystem][operations][fs.op.is_other]")
+TEST_CASE_METHOD(FileTypeMixFixture, "30.10.15.21 is_other", "[filesystem][operations][fs.op.is_other]")
 {
    std::error_code ec;
    CHECK(!fs::is_other("directory"));
@ -2391,7 +2301,7 @@ TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_other - is_other", "[filesystem][
    CHECK(fs::is_other(fs::file_status(fs::file_type::unknown)));
 }

-TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_regular_file - is_regular_file", "[filesystem][operations][fs.op.is_regular_file]")
+TEST_CASE_METHOD(FileTypeMixFixture, "30.10.15.22 is_regular_file", "[filesystem][operations][fs.op.is_regular_file]")
 {
    std::error_code ec;
    CHECK(!fs::is_regular_file("directory"));
@ -2420,7 +2330,7 @@ TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_regular_file - is_regular_file",
    CHECK(!fs::is_regular_file(fs::file_status(fs::file_type::unknown)));
 }

-TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_socket - is_socket", "[filesystem][operations][fs.op.is_socket]")
+TEST_CASE_METHOD(FileTypeMixFixture, "30.10.15.23 is_socket", "[filesystem][operations][fs.op.is_socket]")
 {
    std::error_code ec;
    CHECK(!fs::is_socket("directory"));
@ -2449,7 +2359,7 @@ TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_socket - is_socket", "[filesystem
    CHECK(!fs::is_socket(fs::file_status(fs::file_type::unknown)));
 }

-TEST_CASE_METHOD(FileTypeMixFixture, "fs.op.is_symlink - is_symlink", "[filesystem][operations][fs.op.is_symlink]")
+TEST_CASE_METHOD(FileTypeMixFixture, "30.10.15.24 is_symlink", "[filesystem][operations][fs.op.is_symlink]")
 {
    std::error_code ec;
    CHECK(!fs::is_symlink("directory"));
@ -2492,7 +2402,7 @@ static fs::file_time_type timeFromString(const std::string& str)
 }
 #endif

-TEST_CASE("fs.op.last_write_time - last_write_time", "[filesystem][operations][fs.op.last_write_time]")
+TEST_CASE("30.10.15.25 last_write_time", "[filesystem][operations][fs.op.last_write_time]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2527,7 +2437,7 @@ TEST_CASE("fs.op.last_write_time - last_write_time", "[filesystem][operations][f
 #endif
 }

-TEST_CASE("fs.op.permissions - permissions", "[filesystem][operations][fs.op.permissions]")
+TEST_CASE("30.10.15.26 permissions", "[filesystem][operations][fs.op.permissions]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2535,13 +2445,8 @@ TEST_CASE("fs.op.permissions - permissions", "[filesystem][operations][fs.op.per
    auto allWrite = fs::perms::owner_write | fs::perms::group_write | fs::perms::others_write;
    CHECK_NOTHROW(fs::permissions("foo", allWrite, fs::perm_options::remove));
    CHECK((fs::status("foo").permissions() & fs::perms::owner_write) != fs::perms::owner_write);
-#if !defined(GHC_OS_WINDOWS)
-    if (geteuid() != 0)
-#endif
-    {
-        CHECK_THROWS_AS(fs::resize_file("foo", 1024), fs::filesystem_error);
-        CHECK(fs::file_size("foo") == 512);
-    }
+    CHECK_THROWS_AS(fs::resize_file("foo", 1024), fs::filesystem_error);
+    CHECK(fs::file_size("foo") == 512);
    CHECK_NOTHROW(fs::permissions("foo", fs::perms::owner_write, fs::perm_options::add));
    CHECK((fs::status("foo").permissions() & fs::perms::owner_write) == fs::perms::owner_write);
    CHECK_NOTHROW(fs::resize_file("foo", 2048));
@ -2552,7 +2457,7 @@ TEST_CASE("fs.op.permissions - permissions", "[filesystem][operations][fs.op.per
    CHECK_THROWS_AS(fs::permissions("bar", fs::perms::owner_write, static_cast<fs::perm_options>(0)), fs::filesystem_error);
 }

-TEST_CASE("fs.op.proximate - proximate", "[filesystem][operations][fs.op.proximate]")
+TEST_CASE("30.10.15.27 proximate", "[filesystem][operations][fs.op.proximate]")
 {
    std::error_code ec;
    CHECK(fs::proximate("/a/d", "/a/b/c") == "../../d");
@ -2582,7 +2487,7 @@ TEST_CASE("fs.op.proximate - proximate", "[filesystem][operations][fs.op.proxima
 #endif
 }

-TEST_CASE("fs.op.read_symlink - read_symlink", "[filesystem][operations][fs.op.read_symlink]")
+TEST_CASE("30.10.15.28 read_symlink", "[filesystem][operations][fs.op.read_symlink]")
 {
    if (is_symlink_creation_supported()) {
        TemporaryDirectory t(TempOpt::change_path);
@ -2598,7 +2503,7 @@ TEST_CASE("fs.op.read_symlink - read_symlink", "[filesystem][operations][fs.op.r
    }
 }

-TEST_CASE("fs.op.relative - relative", "[filesystem][operations][fs.op.relative]")
+TEST_CASE("30.10.15.29 relative", "[filesystem][operations][fs.op.relative]")
 {
    CHECK(fs::relative("/a/d", "/a/b/c") == "../../d");
    CHECK(fs::relative("/a/b/c", "/a/d") == "../b/c");
@ -2611,7 +2516,7 @@ TEST_CASE("fs.op.relative - relative", "[filesystem][operations][fs.op.relative]
    CHECK(!ec);
 }

-TEST_CASE("fs.op.remove - remove", "[filesystem][operations][fs.op.remove]")
+TEST_CASE("30.10.15.30 remove", "[filesystem][operations][fs.op.remove]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2635,7 +2540,7 @@ TEST_CASE("fs.op.remove - remove", "[filesystem][operations][fs.op.remove]")
    CHECK(!ec);
 }

-TEST_CASE("fs.op.remove_all - remove_all", "[filesystem][operations][fs.op.remove_all]")
+TEST_CASE("30.10.15.31 remove_all", "[filesystem][operations][fs.op.remove_all]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2651,15 +2556,11 @@ TEST_CASE("fs.op.remove_all - remove_all", "[filesystem][operations][fs.op.remov
    CHECK_NOTHROW(fs::remove_all("dir1/non-existing", ec));
    CHECK(!ec);
    CHECK(fs::remove_all("dir1/non-existing", ec) == 0);
-    if (is_symlink_creation_supported()) {
-        fs::create_directory_symlink("dir1", "dir1link");
-        CHECK(fs::remove_all("dir1link") == 1);
-    }
    CHECK(fs::remove_all("dir1") == 5);
    CHECK(fs::directory_iterator(t.path()) == fs::directory_iterator());
 }

-TEST_CASE("fs.op.rename - rename", "[filesystem][operations][fs.op.rename]")
+TEST_CASE("30.10.15.32 rename", "[filesystem][operations][fs.op.rename]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2683,7 +2584,7 @@ TEST_CASE("fs.op.rename - rename", "[filesystem][operations][fs.op.rename]")
    CHECK(!fs::exists("barfoo"));
 }

-TEST_CASE("fs.op.resize_file - resize_file", "[filesystem][operations][fs.op.resize_file]")
+TEST_CASE("30.10.15.33 resize_file", "[filesystem][operations][fs.op.resize_file]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2701,7 +2602,7 @@ TEST_CASE("fs.op.resize_file - resize_file", "[filesystem][operations][fs.op.res
    CHECK(!fs::exists("bar"));
 }

-TEST_CASE("fs.op.space - space", "[filesystem][operations][fs.op.space]")
+TEST_CASE("30.10.15.34 space", "[filesystem][operations][fs.op.space]")
 {
    {
        fs::space_info si;
@ -2733,7 +2634,7 @@ TEST_CASE("fs.op.space - space", "[filesystem][operations][fs.op.space]")
 #endif
 }

-TEST_CASE("fs.op.status - status", "[filesystem][operations][fs.op.status]")
+TEST_CASE("30.10.15.35 status", "[filesystem][operations][fs.op.status]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2761,7 +2662,7 @@ TEST_CASE("fs.op.status - status", "[filesystem][operations][fs.op.status]")
    }
 }

-TEST_CASE("fs.op.status_known - status_known", "[filesystem][operations][fs.op.status_known]")
+TEST_CASE("30.10.15.36 status_known", "[filesystem][operations][fs.op.status_known]")
 {
    CHECK(!fs::status_known(fs::file_status()));
    CHECK(fs::status_known(fs::file_status(fs::file_type::not_found)));
@ -2774,7 +2675,7 @@ TEST_CASE("fs.op.status_known - status_known", "[filesystem][operations][fs.op.s
    CHECK(fs::status_known(fs::file_status(fs::file_type::unknown)));
 }

-TEST_CASE("fs.op.symlink_status - symlink_status", "[filesystem][operations][fs.op.symlink_status]")
+TEST_CASE("30.10.15.37 symlink_status", "[filesystem][operations][fs.op.symlink_status]")
 {
    TemporaryDirectory t(TempOpt::change_path);
    std::error_code ec;
@ -2801,7 +2702,7 @@ TEST_CASE("fs.op.symlink_status - symlink_status", "[filesystem][operations][fs.
    }
 }

-TEST_CASE("fs.op.temp_dir_path - temporary_directory_path", "[filesystem][operations][fs.op.temp_dir_path]")
+TEST_CASE("30.10.15.38 temporary_directory_path", "[filesystem][operations][fs.op.temp_dir_path]")
 {
    std::error_code ec;
    CHECK_NOTHROW(fs::exists(fs::temp_directory_path()));
@ -2810,7 +2711,7 @@ TEST_CASE("fs.op.temp_dir_path - temporary_directory_path", "[filesystem][operat
    CHECK(!ec);
 }

-TEST_CASE("fs.op.weakly_canonical - weakly_canonical", "[filesystem][operations][fs.op.weakly_canonical]")
+TEST_CASE("30.10.15.39 weakly_canonical", "[filesystem][operations][fs.op.weakly_canonical]")
 {
    INFO("This might fail on std::implementations that return fs::current_path() for fs::canonical(\"\")");
    CHECK(fs::weakly_canonical("") == ".");
@ -2902,15 +2803,13 @@ TEST_CASE("Windows: Long filename support", "[filesystem][path][fs.path.win.long
        CHECK_NOTHROW(fs::create_directory(dir));
        CHECK(fs::exists(dir));
        generateFile(dir / "f0");
-        REQUIRE(fs::exists(dir / "f0"));
+        CHECK(fs::exists(dir / "f0"));
+        auto native = dir.u8string();
+        if (native.substr(0, 4) == u8"\\\\?\\") {
+            break;
+        }
    }
-    CHECK(c > 'Z');
-    fs::remove_all(fs::current_path() / std::string(16, 'A'));
-    CHECK(!fs::exists(fs::current_path() / std::string(16, 'A')));
-    CHECK_NOTHROW(fs::create_directories(dir));
-    CHECK(fs::exists(dir));
-    generateFile(dir / "f0");
-    CHECK(fs::exists(dir / "f0"));
+    CHECK(c <= 'Z');
 #else
    WARN("Windows specific tests are empty on non-Windows systems.");
 #endif
@ -2970,31 +2869,3 @@ TEST_CASE("Windows: path namespace handling", "[filesystem][path][fs.path.win.na
    WARN("Windows specific tests are empty on non-Windows systems.");
 #endif
 }
-
-TEST_CASE("Windows: Mapped folders handling ", "[filesystem][fs.win][fs.win.mapped]")
-{
-#ifdef GHC_OS_WINDOWS
-    // this test expects a mapped volume on C:\\fs-test as is the case on the development test system
-    // does nothing on other systems
-    if (fs::exists("C:\\fs-test")) {
-        CHECK(fs::canonical("C:\\fs-test\\Test.txt").string() == "C:\\fs-test\\Test.txt");
-    }
-#else
-    WARN("Windows specific tests are empty on non-Windows systems.");
-#endif
-}
-
-TEST_CASE("Windows: Deletion of Read-only Files", "[filesystem][fs.win][fs.win.remove]")
-{
-#ifdef GHC_OS_WINDOWS
-    TemporaryDirectory t(TempOpt::change_path);
-    std::error_code ec;
-    generateFile("foo", 512);
-    auto allWrite = fs::perms::owner_write | fs::perms::group_write | fs::perms::others_write;
-    CHECK_NOTHROW(fs::permissions("foo", allWrite, fs::perm_options::remove));
-    CHECK_NOTHROW(fs::remove("foo"));
-    CHECK(!fs::exists("foo"));
-#else
-    WARN("Windows specific tests are empty on non-Windows systems.");
-#endif
-}
--- a/test/impl_test.cpp
+++ b/test/impl_test.cpp
@ -3,6 +3,7 @@
 // where exactly one cpp includes fs_impl.hpp and all others use
 // fs_fwd.hpp (to test this with maximum functionality, the unit tests
 // are included here, signaling they should only include the fs_fwd.hpp)
+#define NOMINMAX
 #include <ghc/fs_impl.hpp>
 #define CATCH_CONFIG_MAIN
 #include "catch.hpp"
--- a/test/multi1.cpp
+++ b/test/multi1.cpp
@ -27,7 +27,7 @@
 #include <ghc/filesystem.hpp>
 namespace fs = ghc::filesystem;

-// This test and the one in multi2.cpp doesn't actually test relevant functionality,
+// This test and the one in multi2.cpp doesn't actualy test relevant functionality,
 // it is just used to check that it is possible to include filesystem.h in multiple
 // source files.
 TEST_CASE("Multifile-test 1", "[multi]")