diff --git a/include/boost/smart_ptr/make_unique.hpp b/include/boost/smart_ptr/make_unique.hpp
index d054e3d..eed5033 100644
--- a/include/boost/smart_ptr/make_unique.hpp
+++ b/include/boost/smart_ptr/make_unique.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_SMART_PTR_MAKE_UNIQUE_HPP
 #define BOOST_SMART_PTR_MAKE_UNIQUE_HPP
@@ -15,6 +14,7 @@ http://boost.org/LICENSE_1_0.txt
 
 namespace boost {
 namespace detail {
+
 template<class T>
 struct up_if_object {
     typedef std::unique_ptr<T> type;
@@ -56,10 +56,12 @@ template<class T>
 struct up_element<T[]> {
     typedef T type;
 };
+
 } /* detail */
 
 template<class T>
-inline typename detail::up_if_object<T>::type make_unique()
+inline typename detail::up_if_object<T>::type
+make_unique()
 {
     return std::unique_ptr<T>(new T());
 }
@@ -67,7 +69,7 @@ inline typename detail::up_if_object<T>::type make_unique()
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<class T, class... Args>
 inline typename detail::up_if_object<T>::type
-    make_unique(Args&&... args)
+make_unique(Args&&... args)
 {
     return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
@@ -75,31 +77,34 @@ inline typename detail::up_if_object<T>::type
 
 template<class T>
 inline typename detail::up_if_object<T>::type
-    make_unique(typename detail::up_remove_reference<T>::type&& value)
+make_unique(typename detail::up_remove_reference<T>::type&& value)
 {
     return std::unique_ptr<T>(new T(std::move(value)));
 }
 
 template<class T>
-inline typename detail::up_if_object<T>::type make_unique_noinit()
+inline typename detail::up_if_object<T>::type
+make_unique_noinit()
 {
     return std::unique_ptr<T>(new T);
 }
 
 template<class T>
-inline typename detail::up_if_array<T>::type make_unique(std::size_t n)
+inline typename detail::up_if_array<T>::type
+make_unique(std::size_t size)
 {
-    return std::unique_ptr<T>(new
-        typename detail::up_element<T>::type[n]());
+    return std::unique_ptr<T>(new typename
+        detail::up_element<T>::type[size]());
 }
 
 template<class T>
 inline typename detail::up_if_array<T>::type
-    make_unique_noinit(std::size_t n)
+make_unique_noinit(std::size_t size)
 {
-    return std::unique_ptr<T>(new
-        typename detail::up_element<T>::type[n]);
+    return std::unique_ptr<T>(new typename
+        detail::up_element<T>::type[size]);
 }
+
 } /* boost */
 
 #endif
diff --git a/make_unique.html b/make_unique.html
index 5b414e8..b649245 100644
--- a/make_unique.html
+++ b/make_unique.html
@@ -21,10 +21,8 @@
     template&lt;class U&gt; // U is not array
     unique_ptr&lt;U&gt; <a href="#functions">make_unique</a>();
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     template&lt;class U, class... Args&gt; // U is not array
     unique_ptr&lt;U&gt; <a href="#functions">make_unique</a>(Args&amp;&amp;... args);
-#endif
 
     template&lt;class U&gt; // U is not array
     unique_ptr&lt;U&gt; <a href="#functions">make_unique</a>(U&amp;&amp; value);
@@ -40,9 +38,9 @@
 }</pre>
     <h2><a name="common">Common Requirements</a></h2>
     <pre>template&lt;class U&gt;
-    unique_ptr&lt;U&gt; make_unique(<em>args</em>);
-template&lt;class U&gt;
-    unique_ptr&lt;U&gt; make_unique_noinit(<em>args</em>);</pre> 
+unique_ptr&lt;U&gt; make_unique(<em>args</em>);</pre>
+    <pre>template&lt;class U&gt;
+unique_ptr&lt;U&gt; make_unique_noinit(<em>args</em>);</pre>
     <blockquote>
       <p><b>Effects:</b> Allocates memory for an object of type <code>U</code> 
         (or <code>T[size]</code> when <code>U</code> is <code>T[]</code>, 
@@ -82,8 +80,8 @@ unique_ptr&lt;U&gt; make_unique(Args&amp;&amp;... args);</pre>
         resolution when <code>U</code> is not an array type.</p>
       <p><b>Examples:</b></p>
       <blockquote>
-        <pre>unique_ptr&lt;float&gt; p1 = boost::make_unique&lt;float&gt;();
-unique_ptr&lt;point&gt; p2 = boost::make_unique&lt;point&gt;(x, y);</pre>
+        <pre>unique_ptr&lt;float&gt; p1 = boost::make_unique&lt;float&gt;();</pre>
+        <pre>unique_ptr&lt;point&gt; p2 = boost::make_unique&lt;point&gt;(x, y);</pre>
       </blockquote>
     </blockquote>
     <pre>template&lt;class U&gt;
@@ -95,8 +93,8 @@ unique_ptr&lt;U&gt; make_unique(U&amp;&amp; value);</pre>
         resolution when <code>U</code> is not an array type.</p>
       <p><b>Examples:</b></p>
       <blockquote>
-        <pre>unique_ptr&lt;string&gt; p1 = boost::make_unique&lt;string&gt;({'a', 'b'});
-unique_ptr&lt;point&gt; p2 = boost::make_unique&lt;point&gt;({-10, 25});</pre>
+        <pre>unique_ptr&lt;string&gt; p1 = boost::make_unique&lt;string&gt;({'a', 'b'});</pre>
+        <pre>unique_ptr&lt;point&gt; p2 = boost::make_unique&lt;point&gt;({-10, 25});</pre>
       </blockquote>
     </blockquote>
     <pre>template&lt;class U&gt;
@@ -108,8 +106,8 @@ unique_ptr&lt;U&gt; make_unique(size_t size);</pre>
         resolution when <code>U</code> is of the form <code>T[]</code>.</p>
       <p><b>Examples:</b></p>
       <blockquote>
-        <pre>unique_ptr&lt;double[]&gt; p1 = boost::make_unique&lt;double[]&gt;(4);
-unique_ptr&lt;int[][2]&gt; p2 = boost::make_unique&lt;int[][2]&gt;(2);</pre>
+        <pre>unique_ptr&lt;double[]&gt; p1 = boost::make_unique&lt;double[]&gt;(4);</pre>
+        <pre>unique_ptr&lt;int[][2]&gt; p2 = boost::make_unique&lt;int[][2]&gt;(2);</pre>
       </blockquote>
     </blockquote>
     <pre>template&lt;class U&gt;
@@ -121,8 +119,8 @@ unique_ptr&lt;U&gt; make_unique_noinit();</pre>
         resolution when <code>U</code> is not an array type.</p>
       <p><b>Examples:</b></p>
       <blockquote>
-        <pre>unique_ptr&lt;float&gt; p1 = boost::make_unique_noinit&lt;float&gt;();
-unique_ptr&lt;point&gt; p2 = boost::make_unique_noinit&lt;point&gt;();</pre>
+        <pre>unique_ptr&lt;float&gt; p1 = boost::make_unique_noinit&lt;float&gt;();</pre>
+        <pre>unique_ptr&lt;point&gt; p2 = boost::make_unique_noinit&lt;point&gt;();</pre>
       </blockquote>
     </blockquote>
     <pre>template&lt;class U&gt;
@@ -134,8 +132,8 @@ unique_ptr&lt;U&gt; make_unique_noinit(size_t size);</pre>
         resolution when <code>U</code> is of the form <code>T[]</code>.</p>
       <p><b>Examples:</b></p>
       <blockquote>
-        <pre>unique_ptr&lt;double[]&gt; p1 = boost::make_unique_noinit&lt;double[]&gt;(4);
-unique_ptr&lt;int[][2]&gt; p2 = boost::make_unique_noinit&lt;int[][2]&gt;(2);</pre>
+        <pre>unique_ptr&lt;double[]&gt; p1 = boost::make_unique_noinit&lt;double[]&gt;(4);</pre>
+        <pre>unique_ptr&lt;int[][2]&gt; p2 = boost::make_unique_noinit&lt;int[][2]&gt;(2);</pre>
       </blockquote>
     </blockquote>
     <h2><a name="history">History</a></h2>
diff --git a/test/allocate_shared_array_construct_test.cpp b/test/allocate_shared_array_construct_test.cpp
index 0228275..669e813 100644
--- a/test/allocate_shared_array_construct_test.cpp
+++ b/test/allocate_shared_array_construct_test.cpp
@@ -1,127 +1,162 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
-struct tag { };
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+struct allow { };
 
-template<typename T>
-class creator {
-public:
+template<class T>
+struct creator {
     typedef T value_type;
-    creator() {
-    }
-    template<typename U>
-    creator(const creator<U>&) {
-    }
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
     T* allocate(std::size_t size) {
-        void* p = ::operator new(size * sizeof(T));
-        return static_cast<T*>(p);
+        return static_cast<T*>(::operator new(sizeof(T) * size));
     }
-    void deallocate(T* memory, std::size_t) {
-        void* p = memory;
-        ::operator delete(p);
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
     }
-    template<typename U>
-    void construct(U* memory) {
-        void* p = memory;
-        ::new(p) U(tag());
+
+    template<class U>
+    void construct(U* ptr) {
+        ::new(static_cast<void*>(ptr)) U(allow());
     }
-    template<typename U>
-    void destroy(U* memory) {
-        memory->~U();
+
+    template<class U>
+    void destroy(U* ptr) {
+        ptr->~U();
     }
+
 };
 
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
 class type {
 public:
-    static unsigned int instances;
-    explicit type(tag) {
-        instances++;
-    }
-    type(const type&) {
-        instances++;
+    static unsigned instances;
+
+    explicit type(allow) {
+        ++instances;
     }
+
     ~type() {
-        instances--;
+        --instances;
     }
+
+private:
+    type(const type&);
+    type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
     {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(creator<void>(), 3);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1.get() != 0);
+        boost::shared_ptr<type[]> result =
+            boost::allocate_shared<type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        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::shared_ptr<type[3]> result =
+            boost::allocate_shared<type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        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::shared_ptr<type[][2]> result =
+            boost::allocate_shared<type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        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::shared_ptr<type[2][2]> result =
+            boost::allocate_shared<type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        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::shared_ptr<const type[]> result =
+            boost::allocate_shared<const type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        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::shared_ptr<const type[3]> result =
+            boost::allocate_shared<const type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        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::shared_ptr<const type[][2]> result =
+            boost::allocate_shared<const type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        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::shared_ptr<const type[2][2]> result =
+            boost::allocate_shared<const type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-#endif
     return boost::report_errors();
 }
+#else
+int main()
+{
+    return 0;
+}
+#endif
diff --git a/test/allocate_shared_array_esft_test.cpp b/test/allocate_shared_array_esft_test.cpp
index 30edfff..0399c1a 100644
--- a/test/allocate_shared_array_esft_test.cpp
+++ b/test/allocate_shared_array_esft_test.cpp
@@ -1,39 +1,79 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/enable_shared_from_this.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
-class type 
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
+class type
     : public boost::enable_shared_from_this<type> {
 public:
-    static unsigned int instances;
-    explicit type() {
-        instances++;
+    static unsigned instances;
+
+    type() {
+        ++instances;
     }
+
     ~type() {
-        instances--;
+        --instances;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 3);
+        boost::shared_ptr<type[]> result =
+            boost::allocate_shared<type[]>(creator<type>(), 3);
         try {
-            a1[0].shared_from_this();
+            result[0].shared_from_this();
             BOOST_ERROR("shared_from_this did not throw");
         } catch (...) {
             BOOST_TEST(type::instances == 3);
@@ -41,9 +81,10 @@ int main()
     }
     BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
+        boost::shared_ptr<type[]> result =
+            boost::allocate_shared_noinit<type[]>(creator<type>(), 3);
         try {
-            a1[0].shared_from_this();
+            result[0].shared_from_this();
             BOOST_ERROR("shared_from_this did not throw");
         } catch (...) {
             BOOST_TEST(type::instances == 3);
diff --git a/test/allocate_shared_array_noinit_test.cpp b/test/allocate_shared_array_noinit_test.cpp
index 83b48ec..f30ee17 100644
--- a/test/allocate_shared_array_noinit_test.cpp
+++ b/test/allocate_shared_array_noinit_test.cpp
@@ -1,154 +1,250 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
+#include <boost/align/is_aligned.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
 class type {
 public:
-    static unsigned int instances;
-    explicit type() {
-        instances++;
+    static unsigned instances;
+
+    type()
+        : value_(0.0) {
+        ++instances;
     }
+
     ~type() {
-        instances--;
+        --instances;
     }
+
+    void set(long double value) {
+        value_ = value;
+    }
+
+    long double get() const {
+        return value_;
+    }
+
 private:
     type(const type&);
     type& operator=(const type&);
+
+    long double value_;
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     {
-        boost::shared_ptr<int[]> a1 = boost::allocate_shared_noinit<int[]>(std::allocator<int>(), 3);
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<int[]> result =
+            boost::allocate_shared_noinit<int[]>(creator<int>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<int[3]> a1 = boost::allocate_shared_noinit<int[3]>(std::allocator<int>());
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<int[3]> result =
+            boost::allocate_shared_noinit<int[3]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<int[][2]> a1 = boost::allocate_shared_noinit<int[][2]>(std::allocator<int>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<int[][2]> result =
+            boost::allocate_shared_noinit<int[][2]>(creator<int>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared_noinit<int[2][2]>(std::allocator<int>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<int[2][2]> result =
+            boost::allocate_shared_noinit<int[2][2]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<const int[]> a1 = boost::allocate_shared_noinit<const int[]>(std::allocator<int>(), 3);
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<const int[]> result =
+            boost::allocate_shared_noinit<const
+                int[]>(creator<int>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<const int[3]> a1 = boost::allocate_shared_noinit<const int[3]>(std::allocator<int>());
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<const int[3]> result =
+            boost::allocate_shared_noinit<const int[3]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<const int[][2]> a1 = boost::allocate_shared_noinit<const int[][2]>(std::allocator<int>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const int[][2]> result =
+            boost::allocate_shared_noinit<const
+                int[][2]>(creator<int>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<const int[2][2]> a1 = boost::allocate_shared_noinit<const int[2][2]>(std::allocator<int>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const int[2][2]> result =
+            boost::allocate_shared_noinit<const
+                int[2][2]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[]> result =
+            boost::allocate_shared_noinit<type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[3]> a1 = boost::allocate_shared_noinit<type[3]>(std::allocator<type>());
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[3]> result =
+            boost::allocate_shared_noinit<type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[3]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[][2]> a1 = boost::allocate_shared_noinit<type[][2]>(std::allocator<type>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[][2]> result =
+            boost::allocate_shared_noinit<type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<type[][2]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[2][2]> a1 = boost::allocate_shared_noinit<type[2][2]>(std::allocator<type>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[2][2]> result =
+            boost::allocate_shared_noinit<type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<type[2][2]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[]> a1 = boost::allocate_shared_noinit<const type[]>(std::allocator<type>(), 3);
-        const type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[]> result =
+            boost::allocate_shared_noinit<const
+                type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        boost::weak_ptr<const type[]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[3]> a1 = boost::allocate_shared_noinit<const type[3]>(std::allocator<type>());
-        const type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[3]> result =
+            boost::allocate_shared_noinit<const
+                type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        boost::weak_ptr<const type[3]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[][2]> a1 = boost::allocate_shared_noinit<const type[][2]>(std::allocator<type>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[][2]> result =
+            boost::allocate_shared_noinit<const
+                type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<const type[][2]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[2][2]> a1 = boost::allocate_shared_noinit<const type[2][2]>(std::allocator<type>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[2][2]> result =
+            boost::allocate_shared_noinit<const
+                type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<const type[2][2]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     return boost::report_errors();
diff --git a/test/allocate_shared_array_test.cpp b/test/allocate_shared_array_test.cpp
index c5a5714..0369631 100644
--- a/test/allocate_shared_array_test.cpp
+++ b/test/allocate_shared_array_test.cpp
@@ -1,182 +1,265 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
+#include <boost/align/is_aligned.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
 class type {
 public:
-    static unsigned int instances;
-    explicit type() {
-        instances++;
+    static unsigned instances;
+
+    type()
+        : value_(0.0) {
+        ++instances;
     }
+
     ~type() {
-        instances--;
+        --instances;
     }
+
+    void set(long double value) {
+        value_ = value;
+    }
+
+    long double get() const {
+        return value_;
+    }
+
 private:
     type(const type&);
     type& operator=(const type&);
+
+    long double value_;
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     {
-        boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), 3);
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<int[]> result =
+            boost::allocate_shared<int[]>(creator<int>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
     {
-        boost::shared_ptr<int[3]> a1 = boost::allocate_shared<int[3]>(std::allocator<int>());
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<int[3]> result =
+            boost::allocate_shared<int[3]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
     {
-        boost::shared_ptr<int[][2]> a1 = boost::allocate_shared<int[][2]>(std::allocator<int>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<int[][2]> result =
+            boost::allocate_shared<int[][2]>(creator<int>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
     {
-        boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<int[2][2]> result =
+            boost::allocate_shared<int[2][2]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
     {
-        boost::shared_ptr<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), 3);
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<const int[]> result =
+            boost::allocate_shared<const int[]>(creator<int>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
     {
-        boost::shared_ptr<const int[3]> a1 = boost::allocate_shared<const int[3]>(std::allocator<int>());
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<const int[3]> result =
+            boost::allocate_shared<const int[3]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
     {
-        boost::shared_ptr<const int[][2]> a1 = boost::allocate_shared<const int[][2]>(std::allocator<int>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<const int[][2]> result =
+            boost::allocate_shared<const int[][2]>(creator<int>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
     {
-        boost::shared_ptr<const int[2][2]> a1 = boost::allocate_shared<const int[2][2]>(std::allocator<int>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<const int[2][2]> result =
+            boost::allocate_shared<const int[2][2]>(creator<int>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
     {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 3);
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[]> result =
+            boost::allocate_shared<type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[]> w1 = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[3]> a1 = boost::allocate_shared<type[3]>(std::allocator<type>());
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[3]> result =
+            boost::allocate_shared<type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[3]> w1 = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[][2]> a1 = boost::allocate_shared<type[][2]>(std::allocator<type>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[][2]> result =
+            boost::allocate_shared<type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[2][2]> a1 = boost::allocate_shared<type[2][2]>(std::allocator<type>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[2][2]> result =
+            boost::allocate_shared<type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[]> a1 = boost::allocate_shared<const type[]>(std::allocator<type>(), 3);
-        const type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[]> result =
+            boost::allocate_shared<const type[]>(creator<type>(), 3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[3]> a1 = boost::allocate_shared<const type[3]>(std::allocator<type>());
-        const type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[3]> result =
+            boost::allocate_shared<const type[3]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[][2]> a1 = boost::allocate_shared<const type[][2]>(std::allocator<type>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[][2]> result =
+            boost::allocate_shared<const type[][2]>(creator<type>(), 2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[2][2]> a1 = boost::allocate_shared<const type[2][2]>(std::allocator<type>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[2][2]> result =
+            boost::allocate_shared<const type[2][2]>(creator<type>());
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     return boost::report_errors();
diff --git a/test/allocate_shared_array_throws_test.cpp b/test/allocate_shared_array_throws_test.cpp
index e14d984..9857d18 100644
--- a/test/allocate_shared_array_throws_test.cpp
+++ b/test/allocate_shared_array_throws_test.cpp
@@ -1,79 +1,118 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
 class type {
 public:
-    static unsigned int instances;
-    explicit type() {
+    static unsigned instances;
+
+    type() {
         if (instances == 5) {
             throw true;
         }
-        instances++;
+        ++instances;
     }
+
     ~type() {
-        instances--;
+        --instances;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     try {
-        boost::allocate_shared<type[]>(std::allocator<type>(), 6);
+        boost::allocate_shared<type[]>(creator<type>(), 6);
         BOOST_ERROR("allocate_shared did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared<type[][2]>(std::allocator<type>(), 3);
+        boost::allocate_shared<type[][2]>(creator<type>(), 3);
         BOOST_ERROR("allocate_shared did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared<type[6]>(std::allocator<type>());
+        boost::allocate_shared<type[6]>(creator<type>());
         BOOST_ERROR("allocate_shared did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared<type[3][2]>(std::allocator<type>());
+        boost::allocate_shared<type[3][2]>(creator<type>());
         BOOST_ERROR("allocate_shared did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 6);
+        boost::allocate_shared_noinit<type[]>(creator<type>(), 6);
         BOOST_ERROR("allocate_shared_noinit did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared_noinit<type[][2]>(std::allocator<type>(), 3);
+        boost::allocate_shared_noinit<type[][2]>(creator<type>(), 3);
         BOOST_ERROR("allocate_shared_noinit did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared_noinit<type[6]>(std::allocator<type>());
+        boost::allocate_shared_noinit<type[6]>(creator<type>());
         BOOST_ERROR("allocate_shared_noinit did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared_noinit<type[3][2]>(std::allocator<type>());
+        boost::allocate_shared_noinit<type[3][2]>(creator<type>());
         BOOST_ERROR("allocate_shared_noinit did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
diff --git a/test/allocate_shared_array_value_test.cpp b/test/allocate_shared_array_value_test.cpp
index c6f08f9..485c477 100644
--- a/test/allocate_shared_array_value_test.cpp
+++ b/test/allocate_shared_array_value_test.cpp
@@ -1,43 +1,83 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
 int main()
 {
     {
-        boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), 4, 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<int[]> result =
+            boost::allocate_shared<int[]>(creator<int>(), 4, 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
     {
-        boost::shared_ptr<int[4]> a1 = boost::allocate_shared<int[4]>(std::allocator<int>(), 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<int[4]> result =
+            boost::allocate_shared<int[4]>(creator<int>(), 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
     {
-        boost::shared_ptr<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), 4, 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<const int[]> result =
+            boost::allocate_shared<const int[]>(creator<int>(), 4, 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
     {
-        boost::shared_ptr<const int[4]> a1 = boost::allocate_shared<const int[4]>(std::allocator<int>(), 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<const int[4]> result =
+            boost::allocate_shared<const int[4]>(creator<int>(), 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
     return boost::report_errors();
 }
diff --git a/test/allocate_shared_arrays_test.cpp b/test/allocate_shared_arrays_test.cpp
index 7c45e72..a088a22 100644
--- a/test/allocate_shared_arrays_test.cpp
+++ b/test/allocate_shared_arrays_test.cpp
@@ -1,45 +1,92 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
+#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
 int main()
 {
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
     {
-        boost::shared_ptr<int[][2]> a1 = boost::allocate_shared<int[][2]>(std::allocator<int>(), 2, {0, 1});
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<int[][2]> result =
+            boost::allocate_shared<int[][2]>(creator<int>(), 2, {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
     {
-        boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>(), { 0, 1 });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<int[2][2]> result =
+            boost::allocate_shared<int[2][2]>(creator<int>(), {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
     {
-        boost::shared_ptr<const int[][2]> a1 = boost::allocate_shared<const int[][2]>(std::allocator<int>(), 2, { 0, 1 });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<const int[][2]> result =
+            boost::allocate_shared<const
+                int[][2]>(creator<int>(), 2, {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
     {
-        boost::shared_ptr<const int[2][2]> a1 = boost::allocate_shared<const int[2][2]>(std::allocator<int>(), { 0, 1 });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<const int[2][2]> result =
+            boost::allocate_shared<const
+                int[2][2]>(creator<int>(), {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
-#endif
     return boost::report_errors();
 }
+#else
+int main()
+{
+    return 0;
+}
+#endif
diff --git a/test/make_shared_array_esft_test.cpp b/test/make_shared_array_esft_test.cpp
index 8429919..f52e3cf 100644
--- a/test/make_shared_array_esft_test.cpp
+++ b/test/make_shared_array_esft_test.cpp
@@ -1,10 +1,9 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/enable_shared_from_this.hpp>
@@ -13,27 +12,31 @@ http://boost.org/LICENSE_1_0.txt
 class type
     : public boost::enable_shared_from_this<type> {
 public:
-    static unsigned int instances;
-    explicit type() {
-        instances++;
+    static unsigned instances;
+
+    type() {
+        ++instances;
     }
+
     ~type() {
-        instances--;
+        --instances;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(3);
+        boost::shared_ptr<type[]> result =
+            boost::make_shared<type[]>(3);
         try {
-            a1[0].shared_from_this();
+            result[0].shared_from_this();
             BOOST_ERROR("shared_from_this did not throw");
         } catch (...) {
             BOOST_TEST(type::instances == 3);
@@ -41,9 +44,10 @@ int main()
     }
     BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::make_shared_noinit<type[]>(3);
+        boost::shared_ptr<type[3]> result =
+            boost::make_shared_noinit<type[3]>();
         try {
-            a1[0].shared_from_this();
+            result[0].shared_from_this();
             BOOST_ERROR("shared_from_this did not throw");
         } catch (...) {
             BOOST_TEST(type::instances == 3);
diff --git a/test/make_shared_array_noinit_test.cpp b/test/make_shared_array_noinit_test.cpp
index 4942569..757e798 100644
--- a/test/make_shared_array_noinit_test.cpp
+++ b/test/make_shared_array_noinit_test.cpp
@@ -1,11 +1,11 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
+#include <boost/align/is_aligned.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
@@ -13,142 +13,194 @@ http://boost.org/LICENSE_1_0.txt
 
 class type {
 public:
-    static unsigned int instances;
-    explicit type() {
-        instances++;
+    static unsigned instances;
+
+    type()
+        : value_(0.0) {
+        ++instances;
     }
+
     ~type() {
-        instances--;
+        --instances;
     }
+
+    void set(long double value) {
+        value_ = value;
+    }
+
+    long double get() const {
+        return value_;
+    }
+
 private:
     type(const type&);
     type& operator=(const type&);
+
+    long double value_;
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     {
-        boost::shared_ptr<int[]> a1 = boost::make_shared_noinit<int[]>(3);
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<int[]> result =
+            boost::make_shared_noinit<int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<int[3]> a1 = boost::make_shared_noinit<int[3]>();
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<int[3]> result =
+            boost::make_shared_noinit<int[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<int[][2]> a1 = boost::make_shared_noinit<int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<int[][2]> result =
+            boost::make_shared_noinit<int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<int[2][2]> a1 = boost::make_shared_noinit<int[2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<int[2][2]> result =
+            boost::make_shared_noinit<int[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<const int[]> a1 = boost::make_shared_noinit<const int[]>(3);
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<const int[]> result =
+            boost::make_shared_noinit<const int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<const int[3]> a1 = boost::make_shared_noinit<const int[3]>();
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+        boost::shared_ptr<const int[3]> result =
+            boost::make_shared_noinit<const int[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<const int[][2]> a1 = boost::make_shared_noinit<const int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const int[][2]> result =
+            boost::make_shared_noinit<const int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<const int[2][2]> a1 = boost::make_shared_noinit<const int[2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const int[2][2]> result =
+            boost::make_shared_noinit<const int[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
     }
     {
-        boost::shared_ptr<type[]> a1 = boost::make_shared_noinit<type[]>(3);
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[]> result =
+            boost::make_shared_noinit<type[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[3]> a1 = boost::make_shared_noinit<type[3]>();
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[3]> result =
+            boost::make_shared_noinit<type[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[3]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[][2]> a1 = boost::make_shared_noinit<type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[][2]> result =
+            boost::make_shared_noinit<type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<type[][2]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[2][2]> a1 = boost::make_shared_noinit<type[2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[2][2]> result =
+            boost::make_shared_noinit<type[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<type[2][2]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[]> a1 = boost::make_shared_noinit<const type[]>(3);
-        const type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[]> result =
+            boost::make_shared_noinit<const type[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        boost::weak_ptr<const type[]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[3]> a1 = boost::make_shared_noinit<const type[3]>();
-        const type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[3]> result =
+            boost::make_shared_noinit<const type[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        boost::weak_ptr<const type[3]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[][2]> a1 = boost::make_shared_noinit<const type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[][2]> result =
+            boost::make_shared_noinit<const type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<const type[][2]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[2][2]> a1 = boost::make_shared_noinit<const type[2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[2][2]> result =
+            boost::make_shared_noinit<const type[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        boost::weak_ptr<const type[2][2]> other = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     return boost::report_errors();
diff --git a/test/make_shared_array_test.cpp b/test/make_shared_array_test.cpp
index de74198..c6bac24 100644
--- a/test/make_shared_array_test.cpp
+++ b/test/make_shared_array_test.cpp
@@ -1,11 +1,11 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
+#include <boost/align/is_aligned.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
@@ -13,170 +13,216 @@ http://boost.org/LICENSE_1_0.txt
 
 class type {
 public:
-    static unsigned int instances;
-    explicit type() {
-        instances++;
+    static unsigned instances;
+
+    type()
+        : value_(0.0) {
+        ++instances;
     }
+
     ~type() {
-        instances--;
+        --instances;
     }
+
+    void set(long double value) {
+        value_ = value;
+    }
+
+    long double get() const {
+        return value_;
+    }
+
 private:
     type(const type&);
     type& operator=(const type&);
+
+    long double value_;
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     {
-        boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>(3);
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<int[]> result =
+            boost::make_shared<int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
     {
-        boost::shared_ptr<int[3]> a1 = boost::make_shared<int[3]>();
-        int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<int[3]> result =
+            boost::make_shared<int[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
     {
-        boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<int[][2]> result =
+            boost::make_shared<int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
     {
-        boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<int[2][2]> result =
+            boost::make_shared<int[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
     {
-        boost::shared_ptr<const int[]> a1 = boost::make_shared<const int[]>(3);
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<const int[]> result =
+            boost::make_shared<const int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
     {
-        boost::shared_ptr<const int[3]> a1 = boost::make_shared<const int[3]>();
-        const int* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        boost::shared_ptr<const int[3]> result =
+            boost::make_shared<const int[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
     {
-        boost::shared_ptr<const int[][2]> a1 = boost::make_shared<const int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<const int[][2]> result =
+            boost::make_shared<const int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
     {
-        boost::shared_ptr<const int[2][2]> a1 = boost::make_shared<const int[2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        boost::shared_ptr<const int[2][2]> result =
+            boost::make_shared<const int[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<int>::value));
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
     {
-        boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(3);
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[]> result =
+            boost::make_shared<type[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[]> w1 = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[3]> a1 = boost::make_shared<type[3]>();
-        type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<type[3]> result =
+            boost::make_shared<type[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
+        boost::weak_ptr<type[3]> w1 = result;
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[][2]> a1 = boost::make_shared<type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[][2]> result =
+            boost::make_shared<type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<type[2][2]> a1 = boost::make_shared<type[2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<type[2][2]> result =
+            boost::make_shared<type[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[]> a1 = boost::make_shared<const type[]>(3);
-        const type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[]> result =
+            boost::make_shared<const type[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[3]> a1 = boost::make_shared<const type[3]>();
-        const type* a2 = a1.get();
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        boost::shared_ptr<const type[3]> result =
+            boost::make_shared<const type[3]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[][2]> a1 = boost::make_shared<const type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[][2]> result =
+            boost::make_shared<const type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     {
-        boost::shared_ptr<const type[2][2]> a1 = boost::make_shared<const type[2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
+        boost::shared_ptr<const type[2][2]> result =
+            boost::make_shared<const type[2][2]>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result.use_count() == 1);
+        BOOST_TEST(boost::alignment::is_aligned(result.get(),
+            boost::alignment_of<type>::value));
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
     return boost::report_errors();
diff --git a/test/make_shared_array_throws_test.cpp b/test/make_shared_array_throws_test.cpp
index 56c7372..a754360 100644
--- a/test/make_shared_array_throws_test.cpp
+++ b/test/make_shared_array_throws_test.cpp
@@ -1,32 +1,34 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
 class type {
 public:
-    static unsigned int instances;
-    explicit type() {
+    static unsigned instances;
+
+    type() {
         if (instances == 5) {
             throw true;
         }
-        instances++;
+        ++instances;
     }
+
     ~type() {
-        instances--;
+        --instances;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
diff --git a/test/make_shared_array_value_test.cpp b/test/make_shared_array_value_test.cpp
index 185605d..44d12d3 100644
--- a/test/make_shared_array_value_test.cpp
+++ b/test/make_shared_array_value_test.cpp
@@ -1,10 +1,9 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
@@ -12,32 +11,36 @@ http://boost.org/LICENSE_1_0.txt
 int main()
 {
     {
-        boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>(4, 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<int[]> result =
+            boost::make_shared<int[]>(4, 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
     {
-        boost::shared_ptr<int[4]> a1 = boost::make_shared<int[4]>(1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<int[4]> result =
+            boost::make_shared<int[4]>(1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
     {
-        boost::shared_ptr<const int[]> a1 = boost::make_shared<const int[]>(4, 1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<const int[]> result =
+            boost::make_shared<const int[]>(4, 1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
     {
-        boost::shared_ptr<const int[4]> a1 = boost::make_shared<const int[4]>(1);
-        BOOST_TEST(a1[0] == 1);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 1);
-        BOOST_TEST(a1[3] == 1);
+        boost::shared_ptr<const int[4]> result =
+            boost::make_shared<const int[4]>(1);
+        BOOST_TEST(result[0] == 1);
+        BOOST_TEST(result[1] == 1);
+        BOOST_TEST(result[2] == 1);
+        BOOST_TEST(result[3] == 1);
     }
     return boost::report_errors();
 }
diff --git a/test/make_shared_arrays_test.cpp b/test/make_shared_arrays_test.cpp
index 7cd067f..0022e01 100644
--- a/test/make_shared_arrays_test.cpp
+++ b/test/make_shared_arrays_test.cpp
@@ -1,45 +1,53 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
+#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
 int main()
 {
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
     {
-        boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>(2, {0, 1});
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<int[][2]> result =
+            boost::make_shared<int[][2]>(2, {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
     {
-        boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>({ 0, 1 });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<int[2][2]> result =
+            boost::make_shared<int[2][2]>({0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
     {
-        boost::shared_ptr<const int[][2]> a1 = boost::make_shared<const int[][2]>(2, { 0, 1 });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<const int[][2]> result =
+            boost::make_shared<const int[][2]>(2, {0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
     {
-        boost::shared_ptr<const int[2][2]> a1 = boost::make_shared<const int[2][2]>({ 0, 1 });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 1);
+        boost::shared_ptr<const int[2][2]> result =
+            boost::make_shared<const int[2][2]>({0, 1});
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 1);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 1);
     }
-#endif
     return boost::report_errors();
 }
+#else
+int main()
+{
+    return 0;
+}
+#endif
diff --git a/test/make_unique_args_test.cpp b/test/make_unique_args_test.cpp
index 7231a8d..6e46612 100644
--- a/test/make_unique_args_test.cpp
+++ b/test/make_unique_args_test.cpp
@@ -1,148 +1,155 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_unique.hpp>
 
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type(int v1 = 0, 
-                  int v2 = 0, 
-                  int v3 = 0, 
-                  int v4 = 0, 
-                  int v5 = 0, 
-                  int v6 = 0, 
-                  int v7 = 0, 
-                  int v8 = 0, 
-                  int v9 = 0) 
-        : sum(v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9) {
-        instances++;
+    type(int v1 = 0,
+         int v2 = 0,
+         int v3 = 0,
+         int v4 = 0,
+         int v5 = 0,
+         int v6 = 0,
+         int v7 = 0,
+         int v8 = 0,
+         int v9 = 0)
+        : sum_(v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 + v9) {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
-    const int sum;
+    int sum() const {
+        return sum_;
+    }
 
 private:
+    int sum_;
+
     type(const type&);
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result = boost::make_unique<type>();
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 0);
-        a1.reset();
+        BOOST_TEST(result->sum() == 0);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
-#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES )
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result = boost::make_unique<type>(1);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result = boost::make_unique<type>(1, 2);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4, 5);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4, 5);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4 + 5);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4 + 5);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4, 5, 6);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4, 5, 6);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4 + 5 + 6);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4 + 5 + 6);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4 + 5 + 6 + 7);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4 + 5 + 6 + 7);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7, 8);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7, 8);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7, 8, 9);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>(1, 2, 3, 4, 5, 6, 7, 8, 9);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        BOOST_TEST(a1->sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9);
-        a1.reset();
+        BOOST_TEST(result->sum() == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9);
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
 #endif
-
     return boost::report_errors();
 }
 #else
-
 int main()
 {
     return 0;
 }
-
 #endif
diff --git a/test/make_unique_array_noinit_test.cpp b/test/make_unique_array_noinit_test.cpp
index 675c470..44ac66e 100644
--- a/test/make_unique_array_noinit_test.cpp
+++ b/test/make_unique_array_noinit_test.cpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
@@ -13,14 +12,14 @@ http://boost.org/LICENSE_1_0.txt
 
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type() {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -28,63 +27,61 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     {
-        std::unique_ptr<int[]> a1 = boost::make_unique_noinit<int[]>(3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<int[]> result =
+            boost::make_unique_noinit<int[]>(3);
+        BOOST_TEST(result.get() != 0);
     }
-
     {
-        std::unique_ptr<int[][2]> a1 = boost::make_unique_noinit<int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<int[][2]> result =
+            boost::make_unique_noinit<int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
     }
-    
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type[]> a1 = boost::make_unique_noinit<type[]>(3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type[]> result =
+            boost::make_unique_noinit<type[]>(3);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type[][2]> a1 = boost::make_unique_noinit<type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type[][2]> result =
+            boost::make_unique_noinit<type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type[]> a1 = boost::make_unique_noinit<const type[]>(3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type[]> result =
+            boost::make_unique_noinit<const type[]>(3);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type[][2]> a1 = boost::make_unique_noinit<const type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type[][2]> result =
+            boost::make_unique_noinit<const type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
 int main()
 {
     return 0;
 }
-
 #endif
diff --git a/test/make_unique_array_test.cpp b/test/make_unique_array_test.cpp
index af0a065..447f79d 100644
--- a/test/make_unique_array_test.cpp
+++ b/test/make_unique_array_test.cpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
@@ -13,14 +12,14 @@ http://boost.org/LICENSE_1_0.txt
 
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type() {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -28,87 +27,84 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     {
-        std::unique_ptr<int[]> a1 = boost::make_unique<int[]>(3);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        std::unique_ptr<int[]> result = boost::make_unique<int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        std::unique_ptr<int[][2]> a1 = boost::make_unique<int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        std::unique_ptr<int[][2]> result =
+            boost::make_unique<int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
-
     {
-        std::unique_ptr<const int[]> a1 = boost::make_unique<const int[]>(3);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 0);
-        BOOST_TEST(a1[2] == 0);
+        std::unique_ptr<const int[]> result =
+            boost::make_unique<const int[]>(3);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result[0] == 0);
+        BOOST_TEST(result[1] == 0);
+        BOOST_TEST(result[2] == 0);
     }
-
     {
-        std::unique_ptr<const int[][2]> a1 = boost::make_unique<const int[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 0);
-        BOOST_TEST(a1[1][0] == 0);
-        BOOST_TEST(a1[1][1] == 0);
+        std::unique_ptr<const int[][2]> result =
+            boost::make_unique<const int[][2]>(2);
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result[0][0] == 0);
+        BOOST_TEST(result[0][1] == 0);
+        BOOST_TEST(result[1][0] == 0);
+        BOOST_TEST(result[1][1] == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type[]> a1 = boost::make_unique<type[]>(3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type[]> result =
+            boost::make_unique<type[]>(3);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type[][2]> a1 = boost::make_unique<type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type[][2]> result =
+            boost::make_unique<type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type[]> a1 = boost::make_unique<const type[]>(3);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type[]> result =
+            boost::make_unique<const type[]>(3);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 3);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type[][2]> a1 = boost::make_unique<const type[][2]>(2);
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type[][2]> result =
+            boost::make_unique<const type[][2]>(2);
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 4);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
 int main()
 {
     return 0;
 }
-
 #endif
diff --git a/test/make_unique_array_throws_test.cpp b/test/make_unique_array_throws_test.cpp
index e38b145..df4ab26 100644
--- a/test/make_unique_array_throws_test.cpp
+++ b/test/make_unique_array_throws_test.cpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
@@ -13,17 +12,17 @@ http://boost.org/LICENSE_1_0.txt
 
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
+    type() {
         if (instances == 5) {
             throw true;
         }
-        instances++;
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -31,7 +30,7 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
@@ -42,7 +41,6 @@ int main()
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_unique<type[][2]>(3);
@@ -50,7 +48,6 @@ int main()
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_unique_noinit<type[]>(6);
@@ -58,7 +55,6 @@ int main()
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_unique_noinit<type[][2]>(3);
@@ -66,14 +62,11 @@ int main()
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
 int main()
 {
     return 0;
 }
-
 #endif
diff --git a/test/make_unique_noinit_test.cpp b/test/make_unique_noinit_test.cpp
index 3de787c..a7cd828 100644
--- a/test/make_unique_noinit_test.cpp
+++ b/test/make_unique_noinit_test.cpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
@@ -13,14 +12,14 @@ http://boost.org/LICENSE_1_0.txt
 
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type() {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -28,40 +27,37 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     {
-        std::unique_ptr<int> a1 = boost::make_unique_noinit<int>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<int> result = boost::make_unique_noinit<int>();
+        BOOST_TEST(result.get() != 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type> a1 = boost::make_unique_noinit<type>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique_noinit<type>();
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type> a1 = boost::make_unique_noinit<const type>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type> result =
+            boost::make_unique_noinit<const type>();
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
 int main()
 {
     return 0;
 }
-
 #endif
diff --git a/test/make_unique_test.cpp b/test/make_unique_test.cpp
index a2c6b99..74c6033 100644
--- a/test/make_unique_test.cpp
+++ b/test/make_unique_test.cpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
@@ -13,14 +12,14 @@ http://boost.org/LICENSE_1_0.txt
 
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
-        instances++;
+    type() {
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -28,47 +27,44 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     {
-        std::unique_ptr<int> a1 = boost::make_unique<int>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(*a1 == 0);
+        std::unique_ptr<int> result = boost::make_unique<int>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(*result == 0);
     }
-
     {
-        std::unique_ptr<const int> a1 = boost::make_unique<const int>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(*a1 == 0);
+        std::unique_ptr<const int> result =
+            boost::make_unique<const int>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(*result == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>();
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     BOOST_TEST(type::instances == 0);
     {
-        std::unique_ptr<const type> a1 = boost::make_unique<const type>();
-        BOOST_TEST(a1.get() != 0);
+        std::unique_ptr<const type> result =
+            boost::make_unique<const type>();
+        BOOST_TEST(result.get() != 0);
         BOOST_TEST(type::instances == 1);
-        a1.reset();
+        result.reset();
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
 int main()
 {
     return 0;
 }
-
 #endif
diff --git a/test/make_unique_throws_test.cpp b/test/make_unique_throws_test.cpp
index c8fdcc8..2032a2e 100644
--- a/test/make_unique_throws_test.cpp
+++ b/test/make_unique_throws_test.cpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
@@ -13,17 +12,17 @@ http://boost.org/LICENSE_1_0.txt
 
 class type {
 public:
-    static unsigned int instances;
+    static unsigned instances;
 
-    explicit type() {
+    type() {
         if (instances == 0) {
             throw true;
         }
-        instances++;
+        ++instances;
     }
 
     ~type() {
-        instances--;
+        --instances;
     }
 
 private:
@@ -31,7 +30,7 @@ private:
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
@@ -42,14 +41,11 @@ int main()
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-
     return boost::report_errors();
 }
 #else
-
 int main()
 {
     return 0;
 }
-
 #endif
diff --git a/test/make_unique_value_test.cpp b/test/make_unique_value_test.cpp
index 4b34af8..c7af67f 100644
--- a/test/make_unique_value_test.cpp
+++ b/test/make_unique_value_test.cpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/config.hpp>
 #if !defined(BOOST_NO_CXX11_SMART_PTR)
@@ -19,42 +18,39 @@ struct type {
 int main()
 {
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1->x == 0);
-        BOOST_TEST(a1->y == 0);
+        std::unique_ptr<type> result = boost::make_unique<type>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result->x == 0);
+        BOOST_TEST(result->y == 0);
     }
-
     {
-        std::unique_ptr<const type> a1 = boost::make_unique<const type>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1->x == 0);
-        BOOST_TEST(a1->y == 0);
+        std::unique_ptr<const type> result =
+            boost::make_unique<const type>();
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result->x == 0);
+        BOOST_TEST(result->y == 0);
     }
-
 #if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
     {
-        std::unique_ptr<type> a1 = boost::make_unique<type>({ 1, 2 });
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1->x == 1);
-        BOOST_TEST(a1->y == 2);
+        std::unique_ptr<type> result =
+            boost::make_unique<type>({ 1, 2 });
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result->x == 1);
+        BOOST_TEST(result->y == 2);
     }
-
     {
-        std::unique_ptr<const type> a1 = boost::make_unique<const type>({ 1, 2 });
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1->x == 1);
-        BOOST_TEST(a1->y == 2);
+        std::unique_ptr<const type> result =
+            boost::make_unique<const type>({ 1, 2 });
+        BOOST_TEST(result.get() != 0);
+        BOOST_TEST(result->x == 1);
+        BOOST_TEST(result->y == 2);
     }
 #endif
-
     return boost::report_errors();
 }
 #else
-
 int main()
 {
     return 0;
 }
-
 #endif