Make fusion::pair trivially copyable if possible

Added tests for support/pair
2018-03-23 02:26:05 +09:00 · 2018-03-23 02:25:38 +09:00
33 changed files with 247 additions and 1656 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -11,6 +11,11 @@ os:
  - linux
  - osx

+branches:
+  only:
+    - master
+    - develop
+
 env:
  matrix:
    - BOGUS_JOB=true
@ -25,20 +30,6 @@ matrix:
    - os: linux
      env: TOOLSET=gcc CXXSTD=03,11,1y

-    - os: linux
-      env: TOOLSET=gcc-4.4 CXXSTD=98,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-
-    - os: linux
-      env: TOOLSET=gcc-4.6 CXXSTD=03,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-
    - os: linux
      env: TOOLSET=gcc-4.7 CXXSTD=03,11
      addons:
@ -162,17 +153,6 @@ matrix:
            - ubuntu-toolchain-r-test
            - llvm-toolchain-trusty-4.0

-    - os: linux
-      env: TOOLSET=clang-5.0 CXXSTD=03,11,14,1z,2a
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-
    - os: osx
      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z

--- a/appveyor.yml
+++ b/appveyor.yml
@ -7,35 +7,25 @@ version: 1.0.{build}-{branch}

 shallow_clone: true

+branches:
+  only:
+    - master
+    - develop
+
 environment:
  matrix:
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      TOOLSET: msvc-9.0
-      CXXSTD: latest # fake
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      TOOLSET: msvc-10.0
-      CXXSTD: latest # fake
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      TOOLSET: msvc-11.0
-      CXXSTD: latest # fake
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      TOOLSET: msvc-12.0
-      CXXSTD: latest # fake
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      TOOLSET: msvc-14.0
-      CXXSTD: 14
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
-      CXXSTD: latest
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      TOOLSET: msvc-14.1
-      CXXSTD: 14
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 17
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: latest

 install:
  - set BOOST_BRANCH=develop
@ -82,4 +72,4 @@ install:
 build: off

 test_script:
-  - b2 -j%NUMBER_OF_PROCESSORS% --hash libs/fusion/test toolset=%TOOLSET% cxxstd=%CXXSTD%
+  - b2 -j%NUMBER_OF_PROCESSORS% --hash libs/fusion/test toolset=%TOOLSET%
--- a/include/boost/fusion/container/deque/detail/keyed_element.hpp
+++ b/include/boost/fusion/container/deque/detail/keyed_element.hpp
@ -13,11 +13,6 @@
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/next.hpp>

-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)
-#include <boost/core/enable_if.hpp>
-#include <boost/type_traits/is_same.hpp>
-#endif
-
 namespace boost { namespace fusion
 {
    struct fusion_sequence_tag;
@ -119,13 +114,8 @@ namespace boost { namespace fusion { namespace detail
        {}

 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)
-        template <typename Value_, typename = typename enable_if<is_same<Value_, Value> >::type>
-#else
-        typedef Value Value_;
-#endif
        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        keyed_element(Value_&& value, Rest&& rest)
+        keyed_element(Value&& value, Rest&& rest)
            : Rest(std::move(rest))
            , value_(BOOST_FUSION_FWD_ELEM(Value, value))
        {}
--- a/include/boost/fusion/container/list/cons.hpp
+++ b/include/boost/fusion/container/list/cons.hpp
@ -70,10 +70,6 @@ namespace boost { namespace fusion
        cons(cons<Car2, Cdr2> const& rhs)
            : car(rhs.car), cdr(rhs.cdr) {}

-#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 406) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
-        // Workaround for `array used as initializer` compile error on gcc 4.6 w/ c++0x.
-        template <typename = void>
-#endif
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        cons(cons const& rhs)
            : car(rhs.car), cdr(rhs.cdr) {}
--- a/include/boost/fusion/container/map/detail/map_impl.hpp
+++ b/include/boost/fusion/container/map/detail/map_impl.hpp
@ -125,7 +125,11 @@ namespace boost { namespace fusion { namespace detail
        }

        BOOST_FUSION_GPU_ENABLED
-        mpl::identity<value_type> get_val(mpl::identity<key_type>) const;
+        value_type get_val(mpl::identity<key_type>);
+        BOOST_FUSION_GPU_ENABLED
+        pair_type get_val(mpl::int_<index>);
+        BOOST_FUSION_GPU_ENABLED
+        value_type get_val(mpl::identity<key_type>) const;
        BOOST_FUSION_GPU_ENABLED
        pair_type get_val(mpl::int_<index>) const;

--- a/include/boost/fusion/container/map/detail/value_at_key_impl.hpp
+++ b/include/boost/fusion/container/map/detail/value_at_key_impl.hpp
@ -1,6 +1,5 @@
 /*=============================================================================
    Copyright (c) 2001-2013 Joel de Guzman
-    Copyright (c) 2018 Kohei Takahashi

    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)
@ -9,6 +8,10 @@
 #define BOOST_FUSION_MAP_DETAIL_VALUE_AT_KEY_IMPL_02042013_0821

 #include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/detail/access.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/identity.hpp>
 #include <boost/utility/declval.hpp>

 namespace boost { namespace fusion
@ -26,9 +29,9 @@ namespace boost { namespace fusion
            template <typename Sequence, typename Key>
            struct apply
            {
-                typedef typename BOOST_FUSION_IDENTIFIED_TYPE((
-                    boost::declval<Sequence>().get_val(mpl::identity<Key>())
-                )) type;
+                typedef
+                    decltype(boost::declval<Sequence>().get_val(mpl::identity<Key>()))
+                type;
            };
        };
    }
--- a/include/boost/fusion/container/vector/detail/value_at_impl.hpp
+++ b/include/boost/fusion/container/vector/detail/value_at_impl.hpp
@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2014,2018 Kohei Takahashi
+    Copyright (c) 2014 Kohei Takahashi

    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)
@ -7,6 +7,7 @@
 #ifndef FUSION_VALUE_AT_IMPL_16122014_1641
 #define FUSION_VALUE_AT_IMPL_16122014_1641

+#include <boost/config.hpp>
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/container/vector/detail/config.hpp>

@ -22,7 +23,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 #include <boost/fusion/container/vector/vector_fwd.hpp>
 #include <boost/type_traits/declval.hpp>
-#include <boost/mpl/identity.hpp>

 namespace boost { namespace fusion
 {
@ -35,7 +35,7 @@ namespace boost { namespace fusion

        template <std::size_t N, typename U>
        static inline BOOST_FUSION_GPU_ENABLED
-        mpl::identity<U> value_at_impl(store<N, U> const volatile*);
+        U value_at_impl(store<N, U> const volatile*);
    }

    namespace extension
@ -49,9 +49,9 @@ namespace boost { namespace fusion
            template <typename Sequence, typename N>
            struct apply
            {
-                typedef typename BOOST_FUSION_IDENTIFIED_TYPE((
-                    vector_detail::value_at_impl<N::value>(boost::declval<Sequence*>())
-                )) type;
+                typedef
+                    decltype(vector_detail::value_at_impl<N::value>(boost::declval<Sequence*>()))
+                type;
            };
        };
    }
--- a/include/boost/fusion/container/vector/vector.hpp
+++ b/include/boost/fusion/container/vector/vector.hpp
@ -26,7 +26,6 @@
 #include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/support/detail/and.hpp>
 #include <boost/fusion/support/detail/index_sequence.hpp>
-#include <boost/fusion/support/detail/propagate_trivialness.hpp>
 #include <boost/fusion/container/vector/detail/at_impl.hpp>
 #include <boost/fusion/container/vector/detail/value_at_impl.hpp>
 #include <boost/fusion/container/vector/detail/begin_impl.hpp>
@ -51,6 +50,8 @@ namespace boost { namespace fusion

    namespace vector_detail
    {
+        struct each_elem {};
+
        template <
            typename This, typename T, typename T_, std::size_t Size, bool IsSeq
        >
@ -130,6 +131,32 @@ namespace boost { namespace fusion
                : elem() // value-initialized explicitly
            {}

+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            store(store const& rhs)
+                : elem(rhs.elem)
+            {}
+
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            store&
+            operator=(store const& rhs)
+            {
+                elem = rhs.elem;
+                return *this;
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            store(store&& rhs)
+                : elem(static_cast<T&&>(rhs.elem))
+            {}
+
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            store&
+            operator=(store&& rhs)
+            {
+                elem = static_cast<T&&>(rhs.elem);
+                return *this;
+            }
+
            template <
                typename U
              , typename = typename boost::disable_if<
@ -151,7 +178,6 @@ namespace boost { namespace fusion
        struct vector_data<detail::index_sequence<I...>, T...>
            : store<I, T>...
            , sequence_base<vector_data<detail::index_sequence<I...>, T...> >
-            , private detail::propagate_trivialness<T...>
        {
            typedef vector_tag                  fusion_tag;
            typedef fusion_sequence_tag         tag; // this gets picked up by MPL
@ -172,14 +198,14 @@ namespace boost { namespace fusion
            >
            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
            explicit
-            vector_data(Sequence&& rhs)
+            vector_data(each_elem, Sequence&& rhs)
                : store<I, T>(forward_at_c<I>(std::forward<Sequence>(rhs)))...
            {}

            template <typename ...U>
            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
            explicit
-            vector_data(U&&... var)
+            vector_data(each_elem, U&&... var)
                : store<I, T>(std::forward<U>(var))...
            {}

@ -264,7 +290,7 @@ namespace boost { namespace fusion
        //      In the (near) future release, should be fixed.
        /* BOOST_CONSTEXPR */ BOOST_FUSION_GPU_ENABLED
        explicit vector(U&&... u)
-            : base(std::forward<U>(u)...)
+            : base(vector_detail::each_elem(), std::forward<U>(u)...)
        {}

        template <
@ -277,7 +303,7 @@ namespace boost { namespace fusion
        >
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        vector(Sequence&& seq)
-            : base(std::forward<Sequence>(seq))
+            : base(vector_detail::each_elem(), std::forward<Sequence>(seq))
        {}

        template <typename Sequence>
--- a/include/boost/fusion/support/config.hpp
+++ b/include/boost/fusion/support/config.hpp
@ -1,6 +1,6 @@
 /*=============================================================================
    Copyright (c) 2014 Eric Niebler
-    Copyright (c) 2014,2015,2018 Kohei Takahashi
+    Copyright (c) 2014 Kohei Takahashi

    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)
@ -96,31 +96,4 @@ namespace std
 #define BOOST_FUSION_CONSTEXPR_THIS BOOST_CONSTEXPR
 #endif

-
-// Workaround for compiler which doesn't compile decltype(expr)::type.
-// It expects decltype(expr) deduced as mpl::identity<T>.
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1913)) || BOOST_WORKAROUND(BOOST_GCC, < 40700)
-#   include <boost/mpl/identity.hpp>
-#   define BOOST_FUSION_IDENTIFIED_TYPE(parenthesized_expr) \
-        boost::mpl::identity<decltype parenthesized_expr>::type::type
-#else
-#   define BOOST_FUSION_IDENTIFIED_TYPE(parenthesized_expr) \
-        decltype parenthesized_expr ::type
-#endif
-
-
-// Workaround for GCC 4.6 that rejects defaulted function with noexcept.
-#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 406)
-#   define BOOST_FUSION_NOEXCEPT_ON_DEFAULTED
-#else
-#   define BOOST_FUSION_NOEXCEPT_ON_DEFAULTED BOOST_NOEXCEPT
-#endif
-
-
-#ifdef __has_extension
-#   define BOOST_FUSION_HAS_EXTENSION __has_extension
-#else
-#   define BOOST_FUSION_HAS_EXTENSION(_) 0
-#endif
-
 #endif
--- a/include/boost/fusion/support/detail/and.hpp
+++ b/include/boost/fusion/support/detail/and.hpp
@ -1,6 +1,5 @@
 /*=============================================================================
    Copyright (c) 2016 Lee Clagett
-    Copyright (c) 2018 Kohei Takahashi

    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)
@ -9,7 +8,6 @@
 #define FUSION_AND_07152016_1625

 #include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
 #include <boost/type_traits/integral_constant.hpp>

 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@ -17,8 +15,7 @@
 #endif

 namespace boost { namespace fusion { namespace detail {
-#if defined(BOOST_NO_CXX17_FOLD_EXPRESSIONS) \
- || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1913))
+#if defined(BOOST_NO_CXX17_FOLD_EXPRESSIONS)
    template<typename ...Cond>
    struct and_impl : false_type {};

--- a/include/boost/fusion/support/detail/is_trivially_copyable.hpp
+++ b/include/boost/fusion/support/detail/is_trivially_copyable.hpp
@ -1,113 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    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)
-==============================================================================*/
-#ifndef BOOST_FUSION_SUPPORT_DETAIL_IS_TRIVIALLY_COPYABLE
-#define BOOST_FUSION_SUPPORT_DETAIL_IS_TRIVIALLY_COPYABLE
-
-#include <boost/fusion/support/config.hpp>
-
-#if BOOST_WORKAROUND(BOOST_GCC, BOOST_TESTED_AT(90000))
-    // GCC treats volatile qualified scalar type as non trivially copyable,
-    // so to be fail safe, we also treat it as non trivially copyable type.
-    // http://wg21.link/cwg2094
-    // https://gcc.gnu.org/PR85679
-    //
-    // Some version of clang also tweats volatile qualified scalar type as
-    // non trivially copyable type, but all of known the versions what
-    // behaves as CWG 496 but not CWG 2094 implement builtin.
-    // So we don't have to emulate CWG 496 on clang.
-#   define BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE
-#endif
-
-#if BOOST_FUSION_HAS_EXTENSION(is_trivially_copyable) || \
-    (50000 <= BOOST_GCC) || (1700 <= BOOST_MSVC)
-#   define BOOST_FUSION_IS_TRIVIALLY_COPYABLE __is_trivially_copyable
-#endif
-
-#if defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
-#   define BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING 2
-#   include <boost/mpl/bool.hpp>
-#elif !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-#   define BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING 2
-#   include <type_traits>
-#else
-#   include <boost/config/workaround.hpp>
-#   include <boost/mpl/bool.hpp>
-#   include <boost/mpl/if.hpp>
-#   include <boost/type_traits/remove_cv.hpp>
-#   include <boost/type_traits/remove_all_extents.hpp>
-#   include <boost/type_traits/is_scalar.hpp>
-#   include <boost/type_traits/is_class.hpp>
-#   include <boost/type_traits/is_union.hpp>
-#   include <boost/type_traits/is_constructible.hpp>
-#   include <boost/type_traits/is_assignable.hpp>
-#   include <boost/type_traits/is_copy_constructible.hpp>
-#   include <boost/type_traits/is_copy_assignable.hpp>
-#   include <boost/type_traits/has_trivial_assign.hpp>
-#   include <boost/type_traits/has_trivial_copy.hpp>
-#   include <boost/type_traits/has_trivial_destructor.hpp>
-#   include <boost/type_traits/has_trivial_move_assign.hpp>
-#   include <boost/type_traits/has_trivial_move_constructor.hpp>
-#ifdef BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE
-#   include <boost/mpl/not.hpp>
-#   include <boost/type_traits/is_volatile.hpp>
-#endif
-#endif // <type_traits>
-
-namespace boost { namespace fusion { namespace detail
-{
-
-#ifndef BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING
-#if defined(BOOST_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_DECLTYPE) && \
-    defined(BOOST_IS_UNION) && defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) && \
-    defined(BOOST_HAS_TRIVIAL_ASSIGN) && defined(BOOST_HAS_TRIVIAL_COPY) && \
-    defined(BOOST_HAS_TRIVIAL_MOVE_ASSIGN) && defined(BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR) && \
-    defined(BOOST_HAS_TRIVIAL_DESTRUCTOR) && defined(BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING)
-#   define BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING 1
-#endif
-
-template <typename T>
-struct is_trivially_copyable_class
-  : mpl::bool_<
-        (has_trivial_copy<T>::value   || !is_copy_constructible<T>::value) &&
-        (has_trivial_assign<T>::value || !is_copy_assignable<T>::value) &&
-        (has_trivial_move_constructor<T>::value || !is_constructible<T, T>::value) &&
-        (has_trivial_move_assign<T>::value      || !is_assignable<T, T>::value) &&
-        (is_copy_constructible<T>::value || is_copy_assignable<T>::value ||
-         is_constructible<T, T>::value   || is_assignable<T, T>::value) &&
-        has_trivial_destructor<T>::value
-    > { };
-
-template <typename T>
-struct is_trivially_copyable_impl
-  : mpl::if_c<is_scalar<T>::value
-#ifdef BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE
-    , mpl::not_<is_volatile<T> >
-#else
-    , mpl::true_
-#endif
-    , typename mpl::if_c<is_class<T>::value || is_union<T>::value
-      , is_trivially_copyable_class<typename remove_cv<T>::type>
-      , mpl::false_
-      >::type
-    >::type { };
-#endif // <type_traits>
-
-template <typename T>
-struct is_trivially_copyable
-#if defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
-  : mpl::bool_<BOOST_FUSION_IS_TRIVIALLY_COPYABLE(T)>
-#elif !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-  : std::is_trivially_copyable<T>
-#else
-  : is_trivially_copyable_impl<typename remove_all_extents<T>::type>
-#endif // <type_traits>
-{ };
-
-}}} // namespace boost::fusion::detail
-
-#endif
-
--- a/include/boost/fusion/support/detail/propagate_trivialness.hpp
+++ b/include/boost/fusion/support/detail/propagate_trivialness.hpp
@ -1,40 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    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)
-==============================================================================*/
-#ifndef BOOST_FUSION_SUPPORT_DETAIL_PROPAGATE_TRIVIALNESS
-#define BOOST_FUSION_SUPPORT_DETAIL_PROPAGATE_TRIVIALNESS
-
-#include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/detail/and.hpp>
-#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
-#include <boost/mpl/if.hpp>
-
-namespace boost { namespace fusion { namespace detail
-{
-
-struct trivial_base { };
-
-struct non_trivial_base
-{
-    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    BOOST_DEFAULTED_FUNCTION(non_trivial_base(), {})
-
-    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-    non_trivial_base(non_trivial_base const&) BOOST_NOEXCEPT { }
-};
-
-template <typename... T>
-struct propagate_trivialness
-  : mpl::if_c<and_<is_trivially_copyable<T>...>::value
-      , trivial_base
-      , non_trivial_base
-    >::type
-{ };
-
-}}} // namespace boost::fusion::detail
-
-#endif
-
--- a/include/boost/fusion/support/pair.hpp
+++ b/include/boost/fusion/support/pair.hpp
@ -8,15 +8,16 @@
 #if !defined(FUSION_PAIR_07222005_1203)
 #define FUSION_PAIR_07222005_1203

-#include <boost/fusion/support/config.hpp>
 #include <iosfwd>
-
+#include <utility>
+#include <boost/fusion/support/config.hpp>
 #include <boost/fusion/support/detail/access.hpp>
 #include <boost/fusion/support/detail/as_fusion_element.hpp>
-#include <boost/config.hpp>
-#include <boost/utility/enable_if.hpp>
+#include <boost/fusion/support/detail/enabler.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_lvalue_reference.hpp>
+#include <boost/type_traits/remove_cv_ref.hpp>

 #if defined (BOOST_MSVC)
 #  pragma warning(push)
@ -33,54 +34,46 @@ namespace boost { namespace fusion
        pair()
            : second() {}

-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair(pair const& rhs)
-            : second(rhs.second) {}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair(pair&& rhs)
-            : second(BOOST_FUSION_FWD_ELEM(Second, rhs.second)) {}
-#endif
-
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        pair(typename detail::call_param<Second>::type val)
            : second(val) {}

 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template <typename Second2>
        BOOST_FUSION_GPU_ENABLED
-        pair(Second2&& val
-          , typename boost::disable_if<is_lvalue_reference<Second2> >::type* /* dummy */ = 0
-          , typename boost::enable_if<is_convertible<Second2, Second> >::type* /*dummy*/ = 0
-        ) : second(BOOST_FUSION_FWD_ELEM(Second, val)) {}
+        pair(typename remove_cv_ref<Second>::type&& val)
+            : second(BOOST_FUSION_FWD_ELEM(Second, val)) {}
 #endif

        template <typename Second2>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair(pair<First, Second2> const& rhs)
+        pair(pair<First, Second2> const& rhs,
+             typename disable_if<is_same<Second, Second2>, detail::enabler_>::type = detail::enabler,
+             typename enable_if<is_convertible<Second2, Second>, detail::enabler_>::type = detail::enabler)
            : second(rhs.second) {}

        template <typename Second2>
        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair& operator=(pair<First, Second2> const& rhs)
-        {
-            second = rhs.second;
-            return *this;
-        }
-
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair& operator=(pair const& rhs)
+        typename disable_if<is_same<Second, Second2>, pair&>::type
+        operator=(pair<First, Second2> const& rhs)
        {
            second = rhs.second;
            return *this;
        }

 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        template <typename Second2>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pair(pair<First, Second2>&& rhs,
+             typename disable_if<is_same<Second, Second2>, detail::enabler_>::type = detail::enabler,
+             typename enable_if<is_convertible<Second2, Second>, detail::enabler_>::type = detail::enabler)
+            : second(std::move(rhs.second)) {}
+
+        template <typename Second2>
        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        pair& operator=(pair&& rhs)
+        typename disable_if<is_same<Second, Second2>, pair&>::type
+        operator=(pair<First, Second2>&& rhs)
        {
-            second = BOOST_FUSION_FWD_ELEM(Second, rhs.second);
+            second = std::move(rhs.second);
            return *this;
        }
 #endif
--- a/include/boost/fusion/support/unused.hpp
+++ b/include/boost/fusion/support/unused.hpp
@ -1,6 +1,5 @@
 /*=============================================================================
    Copyright (c) 2001-2011 Joel de Guzman
-    Copyright (c) 2018 Kohei Takahashi

    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)
@ -11,6 +10,7 @@
 #include <boost/fusion/support/config.hpp>
 #include <iosfwd>

+#include <boost/config.hpp>
 #if defined(BOOST_MSVC)
 # pragma warning(push)
 # pragma warning(disable: 4522) // multiple assignment operators specified warning
@ -23,16 +23,9 @@ namespace boost { namespace fusion
    struct unused_type
    {
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        BOOST_DEFAULTED_FUNCTION(
-        unused_type() BOOST_FUSION_NOEXCEPT_ON_DEFAULTED,
+        unused_type() BOOST_NOEXCEPT
        {
-        })
-
-        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        BOOST_DEFAULTED_FUNCTION(
-        unused_type(unused_type const&) BOOST_FUSION_NOEXCEPT_ON_DEFAULTED,
-        {
-        })
+        }

        template <typename T>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@ -40,12 +33,35 @@ namespace boost { namespace fusion
        {
        }

+        template <typename T>
+        BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
+        unused_type const&
+        operator=(T const&) const BOOST_NOEXCEPT
+        {
+            return *this;
+        }
+
+        template <typename T>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        unused_type&
+        operator=(T const&) BOOST_NOEXCEPT
+        {
+            return *this;
+        }
+
        BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
        unused_type const&
        operator=(unused_type const&) const BOOST_NOEXCEPT
        {
            return *this;
        }
+
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        unused_type&
+        operator=(unused_type const&) BOOST_NOEXCEPT
+        {
+            return *this;
+        }
    };

    BOOST_CONSTEXPR_OR_CONST unused_type unused = unused_type();
--- a/include/boost/fusion/tuple/tuple.hpp
+++ b/include/boost/fusion/tuple/tuple.hpp
@ -56,7 +56,7 @@ namespace boost { namespace fusion
        >
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        tuple(tuple<U...> const& other)
-            : base(other) {}
+            : base(vector_detail::each_elem(), other) {}

        template <
            typename ...U
@ -66,7 +66,7 @@ namespace boost { namespace fusion
        >
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        tuple(tuple<U...>&& other)
-            : base(std::move(other)) {}
+            : base(vector_detail::each_elem(), std::move(other)) {}

        template <
            typename ...U
@ -78,17 +78,17 @@ namespace boost { namespace fusion
        /*BOOST_CONSTEXPR*/ BOOST_FUSION_GPU_ENABLED
        explicit
        tuple(U&&... args)
-            : base(std::forward<U>(args)...) {}
+            : base(vector_detail::each_elem(), std::forward<U>(args)...) {}

        template<typename U1, typename U2>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        tuple(std::pair<U1, U2> const& other)
-            : base(other.first, other.second) {}
+            : base(vector_detail::each_elem(), other.first, other.second) {}

        template<typename U1, typename U2>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        tuple(std::pair<U1, U2>&& other)
-            : base(std::move(other.first), std::move(other.second)) {}
+            : base(vector_detail::each_elem(), std::move(other.first), std::move(other.second)) {}

        template<typename U>
        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
--- a/meta/explicit-failures-markup.xml
+++ b/meta/explicit-failures-markup.xml
@ -9,8 +9,8 @@
            <toolset name="msvc-11.0"/>
            <toolset name="msvc-12.0"/>
            <toolset name="qcc-4.4.2_x86"/>
-            <toolset name="gcc-4.4~c++0x*"/>
-            <toolset name="gcc-4.4~gnu0x*"/>
+            <toolset name="gcc-gnu-4.4~c++0x*"/>
+            <toolset name="gcc-gnu-4.4~gnu0x*"/>
            <note author="Kohei Takahashi">
                The compiler doesn't generate defaulted move ctor/assgin thus
                perform copy construction/assginment. Even though such case,
--- a/test/Jamfile
+++ b/test/Jamfile
@ -154,8 +154,6 @@ project
    [ run sequence/tuple_traits.cpp : :
        : <define>BOOST_FUSION_DISABLE_VARIADIC_VECTOR
        : tuple_traits__no_variadic ]
-    [ run sequence/tuple_trivially_copyable.cpp : :
-        : [ requires cxx11_variadic_templates ] ]
    [ run sequence/transform_view.cpp ]
    [ run sequence/vector_comparison.cpp ]
    [ run sequence/vector_construction.cpp ]
@ -177,8 +175,6 @@ project
    [ run sequence/vector_traits.cpp : :
        : <define>BOOST_FUSION_DISABLE_VARIADIC_VECTOR
        : vector_traits__no_variadic ]
-    [ run sequence/vector_trivially_copyable.cpp : :
-        : [ requires cxx11_variadic_templates ] ]
    [ run sequence/vector_value_at.cpp ]
    [ run sequence/zip_view.cpp ]
    [ run sequence/zip_view2.cpp ]
@ -241,7 +237,6 @@ project
    [ run sequence/ref_vector.cpp ]
    [ run sequence/flatten_view.cpp ]
    [ compile sequence/github-159.cpp ]
-    [ run sequence/github-176.cpp ]

    [ compile sequence/size.cpp ]

@ -260,6 +255,7 @@ project
    [ run sequence/swap.cpp ]

    [ compile support/is_sequence.cpp ]
+    [ compile support/pair_conversion.cpp ]
    [ compile support/pair_deque.cpp ]
    [ compile support/pair_list.cpp ]
    [ compile support/pair_map.cpp ]
@ -271,10 +267,8 @@ project
    [ compile support/and.cpp
        : [ requires cxx11_variadic_templates ] ]
    [ compile support/tag_of.cpp ]
-    [ compile support/unused.cpp ]
-    [ compile support/is_trivially_copyable.cpp ]
-    [ compile support/propagate_trivialness.cpp
-        : [ requires cxx11_variadic_templates ] ]
+    [ compile support/pair_trivially_copyable.cpp
+        : [ requires cxx11_hdr_type_traits ] ]

 #   [ compile-fail xxx.cpp  ]

--- a/test/sequence/define_struct_inline_move.cpp
+++ b/test/sequence/define_struct_inline_move.cpp
@ -47,8 +47,8 @@ int main()
        BOOST_TEST(y.w.value == 42);
    }

-    // Older MSVCs and gcc 4.4 don't generate move ctor by default.
-#if !(defined(CI_SKIP_KNOWN_FAILURE) && (BOOST_WORKAROUND(BOOST_MSVC, < 1900) || BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)))
+    // Older MSVCs don't generate move ctor by default.
+#if !(defined(CI_SKIP_KNOWN_FAILURE) && BOOST_WORKAROUND(BOOST_MSVC, < 1900))
    {
        ns::value x;
        ns::value y(std::move(x)); // move
@ -66,7 +66,7 @@ int main()
        BOOST_TEST(x.w.value == 0);
        BOOST_TEST(y.w.value == 0);
    }
-#endif // !(ci && (msvc < 14.0 || gcc 4.4.x))
+#endif // !(ci && msvc < 14.0)

    return boost::report_errors();
 }
--- a/test/sequence/define_tpl_struct_inline_move.cpp
+++ b/test/sequence/define_tpl_struct_inline_move.cpp
@ -47,8 +47,8 @@ int main()
        BOOST_TEST(y.w.value == 42);
    }

-    // Older MSVCs and gcc 4.4 don't generate move ctor by default.
-#if !(defined(CI_SKIP_KNOWN_FAILURE) && (BOOST_WORKAROUND(BOOST_MSVC, < 1900) || BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)))
+    // Older MSVCs don't generate move ctor by default.
+#if !(defined(CI_SKIP_KNOWN_FAILURE) && BOOST_WORKAROUND(BOOST_MSVC, < 1900))
    {
        ns::value<wrapper> x;
        ns::value<wrapper> y(std::move(x)); // move
@ -66,7 +66,7 @@ int main()
        BOOST_TEST(x.w.value == 0);
        BOOST_TEST(y.w.value == 0);
    }
-#endif // !(ci && (msvc < 14.0 || gcc 4.4.x))
+#endif // !(ci && msvc < 14.0)

    return boost::report_errors();
 }
--- a/test/sequence/github-176.cpp
+++ b/test/sequence/github-176.cpp
@ -1,89 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    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/fusion/sequence/intrinsic/at.hpp>
-#include <boost/fusion/sequence/intrinsic/at_key.hpp>
-#include <boost/fusion/container/vector.hpp>
-#include <boost/fusion/container/list.hpp>
-#include <boost/fusion/container/deque.hpp>
-#include <boost/fusion/container/map.hpp>
-#include <boost/fusion/container/set.hpp>
-#include <boost/fusion/tuple/tuple.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-template <typename Sequence>
-void test_at()
-{
-    Sequence seq;
-
-    // zero initialized
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 0);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 0);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 0);
-
-    int (&arr)[3] = boost::fusion::deref(boost::fusion::begin(seq));
-
-    arr[0] = 2;
-    arr[1] = 4;
-    arr[2] = 6;
-
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 2);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 4);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 6);
-
-    boost::fusion::at_c<0>(seq)[1] = 42;
-
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 2);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 42);
-    BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 6);
-}
-
-template <typename T> inline T& value(T& v) { return v; }
-template <typename K, typename T> inline T& value(boost::fusion::pair<K, T>& v) { return v.second; }
-
-template <typename Sequence>
-void test_at_key()
-{
-    Sequence seq;
-
-    // zero initialized
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 0);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 0);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 0);
-
-    int (&arr)[3] = value(boost::fusion::deref(boost::fusion::begin(seq)));
-
-    arr[0] = 2;
-    arr[1] = 4;
-    arr[2] = 6;
-
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 2);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 4);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 6);
-
-    boost::fusion::at_key<int[3]>(seq)[1] = 42;
-
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 2);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 42);
-    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 6);
-}
-
-int main()
-{
-    using namespace boost::fusion;
-
-    test_at<vector<int[3]> >();
-    test_at<deque<int[3]> >();
-    test_at<list<int[3]> >();
-    test_at<tuple<int[3]> >();
-
-#if !BOOST_WORKAROUND(BOOST_GCC, / 100 == 406) || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
-    // FIXME: gcc 4.6 w/ c++0x doesn't like set with array...
-    test_at_key<set<int[3]> >();
-#endif
-    test_at_key<map<pair<int[3], int[3]> > >();
-}
--- a/test/sequence/hash.hpp
+++ b/test/sequence/hash.hpp
@ -1,6 +1,5 @@
 /*=============================================================================
    Copyright (c) 2014 Christoph Weiss
-    Copyright (c) 2017 Kohei Takahashi

    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)
@ -12,24 +11,24 @@
 #include <boost/fusion/sequence/hash.hpp>
 #include <boost/functional/hash.hpp>

-void hash_test()
+void
+hash_test()
 {
-    namespace fusion = boost::fusion;
-    using namespace fusion;
+    using namespace boost::fusion;

    const FUSION_SEQUENCE<int, char, bool, std::string> v0(42, 'x', false, "Aurea prima");
    const FUSION_SEQUENCE<int, char, bool, std::string> v1(42, 'x', false, "Aurea prima");
-    BOOST_TEST(fusion::hash_value(v0) == fusion::hash_value(v1));
-
+    BOOST_TEST(hash_value(v0) == hash_value(v1));
+    
    const FUSION_SEQUENCE<int, char, bool, std::string> w(41, 'x', false, "Aurea prima");
-    BOOST_TEST(fusion::hash_value(w) != fusion::hash_value(v0));
-
+    BOOST_TEST(hash_value(w) != hash_value(v0));
+    
    const FUSION_SEQUENCE<int, char, bool, std::string> x(42, 'y', false, "Aurea prima");
-    BOOST_TEST(fusion::hash_value(x) != fusion::hash_value(v0));
-
+    BOOST_TEST(hash_value(x) != hash_value(v0));
+    
    const FUSION_SEQUENCE<int, char, bool, std::string> y(42, 'x', true, "Aurea prima");
-    BOOST_TEST(fusion::hash_value(y) != fusion::hash_value(v0));
-
+    BOOST_TEST(hash_value(y) != hash_value(v0));
+    
    const FUSION_SEQUENCE<int, char, bool, std::string> z(42, 'x', false, "quae vindice nullo");
-    BOOST_TEST(fusion::hash_value(z) != fusion::hash_value(v0));
+    BOOST_TEST(hash_value(z) != hash_value(v0));
 }
--- a/test/sequence/traits.hpp
+++ b/test/sequence/traits.hpp
@ -1,6 +1,5 @@
 /*=============================================================================
    Copyright (C) 2016 Lee Clagett
-    Copyright (C) 2018 Kohei Takahashi

    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)
@ -39,7 +38,9 @@ bool is_convertible(bool has_conversion)
 }

 // is_constructible has a few requirements
-#ifdef BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING
+#if !defined(BOOST_NO_CXX11_DECLTYPE) &&   \
+    !defined(BOOST_NO_CXX11_TEMPLATES) &&  \
+    !defined(BOOST_NO_SFINAE_EXPR)

 #define FUSION_TEST_HAS_CONSTRUCTIBLE

@ -87,9 +88,7 @@ void test_constructible()
    BOOST_TEST((
        is_constructible<FUSION_SEQUENCE<convertible>, convertible>(true)
    ));
-
-    // boost::is_constructible always fail to test ctor which takes 2 or more arguments on GCC 4.7.
-#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
+        
    BOOST_TEST((
        is_constructible<FUSION_SEQUENCE<int, int>, int, int>(true)
    ));
@ -132,7 +131,6 @@ void test_constructible()
            FUSION_SEQUENCE<convertible, convertible>, convertible, convertible
        >(true)
    ));
-#endif // !(gcc < 4.7)
 }

 #endif // is_constructible is available
--- a/test/sequence/trivially_copyable.hpp
+++ b/test/sequence/trivially_copyable.hpp
@ -1,76 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    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)
-==============================================================================*/
-#ifndef TRIVIALLY_COPYABLE_HPP
-#define TRIVIALLY_COPYABLE_HPP
-
-#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
-
-#include <boost/mpl/assert.hpp>
-#include "../support/trivial.hpp"
-
-using namespace boost::fusion;
-
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<> >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int> >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int> >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int, int> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int&> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int&> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int, int&> >));
-
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<> > >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int> > >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int, int> > >));
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<int, int, int> > >));
-
-BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int, trivial> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, user_provided_copy> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, user_provided_move> >));
-BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, user_provided_dtor> >));
-
-#ifdef BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING
-#include <boost/core/lightweight_test.hpp>
-#include <boost/core/addressof.hpp>
-#include <boost/fusion/sequence/intrinsic/at_c.hpp>
-#include <boost/fusion/sequence/comparison/equal_to.hpp>
-#include <cstring>
-
-int main()
-{
-    typedef FUSION_SEQUENCE<char, double, const int*> seq_t;
-    BOOST_MPL_ASSERT((detail::is_trivially_copyable<seq_t>));
-
-    char* storage = new char[sizeof(seq_t)];
-
-    int i = 42;
-
-    const seq_t* src = new seq_t('\t', 3.14159265359, &i);
-    std::memcpy(static_cast<void*>(storage), src, sizeof(seq_t));
-
-    seq_t* dst = new seq_t;
-    std::memcpy(dst, static_cast<void const*>(storage), sizeof(seq_t));
-
-    BOOST_TEST((*src) == (*dst));
-    BOOST_TEST(boost::fusion::at_c<0>(*src) == '\t');
-    BOOST_TEST(boost::fusion::at_c<1>(*src) == 3.14159265359);
-    BOOST_TEST(boost::fusion::at_c<2>(*src) == &i);
-    BOOST_TEST(*boost::fusion::at_c<2>(*src) == 42);
-    BOOST_TEST(boost::fusion::at_c<0>(*dst) == '\t');
-    BOOST_TEST(boost::fusion::at_c<1>(*dst) == 3.14159265359);
-    BOOST_TEST(boost::fusion::at_c<2>(*dst) == &i);
-    BOOST_TEST(*boost::fusion::at_c<2>(*dst) == 42);
-
-    delete dst;
-    delete src;
-    delete [] storage;
-
-    return boost::report_errors();
-}
-#else
-int main() { }
-#endif
-#endif
--- a/test/sequence/tuple_traits.cpp
+++ b/test/sequence/tuple_traits.cpp
@ -65,13 +65,10 @@ main()
    BOOST_TEST((is_constructible<tuple<int>, int, int>(false)));

    BOOST_TEST((is_constructible< tuple<int, int> >(true)));
-    // boost::is_constructible always fail to test ctor which takes 2 or more arguments on GCC 4.7.
-#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
    BOOST_TEST((is_constructible<tuple<int, int>, int, int>(true)));
    BOOST_TEST((
        is_constructible<tuple<convertible, convertible>, int, int>(true)
    ));
-#endif // !(gcc < 4.7)
    BOOST_TEST((is_constructible<tuple<int, not_convertible>, int, int>(false)));
    BOOST_TEST((is_constructible<tuple<not_convertible, int>, int, int>(false)));
    BOOST_TEST((
--- a/test/sequence/tuple_trivially_copyable.cpp
+++ b/test/sequence/tuple_trivially_copyable.cpp
@ -1,17 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    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/fusion/tuple/tuple_fwd.hpp>
-
-#ifndef BOOST_FUSION_HAS_VARIADIC_TUPLE
-int main() { }
-#else
-
-#include <boost/fusion/tuple/tuple.hpp>
-#define FUSION_SEQUENCE boost::fusion::tuple
-#include "trivially_copyable.hpp"
-#endif
-
--- a/test/sequence/vector_trivially_copyable.cpp
+++ b/test/sequence/vector_trivially_copyable.cpp
@ -1,17 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    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/fusion/container/vector/detail/config.hpp>
-
-#ifndef BOOST_FUSION_HAS_VARIADIC_VECTOR
-int main() { }
-#else
-
-#include <boost/fusion/container/vector/vector.hpp>
-#define FUSION_SEQUENCE boost::fusion::vector
-#include "trivially_copyable.hpp"
-#endif
-
--- a/test/support/is_trivially_copyable.cpp
+++ b/test/support/is_trivially_copyable.cpp
@ -1,766 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-    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/config.hpp>
-
-#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
-#include <boost/mpl/assert.hpp>
-#include "trivial.hpp"
-
-using namespace boost;
-using namespace boost::fusion::detail;
-
-// disable cv-qialifer on function type warning
-#if defined(BOOST_CLANG)
-#   pragma clang diagnostic ignored "-Wignored-qualifiers"
-#elif defined(BOOST_MSVC)
-#   pragma warning(disable: 4180)
-#endif
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void const>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void volatile>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile&>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile&&>));
-#endif
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<int(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&&)[][3][4][5]>));
-#endif
-
-typedef int function_type();
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile&>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile&&>));
-#endif
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&&)[][3][4][5]>));
-#endif
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&&)[][3][4][5]>));
-#endif
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&&)[][3][4][5]>));
-#endif
-
-
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial>));
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile&>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile&&>));
-#endif
-
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial[]>));
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const[]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile[]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile[]>));
-
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial[3]>));
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const[3]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile[3]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile[3]>));
-
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&&)[][3][4][5]>));
-#endif
-
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile&>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile&&>));
-#endif
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&&)[][3][4][5]>));
-#endif
-
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile&>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile&&>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&&)[][3][4][5]>));
-#endif
-
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile*>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor* const>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor* volatile>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor* const volatile>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile&>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile&&>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile&&>));
-#endif
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile[][3][4][5]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile(*)[]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*const)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*volatile)[]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*const volatile)[]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile(*)[3]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*const)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*volatile)[3]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*const volatile)[3]>));
-
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile(*)[][3][4][5]>));
-BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*const)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*const volatile)[][3][4][5]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&)[][3][4][5]>));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&&)[]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&&)[]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&&)[3]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&&)[3]>));
-
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&&)[][3][4][5]>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&&)[][3][4][5]>));
-#endif
--- a/test/support/pair_conversion.cpp
+++ b/test/support/pair_conversion.cpp
@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    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 <utility>
+#include <boost/config.hpp>
+#include <boost/fusion/support/pair.hpp>
+
+using namespace boost::fusion;
+
+struct eat_int
+{
+    eat_int(int);
+};
+
+struct eat_pair
+{
+    template <typename K, typename V>
+    eat_pair(pair<K, V>);
+};
+
+int main()
+{
+    pair<void, int> p;
+
+    pair<void, eat_int> ci(p);
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    pair<void, eat_int> mi(std::move(p));
+#endif
+
+    // eat_pair can't be converted from int, but can be pair.
+    // So pair(eat_pair) should be called rather than pair(pair<void, eat_pair>).
+    pair<void, eat_pair> cp(p);
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    pair<void, eat_pair> mp(std::move(p));
+#endif
+}
--- a/test/support/pair_nest.cpp
+++ b/test/support/pair_nest.cpp
@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2015 Kohei Takahashi
+    Copyright (c) 2015,2018 Kohei Takahashi

    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)
@ -10,15 +10,20 @@
 using namespace boost::fusion;

 template <typename C>
-void copy()
+void copy(C value)
 {
-    pair<int, C> src;
+    pair<int, C> src(value);
    pair<int, C> dest = src;
    boost::ignore_unused(dest);
 }

 int main()
 {
-    copy<pair<void, float> >();
+    copy<pair<void, float> >(42.195f);
+    copy<pair<int, float> >(42.195f);
+
+    float f;
+    pair<void, float&> r(f);
+    copy<pair<void, float&> >(r);
 }

--- a/test/support/pair_trivially_copyable.cpp
+++ b/test/support/pair_trivially_copyable.cpp
@ -0,0 +1,50 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    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 <type_traits>
+#include <boost/fusion/support/pair.hpp>
+#include <boost/mpl/assert.hpp>
+
+using namespace boost::fusion;
+
+struct non_trivially_copyable
+{
+    non_trivially_copyable(const non_trivially_copyable&);
+    non_trivially_copyable operator=(const non_trivially_copyable&);
+};
+
+struct pod { };
+
+BOOST_MPL_ASSERT_NOT((std::is_trivially_copyable<void>));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<int>));
+BOOST_MPL_ASSERT_NOT((std::is_trivially_copyable<non_trivially_copyable>));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pod>));
+BOOST_MPL_ASSERT_NOT((std::is_trivially_copyable<int&>));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<void*>));
+
+
+
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<void, int> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, int> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<non_trivially_copyable, int> >));
+BOOST_MPL_ASSERT_NOT((std::is_trivially_copyable<pair<int, non_trivially_copyable> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<pod, int> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, pod> >));
+
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<void, int&> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, int&> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<non_trivially_copyable, int&> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, non_trivially_copyable&> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, pod&> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, pod&> >));
+
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<void, int*> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, int*> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<non_trivially_copyable, int*> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, non_trivially_copyable*> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, pod*> >));
+BOOST_MPL_ASSERT((std::is_trivially_copyable<pair<int, pod*> >));
--- a/test/support/propagate_trivialness.cpp
+++ b/test/support/propagate_trivialness.cpp
@ -1,183 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    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/config.hpp>
-#include <boost/fusion/support/detail/propagate_trivialness.hpp>
-#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_base_of.hpp>
-#include <boost/type_traits/is_default_constructible.hpp>
-#include "trivial.hpp"
-
-using namespace boost;
-using namespace boost::fusion::detail;
-
-
-BOOST_MPL_ASSERT((is_default_constructible<trivial_base>));
-BOOST_MPL_ASSERT((is_default_constructible<non_trivial_base>));
-
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial_base>));
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<non_trivial_base>));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int const*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int const volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int* const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int* volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int* const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int volatile&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const volatile&> >));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int volatile&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const volatile&&> >));
-#endif
-
-
-BOOST_FUSION_ASSERT_CWG496((is_base_of<trivial_base, propagate_trivialness<trivial> >));
-BOOST_FUSION_ASSERT_CWG496((is_base_of<trivial_base, propagate_trivialness<trivial const> >));
-BOOST_FUSION_ASSERT_CWG2094((is_base_of<trivial_base, propagate_trivialness<trivial volatile> >));
-BOOST_FUSION_ASSERT_CWG2094((is_base_of<trivial_base, propagate_trivialness<trivial const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial const*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial const volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial* const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<trivial* volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<trivial* const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial volatile&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const volatile&> >));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial volatile&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const volatile&&> >));
-#endif
-
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy volatile> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy const*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy const volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy volatile&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const volatile&> >));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy volatile&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const volatile&&> >));
-#endif
-
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move volatile> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move const*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move const volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move* const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_move* volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_move* const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move volatile&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const volatile&> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move volatile&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const volatile&&> >));
-#endif
-
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor volatile> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor const*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor const volatile*> >));
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* const> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* volatile> >));
-BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* const volatile> >));
-
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor volatile&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const volatile&> >));
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor volatile&&> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const volatile&&> >));
-#endif
-
-
-BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int, float, void*> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float&, void*> >));
-BOOST_FUSION_ASSERT_CWG496((is_base_of<trivial_base, propagate_trivialness<int, float, trivial> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float, user_provided_copy> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float, user_provided_move> >));
-BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float, user_provided_dtor> >));
-
-
-struct S1 : private propagate_trivialness<int, float, void*> { };
-BOOST_MPL_ASSERT((is_trivially_copyable<S1>));
-
-struct S2 : private propagate_trivialness<int, float&, void*> { };
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S2>));
-
-struct S3 : private propagate_trivialness<int, float, trivial> { };
-BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<S3>));
-
-struct S4 : private propagate_trivialness<int, float, user_provided_copy> { };
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S4>));
-
-struct S5 : private propagate_trivialness<int, float, user_provided_move> { };
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S5>));
-
-struct S6 : private propagate_trivialness<int, float, user_provided_dtor> { };
-BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S6>));
--- a/test/support/trivial.hpp
+++ b/test/support/trivial.hpp
@ -1,66 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    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)
-==============================================================================*/
-#ifndef TRIVIAL_HPP
-#define TRIVIAL_HPP
-
-#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/static_assert.hpp>
-
-#if defined(BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE)
-#   define BOOST_FUSION_ASSERT_CWG496_SCALAR BOOST_MPL_ASSERT_NOT
-#elif defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
-#   define BOOST_FUSION_ASSERT_CWG496_SCALAR_I(...) BOOST_STATIC_ASSERT((__VA_ARGS__::value) == BOOST_FUSION_IS_TRIVIALLY_COPYABLE(int volatile))
-#   define BOOST_FUSION_ASSERT_CWG496_SCALAR(pred) BOOST_FUSION_ASSERT_CWG496_SCALAR_I pred
-#else
-#   define BOOST_FUSION_ASSERT_CWG496_SCALAR BOOST_MPL_ASSERT
-#endif
-
-#if defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
-#   define BOOST_FUSION_ASSERT_CWG496 BOOST_MPL_ASSERT
-#   define BOOST_FUSION_ASSERT_CWG2094_I(...) BOOST_STATIC_ASSERT((__VA_ARGS__::value) == BOOST_FUSION_IS_TRIVIALLY_COPYABLE(trivial volatile))
-#   define BOOST_FUSION_ASSERT_CWG2094(pred) BOOST_FUSION_ASSERT_CWG2094_I pred
-#elif defined(BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING)
-#   define BOOST_FUSION_ASSERT_CWG496 BOOST_MPL_ASSERT
-#   define BOOST_FUSION_ASSERT_CWG2094 BOOST_MPL_ASSERT
-#else
-#   define BOOST_FUSION_ASSERT_CWG496(pred) struct skip_assertion
-#   define BOOST_FUSION_ASSERT_CWG2094(pred) struct skip_assertion
-#endif
-
-
-struct S;
-typedef int (S::*member_type);
-typedef int (S::*member_function_type)();
-
-
-struct trivial { };
-
-
-struct user_provided_copy
-{
-    user_provided_copy(user_provided_copy const&);
-    user_provided_copy& operator=(user_provided_copy const&);
-};
-
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-struct user_provided_move
-{
-    user_provided_move(user_provided_move&&);
-    user_provided_move& operator=(user_provided_move&&);
-};
-#endif
-
-
-struct user_provided_dtor
-{
-    ~user_provided_dtor();
-};
-
-#endif
-
--- a/test/support/unused.cpp
+++ b/test/support/unused.cpp
@ -1,95 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2018 Kohei Takahashi
-
-    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/config.hpp>
-#include <boost/fusion/support/unused.hpp>
-#include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/static_assert.hpp>
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-#include <utility>
-#endif
-
-struct T { };
-
-void unused_construction()
-{
-    boost::fusion::unused_type dephault;
-
-    boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED parenthesis();
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED brace{};
-    boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED list_copy = {};
-#endif
-
-    boost::fusion::unused_type copy_copy BOOST_ATTRIBUTE_UNUSED = dephault;
-    boost::fusion::unused_type copy_direct BOOST_ATTRIBUTE_UNUSED (dephault);
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    boost::fusion::unused_type copy_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {dephault};
-    boost::fusion::unused_type copy_direct_brace BOOST_ATTRIBUTE_UNUSED {dephault};
-#endif
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    boost::fusion::unused_type move_copy BOOST_ATTRIBUTE_UNUSED = std::move(dephault);
-    boost::fusion::unused_type move_direct BOOST_ATTRIBUTE_UNUSED (std::move(dephault));
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    boost::fusion::unused_type move_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {std::move(dephault)};
-    boost::fusion::unused_type move_direct_brace BOOST_ATTRIBUTE_UNUSED {std::move(dephault)};
-#endif
-#endif
-
-
-    T value;
-
-    boost::fusion::unused_type T_copy_copy BOOST_ATTRIBUTE_UNUSED = value;
-    boost::fusion::unused_type T_copy_direct BOOST_ATTRIBUTE_UNUSED (value);
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    boost::fusion::unused_type T_copy_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {value};
-    boost::fusion::unused_type T_copy_direct_brace BOOST_ATTRIBUTE_UNUSED {value};
-#endif
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    boost::fusion::unused_type T_move_copy BOOST_ATTRIBUTE_UNUSED = std::move(value);
-    boost::fusion::unused_type T_move_direct BOOST_ATTRIBUTE_UNUSED (std::move(value));
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    boost::fusion::unused_type T_move_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {std::move(value)};
-    boost::fusion::unused_type T_move_direct_brace BOOST_ATTRIBUTE_UNUSED {std::move(value)};
-#endif
-#endif
-}
-
-void unused_assignment()
-{
-    boost::fusion::unused_type val1, val2;
-
-    val1 = val2;
-#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-    val1 = {};
-#endif
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    val1 = std::move(val2);
-#endif
-
-
-    T value;
-
-    val1 = value;
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    val1 = std::move(value);
-#endif
-}
-
-boost::type_traits::yes_type test_unused(boost::fusion::detail::unused_only const&);
-boost::type_traits::no_type  test_unused(...);
-
-void only_unused()
-{
-    BOOST_STATIC_ASSERT((sizeof(test_unused(boost::fusion::unused)) == sizeof(boost::type_traits::yes_type)));
-    BOOST_STATIC_ASSERT((sizeof(test_unused(0)) == sizeof(boost::type_traits::no_type)));
-
-    boost::fusion::unused_type my_unused;
-    BOOST_STATIC_ASSERT((sizeof(test_unused(my_unused)) == sizeof(boost::type_traits::yes_type)));
-}
Author	SHA1	Message	Date
Kohei Takahashi	4e57acbce7	Make fusion::pair trivially copyable if possible	2018-03-23 02:26:05 +09:00
Kohei Takahashi	44ef9e56e6	Added tests for support/pair	2018-03-23 02:25:38 +09:00