diff --git a/include/boost/smart_ptr/allocate_shared_array.hpp b/include/boost/smart_ptr/allocate_shared_array.hpp
index 3ee1655..b76e912 100644
--- a/include/boost/smart_ptr/allocate_shared_array.hpp
+++ b/include/boost/smart_ptr/allocate_shared_array.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License,
@@ -14,9 +14,6 @@
 #include <boost/smart_ptr/detail/array_deleter.hpp>
 #include <boost/smart_ptr/detail/array_traits.hpp>
 #include <boost/smart_ptr/detail/sp_if_array.hpp>
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
 
 namespace boost {
     template<typename T, typename A>
@@ -36,67 +33,27 @@ namespace boost {
         d2->init(p2);
         return boost::shared_ptr<T>(s1, p1);
     }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template<typename T, typename A, typename... Args>
-    inline typename boost::detail::sp_if_array<T>::type
-    allocate_shared(const A& allocator, std::size_t size, Args&&... args) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        std::size_t n1 = size * boost::detail::array_total<T1>::size;
-        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
-        boost::detail::array_deleter<T2[]> d1(n1);
-        boost::shared_ptr<T> s1(p1, d1, a1);
-        typedef boost::detail::array_deleter<T2[]>* D2;
-        p1 = reinterpret_cast<T1*>(p2);
-        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init(p2, boost::detail::sp_forward<Args>(args)...);
-        return boost::shared_ptr<T>(s1, p1);
-    }
-    template<typename T, typename A, typename... Args>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    allocate_shared(const A& allocator, Args&&... args) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        enum {
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
-        boost::detail::array_deleter<T2[N]> d1;
-        boost::shared_ptr<T> s1(p1, d1, a1);
-        typedef boost::detail::array_deleter<T2[N]>* D2;
-        p1 = reinterpret_cast<T1*>(p2);
-        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init(p2, boost::detail::sp_forward<Args>(args)...);
-        return boost::shared_ptr<T>(s1, p1);
-    }
-#endif
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
+
     template<typename T, typename A>
     inline typename boost::detail::sp_if_size_array<T>::type
-    allocate_shared(const A& allocator, const T& list) {
+    allocate_shared(const A& allocator) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
-        typedef const T2 T3;
         enum {
             N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
-        T3* p3 = 0;
         boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
         typedef boost::detail::array_deleter<T2[N]>* D2;
-        p3 = reinterpret_cast<T3*>(list);
         p1 = reinterpret_cast<T1*>(p2);
         D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init_list(p2, p3);
+        d2->init(p2);
         return boost::shared_ptr<T>(s1, p1);
     }
+
     template<typename T, typename A>
     inline typename boost::detail::sp_if_array<T>::type
     allocate_shared(const A& allocator, std::size_t size,
@@ -115,12 +72,13 @@ namespace boost {
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
         typedef boost::detail::array_deleter<T2[]>* D2;
-        p3 = reinterpret_cast<T3*>(list);
+        p3 = reinterpret_cast<T3*>(&list);
         p1 = reinterpret_cast<T1*>(p2);
         D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->template init_list<M>(p2, p3);
+        d2->template init<M>(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
+
     template<typename T, typename A>
     inline typename boost::detail::sp_if_size_array<T>::type
     allocate_shared(const A& allocator,
@@ -139,76 +97,13 @@ namespace boost {
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
         typedef boost::detail::array_deleter<T2[N]>* D2;
-        p3 = reinterpret_cast<T3*>(list);
+        p3 = reinterpret_cast<T3*>(&list);
         p1 = reinterpret_cast<T1*>(p2);
         D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->template init_list<M>(p2, p3);
+        d2->template init<M>(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    template<typename T, typename A>
-    inline typename boost::detail::sp_if_array<T>::type
-    allocate_shared(const A& allocator,
-        std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef const T2 T3;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        T3* p3 = 0;
-        std::size_t n1 = list.size() * boost::detail::array_total<T1>::size;
-        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
-        boost::detail::array_deleter<T2[]> d1(n1);
-        boost::shared_ptr<T> s1(p1, d1, a1);
-        typedef boost::detail::array_deleter<T2[]>* D2;
-        p3 = reinterpret_cast<T3*>(list.begin());
-        p1 = reinterpret_cast<T1*>(p2);
-        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init_list(p2, p3);
-        return boost::shared_ptr<T>(s1, p1);
-    }
-#endif
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template<typename T, typename A>
-    inline typename boost::detail::sp_if_array<T>::type
-    allocate_shared(const A& allocator, std::size_t size,
-        typename boost::detail::array_base<T>::type&& value) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        std::size_t n1 = size * boost::detail::array_total<T1>::size;
-        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
-        boost::detail::array_deleter<T2[]> d1(n1);
-        boost::shared_ptr<T> s1(p1, d1, a1);
-        typedef boost::detail::array_deleter<T2[]>* D2;
-        p1 = reinterpret_cast<T1*>(p2);
-        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init(p2, boost::detail::sp_forward<T2>(value));
-        return boost::shared_ptr<T>(s1, p1);
-    }
-    template<typename T, typename A>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    allocate_shared(const A& allocator,
-        typename boost::detail::array_base<T>::type&& value) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        enum {
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
-        boost::detail::array_deleter<T2[N]> d1;
-        boost::shared_ptr<T> s1(p1, d1, a1);
-        typedef boost::detail::array_deleter<T2[N]>* D2;
-        p1 = reinterpret_cast<T1*>(p2);
-        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init(p2, boost::detail::sp_forward<T2>(value));
-        return boost::shared_ptr<T>(s1, p1);
-    }
-#endif
-#endif
+
     template<typename T, typename A>
     inline typename boost::detail::sp_if_array<T>::type
     allocate_shared_noinit(const A& allocator, std::size_t size) {
@@ -226,6 +121,7 @@ namespace boost {
         d2->noinit(p2);
         return boost::shared_ptr<T>(s1, p1);
     }
+
     template<typename T, typename A>
     inline typename boost::detail::sp_if_size_array<T>::type
     allocate_shared_noinit(const A& allocator) {
diff --git a/include/boost/smart_ptr/detail/allocate_array_helper.hpp b/include/boost/smart_ptr/detail/allocate_array_helper.hpp
index 2eeea2d..1f358e7 100644
--- a/include/boost/smart_ptr/detail/allocate_array_helper.hpp
+++ b/include/boost/smart_ptr/detail/allocate_array_helper.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -15,12 +15,15 @@ namespace boost {
     namespace detail {
         template<typename A, typename T, typename Y = char>
         class allocate_array_helper;
+
         template<typename A, typename T, typename Y>
         class allocate_array_helper<A, T[], Y> {
             template<typename A9, typename T9, typename Y9>
             friend class allocate_array_helper;
+
             typedef typename A::template rebind<Y>   ::other A2;
             typedef typename A::template rebind<char>::other A3;
+
         public:
             typedef typename A2::value_type      value_type;
             typedef typename A2::pointer         pointer;
@@ -29,30 +32,37 @@ namespace boost {
             typedef typename A2::const_reference const_reference;
             typedef typename A2::size_type       size_type;
             typedef typename A2::difference_type difference_type;
+
             template<typename U>
             struct rebind {
                 typedef allocate_array_helper<A, T[], U> other;
             };
+
             allocate_array_helper(const A& allocator_, std::size_t size_, T** data_)
                 : allocator(allocator_),
                   size(sizeof(T) * size_),
                   data(data_) {
             }
+
             template<class U>
             allocate_array_helper(const allocate_array_helper<A, T[], U>& other) 
                 : allocator(other.allocator),
                   size(other.size),
                   data(other.data) {
             }
+
             pointer address(reference value) const {
                 return allocator.address(value);
             }
+
             const_pointer address(const_reference value) const {
                 return allocator.address(value);
             }
+
             size_type max_size() const {
                 return allocator.max_size();
             }
+
             pointer allocate(size_type count, const void* value = 0) {
                 std::size_t a1 = boost::alignment_of<T>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
@@ -64,37 +74,46 @@ namespace boost {
                 *data = reinterpret_cast<T*>(p2);
                 return  reinterpret_cast<Y*>(p1);
             }
+
             void deallocate(pointer memory, size_type count) {
                 std::size_t a1 = boost::alignment_of<T>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
                 char*  p1 = reinterpret_cast<char*>(memory);
                 A3(allocator).deallocate(p1, n1 + size);
             }
+
             void construct(pointer memory, const Y& value) {
                 allocator.construct(memory, value);
             }
+
             void destroy(pointer memory) {
                 allocator.destroy(memory);
             }
+
             template<typename U>
             bool operator==(const allocate_array_helper<A, T[], U>& other) const {
                 return allocator == other.allocator;
             }
+
             template<typename U>
             bool operator!=(const allocate_array_helper<A, T[], U>& other) const {
                 return !(*this == other); 
             }
+
         private:
             A2 allocator;
             std::size_t size;
             T** data;
         };
+
         template<typename A, typename T, std::size_t N, typename Y>
         class allocate_array_helper<A, T[N], Y> {
             template<typename A9, typename T9, typename Y9>
             friend class allocate_array_helper;
+
             typedef typename A::template rebind<Y>   ::other A2;
             typedef typename A::template rebind<char>::other A3;
+
         public:
             typedef typename A2::value_type      value_type;
             typedef typename A2::pointer         pointer;
@@ -103,28 +122,35 @@ namespace boost {
             typedef typename A2::const_reference const_reference;
             typedef typename A2::size_type       size_type;
             typedef typename A2::difference_type difference_type;
+
             template<typename U>
             struct rebind {
                 typedef allocate_array_helper<A, T[N], U> other;
             };
+
             allocate_array_helper(const A& allocator_, T** data_)
                 : allocator(allocator_),
                   data(data_) {
             }
+
             template<class U>
             allocate_array_helper(const allocate_array_helper<A, T[N], U>& other) 
                 : allocator(other.allocator),
                   data(other.data) {
             }
+
             pointer address(reference value) const {
                 return allocator.address(value);
             }
+
             const_pointer address(const_reference value) const {
                 return allocator.address(value);
             }
+
             size_type max_size() const {
                 return allocator.max_size();
             }
+
             pointer allocate(size_type count, const void* value = 0) {
                 std::size_t a1 = boost::alignment_of<T>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
@@ -136,30 +162,37 @@ namespace boost {
                 *data = reinterpret_cast<T*>(p2);
                 return  reinterpret_cast<Y*>(p1);
             }
+
             void deallocate(pointer memory, size_type count) {
                 std::size_t a1 = boost::alignment_of<T>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
                 char*  p1 = reinterpret_cast<char*>(memory);
                 A3(allocator).deallocate(p1, n1 + N1);
             }
+
             void construct(pointer memory, const Y& value) {
                 allocator.construct(memory, value);
             }
+
             void destroy(pointer memory) {
                 allocator.destroy(memory);
             }
+
             template<typename U>
             bool operator==(const allocate_array_helper<A, T[N], U>& other) const {
                 return allocator == other.allocator;
             }
+
             template<typename U>
             bool operator!=(const allocate_array_helper<A, T[N], U>& other) const {
                 return !(*this == other); 
             }
+
         private:
             enum {
                 N1 = N * sizeof(T)
             };
+
             A2 allocator;
             T** data;
         };
diff --git a/include/boost/smart_ptr/detail/array_deleter.hpp b/include/boost/smart_ptr/detail/array_deleter.hpp
index 20f84d1..6db78c8 100644
--- a/include/boost/smart_ptr/detail/array_deleter.hpp
+++ b/include/boost/smart_ptr/detail/array_deleter.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License,
@@ -10,12 +10,12 @@
 #define BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP
 
 #include <boost/smart_ptr/detail/array_utility.hpp>
-#include <boost/smart_ptr/detail/sp_forward.hpp>
 
 namespace boost {
     namespace detail {
         template<typename T>
         class array_deleter;
+
         template<typename T>
         class array_deleter<T[]> {
         public:
@@ -23,98 +23,77 @@ namespace boost {
                 : size(size_),
                   object(0) {
             }
+
             ~array_deleter() {
                 if (object) {
                     array_destroy(object, size);
                 }
             }
+
             void init(T* memory) {
                 array_init(memory, size);
                 object = memory;
             }
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-            void init(T* memory, T&& value) {
-                array_init_value(memory, size, sp_forward<T>(value));
-                object = memory;                
-            }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-            template<typename... Args>
-            void init(T* memory, Args&&... args) {
-                array_init_args(memory, size, sp_forward<Args>(args)...);
-                object = memory;
-            }
-#endif
-#endif
-            void init_list(T* memory, const T* list) {
-                array_init_list(memory, size, list);
-                object = memory;
-            }
+
             template<std::size_t M>
-            void init_list(T* memory, const T* list) {
-                array_init_list<T, M>(memory, size, list);
+            void init(T* memory, const T* list) {
+                array_init<T, M>(memory, size, list);
                 object = memory;
             }
+
             void noinit(T* memory) {
                 array_noinit(memory, size);
                 object = memory;
             }
+
             void operator()(const void*) {
                 if (object) {
                     array_destroy(object, size);
                     object = 0;
                 }
             }
+
         private:
             std::size_t size;
             T* object;
         };
+
         template<typename T, std::size_t N>
         class array_deleter<T[N]> {
         public:
             array_deleter()
                 : object(0) {
             }
+
             ~array_deleter() {
                 if (object) {
                     array_destroy(object, N);
                 }
             }
+
             void init(T* memory) {
                 array_init(memory, N);
                 object = memory;
             }
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-            void init(T* memory, T&& value) {
-                array_init_value(memory, N, sp_forward<T>(value));
-                object = memory;                
-            }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-            template<typename... Args>
-            void init(T* memory, Args&&... args) {
-                array_init_args(memory, N, sp_forward<Args>(args)...);
-                object = memory;
-            }
-#endif
-#endif
-            void init_list(T* memory, const T* list) {
-                array_init_list(memory, N, list);
-                object = memory;
-            }
+
             template<std::size_t M>
-            void init_list(T* memory, const T* list) {
-                array_init_list<T, M>(memory, N, list);
+            void init(T* memory, const T* list) {
+                array_init<T, M>(memory, N, list);
                 object = memory;
             }
+
             void noinit(T* memory) {
                 array_noinit(memory, N);
                 object = memory;
             }
+
             void operator()(const void*) {
                 if (object) {
                     array_destroy(object, N);
                     object = 0;
                 }
             }
+
         private:
             T* object;
         };
diff --git a/include/boost/smart_ptr/detail/array_traits.hpp b/include/boost/smart_ptr/detail/array_traits.hpp
index 8ef7874..712efbb 100644
--- a/include/boost/smart_ptr/detail/array_traits.hpp
+++ b/include/boost/smart_ptr/detail/array_traits.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -17,32 +17,39 @@ namespace boost {
         struct array_base {
             typedef typename boost::remove_cv<T>::type type;
         };
+
         template<typename T>
         struct array_base<T[]> {
             typedef typename array_base<T>::type type;
         };
+
         template<typename T, std::size_t N>
         struct array_base<T[N]> {
             typedef typename array_base<T>::type type;
         };
+
         template<typename T>
         struct array_total {
             enum {
                 size = 1
             };
         };
+
         template<typename T, std::size_t N>
         struct array_total<T[N]> {
             enum {
                 size = N * array_total<T>::size
             };
         };
+
         template<typename T> 
         struct array_inner;
+
         template<typename T>
         struct array_inner<T[]> {
             typedef T type;
         };
+
         template<typename T, std::size_t N>
         struct array_inner<T[N]> {
             typedef T type;
diff --git a/include/boost/smart_ptr/detail/array_utility.hpp b/include/boost/smart_ptr/detail/array_utility.hpp
index 3cf36d7..cea2865 100644
--- a/include/boost/smart_ptr/detail/array_utility.hpp
+++ b/include/boost/smart_ptr/detail/array_utility.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -18,25 +18,30 @@ namespace boost {
         template<typename T>
         inline void array_destroy(T*, std::size_t, boost::true_type) {
         }
+
         template<typename T>
         inline void array_destroy(T* memory, std::size_t size, boost::false_type) {
             for (std::size_t i = size; i > 0; ) {
                 memory[--i].~T();
             }
         }
+
         template<typename T>
         inline void array_destroy(T* memory, std::size_t size) {
             boost::has_trivial_destructor<T> type;
             array_destroy(memory, size, type);
         }
+
         template<typename T>
-        inline void array_init(T* memory, std::size_t size, boost::true_type) {
+        inline void array_value(T* memory, std::size_t size, boost::true_type) {
             for (std::size_t i = 0; i < size; i++) {
-                memory[i] = T();
+                void* p1 = memory + i;
+                ::new(p1) T();
             }
         }
+        
         template<typename T>
-        inline void array_init(T* memory, std::size_t size, boost::false_type) {
+        inline void array_value(T* memory, std::size_t size, boost::false_type) {
 #if !defined(BOOST_NO_EXCEPTIONS)
             std::size_t i = 0;
             try {
@@ -55,77 +60,15 @@ namespace boost {
             }
 #endif
         }
+
         template<typename T>
         inline void array_init(T* memory, std::size_t size) {
             boost::has_trivial_default_constructor<T> type;            
-            array_init(memory, size, type);
-        }
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template<typename T>
-        inline void array_init_value(T* memory, std::size_t size, T&& value) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T(value);
-                }
-            } catch (...) {
-                array_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T(value);
-            }
-#endif
-        }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<typename T, typename... Args>
-        inline void array_init_args(T* memory, std::size_t size, Args&&... args) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T(args...);
-                }
-            } catch (...) {
-                array_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T(args...);
-            }
-#endif
-        }
-#endif
-#endif
-        template<typename T>
-        inline void array_init_list(T* memory, std::size_t size, const T* list) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T(list[i]);
-                }
-            } catch (...) {
-                array_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T(list[i]);
-            }
-#endif
+            array_value(memory, size, type);
         }
+
         template<typename T, std::size_t N>
-        inline void array_init_list(T* memory, std::size_t size, const T* list) {
+        inline void array_init(T* memory, std::size_t size, const T* list) {
 #if !defined(BOOST_NO_EXCEPTIONS)
             std::size_t i = 0;
             try {
@@ -144,11 +87,13 @@ namespace boost {
             }
 #endif
         }
+
         template<typename T>
-        inline void array_noinit(T*, std::size_t, boost::true_type) {
+        inline void array_default(T*, std::size_t, boost::true_type) {
         }
+
         template<typename T>
-        inline void array_noinit(T* memory, std::size_t size, boost::false_type) {
+        inline void array_default(T* memory, std::size_t size, boost::false_type) {
 #if !defined(BOOST_NO_EXCEPTIONS)
             std::size_t i = 0;
             try {
@@ -167,10 +112,11 @@ namespace boost {
             }
 #endif
         }
+
         template<typename T>
         inline void array_noinit(T* memory, std::size_t size) {
             boost::has_trivial_default_constructor<T> type;
-            array_noinit(memory, size, type);
+            array_default(memory, size, type);
         }
     }
 }
diff --git a/include/boost/smart_ptr/detail/make_array_helper.hpp b/include/boost/smart_ptr/detail/make_array_helper.hpp
index 6cf0483..cc1fc44 100644
--- a/include/boost/smart_ptr/detail/make_array_helper.hpp
+++ b/include/boost/smart_ptr/detail/make_array_helper.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2104 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -15,10 +15,12 @@ namespace boost {
     namespace detail {
         template<typename T, typename Y = char>
         class make_array_helper;
+
         template<typename T, typename Y>
         class make_array_helper<T[], Y> {
             template<typename T2, typename Y2>
             friend class make_array_helper;
+
         public:
             typedef Y           value_type;
             typedef Y*          pointer;
@@ -27,28 +29,35 @@ namespace boost {
             typedef const Y&    const_reference;
             typedef std::size_t size_type;
             typedef ptrdiff_t   difference_type;
+
             template<typename U>
             struct rebind {
                 typedef make_array_helper<T[], U> other;
             };
+
             make_array_helper(std::size_t size_, T** data_)
                 : size(sizeof(T) * size_),
                   data(data_) {
             }
+
             template<class U>
             make_array_helper(const make_array_helper<T[], U>& other) 
                 : size(other.size),
                   data(other.data) {
             }
+
             pointer address(reference value) const {
                 return &value;
             }
+
             const_pointer address(const_reference value) const {
                 return &value;
             }
+
             size_type max_size() const {
                 return static_cast<std::size_t>(-1) / sizeof(Y);
             }
+
             pointer allocate(size_type count, const void* = 0) {
                 std::size_t a1 = boost::alignment_of<T>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
@@ -60,33 +69,41 @@ namespace boost {
                 *data = reinterpret_cast<T*>(p2);
                 return  reinterpret_cast<Y*>(p1);
             }
+
             void deallocate(pointer memory, size_type) {
                 void* p1 = memory;
                 ::operator delete(p1);
             }
+
             void construct(pointer memory, const Y& value) {
                 void* p1 = memory;
                 ::new(p1) Y(value);
             }
+
             void destroy(pointer memory) {
                 memory->~Y();
             }
+
             template<typename U>
             bool operator==(const make_array_helper<T[], U>&) const {
                 return true;
             }
+
             template<typename U>
             bool operator!=(const make_array_helper<T[], U>& other) const {
                 return !(*this == other); 
             }
+
         private:
             std::size_t size;
             T** data;
         };
+
         template<typename T, std::size_t N, typename Y>
         class make_array_helper<T[N], Y> {
             template<typename T2, typename Y2>
             friend class make_array_helper;
+
         public:
             typedef Y           value_type;
             typedef Y*          pointer;
@@ -95,26 +112,33 @@ namespace boost {
             typedef const Y&    const_reference;
             typedef std::size_t size_type;
             typedef ptrdiff_t   difference_type;
+
             template<typename U>
             struct rebind {
                 typedef make_array_helper<T[N], U> other;
             };
+
             make_array_helper(T** data_)
                 : data(data_) {
             }
+
             template<class U>
             make_array_helper(const make_array_helper<T[N], U>& other) 
                 : data(other.data) {
             }
+
             pointer address(reference value) const {
                 return &value;
             }
+
             const_pointer address(const_reference value) const {
                 return &value;
             }
+
             size_type max_size() const {
                 return static_cast<std::size_t>(-1) / sizeof(Y);
             }
+
             pointer allocate(size_type count, const void* = 0) {
                 std::size_t a1 = boost::alignment_of<T>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
@@ -126,29 +150,36 @@ namespace boost {
                 *data = reinterpret_cast<T*>(p2);
                 return  reinterpret_cast<Y*>(p1);
             }
+
             void deallocate(pointer memory, size_type) {
                 void* p1 = memory;
                 ::operator delete(p1);
             }
+
             void construct(pointer memory, const Y& value) {
                 void* p1 = memory;
                 ::new(p1) Y(value);
             }
+
             void destroy(pointer memory) {
                 memory->~Y();
             }
+
             template<typename U>
             bool operator==(const make_array_helper<T[N], U>&) const {
                 return true;
             }
+
             template<typename U>
             bool operator!=(const make_array_helper<T[N], U>& other) const {
                 return !(*this == other); 
             }
+
         private:
             enum {
                 N1 = N * sizeof(T)
             };
+
             T** data;
         };
     }
diff --git a/include/boost/smart_ptr/detail/sp_if_array.hpp b/include/boost/smart_ptr/detail/sp_if_array.hpp
index 661e178..bbd0f3c 100644
--- a/include/boost/smart_ptr/detail/sp_if_array.hpp
+++ b/include/boost/smart_ptr/detail/sp_if_array.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -15,12 +15,15 @@ namespace boost {
     namespace detail {
         template<typename T> 
         struct sp_if_array;
+
         template<typename T>
         struct sp_if_array<T[]> {
             typedef boost::shared_ptr<T[]> type;
         };
+
         template<typename T>
         struct sp_if_size_array;
+
         template<typename T, std::size_t N>
         struct sp_if_size_array<T[N]> {
             typedef boost::shared_ptr<T[N]> type;
diff --git a/include/boost/smart_ptr/make_shared_array.hpp b/include/boost/smart_ptr/make_shared_array.hpp
index eb0578d..7dc952e 100644
--- a/include/boost/smart_ptr/make_shared_array.hpp
+++ b/include/boost/smart_ptr/make_shared_array.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License,
@@ -14,9 +14,6 @@
 #include <boost/smart_ptr/detail/array_traits.hpp>
 #include <boost/smart_ptr/detail/make_array_helper.hpp>
 #include <boost/smart_ptr/detail/sp_if_array.hpp>
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>
-#endif
 
 namespace boost {
     template<typename T>
@@ -36,67 +33,27 @@ namespace boost {
         d2->init(p2);
         return boost::shared_ptr<T>(s1, p1);
     }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template<typename T, typename... Args>
-    inline typename boost::detail::sp_if_array<T>::type
-    make_shared(std::size_t size, Args&&... args) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        std::size_t n1 = size * boost::detail::array_total<T1>::size;
-        boost::detail::make_array_helper<T2[]> a1(n1, &p2);
-        boost::detail::array_deleter<T2[]> d1(n1);
-        boost::shared_ptr<T> s1(p1, d1, a1);
-        typedef boost::detail::array_deleter<T2[]>* D2;
-        p1 = reinterpret_cast<T1*>(p2);
-        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init(p2, boost::detail::sp_forward<Args>(args)...);
-        return boost::shared_ptr<T>(s1, p1);
-    }
-    template<typename T, typename... Args>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    make_shared(Args&&... args) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        enum {
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        boost::detail::make_array_helper<T2[N]> a1(&p2);
-        boost::detail::array_deleter<T2[N]> d1;
-        boost::shared_ptr<T> s1(p1, d1, a1);
-        typedef boost::detail::array_deleter<T2[N]>* D2;
-        p1 = reinterpret_cast<T1*>(p2);
-        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init(p2, boost::detail::sp_forward<Args>(args)...);
-        return boost::shared_ptr<T>(s1, p1);
-    }
-#endif
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
+
     template<typename T>
     inline typename boost::detail::sp_if_size_array<T>::type
-    make_shared(const T& list) {
+    make_shared() {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
-        typedef const T2 T3;
         enum {
             N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
-        T3* p3 = 0;
         boost::detail::make_array_helper<T2[N]> a1(&p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
         typedef boost::detail::array_deleter<T2[N]>* D2;
-        p3 = reinterpret_cast<T3*>(list);
         p1 = reinterpret_cast<T1*>(p2);
         D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init_list(p2, p3);
+        d2->init(p2);
         return boost::shared_ptr<T>(s1, p1);
     }
+
     template<typename T>
     inline typename boost::detail::sp_if_array<T>::type
     make_shared(std::size_t size,
@@ -115,12 +72,13 @@ namespace boost {
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
         typedef boost::detail::array_deleter<T2[]>* D2;
-        p3 = reinterpret_cast<T3*>(list);
+        p3 = reinterpret_cast<T3*>(&list);
         p1 = reinterpret_cast<T1*>(p2);
         D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->template init_list<M>(p2, p3);
+        d2->template init<M>(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
+
     template<typename T>
     inline typename boost::detail::sp_if_size_array<T>::type
     make_shared(const typename boost::detail::array_inner<T>::type& list) {
@@ -138,74 +96,13 @@ namespace boost {
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
         typedef boost::detail::array_deleter<T2[N]>* D2;
-        p3 = reinterpret_cast<T3*>(list);
+        p3 = reinterpret_cast<T3*>(&list);
         p1 = reinterpret_cast<T1*>(p2);
         D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->template init_list<M>(p2, p3);
+        d2->template init<M>(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    template<typename T>
-    inline typename boost::detail::sp_if_array<T>::type
-    make_shared(std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef const T2 T3;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        T3* p3 = 0;
-        std::size_t n1 = list.size() * boost::detail::array_total<T1>::size;
-        boost::detail::make_array_helper<T2[]> a1(n1, &p2);
-        boost::detail::array_deleter<T2[]> d1(n1);
-        boost::shared_ptr<T> s1(p1, d1, a1);
-        typedef boost::detail::array_deleter<T2[]>* D2;
-        p3 = reinterpret_cast<T3*>(list.begin());
-        p1 = reinterpret_cast<T1*>(p2);
-        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init_list(p2, p3);
-        return boost::shared_ptr<T>(s1, p1);
-    }
-#endif
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template<typename T>
-    inline typename boost::detail::sp_if_array<T>::type
-    make_shared(std::size_t size,
-        typename boost::detail::array_base<T>::type&& value) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        std::size_t n1 = size * boost::detail::array_total<T1>::size;
-        boost::detail::make_array_helper<T2[]> a1(n1, &p2);
-        boost::detail::array_deleter<T2[]> d1(n1);
-        boost::shared_ptr<T> s1(p1, d1, a1);
-        typedef boost::detail::array_deleter<T2[]>* D2;
-        p1 = reinterpret_cast<T1*>(p2);
-        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init(p2, boost::detail::sp_forward<T2>(value));
-        return boost::shared_ptr<T>(s1, p1);
-    }
-    template<typename T>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    make_shared(typename boost::detail::array_base<T>::type&& value) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        enum {
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        boost::detail::make_array_helper<T2[N]> a1(&p2);
-        boost::detail::array_deleter<T2[N]> d1;
-        boost::shared_ptr<T> s1(p1, d1, a1);
-        typedef boost::detail::array_deleter<T2[N]>* D2;
-        p1 = reinterpret_cast<T1*>(p2);
-        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
-        d2->init(p2, boost::detail::sp_forward<T2>(value));
-        return boost::shared_ptr<T>(s1, p1);
-    }
-#endif
-#endif
+
     template<typename T>
     inline typename boost::detail::sp_if_array<T>::type
     make_shared_noinit(std::size_t size) {
@@ -223,6 +120,7 @@ namespace boost {
         d2->noinit(p2);
         return boost::shared_ptr<T>(s1, p1);
     }
+
     template<typename T>
     inline typename boost::detail::sp_if_size_array<T>::type
     make_shared_noinit() {
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index f90316e..60cf992 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -137,22 +137,16 @@ import testing ;
           [ compile-fail array_fail_array_access.cpp ]
 
           [ run make_shared_array_test.cpp ]
-          [ run make_shared_arrays_test.cpp ]
-          [ run make_shared_array_create_test.cpp ]
-          [ run make_shared_array_init_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
-          [ run make_shared_arrays_create_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
-          [ run make_shared_arrays_init_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
+          [ run make_shared_arrays_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
           [ run make_shared_array_throws_test.cpp ]
           [ run make_shared_array_esft_test.cpp ]
-          [ run make_shared_array_args_test.cpp ]
+          [ run make_shared_array_noinit_test.cpp ]
+          [ run make_shared_array_value_test.cpp ]
           [ run allocate_shared_array_test.cpp ]
-          [ run allocate_shared_arrays_test.cpp ]
-          [ run allocate_shared_array_create_test.cpp ]
-          [ run allocate_shared_array_init_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
-          [ run allocate_shared_arrays_create_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
-          [ run allocate_shared_arrays_init_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
+          [ run allocate_shared_arrays_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
           [ run allocate_shared_array_throws_test.cpp ]
           [ run allocate_shared_array_esft_test.cpp ]
-          [ run allocate_shared_array_args_test.cpp ]
+          [ run allocate_shared_array_noinit_test.cpp ]
+          [ run allocate_shared_array_value_test.cpp ]
         ;
 }
diff --git a/test/allocate_shared_array_args_test.cpp b/test/allocate_shared_array_args_test.cpp
deleted file mode 100644
index f3d38b6..0000000
--- a/test/allocate_shared_array_args_test.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-// allocate_shared_array_args_test.cpp
-//
-// Copyright 2007-2009, 2012 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
-#include <memory>
-#include <cstddef>
-
-class X
-{
-private:
-
-    X( X const & );
-    X & operator=( X const & );
-
-    void * operator new[]( std::size_t n );
-    void operator delete[]( void * p );
-
-public:
-
-    static int instances;
-
-    int v;
-
-    explicit X( int a1 = 0, int a2 = 0, int a3 = 0, int a4 = 0, int a5 = 0, int a6 = 0, int a7 = 0, int a8 = 0, int a9 = 0 ): v( a1+a2+a3+a4+a5+a6+a7+a8+a9 )
-    {
-        ++instances;
-    }
-
-    ~X()
-    {
-        --instances;
-    }
-};
-
-int X::instances = 0;
-
-int main()
-{
-    BOOST_TEST( X::instances == 0 );
-
-    {
-        boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 0 );
-        BOOST_TEST( px[1].v == 0 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    {
-        boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1 );
-        BOOST_TEST( px[1].v == 1 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2 );
-        BOOST_TEST( px[1].v == 1+2 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3 );
-        BOOST_TEST( px[1].v == 1+2+3 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4 );
-        BOOST_TEST( px[1].v == 1+2+3+4 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4, 5 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4+5 );
-        BOOST_TEST( px[1].v == 1+2+3+4+5 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4, 5, 6 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4+5+6 );
-        BOOST_TEST( px[1].v == 1+2+3+4+5+6 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4, 5, 6, 7 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4+5+6+7 );
-        BOOST_TEST( px[1].v == 1+2+3+4+5+6+7 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4, 5, 6, 7, 8 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4+5+6+7+8 );
-        BOOST_TEST( px[1].v == 1+2+3+4+5+6+7+8 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4, 5, 6, 7, 8, 9 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4+5+6+7+8+9 );
-        BOOST_TEST( px[1].v == 1+2+3+4+5+6+7+8+9 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-#endif
-
-    return boost::report_errors();
-}
diff --git a/test/allocate_shared_array_create_test.cpp b/test/allocate_shared_array_create_test.cpp
deleted file mode 100644
index 90b6b96..0000000
--- a/test/allocate_shared_array_create_test.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/allocate_shared_array.hpp>
-
-class type {
-public:
-    static int instances;
-    explicit type(int a=0, int b=0, int c=0, int d=0, int e=0, int f=0, int g=0, int h=0, int i=0)
-        : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h), i(i) {
-        instances++;
-    }
-    ~type() {
-        instances--;
-    }
-    const int a;
-    const int b;
-    const int c;
-    const int d;
-    const int e;
-    const int f;
-    const int g;
-    const int h;
-    const int i;
-private:
-    type(const type&);
-    type& operator=(const type&);
-};
-
-int type::instances = 0;
-
-int main() {
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 2, 1, 2, 3, 4, 5, 6, 7, 8, 9);
-        BOOST_TEST(type::instances == 2);
-        BOOST_TEST(a1[0].a == 1);
-        BOOST_TEST(a1[0].d == 4);
-        BOOST_TEST(a1[1].f == 6);
-        BOOST_TEST(a1[1].i == 9);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2]> a1 = boost::allocate_shared<type[2]>(std::allocator<type>(), 1, 2, 3, 4, 5, 6, 7, 8, 9);
-        BOOST_TEST(type::instances == 2);
-        BOOST_TEST(a1[0].a == 1);
-        BOOST_TEST(a1[0].d == 4);
-        BOOST_TEST(a1[1].f == 6);
-        BOOST_TEST(a1[1].i == 9);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[][2]> a1 = boost::allocate_shared<type[][2]>(std::allocator<type>(), 2, 1, 2, 3, 4, 5, 6, 7);
-        BOOST_TEST(type::instances == 4);
-        BOOST_TEST(a1[0][0].a == 1);
-        BOOST_TEST(a1[0][1].d == 4);
-        BOOST_TEST(a1[1][0].f == 6);
-        BOOST_TEST(a1[1][1].i == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2][2]> a1 = boost::allocate_shared<type[2][2]>(std::allocator<type>(), 1, 2, 3, 4, 5, 6, 7);
-        BOOST_TEST(type::instances == 4);
-        BOOST_TEST(a1[0][0].a == 1);
-        BOOST_TEST(a1[0][1].d == 4);
-        BOOST_TEST(a1[1][0].f == 6);
-        BOOST_TEST(a1[1][1].i == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[][2][2]> a1 = boost::allocate_shared<type[][2][2]>(std::allocator<type>(), 2, 1, 2, 3, 4, 5);
-        BOOST_TEST(type::instances == 8);
-        BOOST_TEST(a1[0][0][0].a == 1);
-        BOOST_TEST(a1[0][1][0].c == 3);
-        BOOST_TEST(a1[1][0][1].e == 5);
-        BOOST_TEST(a1[1][1][1].i == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2][2][2]> a1 = boost::allocate_shared<type[2][2][2]>(std::allocator<type>(), 1, 2, 3, 4, 5);
-        BOOST_TEST(type::instances == 8);
-        BOOST_TEST(a1[0][0][0].a == 1);
-        BOOST_TEST(a1[0][1][0].c == 3);
-        BOOST_TEST(a1[1][0][1].e == 5);
-        BOOST_TEST(a1[1][1][1].i == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[][2][2][2]> a1 = boost::allocate_shared<type[][2][2][2]>(std::allocator<type>(), 2, 1, 2, 3);
-        BOOST_TEST(type::instances == 16);
-        BOOST_TEST(a1[0][0][0][1].a == 1);
-        BOOST_TEST(a1[0][0][1][0].c == 3);
-        BOOST_TEST(a1[0][1][0][0].f == 0);
-        BOOST_TEST(a1[1][0][0][0].i == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2][2][2][2]> a1 = boost::allocate_shared<type[2][2][2][2]>(std::allocator<type>(), 1, 2, 3);
-        BOOST_TEST(type::instances == 16);
-        BOOST_TEST(a1[0][0][0][1].a == 1);
-        BOOST_TEST(a1[0][0][1][0].c == 3);
-        BOOST_TEST(a1[0][1][0][0].f == 0);
-        BOOST_TEST(a1[1][0][0][0].i == 0);
-    }
-#endif
-    return boost::report_errors();
-}
diff --git a/test/allocate_shared_array_esft_test.cpp b/test/allocate_shared_array_esft_test.cpp
index cea73c6..b342366 100644
--- a/test/allocate_shared_array_esft_test.cpp
+++ b/test/allocate_shared_array_esft_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -14,12 +14,15 @@ class type
     : public boost::enable_shared_from_this<type> {
 public:
     static unsigned int instances;
+
     explicit type() {
         instances++;
     }
+
     ~type() {
         instances--;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
@@ -38,6 +41,7 @@ int main() {
             BOOST_TEST(type::instances == 3);
         }
     }
+
     BOOST_TEST(type::instances == 0);
     {
         boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
@@ -48,5 +52,6 @@ int main() {
             BOOST_TEST(type::instances == 3);
         }
     }
+
     return boost::report_errors();
 }
diff --git a/test/allocate_shared_array_init_test.cpp b/test/allocate_shared_array_init_test.cpp
deleted file mode 100644
index c75b41f..0000000
--- a/test/allocate_shared_array_init_test.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/allocate_shared_array.hpp>
-
-class type {
-public:
-    type(int value) 
-        : value(value) {
-    }
-    const int value;
-private:
-    type& operator=(const type&);
-};
-
-int main() {
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
-    {
-        boost::shared_ptr<int[4]> a1 = boost::allocate_shared<int[4]>(std::allocator<int>(), { 0, 1, 2, 3 });
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-    {
-        boost::shared_ptr<const int[4]> a1 = boost::allocate_shared<const int[4]>(std::allocator<int>(), { 0, 1, 2, 3 });
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-    {
-        boost::shared_ptr<type[4]> a1 = boost::allocate_shared<type[4]>(std::allocator<type>(), { 0, 1, 2, 3 });
-        BOOST_TEST(a1[0].value == 0);
-        BOOST_TEST(a1[1].value == 1);
-        BOOST_TEST(a1[2].value == 2);
-        BOOST_TEST(a1[3].value == 3);
-    }
-    {
-        boost::shared_ptr<const type[4]> a1 = boost::allocate_shared<const type[4]>(std::allocator<type>(), { 0, 1, 2, 3 });
-        BOOST_TEST(a1[0].value == 0);
-        BOOST_TEST(a1[1].value == 1);
-        BOOST_TEST(a1[2].value == 2);
-        BOOST_TEST(a1[3].value == 3);
-    }
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    {
-        boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), { 0, 1, 2, 3 });
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-    {
-        boost::shared_ptr<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), { 0, 1, 2, 3 });
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-    {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), { 0, 1, 2, 3 });
-        BOOST_TEST(a1[0].value == 0);
-        BOOST_TEST(a1[1].value == 1);
-        BOOST_TEST(a1[2].value == 2);
-        BOOST_TEST(a1[3].value == 3);
-    }
-    {
-        boost::shared_ptr<const type[]> a1 = boost::allocate_shared<const type[]>(std::allocator<type>(), { 0, 1, 2, 3 });
-        BOOST_TEST(a1[0].value == 0);
-        BOOST_TEST(a1[1].value == 1);
-        BOOST_TEST(a1[2].value == 2);
-        BOOST_TEST(a1[3].value == 3);
-    }
-#endif
-#endif
-    return boost::report_errors();
-}
diff --git a/test/allocate_shared_array_noinit_test.cpp b/test/allocate_shared_array_noinit_test.cpp
new file mode 100644
index 0000000..6c8ff3d
--- /dev/null
+++ b/test/allocate_shared_array_noinit_test.cpp
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
+ * glenfe at live dot com
+ *
+ * Distributed under the Boost Software License, 
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt 
+ * or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/smart_ptr/allocate_shared_array.hpp>
+#include <boost/smart_ptr/weak_ptr.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+
+class type {
+public:
+    static unsigned int instances;
+
+    explicit type() {
+        instances++;
+    }
+
+    ~type() {
+        instances--;
+    }
+
+private:
+    type(const type&);
+    type& operator=(const type&);
+};
+
+unsigned int 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[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[][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][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<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[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[][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][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_TEST(type::instances == 0);
+    {
+        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_TEST(type::instances == 3);
+        boost::weak_ptr<type[]> w1 = a1;
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 3);
+        boost::weak_ptr<type[3]> w1 = a1;
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 3);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 3);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.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 f27e5e8..737e736 100644
--- a/test/allocate_shared_array_test.cpp
+++ b/test/allocate_shared_array_test.cpp
@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes
  * glenfe at live dot com
  *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
+ * Distributed under the Boost Software License,
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt
  * or copy at http://boost.org/LICENSE_1_0.txt)
- */
+*/
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/smart_ptr/allocate_shared_array.hpp>
 #include <boost/smart_ptr/weak_ptr.hpp>
@@ -14,17 +14,18 @@
 class type {
 public:
     static unsigned int instances;
-    explicit type(int = 0, int = 0)
-        : member() {
+
+    explicit type() {
         instances++;
     }
+
     ~type() {
         instances--;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
-    double member;
 };
 
 unsigned int type::instances = 0;
@@ -40,6 +41,38 @@ int main() {
         BOOST_TEST(a1[1] == 0);
         BOOST_TEST(a1[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[][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][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<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), 3);
         const int* a2 = a1.get();
@@ -50,6 +83,38 @@ int main() {
         BOOST_TEST(a1[1] == 0);
         BOOST_TEST(a1[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[][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][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_TEST(type::instances == 0);
     {
         boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 3);
@@ -62,6 +127,40 @@ int main() {
         a1.reset();
         BOOST_TEST(type::instances == 0);
     }
+
+    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_TEST(type::instances == 3);
+        boost::weak_ptr<type[3]> w1 = a1;
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
     BOOST_TEST(type::instances == 0);
     {
         boost::shared_ptr<const type[]> a1 = boost::allocate_shared<const type[]>(std::allocator<type>(), 3);
@@ -73,109 +172,10 @@ int main() {
         a1.reset();
         BOOST_TEST(type::instances == 0);
     }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
     BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 3, 1, 5);
-        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_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[3]> a1 = boost::allocate_shared<type[3]>(std::allocator<type>(), 1, 5);
-        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_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[]> a1 = boost::allocate_shared<const type[]>(std::allocator<type>(), 3, 1, 5);
-        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_TEST(type::instances == 3);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[3]> a1 = boost::allocate_shared<const type[3]>(std::allocator<type>(), 1, 5);
-        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_TEST(type::instances == 3);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-#endif
-    {
-        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[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<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[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_TEST(type::instances == 0);
-    {
-        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_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    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_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[]> a1 = boost::allocate_shared_noinit<const type[]>(std::allocator<type>(), 3);
+        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);
@@ -184,16 +184,26 @@ int main() {
         a1.reset();
         BOOST_TEST(type::instances == 0);
     }
+
     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::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_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
-        BOOST_TEST(type::instances == 3);
+        BOOST_TEST(type::instances == 4);
         a1.reset();
         BOOST_TEST(type::instances == 0);
     }
+
+    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_TEST(type::instances == 4);
+        a1.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 bb5ac52..79beaeb 100644
--- a/test/allocate_shared_array_throws_test.cpp
+++ b/test/allocate_shared_array_throws_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -12,15 +12,18 @@
 class type {
 public:
     static unsigned int instances;
+
     explicit type() {
         if (instances == 5) {
             throw true;
         }
         instances++;
     }
+
     ~type() {
         instances--;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
@@ -36,6 +39,7 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
+
     BOOST_TEST(type::instances == 0);
     try {
         boost::allocate_shared<type[][2]>(std::allocator<type>(), 3);
@@ -43,7 +47,7 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
     BOOST_TEST(type::instances == 0);
     try {
         boost::allocate_shared<type[6]>(std::allocator<type>());
@@ -51,6 +55,7 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
+
     BOOST_TEST(type::instances == 0);
     try {
         boost::allocate_shared<type[3][2]>(std::allocator<type>());
@@ -58,7 +63,7 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-#endif
+
     BOOST_TEST(type::instances == 0);
     try {
         boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 6);
@@ -66,6 +71,7 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
+
     BOOST_TEST(type::instances == 0);
     try {
         boost::allocate_shared_noinit<type[][2]>(std::allocator<type>(), 3);
@@ -73,5 +79,24 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
+
+    BOOST_TEST(type::instances == 0);
+    try {
+        boost::allocate_shared_noinit<type[6]>(std::allocator<type>());
+        BOOST_ERROR("allocate_shared_noinit did not throw");
+    }
+    catch (...) {
+        BOOST_TEST(type::instances == 0);
+    }
+
+    BOOST_TEST(type::instances == 0);
+    try {
+        boost::allocate_shared_noinit<type[3][2]>(std::allocator<type>());
+        BOOST_ERROR("allocate_shared_noinit did not throw");
+    }
+    catch (...) {
+        BOOST_TEST(type::instances == 0);
+    }
+
     return boost::report_errors();
 }
diff --git a/test/allocate_shared_array_value_test.cpp b/test/allocate_shared_array_value_test.cpp
new file mode 100644
index 0000000..c1b8b7c
--- /dev/null
+++ b/test/allocate_shared_array_value_test.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
+ * glenfe at live dot com
+ *
+ * Distributed under the Boost Software License, 
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt 
+ * or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/smart_ptr/allocate_shared_array.hpp>
+
+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[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<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[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);
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/allocate_shared_arrays_create_test.cpp b/test/allocate_shared_arrays_create_test.cpp
deleted file mode 100644
index a7e95d7..0000000
--- a/test/allocate_shared_arrays_create_test.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/allocate_shared_array.hpp>
-
-class type {
-public:
-    type(int x, int y) 
-        : x(x), y(y) {
-    }
-    const int x;
-    const int y;
-private:
-    type& operator=(const type&);
-};
-
-int main() {
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
-    {
-        boost::shared_ptr<int[4]> a1 = boost::allocate_shared<int[4]>(std::allocator<int>(), {0, 1, 2, 3});
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-    {
-        boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>(), { {0, 1}, {2, 3} });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 2);
-        BOOST_TEST(a1[1][1] == 3);
-    }
-    {
-        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][2]> a1 = boost::allocate_shared<int[][2][2]>(std::allocator<int>(), 2, { {0, 1}, {2, 3} });
-        BOOST_TEST(a1[0][0][0] == 0);
-        BOOST_TEST(a1[0][0][1] == 1);
-        BOOST_TEST(a1[1][1][0] == 2);
-        BOOST_TEST(a1[1][1][1] == 3);
-    }
-    {
-        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][2]> a1 = boost::allocate_shared<int[2][2][2]>(std::allocator<int>(), { {0, 1}, {2, 3} });
-        BOOST_TEST(a1[0][0][0] == 0);
-        BOOST_TEST(a1[0][0][1] == 1);
-        BOOST_TEST(a1[1][1][0] == 2);
-        BOOST_TEST(a1[1][1][1] == 3);
-    }
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    {
-        boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), {0, 1, 2, 3});
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-#endif
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    {
-        boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 4, {1, 2});
-        BOOST_TEST(a1[0].x == 1);
-        BOOST_TEST(a1[1].y == 2);
-        BOOST_TEST(a1[2].x == 1);
-        BOOST_TEST(a1[3].y == 2);
-    }
-    {
-        boost::shared_ptr<type[4]> a1 = boost::allocate_shared<type[4]>(std::allocator<type>(), {1, 2});
-        BOOST_TEST(a1[0].x == 1);
-        BOOST_TEST(a1[1].y == 2);
-        BOOST_TEST(a1[2].x == 1);
-        BOOST_TEST(a1[3].y == 2);
-    }
-#endif
-#endif
-    return boost::report_errors();
-}
diff --git a/test/allocate_shared_arrays_init_test.cpp b/test/allocate_shared_arrays_init_test.cpp
deleted file mode 100644
index 76173fa..0000000
--- a/test/allocate_shared_arrays_init_test.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/allocate_shared_array.hpp>
-
-int main() {
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    {
-        boost::shared_ptr<int[][2]> a1 = boost::allocate_shared<int[][2]>(std::allocator<int>(), { {0, 1}, {2, 3} });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 2);
-        BOOST_TEST(a1[1][1] == 3);
-    }
-#endif
-    return boost::report_errors();
-}
diff --git a/test/allocate_shared_arrays_test.cpp b/test/allocate_shared_arrays_test.cpp
index c0746d3..9dfc866 100644
--- a/test/allocate_shared_arrays_test.cpp
+++ b/test/allocate_shared_arrays_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -9,152 +9,40 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/smart_ptr/allocate_shared_array.hpp>
 
-class type {
-public:
-    static unsigned int instances;
-    explicit type(int = 0, int = 0)
-        : member() {
-        instances++;
-    }
-    ~type() {
-        instances--;
-    }
-private:
-    type(const type&);
-    type& operator=(const type&);
-    double member;
-};
-
-unsigned int type::instances = 0;
-
 int main() {
+#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
     {
-        boost::shared_ptr<int[][2][2]> a1 = boost::allocate_shared<int[][2][2]>(std::allocator<int>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0][1] == 0);
-        BOOST_TEST(a1[0][1][0] == 0);
-        BOOST_TEST(a1[1][0][0] == 0);
+        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<const int[][2][2]> a1 = boost::allocate_shared<const int[][2][2]>(std::allocator<int>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0][1] == 0);
-        BOOST_TEST(a1[0][1][0] == 0);
-        BOOST_TEST(a1[1][0][0] == 0);
+        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_TEST(type::instances == 0);
+
     {
-        boost::shared_ptr<type[][2][2]> a1 = boost::allocate_shared<type[][2][2]>(std::allocator<type>(), 2);
-        BOOST_TEST(a1.get() != 0);        
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
+        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_TEST(type::instances == 0);
+
     {
-        boost::shared_ptr<const type[][2][2]> a1 = boost::allocate_shared<const type[][2][2]>(std::allocator<type>(), 2);
-        BOOST_TEST(a1.get() != 0);        
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[][2][2]> a1 = boost::allocate_shared<type[][2][2]>(std::allocator<type>(), 2, 1, 5);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2][2][2]> a1 = boost::allocate_shared<type[2][2][2]>(std::allocator<type>(), 1, 5);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[][2][2]> a1 = boost::allocate_shared<const type[][2][2]>(std::allocator<type>(), 2, 1, 5);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[2][2][2]> a1 = boost::allocate_shared<const type[2][2][2]>(std::allocator<type>(), 1, 5);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
+        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);
     }
 #endif
-    {
-        boost::shared_ptr<int[][2][2]> a1 = boost::allocate_shared_noinit<int[][2][2]>(std::allocator<int>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-    }
-    {
-        boost::shared_ptr<int[2][2][2]> a1 = boost::allocate_shared_noinit<int[2][2][2]>(std::allocator<int>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-    }    
-    {
-        boost::shared_ptr<const int[][2][2]> a1 = boost::allocate_shared_noinit<const int[][2][2]>(std::allocator<int>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-    }
-    {
-        boost::shared_ptr<const int[2][2][2]> a1 = boost::allocate_shared_noinit<const int[2][2][2]>(std::allocator<int>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-    }    
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[][2][2]> a1 = boost::allocate_shared_noinit<type[][2][2]>(std::allocator<type>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2][2][2]> a1 = boost::allocate_shared_noinit<type[2][2][2]>(std::allocator<type>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[][2][2]> a1 = boost::allocate_shared_noinit<const type[][2][2]>(std::allocator<type>(), 2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[2][2][2]> a1 = boost::allocate_shared_noinit<const type[2][2][2]>(std::allocator<type>());
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
+
     return boost::report_errors();
 }
diff --git a/test/make_shared_array_args_test.cpp b/test/make_shared_array_args_test.cpp
deleted file mode 100644
index 8a89429..0000000
--- a/test/make_shared_array_args_test.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-// make_shared_array_args_test.cpp
-//
-// Copyright 2007-2009, 2012 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
-#include <cstddef>
-
-class X
-{
-private:
-
-    X( X const & );
-    X & operator=( X const & );
-
-    void * operator new[]( std::size_t n );
-    void operator delete[]( void * p );
-
-public:
-
-    static int instances;
-
-    int v;
-
-    explicit X( int a1 = 0, int a2 = 0, int a3 = 0, int a4 = 0, int a5 = 0, int a6 = 0, int a7 = 0, int a8 = 0, int a9 = 0 ): v( a1+a2+a3+a4+a5+a6+a7+a8+a9 )
-    {
-        ++instances;
-    }
-
-    ~X()
-    {
-        --instances;
-    }
-};
-
-int X::instances = 0;
-
-int main()
-{
-    BOOST_TEST( X::instances == 0 );
-
-    {
-        boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 0 );
-        BOOST_TEST( px[1].v == 0 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    {
-        boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1 );
-        BOOST_TEST( px[1].v == 1 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2 );
-        BOOST_TEST( px[1].v == 1+2 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3 );
-        BOOST_TEST( px[1].v == 1+2+3 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4 );
-        BOOST_TEST( px[1].v == 1+2+3+4 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4, 5 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4+5 );
-        BOOST_TEST( px[1].v == 1+2+3+4+5 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4, 5, 6 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4+5+6 );
-        BOOST_TEST( px[1].v == 1+2+3+4+5+6 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4, 5, 6, 7 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4+5+6+7 );
-        BOOST_TEST( px[1].v == 1+2+3+4+5+6+7 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4, 5, 6, 7, 8 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4+5+6+7+8 );
-        BOOST_TEST( px[1].v == 1+2+3+4+5+6+7+8 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-    {
-        boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4, 5, 6, 7, 8, 9 );
-
-        BOOST_TEST( X::instances == 2 );
-        BOOST_TEST( px[0].v == 1+2+3+4+5+6+7+8+9 );
-        BOOST_TEST( px[1].v == 1+2+3+4+5+6+7+8+9 );
-
-        px.reset();
-
-        BOOST_TEST( X::instances == 0 );
-    }
-
-#endif
-
-    return boost::report_errors();
-}
diff --git a/test/make_shared_array_create_test.cpp b/test/make_shared_array_create_test.cpp
deleted file mode 100644
index 0bdd635..0000000
--- a/test/make_shared_array_create_test.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared_array.hpp>
-
-class type {
-public:
-    static int instances;
-    explicit type(int a=0, int b=0, int c=0, int d=0, int e=0, int f=0, int g=0, int h=0, int i=0)
-        : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h), i(i) {
-        instances++;
-    }
-    ~type() {
-        instances--;
-    }
-    const int a;
-    const int b;
-    const int c;
-    const int d;
-    const int e;
-    const int f;
-    const int g;
-    const int h;
-    const int i;
-private:
-    type(const type&);
-    type& operator=(const type&);
-};
-
-int type::instances = 0;
-
-int main() {
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(2, 1, 2, 3, 4, 5, 6, 7, 8, 9);
-        BOOST_TEST(type::instances == 2);
-        BOOST_TEST(a1[0].a == 1);
-        BOOST_TEST(a1[0].d == 4);
-        BOOST_TEST(a1[1].f == 6);
-        BOOST_TEST(a1[1].i == 9);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2]> a1 = boost::make_shared<type[2]>(1, 2, 3, 4, 5, 6, 7, 8, 9);
-        BOOST_TEST(type::instances == 2);
-        BOOST_TEST(a1[0].a == 1);
-        BOOST_TEST(a1[0].d == 4);
-        BOOST_TEST(a1[1].f == 6);
-        BOOST_TEST(a1[1].i == 9);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[][2]> a1 = boost::make_shared<type[][2]>(2, 1, 2, 3, 4, 5, 6, 7);
-        BOOST_TEST(type::instances == 4);
-        BOOST_TEST(a1[0][0].a == 1);
-        BOOST_TEST(a1[0][1].d == 4);
-        BOOST_TEST(a1[1][0].f == 6);
-        BOOST_TEST(a1[1][1].i == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2][2]> a1 = boost::make_shared<type[2][2]>(1, 2, 3, 4, 5, 6, 7);
-        BOOST_TEST(type::instances == 4);
-        BOOST_TEST(a1[0][0].a == 1);
-        BOOST_TEST(a1[0][1].d == 4);
-        BOOST_TEST(a1[1][0].f == 6);
-        BOOST_TEST(a1[1][1].i == 0);
-    }    
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[][2][2]> a1 = boost::make_shared<type[][2][2]>(2, 1, 2, 3, 4, 5);
-        BOOST_TEST(type::instances == 8);
-        BOOST_TEST(a1[0][0][0].a == 1);
-        BOOST_TEST(a1[0][1][0].c == 3);
-        BOOST_TEST(a1[1][0][1].e == 5);
-        BOOST_TEST(a1[1][1][1].i == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2][2][2]> a1 = boost::make_shared<type[2][2][2]>(1, 2, 3, 4, 5);
-        BOOST_TEST(type::instances == 8);
-        BOOST_TEST(a1[0][0][0].a == 1);
-        BOOST_TEST(a1[0][1][0].c == 3);
-        BOOST_TEST(a1[1][0][1].e == 5);
-        BOOST_TEST(a1[1][1][1].i == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[][2][2][2]> a1 = boost::make_shared<type[][2][2][2]>(2, 1, 2, 3);
-        BOOST_TEST(type::instances == 16);
-        BOOST_TEST(a1[0][0][0][1].a == 1);
-        BOOST_TEST(a1[0][0][1][0].c == 3);
-        BOOST_TEST(a1[0][1][0][0].f == 0);
-        BOOST_TEST(a1[1][0][0][0].i == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2][2][2][2]> a1 = boost::make_shared<type[2][2][2][2]>(1, 2, 3);
-        BOOST_TEST(type::instances == 16);
-        BOOST_TEST(a1[0][0][0][1].a == 1);
-        BOOST_TEST(a1[0][0][1][0].c == 3);
-        BOOST_TEST(a1[0][1][0][0].f == 0);
-        BOOST_TEST(a1[1][0][0][0].i == 0);
-    }
-#endif
-    return boost::report_errors();
-}
diff --git a/test/make_shared_array_esft_test.cpp b/test/make_shared_array_esft_test.cpp
index 9d0adb1..a93f760 100644
--- a/test/make_shared_array_esft_test.cpp
+++ b/test/make_shared_array_esft_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -14,12 +14,15 @@ class type
     : public boost::enable_shared_from_this<type> {
 public:
     static unsigned int instances;
+
     explicit type() {
         instances++;
     }
+
     ~type() {
         instances--;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
@@ -38,6 +41,7 @@ int main() {
             BOOST_TEST(type::instances == 3);
         }
     }
+
     BOOST_TEST(type::instances == 0);
     {
         boost::shared_ptr<type[]> a1 = boost::make_shared_noinit<type[]>(3);
@@ -48,5 +52,6 @@ int main() {
             BOOST_TEST(type::instances == 3);
         }
     }
+
     return boost::report_errors();
 }
diff --git a/test/make_shared_array_init_test.cpp b/test/make_shared_array_init_test.cpp
deleted file mode 100644
index 11dcb1c..0000000
--- a/test/make_shared_array_init_test.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared_array.hpp>
-
-class type {
-public:
-    type(int value) 
-        : value(value) {
-    }
-    const int value;
-private:    
-    type& operator=(const type&);
-};
-
-int main() {
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
-    {
-        boost::shared_ptr<int[4]> a1 = boost::make_shared<int[4]>({ 0, 1, 2, 3 });
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-    {
-        boost::shared_ptr<const int[4]> a1 = boost::make_shared<const int[4]>({ 0, 1, 2, 3 });
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-    {
-        boost::shared_ptr<type[4]> a1 = boost::make_shared<type[4]>({ 0, 1, 2, 3 });
-        BOOST_TEST(a1[0].value == 0);
-        BOOST_TEST(a1[1].value == 1);
-        BOOST_TEST(a1[2].value == 2);
-        BOOST_TEST(a1[3].value == 3);
-    }
-    {
-        boost::shared_ptr<const type[4]> a1 = boost::make_shared<const type[4]>({ 0, 1, 2, 3 });
-        BOOST_TEST(a1[0].value == 0);
-        BOOST_TEST(a1[1].value == 1);
-        BOOST_TEST(a1[2].value == 2);
-        BOOST_TEST(a1[3].value == 3);
-    }
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    {
-        boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>({ 0, 1, 2, 3 });
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-    {
-        boost::shared_ptr<const int[]> a1 = boost::make_shared<const int[]>({ 0, 1, 2, 3 });
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-    {
-        boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>({ 0, 1, 2, 3 });
-        BOOST_TEST(a1[0].value == 0);
-        BOOST_TEST(a1[1].value == 1);
-        BOOST_TEST(a1[2].value == 2);
-        BOOST_TEST(a1[3].value == 3);
-    }
-    {
-        boost::shared_ptr<const type[]> a1 = boost::make_shared<const type[]>({ 0, 1, 2, 3 });
-        BOOST_TEST(a1[0].value == 0);
-        BOOST_TEST(a1[1].value == 1);
-        BOOST_TEST(a1[2].value == 2);
-        BOOST_TEST(a1[3].value == 3);
-    }
-#endif
-#endif
-    return boost::report_errors();
-}
diff --git a/test/make_shared_array_noinit_test.cpp b/test/make_shared_array_noinit_test.cpp
new file mode 100644
index 0000000..98bd450
--- /dev/null
+++ b/test/make_shared_array_noinit_test.cpp
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
+ * glenfe at live dot com
+ *
+ * Distributed under the Boost Software License, 
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt 
+ * or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared_array.hpp>
+#include <boost/smart_ptr/weak_ptr.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+
+class type {
+public:
+    static unsigned int instances;
+
+    explicit type() {
+        instances++;
+    }
+
+    ~type() {
+        instances--;
+    }
+
+private:
+    type(const type&);
+    type& operator=(const type&);
+};
+
+unsigned int 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[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[][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]> a1 = boost::make_shared_noinit<int[2][2]>();
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+    }
+
+    {
+        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[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[][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]> a1 = boost::make_shared_noinit<const int[2][2]>();
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+    }
+
+    BOOST_TEST(type::instances == 0);
+    {
+        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_TEST(type::instances == 3);
+        boost::weak_ptr<type[]> w1 = a1;
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 3);
+        boost::weak_ptr<type[3]> w1 = a1;
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 3);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 3);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.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 8193553..ebb76c7 100644
--- a/test/make_shared_array_test.cpp
+++ b/test/make_shared_array_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -14,17 +14,18 @@
 class type {
 public:
     static unsigned int instances;
-    explicit type(int = 0, int = 0)
-        : member() {
+
+    explicit type() {
         instances++;
     }
+
     ~type() {
         instances--;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
-    double member;
 };
 
 unsigned int type::instances = 0;
@@ -40,6 +41,38 @@ int main() {
         BOOST_TEST(a1[1] == 0);
         BOOST_TEST(a1[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[][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]> 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<const int[]> a1 = boost::make_shared<const int[]>(3);
         const int* a2 = a1.get();
@@ -50,6 +83,38 @@ int main() {
         BOOST_TEST(a1[1] == 0);
         BOOST_TEST(a1[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[][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]> 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_TEST(type::instances == 0);
     {
         boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(3);
@@ -62,6 +127,40 @@ int main() {
         a1.reset();
         BOOST_TEST(type::instances == 0);
     }
+
+    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_TEST(type::instances == 3);
+        boost::weak_ptr<type[3]> w1 = a1;
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
+    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_TEST(type::instances == 4);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+
     BOOST_TEST(type::instances == 0);
     {
         boost::shared_ptr<const type[]> a1 = boost::make_shared<const type[]>(3);
@@ -73,109 +172,10 @@ int main() {
         a1.reset();
         BOOST_TEST(type::instances == 0);
     }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
     BOOST_TEST(type::instances == 0);
     {
-        boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(3, 1, 5);
-        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_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[3]> a1 = boost::make_shared<type[3]>(1, 5);
-        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_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[]> a1 = boost::make_shared<const type[]>(3, 1, 5);
-        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_TEST(type::instances == 3);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[3]> a1 = boost::make_shared<const type[3]>(1, 5);
-        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_TEST(type::instances == 3);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-#endif
-    {
-        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[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<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[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_TEST(type::instances == 0);
-    {
-        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_TEST(type::instances == 3);
-        boost::weak_ptr<type[]> w1 = a1;
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    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_TEST(type::instances == 3);
-        boost::weak_ptr<type[3]> w1 = a1;
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[]> a1 = boost::make_shared_noinit<const type[]>(3);
+        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);
@@ -184,16 +184,26 @@ int main() {
         a1.reset();
         BOOST_TEST(type::instances == 0);
     }
+
     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::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_TEST(a2 != 0);
-        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
-        BOOST_TEST(type::instances == 3);
+        BOOST_TEST(type::instances == 4);
         a1.reset();
         BOOST_TEST(type::instances == 0);
     }
+
+    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_TEST(type::instances == 4);
+        a1.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 69e9b88..98d6ea7 100644
--- a/test/make_shared_array_throws_test.cpp
+++ b/test/make_shared_array_throws_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -12,15 +12,18 @@
 class type {
 public:
     static unsigned int instances;
+
     explicit type() {
         if (instances == 5) {
             throw true;
         }
         instances++;
     }
+
     ~type() {
         instances--;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
@@ -36,6 +39,7 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
+
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_shared<type[][2]>(3);
@@ -43,7 +47,7 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_shared<type[6]>();
@@ -51,6 +55,7 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
+
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_shared<type[3][2]>();
@@ -58,7 +63,7 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
-#endif
+
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_shared_noinit<type[]>(6);
@@ -66,6 +71,7 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
+
     BOOST_TEST(type::instances == 0);
     try {
         boost::make_shared_noinit<type[][2]>(3);
@@ -73,5 +79,24 @@ int main() {
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
+
+    BOOST_TEST(type::instances == 0);
+    try {
+        boost::make_shared_noinit<type[6]>();
+        BOOST_ERROR("make_shared_noinit did not throw");
+    }
+    catch (...) {
+        BOOST_TEST(type::instances == 0);
+    }
+
+    BOOST_TEST(type::instances == 0);
+    try {
+        boost::make_shared_noinit<type[3][2]>();
+        BOOST_ERROR("make_shared_noinit did not throw");
+    }
+    catch (...) {
+        BOOST_TEST(type::instances == 0);
+    }
+
     return boost::report_errors();
 }
diff --git a/test/make_shared_array_value_test.cpp b/test/make_shared_array_value_test.cpp
new file mode 100644
index 0000000..f042ede
--- /dev/null
+++ b/test/make_shared_array_value_test.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
+ * glenfe at live dot com
+ *
+ * Distributed under the Boost Software License, 
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt 
+ * or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/smart_ptr/make_shared_array.hpp>
+
+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[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<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[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);
+    }
+
+    return boost::report_errors();
+}
diff --git a/test/make_shared_arrays_create_test.cpp b/test/make_shared_arrays_create_test.cpp
deleted file mode 100644
index c6a1b4f..0000000
--- a/test/make_shared_arrays_create_test.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared_array.hpp>
-
-class type {
-public:
-    type(int x, int y) 
-        : x(x), y(y) {
-    }
-    const int x;
-    const int y;
-private:
-    type& operator=(const type&);
-};
-
-int main() {
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
-    {
-        boost::shared_ptr<int[4]> a1 = boost::make_shared<int[4]>({0, 1, 2, 3});
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-    {
-        boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>({ {0, 1}, {2, 3} });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 2);
-        BOOST_TEST(a1[1][1] == 3);
-    }
-    {
-        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][2]> a1 = boost::make_shared<int[][2][2]>(2, { {0, 1}, {2, 3} });
-        BOOST_TEST(a1[0][0][0] == 0);
-        BOOST_TEST(a1[0][0][1] == 1);
-        BOOST_TEST(a1[1][1][0] == 2);
-        BOOST_TEST(a1[1][1][1] == 3);
-    }
-    {
-        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][2]> a1 = boost::make_shared<int[2][2][2]>({ {0, 1}, {2, 3} });
-        BOOST_TEST(a1[0][0][0] == 0);
-        BOOST_TEST(a1[0][0][1] == 1);
-        BOOST_TEST(a1[1][1][0] == 2);
-        BOOST_TEST(a1[1][1][1] == 3);
-    }
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    {
-        boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>({0, 1, 2, 3});
-        BOOST_TEST(a1[0] == 0);
-        BOOST_TEST(a1[1] == 1);
-        BOOST_TEST(a1[2] == 2);
-        BOOST_TEST(a1[3] == 3);
-    }
-#endif
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    {
-        boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(4, {1, 2});
-        BOOST_TEST(a1[0].x == 1);
-        BOOST_TEST(a1[1].y == 2);
-        BOOST_TEST(a1[2].x == 1);
-        BOOST_TEST(a1[3].y == 2);
-    }
-    {
-        boost::shared_ptr<type[4]> a1 = boost::make_shared<type[4]>({1, 2});
-        BOOST_TEST(a1[0].x == 1);
-        BOOST_TEST(a1[1].y == 2);
-        BOOST_TEST(a1[2].x == 1);
-        BOOST_TEST(a1[3].y == 2);
-    }
-#endif
-#endif
-    return boost::report_errors();
-}
diff --git a/test/make_shared_arrays_init_test.cpp b/test/make_shared_arrays_init_test.cpp
deleted file mode 100644
index 1646d5a..0000000
--- a/test/make_shared_arrays_init_test.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) 2012 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/smart_ptr/make_shared_array.hpp>
-
-int main() {
-#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-    {
-        boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>({ {0, 1}, {2, 3} });
-        BOOST_TEST(a1[0][0] == 0);
-        BOOST_TEST(a1[0][1] == 1);
-        BOOST_TEST(a1[1][0] == 2);
-        BOOST_TEST(a1[1][1] == 3);
-    }
-#endif
-    return boost::report_errors();
-}
diff --git a/test/make_shared_arrays_test.cpp b/test/make_shared_arrays_test.cpp
index e03a13c..b905a83 100644
--- a/test/make_shared_arrays_test.cpp
+++ b/test/make_shared_arrays_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012-2014 Glen Joseph Fernandes 
  * glenfe at live dot com
  *
  * Distributed under the Boost Software License, 
@@ -9,152 +9,40 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared_array.hpp>
 
-class type {
-public:
-    static unsigned int instances;
-    explicit type(int = 0, int = 0)
-        : member() {
-        instances++;
-    }
-    ~type() {
-        instances--;
-    }
-private:
-    type(const type&);
-    type& operator=(const type&);
-    double member;
-};
-
-unsigned int type::instances = 0;
-
 int main() {
+#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
     {
-        boost::shared_ptr<int[][2][2]> a1 = boost::make_shared<int[][2][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0][1] == 0);
-        BOOST_TEST(a1[0][1][0] == 0);
-        BOOST_TEST(a1[1][0][0] == 0);
-    }    
-    {
-        boost::shared_ptr<const int[][2][2]> a1 = boost::make_shared<const int[][2][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(a1[0][0][1] == 0);
-        BOOST_TEST(a1[0][1][0] == 0);
-        BOOST_TEST(a1[1][0][0] == 0);
-    }    
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[][2][2]> a1 = boost::make_shared<type[][2][2]>(2);
-        BOOST_TEST(a1.get() != 0);        
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }    
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[][2][2]> a1 = boost::make_shared<const type[][2][2]>(2);
-        BOOST_TEST(a1.get() != 0);        
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
+        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);
     }
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    BOOST_TEST(type::instances == 0);
+
     {
-        boost::shared_ptr<type[][2][2]> a1 = boost::make_shared<type[][2][2]>(2, 1, 5);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
+        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_TEST(type::instances == 0);
+
     {
-        boost::shared_ptr<type[2][2][2]> a1 = boost::make_shared<type[2][2][2]>(1, 5);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
+        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_TEST(type::instances == 0);
+
     {
-        boost::shared_ptr<const type[][2][2]> a1 = boost::make_shared<const type[][2][2]>(2, 1, 5);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[2][2][2]> a1 = boost::make_shared<const type[2][2][2]>(1, 5);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
+        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);
     }
 #endif
-    {
-        boost::shared_ptr<int[][2][2]> a1 = boost::make_shared_noinit<int[][2][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-    }
-    {
-        boost::shared_ptr<int[2][2][2]> a1 = boost::make_shared_noinit<int[2][2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-    }    
-    {
-        boost::shared_ptr<const int[][2][2]> a1 = boost::make_shared_noinit<const int[][2][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-    }
-    {
-        boost::shared_ptr<const int[2][2][2]> a1 = boost::make_shared_noinit<const int[2][2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-    }    
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[][2][2]> a1 = boost::make_shared_noinit<type[][2][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<type[2][2][2]> a1 = boost::make_shared_noinit<type[2][2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[][2][2]> a1 = boost::make_shared_noinit<const type[][2][2]>(2);
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
-    BOOST_TEST(type::instances == 0);
-    {
-        boost::shared_ptr<const type[2][2][2]> a1 = boost::make_shared_noinit<const type[2][2][2]>();
-        BOOST_TEST(a1.get() != 0);
-        BOOST_TEST(a1.use_count() == 1);
-        BOOST_TEST(type::instances == 8);
-        a1.reset();
-        BOOST_TEST(type::instances == 0);
-    }
+
     return boost::report_errors();
 }