[libcxx][test] Disable bad unique_ptr<T[]> to shared_ptr<U[]> conversion test cases

[CaseyCarter]

Summary

for non-libc++. I've reported allowance of these conversions as a bug at https://llvm.org/PR53368.

[Mordante]

LGTM!

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp

129

Thanks for filing a bug report! Can you add a link to the bug in the comments?

[• Quuxplusone]

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp

129

+1, please add // https://llvm.org/PR53368 on each of these lines (and then the longer comment is probably superfluous). Whoever fixes PR53368 should git grep for mentions of it, which will lead them here.

[CaseyCarter]

Replace flowery comment with problem report link.

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.assign/unique_ptr_Y.pass.cpp

//          assert(pB.use_count() == 1); // no longer true due to LWG 2415
             assert(pB.get() == ptrA);
         }
         assert(B::count == 0);
         assert(A::count == 0);
     }
     assert(B::count == 0);
     assert(A::count == 0);
 
+#ifdef _LIBCPP_VERSION // https://llvm.org/PR53368
     {
       std::unique_ptr<A[]> ptr(new A[8]);
       A* raw_ptr = ptr.get();
       std::shared_ptr<B> p;
       p = std::move(ptr);
       assert(A::count == 8);
       assert(B::count == 8);
       assert(p.use_count() == 1);
       assert(p.get() == raw_ptr);
#ifdef _LIBCPP_VERSION // https://llvm.org/PR53368
     }
     assert(A::count == 0);
 
     {
       std::unique_ptr<int[]> ptr(new int[8]);
       std::shared_ptr<int> p;
       p = std::move(ptr);
     }
+#endif // _LIBCPP_VERSION
 
 #if TEST_STD_VER > 14
     {
       StatefulArrayDeleter<A> d;
       std::unique_ptr<A[], StatefulArrayDeleter<A>&> u(new A[4], d);
       std::shared_ptr<A[]> p;
       p = std::move(u);
       d.state = 42;
       assert(A::count == 4);
     }
     assert(A::count == 0);
     assert(B::count == 0);
 
+#ifdef _LIBCPP_VERSION // https://llvm.org/PR53368
     {
       std::unique_ptr<A[]> ptr(new A[8]);
       A* raw_ptr = ptr.get();
       std::shared_ptr<B[]> p;
       p = std::move(ptr);
       assert(A::count == 8);
       assert(B::count == 8);
       assert(p.use_count() == 1);
       assert(p.get() == raw_ptr);
       assert(ptr.get() == 0);
     }
     assert(A::count == 0);
     assert(B::count == 0);
+#endif // _LIBCPP_VERSION
 
     {
       std::unique_ptr<A[]> ptr(new A[8]);
       A* raw_ptr = ptr.get();
       std::shared_ptr<A[]> p;
       p = std::move(ptr);
       assert(A::count == 8);
       assert(p.use_count() == 1);

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

#endif
 
     {
     adl::D d;
     std::unique_ptr<int, adl::D&> u(nullptr, d);
     std::shared_ptr<int> s = std::move(u);
     }
 
     assert(A::count == 0);
+#ifdef _LIBCPP_VERSION // https://llvm.org/PR53368
     {
       std::unique_ptr<A[]> ptr(new A[8]);
       A* raw_ptr = ptr.get();
       std::shared_ptr<B> p(std::move(ptr));
       assert(A::count == 8);
       assert(B::count == 8);
       assert(p.use_count() == 1);
       assert(p.get() == raw_ptr);
assert(B::count == 0);
       assert(ptr.get() == 0);
     }
     assert(A::count == 0);
 
     {
       std::unique_ptr<int[]> ptr(new int[8]);
       std::shared_ptr<int> p(std::move(ptr));
     }
+#endif // _LIBCPP_VERSION
 
 #if TEST_STD_VER > 14
     {
       StatefulArrayDeleter<A> d;
       std::unique_ptr<A[], StatefulArrayDeleter<A>&> u(new A[4], d);
       std::shared_ptr<A[]> p(std::move(u));
       d.state = 42;
       assert(A::count == 4);
     }
     assert(A::count == 0);
     assert(B::count == 0);
 
+#ifdef _LIBCPP_VERSION // https://llvm.org/PR53368
     {
       std::unique_ptr<A[]> ptr(new A[8]);
       A* raw_ptr = ptr.get();
       std::shared_ptr<B[]> p(std::move(ptr));
       assert(A::count == 8);
       assert(B::count == 8);
       assert(p.use_count() == 1);
       assert(p.get() == raw_ptr);
       assert(ptr.get() == 0);
     }
     assert(A::count == 0);
     assert(B::count == 0);
+#endif // _LIBCPP_VERSION
 
     {
       std::unique_ptr<A[]> ptr(new A[8]);
       A* raw_ptr = ptr.get();
       std::shared_ptr<A[]> p(std::move(ptr));
       assert(A::count == 8);
       assert(p.use_count() == 1);
       assert(p.get() == raw_ptr);