Revert unit tests to use automatic allocation

include/boost/align/aligned_allocator.hpp

@@ -78,14 +78,14 @@ class aligned_allocator {
         if (size > 0) {
             p = aligned_alloc(min_align, sizeof(T) * size);
             if (!p) {
-                ::boost::throw_exception(std::bad_alloc());
+                boost::throw_exception(std::bad_alloc());
             }
         }
         return static_cast<T*>(p);
     }
 
     void deallocate(pointer ptr, size_type) {
-        ::boost::alignment::aligned_free(ptr);
+        boost::alignment::aligned_free(ptr);
     }
 
     BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT {

include/boost/align/aligned_allocator_adaptor.hpp

@@ -1,5 +1,5 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
+(c) 2014-2016 Glen Joseph Fernandes
 <glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
@@ -123,8 +123,7 @@ class aligned_allocator_adaptor
         char_ptr p = a.allocate(sizeof p + n);
         void* r = detail::addressof(*p) + sizeof p;
         (void)align(min_align, s, r, n);
-        ::new(static_cast<void*>(static_cast<char_ptr*>(r) -
-            1)) char_ptr(p);
+        ::new((void*)(static_cast<char_ptr*>(r) - 1)) char_ptr(p);
         return static_cast<pointer>(r);
     }
 
@@ -143,13 +142,12 @@ class aligned_allocator_adaptor
 #endif
         void* r = detail::addressof(*p) + sizeof p;
         (void)align(min_align, s, r, n);
-        ::new(static_cast<void*>(static_cast<char_ptr*>(r) -
-            1)) char_ptr(p);
+        ::new((void*)(static_cast<char_ptr*>(r) - 1)) char_ptr(p);
         return static_cast<pointer>(r);
     }
 
     void deallocate(pointer ptr, size_type size) {
-        char_ptr* p = reinterpret_cast<char_ptr*>(ptr) - 1;
+        char_ptr* p = (char_ptr*)ptr - 1;
         char_ptr r = *p;
         p->~char_ptr();
         char_alloc a(base());

include/boost/align/aligned_delete.hpp

@@ -21,7 +21,7 @@ struct aligned_delete {
         BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(ptr->~T())) {
         if (ptr) {
             ptr->~T();
-            ::boost::alignment::aligned_free(ptr);
+            boost::alignment::aligned_free(ptr);
         }
     }
 };

include/boost/align/alignment_of.hpp

@@ -1,5 +1,5 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
+(c) 2014-2016 Glen Joseph Fernandes
 <glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
@@ -39,8 +39,7 @@ namespace alignment {
 
 template<class T>
 struct alignment_of
-    : detail::alignment_of<typename
-        detail::element_type<T>::type>::type { };
+    : detail::alignment_of<typename detail::element_type<T>::type> { };
 
 #if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
 template<class T>

include/boost/align/detail/align.hpp

@@ -1,5 +1,5 @@
 /*
-(c) 2014 Glen Joseph Fernandes
+(c) 2014-2016 Glen Joseph Fernandes
 <glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
@@ -20,12 +20,12 @@ inline void* align(std::size_t alignment, std::size_t size,
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
     if (size <= space) {
-        char* p = reinterpret_cast<char*>((reinterpret_cast<std::
-            size_t>(ptr) + alignment - 1) & ~(alignment - 1));
-        std::ptrdiff_t n = p - static_cast<char*>(ptr);
-        if (size <= space - n) {
+        char* p = (char*)(((std::size_t)ptr + alignment - 1) &
+            ~(alignment - 1));
+        std::size_t n = space - (p - static_cast<char*>(ptr));
+        if (size <= n) {
             ptr = p;
-            space -= n;
+            space = n;
             return p;
         }
     }

include/boost/align/detail/align_down.hpp

@@ -19,8 +19,7 @@ namespace alignment {
 inline void* align_down(void* ptr, std::size_t alignment) BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
-    return reinterpret_cast<void*>(align_down(reinterpret_cast<std::
-        size_t>(ptr), alignment));
+    return (void*)(align_down((std::size_t)ptr, alignment));
 }
 
 } /* .alignment */

include/boost/align/detail/align_up.hpp

@@ -19,8 +19,7 @@ namespace alignment {
 inline void* align_up(void* ptr, std::size_t alignment) BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
-    return reinterpret_cast<void*>(align_up(reinterpret_cast<std::
-        size_t>(ptr), alignment));
+    return (void*)(align_up((std::size_t)ptr, alignment));
 }
 
 } /* .alignment */

include/boost/align/detail/alignment_of.hpp

@@ -23,8 +23,7 @@ struct alignof_helper {
 
 template<class T>
 struct alignment_of
-    : min_size<sizeof(T),
-        sizeof(alignof_helper<T>) - sizeof(T)>::type { };
+    : min_size<sizeof(T), sizeof(alignof_helper<T>) - sizeof(T)> { };
 
 } /* .detail */
 } /* .alignment */

include/boost/align/detail/alignment_of_msvc.hpp

@@ -25,7 +25,7 @@ struct alignof_helper {
 template<class T>
 struct alignment_of
     : min_size<sizeof(T),
-        sizeof(alignof_helper<T>) - (sizeof(T) << 1)>::type { };
+        sizeof(alignof_helper<T>) - (sizeof(T) << 1)> { };
 
 } /* .detail */
 } /* .alignment */

include/boost/align/detail/assume_aligned_clang.hpp

@@ -11,7 +11,7 @@ License, Version 1.0.
 
 #if __has_builtin(__builtin_assume_aligned)
 #define BOOST_ALIGN_ASSUME_ALIGNED(p, n) \
-(p) = static_cast<__typeof__(p)>(__builtin_assume_aligned((p), (n)))
+(p) = (__typeof__(p))(__builtin_assume_aligned((p), (n)))
 #else
 #define BOOST_ALIGN_ASSUME_ALIGNED(p, n)
 #endif

include/boost/align/detail/assume_aligned_gcc.hpp

@@ -13,6 +13,6 @@ License, Version 1.0.
 #define BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_GCC_HPP
 
 #define BOOST_ALIGN_ASSUME_ALIGNED(p, n) \
-(p) = static_cast<__typeof__(p)>(__builtin_assume_aligned((p), (n)))
+(p) = (__typeof__(p))(__builtin_assume_aligned((p), (n)))
 
 #endif

include/boost/align/detail/assume_aligned_msvc.hpp

@@ -15,6 +15,6 @@ License, Version 1.0.
 #include <cstddef>
 
 #define BOOST_ALIGN_ASSUME_ALIGNED(p, n) \
-__assume((reinterpret_cast<std::size_t>(p) & ((n) - 1)) == 0)
+__assume(((std::size_t)(p) & ((n) - 1)) == 0)
 
 #endif

include/boost/align/detail/element_type.hpp

@@ -22,14 +22,9 @@ namespace alignment {
 namespace detail {
 
 #if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-template<class T>
-struct element_type {
-    typedef typename
-        std::remove_cv<typename
-        std::remove_all_extents<typename
-        std::remove_reference<T>::
-        type>::type>::type type;
-};
+using std::remove_reference;
+using std::remove_all_extents;
+using std::remove_cv;
 #else
 template<class T>
 struct remove_reference {
@@ -54,14 +49,12 @@ struct remove_all_extents {
 };
 
 template<class T>
-struct remove_all_extents<T[]> {
-    typedef typename remove_all_extents<T>::type type;
-};
+struct remove_all_extents<T[]>
+    : remove_all_extents<T> { };
 
 template<class T, std::size_t N>
-struct remove_all_extents<T[N]> {
-    typedef typename remove_all_extents<T>::type type;
-};
+struct remove_all_extents<T[N]>
+    : remove_all_extents<T> { };
 
 template<class T>
 struct remove_const {
@@ -84,20 +77,14 @@ struct remove_volatile<volatile T> {
 };
 
 template<class T>
-struct remove_cv {
-    typedef typename remove_volatile<typename
-        remove_const<T>::type>::type type;
-};
+struct remove_cv
+    : remove_volatile<typename remove_const<T>::type> { };
+#endif
 
 template<class T>
-struct element_type {
-    typedef typename
-        remove_cv<typename
-        remove_all_extents<typename
-        remove_reference<T>::
-        type>::type>::type type;
-};
-#endif
+struct element_type
+    : remove_cv<typename remove_all_extents<typename
+        remove_reference<T>::type>::type> { };
 
 } /* .detail */
 } /* .alignment */

include/boost/align/detail/integral_constant.hpp

@@ -1,5 +1,5 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
+(c) 2014-2016 Glen Joseph Fernandes
 <glenjofe -at- gmail.com>
 
 Distributed under the Boost Software
@@ -27,7 +27,11 @@ struct integral_constant {
     typedef T value_type;
     typedef integral_constant type;
 
-    BOOST_CONSTEXPR operator value_type() const {
+    BOOST_CONSTEXPR operator value_type() const BOOST_NOEXCEPT {
+        return Value;
+    }
+
+    BOOST_CONSTEXPR value_type operator()() const BOOST_NOEXCEPT {
         return Value;
     }
 

include/boost/align/detail/is_aligned.hpp

@@ -20,14 +20,14 @@ inline bool is_aligned(const void* ptr, std::size_t alignment)
     BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
-    return is_aligned(reinterpret_cast<std::size_t>(ptr), alignment);
+    return is_aligned((std::size_t)ptr, alignment);
 }
 
 inline bool is_aligned(std::size_t alignment, const void* ptr)
     BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
-    return is_aligned(reinterpret_cast<std::size_t>(ptr), alignment);
+    return is_aligned((std::size_t)ptr, alignment);
 }
 
 } /* .alignment */

include/boost/align/detail/max_align.hpp

@@ -18,8 +18,7 @@ namespace detail {
 
 template<class A, class B>
 struct max_align
-    : max_size<alignment_of<A>::value,
-         alignment_of<B>::value>::type { };
+    : max_size<alignment_of<A>::value, alignment_of<B>::value> { };
 
 } /* .detail */
 } /* .alignment */

test/aligned_delete_test.cpp

@@ -38,7 +38,7 @@ T* aligned_new()
     if (p) {
         return ::new(p) T();
     } else {
-        throw std::bad_alloc();
+        return 0;
     }
 }
 

test/is_aligned_test.cpp

@@ -14,34 +14,24 @@ License, Version 1.0.
 template<std::size_t N>
 struct A { };
 
-template<class T>
-struct P {
-    P()
-        : p(new T) { }
-    ~P() {
-        delete p;
-    }
-    T* p;
-};
-
-template<std::size_t N>
-void test(char* p, A<N>)
+template<class T, std::size_t N>
+void test(T* p, A<N>)
 {
     BOOST_TEST(boost::alignment::is_aligned(p, N));
-    BOOST_TEST(!boost::alignment::is_aligned(&p[1], N));
+    BOOST_TEST(!boost::alignment::is_aligned((char*)p + 1, N));
 }
 
-void test(char* p, A<1>)
+template<class T>
+void test(T* p, A<1>)
 {
     BOOST_TEST(boost::alignment::is_aligned(p, 1));
 }
 
 template<class T>
 void test()
 {
-    P<T> o;
-    test(reinterpret_cast<char*>(o.p),
-        A<boost::alignment::alignment_of<T>::value>());
+    T o;
+    test(&o, A<boost::alignment::alignment_of<T>::value>());
 }
 
 class X;
@@ -60,19 +50,23 @@ int main()
     test<short>();
     test<int>();
     test<long>();
-#if !defined(BOOST_NO_LONG_LONG)
+#if !defined(BOOST_NO_LONG_LONG) && !defined(_MSC_VER)
     test<long long>();
 #endif
     test<float>();
+#if !defined(_MSC_VER)
     test<double>();
     test<long double>();
+#endif
     test<void*>();
     test<char*>();
     test<int*>();
     test<X*>();
     test<void(*)()>();
+#if !defined(_MSC_VER)
     test<int X::*>();
     test<int(X::*)()>();
+#endif
 
     return boost::report_errors();
 }