[libc++][test] cleanup some small test issues

[CaseyCarter]

Summary

• improve coverage in span's "conversion from std::array" test, while eliminating MSVC diagnostics about testConstructorArray<T>() && testConstructorArray<const T, T>() being redundant when T is already const.

• Don't test use of is_assignable that triggers UB due to an insufficiently-complete type argument in std::function's assignment operator test on non-libc++. (Honestly, my preference would be to remove this.)

• Don't test that shared_ptr initialization from an rvalue triggers the lvalue aliasing constructor on non-libc++; this is not the case for Standard Libraries that implement LWG-2996. (Ditto, I'd simply remove this but it's your library ;).)

[ldionne]

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp

135–136

Sorry if I'm being slow, but can you explain why that's UB?

[CaseyCarter]

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp

135–136

Sure! F2 is incomplete, and is_assignable<F1&, F2&&>::value could yield a different result if F2 were completed - say if F2has a conversion operator to F1& - which is undefined per [meta.reqmts]/5.

[ldionne]

Ship it with the is_assignable test removed. Thanks!

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp

135–136

Oh. It's incomplete cause we don't define std::function<R(Args...)&&>. Of course. It makes sense to remove this IMO.

libcxx/test/std/containers/views/span.cons/stdarray.pass.cpp

//  types different (static sized)
     {
     std::span<const          int,3> s1{ arr};   // a span<const          int> pointing at int.
     std::span<      volatile int,3> s2{ arr};   // a span<      volatile int> pointing at int.
     std::span<      volatile int,3> s3{ arr};   // a span<      volatile int> pointing at const int.
     std::span<const volatile int,3> s4{ arr};   // a span<const volatile int> pointing at int.
     }
 }
 
-template <typename T, typename U = T>
-constexpr bool testConstructorArray()
-{
-    std::array<U,2> val = { U(), U() };
-    ASSERT_NOEXCEPT(std::span<T>   {val});
-    ASSERT_NOEXCEPT(std::span<T, 2>{val});
-    std::span<T>    s1{val};
-    std::span<T, 2> s2{val};
-    return s1.data() == &val[0] && s1.size() == 2
-        && s2.data() == &val[0] && s2.size() == 2;
+template <typename T, typename U>
+constexpr bool testConstructorArray() {
+  std::array<U, 2> val = {U(), U()};
+  ASSERT_NOEXCEPT(std::span<T>{val});
+  std::span<T> s1{val};
+  return s1.data() == &val[0] && s1.size() == 2 && s2.data() == &val[0] &&
+         s2.size() == 2;
 }
 
-template <typename T, typename U = T>
-constexpr bool testConstructorConstArray()
-{
-    const std::array<U,2> val = { U(), U() };
-    ASSERT_NOEXCEPT(std::span<const T>   {val});
-    ASSERT_NOEXCEPT(std::span<const T, 2>{val});
-    std::span<const T>    s1{val};
-    std::span<const T, 2> s2{val};
-    return s1.data() == &val[0] && s1.size() == 2
-        && s2.data() == &val[0] && s2.size() == 2;
+template <typename T, typename U>
+constexpr bool testConstructorConstArray() {
+  const std::array<U, 2> val = {U(), U()};
+  ASSERT_NOEXCEPT(std::span<const T>{val});
+  std::span<const T> s1{val};
+  return s1.data() == &val[0] && s1.size() == 2 && s2.data() == &val[0] &&
+         s2.size() == 2;
 }
 
 template <typename T>
 constexpr bool testConstructors() {
-    static_assert(testConstructorArray<T>(), "");
-    static_assert(testConstructorArray<const T, T>(), "");
-    static_assert(testConstructorConstArray<T>(), "");
-    static_assert(testConstructorConstArray<const T, T>(), "");
+  static_assert(testConstructorArray<T, T>(), "");
+  static_assert(testConstructorArray<const T, const T>(), "");
+  static_assert(testConstructorConstArray<T, T>(), "");
+  static_assert(testConstructorConstArray<const T, const T>(), "");
 
-    return testConstructorArray<T>()
-        && testConstructorArray<const T, T>()
-        && testConstructorConstArray<T>()
-        && testConstructorConstArray<const T, T>();
+  return testConstructorArray<T, T>() &&
+         testConstructorArray<const T, const T>() &&
+         testConstructorArray<const T, T>() &&
+         testConstructorConstArray<T, T>() &&
+         testConstructorConstArray<const T, const T>() &&
+         testConstructorConstArray<const T, T>();
 }
 
 struct A{};
 
 int main(int, char**)
 {
     assert(testConstructors<int>());
     assert(testConstructors<long>());
     assert(testConstructors<double>());
     assert(testConstructors<A>());
 
     assert(testConstructors<int*>());
-    assert(testConstructors<int* const>());
     assert(testConstructors<const int*>());
-    assert(testConstructors<const int* const>());
 
     checkCV();
 
     return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp

#if TEST_STD_VER >= 11
         using F2 = std::function<void(int, int, int)>;
         static_assert(!std::is_assignable<F1&, F2&&>::value, "");
     }
     {
         using F1 = std::function<int(int, int)>;
         using F2 = std::function<A  (int, int)>;
         static_assert(!std::is_assignable<F1&, F2&&>::value, "");
         static_assert(!std::is_assignable<F2&, F1&&>::value, "");
     }
-    {
-        using F1 = std::function<void(int, int)>;
-        using F2 = std::function<void(int, int)&&>;
-        static_assert(!std::is_assignable<F1&, F2&&>::value, "");
-    }
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp

int main(int, char**)
     }
     delete pi;
     {
       std::shared_ptr<int> p1(new int);
       std::shared_ptr<int> p2(p1, nullptr);
       assert(p2.get() == nullptr);
     }
 
-#if TEST_STD_VER > 17
+#if TEST_STD_VER > 17 && defined(_LIBCPP_VERSION)
+    // This won't pass when LWG-2996 is implemented.
     {
       std::shared_ptr<A> pA(new A);
       assert(pA.use_count() == 1);
 
       {
         B b;
         std::shared_ptr<B> pB(std::move(pA), &b);
         assert(A::count == 1);