From f27b780724e2af140dae213968ab1c5c9f8f310b Mon Sep 17 00:00:00 2001
From: Glen Fernandes <glenfe@live.com>
Date: Tue, 4 Feb 2014 13:16:06 -0800
Subject: [PATCH] Add unit test for allocate_shared construct case

---
 test/Jamfile.v2                               |   1 +
 test/allocate_shared_array_construct_test.cpp | 160 ++++++++++++++++++
 2 files changed, 161 insertions(+)
 create mode 100644 test/allocate_shared_array_construct_test.cpp

diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index 09263d3..8a74194 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -148,6 +148,7 @@ import testing ;
           [ run allocate_shared_array_esft_test.cpp ]
           [ run allocate_shared_array_noinit_test.cpp ]
           [ run allocate_shared_array_value_test.cpp ]
+          [ run allocate_shared_array_construct_test.cpp ]
 
           [ run make_unique_test.cpp ]
           [ run make_unique_args_test.cpp ]
diff --git a/test/allocate_shared_array_construct_test.cpp b/test/allocate_shared_array_construct_test.cpp
new file mode 100644
index 0000000..623aa65
--- /dev/null
+++ b/test/allocate_shared_array_construct_test.cpp
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
+ * glenfe at live dot com
+ *
+ * Distributed under the Boost Software License, 
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt 
+ * or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+#include <boost/detail/lightweight_test.hpp>
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#include <boost/smart_ptr/allocate_shared_array.hpp>
+
+template<typename T>
+class creator {
+public:
+    typedef T value_type;
+
+    creator() {
+    }
+
+    template<typename U>
+    creator(const creator<U>&) {
+    }
+
+    T* allocate(std::size_t size) {
+        void* p1 = ::operator new(size * sizeof(T));
+        return static_cast<T*>(p1);
+    }
+
+    void deallocate(T* memory, std::size_t) {
+        void* p1 = memory;
+        ::operator delete(p1);
+    }
+
+    template<typename U, typename... Args>
+    void construct(U* memory, Args&&... args) {
+        void* p1 = memory;
+        ::new(p1) U(std::forward<Args>(args)...);
+    }
+
+    template<typename U>
+    void destroy(U* memory) {
+        memory->~U();
+    }
+};
+
+class type {
+    friend class creator<type>;
+
+public:
+    static unsigned int instances;
+    static type object;
+
+protected:
+    explicit type() {
+        instances++;
+    }
+
+    type(const type&) {
+        instances++;
+    }
+
+    ~type() {
+        instances--;
+    }
+};
+
+unsigned int type::instances;
+type type::object;
+
+int main() {
+    BOOST_TEST(type::instances == 1);
+    {
+        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(creator<void>(), 3);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 1);
+    }
+
+    BOOST_TEST(type::instances == 1);
+    {
+        boost::shared_ptr<type[3]> a1 = boost::allocate_shared<type[3]>(creator<void>());
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 1);
+    }
+
+    BOOST_TEST(type::instances == 1);
+    {
+        boost::shared_ptr<type[][2]> a1 = boost::allocate_shared<type[][2]>(creator<void>(), 2);
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(type::instances == 5);
+        a1.reset();
+        BOOST_TEST(type::instances == 1);
+    }
+
+    BOOST_TEST(type::instances == 1);
+    {
+        boost::shared_ptr<type[2][2]> a1 = boost::allocate_shared<type[2][2]>(creator<void>());
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(type::instances == 5);
+        a1.reset();
+        BOOST_TEST(type::instances == 1);
+    }
+
+    BOOST_TEST(type::instances == 1);
+    {
+        boost::shared_ptr<const type[]> a1 = boost::allocate_shared<const type[]>(creator<void>(), 3);
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 1);
+    }
+
+    BOOST_TEST(type::instances == 1);
+    {
+        boost::shared_ptr<const type[3]> a1 = boost::allocate_shared<const type[3]>(creator<void>());
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 1);
+    }
+
+    BOOST_TEST(type::instances == 1);
+    {
+        boost::shared_ptr<const type[][2]> a1 = boost::allocate_shared<const type[][2]>(creator<void>(), 2);
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(type::instances == 5);
+        a1.reset();
+        BOOST_TEST(type::instances == 1);
+    }
+
+    BOOST_TEST(type::instances == 1);
+    {
+        boost::shared_ptr<const type[2][2]> a1 = boost::allocate_shared<const type[2][2]>(creator<void>());
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(type::instances == 5);
+        a1.reset();
+        BOOST_TEST(type::instances == 1);
+    }
+
+    return boost::report_errors();
+}
+#else
+
+int main() {
+    return 0;
+}
+
+#endif