Index: include/CMakeLists.txt
===================================================================
--- include/CMakeLists.txt
+++ include/CMakeLists.txt
@@ -73,6 +73,7 @@
   experimental/iterator
   experimental/list
   experimental/map
+  experimental/memory
   experimental/memory_resource
   experimental/propagate_const
   experimental/regex
Index: include/experimental/memory
===================================================================
--- /dev/null
+++ include/experimental/memory
@@ -0,0 +1,212 @@
+// -*- C++ -*-
+//===-------------------------- algorithm ---------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_MEMORY
+#define _LIBCPP_EXPERIMENTAL_MEMORY
+
+/*
+namespace std {
+template <class W> class observer_ptr {
+public:
+    // publish our template parameter and variations thereof
+    using element_type = W;
+    using pointer = add_pointer_t<W>; // exposition-only
+    using reference = add_lvalue_reference_t<W>; // exposition-only
+
+    // default c’tor
+    constexpr observer_ptr() noexcept;
+
+    // pointer-accepting c’tors
+    constexpr observer_ptr(nullptr_t) noexcept;
+    constexpr explicit observer_ptr(pointer) noexcept;
+
+    // copying c’tors (in addition to compiler-generated copy c’tor)
+    template <class W2> constexpr observer_ptr(observer_ptr<W2>) noexcept;
+
+    // observers
+    constexpr pointer get() const noexcept;
+    constexpr reference operator*() const;
+    constexpr pointer operator->() const noexcept;
+    constexpr explicit operator bool() const noexcept;
+
+    // conversions
+    constexpr explicit operator pointer() const noexcept;
+
+    // modifiers
+    constexpr pointer release() noexcept;
+    constexpr void reset(pointer = nullptr) noexcept;
+    constexpr void swap(observer_ptr&) noexcept;
+};
+}
+*/
+
+#include <experimental/__config>
+#include <type_traits>
+#include <functional>
+
+#include <__debug>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS
+
+#if _LIBCPP_STD_VER > 14
+
+template<class _Wp>
+class observer_ptr
+{
+    typedef add_pointer_t<_Wp>          pointer;
+    typedef add_lvalue_reference_t<_Wp> reference;
+
+    pointer __ptr;
+
+public:
+    typedef _Wp                         element_type;
+
+    // constructors
+    constexpr observer_ptr() noexcept : __ptr(nullptr) { }
+    constexpr observer_ptr(nullptr_t) noexcept : __ptr(nullptr) { }
+    constexpr explicit observer_ptr(pointer __p) noexcept : __ptr(__p) { }
+
+    template<class _W2,
+             class = _EnableIf<is_convertible<_W2*, _Wp*>::value>>
+    constexpr observer_ptr(observer_ptr<_W2> __other) noexcept
+        : __ptr(__other.get()) { }
+
+    observer_ptr(observer_ptr const&) = default;
+    observer_ptr(observer_ptr&&) = default;
+
+    // observers
+    constexpr pointer get() const noexcept { return __ptr; }
+    constexpr reference operator*() const { return *__ptr; }
+    constexpr pointer operator->() const noexcept { return __ptr; }
+    constexpr explicit operator bool() const noexcept { return __ptr != nullptr; }
+
+    // conversions
+    constexpr operator pointer() const noexcept { return __ptr; }
+
+    // modifiers
+    constexpr void swap(observer_ptr& __other) noexcept { _VSTD::swap(__ptr, __other.__ptr); }
+    constexpr void reset(pointer __p = nullptr) { __ptr = __p; }
+    constexpr pointer release() noexcept
+    {
+        observer_ptr __p;
+        __p.swap(*this);
+        return __p.get();
+    }
+};
+
+// specializations
+
+template<class _Wp>
+void swap(observer_ptr<_Wp>& __a, observer_ptr<_Wp>& __b) noexcept
+{
+    __a.swap(__b);
+}
+
+template<class _Wp>
+observer_ptr<_Wp> make_observer(_Wp* __ptr) noexcept
+{
+    return observer_ptr<_Wp>{__ptr};
+}
+
+template<class _W1, class _W2>
+bool operator==(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return __a.get() == __b.get();
+}
+
+template<class _W1, class _W2>
+bool operator!=(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return !(__a == __b);
+}
+
+template<class _Wp>
+bool operator==(observer_ptr<_Wp> __p, nullptr_t)
+{
+    return !__p;
+}
+
+template<class _Wp>
+bool operator==(nullptr_t, observer_ptr<_Wp> __p)
+{
+    return !__p;
+}
+
+template<class _Wp>
+bool operator!=(observer_ptr<_Wp> __p, nullptr_t)
+{
+    return (bool)__p;
+}
+
+template<class _Wp>
+bool operator!=(nullptr_t, observer_ptr<_Wp> __p)
+{
+    return (bool)__p;
+}
+
+template<class _W1, class _W2>
+bool operator<(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return _VSTD::less<typename _VSTD::common_type<_W1*, _W2*>::type>()(__a.get(), __b.get());
+}
+
+template<class _W1, class _W2>
+bool operator>(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return __b < __a;
+}
+
+template<class _W1, class _W2>
+bool operator<=(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return !(__a > __b);
+}
+
+template<class _W1, class _W2>
+bool operator>=(observer_ptr<_W1> __a, observer_ptr<_W2> __b)
+{
+    return !(__a < __b);
+}
+
+#endif // _LIBCPP_STD_VER > 14
+
+_LIBCPP_END_NAMESPACE_LFTS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// hash
+
+#if _LIBCPP_STD_VER > 14
+template<class _Tp>
+struct hash<experimental::observer_ptr<_Tp>>
+{
+    typedef experimental::observer_ptr<_Tp>    argument_type;
+    typedef size_t                             result_type;
+
+    _LIBCPP_INLINE_VISIBILITY
+    result_type operator()(const argument_type& __ptr) const noexcept
+    {
+        return hash<_Tp*>()(__ptr.get());
+    }
+};
+#endif // _LIBCPP_STD_VER > 14
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif /* _LIBCPP_EXPERIMENTAL_MEMORY */
Index: include/module.modulemap
===================================================================
--- include/module.modulemap
+++ include/module.modulemap
@@ -551,6 +551,10 @@
       header "experimental/map"
       export *
     }
+    module memory_resource {
+      header "experimental/memory"
+      export *
+    }
     module memory_resource {
       header "experimental/memory_resource"
       export *
Index: test/libcxx/double_include.sh.cpp
===================================================================
--- test/libcxx/double_include.sh.cpp
+++ test/libcxx/double_include.sh.cpp
@@ -151,6 +151,7 @@
 #include <experimental/iterator>
 #include <experimental/list>
 #include <experimental/map>
+#include <experimental/memory>
 #include <experimental/memory_resource>
 #include <experimental/propagate_const>
 #include <experimental/regex>
Index: test/libcxx/experimental/memory/memory.observer.ptr/version.pass.cpp
===================================================================
--- /dev/null
+++ test/libcxx/experimental/memory/memory.observer.ptr/version.pass.cpp
@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <experimental/memory>
+
+#include <experimental/memory>
+
+#include "test_macros.h"
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main(int, char**)
+{
+
+  return 0;
+}
Index: test/std/experimental/memory/memory.observer.ptr/conv.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/conv.pass.cpp
@@ -0,0 +1,42 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+void test_convertibility()
+{
+    typedef std::experimental::observer_ptr<T> OP;
+    static_assert(std::is_convertible<OP, T*>::value, "");
+}
+
+struct Foo;
+
+struct Bar {};
+
+int main(int, char**)
+{
+    test_convertibility<void>();
+    test_convertibility<bool>();
+    test_convertibility<int>();
+    test_convertibility<Foo>();
+    test_convertibility<Bar>();
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/ctor.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/ctor.pass.cpp
@@ -0,0 +1,129 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+template<class T>
+void custom_delete(T* ptr) { delete ptr; }
+void custom_delete(void* ptr) { delete (int*)ptr; }
+
+template<class T, class U>
+void assert_constructability()
+{
+    typedef std::experimental::observer_ptr<T> OP;
+    static_assert(std::is_nothrow_constructible<OP>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, std::nullptr_t>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, T*>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, OP const&>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, OP&&>::value, "");
+    static_assert(std::is_nothrow_constructible<OP, std::experimental::observer_ptr<U>>::value ==
+                  std::is_convertible<U*, T*>::value, "");
+}
+
+template<class T>
+void constrct_nullptr()
+{
+    {
+        std::experimental::observer_ptr<T> ptr;
+        assert(ptr.get() == nullptr);
+    }
+    {
+        std::experimental::observer_ptr<T> ptr(nullptr);
+        assert(ptr.get() == nullptr);
+    }
+}
+
+template<class T>
+void constrct_ptr(T* raw_ptr)
+{
+    std::experimental::observer_ptr<T> ptr(raw_ptr);
+    assert(ptr.get() == raw_ptr);
+    custom_delete(raw_ptr);
+}
+
+template<class T, class U>
+void constrct_other(U* raw_ptr)
+{
+    std::experimental::observer_ptr<U> uptr(raw_ptr);
+    std::experimental::observer_ptr<T> tptr(uptr);
+    assert(uptr.get() == raw_ptr);
+    assert(tptr.get() == raw_ptr);
+    custom_delete(raw_ptr);
+}
+
+template<class T>
+void test_copy_move(T* raw_ptr)
+{
+    std::experimental::observer_ptr<T> ptr_a(raw_ptr);
+    std::experimental::observer_ptr<T> ptr_b(ptr_a);
+    std::experimental::observer_ptr<T> ptr_c(std::move(ptr_a));
+    assert(ptr_b.get() == raw_ptr);
+    assert(ptr_c.get() == raw_ptr);
+    custom_delete(raw_ptr);
+}
+
+struct Foo;
+struct Bar
+{
+    Bar(int) {}
+};
+
+int main(int, char**)
+{
+    {
+        assert_constructability<void, void>();
+        assert_constructability<void, int>();
+        assert_constructability<void, Bar>();
+        assert_constructability<Foo,  void>();
+        assert_constructability<Foo,  int>();
+        assert_constructability<Foo,  Bar>();
+        assert_constructability<int,  void>();
+        assert_constructability<int,  int>();
+        assert_constructability<int,  Bar>();
+    }
+    {
+        constrct_nullptr<Foo>();
+        constrct_nullptr<Bar>();
+        constrct_nullptr<int>();
+        constrct_nullptr<void>();
+    }
+    {
+        constrct_ptr(new int);
+        constrct_ptr(new Bar(42));
+        constrct_ptr((void*)new int);
+    }
+    {
+        constrct_other<void>(new int);
+        constrct_other<void>(new Bar(42));
+
+        // overload resolution
+        typedef std::experimental::observer_ptr<int>  OP1;
+        typedef std::experimental::observer_ptr<Bar>  OP2;
+        typedef std::experimental::observer_ptr<char> OP3;
+        static_assert(!std::is_nothrow_constructible<OP1, OP2>::value, "");
+        static_assert(!std::is_nothrow_constructible<OP1, OP3>::value, "");
+    }
+    {
+        test_copy_move(new int);
+        test_copy_move((void*)new int);
+        test_copy_move(new Bar(42));
+    }
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/hash.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/hash.pass.cpp
@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <cassert>
+
+#include "poisoned_hash_helper.hpp"
+#include "test_macros.h"
+
+struct A {};
+
+int main(int, char**)
+{
+    {
+        int* ptr = new int;
+        std::experimental::observer_ptr<int> p(ptr);
+        std::hash<std::experimental::observer_ptr<int>> f;
+        std::size_t h = f(p);
+        assert(h == std::hash<int*>()(ptr));
+    }
+    {
+        test_hash_enabled_for_type<std::experimental::observer_ptr<int>>();
+        test_hash_enabled_for_type<std::experimental::observer_ptr<A>>();
+    }
+
+    return 0;
+}
Index: test/std/experimental/memory/memory.observer.ptr/mod/release.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/mod/release.pass.cpp
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+        std::experimental::observer_ptr<int> ptr;
+        assert(ptr.release() == nullptr);
+        assert(ptr.get() == nullptr);
+    }
+    {
+        int* raw_ptr = new int;
+        std::experimental::observer_ptr<int> ptr(raw_ptr);
+        assert(ptr.release() == raw_ptr);
+        assert(ptr.get() == nullptr);
+        delete raw_ptr;
+    }
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/mod/reset.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/mod/reset.pass.cpp
@@ -0,0 +1,42 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    int* raw_ptr1 = new int;
+    int* raw_ptr2 = new int;
+
+    {
+        std::experimental::observer_ptr<int> ptr;
+        ptr.reset(raw_ptr1);
+        assert(ptr.get() == raw_ptr1);
+    }
+    {
+        std::experimental::observer_ptr<int> ptr(raw_ptr1);
+        ptr.reset(raw_ptr2);
+        assert(ptr.get() == raw_ptr2);
+    }
+
+    delete raw_ptr1;
+    delete raw_ptr2;
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/mod/swap.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/mod/swap.pass.cpp
@@ -0,0 +1,60 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    int* raw_ptr1 = new int;
+    int* raw_ptr2 = new int;
+
+    {
+        std::experimental::observer_ptr<int> ptr1;
+        std::experimental::observer_ptr<int> ptr2;
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == nullptr);
+        assert(ptr2.get() == nullptr);
+    }
+    {
+        std::experimental::observer_ptr<int> ptr1(raw_ptr1);
+        std::experimental::observer_ptr<int> ptr2;
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == nullptr);
+        assert(ptr2.get() == raw_ptr1);
+    }
+    {
+        std::experimental::observer_ptr<int> ptr1;
+        std::experimental::observer_ptr<int> ptr2(raw_ptr2);
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == raw_ptr2);
+        assert(ptr2.get() == nullptr);
+    }
+    {
+        std::experimental::observer_ptr<int> ptr1(raw_ptr1);
+        std::experimental::observer_ptr<int> ptr2(raw_ptr2);
+        ptr1.swap(ptr2);
+        assert(ptr1.get() == raw_ptr2);
+        assert(ptr2.get() == raw_ptr1);
+    }
+
+    delete raw_ptr1;
+    delete raw_ptr2;
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/obs.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/obs.pass.cpp
@@ -0,0 +1,54 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct Foo {
+    const int x;
+    constexpr Foo(const int x) : x(x) {}
+};
+
+int main(int, char**)
+{
+    static constexpr int x = 42;
+    constexpr const int* raw_ptr = &x;
+    {
+        constexpr std::experimental::observer_ptr<const int> ptr(raw_ptr);
+        static_assert(ptr.get() == raw_ptr);
+    }
+    {
+        constexpr std::experimental::observer_ptr<const int> ptr1;
+        const bool check1 = ptr1;
+        static_assert(check1 == false);
+
+        constexpr std::experimental::observer_ptr<const int> ptr2(raw_ptr);
+        const bool check2 = ptr2;
+        static_assert(check2 == true);
+    }
+    {
+        static constexpr Foo f = Foo(42);
+        constexpr const Foo* foo_ptr = &f;
+        constexpr std::experimental::observer_ptr<const Foo> ptr(foo_ptr);
+        static_assert(ptr->x == 42);
+        static_assert((*ptr).x == 42);
+
+    }
+
+    return 0;
+}
\ No newline at end of file
Index: test/std/experimental/memory/memory.observer.ptr/spec.pass.cpp
===================================================================
--- /dev/null
+++ test/std/experimental/memory/memory.observer.ptr/spec.pass.cpp
@@ -0,0 +1,87 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+
+// <experimental/memory>
+
+// observer_ptr
+
+#include <experimental/memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+        std::experimental::observer_ptr<int> ptr1(new int(42));
+        std::experimental::observer_ptr<int> ptr2(new int(101));
+        std::experimental::swap(ptr1, ptr2);
+
+        assert(*ptr1 == 101);
+        assert(*ptr2 == 42);
+
+        delete ptr1.get();
+        delete ptr2.get();
+    }
+    {
+        int* raw = new int;
+        std::experimental::observer_ptr<int> ptr = std::experimental::make_observer(raw);
+        assert(ptr.get() == raw);
+        delete raw;
+    }
+
+    std::experimental::observer_ptr<int> ptr1(new int);
+    std::experimental::observer_ptr<int> ptr2(new int);
+    std::experimental::observer_ptr<int> ptr3;
+    std::experimental::observer_ptr<void> vptr((void*)new int);
+    {
+        assert(ptr1 == ptr1);
+        assert(!(ptr1 == ptr2));
+    }
+    {
+        assert(ptr1 != ptr2);
+    }
+    {
+        assert(ptr3 == nullptr);
+        assert(nullptr == ptr3);
+        assert(!(ptr1 == nullptr));
+        assert(!(nullptr == ptr1));
+    }
+    {
+        assert(!(ptr3 != nullptr));
+        assert(!(nullptr != ptr3));
+        assert(ptr1 != nullptr);
+        assert(nullptr != ptr1);
+    }
+    {
+        assert((ptr1 < ptr1) == (ptr1.get() < ptr1.get()));
+        assert((ptr1 < vptr) == (ptr1.get() < vptr.get()));
+    }
+    {
+        assert((ptr1 > ptr1) == (ptr1.get() > ptr1.get()));
+        assert((ptr1 > vptr) == (ptr1.get() > vptr.get()));
+    }
+    {
+        assert((ptr1 <= ptr1) != (ptr1.get() > ptr1.get()));
+        assert((ptr1 <= vptr) != (ptr1.get() > vptr.get()));
+    }
+    {
+        assert((ptr1 >= ptr1) != (ptr1.get() < ptr1.get()));
+        assert((ptr1 >= vptr) != (ptr1.get() < vptr.get()));
+    }
+
+    delete ptr1.get();
+    delete ptr2.get();
+    delete (int*)vptr.get();
+
+    return 0;
+}