Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/types.pass.cpp
@@ -20,14 +20,41 @@

 #include "test_macros.h"

+template<typename T, typename = std::void_t<>>
+struct has_less
+    : std::false_type
+{};
+
+template<typename T>
+struct has_less<T, std::void_t<decltype(std::declval<T>() < std::declval<T>())>>
+    : std::true_type
+{};
+
 struct A;  // purposefully incomplete
+struct B { int x = 42; };

-int main(int, char**)
+template<class T>
+void test()
 {
-    static_assert((std::is_same<std::shared_ptr<A>::element_type, A>::value), "");
+    static_assert(std::is_same<typename std::shared_ptr<T>::element_type, T>::value);
 #if TEST_STD_VER > 14
-    static_assert((std::is_same<std::shared_ptr<A>::weak_type, std::weak_ptr<A>>::value), "");
+    static_assert(std::is_same<typename std::shared_ptr<T>::weak_type, std::weak_ptr<T>>::value);
+    static_assert(std::is_copy_constructible<std::shared_ptr<T>>::value);
+    static_assert(std::is_copy_assignable<std::shared_ptr<T>>::value);
+    static_assert(has_less<std::shared_ptr<T>>::value);
+#if _LIBCPP_NEW_SHARED_PTR
+    static_assert(std::is_same<std::shared_ptr<T[]> ::element_type, T>::value);
+    static_assert(std::is_same<std::shared_ptr<T[8]>::element_type, T>::value);
+#endif
 #endif
+}
+
+int main(int, char**)
+{
+    test<A>();
+    test<B>();
+    test<int>();
+    test<char*>();

-  return 0;
+    return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/default.pass.cpp
@@ -13,11 +13,30 @@
 #include <memory>
 #include <cassert>

+struct A { };
+
+template<class T>
+void test()
+{
+    {
+        std::shared_ptr<T> p;
+        assert(p.use_count() == 0);
+        assert(p.get() == 0);
+    }
+    {
+        std::shared_ptr<T> p {};
+        assert(p.use_count() == 0);
+        assert(p.get() == 0);
+    }
+}
+
 int main(int, char**)
 {
-    std::shared_ptr<int> p;
-    assert(p.use_count() == 0);
-    assert(p.get() == 0);
+    test<int>();
+    test<A>();
+    test<int*>();
+    test<int[]>();
+    test<int[8]>();

-  return 0;
+    return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer.pass.cpp
@@ -27,21 +27,36 @@
 int main(int, char**)
 {
     {
-    A* ptr = new A;
-    std::shared_ptr<A> p(ptr);
-    assert(A::count == 1);
-    assert(p.use_count() == 1);
-    assert(p.get() == ptr);
+        A* ptr = new A;
+        std::shared_ptr<A> p(ptr);
+        assert(A::count == 1);
+        assert(p.use_count() == 1);
+        assert(p.get() == ptr);
     }
     assert(A::count == 0);
+
+    {
+        A* ptr = new A;
+        std::shared_ptr<void> p(ptr);
+        assert(A::count == 1);
+        assert(p.use_count() == 1);
+        assert(p.get() == ptr);
+    }
+    assert(A::count == 0);
+
+// TODO: add fail tests for when `delete[]` or `delete` does not work.
+#if _LIBCPP_NEW_SHARED_PTR
     {
-    A* ptr = new A;
-    std::shared_ptr<void> p(ptr);
-    assert(A::count == 1);
-    assert(p.use_count() == 1);
-    assert(p.get() == ptr);
+        A* ptr[8];
+        for (unsigned i = 0; i < 8; ++i) ptr[i] = new A;
+
+        std::shared_ptr<A[8]> p(ptr);
+        assert(A::count == 8);
+        assert(p.use_count() == 1);
+        assert(p.get() == ptr);
     }
     assert(A::count == 0);
+#endif

-  return 0;
+    return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.fail.cpp
===================================================================
--- /dev/null
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.fail.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// shared_ptr
+
+// template<class Y, class D> shared_ptr(Y* p, D d);
+
+#include <memory>
+
+struct NotDeleter
+{
+    NotDeleter() = default;
+    NotDeleter(NotDeleter const&) = default;
+    NotDeleter(NotDeleter&&) = default;
+};
+
+template<class T>
+struct NoMoveDeleter
+{
+    NoMoveDeleter() = default;
+    NoMoveDeleter(NoMoveDeleter const&) = default;
+    NoMoveDeleter(NoMoveDeleter&&) = delete;
+
+    void operator()(T*) { }
+};
+
+int main(int, char**)
+{
+    {
+        int* ptr = new int;
+        // expected-error@memory:* {{type 'NotDeleter' does not provide a call operator}}
+        std::shared_ptr<int> bp0(ptr, NotDeleter()); // expected-error@memory:* {{type 'NotDeleter' does not provide a call operator}}
+        std::shared_ptr<int> bp1(ptr, NoMoveDeleter<int>()); // expected-error@memory:* {{call to deleted constructor of 'NoMoveDeleter<int>'}}
+    }
+
+    return 0;
+}
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp
@@ -30,20 +30,21 @@
 int main(int, char**)
 {
     {
-    A* ptr = new A;
-    std::shared_ptr<A> p(ptr, test_deleter<A>(3));
-    assert(A::count == 1);
-    assert(p.use_count() == 1);
-    assert(p.get() == ptr);
-    test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
-    assert(test_deleter<A>::count == 1);
-    assert(test_deleter<A>::dealloc_count == 0);
-    assert(d);
-    assert(d->state() == 3);
+        A* ptr = new A;
+        std::shared_ptr<A> p(ptr, test_deleter<A>(3));
+        assert(A::count == 1);
+        assert(p.use_count() == 1);
+        assert(p.get() == ptr);
+
+        test_deleter<A>* d = std::get_deleter<test_deleter<A>>(p);
+        assert(test_deleter<A>::count == 1);
+        assert(test_deleter<A>::dealloc_count == 0);
+        assert(d);
+        assert(d->state() == 3);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);

   return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp
@@ -27,22 +27,23 @@

 int A::count = 0;

-
 int main(int, char**)
 {
+    // TODO: add tests for whatever the result of 41930 happens to be.
+
     {
-    A* ptr = new A;
-    std::shared_ptr<A> p(ptr, test_deleter<A>(3), test_allocator<A>(5));
-    assert(A::count == 1);
-    assert(p.use_count() == 1);
-    assert(p.get() == ptr);
-    test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
-    assert(test_deleter<A>::count == 1);
-    assert(test_deleter<A>::dealloc_count == 0);
-    assert(d);
-    assert(d->state() == 3);
-    assert(test_allocator<A>::count == 1);
-    assert(test_allocator<A>::alloc_count == 1);
+        A* ptr = new A;
+        std::shared_ptr<A> p(ptr, test_deleter<A>(3), test_allocator<A>(5));
+        assert(A::count == 1);
+        assert(p.use_count() == 1);
+        assert(p.get() == ptr);
+        test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
+        assert(test_deleter<A>::count == 1);
+        assert(test_deleter<A>::dealloc_count == 0);
+        assert(d);
+        assert(d->state() == 3);
+        assert(test_allocator<A>::count == 1);
+        assert(test_allocator<A>::alloc_count == 1);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
@@ -50,41 +51,41 @@
     assert(test_allocator<A>::count == 0);
     assert(test_allocator<A>::alloc_count == 0);
     test_deleter<A>::dealloc_count = 0;
+
     // Test an allocator with a minimal interface
     {
-    A* ptr = new A;
-    std::shared_ptr<A> p(ptr, test_deleter<A>(3), bare_allocator<void>());
-    assert(A::count == 1);
-    assert(p.use_count() == 1);
-    assert(p.get() == ptr);
-    test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
-    assert(test_deleter<A>::count == 1);
-    assert(test_deleter<A>::dealloc_count == 0);
-    assert(d);
-    assert(d->state() == 3);
+        A* ptr = new A;
+        std::shared_ptr<A> p(ptr, test_deleter<A>(3), bare_allocator<void>());
+        assert(A::count == 1);
+        assert(p.use_count() == 1);
+        assert(p.get() == ptr);
+        test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
+        assert(test_deleter<A>::count == 1);
+        assert(test_deleter<A>::dealloc_count == 0);
+        assert(d);
+        assert(d->state() == 3);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
     test_deleter<A>::dealloc_count = 0;
-#if TEST_STD_VER >= 11
+
     // Test an allocator that returns class-type pointers
     {
-    A* ptr = new A;
-    std::shared_ptr<A> p(ptr, test_deleter<A>(3), min_allocator<void>());
-    assert(A::count == 1);
-    assert(p.use_count() == 1);
-    assert(p.get() == ptr);
-    test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
-    assert(test_deleter<A>::count == 1);
-    assert(test_deleter<A>::dealloc_count == 0);
-    assert(d);
-    assert(d->state() == 3);
+        A* ptr = new A;
+        std::shared_ptr<A> p(ptr, test_deleter<A>(3), min_allocator<void>());
+        assert(A::count == 1);
+        assert(p.use_count() == 1);
+        assert(p.get() == ptr);
+        test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
+        assert(test_deleter<A>::count == 1);
+        assert(test_deleter<A>::dealloc_count == 0);
+        assert(d);
+        assert(d->state() == 3);
     }
     assert(A::count == 0);
     assert(test_deleter<A>::count == 0);
     assert(test_deleter<A>::dealloc_count == 1);
-#endif

-  return 0;
+    return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_Y_rv.pass.cpp
@@ -59,6 +59,7 @@
     static_assert(( std::is_convertible<std::shared_ptr<A>, std::shared_ptr<B> >::value), "");
     static_assert((!std::is_convertible<std::shared_ptr<B>, std::shared_ptr<A> >::value), "");
     static_assert((!std::is_convertible<std::shared_ptr<A>, std::shared_ptr<C> >::value), "");
+
     {
         std::shared_ptr<A> pA(new A);
         assert(pA.use_count() == 1);
@@ -69,27 +70,17 @@
             std::shared_ptr<B> pB(std::move(pA));
             assert(B::count == 1);
             assert(A::count == 1);
-#if TEST_STD_VER >= 11
             assert(pB.use_count() == 1);
             assert(pA.use_count() == 0);
-#else
-            assert(pB.use_count() == 2);
-            assert(pA.use_count() == 2);
-#endif
             assert(p == pB.get());
         }
-#if TEST_STD_VER >= 11
         assert(pA.use_count() == 0);
         assert(B::count == 0);
         assert(A::count == 0);
-#else
-        assert(pA.use_count() == 1);
-        assert(B::count == 1);
-        assert(A::count == 1);
-#endif
     }
     assert(B::count == 0);
     assert(A::count == 0);
+
     {
         std::shared_ptr<A> pA;
         assert(pA.use_count() == 0);
@@ -102,6 +93,7 @@
             assert(pB.use_count() == 0);
             assert(pA.use_count() == 0);
             assert(pA.get() == pB.get());
+            assert(pA.get() == nullptr);
         }
         assert(pA.use_count() == 0);
         assert(B::count == 0);
@@ -110,5 +102,5 @@
     assert(B::count == 0);
     assert(A::count == 0);

-  return 0;
+    return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_copy_move.fail.cpp
===================================================================
--- /dev/null
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_copy_move.fail.cpp
@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// shared_ptr
+
+// template<class Y> shared_ptr(const shared_ptr<Y>& r);
+
+#include <memory>
+#include <type_traits>
+
+struct A { int x = 42; };
+
+struct ADel : std::default_delete<A>
+{
+    typedef A* pointer;
+};
+
+int main(int, char**)
+{
+    static_assert(!std::is_convertible<A, int>::value);
+
+    {
+        std::shared_ptr<A> pA;
+        std::shared_ptr<int> pi(pA); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
+    }
+    {
+        std::shared_ptr<A> pA;
+        std::shared_ptr<int> pi(std::move(pA)); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
+    }
+    {
+        std::weak_ptr<A> pA;
+        std::shared_ptr<int> pi(std::move(pA)); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
+    }
+
+#if TEST_STD_VER > 14
+    {
+        std::unique_ptr<int, ADel> ui;
+        std::shared_ptr<int> pi(std::move(ui)); // expected-error {{no matching constructor for initialization of 'std::shared_ptr<int>'}}
+    }
+#endif
+
+    return 0;
+}
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/shared_ptr_pointer.pass.cpp
@@ -42,6 +42,7 @@
     {
         std::shared_ptr<A> pA(new A);
         assert(pA.use_count() == 1);
+
         {
             B b;
             std::shared_ptr<B> pB(pA, &b);
@@ -58,5 +59,38 @@
     assert(A::count == 0);
     assert(B::count == 0);

-  return 0;
+    {
+        std::shared_ptr<int> p1(nullptr);
+        std::shared_ptr<int> p2(p1, new int);
+        assert(p2.get() != nullptr);
+    }
+    {
+        std::shared_ptr<int> p1(new int);
+        std::shared_ptr<int> p2(p1, nullptr);
+        assert(p2.get() == nullptr);
+    }
+
+#if TEST_STD_VER > 14
+    {
+        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);
+            assert(B::count == 1);
+            assert(pA.use_count() == 2);
+            assert(pB.use_count() == 2);
+            assert(pB.get() == &b);
+        }
+        assert(pA.use_count() == 1);
+        assert(A::count == 1);
+        assert(B::count == 0);
+    }
+    assert(A::count == 0);
+    assert(B::count == 0);
+#endif
+
+    return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/unique_ptr.pass.cpp
@@ -6,49 +6,64 @@
 //
 //===----------------------------------------------------------------------===//

-// UNSUPPORTED: sanitizer-new-delete
+// UNSUPPORTED: sanitizer-new-delete, c++98, c++03
+

 // <memory>

 // template <class Y, class D> explicit shared_ptr(unique_ptr<Y, D>&&r);

 #include <memory>
 #include <new>
 #include <cstdlib>
 #include <cassert>

 #include "test_macros.h"
 #include "count_new.hpp"

 struct B
 {
     static int count;

     B() {++count;}
     B(const B&) {++count;}
     virtual ~B() {--count;}
 };

 int B::count = 0;

 struct A
     : public B
 {
     static int count;

     A() {++count;}
     A(const A&) {++count;}
     ~A() {--count;}
 };

 int A::count = 0;

 void fn ( const std::shared_ptr<int> &) {}
 void fn ( const std::shared_ptr<B> &) { assert (false); }

 template <typename T>
 void assert_deleter ( T * ) { assert(false); }

+template<class T>
+struct StatefulDeleter
+{
+    int state = 0;
+
+    StatefulDeleter(int val = 0) : state(val) {}
+    StatefulDeleter(StatefulDeleter const&) { assert(false); }
+
+    void operator()(T* ptr) {
+        assert(state == 42);
+        delete ptr;
+    }
+};
+
 int main(int, char**)
 {
     {
@@ -74,20 +89,31 @@
         }
         catch (...)
         {
-#if TEST_STD_VER >= 11
             assert(A::count == 1);
             assert(B::count == 1);
             assert(ptr.get() == raw_ptr);
-#else
-            (void) raw_ptr; // silence 'unused variable' warning
-            assert(A::count == 0);
-            assert(B::count == 0);
-            assert(ptr.get() == 0);
-#endif
         }
     }
 #endif
+
+#if TEST_STD_VER > 14
+    {
+        std::unique_ptr<int> ptr;
+        std::shared_ptr<int> p(std::move(ptr));
+        assert(p.use_count() == 0);
+        assert(p.get() == nullptr);
+    }
+#endif
+
+    {
+        StatefulDeleter<A> d;
+        std::unique_ptr<A, StatefulDeleter<A>&> u(new A, d);
+        std::shared_ptr<A> p(std::move(u));
+        d.state = 42;
+        assert(A::count == 1);
+    }
     assert(A::count == 0);
+
     { // LWG 2399
         fn(std::unique_ptr<int>(new int));
     }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.obs/op_bool.pass.cpp
@@ -15,16 +15,32 @@
 #include <memory>
 #include <cassert>

+struct A
+{
+    int a;
+    virtual ~A() {};
+};
+struct B : A { };
+
 int main(int, char**)
 {
     {
-    const std::shared_ptr<int> p(new int(32));
-    assert(p);
+        const std::shared_ptr<int> p(new int(32));
+        assert(p);
+    }
+    {
+        const std::shared_ptr<int> p;
+        assert(!p);
     }
     {
-    const std::shared_ptr<int> p;
-    assert(!p);
+        bool check = false;
+        std::shared_ptr<A> basePtr = std::make_shared<B>();
+
+        if (std::shared_ptr<B> sp = std::dynamic_pointer_cast<B>(basePtr))
+        { check = true; }
+
+        assert(check);
     }

-  return 0;
+    return 0;
 }