[WIP] [private] [libcxx] Tests for future changes for windows CI configurations

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

[mstorsjo]

New run

libcxx/docs/BuildingLibcxx.rst

 it is the simplest way to build.
 
 .. code-block:: batch
 
   > cmake -G "Visual Studio 16 2019"              ^
           -T "ClangCL"                            ^
           -DLIBCXX_ENABLE_SHARED=YES              ^
           -DLIBCXX_ENABLE_STATIC=NO               ^
-          -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=NO ^
           \path\to\libcxx
   > cmake --build .
 
 CMake + ninja (MSVC)
 ~~~~~~~~~~~~~~~~~~~~
 
 Building with ninja is required for development to enable tests.
 Running the tests also requires a Bash shell and Python to be available.

 In either case, then run:
 
 .. code-block:: batch
 
   > cmake -G Ninja                                                                    ^
           -DCMAKE_BUILD_TYPE=Release                                                  ^
           -DCMAKE_C_COMPILER=clang-cl                                                 ^
           -DCMAKE_CXX_COMPILER=clang-cl                                               ^
-          -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=NO                                     ^
           path/to/libcxx
   > ninja cxx
   > ninja check-cxx
 
 If you are running in an MSYS2 shell and you have installed the
 MSYS2-provided clang package (which defaults to a non-MSVC target), you
 should add e.g. ``-DLIBCXX_TARGET_TRIPLE=x86_64-windows-msvc`` (replacing
 ``x86_64`` with the architecture you're targeting) to the ``cmake`` command

libcxx/test/libcxx/strings/c.strings/version_cuchar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // XFAIL: *
 
+// Skip this test on windows. If built on top of the MSVC runtime, the
+// <cuchar> header actually does exist (although not provided by us).
+// UNSUPPORTED: windows
+
 // <cuchar>
 
 #include <cuchar>
 
 #include "test_macros.h"
 
 #ifndef _LIBCPP_VERSION
 #error _LIBCPP_VERSION not defined
 #endif
 
 int main(int, char**)
 {
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/path.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // class directory_entry
 
 // explicit directory_entry(const path);
 // directory_entry(const path&, error_code& ec);
 
 #include "filesystem_include.h"

 
 TEST_CASE(path_ctor_cannot_resolve) {
   using namespace fs;
 #ifdef _WIN32
   // Windows doesn't support setting perms::none to trigger failures
   // reading directories; test using a special inaccessible directory
   // instead.
   const path dir = GetWindowsInaccessibleDir();
-  TEST_REQUIRE(!dir.empty());
+  if (dir.empty())
+    TEST_UNSUPPORTED();
   const path file = dir / "file";
   {
     std::error_code ec = GetTestEC();
     directory_entry ent(file, ec);
     TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
     TEST_CHECK(ent.path() == file);
   }
   {

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // class directory_iterator
 
 // explicit directory_iterator(const path& p);
 // directory_iterator(const path& p, directory_options options);
 // directory_iterator(const path& p, error_code& ec);
 // directory_iterator(const path& p, directory_options options, error_code& ec);

 TEST_CASE(access_denied_test_case)
 {
     using namespace fs;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path testDir = GetWindowsInaccessibleDir();
-    TEST_REQUIRE(!testDir.empty());
+    if (testDir.empty())
+        TEST_UNSUPPORTED();
 #else
     scoped_test_env env;
     path const testDir = env.make_env_path("dir1");
     path const testFile = testDir / "testFile";
     env.create_dir(testDir);
     env.create_file(testFile, 42);
 
     // Test that we can iterator over the directory before changing the perms

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // class directory_iterator
 
 //
 // explicit recursive_directory_iterator(const path& p);
 // recursive_directory_iterator(const path& p, directory_options options);
 // recursive_directory_iterator(const path& p, error_code& ec);

 TEST_CASE(access_denied_test_case)
 {
     using namespace fs;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path testDir = GetWindowsInaccessibleDir();
-    TEST_REQUIRE(!testDir.empty());
+    if (testDir.empty())
+        TEST_UNSUPPORTED();
 #else
     scoped_test_env env;
     path const testDir = env.make_env_path("dir1");
     path const testFile = testDir / "testFile";
     env.create_dir(testDir);
     env.create_file(testFile, 42);
 
     // Test that we can iterator over the directory before changing the perms

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.exists/exists.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
-// XFAIL: LIBCXX-WINDOWS-FIXME
-
 // <filesystem>
 
 // bool exists(file_status s) noexcept
 // bool exists(path const& p);
 // bool exists(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>

 
 TEST_CASE(test_exists_fails)
 {
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
-    TEST_REQUIRE(!p.empty());
+    if (p.empty())
+        TEST_UNSUPPORTED();
 #else
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path p = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;

libcxx/test/std/strings/c.strings/cuchar.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // XFAIL: libc++
 
+// Skip this test on windows. If built on top of the MSVC runtime, the
+// <cuchar> header actually does exist (although not provided by us).
+// UNSUPPORTED: windows
+
 // <cuchar>
 
 #include <cuchar>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
 
   return 0;
 }

libcxx/test/support/filesystem_test_helper.h

 };
 
 inline fs::path GetWindowsInaccessibleDir() {
   // Only makes sense on windows, but the code can be compiled for
   // any platform.
   const fs::path dir("C:\\System Volume Information");
   std::error_code ec;
   const fs::path root("C:\\");
-  fs::directory_iterator it(root, ec);
-  if (ec)
-    return fs::path();
-  const fs::directory_iterator endIt{};
-  while (it != endIt) {
-    const fs::directory_entry &ent = *it;
-    if (ent == dir) {
-      // Basic sanity checks on the directory_entry
-      if (!ent.exists())
-        return fs::path();
-      if (!ent.is_directory())
-        return fs::path();
-      return ent;
+  for (const auto &ent : fs::directory_iterator(root, ec)) {
+    if (ent != dir)
+      continue;
+    if (!ent.exists() || !ent.is_directory()) {
+      fprintf(stderr, "The expected inaccessible directory \"%s\" was found "
+                      "but doesn't behave as expected, skipping tests "
+                      "regarding it\n", dir.string().c_str());
+    }
+    // Check that it indeed is inaccessible as expected
+    (void)fs::exists(ent, ec);
+    if (!ec) {
+      fprintf(stderr, "The expected inaccessible directory \"%s\" was found "
+                      "but seems to be accessible, skipping tests "
+                      "regarding it\n", dir.string().c_str());
     }
-    ++it;
+    return ent;
   }
+  fprintf(stderr, "No inaccessible directory \"%s\" found, skipping tests "
+                  "regarding it\n", dir.string().c_str());
   return fs::path();
 }
 
 #endif /* FILESYSTEM_TEST_HELPER_HPP */

libcxx/utils/ci/buildkite-pipeline.yml

artifact_paths:
       - "**/test-results.xml"
     agents:
       queue: "libcxx-builders"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
 
+  - label: "Windows"
+    # The CI runner doesn't have bash in the path currently
+    command: "\"\\Program Files\\Git\\usr\\bin\\bash\" libcxx/utils/ci/run-buildbot generic-win"
+    artifact_paths:
+      - "**/test-results.xml"
+    agents:
+      queue: "windows"
+    retry:
+      automatic:
+        - exit_status: -1  # Agent was lost
+          limit: 2
+    soft_fail:
+        - exit_status: 1
+
   # All jobs defined before this `wait` will run whenever a CI job is started.
   # Jobs defined after the `wait` will run only if all the jobs above succeeded.
   # We use this to reduce the load on testers that have more constrained resources
   # and avoid running builds that we know fail anyway.
   - wait
 
   # Build with the configuration we use to generate libc++.dylib on Apple platforms
   - label: "Apple system"

libcxx/utils/ci/run-buildbot

armv7)
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Armv7Arm.cmake"
     check-cxx-cxxabi
 ;;
 armv7-noexceptions)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Armv7Thumb-noexceptions.cmake"
     check-cxx-cxxabi
 ;;
+generic-win)
+    clean
+    # Add bash to the path; the current CI runner doesn't have it added
+    # globally.
+    export PATH="$PATH:/c/Program Files/Git/usr/bin"
+
+    # -D_LIBCPP_HAS_NO_INT128 allows building filesystem with a MSVC
+    # setup that lacks the necessary builtins for int128.
+
+    # -loldnames is needed for some tests unless using Clang 12 (the
+    # CI runner has Clang 11 currently).
+
+    echo "--- Generating CMake"
+    cmake -S "${MONOREPO_ROOT}/libcxx" \
+          -B "${BUILD_DIR}" \
+          -GNinja -DCMAKE_MAKE_PROGRAM="${NINJA}" \
+          -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+          -DCMAKE_C_COMPILER=clang-cl \
+          -DCMAKE_CXX_COMPILER=clang-cl \
+          -DLLVM_LIT_ARGS="-sv --show-unsupported --xunit-xml-output test-results.xml" \
+          -DLIBCXX_ENABLE_FILESYSTEM=YES \
+          -DCMAKE_CXX_FLAGS="-D_LIBCPP_HAS_NO_INT128" \
+          -DLIBCXX_TEST_LINKER_FLAGS="-loldnames"
+    echo "+++ Running the libc++ tests"
+    ${NINJA} -vC "${BUILD_DIR}" check-cxx
+;;
 *)
     echo "${BUILDER} is not a known configuration"
     exit 1
 ;;
 esac

libcxx/utils/libcxx/test/config.py

def get_lit_bool(self, name, default=None, env_var=None):
                     'Environment variable %s=%s is overriding explicit '
                     '--param=%s=%s' % (env_var, val, name, conf_val))
             return check_value(val, env_var)
         return check_value(conf_val, name)
 
     def make_static_lib_name(self, name):
         """Return the full filename for the specified library name"""
         if self.target_info.is_windows() and not self.target_info.is_mingw():
-            assert name == 'c++'  # Only allow libc++ to use this function for now.
             return 'lib' + name + '.lib'
         else:
             return 'lib' + name + '.a'
 
     def configure(self):
         self.target_info = make_target_info(self)
         self.executor = self.get_lit_conf('executor')
         self.configure_cxx()
def configure(self):
 
         libcxx.test.newconfig.configure(
             libcxx.test.params.DEFAULT_PARAMETERS,
             libcxx.test.features.DEFAULT_FEATURES,
             self.config,
             self.lit_config
         )
 
+        if 'c++experimental' in self.config.available_features:
+            self.configure_link_flags_cxx_experimental_library()
+
         self.lit_config.note("All available features: {}".format(self.config.available_features))
 
     def print_config_info(self):
         if self.cxx.use_modules:
             self.lit_config.note('Using modules flags: %s' %
                                  self.cxx.modules_flags)
         if len(self.cxx.warning_flags):
             self.lit_config.note('Using warnings: %s' % self.cxx.warning_flags)
def configure_link_flags_cxx_library(self):
                 libname = self.make_static_lib_name('c++')
                 abs_path = os.path.join(self.cxx_library_root, libname)
                 assert os.path.exists(abs_path) and \
                        "static libc++ library does not exist"
                 self.cxx.link_flags += [abs_path]
             else:
                 self.cxx.link_flags += ['-lc++']
 
+    def configure_link_flags_cxx_experimental_library(self):
+        # c++experimental is always linked statically
+        if self.cxx_library_root:
+            libname = self.make_static_lib_name('c++experimental')
+            abs_path = os.path.join(self.cxx_library_root, libname)
+            assert os.path.exists(abs_path) and \
+                   "static libc++ library does not exist"
+            self.cxx.link_flags += [abs_path]
+        else:
+            self.cxx.link_flags += ['-lc++experimental']
+
     def configure_link_flags_abi_library(self):
         cxx_abi = self.get_lit_conf('cxx_abi', 'libcxxabi')
         if cxx_abi == 'libstdc++':
             self.cxx.link_flags += ['-lstdc++']
         elif cxx_abi == 'libsupc++':
             self.cxx.link_flags += ['-lsupc++']
         elif cxx_abi == 'libcxxabi':
             # If the C++ library requires explicitly linking to libc++abi, or

libcxx/utils/libcxx/test/params.py

Parameter(name='use_system_cxx_lib', choices=[True, False], type=bool, default=False,
               # which is not relevant for non-shipped flavors of libc++.
               AddCompileFlag('-D_LIBCPP_DISABLE_AVAILABILITY')
             ]),
 
   # Parameters to enable or disable parts of the test suite
   Parameter(name='enable_experimental', choices=[True, False], type=bool, default=False,
             help="Whether to enable tests for experimental C++ libraries (typically Library Fundamentals TSes).",
             actions=lambda experimental: [] if not experimental else [
-              AddFeature('c++experimental'),
-              AddLinkFlag('-lc++experimental')
+              AddFeature('c++experimental')
             ]),
 
   Parameter(name='long_tests', choices=[True, False], type=bool, default=True,
             help="Whether to enable tests that take longer to run. This can be useful when running on a very slow device.",
             actions=lambda enabled: [] if not enabled else [
               AddFeature('long_tests')
             ]),
 
   Parameter(name='enable_debug_tests', choices=[True, False], type=bool, default=True,
             help="Whether to enable tests that exercise the libc++ debugging mode.",
             actions=lambda enabled: [] if enabled else [
               AddFeature('libcxx-no-debug-mode')
             ]),
 ]