1 files changed, 123 insertions, 0 deletions
diff --git a/test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/pointer_deleter.pass.cpp b/test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/pointer_deleter.pass.cpp
new file mode 100644
index 000000000000..7ddd16265107
--- /dev/null
+++ b/test/std/utilities/memory/unique.ptr/unique.ptr.single/unique.ptr.single.ctor/pointer_deleter.pass.cpp
@@ -0,0 +1,123 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// unique_ptr
+
+//=============================================================================
+// TESTING unique_ptr(pointer, deleter)
+//
+// Concerns:
+//   1 unique_ptr(pointer, deleter&&) only requires a MoveConstructible deleter.
+//   2 unique_ptr(pointer, deleter&) requires a CopyConstructible deleter.
+//   3 unique_ptr<T, D&>(pointer, deleter) does not require a CopyConstructible deleter.
+//   4 unique_ptr<T, D const&>(pointer, deleter) does not require a CopyConstructible deleter.
+//   5 unique_ptr(pointer, deleter) should work for derived pointers.
+//   6 unique_ptr(pointer, deleter) should work with function pointers.
+//   7 unique_ptr<void> should work.
+
+
+#include <memory>
+#include <cassert>
+
+#include "../../deleter.h"
+
+struct A
+{
+    static int count;
+    A() {++count;}
+    A(const A&) {++count;}
+    virtual ~A() {--count;}
+};
+
+int A::count = 0;
+
+
+struct B
+    : public A
+{
+    static int count;
+    B() {++count;}
+    B(const B&) {++count;}
+    virtual ~B() {--count;}
+};
+
+int B::count = 0;
+
+bool my_free_called = false;
+
+void my_free(void*) {
+    my_free_called = true;
+}
+
+int main()
+{
+    { // MoveConstructible deleter (C-1)
+        A* p = new A;
+        assert(A::count == 1);
+        std::unique_ptr<A, Deleter<A> > s(p, Deleter<A>(5));
+        assert(s.get() == p);
+        assert(s.get_deleter().state() == 5);
+    }
+    assert(A::count == 0);
+    { // CopyConstructible deleter (C-2)
+        A* p = new A;
+        assert(A::count == 1);
+        CopyDeleter<A> d(5);
+        std::unique_ptr<A, CopyDeleter<A> > s(p, d);
+        assert(s.get() == p);
+        assert(s.get_deleter().state() == 5);
+        d.set_state(6);
+        assert(s.get_deleter().state() == 5);
+    }
+    assert(A::count == 0);
+    { // Reference deleter (C-3)
+        A* p = new A;
+        assert(A::count == 1);
+        NCDeleter<A> d(5);
+        std::unique_ptr<A, NCDeleter<A>&> s(p, d);
+        assert(s.get() == p);
+        assert(&s.get_deleter() == &d);
+        assert(s.get_deleter().state() == 5);
+        d.set_state(6);
+        assert(s.get_deleter().state() == 6);
+    }
+    assert(A::count == 0);
+    { // Const Reference deleter (C-4)
+        A* p = new A;
+        assert(A::count == 1);
+        NCConstDeleter<A> d(5);
+        std::unique_ptr<A, NCConstDeleter<A> const&> s(p, d);
+        assert(s.get() == p);
+        assert(s.get_deleter().state() == 5);
+        assert(&s.get_deleter() == &d);
+    }
+    assert(A::count == 0);
+    { // Derived pointers (C-5)
+        B* p = new B;
+        assert(A::count == 1);
+        assert(B::count == 1);
+        std::unique_ptr<A, Deleter<A> > s(p, Deleter<A>(5));
+        assert(s.get() == p);
+        assert(s.get_deleter().state() == 5);
+    }
+    assert(A::count == 0);
+    assert(B::count == 0);
+    { // Void and function pointers (C-6,7)
+        {
+        int i = 0;
+        std::unique_ptr<void, void(*)(void*)> s(&i, my_free);
+        assert(s.get() == &i);
+        assert(s.get_deleter() == my_free);
+        assert(!my_free_called);
+        }
+        assert(my_free_called);
+    }
+}