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,45 @@
 
 #include "test_macros.h"
 
+#if TEST_STD_VER > 14
+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
+{};
+#endif
+
 struct A;  // purposefully incomplete
+struct B
+{
+    int x;
+    B() = default;
+};
 
-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);
+//     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
+}
+
+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,32 @@
 #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);
+    }
+    {
+#if TEST_STD_VER >= 11
+        std::shared_ptr<T> p {};
+        assert(p.use_count() == 0);
+        assert(p.get() == 0);
+#endif
+    }
+}
+
 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/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
@@ -93,6 +93,7 @@
     {
         std::shared_ptr<A> pA;
         assert(pA.use_count() == 0);
+        assert(pA.get() == nullptr);
         assert(B::count == 0);
         assert(A::count == 0);
         {
@@ -102,6 +103,7 @@
             assert(pB.use_count() == 0);
             assert(pA.use_count() == 0);
             assert(pA.get() == pB.get());
+            assert(pB.get() == nullptr);
         }
         assert(pA.use_count() == 0);
         assert(B::count == 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
@@ -49,6 +49,20 @@
 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**)
 {
     {
@@ -83,11 +97,29 @@
             assert(A::count == 0);
             assert(B::count == 0);
             assert(ptr.get() == 0);
-#endif
+#endif // TEST_STD_VER >= 11
         }
     }
 #endif
+
+#if TEST_STD_VER > 14
+    {
+        std::unique_ptr<int> ptr;
+        std::shared_ptr<int> p(std::move(ptr));
+        assert(p.get() == 0);
+        assert(p.use_count() == 0);
+    }
+#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.create/make_shared.private.fail.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.private.fail.cpp
@@ -26,5 +26,5 @@
 {
     std::shared_ptr<S> p = std::make_shared<S>();
 
-  return 0;
+    return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.protected.fail.cpp
@@ -24,7 +24,7 @@
 
 int main(int, char**)
 {
-    std::shared_ptr<S> p = std::make_shared<S>();  // expected-error-re@memory:* {{static_assert failed{{.*}} "Can't construct object in make_shared"}}
+    std::shared_ptr<S> p = std::make_shared<S>(); // expected-error@memory:* {{static_assert failed due to requirement 'is_constructible<S>::value' "Can't construct object in make_shared"}}
 
   return 0;
 }
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,28 @@
 #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);
+        std::shared_ptr<A> basePtr = std::make_shared<B>();
+        std::shared_ptr<B> sp = std::dynamic_pointer_cast<B>(basePtr);
+        assert(sp);
     }
 
-  return 0;
+    return 0;
 }
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.assign/shared_ptr_Y.pass.cpp
@@ -43,6 +43,7 @@
 {
     {
         const std::shared_ptr<A> pA(new A);
+        assert(pA.use_count() == 1);
         {
             std::weak_ptr<B> pB;
             pB = pA;
Index: test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp
@@ -105,5 +105,5 @@
     assert(B::count == 0);
     assert(A::count == 0);
 
-  return 0;
+    return 0;
 }