[libc++] [test] Add tests for converting array types in shared_ptr.

[var-const]

Summary

The only possible kind of a conversion in initialization of a shared
pointer to an array is a qualification conversion (i.e., adding
cv-qualifiers). This patch adds tests for converting from A[] to
const A[] to the following functions:

template<class Y> explicit shared_ptr(Y* p);

template<class Y> shared_ptr(const shared_ptr<Y>& r);
template<class Y> shared_ptr(shared_ptr<Y>&& r);

template<class Y> shared_ptr& operator=(const shared_ptr<Y>& r);
template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r);

template<class Y> void reset(Y* p);
template<class Y, class D> void reset(Y* p, D d);
template<class Y, class D, class A> void reset(Y* p, D d, A a);

Similar tests for converting functions that involve a weak_ptr should
be added once LWG issue 3001
is implemented.

[ldionne]

Awesome, thanks for adding these tests!

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

100

For lurkers: this was most likely an oversight in the original test, since we mean to test the move constructor, not the copy constructor. @var-const told me offline, cause I was puzzled.

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

assert(A::count == 0);
         }
         assert(pA.use_count() == 0);
         assert(B::count == 0);
         assert(A::count == 0);
     }
     assert(B::count == 0);
     assert(A::count == 0);
 
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<A[]> p1(new A[8]);
+        A* ptr = p1.get();
+        assert(A::count == 8);
+        {
+            std::shared_ptr<const A[]> p2;
+            p2 = p1;
+            assert(A::count == 8);
+            assert(p2.use_count() == 2);
+            assert(p1.use_count() == 2);
+            assert(p1.get() == p2.get());
+            assert(p2.get() == ptr);
+        }
+        assert(p1.use_count() == 1);
+        assert(A::count == 8);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }

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

 // <memory>
 
 // shared_ptr
 
 // template<class Y> shared_ptr& operator=(shared_ptr<Y>&& r);
 
 #include <memory>
 #include <type_traits>
+#include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct B
 {
     static int count;
 
assert(A::count == 0);
         }
         assert(pA.use_count() == 0);
         assert(B::count == 0);
         assert(A::count == 0);
     }
     assert(B::count == 0);
     assert(A::count == 0);
 
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<A[]> p1(new A[8]);
+        A* ptr = p1.get();
+        assert(A::count == 8);
+        {
+            std::shared_ptr<const A[]> p2;
+            p2 = std::move(p1);
+            assert(A::count == 8);
+            assert(p2.use_count() == 1);
+            assert(p1.use_count() == 0);
+            assert(p1.get() == nullptr);
+            assert(p2.get() == ptr);
+        }
+        assert(p1.use_count() == 0);
+        assert(A::count == 0);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }

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

#if TEST_STD_VER > 14
     assert(A::count == 0);
 
     {
       std::shared_ptr<A[]> pA(new A[8]);
       assert(pA.use_count() == 1);
       assert(A::count == 8);
     }
     assert(A::count == 0);
+
+    {
+      std::shared_ptr<const A[]> pA(new A[8]);
+      assert(pA.use_count() == 1);
+      assert(A::count == 8);
+    }
+    assert(A::count == 0);
 #endif
 
     return 0;
 }

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

#if TEST_STD_VER >= 11 && !defined(TEST_COMPILER_GCC)
         //          this constructor only participates in overload resolution when
         //          `delete p` is well formed.
         static_assert(!std::is_constructible<std::shared_ptr<private_delete_op>,
                                                              private_delete_op*>::value, "");
         static_assert(!std::is_constructible<std::shared_ptr<private_delete_arr_op[4]>,
                                                              private_delete_arr_op*>::value, "");
     }
 #endif
+
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<A[]> p1(new A[8]);
+        assert(p1.use_count() == 1);
+        assert(A::count == 8);
+        {
+            std::shared_ptr<const A[]> p2(p1);
+            assert(A::count == 8);
+            assert(p2.use_count() == 2);
+            assert(p1.use_count() == 2);
+            assert(p1.get() == p2.get());
+        }
+        assert(p1.use_count() == 1);
+        assert(A::count == 8);
+    }
+    assert(A::count == 0);
+#endif
 }

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

 // <memory>
 
 // shared_ptr
 
 // template<class Y> shared_ptr(shared_ptr<Y>&& r);
 
 #include <memory>
 #include <type_traits>
+#include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct B
 {
     static int count;
 
#endif
     assert(B::count == 0);
     assert(A::count == 0);
     {
         std::shared_ptr<A> pA;
         assert(pA.use_count() == 0);
         assert(B::count == 0);
         assert(A::count == 0);
         {
-            std::shared_ptr<B> pB(pA);
+            std::shared_ptr<B> pB(std::move(pA));
             assert(B::count == 0);
             assert(A::count == 0);
             assert(pB.use_count() == 0);
             assert(pA.use_count() == 0);
             assert(pA.get() == pB.get());
         }
         assert(pA.use_count() == 0);
         assert(B::count == 0);
         assert(A::count == 0);
     }
     assert(B::count == 0);
     assert(A::count == 0);
 
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<A[]> p1;
+        assert(p1.use_count() == 0);
+        assert(A::count == 0);
+        {
+            std::shared_ptr<const A[]> p2(p1);
+            assert(A::count == 0);
+            assert(p2.use_count() == 0);
+            assert(p1.use_count() == 0);
+            assert(p1.get() == p2.get());
+        }
+        assert(p1.use_count() == 0);
+        assert(A::count == 0);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer.pass.cpp

assert(A::count == 0);
         p.reset(ptr);
         assert(A::count == 1);
         assert(B::count == 1);
         assert(p.use_count() == 1);
         assert(p.get() == ptr);
     }
     assert(A::count == 0);
 
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<const A[]> p;
+        A* ptr = new A[8];
+        p.reset(ptr);
+        assert(A::count == 8);
+        assert(p.use_count() == 1);
+        assert(p.get() == ptr);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter.pass.cpp

#ifndef TEST_HAS_NO_RTTI
         assert(d);
         assert(d->state() == 3);
 #endif
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 2);
 
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<const A[]> p;
+        A* ptr = new A[8];
+        p.reset(ptr, CDeleter<A[]>());
+        assert(A::count == 8);
+        assert(p.use_count() == 1);
+        assert(p.get() == ptr);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.mod/reset_pointer_deleter_allocator.pass.cpp

#endif
         assert(test_allocator<A>::alloc_count == 1);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 2);
     assert(test_allocator<A>::count == 0);
     assert(test_allocator<A>::alloc_count == 0);
 
+#if TEST_STD_VER > 14
+    {
+        std::shared_ptr<const A[]> p;
+        A* ptr = new A[8];
+        p.reset(ptr, CDeleter<A[]>(), test_allocator<A[]>());
+        assert(A::count == 8);
+        assert(p.use_count() == 1);
+        assert(p.get() == ptr);
+    }
+    assert(A::count == 0);
+#endif
+
   return 0;
 }