[libc++] Remove MSVC tests checked into the libc++ test suite

[ldionne]

Summary

We should strive to have our own tests, except when there is overwhelming
value in using another standard library's existing tests. The reason is
that it ensures that implementations don't all start relying on the same
interpretation of the Standard.

The unique_ptr tests did not add any test coverage AFAICT, and the
forward_like tests were moved to the style used everywhere in the
libc++ test suite.

Note that I got to this because this actually broke a downstream
configuration where we use -ffreestanding. The signature of main()
was not consistent with the signature we (need to) use everywhere
in the test suite.

[philnik]

I'm fine with this, but we might want to look into running tests from other standard libraries on libc++ to find implementation divergence and potentially have some extra test coverage.

[ldionne]

In D134767#3819275, @philnik wrote:

I'm fine with this, but we might want to look into running tests from other standard libraries on libc++ to find implementation divergence and potentially have some extra test coverage.

Yes, I 100% agree. It would be great to have e.g. a CI job that runs the MSVC tests using libc++. I just don't think these tests should be checked into our own tree.

[Mordante]

In D134767#3819279, @ldionne wrote:

In D134767#3819275, @philnik wrote:

I'm fine with this, but we might want to look into running tests from other standard libraries on libc++ to find implementation divergence and potentially have some extra test coverage.

Yes, I 100% agree. It would be great to have e.g. a CI job that runs the MSVC tests using libc++. I just don't think these tests should be checked into our own tree.

As discussed on Discord I think they need to be checked in. But We should look at that when we really start to use this feature. No objection to remove this test.

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.msvc/test.compile.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// Includes Microsoft's test that tests the entire header.
-
-#include "test.cpp"

libcxx/test/std/utilities/smartptr/unique.ptr/unique.ptr.msvc/test.cpp

-// Copyright (c) Microsoft Corporation.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include <cassert>
-#include <memory>
-#include <utility>
-
-#include "test_macros.h"
-
-using namespace std;
-
-struct Dummy {
-  constexpr int test() const { return 10; }
-};
-
-constexpr bool test() {
-  // [memory.syn]
-  {
-    // FIXME no make_unique_for_overwrite support
-    //auto p1 = make_unique<int>(42);
-    //auto p2 = make_unique_for_overwrite<int>();
-    //swap(p1, p2);
-    //assert(p1 == p1);
-    //assert(p1 != p2);
-
-    //auto p3 = make_unique<int[]>(10);
-    //auto p4 = make_unique_for_overwrite<int[]>(4);
-    //swap(p3, p4);
-    //assert(p3 == p3);
-    //assert(p3 != p4);
-
-    auto p5 = unique_ptr<int>{nullptr};
-    assert(p5 == nullptr);
-    assert(nullptr == p5);
-    assert(!(p5 != nullptr));
-    assert(!(nullptr != p5));
-    assert(!(p5 < nullptr));
-    assert(!(nullptr < p5));
-    assert(p5 <= nullptr);
-    assert(nullptr <= p5);
-    assert(!(p5 > nullptr));
-    assert(!(nullptr > p5));
-    assert(p5 >= nullptr);
-    assert(nullptr >= p5);
-    assert((p5 <=> nullptr) == strong_ordering::equal);
-    assert((nullptr <=> p5) == strong_ordering::equal);
-  }
-
-  // changes in [unique.ptr.dltr.dflt] and [unique.ptr.dltr.dflt1]
-  // will be tested via destructors and copy assign/constructors
-
-  // [unique.ptr.single.general]
-  {
-    // constructors
-    auto p1 = unique_ptr<int>{new int{}};
-    auto d1 = default_delete<int>{};
-    auto p2 = unique_ptr<int>{new int{}, d1};
-    auto p3 = unique_ptr<int>{new int{}, default_delete<int>{}};
-    auto p4 = std::move(p3);
-    auto p5 = unique_ptr<int>{nullptr};
-    auto p6 = unique_ptr<int, default_delete<int>&>{new int{}, d1};
-    auto p7 = unique_ptr<int>{std::move(p6)};
-
-    // assignment
-    p3      = std::move(p4);
-    auto p8 = unique_ptr<int, default_delete<int>&>{new int{}, d1};
-    p7      = std::move(p8);
-    p1      = nullptr;
-
-    // observers
-    assert(*p2 == 0);
-    auto p9 = unique_ptr<Dummy>{new Dummy};
-    assert(p9->test() == 10);
-    assert(p2.get() != nullptr);
-    [[maybe_unused]] auto& d2 = p2.get_deleter();
-    [[maybe_unused]] auto& d3 = as_const(p2).get_deleter();
-    auto b1                   = static_cast<bool>(p2);
-    assert(b1);
-
-    // modifiers
-    p1.reset();
-    p1.reset(new int{});
-    auto manual_delete = p2.release();
-    delete manual_delete;
-    p5.swap(p1);
-  }
-
-  // [unique.ptr.runtime.general]
-  {
-    // constructors
-    auto p1 = unique_ptr<int[]>{new int[5]};
-    auto d1 = default_delete<int[]>{};
-    auto p2 = unique_ptr<int[]>{new int[5], d1};
-    auto p3 = unique_ptr<int[]>{new int[5], default_delete<int[]>{}};
-    auto p4 = std::move(p1);
-    auto p5 = unique_ptr<int[], default_delete<int[]>&>{new int[5], d1};
-    auto p6 = unique_ptr<int[]>{std::move(p5)};
-
-    // assignment
-    p1      = std::move(p4);
-    auto p7 = unique_ptr<int[], default_delete<int[]>&>{new int[5], d1};
-    p6      = std::move(p7);
-    p4      = nullptr;
-
-    // observers
-    p1[0] = 50;
-    assert(p1[0] == 50);
-    assert(p1.get() != nullptr);
-    [[maybe_unused]] auto& d2 = p1.get_deleter();
-    [[maybe_unused]] auto& d3 = as_const(p1).get_deleter();
-    auto b1                   = static_cast<bool>(p1);
-    assert(b1);
-
-    // modifiers
-    auto manual_delete = p1.release();
-    delete[] manual_delete;
-    p1.reset(new int[3]);
-    p1.reset(nullptr);
-    p1.reset();
-    p1.swap(p4);
-  }
-
-  return true;
-}
-
-static_assert(test());
-
-int main() {} // COMPILE-ONLY

libcxx/test/std/utilities/utility/forward/forward_like.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// test forward_like
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+
+struct U {}; // class type so const-qualification is not stripped from a prvalue
+using CU = const U;
+using T  = int;
+using CT = const T;
+
+U u{};
+const U& cu = u;
+
+static_assert(std::is_same_v<decltype(std::forward_like<T>(U{})), U&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T>(CU{})), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T>(u)), U&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T>(cu)), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T>(std::move(u))), U&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T>(std::move(cu))), CU&&>);
+
+static_assert(std::is_same_v<decltype(std::forward_like<CT>(U{})), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT>(CU{})), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT>(u)), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT>(cu)), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT>(std::move(u))), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT>(std::move(cu))), CU&&>);
+
+static_assert(std::is_same_v<decltype(std::forward_like<T&>(U{})), U&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&>(CU{})), CU&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&>(u)), U&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&>(cu)), CU&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&>(std::move(u))), U&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&>(std::move(cu))), CU&>);
+
+static_assert(std::is_same_v<decltype(std::forward_like<CT&>(U{})), CU&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&>(CU{})), CU&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&>(u)), CU&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&>(cu)), CU&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&>(std::move(u))), CU&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&>(std::move(cu))), CU&>);
+
+static_assert(std::is_same_v<decltype(std::forward_like<T&&>(U{})), U&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&&>(CU{})), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&&>(u)), U&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&&>(cu)), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&&>(std::move(u))), U&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&&>(std::move(cu))), CU&&>);
+
+static_assert(std::is_same_v<decltype(std::forward_like<CT&&>(U{})), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&&>(CU{})), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&&>(u)), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&&>(cu)), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&&>(std::move(u))), CU&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&&>(std::move(cu))), CU&&>);
+
+static_assert(noexcept(std::forward_like<T>(u)));
+
+static_assert(std::is_same_v<decltype(std::forward_like<U&>(u)), U&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CU&>(cu)), CU&>);
+static_assert(std::is_same_v<decltype(std::forward_like<U&&>(std::move(u))), U&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CU&&>(std::move(cu))), CU&&>);
+
+struct NoCtorCopyMove {
+  NoCtorCopyMove() = delete;
+  NoCtorCopyMove(const NoCtorCopyMove&) = delete;
+  NoCtorCopyMove(NoCtorCopyMove&&) = delete;
+};
+
+static_assert(std::is_same_v<decltype(std::forward_like<CT&&>(std::declval<NoCtorCopyMove>())), const NoCtorCopyMove&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<CT&>(std::declval<NoCtorCopyMove>())), const NoCtorCopyMove&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&&>(std::declval<NoCtorCopyMove>())), NoCtorCopyMove&&>);
+static_assert(std::is_same_v<decltype(std::forward_like<T&>(std::declval<NoCtorCopyMove>())), NoCtorCopyMove&>);
+
+static_assert(noexcept(std::forward_like<T>(std::declval<NoCtorCopyMove>())));
+
+constexpr bool test() {
+  {
+    int val       = 1729;
+    auto&& result = std::forward_like<const double&>(val);
+    static_assert(std::is_same_v<decltype(result), const int&>);
+    assert(&result == &val);
+  }
+  {
+    int val       = 1729;
+    auto&& result = std::forward_like<double&>(val);
+    static_assert(std::is_same_v<decltype(result), int&>);
+    assert(&result == &val);
+  }
+  {
+    int val       = 1729;
+    auto&& result = std::forward_like<const double&&>(val);
+    static_assert(std::is_same_v<decltype(result), const int&&>);
+    assert(&result == &val);
+  }
+  {
+    int val       = 1729;
+    auto&& result = std::forward_like<double&&>(val);
+    static_assert(std::is_same_v<decltype(result), int&&>);
+    assert(&result == &val);
+  }
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/utility/forward_like/forward_like.msvc/test.cpp

-// Copyright (c) Microsoft Corporation.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-#include <cassert>
-#include <type_traits>
-#include <utility>
-
-using namespace std;
-
-struct U {}; // class type so const-qualification is not stripped from a prvalue
-using CU = const U;
-using T  = int;
-using CT = const T;
-
-U u{};
-const U& cu = u;
-
-static_assert(is_same_v<decltype(forward_like<T>(U{})), U&&>);
-static_assert(is_same_v<decltype(forward_like<T>(CU{})), CU&&>);
-static_assert(is_same_v<decltype(forward_like<T>(u)), U&&>);
-static_assert(is_same_v<decltype(forward_like<T>(cu)), CU&&>);
-static_assert(is_same_v<decltype(forward_like<T>(std::move(u))), U&&>);
-static_assert(is_same_v<decltype(forward_like<T>(std::move(cu))), CU&&>);
-
-static_assert(is_same_v<decltype(forward_like<CT>(U{})), CU&&>);
-static_assert(is_same_v<decltype(forward_like<CT>(CU{})), CU&&>);
-static_assert(is_same_v<decltype(forward_like<CT>(u)), CU&&>);
-static_assert(is_same_v<decltype(forward_like<CT>(cu)), CU&&>);
-static_assert(is_same_v<decltype(forward_like<CT>(std::move(u))), CU&&>);
-static_assert(is_same_v<decltype(forward_like<CT>(std::move(cu))), CU&&>);
-
-static_assert(is_same_v<decltype(forward_like<T&>(U{})), U&>);
-static_assert(is_same_v<decltype(forward_like<T&>(CU{})), CU&>);
-static_assert(is_same_v<decltype(forward_like<T&>(u)), U&>);
-static_assert(is_same_v<decltype(forward_like<T&>(cu)), CU&>);
-static_assert(is_same_v<decltype(forward_like<T&>(std::move(u))), U&>);
-static_assert(is_same_v<decltype(forward_like<T&>(std::move(cu))), CU&>);
-
-static_assert(is_same_v<decltype(forward_like<CT&>(U{})), CU&>);
-static_assert(is_same_v<decltype(forward_like<CT&>(CU{})), CU&>);
-static_assert(is_same_v<decltype(forward_like<CT&>(u)), CU&>);
-static_assert(is_same_v<decltype(forward_like<CT&>(cu)), CU&>);
-static_assert(is_same_v<decltype(forward_like<CT&>(std::move(u))), CU&>);
-static_assert(is_same_v<decltype(forward_like<CT&>(std::move(cu))), CU&>);
-
-static_assert(is_same_v<decltype(forward_like<T&&>(U{})), U&&>);
-static_assert(is_same_v<decltype(forward_like<T&&>(CU{})), CU&&>);
-static_assert(is_same_v<decltype(forward_like<T&&>(u)), U&&>);
-static_assert(is_same_v<decltype(forward_like<T&&>(cu)), CU&&>);
-static_assert(is_same_v<decltype(forward_like<T&&>(std::move(u))), U&&>);
-static_assert(is_same_v<decltype(forward_like<T&&>(std::move(cu))), CU&&>);
-
-static_assert(is_same_v<decltype(forward_like<CT&&>(U{})), CU&&>);
-static_assert(is_same_v<decltype(forward_like<CT&&>(CU{})), CU&&>);
-static_assert(is_same_v<decltype(forward_like<CT&&>(u)), CU&&>);
-static_assert(is_same_v<decltype(forward_like<CT&&>(cu)), CU&&>);
-static_assert(is_same_v<decltype(forward_like<CT&&>(std::move(u))), CU&&>);
-static_assert(is_same_v<decltype(forward_like<CT&&>(std::move(cu))), CU&&>);
-
-static_assert(noexcept(forward_like<T>(u)));
-
-static_assert(is_same_v<decltype(forward_like<U&>(u)), U&>);
-static_assert(is_same_v<decltype(forward_like<CU&>(cu)), CU&>);
-static_assert(is_same_v<decltype(forward_like<U&&>(std::move(u))), U&&>);
-static_assert(is_same_v<decltype(forward_like<CU&&>(std::move(cu))), CU&&>);
-
-struct NoCtorCopyMove {
-  NoCtorCopyMove() = delete;
-  NoCtorCopyMove(const NoCtorCopyMove&) = delete;
-  NoCtorCopyMove(NoCtorCopyMove&&) = delete;
-};
-
-static_assert(is_same_v<decltype(forward_like<CT&&>(declval<NoCtorCopyMove>())), const NoCtorCopyMove&&>);
-static_assert(is_same_v<decltype(forward_like<CT&>(declval<NoCtorCopyMove>())), const NoCtorCopyMove&>);
-static_assert(is_same_v<decltype(forward_like<T&&>(declval<NoCtorCopyMove>())), NoCtorCopyMove&&>);
-static_assert(is_same_v<decltype(forward_like<T&>(declval<NoCtorCopyMove>())), NoCtorCopyMove&>);
-
-static_assert(noexcept(forward_like<T>(declval<NoCtorCopyMove>())));
-
-constexpr bool test() {
-  {
-    int val       = 1729;
-    auto&& result = forward_like<const double&>(val);
-    static_assert(is_same_v<decltype(result), const int&>);
-    assert(&result == &val);
-  }
-  {
-    int val       = 1729;
-    auto&& result = forward_like<double&>(val);
-    static_assert(is_same_v<decltype(result), int&>);
-    assert(&result == &val);
-  }
-  {
-    int val       = 1729;
-    auto&& result = forward_like<const double&&>(val);
-    static_assert(is_same_v<decltype(result), const int&&>);
-    assert(&result == &val);
-  }
-  {
-    int val       = 1729;
-    auto&& result = forward_like<double&&>(val);
-    static_assert(is_same_v<decltype(result), int&&>);
-    assert(&result == &val);
-  }
-  return true;
-}
-
-int main() {
-  assert(test());
-  static_assert(test());
-}

libcxx/test/std/utilities/utility/forward_like/forward_like.msvc/test.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
-
-// Includes Microsoft's test that tests the entire header.
-
-#include "test.cpp"