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,22 @@
 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);
+        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);
 
-  return 0;
+    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,16 +30,17 @@
 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);
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,7 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: sanitizer-new-delete
+// UNSUPPORTED: sanitizer-new-delete, c++98, c++03
+
 
 // <memory>
 
@@ -49,6 +50,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**)
 {
     {
@@ -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.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.pass.cpp
===================================================================
--- test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
+++ test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.create/make_shared.pass.cpp
@@ -80,7 +80,7 @@
     int i = 67;
     char c = 'e';
     std::shared_ptr<A> p = std::make_shared<A>(i, c);
-    assert(globalMemCounter.checkOutstandingNewEq(nc+1));
+    assert(globalMemCounter.checkOutstandingNewEq(nc+1)); // one for make_shared (create type ptr) and one for creation of control block.
     assert(A::count == 1);
     assert(p->get_int() == 67);
     assert(p->get_char() == 'e');
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,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;
 }
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;
 }