Adding upstream version 14.2.21.upstream/14.2.21upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

168 files changed, 13212 insertions, 0 deletions

diff --git a/src/boost/libs/fusion/test/sequence/adapt_adt.cpp b/src/boost/libs/fusion/test/sequence/adapt_adt.cpp
new file mode 100644
index 00000000..00a149b7
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_adt.cpp
@@ -0,0 +1,311 @@
+/*=============================================================================
+    Copyright (c) 2001-2009 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/adt/adapt_adt.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    class point
+    {
+    public:
+    
+        point() : x(0), y(0), z(0) {}
+        point(int in_x, int in_y, int in_z) : x(in_x), y(in_y), z(in_z) {}
+            
+        int get_x() const { return x; }
+        int get_y() const { return y; }
+        int get_z() const { return z; }
+        void set_x(int x_) { x = x_; }
+        void set_y(int y_) { y = y_; }
+        void set_z(int z_) { z = z_; }
+        
+    private:
+        
+        int x;
+        int y;
+        int z;
+    };
+
+#if !BOOST_WORKAROUND(__GNUC__,<4)
+    class point_with_private_members
+    {
+        friend struct boost::fusion::extension::access;
+
+    public:
+        point_with_private_members() : x(0), y(0), z(0) {}
+        point_with_private_members(int in_x, int in_y, int in_z) 
+          : x(in_x), y(in_y), z(in_z) {}
+            
+        int get_x() const { return x; }
+        int get_y() const { return y; }
+        int get_z() const { return z; }
+        void set_x(int x_) { x = x_; }
+        void set_y(int y_) { y = y_; }
+        void set_z(int z_) { z = z_; }
+        
+    private:
+        
+        int x;
+        int y;
+        int z;    
+    };
+#endif
+    
+    // A sequence that has data members defined in an unrelated namespace
+    // (std, in this case). This allows testing ADL issues.
+    class name
+    {
+    public:
+        name() {}
+        name(const std::string& last, const std::string& first)
+           : last(last), first(first) {}
+        
+        const std::string& get_last() const { return last; }
+        const std::string& get_first() const { return first; }
+        void set_last(const std::string& last_) { last = last_; }
+        void set_first(const std::string& first_) { first = first_; }
+    private:
+        std::string last;
+        std::string first;
+    };
+}
+
+#if BOOST_PP_VARIADICS
+  BOOST_FUSION_ADAPT_ADT(
+      ns::point,
+      (int, int, obj.get_x(), obj.set_x(val))
+      // Mixing auto & BOOST_FUSION_ADAPT_AUTO to test backward compatibility
+      (auto, BOOST_FUSION_ADAPT_AUTO, obj.get_y(), obj.set_y(val))
+      (obj.get_z(), obj.set_z(val))
+  )
+
+#   if !BOOST_WORKAROUND(__GNUC__,<4)
+    BOOST_FUSION_ADAPT_ADT(
+        ns::point_with_private_members,
+        (obj.get_x(), obj.set_x(val))
+        (obj.get_y(), obj.set_y(val))
+        (obj.get_z(), obj.set_z(val))
+    )
+#   endif
+
+
+  BOOST_FUSION_ADAPT_ADT(
+      ns::name,
+      (obj.get_last(), obj.set_last(val))
+      (obj.get_first(), obj.set_first(val))
+  )
+
+
+#else // BOOST_PP_VARIADICS
+  BOOST_FUSION_ADAPT_ADT(
+      ns::point,
+      (int, int, obj.get_x(), obj.set_x(val))
+      (auto, auto, obj.get_y(), obj.set_y(val))
+      (auto, auto, obj.get_z(), obj.set_z(val))
+  )
+
+#   if !BOOST_WORKAROUND(__GNUC__,<4)
+    BOOST_FUSION_ADAPT_ADT(
+        ns::point_with_private_members,
+        (auto, auto, obj.get_x(), obj.set_x(val))
+        (auto, auto, obj.get_y(), obj.set_y(val))
+        (auto, auto, obj.get_z(), obj.set_z(val))
+    )
+#   endif
+
+  BOOST_FUSION_ADAPT_ADT(
+      ns::name,
+      (const std::string&, const std::string&, obj.get_last(), obj.set_last(val))
+      (BOOST_FUSION_ADAPT_AUTO, auto, obj.get_first(), obj.set_first(val))
+  )
+
+#endif
+
+class empty_adt{};
+BOOST_FUSION_ADAPT_ADT(empty_adt,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<ns::point>::value);
+        ns::point p(123, 456, 789);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<ns::point>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<ns::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        fusion::vector<int, float, int> v1(4, 2.f, 2);
+        ns::point v2(5, 3, 3);
+        fusion::vector<long, double, int> v3(5, 4., 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+    
+    {
+        fusion::vector<std::string, std::string> v1("Lincoln", "Abraham");
+        ns::name v2("Roosevelt", "Franklin");
+        ns::name v3("Roosevelt", "Theodore");
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from ns::point to vector
+        ns::point p(5, 3, 3);
+        fusion::vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from ns::point to list
+        ns::point p(5, 3, 3);
+        fusion::list<int, long, int> l(p);
+        l = p;
+    }
+
+    {
+        BOOST_MPL_ASSERT((mpl::is_sequence<ns::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<ns::point,0>::type
+          , mpl::front<ns::point>::type>));
+    }
+
+#if !BOOST_WORKAROUND(__GNUC__,<4)
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point_with_private_members>));
+        BOOST_STATIC_ASSERT(!traits::is_view<ns::point_with_private_members>::value);
+        ns::point_with_private_members p(123, 456, 789);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<ns::point_with_private_members>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<ns::point_with_private_members>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+#endif
+
+    {
+        // Check types provided in case it's provided
+        BOOST_MPL_ASSERT((
+            boost::is_same<
+                boost::fusion::result_of::front<ns::point>::type,
+                boost::fusion::extension::adt_attribute_proxy<ns::point,0,false>
+            >));
+        BOOST_MPL_ASSERT((
+            boost::is_same<
+                boost::fusion::result_of::front<ns::point>::type::type,
+                int
+            >));
+        BOOST_MPL_ASSERT((
+            boost::is_same<
+                boost::fusion::result_of::front<ns::point const>::type,
+                boost::fusion::extension::adt_attribute_proxy<ns::point,0,true>
+            >));
+        BOOST_MPL_ASSERT((
+            boost::is_same<
+                boost::fusion::result_of::front<ns::point const>::type::type,
+                int
+            >));
+
+        // Check types provided in case it's deduced
+        BOOST_MPL_ASSERT((
+            boost::is_same<
+                boost::fusion::result_of::back<ns::point>::type,
+                boost::fusion::extension::adt_attribute_proxy<ns::point,2,false>
+            >));
+        BOOST_MPL_ASSERT((
+            boost::is_same<
+                boost::fusion::result_of::back<ns::point>::type::type,
+                int
+            >));
+        BOOST_MPL_ASSERT((
+            boost::is_same<
+                boost::fusion::result_of::back<ns::point const>::type,
+                boost::fusion::extension::adt_attribute_proxy<ns::point,2,true>
+            >));
+        BOOST_MPL_ASSERT((
+            boost::is_same<
+                boost::fusion::result_of::back<ns::point const>::type::type,
+                int
+            >));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_adt_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_adt_empty.cpp
new file mode 100644
index 00000000..03e786b7
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_adt_empty.cpp
@@ -0,0 +1,87 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/adt/adapt_adt.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+class empty_adt{};
+BOOST_FUSION_ADAPT_ADT(empty_adt,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_adt>));
+        BOOST_STATIC_ASSERT(!traits::is_view<empty_adt>::value);
+        empty_adt e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_adt>::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<empty_adt>));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<empty_adt>::type,
+            fusion::result_of::end<empty_adt>::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        empty_adt e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(v != e);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        empty_adt e;
+
+        // conversion from empty_adt to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_adt to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_adt>));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_adt_named.cpp b/src/boost/libs/fusion/test/sequence/adapt_adt_named.cpp
new file mode 100644
index 00000000..19d2d8b1
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_adt_named.cpp
@@ -0,0 +1,161 @@
+/*=============================================================================
+    Copyright (c) 2001-2009 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/adt/adapt_adt_named.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    class point
+    {
+    public:
+    
+        point() : x(0), y(0), z(0) {}
+        point(int in_x, int in_y, int in_z) : x(in_x), y(in_y), z(in_z) {}
+            
+        int get_x() const { return x; }
+        int get_y() const { return y; }
+        int get_z() const { return z; }
+        void set_x(int x_) { x = x_; }
+        void set_y(int y_) { y = y_; }
+        void set_z(int z_) { z = z_; }
+        
+    private:
+        
+        int x;
+        int y;
+        int z;
+    };
+}
+
+#if BOOST_PP_VARIADICS
+
+// this creates a fusion view: boost::fusion::adapted::point
+BOOST_FUSION_ADAPT_ADT_NAMED(
+    ns::point, point,
+    (int, int, obj.get_x(), obj.set_x(val))
+    (int, int, obj.get_y(), obj.set_y(val))
+    (obj.get_z(), obj.set_z(val))
+)
+
+#else // BOOST_PP_VARIADICS
+
+// this creates a fusion view: boost::fusion::adapted::point
+BOOST_FUSION_ADAPT_ADT_NAMED(
+    ns::point, point,
+    (int, int, obj.get_x(), obj.set_x(val))
+    (int, int, obj.get_y(), obj.set_y(val))
+    (auto, auto, obj.get_z(), obj.set_z(val))
+)
+
+#endif // BOOST_PP_VARIADICS
+
+
+class empty_adt{};
+BOOST_FUSION_ADAPT_ADT_NAMED(empty_adt,renamed_empty_adt,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT((traits::is_view<adapted::point>));
+        BOOST_STATIC_ASSERT(traits::is_view<adapted::point>::value);
+        ns::point basep(123, 456, 789);
+        adapted::point p(basep);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<adapted::point>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<adapted::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        fusion::vector<int, float, int> v1(4, 2.f, 2);
+        ns::point basep(5, 3, 3);
+        adapted::point v2(basep);
+
+        fusion::vector<long, double, int> v3(5, 4., 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from ns::point to vector
+        ns::point basep(5, 3, 3);
+        adapted::point p(basep);
+
+        fusion::vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from ns::point to list
+        ns::point basep(5, 3, 3);
+        adapted::point p(basep);
+
+        fusion::list<int, long, float> l(p);
+        l = p;
+    }
+
+    {
+        BOOST_MPL_ASSERT((mpl::is_sequence<adapted::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<adapted::point,0>::type
+          , mpl::front<adapted::point>::type>));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_adt_named_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_adt_named_empty.cpp
new file mode 100644
index 00000000..c7fa2033
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_adt_named_empty.cpp
@@ -0,0 +1,88 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/adt/adapt_adt_named.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+class empty_adt{};
+BOOST_FUSION_ADAPT_ADT_NAMED(::empty_adt,empty_adt,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    empty_adt empty;
+    {
+        BOOST_MPL_ASSERT((traits::is_view<adapted::empty_adt>));
+        BOOST_STATIC_ASSERT(traits::is_view<adapted::empty_adt>::value);
+        adapted::empty_adt e(empty);
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<adapted::empty_adt>::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<adapted::empty_adt>));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<adapted::empty_adt>::type,
+            fusion::result_of::end<adapted::empty_adt>::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        adapted::empty_adt e(empty);
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(v != e);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        adapted::empty_adt e(empty);
+
+        // conversion from empty_adt to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_adt to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<adapted::empty_adt>));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_adt.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt.cpp
new file mode 100644
index 00000000..a0dc2232
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt.cpp
@@ -0,0 +1,164 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    struct non_member;
+
+    class point
+    {
+    public:
+    
+        point() : x(0), y(0), z(0) {}
+        point(int in_x, int in_y, int in_z) : x(in_x), y(in_y), z(in_z) {}
+            
+        int get_x() const { return x; }
+        int get_y() const { return y; }
+        int get_z() const { return z; }
+        void set_x(int x_) { x = x_; }
+        void set_y(int y_) { y = y_; }
+        void set_z(int z_) { z = z_; }
+        
+    private:
+        
+        int x;
+        int y;
+        int z;
+    };
+}
+
+#if BOOST_PP_VARIADICS
+
+BOOST_FUSION_ADAPT_ASSOC_ADT(
+    ns::point,
+    (int, int, obj.get_x(), obj.set_x(val), ns::x_member)
+    (int, int, obj.get_y(), obj.set_y(val), ns::y_member)
+    (obj.get_z(), obj.set_z(val), ns::z_member)
+)
+
+#else // BOOST_PP_VARIADICS
+
+BOOST_FUSION_ADAPT_ASSOC_ADT(
+    ns::point,
+    (int, int, obj.get_x(), obj.set_x(val), ns::x_member)
+    (int, int, obj.get_y(), obj.set_y(val), ns::y_member)
+    (auto, auto, obj.get_z(), obj.set_z(val), ns::z_member)
+)
+
+#endif
+
+class empty_adt{};
+BOOST_FUSION_ADAPT_ASSOC_ADT(empty_adt,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<ns::point>::value);
+        ns::point p(123, 456, 789);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<ns::point>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<ns::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        boost::fusion::vector<int, float, int> v1(4, 2.f, 2);
+        ns::point v2(5, 3, 3);
+        boost::fusion::vector<long, double, int> v3(5, 4., 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from ns::point to vector
+        ns::point p(5, 3, 3);
+        boost::fusion::vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from ns::point to list
+        ns::point p(5, 3, 3);
+        boost::fusion::list<int, long, int> l(p);
+        l = p;
+    }
+
+    {
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<ns::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<ns::point,0>::type
+          , boost::mpl::front<ns::point>::type>));
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<ns::point, ns::x_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<ns::point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<ns::point, ns::z_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<boost::fusion::result_of::has_key<ns::point, ns::non_member> >));
+
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<ns::point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<ns::point, ns::y_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<ns::point, ns::z_member>::type, int>));
+
+        ns::point p(5, 3, 1);
+
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+        BOOST_TEST(at_key<ns::z_member>(p) == 1);
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_empty.cpp
new file mode 100644
index 00000000..26cd9857
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_empty.cpp
@@ -0,0 +1,89 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+class empty_adt{};
+BOOST_FUSION_ADAPT_ASSOC_ADT(empty_adt,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_adt>));
+        BOOST_STATIC_ASSERT(!traits::is_view<empty_adt>::value);
+        empty_adt e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_adt>::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<empty_adt>));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<empty_adt>::type,
+            fusion::result_of::end<empty_adt>::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        empty_adt e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(e != v);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        empty_adt e;
+
+        // conversion from empty_adt to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_adt to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_adt>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_adt, void>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_adt, int>));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named.cpp
new file mode 100644
index 00000000..ecdd9028
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named.cpp
@@ -0,0 +1,159 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/adapted/adt/adapt_assoc_adt_named.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    class point
+    {
+    public:
+    
+        point() : x(0), y(0) {}
+        point(int in_x, int in_y) : x(in_x), y(in_y) {}
+            
+        int get_x() const { return x; }
+        int get_y() const { return y; }
+        void set_x(int x_) { x = x_; }
+        void set_y(int y_) { y = y_; }
+        
+    private:
+        
+        int x;
+        int y;
+    };
+}
+
+#if BOOST_PP_VARIADICS
+
+    BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED(
+        ns::point,
+        point,
+        (obj.get_x(), obj.set_x(val), ns::x_member)
+        (int, int, obj.get_y(), obj.set_y(val), ns::y_member)
+    )
+
+#else // BOOST_PP_VARIADICS
+
+    BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED(
+        ns::point,
+        point,
+        (auto, auto, obj.get_x(), obj.set_x(val), ns::x_member)
+        (int, int, obj.get_y(), obj.set_y(val), ns::y_member)
+    )
+
+#endif
+
+
+class empty_adt{};
+BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED(empty_adt, renamed_empty_adt,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT((traits::is_view<adapted::point>));
+        BOOST_STATIC_ASSERT(traits::is_view<adapted::point>::value);
+        ns::point basep(123, 456);
+        adapted::point p(basep);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<adapted::point>::value == 2);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<adapted::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        boost::fusion::vector<int, float> v1(4, 2.f);
+        ns::point basev2(5, 3);
+        adapted::point v2(basev2);
+        boost::fusion::vector<long, double> v3(5, 4.);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from adapted::point to vector
+        ns::point basep(5, 3);
+        adapted::point p(basep);
+        boost::fusion::vector<int, long> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from adated::point to list
+        ns::point basep(5, 3);
+        adapted::point p(basep);
+        boost::fusion::list<int, long> l(p);
+        l = p;
+    }
+
+    {
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<adapted::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<adapted::point,0>::type
+          , boost::mpl::front<adapted::point>::type>));
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<adapted::point, ns::x_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<adapted::point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<boost::fusion::result_of::has_key<adapted::point, ns::z_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<adapted::point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<adapted::point, ns::y_member>::type, int>));
+
+        ns::point basep(5, 3);
+        adapted::point p(basep);
+
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named_empty.cpp
new file mode 100644
index 00000000..e2e26800
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_adt_named_empty.cpp
@@ -0,0 +1,90 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/adt/adapt_assoc_adt_named.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+class empty_adt{};
+BOOST_FUSION_ADAPT_ASSOC_ADT_NAMED(::empty_adt,empty_adt,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    empty_adt empty;
+    {
+        BOOST_MPL_ASSERT((traits::is_view<adapted::empty_adt>));
+        BOOST_STATIC_ASSERT(traits::is_view<adapted::empty_adt>::value);
+        adapted::empty_adt e(empty);
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<adapted::empty_adt>::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<adapted::empty_adt>));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<adapted::empty_adt>::type,
+            fusion::result_of::end<adapted::empty_adt>::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        adapted::empty_adt e(empty);
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(e != v);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        adapted::empty_adt e(empty);
+
+        // conversion from empty_adt to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_adt to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<adapted::empty_adt>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<adapted::empty_adt, void>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<adapted::empty_adt, int>));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_struct.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct.cpp
new file mode 100644
index 00000000..6266e95f
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct.cpp
@@ -0,0 +1,168 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2005-2007 Dan Marsden
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/has_key.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at_key.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/back.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+    struct non_member;
+
+    struct point
+    {
+        int x;
+        int y;
+        int z;
+    };
+}
+
+#if BOOST_PP_VARIADICS
+  BOOST_FUSION_ADAPT_ASSOC_STRUCT(
+      ns::point,
+      (x, ns::x_member)
+      (auto, y, ns::y_member)
+      (int, z, ns::z_member)
+  )
+
+#else // BOOST_PP_VARIADICS
+  BOOST_FUSION_ADAPT_ASSOC_STRUCT(
+      ns::point,
+      (auto, x, ns::x_member)
+      (auto, y, ns::y_member)
+      (int, z, ns::z_member)
+  )
+
+#endif
+
+struct empty_struct {};
+BOOST_FUSION_ADAPT_ASSOC_STRUCT(empty_struct,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<ns::point>::value);
+        ns::point p = {123, 456, 789};
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<ns::point>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<ns::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        fusion::vector<int, float, int> v1(4, 2.f, 2);
+        ns::point v2 = {5, 3, 3};
+        fusion::vector<long, double, int> v3(5, 4., 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from ns::point to vector
+        ns::point p = {5, 3, 3};
+        fusion::vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from ns::point to list
+        ns::point p = {5, 3, 3};
+        fusion::list<int, long, int> l(p);
+        l = p;
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<ns::point, ns::x_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<ns::point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<ns::point, ns::z_member>));
+        BOOST_MPL_ASSERT((mpl::not_<boost::fusion::result_of::has_key<ns::point, ns::non_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<ns::point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<ns::point, ns::y_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<ns::point, ns::z_member>::type, int>));
+
+        ns::point p = {5, 3, 9};
+        
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+        BOOST_TEST(at_key<ns::z_member>(p) == 9);
+    }
+
+    {
+        BOOST_MPL_ASSERT((mpl::is_sequence<ns::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<ns::point,0>::type
+          , mpl::front<ns::point>::type>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<ns::point,2>::type
+          , mpl::back<ns::point>::type>));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_empty.cpp
new file mode 100644
index 00000000..c7cadf94
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_empty.cpp
@@ -0,0 +1,89 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+class empty_struct{};
+BOOST_FUSION_ADAPT_ASSOC_STRUCT(empty_struct,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
+        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
+        empty_struct e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct>::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<empty_struct>));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<empty_struct>::type,
+            fusion::result_of::end<empty_struct>::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        empty_struct e;
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        empty_struct e;
+
+        // conversion from empty_struct to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_struct to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_struct, void>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_struct, int>));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named.cpp
new file mode 100644
index 00000000..96606787
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named.cpp
@@ -0,0 +1,139 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/adapted/struct/adapt_assoc_struct_named.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    struct point
+    {
+        int x;
+        int y;
+    };
+}
+
+
+#if BOOST_PP_VARIADICS
+
+    BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(
+        ns::point,
+        point,
+        (x, ns::x_member)
+        (auto, y, ns::y_member)
+    )
+
+#else // BOOST_PP_VARIADICS
+
+    BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(
+        ns::point,
+        point,
+        (int, x, ns::x_member)
+        (auto, y, ns::y_member)
+    )
+
+#endif
+
+struct empty_struct {};
+BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(empty_struct, renamed_empty_struct,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT((traits::is_view<adapted::point>));
+        BOOST_STATIC_ASSERT(traits::is_view<adapted::point>::value);
+        ns::point basep = {123, 456};
+        adapted::point p(basep);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<adapted::point>::value == 2);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<adapted::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        vector<int, float> v1(4, 2.f);
+        ns::point basev2 = {5, 3};
+        adapted::point v2(basev2);
+
+        vector<long, double> v3(5, 4.);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from adapted::point to vector
+        ns::point basep = {5, 3};
+        adapted::point p(basep);
+        vector<int, long> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from adapted::point to list
+        ns::point basep = {5, 3};
+        adapted::point p(basep);
+        list<int, long> l(p);
+        l = p;
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<adapted::point, ns::x_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<adapted::point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<boost::fusion::result_of::has_key<adapted::point, ns::z_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<adapted::point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<adapted::point, ns::y_member>::type, int>));
+
+        ns::point basep = {5, 3};
+        adapted::point p(basep);
+        
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named_empty.cpp
new file mode 100644
index 00000000..a1783fd3
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_struct_named_empty.cpp
@@ -0,0 +1,90 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_assoc_struct_named.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+class empty_struct{};
+BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(::empty_struct,empty_struct,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    empty_struct empty;
+    {
+        BOOST_MPL_ASSERT((traits::is_view<adapted::empty_struct>));
+        BOOST_STATIC_ASSERT(traits::is_view<adapted::empty_struct>::value);
+        adapted::empty_struct e(empty);
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<adapted::empty_struct>::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<adapted::empty_struct>));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<adapted::empty_struct>::type,
+            fusion::result_of::end<adapted::empty_struct>::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        adapted::empty_struct e(empty);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        adapted::empty_struct e(empty);
+
+        // conversion from empty_struct to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_struct to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<adapted::empty_struct>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<adapted::empty_struct, void>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<adapted::empty_struct, int>));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt.cpp
new file mode 100644
index 00000000..f416f46a
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt.cpp
@@ -0,0 +1,177 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    struct non_member;
+
+    template<typename X, typename Y, typename Z>
+    class point
+    {
+    public:
+    
+        point() : x(0), y(0), z(0) {}
+        point(X in_x, Y in_y, Z in_z) : x(in_x), y(in_y), z(in_z) {}
+            
+        X get_x() const { return x; }
+        Y get_y() const { return y; }
+        Z get_z() const { return z; }
+        void set_x(X x_) { x = x_; }
+        void set_y(Y y_) { y = y_; }
+        void set_z(Z z_) { z = z_; }
+        
+    private:
+        
+        X x;
+        Y y;
+        Z z;
+    };
+}
+
+#if BOOST_PP_VARIADICS
+BOOST_FUSION_ADAPT_ASSOC_TPL_ADT(
+    (X)(Y)(Z),
+    (ns::point)(X)(Y)(Z),
+    (X, X, obj.get_x(), obj.set_x(val), ns::x_member)
+    (Y, Y, obj.get_y(), obj.set_y(val), ns::y_member)
+    (obj.get_z(), obj.set_z(val), ns::z_member)
+)
+  
+#else // BOOST_PP_VARIADICS
+BOOST_FUSION_ADAPT_ASSOC_TPL_ADT(
+    (X)(Y)(Z),
+    (ns::point)(X)(Y)(Z),
+    (X, X, obj.get_x(), obj.set_x(val), ns::x_member)
+    (Y, Y, obj.get_y(), obj.set_y(val), ns::y_member)
+    (auto, auto, obj.get_z(), obj.set_z(val), ns::z_member)
+)
+
+#endif
+
+template <typename TypeToConstruct>
+class empty_adt_templated_factory {
+
+  TypeToConstruct operator()() {
+    return TypeToConstruct();
+  }
+
+};
+
+BOOST_FUSION_ADAPT_ASSOC_TPL_ADT(
+    (TypeToConstruct),
+    (empty_adt_templated_factory)(TypeToConstruct),
+) 
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    typedef ns::point<int,int,long> point;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
+        point p(123, 456, 789);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<point>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        boost::fusion::vector<int, float, long> v1(4, 2.f, 2);
+        point v2(5, 3, 3);
+        boost::fusion::vector<long, double, long> v3(5, 4., 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p(5, 3, 3);
+        boost::fusion::vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p(5, 3, 3);
+        boost::fusion::list<int, long, int> l(p);
+        l = p;
+    }
+
+    {
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<point,0>::type
+          , boost::mpl::front<point>::type>));
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<point, ns::x_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<point, ns::z_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<boost::fusion::result_of::has_key<point, ns::non_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<point, ns::y_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<point, ns::z_member>::type, long>));
+
+        point p(5, 3, 1);
+
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+        BOOST_TEST(at_key<ns::z_member>(p) == 1);
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt_empty.cpp
new file mode 100644
index 00000000..f38ba7ac
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_adt_empty.cpp
@@ -0,0 +1,89 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+template <typename T>
+class empty_adt{};
+BOOST_FUSION_ADAPT_ASSOC_TPL_ADT((T), (empty_adt)(T),)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_adt<void> >));
+        empty_adt<void> e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_adt<void> >::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<empty_adt<void> >));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<empty_adt<void> >::type,
+            fusion::result_of::end<empty_adt<void> >::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        empty_adt<void>  e;
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        empty_adt<void> e;
+
+        // conversion from empty_adt to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_adt to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_adt<void> >));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_adt<void>, void>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_adt<void>, int>));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct.cpp
new file mode 100644
index 00000000..49f42c5d
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct.cpp
@@ -0,0 +1,168 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/has_key.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at_key.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    struct non_member;
+
+    template<typename X, typename Y, typename Z>
+    struct point
+    {
+        X x;
+        Y y;
+        Z z;
+    };
+}
+
+#if BOOST_PP_VARIADICS
+  BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT(
+        (X)(Y)(Z),
+        (ns::point)(X)(Y)(Z),
+        (int, x, ns::x_member)
+        (auto, y, ns::y_member)
+        (z, ns::z_member)
+    )
+
+#else // BOOST_PP_VARIADICS
+  BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT(
+      (X)(Y)(Z),
+      (ns::point)(X)(Y)(Z),
+      (int, x, ns::x_member)
+      (Y, y, ns::y_member)
+      (auto, z, ns::z_member)
+  )
+#endif
+
+template <typename TypeToConstruct>
+struct empty_struct_templated_factory {
+
+  TypeToConstruct operator()() {
+    return TypeToConstruct();
+  }
+
+};
+
+BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT(
+    (TypeToConstruct),
+    (empty_struct_templated_factory)(TypeToConstruct),
+) 
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    typedef ns::point<int,int,float> point;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
+        point p = {123, 456, 789.43f};
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789.43f));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<point>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        vector<int, float, int> v1(4, 2.f, 2);
+        point v2 = {5, 3, 3.f};
+        vector<long, double, float> v3(5, 4., 4.13f);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p = {5, 3, 3.f};
+        vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p = {5, 3, 3.f};
+        list<int, long, int> l(p);
+        l = p;
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<point, ns::x_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<point, ns::z_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<boost::fusion::result_of::has_key<point, ns::non_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<point, ns::y_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<point, ns::z_member>::type, float>));
+
+        point p = {5, 3, 9.f};
+        
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+        BOOST_TEST(at_key<ns::z_member>(p) == 9);
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct_empty.cpp
new file mode 100644
index 00000000..42795c41
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_assoc_tpl_struct_empty.cpp
@@ -0,0 +1,89 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+template <typename T>
+class empty_struct{};
+BOOST_FUSION_ADAPT_ASSOC_TPL_STRUCT((T), (empty_struct)(T),)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct<void> >));
+        empty_struct<void> e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct<void> >::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<empty_struct<void> >));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<empty_struct<void> >::type,
+            fusion::result_of::end<empty_struct<void> >::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        empty_struct<void> e;
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        empty_struct<void> e;
+
+        // conversion from empty_struct to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_struct to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct<void> >));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_struct<void>, void>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_struct<void>, int>));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_struct.cpp b/src/boost/libs/fusion/test/sequence/adapt_struct.cpp
new file mode 100644
index 00000000..3518ff41
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_struct.cpp
@@ -0,0 +1,271 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_struct.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace namespaced_type {
+  typedef int integer;
+}
+
+namespace ns
+{
+    struct point
+    {
+        int x;
+        int y;
+        namespaced_type::integer z;
+    };
+
+#if !BOOST_WORKAROUND(__GNUC__,<4)
+    struct point_with_private_attributes
+    {
+        friend struct boost::fusion::extension::access;
+
+    private:
+        int x;
+        int y;
+        int z;
+
+    public:
+        point_with_private_attributes(int x, int y, int z):x(x),y(y),z(z)
+        {}
+    };
+#endif
+
+    struct foo
+    {
+        int x;
+    };
+    
+    struct bar
+    {
+        foo foo_;
+        int y;
+    };
+
+
+    // Testing non-constexpr compatible types
+    struct employee {
+      std::string name;
+      std::string nickname;
+
+      employee(std::string name, std::string nickname)
+        : name(name), nickname(nickname) 
+      {}
+    };
+}
+
+#if BOOST_PP_VARIADICS
+
+    BOOST_FUSION_ADAPT_STRUCT(
+        ns::point,
+        x,
+        y,
+        z
+    )
+
+#   if !BOOST_WORKAROUND(__GNUC__,<4)
+    BOOST_FUSION_ADAPT_STRUCT(
+        ns::point_with_private_attributes,
+        x,
+        y,
+        z
+    )
+#   endif
+
+    struct s { int m; };
+    BOOST_FUSION_ADAPT_STRUCT(s, m)
+
+    BOOST_FUSION_ADAPT_STRUCT(
+        ns::bar,
+        foo_.x, // test that adapted members can actually be expressions
+        (auto , y)
+    )
+
+    BOOST_FUSION_ADAPT_STRUCT(
+        ns::employee,
+        name,
+        nickname
+    )
+        
+
+#else // BOOST_PP_VARIADICS
+
+    BOOST_FUSION_ADAPT_STRUCT(
+        ns::point,
+        (int, x)
+        (auto, y)
+        (namespaced_type::integer, z)
+    )
+
+#   if !BOOST_WORKAROUND(__GNUC__,<4)
+    BOOST_FUSION_ADAPT_STRUCT(
+        ns::point_with_private_attributes,
+        (int, x)
+        (int, y)
+        (auto, z)
+    )
+#   endif
+
+    struct s { int m; };
+    BOOST_FUSION_ADAPT_STRUCT(s, (auto, m))
+
+    BOOST_FUSION_ADAPT_STRUCT(
+        ns::bar,
+        (auto, foo_.x) // test that adapted members can actually be expressions
+        (BOOST_FUSION_ADAPT_AUTO, y) // Mixing auto & BOOST_FUSION_ADAPT_AUTO 
+                                     // to test backward compatibility
+    )
+
+    BOOST_FUSION_ADAPT_STRUCT(
+        ns::employee,
+        (std::string, name)
+        (BOOST_FUSION_ADAPT_AUTO, nickname)
+    )
+
+#endif
+
+struct empty_struct {};
+BOOST_FUSION_ADAPT_STRUCT(empty_struct,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+    using ns::point;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
+        point p = {123, 456, 789};
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<point>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        vector<int, float, int> v1(4, 2.f, 2);
+        point v2 = {5, 3, 3};
+        vector<long, double, int> v3(5, 4., 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p = {5, 3, 3};
+        vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p = {5, 3, 3};
+        list<int, long, int> l(p);
+        l = p;
+    }
+
+    { // begin/end
+        using namespace boost::fusion;
+        using boost::is_same;
+
+        typedef boost::fusion::result_of::begin<s>::type b;
+        typedef boost::fusion::result_of::end<s>::type e;
+        // this fails
+        BOOST_MPL_ASSERT((is_same<boost::fusion::result_of::next<b>::type, e>));
+    }
+
+    {
+        BOOST_MPL_ASSERT((mpl::is_sequence<ns::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<ns::point,0>::type
+          , mpl::front<ns::point>::type>));
+    }
+
+#if !BOOST_WORKAROUND(__GNUC__,<4)
+    {
+        ns::point_with_private_attributes p(123, 456, 789);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+    }
+#endif
+
+    {
+        fusion::vector<int, float> v1(4, 2.f);
+        ns::bar v2 = {{5}, 3};
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+    }
+
+    {
+        ns::employee emp("John Doe", "jdoe"); 
+        std::cout << at_c<0>(emp) << std::endl;
+        std::cout << at_c<1>(emp) << std::endl;
+
+        fusion::vector<std::string, std::string> v1("John Doe", "jdoe");
+        BOOST_TEST(emp == v1);
+    } 
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_struct_empty.cpp
new file mode 100644
index 00000000..202131d4
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_struct_empty.cpp
@@ -0,0 +1,87 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_struct.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+class empty_struct{};
+BOOST_FUSION_ADAPT_STRUCT(empty_struct,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
+        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
+        empty_struct e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct>::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<empty_struct>));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<empty_struct>::type,
+            fusion::result_of::end<empty_struct>::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        empty_struct e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(e != v);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        empty_struct e;
+
+        // conversion from empty_struct to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_struct to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct>));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_struct_named.cpp b/src/boost/libs/fusion/test/sequence/adapt_struct_named.cpp
new file mode 100644
index 00000000..ec5cf7ba
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_struct_named.cpp
@@ -0,0 +1,164 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_struct_named.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct point
+    {
+        int x;
+        int y;
+        int z;
+    };
+}
+
+#if BOOST_PP_VARIADICS
+
+    // this creates a fusion view: boost::fusion::adapted::point
+    BOOST_FUSION_ADAPT_STRUCT_NAMED(
+        ns::point, point,
+        x,
+        y,
+        z
+    )
+
+    // this creates a fusion view: ns1::s1
+    struct s { int m; };
+    BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(s, (ns1), s1, m)
+
+#else // BOOST_PP_VARIADICS
+
+    // this creates a fusion view: boost::fusion::adapted::point
+    BOOST_FUSION_ADAPT_STRUCT_NAMED(
+        ns::point, point,
+        (int, x)
+        (BOOST_FUSION_ADAPT_AUTO, y)
+        (auto, z)
+    )
+
+    // this creates a fusion view: ns1::s1
+    struct s { int m; };
+    BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(s, (ns1), s1, (auto, m))
+
+#endif 
+
+struct empty_struct {};
+BOOST_FUSION_ADAPT_STRUCT_NAMED(empty_struct, renamed_empty_struct, )
+BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(empty_struct, (ns1), renamed_empty_struct1, ) 
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT((traits::is_view<adapted::point>));
+        BOOST_STATIC_ASSERT(traits::is_view<adapted::point>::value);
+        ns::point basep = {123, 456, 789};
+        adapted::point p(basep);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<adapted::point>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<adapted::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        fusion::vector<int, float, int> v1(4, 2.f, 2);
+        ns::point p = {5, 3, 3};
+        adapted::point v2(p);
+
+        fusion::vector<long, double, int> v3(5, 4., 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from adapted::point to vector
+        ns::point basep = {5, 3, 3};
+        adapted::point p(basep);
+        fusion::vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from adapted::point to list
+        ns::point basep = {5, 3, 3};
+        adapted::point p(basep);
+        fusion::list<int, long, int> l(p);
+        l = p;
+    }
+
+    { // begin/end
+        using namespace boost::fusion;
+        using boost::is_same;
+
+        typedef boost::fusion::result_of::begin<ns1::s1>::type b;
+        typedef boost::fusion::result_of::end<ns1::s1>::type e;
+        // this fails
+        BOOST_MPL_ASSERT((is_same<boost::fusion::result_of::next<b>::type, e>));
+    }
+
+
+    {
+        BOOST_MPL_ASSERT((mpl::is_sequence<adapted::point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<adapted::point,0>::type
+          , mpl::front<adapted::point>::type>));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_struct_named_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_struct_named_empty.cpp
new file mode 100644
index 00000000..7272f6f6
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_struct_named_empty.cpp
@@ -0,0 +1,88 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_struct_named.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+class empty_struct{};
+BOOST_FUSION_ADAPT_STRUCT_NAMED(::empty_struct,empty_struct,)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    empty_struct empty;
+    {
+        BOOST_MPL_ASSERT((traits::is_view<adapted::empty_struct>));
+        BOOST_STATIC_ASSERT(traits::is_view<adapted::empty_struct>::value);
+        adapted::empty_struct e(empty);
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<adapted::empty_struct>::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<adapted::empty_struct>));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<adapted::empty_struct>::type,
+            fusion::result_of::end<adapted::empty_struct>::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        adapted::empty_struct e(empty);
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(e != v);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        adapted::empty_struct e(empty);
+
+        // conversion from empty_struct to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_struct to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<adapted::empty_struct>));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_tpl_adt.cpp b/src/boost/libs/fusion/test/sequence/adapt_tpl_adt.cpp
new file mode 100644
index 00000000..d917134a
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_tpl_adt.cpp
@@ -0,0 +1,182 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/adt/adapt_adt.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    template<typename X, typename Y>
+    class point
+    {
+    public:
+    
+        point() : x(0), y(0), z(0) {}
+        point(X x_, Y y_, int z_) : x(x_), y(y_), z(z_) {}
+            
+        X get_x() const { return x; }
+        Y get_y() const { return y; }
+        int get_z() const { return z; }
+        void set_x(X x_) { x = x_; }
+        void set_y(Y y_) { y = y_; }
+        void set_z(int z_) { z = z_; }
+        
+    private:
+        
+        X x;
+        Y y;
+        int z;
+    };
+}
+
+
+#if BOOST_PP_VARIADICS
+
+  BOOST_FUSION_ADAPT_TPL_ADT(
+      (X)(Y),
+      (ns::point)(X)(Y),
+      (X, X, obj.get_x(), obj.set_x(val))
+      (Y, Y, obj.get_y(), obj.set_y(val))
+      (obj.get_z(), obj.set_z(val))
+  )
+
+#else // BOOST_PP_VARIADICS
+
+  BOOST_FUSION_ADAPT_TPL_ADT(
+      (X)(Y),
+      (ns::point)(X)(Y),
+      (X, X, obj.get_x(), obj.set_x(val))
+      (Y, Y, obj.get_y(), obj.set_y(val))
+      (auto, auto, obj.get_z(), obj.set_z(val))
+  )
+#endif
+
+template <typename TypeToConstruct>
+class empty_adt_templated_factory {
+
+  TypeToConstruct operator()() {
+    return TypeToConstruct();
+  }
+
+};
+
+BOOST_FUSION_ADAPT_TPL_ADT(
+    (TypeToConstruct),
+    (empty_adt_templated_factory)(TypeToConstruct),
+) 
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    typedef ns::point<int, int> point;
+    typedef ns::point<std::string, std::string> name;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
+        point p(123, 456, 789);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<point>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        boost::fusion::vector<int, float, int> v1(4, 2.f, 2);
+        point v2(5, 3, 3);
+        boost::fusion::vector<long, double, int> v3(5, 4., 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        boost::fusion::vector<std::string, std::string, int> v1("Lincoln", "Abraham", 3);
+        name v2("Roosevelt", "Franklin", 3);
+        name v3("Roosevelt", "Theodore", 3);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+    
+    {
+        // conversion from point to vector
+        point p(5, 3, 3);
+        boost::fusion::vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p(5, 3, 3);
+        boost::fusion::list<int, long, int> l(p);
+        l = p;
+    }
+
+    {
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<point>));
+        BOOST_MPL_ASSERT((boost::is_same<
+            boost::fusion::result_of::value_at_c<point,0>::type
+          , boost::mpl::front<point>::type>));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_tpl_adt_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_tpl_adt_empty.cpp
new file mode 100644
index 00000000..82bf2121
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_tpl_adt_empty.cpp
@@ -0,0 +1,87 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/adt/adapt_adt.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+template <typename T>
+class empty_adt{};
+BOOST_FUSION_ADAPT_TPL_ADT((T), (empty_adt)(T),)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_adt<void> >));
+        empty_adt<void> e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_adt<void> >::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<empty_adt<void> >));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<empty_adt<void> >::type,
+            fusion::result_of::end<empty_adt<void> >::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        empty_adt<void> e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(v != e);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(e > v);
+        BOOST_TEST(e >= v);
+    }
+
+    {
+        empty_adt<void> e;
+
+        // conversion from empty_adt to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_adt to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_adt<void> >));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_tpl_struct.cpp b/src/boost/libs/fusion/test/sequence/adapt_tpl_struct.cpp
new file mode 100644
index 00000000..1776cd62
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_tpl_struct.cpp
@@ -0,0 +1,159 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_struct.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    template<typename X, typename Y>
+    struct point
+    {
+        X x;
+        Y y;
+        int z;
+    };
+}
+
+#if BOOST_PP_VARIADICS
+
+    BOOST_FUSION_ADAPT_TPL_STRUCT(
+        (X)(Y),
+        (ns::point)(X)(Y),
+        x,
+        (auto, y)
+        (int, z)
+    )
+
+    template<typename M>
+    struct s { M m; };
+    BOOST_FUSION_ADAPT_TPL_STRUCT((M), (s)(M), m)
+
+#else // BOOST_PP_VARIADICS
+
+    BOOST_FUSION_ADAPT_TPL_STRUCT(
+        (X)(Y),
+        (ns::point)(X)(Y),
+        (X, x)
+        (Y, y)
+        (auto, z)
+    )
+
+    template<typename M>
+    struct s { M m; };
+    BOOST_FUSION_ADAPT_TPL_STRUCT((M), (s)(M), (auto, m))
+
+#endif
+
+template <typename TypeToConstruct>
+struct empty_struct_templated_factory {
+
+  TypeToConstruct operator()() {
+    return TypeToConstruct();
+  }
+
+};
+
+BOOST_FUSION_ADAPT_TPL_STRUCT(
+    (TypeToConstruct),
+    (empty_struct_templated_factory)(TypeToConstruct),
+) 
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    typedef ns::point<int, int> point;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
+        point p = {123, 456, 789};
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << at_c<2>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456, 789));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        at_c<2>(p) = 12;
+        BOOST_TEST(p == make_vector(6, 9, 12));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<point>::value == 3);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 12);
+    }
+
+    {
+        vector<int, float, int> v1(4, 2.f, 2);
+        point v2 = {5, 3, 3};
+        vector<long, double, int> v3(5, 4., 4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p = {5, 3, 3};
+        vector<int, long, int> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p = {5, 3, 3};
+        list<int, long> l(p);
+        l = p;
+    }
+
+    { // begin/end
+        using namespace boost::fusion;
+
+        typedef boost::fusion::result_of::begin<s<int> >::type b;
+        typedef boost::fusion::result_of::end<s<int> >::type e;
+        // this fails
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::next<b>::type, e>));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adapt_tpl_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/adapt_tpl_struct_empty.cpp
new file mode 100644
index 00000000..5cb1d442
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adapt_tpl_struct_empty.cpp
@@ -0,0 +1,87 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_struct.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+
+template <typename T>
+class empty_struct{};
+BOOST_FUSION_ADAPT_TPL_STRUCT((T), (empty_struct)(T),)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct<void> >));
+        empty_struct<void> e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct<void> >::value == 0);
+        BOOST_MPL_ASSERT((fusion::result_of::empty<empty_struct<void> >));
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<
+            fusion::result_of::begin<empty_struct<void> >::type,
+            fusion::result_of::end<empty_struct<void> >::type>));
+    }
+
+    {
+        fusion::vector<> v;
+        empty_struct<void> e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(v != e);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(v > e);
+        BOOST_TEST(v >= e);
+    }
+
+    {
+        empty_struct<void> e;
+
+        // conversion from empty_struct to vector
+        fusion::vector<> v(e);
+        v = e;
+
+        // FIXME
+        // conversion from empty_struct to list
+        //fusion::list<> l(e);
+        //l = e;
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct<void> >));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/adt_attribute_proxy.cpp b/src/boost/libs/fusion/test/sequence/adt_attribute_proxy.cpp
new file mode 100644
index 00000000..eae4eb9a
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/adt_attribute_proxy.cpp
@@ -0,0 +1,189 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    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/core/lightweight_test.hpp>
+#include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <iostream>
+#include <string>
+
+namespace fusion=boost::fusion;
+
+template<typename Name, typename Age>
+struct employee
+{
+private:
+    Name name;
+    Age age;
+
+public:
+    template<typename OtherName>
+    void
+    set_name(OtherName const& n)
+    {
+        name=n;
+    }
+
+    template<typename OtherAge>
+    void
+    set_age(OtherAge const& a)
+    {
+        age=a;
+    }
+
+    Name& get_name()
+    {
+        return name;
+    }
+
+    Name const& get_name()const
+    {
+        return name;
+    }
+
+    Age& get_age()
+    {
+        return age;
+    }
+
+    Age const& get_age()const
+    {
+        return age;
+    }
+};
+
+namespace keys
+{
+    struct name;
+    struct age;
+}
+
+BOOST_FUSION_ADAPT_ASSOC_TPL_ADT(
+    (Name)(Age),
+    (employee) (Name)(Age),
+    (Name&, Name const&, obj.get_name(), obj.template set_name<Val>(val), keys::name)
+        (Age&, Age const&, obj.get_age(), obj.template set_age<Val>(val), keys::age))
+
+int main()
+{
+    typedef employee<std::string, int> et;
+    typedef et const etc;
+    et e;
+    etc& ec=e;
+
+    fusion::at_key<keys::name>(e)="marshall mathers";
+    fusion::at_key<keys::age>(e)=37;
+
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::value_at_key<et, keys::name>::type,
+            std::string
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::value_at_key<et, keys::name>::type,
+            boost::fusion::result_of::value_at_c<et, 0>::type
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::value_at_key<et, keys::age>::type,
+            int
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::value_at_key<et, keys::age>::type,
+            boost::fusion::result_of::value_at_c<et, 1>::type
+        >));
+
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::at_key<et, keys::name>::type,
+            fusion::extension::adt_attribute_proxy<et, 0, false>
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::at_key<et, keys::age>::type,
+            fusion::extension::adt_attribute_proxy<et, 1, false>
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::at_key<et, keys::name>::type,
+            boost::fusion::result_of::front<et>::type
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::at_key<et, keys::age>::type,
+            boost::fusion::result_of::back<et>::type
+        >));
+
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::at_key<etc, keys::name>::type,
+            fusion::extension::adt_attribute_proxy<et, 0, true>
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::at_key<etc, keys::age>::type,
+            fusion::extension::adt_attribute_proxy<et, 1, true>
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::at_key<etc, keys::name>::type,
+            boost::fusion::result_of::front<etc>::type
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            boost::fusion::result_of::at_key<etc, keys::age>::type,
+            boost::fusion::result_of::back<etc>::type
+        >));
+
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            fusion::extension::adt_attribute_proxy<et, 0, false>::type,
+            std::string&
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            fusion::extension::adt_attribute_proxy<et, 0, true>::type,
+            std::string const&
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            fusion::extension::adt_attribute_proxy<et, 1, false>::type,
+            int&
+        >));
+    BOOST_MPL_ASSERT((
+        boost::is_same<
+            fusion::extension::adt_attribute_proxy<et, 1, true>::type,
+            int const&
+        >));
+
+    {
+        std::string& name=fusion::at_key<keys::name>(e);
+        int& age=fusion::at_key<keys::age>(e);
+        BOOST_TEST(name=="marshall mathers");
+        BOOST_TEST(age==37);
+        BOOST_TEST(fusion::at_key<keys::name>(e).get()=="marshall mathers");
+        BOOST_TEST(fusion::at_key<keys::age>(e).get()==37);
+        BOOST_TEST(fusion::front(e).get()=="marshall mathers");
+        BOOST_TEST(fusion::back(e).get()==37);
+    }
+
+    {
+        std::string const& name=fusion::at_key<keys::name>(ec);
+        int const& age=fusion::at_key<keys::age>(ec);
+        BOOST_TEST(name=="marshall mathers");
+        BOOST_TEST(age==37);
+        BOOST_TEST(fusion::at_key<keys::name>(ec).get()=="marshall mathers");
+        BOOST_TEST(fusion::at_key<keys::age>(ec).get()==37);
+        BOOST_TEST(fusion::front(ec).get()=="marshall mathers");
+        BOOST_TEST(fusion::back(ec).get()==37);
+    }
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/array.cpp b/src/boost/libs/fusion/test/sequence/array.cpp
new file mode 100644
index 00000000..ca4a40ac
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/array.cpp
@@ -0,0 +1,41 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/fusion/adapted/array.hpp>
+#include <boost/fusion/sequence/intrinsic.hpp>
+#include <boost/fusion/iterator.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/support/is_view.hpp>
+
+#include <boost/mpl/assert.hpp>
+
+int main()
+{
+    using namespace boost::fusion;
+    typedef int array_type[3];
+
+    BOOST_MPL_ASSERT((traits::is_sequence<array_type>));
+    BOOST_MPL_ASSERT_NOT((traits::is_view<array_type>));
+    BOOST_STATIC_ASSERT(traits::is_sequence<array_type>::value);
+    BOOST_STATIC_ASSERT(!traits::is_view<array_type>::value);
+
+    array_type arr = {1,2,3};
+
+    BOOST_TEST(*begin(arr) == 1);
+    BOOST_TEST(*next(begin(arr)) == 2);
+    BOOST_TEST(*advance_c<2>(begin(arr)) == 3);
+    BOOST_TEST(prior(next(begin(arr))) == begin(arr));
+    BOOST_TEST(*prior(end(arr)) == 3);
+    BOOST_TEST(at_c<2>(arr) == 3);
+    BOOST_TEST(size(arr) == 3);
+    BOOST_TEST(distance(begin(arr), end(arr)) == 3);
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/as_deque.cpp b/src/boost/libs/fusion/test/sequence/as_deque.cpp
new file mode 100644
index 00000000..c56c598d
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/as_deque.cpp
@@ -0,0 +1,70 @@
+/*=============================================================================
+    Copyright (c) 2014 Louis Dionne
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/algorithm/transformation/push_back.hpp>
+#include <boost/fusion/algorithm/transformation/push_front.hpp>
+#include <boost/fusion/container/deque/convert.hpp>
+#include <boost/fusion/container/deque/deque.hpp>
+#include <boost/fusion/container/generation/make_deque.hpp>
+#include <boost/fusion/container/generation/make_list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+
+#include <string>
+
+
+int main() {
+    using namespace boost::fusion;
+    using namespace boost;
+
+    BOOST_TEST(as_deque(make_vector()) == make_deque());
+    BOOST_TEST(as_deque(make_vector(1)) == make_deque(1));
+    BOOST_TEST(as_deque(make_vector(1, '2')) == make_deque(1, '2'));
+    BOOST_TEST(as_deque(make_vector(1, '2', 3.3f)) == make_deque(1, '2', 3.3f));
+
+    BOOST_TEST(as_deque(make_list()) == make_deque());
+    BOOST_TEST(as_deque(make_list(1)) == make_deque(1));
+    BOOST_TEST(as_deque(make_list(1, '2')) == make_deque(1, '2'));
+    BOOST_TEST(as_deque(make_list(1, '2', 3.3f)) == make_deque(1, '2', 3.3f));
+
+    {
+        deque<> xs;
+        BOOST_TEST(as_deque(push_back(xs, 1)) == make_deque(1));
+    }
+
+    {
+        deque<int> xs(1);
+        BOOST_TEST(as_deque(push_back(xs, '2')) == make_deque(1, '2'));
+    }
+
+    {
+        deque<int, char> xs(1, '2');
+        BOOST_TEST(as_deque(push_back(xs, 3.3f)) == make_deque(1, '2', 3.3f));
+    }
+
+    {
+        deque<> xs;
+        BOOST_TEST(
+            as_deque(push_front(xs, make_deque(1, '2', 3.3f))) ==
+            make_deque(make_deque(1, '2', 3.3f))
+        );
+
+        BOOST_TEST(as_deque(make_deque(make_deque(1))) == make_deque(make_deque(1)));
+    }
+
+/* Disabling test for now, see https://github.com/boostorg/fusion/pull/38 ($$$ FIXME $$$)
+
+    {
+        deque<> xs;
+        BOOST_TEST(
+            as_deque(push_front(xs, make_vector(1, '2', 3.3f))) ==
+            make_deque(make_vector(1, '2', 3.3f))
+        );
+    }
+*/
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/as_list.cpp b/src/boost/libs/fusion/test/sequence/as_list.cpp
new file mode 100644
index 00000000..8ee8bf12
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/as_list.cpp
@@ -0,0 +1,53 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/generation/make_list.hpp>
+#include <boost/fusion/container/list/convert.hpp>
+#include <boost/fusion/algorithm/transformation/push_back.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/mpl/vector_c.hpp>
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        vector0<> empty;
+        std::cout << as_list(make_vector(1, 1.23, "harru")) << std::endl; 
+        std::cout << as_list(push_back(empty, 999)) << std::endl;
+
+        BOOST_TEST(as_list(make_vector(1, 1.23, "harru")) == make_vector(1, 1.23, std::string("harru")));
+        BOOST_TEST(as_list(push_back(empty, 999)) == push_back(empty, 999));
+    }
+
+    {
+        std::cout << as_list(mpl::vector_c<int, 1, 2, 3, 4, 5>()) << std::endl;
+        BOOST_TEST((as_list(mpl::vector_c<int, 1, 2, 3, 4, 5>()) 
+            == mpl::vector_c<int, 1, 2, 3, 4, 5>()));
+    }
+
+    {
+        // test conversion
+        list<int, std::string> l(make_vector(123, "harru"));
+        BOOST_TEST(l == make_vector(123, "harru"));
+        l = (make_vector(235, "hola")); // test assign
+        BOOST_TEST(l == make_vector(235, "hola"));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/as_map.cpp b/src/boost/libs/fusion/test/sequence/as_map.cpp
new file mode 100644
index 00000000..d2a89cc6
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/as_map.cpp
@@ -0,0 +1,61 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/generation/make_list.hpp>
+#include <boost/fusion/container/map/convert.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/algorithm/transformation/push_back.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/support/pair.hpp>
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        vector0<> empty;
+        std::cout << as_map(make_list(make_pair<int>('X'), make_pair<double>("Men"))) << std::endl;
+        std::cout << as_map(push_back(empty, make_pair<int>(999))) << std::endl;
+    }
+
+    {
+        typedef pair<int, char> p1;
+        typedef pair<double, std::string> p2;
+        boost::fusion::result_of::as_map<list<p1, p2> >::type map(make_pair<int>('X'), make_pair<double>("Men"));
+        std::cout << at_key<int>(map) << std::endl;
+        std::cout << at_key<double>(map) << std::endl;
+        BOOST_TEST(at_key<int>(map) == 'X');
+        BOOST_TEST(at_key<double>(map) == "Men");
+    }
+
+    {
+        // test conversion
+        typedef map<
+            pair<int, char>
+          , pair<double, std::string> > 
+        map_type;
+
+        map_type m(make_vector(make_pair<int>('X'), make_pair<double>("Men")));
+        BOOST_TEST(as_vector(m) == make_vector(make_pair<int>('X'), make_pair<double>("Men")));
+        m = (make_vector(make_pair<int>('X'), make_pair<double>("Men"))); // test assign
+        BOOST_TEST(as_vector(m) == make_vector(make_pair<int>('X'), make_pair<double>("Men")));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/as_map_assoc.cpp b/src/boost/libs/fusion/test/sequence/as_map_assoc.cpp
new file mode 100644
index 00000000..bc9a6951
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/as_map_assoc.cpp
@@ -0,0 +1,85 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/adapt_assoc_struct.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/map/convert.hpp>
+#include <boost/fusion/container/generation/make_set.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/support/pair.hpp>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+
+    struct point
+    {
+        int x;
+        int y;
+    };
+}
+
+BOOST_FUSION_ADAPT_ASSOC_STRUCT(
+    ns::point,
+    (int, x, ns::x_member)
+    (int, y, ns::y_member)
+)
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        ns::point p = {123, 456};
+        std::cout << as_map(p) << std::endl;
+    }
+
+    {
+        ns::point p = {123, 456};
+        boost::fusion::result_of::as_map<ns::point>::type map(p);
+        std::cout << at_key<ns::x_member>(map) << std::endl;
+        std::cout << at_key<ns::y_member>(map) << std::endl;
+        BOOST_TEST(at_key<ns::x_member>(map) == 123);
+        BOOST_TEST(at_key<ns::y_member>(map) == 456);
+    }
+
+    {
+        boost::fusion::result_of::as_map<set<int, char> >::type map(make_set(1, '2'));
+        BOOST_TEST(at_key<int>(map) == 1);
+        BOOST_TEST(at_key<char>(map) == '2');
+    }
+    
+    {
+        // test conversion
+        typedef map<
+            pair<ns::x_member, int>
+          , pair<ns::y_member, int> >
+        map_type;
+
+        ns::point p = {123, 456};
+        map_type m(p);
+        BOOST_TEST(as_vector(m) == make_vector(make_pair<ns::x_member>(123), make_pair<ns::y_member>(456)));
+        m = (make_vector(make_pair<ns::x_member>(123), make_pair<ns::y_member>(456))); // test assign
+        BOOST_TEST(as_vector(m) == make_vector(make_pair<ns::x_member>(123), make_pair<ns::y_member>(456)));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/as_set.cpp b/src/boost/libs/fusion/test/sequence/as_set.cpp
new file mode 100644
index 00000000..97dd89e8
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/as_set.cpp
@@ -0,0 +1,64 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/generation/make_list.hpp>
+#include <boost/fusion/container/set/convert.hpp>
+#include <boost/fusion/container/list/convert.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/algorithm/transformation/push_back.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/mpl/vector_c.hpp>
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        vector0<> empty;
+        std::cout << as_set(make_list(1, 1.23, "harru")) << std::endl;
+        std::cout << as_set(push_back(empty, 999)) << std::endl;
+        
+        BOOST_TEST(as_list(as_set(make_list(1, 1.23, "harru")))
+            == make_list(1, 1.23, std::string("harru")));
+        BOOST_TEST(as_list(as_set(push_back(empty, 999)))
+            == push_back(empty, 999));
+    }
+
+    {
+        boost::fusion::result_of::as_set<list<int, double, std::string> >::type set(1, 1.23, "harru");
+        std::cout << at_key<int>(set) << std::endl;
+        BOOST_TEST(at_key<int>(set) == 1);
+    }
+
+    {
+        std::cout << as_set(mpl::vector_c<int, 1, 2, 3, 4, 5>()) << std::endl;
+        BOOST_TEST((as_list(as_set(mpl::vector_c<int, 1, 2, 3, 4, 5>())) 
+            == mpl::vector_c<int, 1, 2, 3, 4, 5>()));
+    }
+
+    {
+        // test conversion
+        set<int, std::string> s(make_vector(123, "harru"));
+        BOOST_TEST(as_vector(s) == make_vector(123, "harru"));
+        s = (make_vector(235, "hola")); // test assign
+        BOOST_TEST(as_vector(s) == make_vector(235, "hola"));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/as_vector.cpp b/src/boost/libs/fusion/test/sequence/as_vector.cpp
new file mode 100644
index 00000000..af1aaffb
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/as_vector.cpp
@@ -0,0 +1,54 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/generation/make_list.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/algorithm/transformation/push_back.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/mpl/vector_c.hpp>
+#include <string>
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        vector0<> empty;
+        std::cout << as_vector(make_list(1, 1.23, "harru")) << std::endl;
+        std::cout << as_vector(push_back(empty, 999)) << std::endl;
+        
+        BOOST_TEST(as_vector(make_list(1, 1.23, "harru")) == make_list(1, 1.23, std::string("harru")));
+        BOOST_TEST(as_vector(push_back(empty, 999)) == push_back(empty, 999));
+    }
+
+    {
+        std::cout << as_vector(mpl::vector_c<int, 1, 2, 3, 4, 5>()) << std::endl;
+        BOOST_TEST((as_vector(mpl::vector_c<int, 1, 2, 3, 4, 5>()) 
+            == mpl::vector_c<int, 1, 2, 3, 4, 5>()));
+    }
+    
+    {
+        // test conversion
+        vector<int, std::string> v(make_list(123, "harru"));
+        BOOST_TEST(v == make_list(123, "harru"));
+        v = (make_list(235, "hola")); // test assign
+        BOOST_TEST(v == make_list(235, "hola"));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/back_extended_deque.cpp b/src/boost/libs/fusion/test/sequence/back_extended_deque.cpp
new file mode 100644
index 00000000..368ec0c2
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/back_extended_deque.cpp
@@ -0,0 +1,114 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/fusion/container/deque/deque.hpp>
+#include <boost/fusion/container/deque/back_extended_deque.hpp>
+#include <boost/fusion/sequence/comparison.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/mpl.hpp>
+
+#include <boost/fusion/sequence/intrinsic.hpp>
+#include <boost/fusion/iterator.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+int main()
+{
+    using namespace boost::fusion;
+    {
+        typedef deque<> initial_deque_type;
+        initial_deque_type initial_deque;
+        typedef back_extended_deque<initial_deque_type, long> extended_type;
+        extended_type extended(initial_deque, 101L);
+
+        BOOST_TEST(size(extended) == 1);
+        BOOST_TEST(extended == make_vector(101L));
+        BOOST_TEST(*begin(extended) == 101L);
+        BOOST_TEST(*prior(end(extended)) == 101L);
+        BOOST_TEST(distance(begin(extended), end(extended)) == 1);
+    }
+    {
+        namespace mpl = boost::mpl;
+        typedef deque<> initial_deque_type;
+        typedef back_extended_deque<initial_deque_type, long> extended_type;
+
+        BOOST_MPL_ASSERT((boost::is_same<mpl::at_c<extended_type, 0>::type, long>));
+        BOOST_MPL_ASSERT((boost::is_same<mpl::deref<mpl::begin<extended_type>::type>::type, long>));
+        BOOST_MPL_ASSERT((mpl::equal_to<mpl::size<extended_type>::type, mpl::int_<1> >));
+    }
+    {
+        long l(101L);
+        typedef deque<> initial_deque_type;
+        initial_deque_type initial_deque;
+        typedef back_extended_deque<initial_deque_type, long&> extended_type;
+        extended_type extended(initial_deque, l);
+        BOOST_TEST(extended == make_vector(101L));
+
+        long l2(202L);
+        extended_type extended2(initial_deque_type(), l2);
+
+        extended = extended2;
+
+        BOOST_TEST(extended == make_vector(202L));
+
+        BOOST_TEST(l == l2);
+    }
+
+    {
+        typedef deque<int, char> initial_deque_type;
+        initial_deque_type initial_deque(1, 'a');
+        typedef back_extended_deque<initial_deque_type, long> extended_type;
+        extended_type extended(initial_deque, 101L);
+
+        BOOST_TEST(size(extended) == 3);
+        BOOST_TEST(extended == make_vector(1, 'a', 101L));
+        BOOST_TEST(*begin(extended) == 1);
+        BOOST_TEST(*next(begin(extended)) == 'a');
+        BOOST_TEST(*prior(end(extended)) == 101L);
+        BOOST_TEST(distance(begin(extended), end(extended)) == 3);
+        BOOST_TEST(*advance_c<2>(begin(extended)) == 101L);
+    }
+    {
+        namespace mpl = boost::mpl;
+        typedef deque<int, char> initial_deque_type;
+        typedef back_extended_deque<initial_deque_type, long> extended_type;
+
+        BOOST_MPL_ASSERT((boost::is_same<mpl::at_c<extended_type, 0>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<mpl::at_c<extended_type, 1>::type, char>));
+        BOOST_MPL_ASSERT((boost::is_same<mpl::at_c<extended_type, 2>::type, long>));
+        BOOST_MPL_ASSERT((boost::is_same<mpl::deref<mpl::begin<extended_type>::type>::type, int>));
+        BOOST_MPL_ASSERT((mpl::equal_to<mpl::size<extended_type>::type, mpl::int_<3> >));
+    }
+    {
+        char ch('a');
+        long l(101L);
+        int i(1);
+        typedef deque<int&, char&> initial_deque_type;
+        initial_deque_type initial_deque(i, ch);
+        typedef back_extended_deque<initial_deque_type, long&> extended_type;
+        extended_type extended(initial_deque, l);
+        BOOST_TEST(extended == make_vector(1, 'a', 101L));
+
+        char ch2('b');
+        long l2(202L);
+        int i2(2);
+        extended_type extended2(initial_deque_type(i2, ch2), l2);
+
+        extended = extended2;
+
+        BOOST_TEST(extended == make_vector(2, 'b', 202L));
+
+        BOOST_TEST(i == i2);
+        BOOST_TEST(ch == ch2);
+        BOOST_TEST(l == l2);
+    }
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/boost_array.cpp b/src/boost/libs/fusion/test/sequence/boost_array.cpp
new file mode 100644
index 00000000..f3f71470
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/boost_array.cpp
@@ -0,0 +1,44 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/fusion/adapted/boost_array.hpp>
+#include <boost/array.hpp>
+
+#include <boost/fusion/sequence/intrinsic.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/fusion/iterator.hpp>
+
+#include <boost/mpl/assert.hpp>
+
+int main()
+{
+    using namespace boost::fusion;
+    typedef boost::array<int,3> array_type;
+
+    BOOST_MPL_ASSERT((traits::is_sequence<array_type>));
+    BOOST_MPL_ASSERT_NOT((traits::is_view<array_type>));
+    BOOST_STATIC_ASSERT(traits::is_sequence<array_type>::value);
+    BOOST_STATIC_ASSERT(!traits::is_view<array_type>::value);
+
+    array_type arr = {{1,2,3}};
+
+    BOOST_TEST(*begin(arr) == 1);
+    BOOST_TEST(*next(begin(arr)) == 2);
+    BOOST_TEST(*advance_c<2>(begin(arr)) == 3);
+    BOOST_TEST(prior(next(begin(arr))) == begin(arr));
+    BOOST_TEST(*prior(end(arr)) == 3);
+    BOOST_TEST(at_c<2>(arr) == 3);
+    BOOST_TEST(size(arr) == 3);
+    BOOST_TEST(distance(begin(arr), end(arr)) == 3);
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/boost_tuple.cpp b/src/boost/libs/fusion/test/sequence/boost_tuple.cpp
new file mode 100644
index 00000000..abe7d3c8
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/boost_tuple.cpp
@@ -0,0 +1,118 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/boost_tuple.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/distance.hpp> 
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/sequence/convert.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+#include <string>
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        typedef boost::tuple<int, std::string> tuple_type;
+        BOOST_MPL_ASSERT_NOT((traits::is_view<tuple_type>));
+        BOOST_STATIC_ASSERT(!traits::is_view<tuple_type>::value);
+        tuple_type t(123, "Hola!!!");
+
+        std::cout << at_c<0>(t) << std::endl;
+        std::cout << at_c<1>(t) << std::endl;
+        std::cout << t << std::endl;
+        BOOST_TEST(t == make_vector(123, "Hola!!!"));
+
+        at_c<0>(t) = 6;
+        at_c<1>(t) = "mama mia";
+        BOOST_TEST(t == make_vector(6, "mama mia"));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<tuple_type>::value == 2);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<tuple_type>::value);
+
+        BOOST_TEST(front(t) == 6);
+    }
+    
+    {
+        fusion::vector<int, float> v1(4, 3.3f);
+        boost::tuple<short, float> v2(5, 3.3f);
+        fusion::vector<long, double> v3(5, 4.4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from boost tuple to vector
+        fusion::vector<int, std::string> v(tuples::make_tuple(123, "Hola!!!"));
+        v = tuples::make_tuple(123, "Hola!!!");
+    }
+
+    {
+        // conversion from boost tuple to list
+        fusion::list<int, std::string> l(tuples::make_tuple(123, "Hola!!!"));
+        l = tuples::make_tuple(123, "Hola!!!");
+    }
+
+    {
+        // conversion vector to boost tuple
+        boost::tuple<int, std::string> t = convert<boost_tuple_tag>(make_vector(123, "Hola!!!"));
+        BOOST_TEST(get<0>(t) == 123);
+        BOOST_TEST(get<1>(t) == "Hola!!!");
+    }
+
+    { 
+        // test from Ticket #1601, submitted by Shunsuke Sogame 
+        // expanded by Stjepan Rajko 
+        boost::tuple<int, char> t(3, 'a'); 
+
+        BOOST_TEST(0u == fusion::distance(fusion::begin(t), fusion::begin(t))); 
+        BOOST_TEST(1u == fusion::distance(fusion::begin(t), fusion::next(fusion::begin(t)))); 
+        BOOST_TEST(2u == fusion::distance(fusion::begin(t), fusion::end(t))); 
+    } 
+
+    {
+        typedef boost::tuple<int, std::string> tuple_type;
+        BOOST_MPL_ASSERT((mpl::is_sequence<tuple_type>));
+        BOOST_MPL_ASSERT((boost::is_same<int, mpl::front<tuple_type>::type>));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/boost_tuple_iterator.cpp b/src/boost/libs/fusion/test/sequence/boost_tuple_iterator.cpp
new file mode 100644
index 00000000..3ab096b9
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/boost_tuple_iterator.cpp
@@ -0,0 +1,21 @@
+/*=============================================================================
+    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)
+==============================================================================*/
+
+#include <boost/fusion/adapted/boost_tuple.hpp>
+
+#define FUSION_SEQUENCE boost::tuple
+#define FUSION_TRAVERSAL_TAG forward_traversal_tag
+#define FUSION_NO_PRIOR
+#include "./iterator.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/comparison.hpp b/src/boost/libs/fusion/test/sequence/comparison.hpp
new file mode 100644
index 00000000..2dfe6550
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/comparison.hpp
@@ -0,0 +1,57 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/comparison.hpp>
+
+void
+equality_test()
+{
+    using namespace boost::fusion;
+
+    FUSION_SEQUENCE<int, char> v1(5, 'a');
+    FUSION_SEQUENCE<int, char> v2(5, 'a');
+    BOOST_TEST(v1 == v2);
+
+    FUSION_SEQUENCE<int, char> v3(5, 'b');
+    FUSION_SEQUENCE<int, char> t4(2, 'a');
+    BOOST_TEST(v1 != v3);
+    BOOST_TEST(v1 != t4);
+    BOOST_TEST(!(v1 != v2));
+
+    FUSION_SEQUENCE<int, char, bool> v5(5, 'a', true);
+    BOOST_TEST(v1 != v5);
+    BOOST_TEST(!(v1 == v5));
+    BOOST_TEST(v5 != v1);
+    BOOST_TEST(!(v5 == v1));
+}
+
+void
+ordering_test()
+{
+    using namespace boost::fusion;
+
+    FUSION_SEQUENCE<int, float> v1(4, 3.3f);
+    FUSION_SEQUENCE<short, float> v2(5, 3.3f);
+    FUSION_SEQUENCE<long, double> v3(5, 4.4);
+    BOOST_TEST(v1 < v2);
+    BOOST_TEST(v1 <= v2);
+    BOOST_TEST(v2 > v1);
+    BOOST_TEST(v2 >= v1);
+    BOOST_TEST(v2 < v3);
+    BOOST_TEST(v2 <= v3);
+    BOOST_TEST(v3 > v2);
+    BOOST_TEST(v3 >= v2);
+
+#if defined(FUSION_TEST_FAIL)
+    FUSION_SEQUENCE<int, char, bool> v5(5, 'a', true);
+    v1 >= v5;
+#endif
+}
+
+
+
diff --git a/src/boost/libs/fusion/test/sequence/cons.cpp b/src/boost/libs/fusion/test/sequence/cons.cpp
new file mode 100644
index 00000000..88a04101
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/cons.cpp
@@ -0,0 +1,95 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005 Eric Niebler
+
+    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 <string>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/list/cons.hpp>
+#include <boost/fusion/container/generation/make_cons.hpp>
+#include <boost/fusion/container/generation/cons_tie.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/fusion/algorithm/transformation/filter_if.hpp>
+#include <boost/fusion/algorithm/transformation/push_front.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/lambda.hpp>
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using boost::is_same;
+    namespace fusion = boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+/// Testing cons
+    
+    {
+        std::string hello("hello");
+        cons<int, cons<std::string> > ns =
+            make_cons(1, make_cons(hello));
+
+        BOOST_TEST((*begin(ns) == 1));
+        BOOST_TEST((*fusion::next(begin(ns)) == hello));
+
+        *begin(ns) += 1;
+        *fusion::next(begin(ns)) += ' ';
+
+        BOOST_TEST((*begin(ns) == 2));
+        BOOST_TEST((*fusion::next(begin(ns)) == hello + ' '));
+
+        for_each(ns, boost::lambda::_1 += ' ');
+
+        BOOST_TEST((*begin(ns) == 2 + ' '));
+        BOOST_TEST((*fusion::next(begin(ns)) == hello + ' ' + ' '));
+    }
+
+    {
+        BOOST_TEST(
+            make_cons("hello") == make_vector(std::string("hello"))
+        );
+
+        BOOST_TEST(
+            make_cons(123, make_cons("hello")) == 
+            make_vector(123, std::string("hello"))
+        );
+    }
+
+    {
+        vector<int, float> t(1, 1.1f);
+        cons<int, cons<float> > nf =
+            make_cons(1, make_cons(1.1f));
+
+        BOOST_TEST((t == nf));
+        BOOST_TEST((vector<int>(1) == filter_if<is_same<boost::mpl::_, int> >(nf)));
+
+        std::cout << nf << std::endl;
+        std::cout << filter_if<is_same<boost::mpl::_, int> >(nf) << std::endl;
+    }
+    
+    {
+        int i = 3;
+        cons<int&> tie(cons_tie(i));
+        BOOST_TEST((*begin(tie) == 3));
+    }
+
+    {
+        // This used to trigger a hard compilation error:
+        cons<cons<int> > xs;
+        begin(push_front(xs, 3));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/construction.hpp b/src/boost/libs/fusion/test/sequence/construction.hpp
new file mode 100644
index 00000000..94c7d182
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/construction.hpp
@@ -0,0 +1,122 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/container/list/cons.hpp>
+
+#if !defined(FUSION_AT)
+#define FUSION_AT at_c
+#endif
+
+namespace test_detail
+{
+    // something to prevent warnings for unused variables
+    template<class T> void dummy(const T&) {}
+
+    // no public default constructor
+    class foo
+    {
+    public:
+
+        explicit foo(int v) : val(v) {}
+
+        bool operator==(const foo& other) const
+        {
+            return val == other.val;
+        }
+
+    private:
+
+        foo() {}
+        int val;
+    };
+
+    // another class without a public default constructor
+    class no_def_constructor
+    {
+        no_def_constructor() {}
+
+    public:
+
+        no_def_constructor(std::string) {}
+    };
+}
+
+inline void
+test()
+{
+    using namespace boost::fusion;
+    using namespace test_detail;
+
+    nil empty;
+    (void)empty;
+
+    FUSION_SEQUENCE<> empty0;
+    (void)empty0;
+
+#ifndef NO_CONSTRUCT_FROM_NIL
+    FUSION_SEQUENCE<> empty1(empty);
+    (void)empty1;
+#endif
+
+    FUSION_SEQUENCE<int> t1;
+    BOOST_TEST(FUSION_AT<0>(t1) == int());
+
+    FUSION_SEQUENCE<float> t2(5.5f);
+    BOOST_TEST(FUSION_AT<0>(t2) > 5.4f && FUSION_AT<0>(t2) < 5.6f);
+
+    FUSION_SEQUENCE<foo> t3(foo(12));
+    BOOST_TEST(FUSION_AT<0>(t3) == foo(12));
+
+    FUSION_SEQUENCE<double> t4(t2);
+    BOOST_TEST(FUSION_AT<0>(t4) > 5.4 && FUSION_AT<0>(t4) < 5.6);
+
+    FUSION_SEQUENCE<int, float> t5;
+    BOOST_TEST(FUSION_AT<0>(t5) == int());
+    BOOST_TEST(FUSION_AT<1>(t5) == float());
+
+    FUSION_SEQUENCE<int, float> t6(12, 5.5f);
+    BOOST_TEST(FUSION_AT<0>(t6) == 12);
+    BOOST_TEST(FUSION_AT<1>(t6) > 5.4f && FUSION_AT<1>(t6) < 5.6f);
+
+    FUSION_SEQUENCE<int, float> t7(t6);
+    BOOST_TEST(FUSION_AT<0>(t7) == 12);
+    BOOST_TEST(FUSION_AT<1>(t7) > 5.4f && FUSION_AT<1>(t7) < 5.6f);
+
+    FUSION_SEQUENCE<long, double> t8(t6);
+    BOOST_TEST(FUSION_AT<0>(t8) == 12);
+    BOOST_TEST(FUSION_AT<1>(t8) > 5.4f && FUSION_AT<1>(t8) < 5.6f);
+
+    dummy
+    (
+        FUSION_SEQUENCE<no_def_constructor, no_def_constructor, no_def_constructor>(
+            std::string("Jaba"),        // ok, since the default
+            std::string("Daba"),        // constructor is not used
+            std::string("Doo")
+        )
+    );
+
+    dummy(FUSION_SEQUENCE<int, double>());
+    dummy(FUSION_SEQUENCE<int, double>(1,3.14));
+
+#if defined(FUSION_TEST_FAIL)
+    dummy(FUSION_SEQUENCE<double&>());          // should fail, no defaults for references
+    dummy(FUSION_SEQUENCE<const double&>());    // likewise
+#endif
+
+    {
+        double dd = 5;
+        dummy(FUSION_SEQUENCE<double&>(dd)); // ok
+        dummy(FUSION_SEQUENCE<const double&>(dd+3.14)); // ok, but dangerous
+    }
+
+#if defined(FUSION_TEST_FAIL)
+    dummy(FUSION_SEQUENCE<double&>(dd+3.14));   // should fail,
+                                                // temporary to non-const reference
+#endif
+}
diff --git a/src/boost/libs/fusion/test/sequence/conversion.hpp b/src/boost/libs/fusion/test/sequence/conversion.hpp
new file mode 100644
index 00000000..f5720776
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/conversion.hpp
@@ -0,0 +1,322 @@
+/*=============================================================================
+    Copyright (c) 2016 Lee Clagett
+
+    Use modification and distribution are subject to the Boost Software
+    License, Version 1.0. (See accompanyintg file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+==============================================================================*/
+
+#include <boost/config.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/boost_tuple.hpp>
+#include <boost/fusion/adapted/std_pair.hpp>
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) \
+ && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+# include <boost/fusion/adapted/std_tuple.hpp>
+#endif
+#include <boost/fusion/container/deque.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/tuple.hpp>
+#include <boost/fusion/container/vector.hpp>
+
+#include "fixture.hpp"
+
+template <template <typename> class Scenario>
+void test()
+{
+    using namespace test_detail;
+
+    // Note the trunction conversion tests from each containter
+    // ... bug or feature?
+
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(FUSION_SEQUENCE<int>(300), 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::fusion::push_back(FUSION_SEQUENCE<int>(200), 400)
+          , FUSION_SEQUENCE<convertible>(200)
+        )
+    ));
+
+    BOOST_TEST((run<Scenario<FUSION_SEQUENCE<> > >(boost::fusion::vector<>())));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<> > >(
+            boost::fusion::vector<int>(100), boost::fusion::vector<>()
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::fusion::vector<int>(110)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::fusion::vector<int, int>(200, 100)
+          , boost::fusion::vector<convertible>(200)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::vector<int, int>(200, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::vector<int, int, int>(500, 400, 100)
+          , boost::fusion::vector<convertible, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(
+                boost::fusion::vector<int>(500), 400
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(
+                boost::fusion::vector<int, int>(500, 400), 100
+            )
+          , boost::fusion::vector<convertible, int>(500, 400)
+        )
+    ));
+
+    BOOST_TEST((run<Scenario< FUSION_SEQUENCE<> > >(boost::fusion::deque<>())));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<> > >(
+            boost::fusion::deque<int>(100), boost::fusion::deque<>()
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::fusion::deque<int>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::fusion::deque<int, int>(500, 100)
+          , boost::fusion::deque<convertible>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::deque<int, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::deque<int, int, int>(500, 400, 100)
+          , boost::fusion::deque<convertible, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(
+                boost::fusion::deque<int>(500), 400
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(
+                boost::fusion::deque<int, int>(500, 400), 100
+            )
+          , boost::fusion::deque<convertible, int>(500, 400)
+        )
+    ));
+
+    BOOST_TEST((run< Scenario< FUSION_SEQUENCE<> > >(boost::fusion::list<>())));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<> > >(
+            boost::fusion::list<int>(100), boost::fusion::list<>()
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::fusion::list<int>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::fusion::list<int, int>(500, 100)
+          , boost::fusion::list<convertible>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::list<int, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::list<int, int, int>(500, 400, 100)
+          , boost::fusion::list<convertible, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(
+                boost::fusion::list<int>(500), 400
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(
+                boost::fusion::list<int, int>(500, 400), 100
+            )
+          , boost::fusion::list<convertible, int>(500, 400)
+        )
+    ));
+
+    BOOST_TEST((run<Scenario< FUSION_SEQUENCE<> > >(boost::fusion::tuple<>())));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<> > >(
+            boost::fusion::tuple<int>(100), boost::fusion::tuple<>()
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::fusion::tuple<int>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::fusion::tuple<int, int>(500, 100)
+          , boost::fusion::tuple<convertible>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::tuple<int, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::tuple<int, int, int>(500, 400, 100)
+          , boost::fusion::tuple<convertible, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(
+                boost::fusion::tuple<int>(500), 400
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(
+                boost::fusion::tuple<int, int>(500, 400), 100
+            )
+          , boost::fusion::tuple<convertible, int>(500, 400)
+        )
+    ));
+
+    BOOST_TEST((run< Scenario< FUSION_SEQUENCE<> > >(boost::tuple<>())));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<> > >(
+            boost::tuple<int>(100), boost::tuple<>()
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::tuple<int>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            boost::tuple<int, int>(500, 100)
+          , boost::tuple<convertible>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::tuple<int, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::tuple<int, int, int>(500, 400, 100)
+          , boost::tuple<convertible, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(boost::tuple<int>(500), 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(
+                boost::tuple<int, int>(500, 400), 100
+            )
+          , boost::tuple<convertible, int>(500, 400)
+        )
+    ));
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) \
+ && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    BOOST_TEST((run< Scenario< FUSION_SEQUENCE<> > >(std::tuple<>())));
+    BOOST_TEST((
+        run<Scenario<FUSION_SEQUENCE<> > >(std::tuple<int>(100), std::tuple<>())
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            std::tuple<int>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            std::tuple<int, int>(500, 100)
+          , std::tuple<convertible>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            std::tuple<int, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            std::tuple<int, int, int>(500, 400, 100)
+          , std::tuple<convertible, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(std::tuple<int>(500), 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            boost::fusion::push_back(
+                std::tuple<int, int>(500, 400), 100
+            )
+          , std::tuple<convertible, int>(500, 400)
+        )
+    ));
+#endif
+
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            std::pair<int, int>(500, 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<> > >(
+            std::pair<int, int>(500, 400)
+          , boost::fusion::vector<>()
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            std::pair<int, int>(500, 400)
+          , boost::fusion::vector<convertible>(500)
+        )
+    ));
+}
diff --git a/src/boost/libs/fusion/test/sequence/convert.hpp b/src/boost/libs/fusion/test/sequence/convert.hpp
new file mode 100644
index 00000000..233fabfb
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/convert.hpp
@@ -0,0 +1,51 @@
+/*=============================================================================
+    Copyright (c) 2015 Kohei Takahashi
+
+    Use modification and distribution are subject to 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 <string>
+#include <boost/config.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/fusion/include/convert.hpp>
+#include <boost/fusion/include/at.hpp>
+
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/deque.hpp>
+#include <boost/fusion/include/list.hpp>
+#include <boost/fusion/include/boost_tuple.hpp>
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include <boost/fusion/include/std_tuple.hpp>
+#endif
+
+template <typename Tag>
+void test(FUSION_SEQUENCE<int, std::string> const& seq)
+{
+    typedef typename
+        boost::fusion::result_of::convert<
+            Tag
+          , FUSION_SEQUENCE<int, std::string>
+        >::type
+    type;
+
+    type v = boost::fusion::convert<Tag>(seq);
+    BOOST_TEST((boost::fusion::at_c<0>(v) == 123));
+    BOOST_TEST((boost::fusion::at_c<1>(v) == "Hola!!!"));
+}
+
+int main()
+{
+    FUSION_SEQUENCE<int, std::string> seq(123, "Hola!!!");
+    test<boost::fusion::vector_tag>(seq);
+    test<boost::fusion::deque_tag>(seq);
+    test<boost::fusion::cons_tag>(seq);
+    test<boost::fusion::boost_tuple_tag>(seq);
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    test<boost::fusion::std_tuple_tag>(seq);
+#endif
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/convert_boost_tuple.cpp b/src/boost/libs/fusion/test/sequence/convert_boost_tuple.cpp
new file mode 100644
index 00000000..588ee4d7
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/convert_boost_tuple.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2015 Kohei Takahashi
+
+    Use modification and distribution are subject to 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/tuple/tuple.hpp>
+#include <boost/fusion/include/boost_tuple.hpp>
+
+#define FUSION_SEQUENCE boost::tuples::tuple
+#include "convert.hpp"
+
diff --git a/src/boost/libs/fusion/test/sequence/convert_deque.cpp b/src/boost/libs/fusion/test/sequence/convert_deque.cpp
new file mode 100644
index 00000000..5be34d3f
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/convert_deque.cpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2015 Kohei Takahashi
+
+    Use modification and distribution are subject to 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/include/deque.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::deque
+#include "convert.hpp"
+
diff --git a/src/boost/libs/fusion/test/sequence/convert_list.cpp b/src/boost/libs/fusion/test/sequence/convert_list.cpp
new file mode 100644
index 00000000..57ad0507
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/convert_list.cpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2015 Kohei Takahashi
+
+    Use modification and distribution are subject to 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/include/list.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::list
+#include "convert.hpp"
+
diff --git a/src/boost/libs/fusion/test/sequence/convert_std_pair.cpp b/src/boost/libs/fusion/test/sequence/convert_std_pair.cpp
new file mode 100644
index 00000000..aa350025
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/convert_std_pair.cpp
@@ -0,0 +1,14 @@
+/*=============================================================================
+    Copyright (c) 2015 Kohei Takahashi
+
+    Use modification and distribution are subject to 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/fusion/include/std_pair.hpp>
+
+#define FUSION_SEQUENCE std::pair
+#include "convert.hpp"
+
diff --git a/src/boost/libs/fusion/test/sequence/convert_std_tuple.cpp b/src/boost/libs/fusion/test/sequence/convert_std_tuple.cpp
new file mode 100644
index 00000000..643f01cf
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/convert_std_tuple.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 2015 Kohei Takahashi
+
+    Use modification and distribution are subject to 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>
+
+#if defined(BOOST_NO_CXX11_HDR_TUPLE) || \
+    defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#   error "does not meet requirements"
+#endif
+
+#include <tuple>
+#include <boost/fusion/include/std_tuple.hpp>
+
+#define FUSION_SEQUENCE std::tuple
+#include "convert.hpp"
diff --git a/src/boost/libs/fusion/test/sequence/convert_vector.cpp b/src/boost/libs/fusion/test/sequence/convert_vector.cpp
new file mode 100644
index 00000000..b39014df
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/convert_vector.cpp
@@ -0,0 +1,13 @@
+/*=============================================================================
+    Copyright (c) 2015 Kohei Takahashi
+
+    Use modification and distribution are subject to 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/include/vector.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::vector
+#include "convert.hpp"
+
diff --git a/src/boost/libs/fusion/test/sequence/copy.hpp b/src/boost/libs/fusion/test/sequence/copy.hpp
new file mode 100644
index 00000000..566384cd
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/copy.hpp
@@ -0,0 +1,154 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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 <string>
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/mpl/insert_range.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/equal.hpp>
+#include <boost/static_assert.hpp>
+
+#include "fixture.hpp"
+
+#if !defined(FUSION_AT)
+#define FUSION_AT at_c
+#endif
+
+#if !defined(FUSION_MAKE)
+#define FUSION_MAKE BOOST_PP_CAT(make_, FUSION_SEQUENCE)
+#endif
+
+#if !defined(FUSION_TIE)
+#define FUSION_TIE BOOST_PP_CAT(FUSION_SEQUENCE, _tie)
+#endif
+
+namespace test_detail
+{
+    // classes with different kinds of conversions
+    class AA {};
+    class BB : public AA {};
+    struct CC { CC() {} CC(const BB&) {} };
+    struct DD { operator CC() const { return CC(); }; };
+}
+
+void test_mpl()
+{
+    using namespace boost::fusion;
+
+    typedef FUSION_SEQUENCE<int, char> seq;
+
+    typedef
+        boost::mpl::insert_range<
+            boost::mpl::vector<>
+          , boost::mpl::end< boost::mpl::vector<> >::type
+          , seq
+        >::type
+    sequence;
+
+    typedef boost::mpl::equal<sequence, boost::mpl::vector<int, char> > equal;
+    BOOST_STATIC_ASSERT(equal::value);
+}
+
+template <template <typename> class Scenario>
+void
+test()
+{
+    using namespace boost::fusion;
+    using namespace test_detail;
+
+    FUSION_SEQUENCE<int, char> t1(4, 'a');
+    FUSION_SEQUENCE<int, char> t2(5, 'b');
+    t2 = t1;
+    BOOST_TEST(FUSION_AT<0>(t1) == FUSION_AT<0>(t2));
+    BOOST_TEST(FUSION_AT<1>(t1) == FUSION_AT<1>(t2));
+
+    FUSION_SEQUENCE<long, std::string> t3(2, "a");
+    t3 = t1;
+    BOOST_TEST((double)FUSION_AT<0>(t1) == FUSION_AT<0>(t3));
+    BOOST_TEST(FUSION_AT<1>(t1) == FUSION_AT<1>(t3)[0]);
+
+    BOOST_TEST(FUSION_AT<0>(t1) == 4);
+    BOOST_TEST(FUSION_AT<1>(t1) == 'a');
+
+    // testing copy and assignment with implicit conversions
+    // between elements testing tie
+
+    FUSION_SEQUENCE<char, BB*, BB, DD> t;
+    FUSION_SEQUENCE<int, AA*, CC, CC> a(t);
+    a = t;
+
+    int i; char c; double d;
+    FUSION_TIE(i, c, d) = FUSION_MAKE(1, 'a', 5.5);
+
+    BOOST_TEST(i==1);
+    BOOST_TEST(c=='a');
+    BOOST_TEST(d>5.4 && d<5.6);
+
+    test_mpl();
+
+
+    BOOST_TEST((run< Scenario< FUSION_SEQUENCE<> > >(FUSION_SEQUENCE<>())));
+
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<int> > >(FUSION_SEQUENCE<int>(500))
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            FUSION_SEQUENCE<int>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<int> > >(
+            FUSION_SEQUENCE<int, int>(500, 100)
+          , FUSION_SEQUENCE<int>(500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible> > >(
+            FUSION_SEQUENCE<int, int>(500, 100)
+          , FUSION_SEQUENCE<convertible>(500)
+        )
+    ));
+
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<int, int> > >(
+            FUSION_SEQUENCE<int, int>(500, 600)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, int> > >(
+            FUSION_SEQUENCE<convertible, int>(100, 500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<int, convertible> > >(
+            FUSION_SEQUENCE<int, convertible>(500, 600)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, convertible> > >(
+            FUSION_SEQUENCE<int, int>(400, 500)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<int, int> > >(
+            FUSION_SEQUENCE<int, int, int>(500, 100, 323)
+          , FUSION_SEQUENCE<int, int>(500, 100)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<convertible, convertible> > >(
+            FUSION_SEQUENCE<int, int, int>(500, 600, 100)
+          , FUSION_SEQUENCE<convertible, convertible>(500, 600)
+        )
+    ));
+}
diff --git a/src/boost/libs/fusion/test/sequence/deduce_sequence.cpp b/src/boost/libs/fusion/test/sequence/deduce_sequence.cpp
new file mode 100644
index 00000000..a1569f46
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deduce_sequence.cpp
@@ -0,0 +1,91 @@
+/*=============================================================================
+    Copyright (c) 2007 Tobias Schwinger
+
+    Use modification and distribution are subject to 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/deduce_sequence.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/mpl/equal.hpp>
+
+#include <boost/ref.hpp>
+#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
+#include <functional>
+#endif
+
+using boost::is_same;
+using boost::reference_wrapper;
+using boost::fusion::traits::deduce;
+using boost::fusion::traits::deduce_sequence;
+
+namespace fusion = boost::fusion;
+
+template <class Args>
+struct test_seq_ctor
+{
+    typename deduce_sequence<Args>::type fsq_args;
+
+    test_seq_ctor(Args const & args)
+        : fsq_args(args)
+    { }
+};
+
+#define TEST_SAME_TYPE(a,b) BOOST_TEST(( is_same< a, b >::value ))
+#define TEST_SAME_ELEMENTS(a,b) BOOST_TEST(( boost::mpl::equal< a, b >::type::value ))
+
+typedef fusion::vector<int, int const, int &, int const &> args1;
+typedef fusion::vector<int, int, int &, int> storable1;
+template struct test_seq_ctor<args1>;
+
+typedef fusion::vector< reference_wrapper<int> &, reference_wrapper<int const> &,
+    reference_wrapper<int> const &, reference_wrapper<int const> const & > args2;
+typedef fusion::vector<int &, int const &, int &, int const &> storable2;
+template struct test_seq_ctor<args2>;
+
+
+typedef fusion::vector<int *, int const *, int const * const, int const * &, int const * const &> args3;
+typedef fusion::vector<int *, int const *, int const *, int const * &, int const * > storable3;
+template struct test_seq_ctor<args3>;
+
+typedef fusion::vector<int(&)[2], int const(&)[2]> args4;
+typedef args4 storable4;
+template struct test_seq_ctor<args4>;
+
+int main()
+{
+    TEST_SAME_TYPE(deduce<int &>::type, int &);
+    TEST_SAME_TYPE(deduce<int volatile &>::type,  int volatile &);
+
+    TEST_SAME_TYPE(deduce<int>::type, int);
+    TEST_SAME_TYPE(deduce<int const &>::type, int);
+    TEST_SAME_TYPE(deduce<int const volatile &>::type, int);
+
+    TEST_SAME_TYPE(deduce< reference_wrapper<int> & >::type, int &);
+    TEST_SAME_TYPE(deduce< reference_wrapper<int const> & >::type, int const &);
+    TEST_SAME_TYPE(deduce< reference_wrapper<int> const & >::type, int &);
+    TEST_SAME_TYPE(deduce< reference_wrapper<int const> const & >::type, int const &);
+
+#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
+    TEST_SAME_TYPE(deduce< std::reference_wrapper<int> & >::type, int &);
+    TEST_SAME_TYPE(deduce< std::reference_wrapper<int const> & >::type, int const &);
+    TEST_SAME_TYPE(deduce< std::reference_wrapper<int> const & >::type, int &);
+    TEST_SAME_TYPE(deduce< std::reference_wrapper<int const> const & >::type, int const &);
+#endif
+
+    TEST_SAME_TYPE(deduce< int(&)[2] >::type, int(&)[2]);
+    TEST_SAME_TYPE(deduce< int const (&)[2] >::type, int const (&)[2]);
+    TEST_SAME_TYPE(deduce< int volatile (&)[2] >::type, int volatile (&)[2]);
+    TEST_SAME_TYPE(deduce< int const volatile (&)[2] >::type, int const volatile (&)[2]);
+
+    TEST_SAME_ELEMENTS(deduce_sequence<args1>::type,storable1);
+    TEST_SAME_ELEMENTS(deduce_sequence<args2>::type,storable2);
+    TEST_SAME_ELEMENTS(deduce_sequence<args3>::type,storable3);
+    TEST_SAME_ELEMENTS(deduce_sequence<args4>::type,storable4);
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/define_assoc_struct.cpp b/src/boost/libs/fusion/test/sequence/define_assoc_struct.cpp
new file mode 100644
index 00000000..231621f8
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_assoc_struct.cpp
@@ -0,0 +1,117 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
+#include <boost/preprocessor/empty.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+}
+
+BOOST_FUSION_DEFINE_ASSOC_STRUCT(
+    (ns),
+    point,
+    (int, x, ns::x_member)
+    (int, y, ns::y_member)
+)
+
+BOOST_FUSION_DEFINE_ASSOC_STRUCT(BOOST_PP_EMPTY(), empty_struct, )
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<ns::point>::value);
+        ns::point p(123, 456);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<ns::point>::value == 2);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<ns::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        vector<int, float> v1(4, 2.f);
+        ns::point v2(5, 3);
+        vector<long, double> v3(5, 4.);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from ns::point to vector
+        ns::point p(5, 3);
+        vector<int, long> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from ns::point to list
+        ns::point p(5, 3);
+        list<int, long> l(p);
+        l = p;
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<ns::point, ns::x_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<ns::point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<boost::fusion::result_of::has_key<ns::point, ns::z_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<ns::point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<ns::point, ns::y_member>::type, int>));
+
+        ns::point p(5, 3);
+        
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+    }
+
+    {
+        ns::point p = make_list(5,3);
+        BOOST_TEST(p == make_vector(5,3));
+
+        p = make_list(3,5);
+        BOOST_TEST(p == make_vector(3,5));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/define_assoc_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/define_assoc_struct_empty.cpp
new file mode 100644
index 00000000..91dd2f35
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_assoc_struct_empty.cpp
@@ -0,0 +1,78 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+
+BOOST_FUSION_DEFINE_ASSOC_STRUCT(BOOST_PP_EMPTY(), empty_struct, )
+
+int
+main()
+{
+    using namespace boost;
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
+        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
+        empty_struct e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct>::value == 0);
+        BOOST_STATIC_ASSERT(fusion::result_of::empty<empty_struct>::value);
+    }
+
+    {
+        vector<> v;
+        empty_struct e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(v != e);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(v > e);
+        BOOST_TEST(v >= e);
+    }
+
+    {
+        empty_struct e;
+
+        // conversion from empty_struct to vector
+        vector<> v(e);
+        v = e;
+
+        // conversion from empty_struct to list
+        //list<> l(e);
+        //l = e;
+    }
+
+    { // begin/end
+        typedef fusion::result_of::begin<empty_struct>::type b;
+        typedef fusion::result_of::end<empty_struct>::type e;
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<b, e>));
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_struct, void>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_struct, int>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/define_assoc_struct_move.cpp b/src/boost/libs/fusion/test/sequence/define_assoc_struct_move.cpp
new file mode 100644
index 00000000..07def389
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_assoc_struct_move.cpp
@@ -0,0 +1,67 @@
+/*=============================================================================
+    Copyright (c) 2016,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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
+#include <utility>
+
+struct key_type;
+struct wrapper
+{
+    int value;
+
+    wrapper() : value(42) {}
+    wrapper(wrapper&& other) : value(other.value) { other.value = 0; }
+    wrapper(wrapper const& other) : value(other.value) {}
+
+    wrapper& operator=(wrapper&& other) { value = other.value; other.value = 0; return *this; }
+    wrapper& operator=(wrapper const& other) { value = other.value; return *this; }
+};
+BOOST_FUSION_DEFINE_ASSOC_STRUCT((ns), value, (wrapper, w, key_type))
+
+int main()
+{
+    using namespace boost::fusion;
+
+    {
+        ns::value x;
+        ns::value y(x); // copy
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 43);
+
+        y = x; // copy assign
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 42);
+    }
+
+    {
+        ns::value x;
+        ns::value y(std::move(x)); // move
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 43);
+
+        y = std::move(x); // move assign
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 0);
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct.cpp b/src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct.cpp
new file mode 100644
index 00000000..bdbcfe47
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct.cpp
@@ -0,0 +1,121 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+namespace ns
+{
+    struct x_member;
+    struct y_member;
+    struct z_member;
+}
+
+BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT(
+    (X)(Y),
+    (ns),
+    point,
+    (int, x, ns::x_member)
+    (int, y, ns::y_member)
+)
+
+BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT((M), BOOST_PP_EMPTY(), empty_struct, )
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    typedef ns::point<int,int> point;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
+        point p(123, 456);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<point>::value == 2);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        vector<int, float> v1(4, 2.f);
+        point v2(5, 3);
+        vector<long, double> v3(5, 4.0);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p(5, 3);
+        vector<int, long> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p(5, 3);
+        list<int, long> l(p);
+        l = p;
+    }
+
+    {
+        // assoc stuff
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<point, ns::x_member>));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<point, ns::y_member>));
+        BOOST_MPL_ASSERT((boost::mpl::not_<boost::fusion::result_of::has_key<point, ns::z_member> >));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<point, ns::x_member>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_key<point, ns::y_member>::type, int>));
+
+        point p(5, 3);
+        
+        BOOST_TEST(at_key<ns::x_member>(p) == 5);
+        BOOST_TEST(at_key<ns::y_member>(p) == 3);
+    }
+
+    {
+        point p = make_list(5,3);
+        BOOST_TEST(p == make_vector(5,3));
+
+        p = make_list(3,5);
+        BOOST_TEST(p == make_vector(3,5));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct_empty.cpp
new file mode 100644
index 00000000..70d6ca50
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct_empty.cpp
@@ -0,0 +1,78 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+
+BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT((M), BOOST_PP_EMPTY(), empty_struct, )
+
+int
+main()
+{
+    using namespace boost;
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct<void> >));
+        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct<void> >::value);
+        empty_struct<void> e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct<void> >::value == 0);
+        BOOST_STATIC_ASSERT(fusion::result_of::empty<empty_struct<void> >::value);
+    }
+
+    {
+        vector<> v;
+        empty_struct<void> e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(v != e);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(v > e);
+        BOOST_TEST(v >= e);
+    }
+
+    {
+        empty_struct<void> e;
+
+        // conversion from empty_struct to vector
+        vector<> v(e);
+        v = e;
+
+        // conversion from empty_struct to list
+        //list<> l(e);
+        //l = e;
+    }
+
+    { // begin/end
+        typedef fusion::result_of::begin<empty_struct<void> >::type b;
+        typedef fusion::result_of::end<empty_struct<void> >::type e;
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<b, e>));
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct<void> >));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_struct<void>, void>));
+    BOOST_MPL_ASSERT_NOT((fusion::result_of::has_key<empty_struct<void>, int>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct_move.cpp b/src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct_move.cpp
new file mode 100644
index 00000000..dcffa566
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_assoc_tpl_struct_move.cpp
@@ -0,0 +1,78 @@
+/*=============================================================================
+    Copyright (c) 2016 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>
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
+#include <utility>
+
+struct key_type;
+struct wrapper
+{
+    int value;
+
+    wrapper() : value(42) {}
+    wrapper(wrapper&& other) : value(other.value) { other.value = 0; }
+    wrapper(wrapper const& other) : value(other.value) {}
+
+    wrapper& operator=(wrapper&& other) { value = other.value; other.value = 0; return *this; }
+    wrapper& operator=(wrapper const& other) { value = other.value; return *this; }
+};
+BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT((W), (ns), value, (W, w, key_type))
+
+int main()
+{
+    using namespace boost::fusion;
+
+    {
+        ns::value<wrapper> x;
+        ns::value<wrapper> y(x); // copy
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 43);
+
+        y = x; // copy assign
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 42);
+    }
+
+    {
+        ns::value<wrapper> x;
+        ns::value<wrapper> y(std::move(x)); // move
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 43);
+
+        y = std::move(x); // move assign
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 0);
+    }
+
+    return boost::report_errors();
+}
+
+#else
+
+int main()
+{
+}
+
+#endif
diff --git a/src/boost/libs/fusion/test/sequence/define_struct.cpp b/src/boost/libs/fusion/test/sequence/define_struct.cpp
new file mode 100644
index 00000000..1243b9fe
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_struct.cpp
@@ -0,0 +1,130 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/adapted/struct/define_struct.hpp>
+#include <boost/preprocessor/empty.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+BOOST_FUSION_DEFINE_STRUCT(
+    (ns),
+    point,
+    (int, x)
+    (int, y)
+)
+
+// Tutorial (compile test only)
+BOOST_FUSION_DEFINE_STRUCT(
+    (demo), employee,
+    (std::string, name)
+    (int, age)
+)
+
+BOOST_FUSION_DEFINE_STRUCT(BOOST_PP_EMPTY(), s, (int, m))
+
+BOOST_FUSION_DEFINE_STRUCT(BOOST_PP_EMPTY(), empty_struct, )
+
+// Testing non-constexpr compatible types
+BOOST_FUSION_DEFINE_STRUCT(
+    (ns),
+    employee, 
+    (std::string, name)
+    (std::string, nickname)
+)
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<ns::point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<ns::point>::value);
+        ns::point p(123, 456);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<ns::point>::value == 2);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<ns::point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        vector<int, float> v1(4, 2.f);
+        ns::point v2(5, 3);
+        vector<long, double> v3(5, 4.0);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from ns::point to vector
+        ns::point p(5, 3);
+        vector<int, long> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from ns::point to list
+        ns::point p(5, 3);
+        list<int, long> l(p);
+        l = p;
+    }
+
+    { // begin/end
+        using namespace boost::fusion;
+
+        typedef boost::fusion::result_of::begin<s>::type b;
+        typedef boost::fusion::result_of::end<s>::type e;
+        // this fails
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::next<b>::type, e>));
+    }
+
+    {
+        ns::point p = make_list(5,3);
+        BOOST_TEST(p == make_vector(5,3));
+
+        p = make_list(3,5);
+        BOOST_TEST(p == make_vector(3,5));
+    }
+
+    {
+        ns::employee emp = make_list("John Doe", "jdoe"); 
+        std::cout << at_c<0>(emp) << std::endl;
+        std::cout << at_c<1>(emp) << std::endl;
+
+        BOOST_TEST(emp == make_vector("John Doe", "jdoe"));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/define_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/define_struct_empty.cpp
new file mode 100644
index 00000000..1468b917
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_struct_empty.cpp
@@ -0,0 +1,76 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/adapted/struct/define_struct.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+
+BOOST_FUSION_DEFINE_STRUCT(BOOST_PP_EMPTY(), empty_struct, )
+
+int
+main()
+{
+    using namespace boost;
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
+        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
+        empty_struct e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct>::value == 0);
+        BOOST_STATIC_ASSERT(fusion::result_of::empty<empty_struct>::value);
+    }
+
+    {
+        vector<> v;
+        empty_struct e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(v != e);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(v > e);
+        BOOST_TEST(v >= e);
+    }
+
+    {
+        empty_struct e;
+
+        // conversion from empty_struct to vector
+        vector<> v(e);
+        v = e;
+
+        // conversion from empty_struct to list
+        //list<> l(e);
+        //l = e;
+    }
+
+    { // begin/end
+        typedef fusion::result_of::begin<empty_struct>::type b;
+        typedef fusion::result_of::end<empty_struct>::type e;
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<b, e>));
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/define_struct_inline.cpp b/src/boost/libs/fusion/test/sequence/define_struct_inline.cpp
new file mode 100644
index 00000000..4a3793b7
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_struct_inline.cpp
@@ -0,0 +1,153 @@
+/*=============================================================================
+    Copyright (c) 2010, 2012 Christopher Schmidt, Nathan Ridge
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/adapted/struct/define_struct_inline.hpp>
+#include <boost/preprocessor/empty.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+struct cls
+{
+    BOOST_FUSION_DEFINE_STRUCT_INLINE(
+        point,
+        (int, x)
+        (int, y)
+    )
+};
+
+template <typename = int>
+struct tpl_cls
+{
+    BOOST_FUSION_DEFINE_STRUCT_INLINE(
+        point,
+        (int, x)
+        (int, y)
+    )
+};
+
+namespace ns
+{
+    BOOST_FUSION_DEFINE_STRUCT_INLINE(s, (int, m))
+            
+    BOOST_FUSION_DEFINE_STRUCT_INLINE(empty_struct, )
+
+    // Testing non-constexpr compatible types
+    BOOST_FUSION_DEFINE_STRUCT_INLINE(
+        employee, 
+        (std::string, name)
+        (std::string, nickname)
+    )
+}
+
+template <typename Point>
+void run_test()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<ns::empty_struct>::value == 0);
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::empty<ns::empty_struct>::value);
+    }
+    
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<Point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<Point>::value);
+        Point p(123, 456);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<Point>::value == 2);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<Point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        vector<int, float> v1(4, 2.0f);
+        Point v2(5, 3);
+        vector<long, double> v3(5, 4.);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from Point to vector
+        Point p(5, 3);
+        vector<int, long> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from Point to list
+        Point p(5, 3);
+        list<int, long> l(p);
+        l = p;
+    }
+
+    { // begin/end
+        using namespace boost::fusion;
+
+        typedef boost::fusion::result_of::begin<ns::s>::type b;
+        typedef boost::fusion::result_of::end<ns::s>::type e;
+        // this fails
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::next<b>::type, e>));
+    }
+
+    {
+        Point p = make_list(5,3);
+        BOOST_TEST(p == make_vector(5,3));
+
+        p = make_list(3,5);
+        BOOST_TEST(p == make_vector(3,5));
+    }
+}
+
+int
+main()
+{
+    run_test<cls::point>();        // test with non-template enclosing class
+    run_test<tpl_cls<>::point>();  // test with template enclosing class
+
+    {
+        using namespace boost::fusion;
+
+        ns::employee emp = make_list("John Doe", "jdoe"); 
+        std::cout << at_c<0>(emp) << std::endl;
+        std::cout << at_c<1>(emp) << std::endl;
+
+        BOOST_TEST(emp == make_vector("John Doe", "jdoe"));
+    }
+
+    return boost::report_errors();
+
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/define_struct_inline_empty.cpp b/src/boost/libs/fusion/test/sequence/define_struct_inline_empty.cpp
new file mode 100644
index 00000000..4168770a
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_struct_inline_empty.cpp
@@ -0,0 +1,76 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/adapted/struct/define_struct_inline.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+
+BOOST_FUSION_DEFINE_STRUCT_INLINE(empty_struct, )
+
+int
+main()
+{
+    using namespace boost;
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct>));
+        BOOST_STATIC_ASSERT(!traits::is_view<empty_struct>::value);
+        empty_struct e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct>::value == 0);
+        BOOST_STATIC_ASSERT(fusion::result_of::empty<empty_struct>::value);
+    }
+
+    {
+        vector<> v;
+        empty_struct e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(v != e);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(v > e);
+        BOOST_TEST(v >= e);
+    }
+
+    {
+        empty_struct e;
+
+        // conversion from empty_struct to vector
+        vector<> v(e);
+        v = e;
+
+        // conversion from empty_struct to list
+        //list<> l(e);
+        //l = e;
+    }
+
+    { // begin/end
+        typedef fusion::result_of::begin<empty_struct>::type b;
+        typedef fusion::result_of::end<empty_struct>::type e;
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<b, e>));
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/define_struct_inline_move.cpp b/src/boost/libs/fusion/test/sequence/define_struct_inline_move.cpp
new file mode 100644
index 00000000..3c707404
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_struct_inline_move.cpp
@@ -0,0 +1,73 @@
+/*=============================================================================
+    Copyright (c) 2016-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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/define_struct_inline.hpp>
+#include <utility>
+
+struct wrapper
+{
+    int value;
+
+    wrapper() : value(42) {}
+    wrapper(wrapper&& other) : value(other.value) { other.value = 0; }
+    wrapper(wrapper const& other) : value(other.value) {}
+
+    wrapper& operator=(wrapper&& other) { value = other.value; other.value = 0; return *this; }
+    wrapper& operator=(wrapper const& other) { value = other.value; return *this; }
+};
+
+namespace ns
+{
+    BOOST_FUSION_DEFINE_STRUCT_INLINE(value, (wrapper, w))
+}
+
+int main()
+{
+    using namespace boost::fusion;
+
+    {
+        ns::value x;
+        ns::value y(x); // copy
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 43);
+
+        y = x; // copy assign
+
+        BOOST_TEST(x.w.value == 42);
+        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)))
+    {
+        ns::value x;
+        ns::value y(std::move(x)); // move
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 43);
+
+        y = std::move(x); // move assign
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 0);
+    }
+#endif // !(ci && (msvc < 14.0 || gcc 4.4.x))
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/define_struct_move.cpp b/src/boost/libs/fusion/test/sequence/define_struct_move.cpp
new file mode 100644
index 00000000..8732b59b
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_struct_move.cpp
@@ -0,0 +1,66 @@
+/*=============================================================================
+    Copyright (c) 2016,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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/define_struct.hpp>
+#include <utility>
+
+struct wrapper
+{
+    int value;
+
+    wrapper() : value(42) {}
+    wrapper(wrapper&& other) : value(other.value) { other.value = 0; }
+    wrapper(wrapper const& other) : value(other.value) {}
+
+    wrapper& operator=(wrapper&& other) { value = other.value; other.value = 0; return *this; }
+    wrapper& operator=(wrapper const& other) { value = other.value; return *this; }
+};
+BOOST_FUSION_DEFINE_STRUCT((ns), value, (wrapper, w))
+
+int main()
+{
+    using namespace boost::fusion;
+
+    {
+        ns::value x;
+        ns::value y(x); // copy
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 43);
+
+        y = x; // copy assign
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 42);
+    }
+
+    {
+        ns::value x;
+        ns::value y(std::move(x)); // move
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 43);
+
+        y = std::move(x); // move assign
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 0);
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/define_tpl_struct.cpp b/src/boost/libs/fusion/test/sequence/define_tpl_struct.cpp
new file mode 100644
index 00000000..b47ac611
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_tpl_struct.cpp
@@ -0,0 +1,112 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/adapted/struct/define_struct.hpp>
+#include <boost/preprocessor/empty.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+BOOST_FUSION_DEFINE_TPL_STRUCT(
+    (X)(Y),
+    (ns),
+    point,
+    (X, x)
+    (Y, y)
+)
+
+BOOST_FUSION_DEFINE_TPL_STRUCT((M), BOOST_PP_EMPTY(), s, (M, m))
+
+BOOST_FUSION_DEFINE_TPL_STRUCT((M), BOOST_PP_EMPTY(), empty_struct, )
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    typedef ns::point<int, int> point;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<point>::value);
+        point p(123, 456);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<point>::value == 2);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        vector<int, float> v1(4, 2.f);
+        point v2(5, 3);
+        vector<long, double> v3(5, 4.);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from point to vector
+        point p(5, 3);
+        vector<int, long> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from point to list
+        point p(5, 3);
+        list<int, long> l(p);
+        l = p;
+    }
+
+    { // begin/end
+        using namespace boost::fusion;
+
+        typedef boost::fusion::result_of::begin<s<int> >::type b;
+        typedef boost::fusion::result_of::end<s<int> >::type e;
+        // this fails
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::next<b>::type, e>));
+    }
+
+
+    {
+        point p = make_list(5,3);
+        BOOST_TEST(p == make_vector(5,3));
+
+        p = make_list(3,5);
+        BOOST_TEST(p == make_vector(3,5));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/define_tpl_struct_empty.cpp b/src/boost/libs/fusion/test/sequence/define_tpl_struct_empty.cpp
new file mode 100644
index 00000000..d8cf47de
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_tpl_struct_empty.cpp
@@ -0,0 +1,75 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/adapted/struct/define_struct.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+
+BOOST_FUSION_DEFINE_TPL_STRUCT((M), BOOST_PP_EMPTY(), empty_struct, )
+
+int
+main()
+{
+    using namespace boost;
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct<void> >));
+        empty_struct<void>  e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct<void> >::value == 0);
+        BOOST_STATIC_ASSERT(fusion::result_of::empty<empty_struct<void> >::value);
+    }
+
+    {
+        vector<> v;
+        empty_struct<void>  e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(v != e);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(v > e);
+        BOOST_TEST(v >= e);
+    }
+
+    {
+        empty_struct<void>  e;
+
+        // conversion from empty_struct to vector
+        vector<> v(e);
+        v = e;
+
+        // conversion from empty_struct to list
+        //list<> l(e);
+        //l = e;
+    }
+
+    { // begin/end
+        typedef fusion::result_of::begin<empty_struct<void> >::type b;
+        typedef fusion::result_of::end<empty_struct<void> >::type e;
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<b, e>));
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct<void> >));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/define_tpl_struct_inline.cpp b/src/boost/libs/fusion/test/sequence/define_tpl_struct_inline.cpp
new file mode 100644
index 00000000..3a7c69e3
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_tpl_struct_inline.cpp
@@ -0,0 +1,138 @@
+/*=============================================================================
+    Copyright (c) 2010, 2012 Christopher Schmidt, nathan Ridge
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/support.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/adapted/struct/define_struct_inline.hpp>
+#include <boost/preprocessor/empty.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+#include <string>
+
+struct cls
+{
+    BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE(
+        (X)(Y),
+        point,
+        (X, x)
+        (Y, y)
+    )
+};
+
+template <typename = int>
+struct tpl_cls
+{
+    BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE(
+        (X)(Y),
+        point,
+        (X, x)
+        (Y, y)
+    )
+};
+
+namespace ns
+{
+    BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE((M), s, (M, m))
+            
+    BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE((M), empty_struct, )
+}
+
+template <typename Point>
+void run_test()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<ns::empty_struct<int> >::value == 0);
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::empty<ns::empty_struct<int> >::value);
+    }
+    
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<Point>));
+        BOOST_STATIC_ASSERT(!traits::is_view<Point>::value);
+        Point p(123, 456);
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, 456));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = 9;
+        BOOST_TEST(p == make_vector(6, 9));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<Point>::value == 2);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<Point>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == 9);
+    }
+
+    {
+        vector<int, float> v1(4, 2.f);
+        Point v2(5, 3);
+        vector<long, double> v3(5, 4.);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from Point to vector
+        Point p(5, 3);
+        vector<int, long> v(p);
+        v = p;
+    }
+
+    {
+        // conversion from Point to list
+        Point p(5, 3);
+        list<int, long> l(p);
+        l = p;
+    }
+
+    { // begin/end
+        using namespace boost::fusion;
+
+        typedef boost::fusion::result_of::begin<ns::s<int> >::type b;
+        typedef boost::fusion::result_of::end<ns::s<int> >::type e;
+        // this fails
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::next<b>::type, e>));
+    }
+
+
+    {
+        Point p = make_list(5,3);
+        BOOST_TEST(p == make_vector(5,3));
+
+        p = make_list(3,5);
+        BOOST_TEST(p == make_vector(3,5));
+    }
+}
+
+int
+main()
+{
+    run_test<cls::point<int, int> >();        // test non-template enclosing class
+    run_test<tpl_cls<>::point<int, int> >();  // test template enclosing class
+    
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/define_tpl_struct_inline_empty.cpp b/src/boost/libs/fusion/test/sequence/define_tpl_struct_inline_empty.cpp
new file mode 100644
index 00000000..5cc0163f
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_tpl_struct_inline_empty.cpp
@@ -0,0 +1,75 @@
+/*=============================================================================
+    Copyright (c) 2016 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/detail/lightweight_test.hpp>
+#include <boost/fusion/container.hpp>
+#include <boost/fusion/sequence.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/adapted/struct/define_struct_inline.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+
+BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE((M), empty_struct, )
+
+int
+main()
+{
+    using namespace boost;
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        BOOST_MPL_ASSERT_NOT((traits::is_view<empty_struct<void> >));
+        empty_struct<void>  e;
+
+        std::cout << e << std::endl;
+        BOOST_TEST(e == make_vector());
+
+        BOOST_STATIC_ASSERT(fusion::result_of::size<empty_struct<void> >::value == 0);
+        BOOST_STATIC_ASSERT(fusion::result_of::empty<empty_struct<void> >::value);
+    }
+
+    {
+        vector<> v;
+        empty_struct<void>  e;
+        BOOST_TEST(v == e);
+        BOOST_TEST_NOT(v != e);
+        BOOST_TEST_NOT(v < e);
+        BOOST_TEST(v <= e);
+        BOOST_TEST_NOT(v > e);
+        BOOST_TEST(v >= e);
+    }
+
+    {
+        empty_struct<void>  e;
+
+        // conversion from empty_struct to vector
+        vector<> v(e);
+        v = e;
+
+        // conversion from empty_struct to list
+        //list<> l(e);
+        //l = e;
+    }
+
+    { // begin/end
+        typedef fusion::result_of::begin<empty_struct<void> >::type b;
+        typedef fusion::result_of::end<empty_struct<void> >::type e;
+
+        BOOST_MPL_ASSERT((fusion::result_of::equal_to<b, e>));
+    }
+
+    BOOST_MPL_ASSERT((mpl::is_sequence<empty_struct<void> >));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/define_tpl_struct_inline_move.cpp b/src/boost/libs/fusion/test/sequence/define_tpl_struct_inline_move.cpp
new file mode 100644
index 00000000..39a00079
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_tpl_struct_inline_move.cpp
@@ -0,0 +1,73 @@
+/*=============================================================================
+    Copyright (c) 2016-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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/define_struct_inline.hpp>
+#include <utility>
+
+struct wrapper
+{
+    int value;
+
+    wrapper() : value(42) {}
+    wrapper(wrapper&& other) : value(other.value) { other.value = 0; }
+    wrapper(wrapper const& other) : value(other.value) {}
+
+    wrapper& operator=(wrapper&& other) { value = other.value; other.value = 0; return *this; }
+    wrapper& operator=(wrapper const& other) { value = other.value; return *this; }
+};
+
+namespace ns
+{
+    BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE((W), value, (W, w))
+}
+
+int main()
+{
+    using namespace boost::fusion;
+
+    {
+        ns::value<wrapper> x;
+        ns::value<wrapper> y(x); // copy
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 43);
+
+        y = x; // copy assign
+
+        BOOST_TEST(x.w.value == 42);
+        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)))
+    {
+        ns::value<wrapper> x;
+        ns::value<wrapper> y(std::move(x)); // move
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 43);
+
+        y = std::move(x); // move assign
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 0);
+    }
+#endif // !(ci && (msvc < 14.0 || gcc 4.4.x))
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/define_tpl_struct_move.cpp b/src/boost/libs/fusion/test/sequence/define_tpl_struct_move.cpp
new file mode 100644
index 00000000..c4dd9ab6
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/define_tpl_struct_move.cpp
@@ -0,0 +1,66 @@
+/*=============================================================================
+    Copyright (c) 2016,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/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/struct/define_struct.hpp>
+#include <utility>
+
+struct wrapper
+{
+    int value;
+
+    wrapper() : value(42) {}
+    wrapper(wrapper&& other) : value(other.value) { other.value = 0; }
+    wrapper(wrapper const& other) : value(other.value) {}
+
+    wrapper& operator=(wrapper&& other) { value = other.value; other.value = 0; return *this; }
+    wrapper& operator=(wrapper const& other) { value = other.value; return *this; }
+};
+BOOST_FUSION_DEFINE_TPL_STRUCT((W), (ns), value, (W, w))
+
+int main()
+{
+    using namespace boost::fusion;
+
+    {
+        ns::value<wrapper> x;
+        ns::value<wrapper> y(x); // copy
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 43);
+
+        y = x; // copy assign
+
+        BOOST_TEST(x.w.value == 42);
+        BOOST_TEST(y.w.value == 42);
+    }
+
+    {
+        ns::value<wrapper> x;
+        ns::value<wrapper> y(std::move(x)); // move
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 42);
+
+        ++y.w.value;
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 43);
+
+        y = std::move(x); // move assign
+
+        BOOST_TEST(x.w.value == 0);
+        BOOST_TEST(y.w.value == 0);
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/deque_comparison.cpp b/src/boost/libs/fusion/test/sequence/deque_comparison.cpp
new file mode 100644
index 00000000..9bbf4fd9
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_comparison.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/deque/deque.hpp>
+
+#define FUSION_SEQUENCE deque
+#include "comparison.hpp"
+
+int
+main()
+{
+    equality_test();
+    ordering_test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/deque_construction.cpp b/src/boost/libs/fusion/test/sequence/deque_construction.cpp
new file mode 100644
index 00000000..4fc8c883
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_construction.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/deque/deque.hpp>
+
+#define FUSION_SEQUENCE deque
+#include "construction.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/deque_copy.cpp b/src/boost/libs/fusion/test/sequence/deque_copy.cpp
new file mode 100644
index 00000000..5c48d5ec
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_copy.cpp
@@ -0,0 +1,42 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/deque/deque.hpp>
+#include <boost/fusion/container/generation/make_deque.hpp>
+#include <boost/fusion/container/generation/deque_tie.hpp>
+
+#define FUSION_SEQUENCE deque
+#include "copy.hpp"
+
+using namespace test_detail;
+
+// c++11 deque has bug, cannot properly copy-assign from a const value
+template <typename T>
+struct skip_const_lvalue_assignment
+{
+    template <typename Source, typename Expected>
+    bool operator()(Source const& source, Expected const& expected) const
+    {
+        return
+            run< can_implicit_construct<T> >(source, expected) &&
+            run< can_construct<T> >(source, expected) &&
+            run< can_rvalue_assign<T> >(source, expected) &&
+            run< can_lvalue_assign<T> >(source, expected);
+    }
+};
+
+int
+main()
+{
+#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
+    test<skip_const_lvalue_assignment>();
+#else
+    test<can_copy>();
+#endif
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/deque_hash.cpp b/src/boost/libs/fusion/test/sequence/deque_hash.cpp
new file mode 100644
index 00000000..01b36660
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_hash.cpp
@@ -0,0 +1,16 @@
+/*=============================================================================
+    Copyright (c) 2014 Christoph Weiss
+
+    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/deque/deque.hpp>
+
+#define FUSION_SEQUENCE deque
+#include "hash.hpp"
+
+int main()
+{
+    hash_test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/deque_is_constructible.cpp b/src/boost/libs/fusion/test/sequence/deque_is_constructible.cpp
new file mode 100644
index 00000000..e08b4787
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_is_constructible.cpp
@@ -0,0 +1,21 @@
+/*=============================================================================
+    Copyright (c) 2015 Louis Dionne
+
+    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>
+
+#ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#include <type_traits>
+#include <boost/fusion/include/deque.hpp>
+
+
+struct Dummy { };
+
+// Make sure deque's constructor is SFINAE-friendly.
+static_assert(!std::is_constructible<boost::fusion::deque<int>, Dummy const&>::value, "");
+
+#endif
+
diff --git a/src/boost/libs/fusion/test/sequence/deque_iterator.cpp b/src/boost/libs/fusion/test/sequence/deque_iterator.cpp
new file mode 100644
index 00000000..10ce27f8
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_iterator.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/deque/deque.hpp>
+
+#define FUSION_SEQUENCE deque
+#define FUSION_TRAVERSAL_TAG bidirectional_traversal_tag
+#include "./iterator.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/deque_make.cpp b/src/boost/libs/fusion/test/sequence/deque_make.cpp
new file mode 100644
index 00000000..fe570533
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_make.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/deque/deque.hpp>
+#include <boost/fusion/container/generation/make_deque.hpp>
+
+#define FUSION_SEQUENCE deque
+#include "make.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/deque_misc.cpp b/src/boost/libs/fusion/test/sequence/deque_misc.cpp
new file mode 100644
index 00000000..402afacc
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_misc.cpp
@@ -0,0 +1,24 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/deque/deque.hpp>
+#include <boost/fusion/container/deque/convert.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+
+#define BOOST_FUSION_SEQUENCE_CONVERSION_IS_NOT_SEQUENCE__TYPE_PRESERVING
+
+#define FUSION_SEQUENCE deque
+#include "misc.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/deque_move.cpp b/src/boost/libs/fusion/test/sequence/deque_move.cpp
new file mode 100644
index 00000000..b3bdf11b
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_move.cpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 2012 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)
+==============================================================================*/
+#define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+#include <boost/fusion/container/deque/deque.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::deque<std::vector<x>>
+#define FUSION_SEQUENCE2 boost::fusion::deque<std::vector<x>, x>
+
+#include "move.hpp"
+
+int main()
+{
+    test();
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/deque_mutate.cpp b/src/boost/libs/fusion/test/sequence/deque_mutate.cpp
new file mode 100644
index 00000000..1564ade9
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_mutate.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006
+
+    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/deque/deque.hpp>
+
+#define FUSION_SEQUENCE deque
+#include "mutate.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/deque_nest.cpp b/src/boost/libs/fusion/test/sequence/deque_nest.cpp
new file mode 100644
index 00000000..fd69d151
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_nest.cpp
@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (C) 2015 Kohei Takahshi
+
+    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/deque/deque.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::deque
+#include "nest.hpp"
+
+/* deque has a few issues:
+    - sequence conversion constructor is explicit
+    - assignment sequence conversion has bug in base class
+    - c++11 direct assignment from lvalue has bug */
+template <typename T>
+struct skip_issues
+{
+    template <typename Source, typename Expected>
+    bool operator()(Source const& source, Expected const& expected) const
+    {
+        using namespace test_detail;
+        return
+#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
+            run< can_construct<T> >(source, expected) &&
+            run< can_implicit_construct<T> >(source, expected) &&
+            run< can_rvalue_assign<T> >(source, expected) &&
+            run< can_convert_using<can_construct>::to<T> >(source, expected) &&
+#else
+            run< can_copy<T> >(source, expected) &&
+#endif
+            run< can_construct_from_elements<T> >(source, expected);
+    }
+};
+
+int
+main()
+{
+    test<skip_issues>();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/deque_tie.cpp b/src/boost/libs/fusion/test/sequence/deque_tie.cpp
new file mode 100644
index 00000000..f6ee9160
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_tie.cpp
@@ -0,0 +1,23 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/deque/deque.hpp>
+#include <boost/fusion/container/generation/deque_tie.hpp>
+#include <boost/fusion/container/generation/ignore.hpp>
+#include <boost/fusion/container/generation/make_deque.hpp>
+
+#define FUSION_SEQUENCE deque
+#include "tie.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/deque_value_at.cpp b/src/boost/libs/fusion/test/sequence/deque_value_at.cpp
new file mode 100644
index 00000000..5b31504f
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/deque_value_at.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/deque/deque.hpp>
+
+#define FUSION_SEQUENCE deque
+#include "value_at.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/filter_view.cpp b/src/boost/libs/fusion/test/sequence/filter_view.cpp
new file mode 100644
index 00000000..8ebe1476
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/filter_view.cpp
@@ -0,0 +1,129 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/container/vector/vector_iterator.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/view/filter_view/filter_view.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/container/map.hpp>
+#include <boost/fusion/sequence/intrinsic/has_key.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/iterator/key_of.hpp>
+#include <boost/fusion/iterator/value_of_data.hpp>
+#include <boost/fusion/iterator/deref_data.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/arg.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/vector_c.hpp>
+#include <boost/mpl/less.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/assert.hpp>
+
+struct X
+{
+    operator char const*() const
+    {
+        return "<X-object>";
+    }
+};
+
+struct Y
+{
+    operator char const*() const
+    {
+        return "<Y-object>";
+    }
+};
+
+struct reject_all
+{
+    template<typename T>
+    struct apply : boost::mpl::false_
+    {};
+};
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    using boost::mpl::int_;
+    using boost::mpl::_;
+    using boost::mpl::not_;
+    using boost::mpl::less;
+    using boost::mpl::vector_c;
+    using boost::is_class;
+    using boost::is_same;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        typedef vector<Y, char, long, X, bool, double> vector_type;
+
+        X x; Y y;
+        vector_type v(y, '@', 987654, x, true, 6.6);
+        typedef filter_view<vector_type const, not_<is_class<_> > > filter_view_type;
+        filter_view_type view(v);
+        std::cout << view << std::endl;
+        BOOST_TEST((view == make_vector('@', 987654, true, 6.6)));
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<filter_view_type>::value == 4);
+    }
+
+    //cschmidt: This is illegal C++. ADL instantiates less<_, int_<3> > - which
+    //leads to compile errors.
+    /*{
+        // $$$ JDG $$$ For some obscure reason, EDG based compilers
+        // (e.g. comeau 4.3.3, intel) have problems with this.
+        // vc7.1 and g++ are ok. The errors from comeau are useless.
+        
+#ifndef __EDG_VERSION__
+        typedef vector_c<int, 5, 1, 2, 3, 6, 0, -1> vector_type;
+        typedef filter_view<vector_type const, less<_, int_<3> > > filter_view_type;
+        vector_type v;
+        filter_view_type view(v);
+        std::cout << view << std::endl;
+        BOOST_TEST((view == make_vector(1, 2, 0, -1)));
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<filter_view_type>::value == 4);
+#endif
+    }*/
+
+    {
+        // Previous filtering out all values caused problems as begin<seq> was not equal to end<seq>
+        // Picked up by Andreas Pokorny
+        typedef vector<int> vec;
+        typedef filter_view<vec, reject_all> filter_view_type;
+
+        BOOST_MPL_ASSERT((boost::fusion::result_of::equal_to<boost::fusion::result_of::begin<filter_view_type>::type, boost::fusion::result_of::end<filter_view_type>::type>));
+    }
+
+    {
+        typedef map<pair<void, int>, pair<double, std::string> > map_type;
+        map_type m(make_pair<void>(0), make_pair<double>("Bond"));
+
+        typedef filter_view<map_type const, is_same<_, pair<double, std::string> > > filter_view_type;
+        filter_view_type f(m);
+
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<filter_view_type, double>::type));
+        BOOST_MPL_ASSERT_NOT((boost::fusion::result_of::has_key<filter_view_type, void>::type));
+
+        BOOST_MPL_ASSERT((is_same<boost::fusion::result_of::key_of<boost::fusion::result_of::begin<filter_view_type>::type>::type, double>));
+        BOOST_MPL_ASSERT((is_same<boost::fusion::result_of::value_of_data<boost::fusion::result_of::begin<filter_view_type>::type>::type, std::string>));
+
+        std::cout << deref_data(begin(f)) << std::endl;
+        BOOST_TEST((deref_data(begin(f)) == "Bond"));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/fixture.hpp b/src/boost/libs/fusion/test/sequence/fixture.hpp
new file mode 100644
index 00000000..4cb05971
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/fixture.hpp
@@ -0,0 +1,216 @@
+/*=============================================================================
+    Copyright (c) 2016 Lee Clagett
+
+    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/comparison.hpp>
+#include <boost/mpl/identity.hpp>
+
+namespace test_detail
+{
+    struct convertible
+    {
+        convertible() : value_() {}
+        convertible(int value) : value_(value) {}
+        int value_;
+    };
+
+    bool operator==(convertible const& lhs, convertible const& rhs)
+    {
+        return lhs.value_ == rhs.value_;
+    }
+
+    bool operator!=(convertible const& lhs, convertible const& rhs)
+    {
+        return lhs.value_ != rhs.value_;
+    }
+
+    // Testing conversion at function call allows for testing mutable lvalue,
+    // const lvalue, and rvalue as the source. mpl::identity prevents deduction
+    template <typename T>
+    T implicit_construct(typename boost::mpl::identity<T>::type source)
+    {
+        return source;
+    }
+
+    template <typename F, typename Source, typename Expected>
+    bool run(Source const& source, Expected const& expected)
+    {
+        return F()(source, expected);
+    }
+
+    template <typename F, typename Source>
+    bool run(Source const& source)
+    {
+        return run<F>(source, source);
+    }
+
+    template <typename T>
+    struct can_rvalue_implicit_construct
+    {
+        template<typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected) const
+        {
+            return expected == implicit_construct<T>(implicit_construct<Source>(source));
+        }
+    };
+
+    template <typename T>
+    struct can_lvalue_implicit_construct    
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source source, Expected const& expected) const
+        {
+            return expected == implicit_construct<T>(source);
+        }
+    };
+
+    template <typename T>
+    struct can_const_lvalue_implicit_construct
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected) const
+        {
+            return expected == implicit_construct<T>(source);
+        }
+    };
+
+    template <typename T>
+    struct can_implicit_construct
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected) const
+        {
+            return
+                run< can_rvalue_implicit_construct<T> >(source, expected) &&
+                run< can_lvalue_implicit_construct<T> >(source, expected) &&
+                run< can_const_lvalue_implicit_construct<T> >(source, expected);
+        }
+    };
+
+    template <typename T>
+    struct can_rvalue_construct
+    {
+        template<typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected) const
+        {
+            return expected == T(implicit_construct<Source>(source));
+        }
+    };
+
+    template <typename T>
+    struct can_lvalue_construct    
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source source, Expected const& expected) const
+        {
+            return expected == T(source);
+        }
+    };
+
+    template <typename T>
+    struct can_const_lvalue_construct
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected) const
+        {
+            return expected == T(source);
+        }
+    };
+
+    template <typename T>
+    struct can_construct
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected) const
+        {
+            return
+                run< can_rvalue_construct<T> >(source, expected) &&
+                run< can_lvalue_construct<T> >(source, expected) &&
+                run< can_const_lvalue_construct<T> >(source, expected);
+        }
+    };
+
+    template <typename T>
+    struct can_rvalue_assign
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected) const
+        {
+            bool result = true;
+            {
+                T seq;
+                result &= (seq == expected || seq != expected);
+
+                seq = implicit_construct<Source>(source);
+                result &= (seq == expected);
+            }
+            return result;
+        }
+    };
+
+    template <typename T>    
+    struct can_lvalue_assign
+    {
+
+        template <typename Source, typename Expected>
+        bool operator()(Source source, Expected const& expected) const
+        {
+            bool result = true;
+            {
+                T seq;
+                result &= (seq == expected || seq != expected);
+
+                seq = source;
+                result &= (seq == expected);
+            }
+            return result;
+        }
+    };
+
+    template <typename T>
+    struct can_const_lvalue_assign
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected) const
+        {
+            bool result = true;
+            {
+                T seq;
+                result &= (seq == expected || seq != expected);
+
+                seq = source;
+                result &= (seq == expected);
+            }
+            return result;
+        }
+    };
+    
+    template <typename T>
+    struct can_assign
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected) const
+        {
+            return 
+                run< can_rvalue_assign<T> >(source, expected) &&
+                run< can_lvalue_assign<T> >(source, expected) &&
+                run< can_const_lvalue_assign<T> >(source, expected);
+        }
+    };
+
+    template <typename T>
+    struct can_copy
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected) const
+        {
+            return
+                run< can_construct<T> >(source, expected) &&
+                run< can_implicit_construct<T> >(source, expected) &&
+                run< can_assign<T> >(source, expected);
+        }
+    }; 
+} // test_detail
diff --git a/src/boost/libs/fusion/test/sequence/flatten_view.cpp b/src/boost/libs/fusion/test/sequence/flatten_view.cpp
new file mode 100644
index 00000000..da8e6527
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/flatten_view.cpp
@@ -0,0 +1,56 @@
+/*==============================================================================
+    Copyright (c) 2013 Jamboree
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/view/flatten_view/flatten_view.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+#include <boost/fusion/algorithm/auxiliary/copy.hpp>
+
+
+int main()
+{
+    using namespace boost::fusion;
+
+    {
+        typedef vector<int, int, vector<int, int>, int> sequence_type;
+        sequence_type seq(1, 2, make_vector(3, 4), 5);
+        flatten_view<sequence_type> flattened(seq);
+
+        BOOST_TEST((boost::fusion::size(flattened) == 5));
+        BOOST_TEST((boost::fusion::distance(boost::fusion::begin(flattened), boost::fusion::end(flattened)) == 5));
+    }
+        
+    {
+        typedef vector<int, int, vector<int, int>, int> sequence_type;
+        sequence_type seq(1, 2, make_vector(3, 4), 5);
+        flatten_view<sequence_type> flattened(seq);
+        std::cout << flattened << std::endl;
+        BOOST_TEST((flattened == make_vector(1, 2, 3, 4, 5)));
+        BOOST_TEST((*advance_c<2>(boost::fusion::begin(flattened)) == 3));
+    }
+
+    {
+        typedef vector<int, int, vector<int, int>, int> sequence_type;
+        sequence_type seq;
+        flatten_view<sequence_type> flattened(seq);
+        copy(make_vector(1, 2, 3, 4, 5), flattened);
+        std::cout << seq << std::endl;
+        BOOST_TEST((seq == make_vector(1, 2, make_vector(3, 4), 5)));
+    }
+    
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/front_extended_deque.cpp b/src/boost/libs/fusion/test/sequence/front_extended_deque.cpp
new file mode 100644
index 00000000..cdbedeb3
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/front_extended_deque.cpp
@@ -0,0 +1,114 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/fusion/container/deque/deque.hpp>
+#include <boost/fusion/container/deque/front_extended_deque.hpp>
+#include <boost/fusion/sequence/comparison.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/mpl.hpp>
+
+#include <boost/fusion/sequence/intrinsic.hpp>
+#include <boost/fusion/iterator.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+int main()
+{
+    using namespace boost::fusion;
+    {
+        typedef deque<> initial_deque_type;
+        initial_deque_type initial_deque;
+        typedef front_extended_deque<initial_deque_type, int> extended_type;
+        extended_type extended(initial_deque, 1);
+
+        BOOST_TEST(size(extended) == 1);
+        BOOST_TEST(extended == make_vector(1));
+        BOOST_TEST(*begin(extended) == 1);
+        BOOST_TEST(*prior(end(extended)) == 1);
+        BOOST_TEST(distance(begin(extended), end(extended)) == 1);
+    }
+    {
+        namespace mpl = boost::mpl;
+        typedef deque<> initial_deque_type;
+        typedef front_extended_deque<initial_deque_type, int> extended_type;
+
+        BOOST_MPL_ASSERT((boost::is_same<mpl::at_c<extended_type, 0>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<mpl::deref<mpl::begin<extended_type>::type>::type, int>));
+        BOOST_MPL_ASSERT((mpl::equal_to<mpl::size<extended_type>::type, mpl::int_<1> >));
+    }
+    {
+        int i(1);
+        typedef deque<> initial_deque_type;
+        initial_deque_type initial_deque;
+        typedef front_extended_deque<initial_deque_type, int&> extended_type;
+        extended_type extended(initial_deque, i);
+        BOOST_TEST(extended == make_vector(1));
+
+        int i2(2);
+        extended_type extended2(initial_deque_type(), i2);
+
+        extended = extended2;
+
+        BOOST_TEST(extended == make_vector(2));
+
+        BOOST_TEST(i == i2);
+    }
+
+    {
+        typedef deque<char, long> initial_deque_type;
+        initial_deque_type initial_deque('a', 101L);
+        typedef front_extended_deque<initial_deque_type, int> extended_type;
+        extended_type extended(initial_deque, 1);
+
+        BOOST_TEST(size(extended) == 3);
+        BOOST_TEST(extended == make_vector(1, 'a', 101L));
+        BOOST_TEST(*begin(extended) == 1);
+        BOOST_TEST(*next(begin(extended)) == 'a');
+        BOOST_TEST(*prior(end(extended)) == 101L);
+        BOOST_TEST(distance(begin(extended), end(extended)) == 3);
+        BOOST_TEST(*advance_c<2>(begin(extended)) == 101L);
+    }
+    {
+        namespace mpl = boost::mpl;
+        typedef deque<char, long> initial_deque_type;
+        typedef front_extended_deque<initial_deque_type, int> extended_type;
+
+        BOOST_MPL_ASSERT((boost::is_same<mpl::at_c<extended_type, 0>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<mpl::at_c<extended_type, 1>::type, char>));
+        BOOST_MPL_ASSERT((boost::is_same<mpl::at_c<extended_type, 2>::type, long>));
+        BOOST_MPL_ASSERT((boost::is_same<mpl::deref<mpl::begin<extended_type>::type>::type, int>));
+        BOOST_MPL_ASSERT((mpl::equal_to<mpl::size<extended_type>::type, mpl::int_<3> >));
+    }
+    {
+        char ch('a');
+        long l(101L);
+        int i(1);
+        typedef deque<char&, long&> initial_deque_type;
+        initial_deque_type initial_deque(ch, l);
+        typedef front_extended_deque<initial_deque_type, int&> extended_type;
+        extended_type extended(initial_deque, i);
+        BOOST_TEST(extended == make_vector(1, 'a', 101L));
+
+        char ch2('b');
+        long l2(202L);
+        int i2(2);
+        extended_type extended2(initial_deque_type(ch2, l2), i2);
+
+        extended = extended2;
+
+        BOOST_TEST(extended == make_vector(2, 'b', 202L));
+
+        BOOST_TEST(i == i2);
+        BOOST_TEST(ch == ch2);
+        BOOST_TEST(l == l2);
+    }
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/github-159.cpp b/src/boost/libs/fusion/test/sequence/github-159.cpp
new file mode 100644
index 00000000..e21d80c5
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/github-159.cpp
@@ -0,0 +1,16 @@
+/*=============================================================================
+    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)
+==============================================================================*/
+
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/type.hpp>
+
+int main()
+{
+    boost::fusion::vector<int, float> v1;
+    boost::fusion::vector<int, float> v2(v1);
+    v1 = v2;
+}
diff --git a/src/boost/libs/fusion/test/sequence/github-176.cpp b/src/boost/libs/fusion/test/sequence/github-176.cpp
new file mode 100644
index 00000000..3f57df27
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/github-176.cpp
@@ -0,0 +1,90 @@
+/*=============================================================================
+    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]> > >();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/hash.cpp b/src/boost/libs/fusion/test/sequence/hash.cpp
new file mode 100644
index 00000000..30b44055
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/hash.cpp
@@ -0,0 +1,59 @@
+/*=============================================================================
+    Copyright (c) 2014 Christoph Weiss
+
+    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 <string>
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+#include <boost/fusion/sequence/hash.hpp>
+
+struct test_struct
+{
+    test_struct(bool bb, int ii, char cc, std::string const& ss) :
+        b(bb),
+        i(ii),
+        c(cc),
+        s(ss) {}
+
+    bool b;
+    int i;
+    char c;
+    std::string s;
+};
+
+BOOST_FUSION_ADAPT_STRUCT(
+    test_struct,
+    (bool, b)
+    (int, i)
+    (char, c)
+    (std::string, s)
+)
+
+int main()
+{
+    using boost::fusion::hash_value;
+
+    const test_struct a0(false, 1, 'c', "Hello Nurse"),
+                      a1(false, 1, 'c', "Hello Nurse"),
+                      b(true, 1, 'c', "Hello Nurse"),
+                      c(false, 0, 'c', "Hello Nurse"),
+                      d(false, 1, 'd', "Hello Nurse"),
+                      e(false, 1, 'c', "Hello World");
+
+    BOOST_TEST(hash_value(a0) == hash_value(a1));
+    BOOST_TEST(hash_value(a0) != hash_value(b));
+    BOOST_TEST(hash_value(a0) != hash_value(c));
+    BOOST_TEST(hash_value(a0) != hash_value(d));
+    BOOST_TEST(hash_value(a0) != hash_value(e));
+    BOOST_TEST(hash_value(b) != hash_value(c));
+    BOOST_TEST(hash_value(b) != hash_value(d));
+    BOOST_TEST(hash_value(b) != hash_value(d));
+    BOOST_TEST(hash_value(c) != hash_value(d));
+    BOOST_TEST(hash_value(c) != hash_value(e));
+    BOOST_TEST(hash_value(d) != hash_value(e));
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/hash.hpp b/src/boost/libs/fusion/test/sequence/hash.hpp
new file mode 100644
index 00000000..b298f418
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/hash.hpp
@@ -0,0 +1,35 @@
+/*=============================================================================
+    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)
+==============================================================================*/
+#include <string>
+#include <utility>
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/hash.hpp>
+#include <boost/functional/hash.hpp>
+
+void hash_test()
+{
+    namespace fusion = boost::fusion;
+    using namespace 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));
+
+    const FUSION_SEQUENCE<int, char, bool, std::string> w(41, 'x', false, "Aurea prima");
+    BOOST_TEST(fusion::hash_value(w) != fusion::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));
+
+    const FUSION_SEQUENCE<int, char, bool, std::string> y(42, 'x', true, "Aurea prima");
+    BOOST_TEST(fusion::hash_value(y) != fusion::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));
+}
diff --git a/src/boost/libs/fusion/test/sequence/io.cpp b/src/boost/libs/fusion/test/sequence/io.cpp
new file mode 100644
index 00000000..d14f2af3
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/io.cpp
@@ -0,0 +1,131 @@
+/*=============================================================================
+    Copyright (C) 1999-2003 Jaakko Jarvi
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/io/in.hpp>
+
+#include <fstream>
+#include <iterator>
+#include <algorithm>
+#include <string>
+
+#if defined BOOST_NO_STRINGSTREAM
+# include <strstream>
+#else
+# include <sstream>
+#endif
+
+using boost::fusion::vector;
+using boost::fusion::make_vector;
+using boost::fusion::tuple_close;
+using boost::fusion::tuple_open;
+using boost::fusion::tuple_delimiter;
+
+#if defined BOOST_NO_STRINGSTREAM
+  using std::ostrstream;
+  using std::istrstream;
+  typedef ostrstream useThisOStringStream;
+  typedef istrstream useThisIStringStream;
+#else
+  using std::ostringstream;
+  using std::istringstream;
+  typedef ostringstream useThisOStringStream;
+  typedef istringstream useThisIStringStream;
+#endif
+
+using std::endl;
+using std::ofstream;
+using std::ifstream;
+using std::string;
+
+int
+main()
+{
+    using boost::fusion::tuple_close;
+    using boost::fusion::tuple_open;
+    using boost::fusion::tuple_delimiter;
+
+    useThisOStringStream os1;
+
+    // Set format [a, b, c] for os1
+    os1 << tuple_open('[');
+    os1 << tuple_close(']');
+    os1 << tuple_delimiter(',');
+    os1 << make_vector(1, 2, 3);
+
+    BOOST_TEST (os1.str() == std::string("[1,2,3]") );
+
+    {
+        useThisOStringStream os2;
+        // Set format (a:b:c) for os2;
+        os2 << tuple_open('(');
+        os2 << tuple_close(')');
+        os2 << tuple_delimiter(':');
+
+        os2 << make_vector("TUPU", "HUPU", "LUPU", 4.5);
+        BOOST_TEST (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
+    }
+
+    {
+        useThisOStringStream os2;
+        // Set format (a:b:c) for os2;
+        os2 << tuple_open('(');
+        os2 << tuple_close(')');
+        os2 << tuple_delimiter(':');
+        // overwrite previous setting
+        os2 << tuple_open("< ");
+        os2 << tuple_close('>');
+        os2 << tuple_delimiter(", ");
+
+        os2 << make_vector("TUPU", "HUPU", "LUPU", 4.5);
+        BOOST_TEST (os2.str() == std::string("< TUPU, HUPU, LUPU, 4.5>") );
+    }
+
+    // The format is still [a, b, c] for os1
+    os1 << make_vector(1, 2, 3);
+    BOOST_TEST (os1.str() == std::string("[1,2,3][1,2,3]") );
+
+    std::ofstream tmp("temp.tmp");
+
+    tmp << make_vector("One", "Two", 3);
+    tmp << tuple_delimiter(':');
+    tmp << make_vector(1000, 2000, 3000) << endl;
+
+    tmp.close();
+
+    // When reading tuples from a stream, manipulators must be set correctly:
+    ifstream tmp3("temp.tmp");
+    vector<string, string, int> j;
+
+    tmp3 >> j;
+    BOOST_TEST (tmp3.good() );
+
+    tmp3 >> tuple_delimiter(':');
+    vector<int, int, int> i;
+    tmp3 >> i;
+    BOOST_TEST (tmp3.good() );
+
+    tmp3.close();
+
+    // reading vector<int, int, int> in format (a b c);
+    useThisIStringStream is("(100 200 300)");
+
+    vector<int, int, int> ti;
+    BOOST_TEST(!!(is >> ti));
+    BOOST_TEST(ti == make_vector(100, 200, 300));
+
+    // Note that strings are problematic:
+    // writing a tuple on a stream and reading it back doesn't work in
+    // general. If this is wanted, some kind of a parseable string class
+    // should be used.
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/iterator.hpp b/src/boost/libs/fusion/test/sequence/iterator.hpp
new file mode 100644
index 00000000..d543f8eb
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/iterator.hpp
@@ -0,0 +1,200 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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 <string>
+#include <boost/static_assert.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/prior.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+
+void test()
+{
+    using boost::fusion::next;
+    using namespace boost::fusion;
+    using namespace boost;
+
+    { // Testing deref, next, prior, begin, end
+
+        char const* s = "Hello";
+        typedef FUSION_SEQUENCE<int, char, double, char const*> seq_type;
+        seq_type v(1, 'x', 3.3, s);
+        boost::fusion::result_of::begin<seq_type>::type i(v);
+
+        BOOST_TEST(*i == 1);
+        BOOST_TEST(*next(i) == 'x');
+        BOOST_TEST(*next(next(i)) == 3.3);
+        BOOST_TEST(*next(next(next(i))) == s);
+        next(next(next(next(i)))); // end
+
+#if !defined(FUSION_NO_PRIOR)
+        BOOST_TEST(*prior(next(next(next(i)))) == 3.3);
+        BOOST_TEST(*prior(prior(next(next(next(i))))) == 'x');
+        BOOST_TEST(*prior(prior(prior(next(next(next(i)))))) == 1);
+#endif
+        BOOST_TEST(*begin(v) == 1);
+#if !defined(FUSION_NO_PRIOR)
+        BOOST_TEST(*prior(end(v)) == s);
+#endif
+
+        *i = 3;
+        BOOST_TEST(*i == 3);
+        BOOST_TEST(&*i == &at_c<0>(v));
+
+        // prove that it is mutable
+        *i = 987;
+        BOOST_TEST(*i == 987);
+    }
+
+    { // Testing const sequence and const iterator
+
+        char const* s = "Hello";
+        typedef FUSION_SEQUENCE<int, char, double, char const*> const seq_type;
+        seq_type t(1, 'x', 3.3, s);
+        boost::fusion::result_of::begin<seq_type>::type i(t);
+
+        BOOST_TEST(*i == 1);
+        BOOST_TEST(*next(i) == 'x');
+        BOOST_TEST(*begin(t) == 1);
+#if !defined(FUSION_NO_PRIOR)
+        BOOST_TEST(*prior(end(t)) == s);
+#endif
+
+#ifdef FUSION_TEST_FAIL
+        *i = 3; // must not compile
+#endif
+    }
+
+    { // Testing iterator equality
+
+        typedef FUSION_SEQUENCE<int, char, double, char const*> seq_type;
+        typedef FUSION_SEQUENCE<int, char, double, char const*> const cseq_type;
+        typedef boost::fusion::result_of::begin<seq_type>::type vi1;
+        typedef boost::fusion::result_of::begin<cseq_type>::type vi2;
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::equal_to<vi1 const, vi1>::value));
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::equal_to<vi1, vi1 const>::value));
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::equal_to<vi1, vi2>::value));
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::equal_to<vi1 const, vi2>::value));
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::equal_to<vi1, vi2 const>::value));
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::equal_to<vi1 const, vi2 const>::value));
+    }
+
+    {
+        typedef FUSION_SEQUENCE<int, int> seq_type;
+        typedef boost::fusion::result_of::begin<seq_type>::type begin_type;
+        typedef boost::fusion::result_of::end<seq_type>::type end_type;
+        typedef boost::fusion::result_of::next<begin_type>::type i1;
+        typedef boost::fusion::result_of::next<i1>::type i2;
+
+        BOOST_STATIC_ASSERT((is_same<end_type, i2>::value));
+    }
+
+    { // testing deref, next, prior, begin, end
+
+        char const* s = "Hello";
+        typedef FUSION_SEQUENCE<int, char, double, char const*> seq_type;
+        seq_type t(1, 'x', 3.3, s);
+        boost::fusion::result_of::begin<seq_type>::type i(t);
+
+        BOOST_TEST(*i == 1);
+        BOOST_TEST(*next(i) == 'x');
+        BOOST_TEST(*next(next(i)) == 3.3);
+        BOOST_TEST(*next(next(next(i))) == s);
+
+        next(next(next(next(i)))); // end
+
+#ifdef FUSION_TEST_FAIL
+        next(next(next(next(next(i))))); // past the end: must not compile
+#endif
+
+#if !defined(FUSION_NO_PRIOR)
+        BOOST_TEST(*prior(next(next(next(i)))) == 3.3);
+        BOOST_TEST(*prior(prior(next(next(next(i))))) == 'x');
+        BOOST_TEST(*prior(prior(prior(next(next(next(i)))))) == 1);
+#endif
+        BOOST_TEST(*begin(t) == 1);
+#if !defined(FUSION_NO_PRIOR)
+        BOOST_TEST(*prior(end(t)) == s);
+#endif
+
+        *i = 3;
+        BOOST_TEST(*i == 3);
+        BOOST_TEST(*i == at_c<0>(t));
+    }
+
+    { // Testing distance
+
+        typedef FUSION_SEQUENCE<int, char, double, char const*> seq_type;
+        seq_type t(1, 'x', 3.3, "Hello");
+
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::distance<
+            boost::fusion::result_of::begin<seq_type>::type
+          , boost::fusion::result_of::end<seq_type>::type >::value == 4));
+
+        BOOST_TEST(distance(begin(t), end(t)).value == 4);
+    }
+
+    { // Testing tuple iterator boost::fusion::result_of::value_of, boost::fusion::result_of::deref, boost::fusion::result_of::value_at
+
+        typedef FUSION_SEQUENCE<int, char&> seq_type;
+        typedef boost::fusion::result_of::begin<seq_type>::type i0;
+        typedef boost::fusion::result_of::next<i0>::type i1;
+        typedef boost::fusion::result_of::next<boost::fusion::result_of::begin<const seq_type>::type>::type i2;
+
+        BOOST_STATIC_ASSERT((
+            is_same<boost::fusion::result_of::value_at_c<seq_type, 0>::type, int>::value));
+
+        BOOST_STATIC_ASSERT((
+            is_same<boost::fusion::result_of::value_at_c<seq_type, 1>::type, char&>::value));
+
+        BOOST_STATIC_ASSERT((
+            is_same<traits::category_of<i0>::type, FUSION_TRAVERSAL_TAG>::value));
+
+        BOOST_STATIC_ASSERT((is_same<boost::fusion::result_of::deref<i0>::type, int&>::value));
+        BOOST_STATIC_ASSERT((is_same<boost::fusion::result_of::deref<i1>::type, char&>::value));
+        BOOST_STATIC_ASSERT((is_same<boost::fusion::result_of::deref<i2>::type, char&>::value));
+
+        BOOST_STATIC_ASSERT((is_same<boost::fusion::result_of::value_of<i0>::type, int>::value));
+        BOOST_STATIC_ASSERT((is_same<boost::fusion::result_of::value_of<i1>::type, char&>::value));
+        BOOST_STATIC_ASSERT((is_same<boost::fusion::result_of::value_of<i2>::type, char&>::value));
+    }
+
+    { // Testing advance
+
+        typedef FUSION_SEQUENCE<int, char, double, char const*> seq_type;
+        seq_type t(1, 'x', 3.3, "Hello");
+
+        BOOST_TEST(*advance_c<0>(begin(t)) == at_c<0>(t));
+        BOOST_TEST(*advance_c<1>(begin(t)) == at_c<1>(t));
+        BOOST_TEST(*advance_c<2>(begin(t)) == at_c<2>(t));
+        BOOST_TEST(*advance_c<3>(begin(t)) == at_c<3>(t));
+
+#if !defined(FUSION_NO_PRIOR)
+        BOOST_TEST(*advance_c<-1>(end(t)) == at_c<3>(t));
+        BOOST_TEST(*advance_c<-2>(end(t)) == at_c<2>(t));
+        BOOST_TEST(*advance_c<-3>(end(t)) == at_c<1>(t));
+        BOOST_TEST(*advance_c<-4>(end(t)) == at_c<0>(t));
+#endif
+
+        BOOST_TEST(&*advance_c<0>(begin(t)) == &at_c<0>(t));
+        BOOST_TEST(&*advance_c<1>(begin(t)) == &at_c<1>(t));
+        BOOST_TEST(&*advance_c<2>(begin(t)) == &at_c<2>(t));
+        BOOST_TEST(&*advance_c<3>(begin(t)) == &at_c<3>(t));
+    }
+}
+
+
+
+
diff --git a/src/boost/libs/fusion/test/sequence/iterator_range.cpp b/src/boost/libs/fusion/test/sequence/iterator_range.cpp
new file mode 100644
index 00000000..18f91af0
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/iterator_range.cpp
@@ -0,0 +1,115 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/map.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/view/iterator_range/iterator_range.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/has_key.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/key_of.hpp>
+#include <boost/fusion/iterator/value_of_data.hpp>
+#include <boost/fusion/iterator/deref_data.hpp>
+#include <boost/mpl/vector_c.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+
+int
+main()
+{
+    using namespace boost::fusion;
+    namespace fusion = boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        char const* s = "Ruby";
+        typedef vector<int, char, double, char const*> vector_type;
+        vector_type vec(1, 'x', 3.3, s);
+
+        {
+            typedef vector_iterator<vector_type, 1> i1t;
+            typedef vector_iterator<vector_type, 3> i3t;
+
+            i1t i1(vec);
+            i3t i3(vec);
+
+            typedef iterator_range<i1t, i3t> slice_t;
+            slice_t slice(i1, i3);
+            std::cout << slice << std::endl;
+            BOOST_TEST((slice == make_vector('x', 3.3)));
+            BOOST_STATIC_ASSERT(boost::fusion::result_of::size<slice_t>::value == 2);
+        }
+
+        {
+            typedef vector_iterator<vector_type, 0> i1t;
+            typedef vector_iterator<vector_type, 0> i3t;
+
+            i1t i1(vec);
+            i3t i3(vec);
+
+            typedef iterator_range<i1t, i3t> slice_t;
+            slice_t slice(i1, i3);
+            std::cout << slice << std::endl;
+            BOOST_TEST(slice == make_vector());
+            BOOST_STATIC_ASSERT(boost::fusion::result_of::size<slice_t>::value == 0);
+        }
+    }
+
+    {
+        typedef boost::mpl::vector_c<int, 2, 3, 4, 5, 6> mpl_vec;
+        typedef boost::mpl::begin<mpl_vec>::type it0;
+        typedef boost::mpl::next<it0>::type it1;
+        typedef boost::mpl::next<it1>::type it2;
+        typedef boost::mpl::next<it2>::type it3;
+
+        it1 f;
+        it3 l;
+        
+        typedef iterator_range<it1, it3> slice_t;
+        slice_t slice(f, l);
+        std::cout << slice << std::endl;
+        BOOST_TEST((slice == make_vector(3, 4)));
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<slice_t>::value == 2);
+    }
+
+    {
+        typedef map<pair<void,std::string>, pair<double,char>,pair<void*, int> > map_type;
+        map_type m(make_pair<void>("foo"), make_pair<double>('x'), make_pair<void*>(2));
+
+        typedef iterator_range<
+            boost::fusion::result_of::begin<map_type>::type
+          , boost::fusion::result_of::advance_c<boost::fusion::result_of::begin<map_type>::type,2>::type
+        > range_type;
+        range_type r(begin(m), advance_c<2>(begin(m)));
+
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<range_type, void>::type));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<range_type, double>::type));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::key_of<boost::fusion::result_of::begin<range_type>::type>::type, void>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::key_of<boost::fusion::result_of::next<boost::fusion::result_of::begin<range_type>::type>::type>::type, double>));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_of_data<boost::fusion::result_of::begin<range_type>::type>::type, std::string>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_of_data<boost::fusion::result_of::next<boost::fusion::result_of::begin<range_type>::type>::type>::type, char>));
+
+        std::cout << deref_data(begin(r)) << std::endl;
+        std::cout << deref_data(fusion::next(begin(r))) << std::endl;
+        BOOST_TEST((deref_data(begin(r)) == "foo"));
+        BOOST_TEST((deref_data(fusion::next(begin(r))) == 'x'));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/joint_view.cpp b/src/boost/libs/fusion/test/sequence/joint_view.cpp
new file mode 100644
index 00000000..ba5659b7
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/joint_view.cpp
@@ -0,0 +1,188 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/map.hpp>
+#include <boost/fusion/container/set.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/view/joint_view/joint_view.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/has_key.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/key_of.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/iterator/deref_data.hpp>
+#include <boost/mpl/assert.hpp>
+#include <string>
+
+struct X
+{
+    operator char const*() const
+    {
+        return "<X-object>";
+    }
+};
+
+int
+main()
+{
+    using namespace boost::fusion;
+    namespace fusion = boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+/// Testing joint_view
+
+    {
+        vector<int> t1(3);
+        vector<X> t2;
+        typedef joint_view<vector<int>, vector<X> > view_type;
+        view_type view(t1, t2);
+
+        std::cout << view << std::endl;
+        BOOST_TEST((view == make_vector(3, X())));
+    }
+
+    {
+        vector<int, char> t1(3, 'x');
+        vector<X> t2;
+        typedef joint_view<vector<int, char>, vector<X> > view_type;
+        view_type view(t1, t2);
+        std::cout << view << std::endl;
+        BOOST_TEST((view == make_vector(3, 'x', X())));
+
+        *begin(view) = 4;
+        BOOST_TEST(at_c<0>(t1) == 4);
+    }
+
+    {
+        vector<int, char> t1(3, 'x');
+        vector<X, int> t2;
+        typedef joint_view<vector<int, char>, vector<X, int> > view_type;
+        view_type view(t1, t2);
+        std::cout << view << std::endl;
+        BOOST_TEST((view == make_vector(3, 'x', X(), 0)));
+    }
+
+    {
+        typedef vector<int> t1_type;
+        t1_type t1(777);
+        typedef vector<int, char, double> t2_type;
+        t2_type t2(1, 'x', 3.3);
+
+        {
+            typedef joint_view<t1_type, t2_type> view_type;
+            view_type view(t1, t2);
+            std::cout << view << std::endl;
+            BOOST_TEST((view == make_vector(777, 1, 'x', 3.3)));
+        }
+
+        {
+            typedef joint_view<t2_type, t1_type> view_type;
+            view_type view(t2, t1);
+            std::cout << view << std::endl;
+            BOOST_TEST((view == make_vector(1, 'x', 3.3, 777)));
+        }
+
+        {
+            typedef joint_view<t2_type, t1_type> jv_type;
+            typedef joint_view<jv_type, jv_type> jv2_type;
+
+            jv_type jv(t2, t1);
+            jv2_type jv2(jv, jv);
+
+            std::cout << jv << std::endl;
+            std::cout << jv2 << std::endl;
+
+            BOOST_TEST(jv2
+                == make_vector(1, 'x', 3.3, 777, 1, 'x', 3.3, 777));
+        }
+
+        {
+            typedef joint_view<t2_type, t1_type> jt_type;
+            typedef joint_view<t1_type, t2_type> jv2_type;
+            typedef joint_view<jt_type, jv2_type> jv3_type;
+
+            jt_type jt(t2, t1);
+            jv2_type jv2(t1, t2);
+            jv3_type jv3(jt, jv2);
+
+            std::cout << jt << std::endl;
+            std::cout << jv2 << std::endl;
+            std::cout << jv3 << std::endl;
+
+            BOOST_TEST(jv3
+                == make_vector(1, 'x', 3.3, 777, 777, 1, 'x', 3.3));
+        }
+
+        {
+            typedef joint_view<vector<>, t1_type> jt_type;
+            vector<> empty;
+            jt_type jt(empty, t1);
+            std::cout << jt << std::endl;
+            BOOST_TEST(jt == make_vector(777));
+        }
+
+        {
+            typedef joint_view<t1_type, vector<> > jt_type;
+            vector<> empty;
+            jt_type jt(t1, empty);
+            std::cout << jt << std::endl;
+            BOOST_TEST(jt == make_vector(777));
+        }
+
+        {
+            typedef joint_view<vector<>, vector<> > jt_type;
+            vector<> empty;
+            jt_type jt(empty, empty);
+            std::cout << jt << std::endl;
+            BOOST_TEST(jt == make_vector());
+        }
+    }
+
+    {
+        typedef map<pair<void,int> > map_type;
+        map_type m(make_pair<void>(0));
+
+        typedef set<std::string, float> set_type;
+        set_type s("foo", 1.3f);
+
+        typedef joint_view<map_type, set_type> joint_view_type;
+        joint_view_type j(m,s);
+
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<joint_view_type, void>::type));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<joint_view_type, std::string>::type));
+        BOOST_MPL_ASSERT((boost::fusion::result_of::has_key<joint_view_type, float>::type));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::key_of<boost::fusion::result_of::begin<joint_view_type>::type>::type, void>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::key_of<boost::fusion::result_of::next<boost::fusion::result_of::begin<joint_view_type>::type>::type>::type, std::string>));
+        BOOST_MPL_ASSERT((boost::is_same<
+                boost::fusion::result_of::key_of<boost::fusion::result_of::next<boost::fusion::result_of::next<boost::fusion::result_of::begin<joint_view_type>::type>::type>::type>::type
+              , float>));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_of_data<boost::fusion::result_of::begin<joint_view_type>::type>::type, int>));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_of_data<boost::fusion::result_of::next<boost::fusion::result_of::begin<joint_view_type>::type>::type>::type, std::string>));
+        BOOST_MPL_ASSERT((boost::is_same<
+                boost::fusion::result_of::value_of_data<boost::fusion::result_of::next<boost::fusion::result_of::next<boost::fusion::result_of::begin<joint_view_type>::type>::type>::type>::type
+              , float>));
+
+        std::cout << deref_data(begin(j)) << std::endl;
+        std::cout << deref_data(fusion::next(begin(j))) << std::endl;
+        std::cout << deref_data(fusion::next(fusion::next(begin(j)))) << std::endl;
+        BOOST_TEST((deref_data(begin(j)) == 0));
+        BOOST_TEST((deref_data(fusion::next(begin(j))) == "foo"));
+        BOOST_TEST((deref_data(fusion::next(fusion::next(begin(j)))) == 1.3f));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/list_comparison.cpp b/src/boost/libs/fusion/test/sequence/list_comparison.cpp
new file mode 100644
index 00000000..2a02eba0
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_comparison.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/list/list.hpp>
+
+#define FUSION_SEQUENCE list
+#include "comparison.hpp"
+
+int
+main()
+{
+    equality_test();
+    ordering_test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/list_construction.cpp b/src/boost/libs/fusion/test/sequence/list_construction.cpp
new file mode 100644
index 00000000..a10b1e1a
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_construction.cpp
@@ -0,0 +1,18 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/list/list.hpp>
+
+#define FUSION_SEQUENCE list
+#include "construction.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/list_copy.cpp b/src/boost/libs/fusion/test/sequence/list_copy.cpp
new file mode 100644
index 00000000..797089e9
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_copy.cpp
@@ -0,0 +1,21 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/list/list.hpp>
+#include <boost/fusion/container/generation/make_list.hpp>
+#include <boost/fusion/container/generation/list_tie.hpp>
+
+#define FUSION_SEQUENCE list
+#include "copy.hpp"
+
+int
+main()
+{
+    test<test_detail::can_copy>();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/list_hash.cpp b/src/boost/libs/fusion/test/sequence/list_hash.cpp
new file mode 100644
index 00000000..51203b27
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_hash.cpp
@@ -0,0 +1,16 @@
+/*=============================================================================
+    Copyright (c) 2014 Christoph Weiss
+
+    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/list/list.hpp>
+
+#define FUSION_SEQUENCE list
+#include "hash.hpp"
+
+int main()
+{
+    hash_test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/list_iterator.cpp b/src/boost/libs/fusion/test/sequence/list_iterator.cpp
new file mode 100644
index 00000000..62d67087
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_iterator.cpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/list/list.hpp>
+
+#define FUSION_SEQUENCE list
+#define FUSION_NO_PRIOR
+#define FUSION_TRAVERSAL_TAG forward_traversal_tag
+#include "./iterator.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
+
+
diff --git a/src/boost/libs/fusion/test/sequence/list_make.cpp b/src/boost/libs/fusion/test/sequence/list_make.cpp
new file mode 100644
index 00000000..296b6063
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_make.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/list/list.hpp>
+#include <boost/fusion/container/generation/make_list.hpp>
+
+#define FUSION_SEQUENCE list
+#include "make.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/list_misc.cpp b/src/boost/libs/fusion/test/sequence/list_misc.cpp
new file mode 100644
index 00000000..28d84854
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_misc.cpp
@@ -0,0 +1,21 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/list/list.hpp>
+#include <boost/fusion/container/list/convert.hpp>
+
+#define FUSION_SEQUENCE list
+#define FUSION_FORWARD_ONLY
+#include "misc.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/list_mutate.cpp b/src/boost/libs/fusion/test/sequence/list_mutate.cpp
new file mode 100644
index 00000000..b2736679
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_mutate.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/list/list.hpp>
+
+#define FUSION_SEQUENCE list
+#include "mutate.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/list_nest.cpp b/src/boost/libs/fusion/test/sequence/list_nest.cpp
new file mode 100644
index 00000000..82df4864
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_nest.cpp
@@ -0,0 +1,36 @@
+/*=============================================================================
+    Copyright (C) 2015 Kohei Takahshi
+
+    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/list/list.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::list
+#include "nest.hpp"
+
+/* list has a few issues:
+    - sequence conversion constructor has bug when first element is a sequence
+    - assignment sequence conversion has bug in base class */
+template <typename T>
+struct skip_issues
+{
+    template <typename Source, typename Expected>
+    bool operator()(Source const& source, Expected const& expected) const
+    {
+        using namespace test_detail;
+        return
+            run< can_copy<T> >(source, expected) &&
+            run< can_construct_from_elements<T> >(source, expected);
+    }
+};
+
+
+int
+main()
+{
+    test<skip_issues>();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/list_tie.cpp b/src/boost/libs/fusion/test/sequence/list_tie.cpp
new file mode 100644
index 00000000..30c8ed83
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_tie.cpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/list/list.hpp>
+#include <boost/fusion/container/generation/list_tie.hpp>
+#include <boost/fusion/container/generation/ignore.hpp>
+#include <boost/fusion/container/generation/make_list.hpp>
+
+#define FUSION_SEQUENCE list
+#include "tie.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/list_value_at.cpp b/src/boost/libs/fusion/test/sequence/list_value_at.cpp
new file mode 100644
index 00000000..487968da
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/list_value_at.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/list/list.hpp>
+
+#define FUSION_SEQUENCE list
+#include "value_at.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/make.hpp b/src/boost/libs/fusion/test/sequence/make.hpp
new file mode 100644
index 00000000..00eaed2c
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/make.hpp
@@ -0,0 +1,88 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <string>
+
+#if !defined(FUSION_AT)
+#define FUSION_AT at_c
+#endif
+
+#if !defined(FUSION_MAKE)
+#define FUSION_MAKE BOOST_PP_CAT(make_, FUSION_SEQUENCE)
+#endif
+
+namespace test_detail
+{
+    // something to prevent warnings for unused variables
+    template<class T> void dummy(const T&) {}
+
+    class A {};
+    class B {};
+}
+
+void make_tuple_test() {}
+
+void
+test()
+{
+    using namespace boost::fusion;
+    using namespace test_detail;
+
+    {
+        FUSION_SEQUENCE<int, char> t1 = FUSION_MAKE(5, 'a');
+        BOOST_TEST(FUSION_AT<0>(t1) == 5);
+        BOOST_TEST(FUSION_AT<1>(t1) == 'a');
+
+        FUSION_SEQUENCE<int, std::string> t2;
+        t2 = FUSION_MAKE((short int)2, std::string("Hi"));
+        BOOST_TEST(FUSION_AT<0>(t2) == 2);
+        BOOST_TEST(FUSION_AT<1>(t2) == "Hi");
+    }
+
+    {   // This test was previously disallowed for non-PTS compilers.
+        A a = A(); B b;
+        const A ca = a;
+        FUSION_MAKE(boost::cref(a), b);
+        FUSION_MAKE(boost::ref(a), b);
+        FUSION_MAKE(boost::ref(a), boost::cref(b));
+        FUSION_MAKE(boost::ref(ca));
+    }
+
+    {   //  the result of make_xxx is assignable: 
+        BOOST_TEST(FUSION_MAKE(2, 4, 6) ==
+            (FUSION_MAKE(1, 2, 3) = FUSION_MAKE(2, 4, 6)));
+    }
+
+    {   // This test was previously disallowed for non-PTS compilers.
+        FUSION_MAKE("Donald", "Daisy"); // should work;
+    //  std::make_pair("Doesn't","Work"); // fails
+    }
+
+    {
+        // You can store a reference to a function in a sequence
+        FUSION_SEQUENCE<void(&)()> adf(make_tuple_test);
+        dummy(adf); // avoid warning for unused variable
+    }
+
+#if defined(FUSION_TEST_FAIL)
+    {
+        //  But make_xxx doesn't work
+        //  with function references, since it creates a const
+        //  qualified function type
+
+        FUSION_MAKE(make_tuple_test);
+    }
+#endif
+    
+    {
+        // With function pointers, make_xxx works just fine
+        FUSION_MAKE(&make_tuple_test);
+    }
+}
diff --git a/src/boost/libs/fusion/test/sequence/make_list.cpp b/src/boost/libs/fusion/test/sequence/make_list.cpp
new file mode 100644
index 00000000..296b6063
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/make_list.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/list/list.hpp>
+#include <boost/fusion/container/generation/make_list.hpp>
+
+#define FUSION_SEQUENCE list
+#include "make.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/make_vector.cpp b/src/boost/libs/fusion/test/sequence/make_vector.cpp
new file mode 100644
index 00000000..8a687354
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/make_vector.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+
+#define FUSION_SEQUENCE vector
+#include "make.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/map.cpp b/src/boost/libs/fusion/test/sequence/map.cpp
new file mode 100644
index 00000000..5a130f8b
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/map.cpp
@@ -0,0 +1,181 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/map/map.hpp>
+#include <boost/fusion/container/generation/make_map.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at_key.hpp>
+#include <boost/fusion/sequence/intrinsic/has_key.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/key_of.hpp>
+#include <boost/fusion/iterator/deref_data.hpp>
+#include <boost/fusion/iterator/value_of_data.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/support/pair.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <iostream>
+#include <string>
+
+
+struct copy_all
+{
+    copy_all() {}
+    copy_all(copy_all const&) {}
+
+    template <typename T>
+    copy_all(T const& x)
+    {
+        foo(x); // should fail!
+    }
+};
+
+struct abstract
+{
+    virtual void foo() = 0;
+};
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+    namespace fusion = boost::fusion;
+    using boost::fusion::pair;
+    using boost::fusion::make_pair;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        typedef map<
+            pair<int, char>
+          , pair<double, std::string>
+          , pair<abstract, int> >
+        map_type;
+
+        BOOST_MPL_ASSERT((traits::is_associative<map_type>));
+        BOOST_MPL_ASSERT((traits::is_random_access<map_type>));
+
+        map_type m(
+            make_pair<int>('X')
+          , make_pair<double>("Men")
+          , make_pair<abstract>(2));
+
+        std::cout << at_key<int>(m) << std::endl;
+        std::cout << at_key<double>(m) << std::endl;
+        std::cout << at_key<abstract>(m) << std::endl;
+
+        BOOST_TEST(at_key<int>(m) == 'X');
+        BOOST_TEST(at_key<double>(m) == "Men");
+        BOOST_TEST(at_key<abstract>(m) == 2);
+
+        BOOST_STATIC_ASSERT((
+            boost::is_same<boost::fusion::result_of::value_at_key<map_type, int>::type, char>::value));
+        BOOST_STATIC_ASSERT((
+            boost::is_same<boost::fusion::result_of::value_at_key<map_type, double>::type, std::string>::value));
+        BOOST_STATIC_ASSERT((
+            boost::is_same<boost::fusion::result_of::value_at_key<map_type, abstract>::type, int>::value));
+
+        std::cout << m << std::endl;
+
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::has_key<map_type, int>::value));
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::has_key<map_type, double>::value));
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::has_key<map_type, abstract>::value));
+        BOOST_STATIC_ASSERT((!boost::fusion::result_of::has_key<map_type, std::string>::value));
+
+        std::cout << deref_data(begin(m)) << std::endl;
+        std::cout << deref_data(fusion::next(begin(m))) << std::endl;
+
+        BOOST_TEST(deref_data(begin(m)) == 'X');
+        BOOST_TEST(deref_data(fusion::next(begin(m))) == "Men");
+        BOOST_TEST(deref_data(fusion::next(next(begin(m)))) == 2);
+
+        BOOST_STATIC_ASSERT((boost::is_same<boost::fusion::result_of::key_of<boost::fusion::result_of::begin<map_type>::type>::type, int>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<boost::fusion::result_of::key_of<boost::fusion::result_of::next<boost::fusion::result_of::begin<map_type>::type>::type>::type, double>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<boost::fusion::result_of::key_of<boost::fusion::result_of::next<boost::fusion::result_of::next<boost::fusion::result_of::begin<map_type>::type>::type>::type>::type, abstract>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<boost::fusion::result_of::value_of_data<boost::fusion::result_of::begin<map_type>::type>::type, char>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<boost::fusion::result_of::value_of_data<boost::fusion::result_of::next<boost::fusion::result_of::begin<map_type>::type>::type>::type, std::string>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<boost::fusion::result_of::value_of_data<boost::fusion::result_of::next<boost::fusion::result_of::next<boost::fusion::result_of::begin<map_type>::type>::type>::type>::type, int>::value));
+
+        // Test random access interface.
+        pair<int, char> a = at_c<0>(m); (void) a;
+        pair<double, std::string> b = at_c<1>(m);
+        pair<abstract, int> c = at_c<2>(m);
+        (void)c;
+    }
+
+    // iterators & random access interface.
+    {
+        typedef pair<boost::mpl::int_<0>, std::string> pair0;
+        typedef pair<boost::mpl::int_<1>, std::string> pair1;
+        typedef pair<boost::mpl::int_<2>, std::string> pair2;
+        typedef pair<boost::mpl::int_<3>, std::string> pair3;
+        typedef pair<boost::mpl::int_<4>, std::string> pair4;
+
+        typedef map< pair0, pair1, pair2, pair3, pair4 > map_type;
+        map_type m( pair0("zero"), pair1("one"), pair2("two"), pair3("three"), pair4("four") );
+        BOOST_AUTO( it0, begin(m) );
+        BOOST_TEST((deref(it0) == pair0("zero")));
+        BOOST_AUTO( it1, fusion::next(it0) );
+        BOOST_TEST((deref(it1) == pair1("one")));
+        BOOST_AUTO( it2, fusion::next(it1) );
+        BOOST_TEST((deref(it2) == pair2("two")));
+        BOOST_AUTO( it3, fusion::next(it2) );
+        BOOST_TEST((deref(it3) == pair3("three")));
+        BOOST_AUTO( it4, fusion::next(it3) );
+        BOOST_TEST((deref(it4) == pair4("four")));
+
+        BOOST_TEST((deref(fusion::advance_c<4>(it0)) == deref(it4)));
+
+        // Bi-directional
+        BOOST_TEST((deref(fusion::prior(it4)) == deref(it3) ));
+        BOOST_TEST((deref(fusion::prior(it3)) == deref(it2) ));
+        BOOST_TEST((deref(fusion::prior(it2)) == deref(it1) ));
+        BOOST_TEST((deref(fusion::prior(it1)) == deref(it0) ));
+    }
+
+    {
+        std::cout << make_map<char, int>('X', 123) << std::endl;
+        BOOST_TEST(at_key<char>(make_map<char, int>('X', 123)) == 'X');
+        BOOST_TEST(at_key<int>(make_map<char, int>('X', 123)) == 123);
+    }
+    
+    {
+        // test for copy construction of fusion pairs
+        // make sure that the correct constructor is called
+        pair<int, copy_all> p1;
+        pair<int, copy_all> p2 = p1;
+        (void)p2;
+    }
+    
+    {
+        // compile test only
+        // make sure result_of::deref_data returns a reference
+        typedef map<pair<float, int> > map_type;
+        typedef boost::fusion::result_of::begin<map_type>::type i_type;
+        typedef boost::fusion::result_of::deref_data<i_type>::type r_type;
+        BOOST_STATIC_ASSERT((boost::is_same<r_type, int&>::value));
+    }
+    
+    {
+        // compile test only
+        // make sure result_of::deref_data is const correct
+        typedef map<pair<float, int> > const map_type;
+        typedef boost::fusion::result_of::begin<map_type>::type i_type;
+        typedef boost::fusion::result_of::deref_data<i_type>::type r_type;
+        BOOST_STATIC_ASSERT((boost::is_same<r_type, int const&>::value));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/map_comparison.cpp b/src/boost/libs/fusion/test/sequence/map_comparison.cpp
new file mode 100644
index 00000000..63f39515
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/map_comparison.cpp
@@ -0,0 +1,68 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/map/map.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/comparison.hpp>
+
+struct key1 {};
+struct key2 {};
+struct key3 {};
+
+void
+equality_test()
+{
+    using namespace boost::fusion;
+
+    map<pair<key1, int>, pair<key2, char> > v1(5, 'a');
+    map<pair<key1, int>, pair<key2, char> > v2(5, 'a');
+    BOOST_TEST(v1 == v2);
+
+    map<pair<key1, int>, pair<key2, char> > v3(5, 'b');
+    map<pair<key1, int>, pair<key2, char> > t4(2, 'a');
+    BOOST_TEST(v1 != v3);
+    BOOST_TEST(v1 != t4);
+    BOOST_TEST(!(v1 != v2));
+
+    map<pair<key1, int>, pair<key2, char>, pair<key2, bool> > v5(5, 'a', true);
+    BOOST_TEST(v1 != v5);
+    BOOST_TEST(!(v1 == v5));
+    BOOST_TEST(v5 != v1);
+    BOOST_TEST(!(v5 == v1));
+}
+
+void
+ordering_test()
+{
+    using namespace boost::fusion;
+
+    map<pair<key1, int>, pair<key2, float> > v1(4, 3.3f);
+    map<pair<key1, short>, pair<key2, float> > v2(5, 3.3f);
+    map<pair<key1, long>, pair<key2, double> > v3(5, 4.4);
+    BOOST_TEST(v1 < v2);
+    BOOST_TEST(v1 <= v2);
+    BOOST_TEST(v2 > v1);
+    BOOST_TEST(v2 >= v1);
+    BOOST_TEST(v2 < v3);
+    BOOST_TEST(v2 <= v3);
+    BOOST_TEST(v3 > v2);
+    BOOST_TEST(v3 >= v2);
+
+#if defined(FUSION_TEST_FAIL)
+    map<int, char, bool> v5(5, 'a', true);
+    v1 >= v5;
+#endif
+}
+
+int
+main()
+{
+    equality_test();
+    ordering_test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/map_construction.cpp b/src/boost/libs/fusion/test/sequence/map_construction.cpp
new file mode 100644
index 00000000..9c03b426
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/map_construction.cpp
@@ -0,0 +1,134 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/map/map.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+
+struct key1 {};
+struct key2 {};
+struct key3 {};
+
+namespace test_detail
+{
+    // something to prevent warnings for unused variables
+    template<class T> void dummy(const T&) {}
+
+    // no public default constructor
+    class foo
+    {
+    public:
+
+        explicit foo(int v) : val(v) {}
+
+        bool operator==(const foo& other) const
+        {
+            return val == other.val;
+        }
+
+    private:
+
+        foo() {}
+        int val;
+    };
+
+    // another class without a public default constructor
+    class no_def_constructor
+    {
+        no_def_constructor() {}
+
+    public:
+
+        no_def_constructor(std::string) {}
+    };
+}
+
+inline void
+test()
+{
+    using namespace boost::fusion;
+    using namespace test_detail;
+
+    nil empty;
+    (void)empty;
+
+    map<> empty0;
+    (void)empty0;
+
+#ifndef NO_CONSTRUCT_FROM_NIL
+    map<> empty1(empty);
+    (void)empty1;
+#endif
+
+    map<pair<key1, int> > t1;
+    BOOST_TEST(at_c<0>(t1).second == int());
+
+    map<pair<key1, float> > t2(5.5f);
+    BOOST_TEST(at_c<0>(t2).second > 5.4f && at_c<0>(t2).second < 5.6f);
+
+    map<pair<key1, foo> > t3(foo(12));
+    BOOST_TEST(at_c<0>(t3).second == foo(12));
+
+    map<pair<key1, double> > t4(t2);
+    BOOST_TEST(at_c<0>(t4).second > 5.4 && at_c<0>(t4).second < 5.6);
+
+    map<pair<key1, int>, pair<key2, float> > t5;
+    BOOST_TEST(at_c<0>(t5).second == int());
+    BOOST_TEST(at_c<1>(t5).second == float());
+
+    map<pair<key1, int>, pair<key2, float> > t6(12, 5.5f);
+    BOOST_TEST(at_c<0>(t6).second == 12);
+    BOOST_TEST(at_c<1>(t6).second > 5.4f && at_c<1>(t6).second < 5.6f);
+
+    map<pair<key1, int>, pair<key2, float> > t7(t6);
+    BOOST_TEST(at_c<0>(t7).second == 12);
+    BOOST_TEST(at_c<1>(t7).second > 5.4f && at_c<1>(t7).second < 5.6f);
+
+    map<pair<key1, long>, pair<key2, double> > t8(t6);
+    BOOST_TEST(at_c<0>(t8).second == 12);
+    BOOST_TEST(at_c<1>(t8).second > 5.4f && at_c<1>(t8).second < 5.6f);
+
+    dummy
+    (
+        map<
+            pair<key1, no_def_constructor>,
+            pair<key2, no_def_constructor>,
+            pair<key3, no_def_constructor> >
+        (
+            pair<key1, no_def_constructor>(std::string("Jaba")), // ok, since the default
+            pair<key2, no_def_constructor>(std::string("Daba")), // constructor is not used
+            pair<key3, no_def_constructor>(std::string("Doo"))
+        )
+    );
+
+    dummy(map<pair<key1, int>, pair<key2, double> >());
+    dummy(map<pair<key1, int>, pair<key2, double> >(1,3.14));
+
+#if defined(FUSION_TEST_FAIL)
+    dummy(map<pair<key1, double&> >());         // should fail, no defaults for references
+    dummy(map<pair<key1, const double&> >());   // likewise
+#endif
+
+    {
+        double dd = 5;
+        dummy(map<pair<key1, double&> >(pair<key1, double&>(dd)));   // ok
+        dummy(map<pair<key1, const double&> >(pair<key1, const double&>(dd+3.14))); // ok, but dangerous
+    }
+
+#if defined(FUSION_TEST_FAIL)
+    dummy(map<pair<key1, double&> >(dd+3.14));  // should fail,
+                                                // temporary to non-const reference
+#endif
+}
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/map_copy.cpp b/src/boost/libs/fusion/test/sequence/map_copy.cpp
new file mode 100644
index 00000000..b8218bdf
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/map_copy.cpp
@@ -0,0 +1,90 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/map/map.hpp>
+#include <boost/fusion/container/generation/make_map.hpp>
+#include <boost/fusion/container/generation/map_tie.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/mpl/insert_range.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/equal.hpp>
+#include <boost/static_assert.hpp>
+#include <string>
+
+struct k1 {};
+struct k2 {};
+struct k3 {};
+struct k4 {};
+
+namespace test_detail
+{
+    // classes with different kinds of conversions
+    class AA {};
+    class BB : public AA {};
+    struct CC { CC() {} CC(const BB&) {} };
+    struct DD { operator CC() const { return CC(); }; };
+}
+
+boost::fusion::map<
+    boost::fusion::pair<k1, double>,
+    boost::fusion::pair<k2, double>,
+    boost::fusion::pair<k3, double>,
+    boost::fusion::pair<k4, double>
+>
+foo(int i)
+{
+   return boost::fusion::make_map<k1, k2, k3, k4>(i, i+1, i+2, i+3);
+}
+
+void
+test()
+{
+    using namespace boost::fusion;
+    using namespace test_detail;
+
+    map<pair<k1, int>, pair<k2, char> > t1(4, 'a');
+    map<pair<k1, int>, pair<k2, char> > t2(5, 'b');
+    t2 = t1;
+    BOOST_TEST(at_c<0>(t1).second == at_c<0>(t2).second);
+    BOOST_TEST(at_c<1>(t1).second == at_c<1>(t2).second);
+
+    map<pair<k1, int>, pair<k2, char const*> > t4(4, "a");
+    map<pair<k1, long>, pair<k2, std::string> > t3(2, std::string("a"));
+    t3 = t4;
+    BOOST_TEST((double)at_c<0>(t4).second == at_c<0>(t3).second);
+    BOOST_TEST(at_c<1>(t4).second == at_c<1>(t3).second);
+
+    // testing copy and assignment with implicit conversions
+    // between elements testing tie
+
+    map<pair<k1, char>, pair<k2, BB*>, pair<k3, BB>, pair<k4, DD> > t;
+    map<pair<k1, int>, pair<k2, AA*>, pair<k3, CC>, pair<k4, CC> > a(t);
+    a = t;
+
+    int i; char c; double d;
+    map_tie<k1, k2, k3>(i, c, d) = make_map<k1, k2, k3>(1, 'a', 5.5);
+
+    BOOST_TEST(i==1);
+    BOOST_TEST(c=='a');
+    BOOST_TEST(d>5.4 && d<5.6);
+
+    // returning a map with conversion
+    foo(2);
+}
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/map_misc.cpp b/src/boost/libs/fusion/test/sequence/map_misc.cpp
new file mode 100644
index 00000000..81da9753
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/map_misc.cpp
@@ -0,0 +1,179 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2013 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/map/map.hpp>
+#include <boost/fusion/container/map/convert.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/mpl/find.hpp>
+#include <boost/mpl/equal.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <string>
+
+struct k1 {};
+struct k2 {};
+struct k3 {};
+struct k4 {};
+
+template <typename S1, typename S2>
+struct is_same
+{
+};
+
+namespace fn = boost::fusion;
+
+struct test_intrinsics1
+{
+    // test at, begin, end, next, prior, advance, size, deref, etc.
+
+    typedef fn::map<
+        fn::pair<k1, int>, fn::pair<k2, float>,
+        fn::pair<k3, bool>, fn::pair<k3, char> >
+    sequence;
+
+    typedef boost::mpl::begin<sequence>::type first;
+    typedef boost::mpl::next<first>::type second;
+    typedef boost::mpl::next<second>::type third;
+    typedef boost::mpl::next<third>::type fourth;
+    typedef boost::mpl::end<sequence>::type last;
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<first>::type, fn::pair<k1, int> >::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<second>::type, fn::pair<k2, float> >::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<third>::type, fn::pair<k3, bool> >::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<fourth>::type, fn::pair<k3, char> >::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::at_c<sequence, 2>::type, fn::pair<k3, bool> >::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::front<sequence>::type, fn::pair<k1, int> >::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<
+            boost::mpl::advance_c<second, 2>::type>::type, fn::pair<k3, char> >::value));
+
+    BOOST_STATIC_ASSERT((boost::mpl::size<sequence>::value == 4));
+    BOOST_STATIC_ASSERT(!(boost::mpl::empty<sequence>::value));
+    BOOST_STATIC_ASSERT((boost::mpl::distance<second, fourth>::value == 2));
+
+    typedef boost::mpl::prior<last>::type fourth_;
+    typedef boost::mpl::prior<fourth_>::type third_;
+    typedef boost::mpl::prior<third_>::type second_;
+    typedef boost::mpl::prior<second_>::type first_;
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<first_>::type, fn::pair<k1, int> >::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<second_>::type, fn::pair<k2, float> >::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<third_>::type, fn::pair<k3, bool> >::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<fourth_>::type, fn::pair<k3, char> >::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::back<sequence>::type, fn::pair<k3, char> >::value));
+
+};
+
+void
+test()
+{
+    using namespace boost::fusion;
+
+    {   // testing const sequences
+
+        const map<pair<k1, int>, pair<k2, float> > t1(5, 3.3f);
+        BOOST_TEST(at_c<0>(t1).second == 5);
+        BOOST_TEST(at_c<1>(t1).second == 3.3f);
+    }
+
+    {   // testing at<N> works with MPL integral constants
+        const map<pair<k1, int>, pair<k2, char> > t1(101, 'z');
+        BOOST_TEST(boost::fusion::at<boost::mpl::int_<0> >(t1).second == 101);
+        BOOST_TEST(boost::fusion::at<boost::mpl::int_<1> >(t1).second == 'z');
+        // explicitly try something other than mpl::int_
+        BOOST_TEST((boost::fusion::at<boost::mpl::integral_c<long, 0> >(t1).second == 101));
+        BOOST_TEST((boost::fusion::at<boost::mpl::integral_c<long, 1> >(t1).second == 'z'));
+    }
+
+    {   // testing size & empty
+
+        typedef map<pair<k1, int>, pair<k2, float>, pair<k3, double> > t1;
+        typedef map<> t2;
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<t1>::value == 3);
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<t2>::value == 0);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<t1>::value);
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::empty<t2>::value);
+    }
+
+    {   // testing front & back
+
+        typedef map<pair<k1, int>, pair<k2, float>, pair<k3, std::string> > tup;
+        tup t(1, 2.2f, std::string("Kimpo"));
+
+        BOOST_TEST(front(t).second == 1);
+        BOOST_TEST(back(t).second == "Kimpo");
+    }
+
+    {   // testing is_sequence
+
+        typedef map<pair<k1, int>, pair<k2, float>, pair<k3, double> > t1;
+        typedef map<> t2;
+        typedef map<pair<k1, char> > t3;
+
+        BOOST_STATIC_ASSERT(traits::is_sequence<t1>::value);
+        BOOST_STATIC_ASSERT(traits::is_sequence<t2>::value);
+        BOOST_STATIC_ASSERT(traits::is_sequence<t3>::value);
+        BOOST_STATIC_ASSERT(!traits::is_sequence<int>::value);
+        BOOST_STATIC_ASSERT(!traits::is_sequence<char>::value);
+    }
+
+    {   // testing mpl::is_sequence
+
+        typedef map<pair<k1, int>, pair<k2, float>, pair<k3, double> > t1;
+        typedef map<> t2;
+        typedef map<pair<k1, char> > t3;
+
+        BOOST_STATIC_ASSERT(boost::mpl::is_sequence<t1>::value);
+        BOOST_STATIC_ASSERT(boost::mpl::is_sequence<t2>::value);
+        BOOST_STATIC_ASSERT(boost::mpl::is_sequence<t3>::value);
+    }
+
+    {   // testing mpl compatibility
+
+        // test an algorithm
+        typedef map<pair<k1, int>, pair<k2, float>, pair<k3, double> > t1;
+        typedef boost::mpl::find<t1, pair<k2, float> >::type iter;
+        typedef boost::mpl::deref<iter>::type type;
+        BOOST_STATIC_ASSERT((boost::is_same<type, pair<k2, float> >::value));
+    }
+}
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/map_move.cpp b/src/boost/libs/fusion/test/sequence/map_move.cpp
new file mode 100644
index 00000000..9f9dd004
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/map_move.cpp
@@ -0,0 +1,28 @@
+/*=============================================================================
+    Copyright (c) 2012 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)
+==============================================================================*/
+#define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+#include <boost/fusion/container/map/map.hpp>
+
+struct k1 {};
+struct k2 {};
+
+#define FUSION_SEQUENCE boost::fusion::map<boost::fusion::pair<k1, std::vector<x>>>
+
+#define FUSION_SEQUENCE2 boost::fusion::map<        \
+    boost::fusion::pair<k1, std::vector<x>>,        \
+    boost::fusion::pair<k2, x>>
+
+#include "move.hpp"
+
+int main()
+{
+    test();
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/map_mutate.cpp b/src/boost/libs/fusion/test/sequence/map_mutate.cpp
new file mode 100644
index 00000000..afe78ad6
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/map_mutate.cpp
@@ -0,0 +1,69 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006
+
+    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/map/map.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+
+struct k1 {};
+struct k2 {};
+struct k3 {};
+struct k4 {};
+
+namespace test_detail
+{
+    // no public default constructor
+    class foo
+    {
+    public:
+
+        explicit foo(int v) : val(v) {}
+
+        bool operator==(const foo& other) const
+        {
+            return val == other.val;
+        }
+
+    private:
+
+        foo() {}
+        int val;
+    };
+}
+
+void
+test()
+{
+    using namespace boost::fusion;
+    using namespace test_detail;
+
+    map<
+        pair<k1, int>,
+        pair<k1, float>,
+        pair<k1, bool>,
+        pair<k1, foo>
+    > t1(5, 12.2f, true, foo(4));
+
+    at_c<0>(t1).second = 6;
+    at_c<1>(t1).second = 2.2f;
+    at_c<2>(t1).second = false;
+    at_c<3>(t1).second = foo(5);
+
+    BOOST_TEST(at_c<0>(t1).second == 6);
+    BOOST_TEST(at_c<1>(t1).second > 2.1f && at_c<1>(t1).second < 2.3f);
+    BOOST_TEST(at_c<2>(t1).second == false);
+    BOOST_TEST(at_c<3>(t1).second == foo(5));
+}
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/map_tie.cpp b/src/boost/libs/fusion/test/sequence/map_tie.cpp
new file mode 100644
index 00000000..a3547375
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/map_tie.cpp
@@ -0,0 +1,35 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/fusion/container/generation/map_tie.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+
+struct key_zero;
+struct key_one;
+
+int main()
+{
+    using namespace boost::fusion;
+    {
+        int number = 101;
+        char letter = 'a';
+        BOOST_TEST(at_key<key_zero>(map_tie<key_zero, key_one>(number, letter)) == 101);
+        BOOST_TEST(at_key<key_one>(map_tie<key_zero, key_one>(number, letter)) == 'a');
+
+        BOOST_TEST(&at_key<key_zero>(map_tie<key_zero, key_one>(number, letter)) == &number);
+        BOOST_TEST(&at_key<key_one>(map_tie<key_zero, key_one>(number, letter)) == &letter);
+
+        at_key<key_zero>(map_tie<key_zero, key_one>(number, letter)) = 202;
+        at_key<key_one>(map_tie<key_zero, key_one>(number, letter)) = 'b';
+
+        BOOST_TEST(number == 202);
+        BOOST_TEST(letter == 'b');
+    }
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/misc.hpp b/src/boost/libs/fusion/test/sequence/misc.hpp
new file mode 100644
index 00000000..c426bba8
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/misc.hpp
@@ -0,0 +1,204 @@
+/*=============================================================================
+    Copyright (C) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/mpl/find.hpp>
+#include <boost/mpl/equal.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <string>
+
+#if !defined(FUSION_AT)
+#define FUSION_AT at_c
+#endif
+
+#if !defined(FUSION_SIZE)
+#define FUSION_SIZE boost::fusion::result_of::size
+#endif
+
+template <typename S1, typename S2>
+struct is_same
+{
+};
+
+struct test_intrinsics1
+{
+    // test at, begin, end, next, prior, advance, size, deref, etc.
+
+    typedef boost::fusion::FUSION_SEQUENCE<int, float, bool, char> sequence;
+    typedef boost::mpl::begin<sequence>::type first;
+    typedef boost::mpl::next<first>::type second;
+    typedef boost::mpl::next<second>::type third;
+    typedef boost::mpl::next<third>::type fourth;
+    typedef boost::mpl::end<sequence>::type last;
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<first>::type, int>::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<second>::type, float>::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<third>::type, bool>::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<fourth>::type, char>::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::at_c<sequence, 2>::type, bool>::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::front<sequence>::type, int>::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<
+            boost::mpl::advance_c<second, 2>::type>::type, char>::value));
+
+    BOOST_STATIC_ASSERT((boost::mpl::size<sequence>::value == 4));
+    BOOST_STATIC_ASSERT(!(boost::mpl::empty<sequence>::value));
+    BOOST_STATIC_ASSERT((boost::mpl::distance<second, fourth>::value == 2));
+
+#if !defined(FUSION_FORWARD_ONLY) // list has no back/prev
+
+    typedef boost::mpl::prior<last>::type fourth_;
+    typedef boost::mpl::prior<fourth_>::type third_;
+    typedef boost::mpl::prior<third_>::type second_;
+    typedef boost::mpl::prior<second_>::type first_;
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<first_>::type, int>::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<second_>::type, float>::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<third_>::type, bool>::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::deref<fourth_>::type, char>::value));
+
+    BOOST_STATIC_ASSERT((boost::is_same<
+        boost::mpl::back<sequence>::type, char>::value));
+
+#endif
+};
+
+struct test_intrinsics2
+{
+    typedef boost::fusion::FUSION_SEQUENCE<> seq0;
+
+#if !defined(BOOST_FUSION_SEQUENCE_CONVERSION_IS_NOT_SEQUENCE__TYPE_PRESERVING)
+#if !defined(FUSION_FORWARD_ONLY) // list has no back/prev
+
+    typedef boost::fusion::FUSION_SEQUENCE<int> target1;
+    typedef boost::mpl::push_back<seq0, int>::type seq1;
+    BOOST_STATIC_ASSERT((boost::mpl::equal<seq1, target1>::value));
+
+    typedef boost::fusion::FUSION_SEQUENCE<int, double> target2;
+    typedef boost::mpl::push_back<seq1, double>::type seq2;
+    BOOST_STATIC_ASSERT((boost::mpl::equal<seq2, target2>::value));
+
+#endif
+
+    typedef boost::fusion::FUSION_SEQUENCE<int> target3;
+    typedef boost::mpl::push_front<seq0, int>::type seq3;
+    BOOST_STATIC_ASSERT((boost::mpl::equal<seq3, target3>::value));
+
+    typedef boost::fusion::FUSION_SEQUENCE<double, int> target4;
+    typedef boost::mpl::push_front<seq3, double>::type seq4;
+    BOOST_STATIC_ASSERT((boost::mpl::equal<seq4, target4>::value));
+
+#endif
+};
+
+void
+test()
+{
+    using namespace boost::fusion;
+
+    {   // testing const sequences
+
+        const FUSION_SEQUENCE<int, float> t1(5, 3.3f);
+        BOOST_TEST(FUSION_AT<0>(t1) == 5);
+        BOOST_TEST(FUSION_AT<1>(t1) == 3.3f);
+    }
+
+    {   // testing at<N> works with MPL integral constants
+        const FUSION_SEQUENCE<int, char> t1(101, 'z');
+        BOOST_TEST(boost::fusion::at<boost::mpl::int_<0> >(t1) == 101);
+        BOOST_TEST(boost::fusion::at<boost::mpl::int_<1> >(t1) == 'z');
+        // explicitly try something other than mpl::int_
+        BOOST_TEST((boost::fusion::at<boost::mpl::integral_c<long, 0> >(t1) == 101));
+        BOOST_TEST((boost::fusion::at<boost::mpl::integral_c<long, 1> >(t1) == 'z'));
+    }
+
+    {   // testing size & empty
+
+        typedef FUSION_SEQUENCE<int, float, double> t1;
+        typedef FUSION_SEQUENCE<> t2;
+
+        BOOST_STATIC_ASSERT(FUSION_SIZE<t1>::value == 3);
+        BOOST_STATIC_ASSERT(FUSION_SIZE<t2>::value == 0);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<t1>::value);
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::empty<t2>::value);
+    }
+
+    {   // testing front & back
+
+        typedef FUSION_SEQUENCE<int, float, std::string> tup;
+        tup t(1, 2.2f, "Kimpo");
+
+        BOOST_TEST(front(t) == 1);
+#if !defined(FUSION_FORWARD_ONLY) // list has no back
+        BOOST_TEST(back(t) == "Kimpo");
+#endif
+    }
+
+    {   // testing is_sequence
+
+        typedef FUSION_SEQUENCE<int, float, double> t1;
+        typedef FUSION_SEQUENCE<> t2;
+        typedef FUSION_SEQUENCE<char> t3;
+
+        BOOST_STATIC_ASSERT(traits::is_sequence<t1>::value);
+        BOOST_STATIC_ASSERT(traits::is_sequence<t2>::value);
+        BOOST_STATIC_ASSERT(traits::is_sequence<t3>::value);
+        BOOST_STATIC_ASSERT(!traits::is_sequence<int>::value);
+        BOOST_STATIC_ASSERT(!traits::is_sequence<char>::value);
+    }
+
+    {   // testing mpl::is_sequence
+
+        typedef FUSION_SEQUENCE<int, float, double> t1;
+        typedef FUSION_SEQUENCE<> t2;
+        typedef FUSION_SEQUENCE<char> t3;
+
+        BOOST_STATIC_ASSERT(boost::mpl::is_sequence<t1>::value);
+        BOOST_STATIC_ASSERT(boost::mpl::is_sequence<t2>::value);
+        BOOST_STATIC_ASSERT(boost::mpl::is_sequence<t3>::value);
+    }
+
+    {   // testing mpl compatibility
+
+        // test begin, end, next, prior, advance, size, deref, etc.
+        //~ typedef FUSION_SEQUENCE<int, float, bool, char> tuple_type;
+        //~ test_intrinsics1<tuple_type> test1;
+        //~ (void)test1; // prevent unused variable warning
+
+        // test an algorithm
+        typedef FUSION_SEQUENCE<int, float, double> t1;
+        typedef boost::mpl::find<t1, float>::type iter;
+        typedef boost::mpl::deref<iter>::type type;
+        BOOST_STATIC_ASSERT((boost::is_same<type, float>::value));
+
+    }
+}
diff --git a/src/boost/libs/fusion/test/sequence/move.hpp b/src/boost/libs/fusion/test/sequence/move.hpp
new file mode 100644
index 00000000..8636604f
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/move.hpp
@@ -0,0 +1,120 @@
+/*=============================================================================
+    Copyright (c) 2012 Joel de Guzman
+
+    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>
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#error "Valid only on compilers that support rvalues"
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/assert.hpp>
+#include <vector>
+
+
+namespace test_detail
+{
+    int copies = 0;
+
+    void incr_copy()
+    {
+        copies++;
+    }
+
+    struct x
+    {
+        int i;
+        x() : i(123) {}
+
+        x(x&& rhs) : i(rhs.i) {}
+
+        x& operator=(x&& rhs)
+        {
+            i = rhs.i;
+            return *this;
+        }
+
+        x(x const& /*rhs*/)
+        {
+            incr_copy();
+        }
+
+        x& operator=(x const& /*rhs*/)
+        {
+            incr_copy();
+            return *this;
+        }
+    };
+
+    typedef std::vector<x> vector_type;
+    extern bool disable_rvo; // to disable RVO
+
+    vector_type
+    generate_vec()
+    {
+        vector_type v;
+        v.push_back(x());
+        if (disable_rvo)
+            return v;
+        return vector_type();
+   }
+
+
+    template <typename T>
+    T move_me(T && val)
+    {
+        T r(std::move(val));
+        if (disable_rvo)
+            return r;
+        return T();
+    }
+
+    typedef FUSION_SEQUENCE return_type;
+
+    return_type
+    generate()
+    {
+        return_type r(generate_vec());
+        if (disable_rvo)
+            return r;
+        return return_type();
+    }
+
+    typedef FUSION_SEQUENCE2 return_type2;
+
+    return_type2
+    generate2()
+    {
+        return_type2 r(generate_vec(), x());
+        if (disable_rvo)
+            return r;
+        return return_type2();
+    }
+}
+
+void test()
+{
+    using namespace boost::fusion;
+    using namespace test_detail;
+
+    return_type v = move_me(generate());
+    BOOST_TEST(copies == 0);
+
+    return_type2 v2 = move_me(generate2());
+    BOOST_TEST(copies == 0);
+
+    v2 = move_me(generate2());
+    BOOST_TEST(copies == 0);
+
+    std::cout << "Copies: " << copies << std::endl;
+}
+
+namespace test_detail
+{
+   bool disable_rvo = true;
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/mutate.hpp b/src/boost/libs/fusion/test/sequence/mutate.hpp
new file mode 100644
index 00000000..9bc9be8a
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/mutate.hpp
@@ -0,0 +1,52 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+
+#if !defined(FUSION_AT)
+#define FUSION_AT at_c
+#endif
+
+namespace test_detail
+{
+    // no public default constructor
+    class foo
+    {
+    public:
+
+        explicit foo(int v) : val(v) {}
+
+        bool operator==(const foo& other) const
+        {
+            return val == other.val;
+        }
+
+    private:
+
+        foo() {}
+        int val;
+    };
+}
+
+void
+test()
+{
+    using namespace boost::fusion;
+    using namespace test_detail;
+
+    FUSION_SEQUENCE<int, float, bool, foo> t1(5, 12.2f, true, foo(4));
+    FUSION_AT<0>(t1) = 6;
+    FUSION_AT<1>(t1) = 2.2f;
+    FUSION_AT<2>(t1) = false;
+    FUSION_AT<3>(t1) = foo(5);
+
+    BOOST_TEST(FUSION_AT<0>(t1) == 6);
+    BOOST_TEST(FUSION_AT<1>(t1) > 2.1f && FUSION_AT<1>(t1) < 2.3f);
+    BOOST_TEST(FUSION_AT<2>(t1) == false);
+    BOOST_TEST(FUSION_AT<3>(t1) == foo(5));
+}
diff --git a/src/boost/libs/fusion/test/sequence/nest.hpp b/src/boost/libs/fusion/test/sequence/nest.hpp
new file mode 100644
index 00000000..76f3b436
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/nest.hpp
@@ -0,0 +1,321 @@
+/*=============================================================================
+    Copyright (C) 2015 Kohei Takahshi
+
+    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/include/adapt_struct.hpp>
+#include <boost/fusion/include/as_deque.hpp>
+#include <boost/fusion/include/as_list.hpp>
+#include <boost/fusion/include/as_vector.hpp>
+#include <boost/fusion/include/begin.hpp>
+#include <boost/fusion/include/is_sequence.hpp>
+#include <boost/fusion/include/size.hpp>
+#include <boost/fusion/include/value_of.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include "fixture.hpp"
+
+namespace test_detail
+{
+    struct adapted_sequence
+    {
+        adapted_sequence() : value_() {}
+        explicit adapted_sequence(int value) : value_(value) {}
+        int value_;
+    };
+
+    bool operator==(adapted_sequence const& lhs, adapted_sequence const& rhs)
+    {
+        return lhs.value_ == rhs.value_;
+    }
+
+    bool operator!=(adapted_sequence const& lhs, adapted_sequence const& rhs)
+    {
+        return lhs.value_ != rhs.value_;
+    }
+
+    template <template <typename> class Scenario>
+    struct can_convert_using
+    {
+        template <typename T>
+        struct to
+        {
+            static bool can_convert_(boost::true_type /* skip */)
+            {
+                return true;
+            }
+
+            static bool can_convert_(boost::false_type /* skip */)
+            {
+                using namespace boost::fusion;
+                return
+                    run<Scenario<T> >(typename result_of::as_deque<T>::type()) &&
+                    run<Scenario<T> >(typename result_of::as_list<T>::type()) &&
+                    run<Scenario<T> >(typename result_of::as_vector<T>::type());
+            }
+
+            template <typename Source, typename Expected>
+            bool operator()(Source const&, Expected const&) const
+            {
+                // bug when converting single element sequences in C++03 and
+                // C++11... 
+                // not_<not_<is_convertible<sequence<sequence<int>>, int >
+                // is invalid check
+                typedef typename ::boost::fusion::result_of::size<T>::type seq_size;
+                return can_convert_(
+                    boost::integral_constant<bool, seq_size::value == 1>()
+                );
+            }
+        };
+    };
+
+    template <typename T>
+    struct can_construct_from_elements
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source const&, Expected const&) const
+        {
+            // constructing a nested sequence of one is the complicated case to
+            // disambiguate from a conversion-copy, so focus on that
+            typedef typename boost::fusion::result_of::size<T>::type seq_size;
+            return can_construct_(
+                boost::integral_constant<int, seq_size::value>()
+            );
+        }
+
+        template <int Size>
+        static bool can_construct_(boost::integral_constant<int, Size>)
+        {
+            return Size == 0 || Size == 2 || Size == 3;
+        }
+
+        static bool can_construct_(boost::integral_constant<int, 1>)
+        {
+            typedef typename ::boost::remove_reference<
+                typename ::boost::remove_const<
+                    typename ::boost::fusion::result_of::value_of<
+                        typename ::boost::fusion::result_of::begin<T>::type
+                    >::type
+                >::type
+            >::type element;
+
+            return run< can_construct<T> >(element(), T());
+        }
+    };
+
+    template <typename T>
+    struct can_nest
+    {
+        template <typename Source, typename Expected>
+        bool operator()(Source const& source, Expected const& expected)
+        {
+            return
+                run< can_copy<T> >(source, expected) &&
+                run< can_convert_using<can_copy>::to<T> >(source, expected) &&
+                run< can_construct_from_elements<T> >(source, expected);
+        }
+    };
+} // test_detail
+
+
+BOOST_FUSION_ADAPT_STRUCT(test_detail::adapted_sequence, (int, data))
+
+template <template <typename> class Scenario>
+void
+test()
+{
+    using namespace test_detail;
+
+    BOOST_TEST(boost::fusion::traits::is_sequence<adapted_sequence>::value);
+    BOOST_TEST(boost::fusion::size(adapted_sequence()) == 1);
+
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE< FUSION_SEQUENCE<> > > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<> >()
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario<FUSION_SEQUENCE<FUSION_SEQUENCE<>, int> > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<>, int>(FUSION_SEQUENCE<>(), 325)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<int, FUSION_SEQUENCE<> > > >(
+            FUSION_SEQUENCE< int, FUSION_SEQUENCE<> >(325, FUSION_SEQUENCE<>())
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario<FUSION_SEQUENCE<int, FUSION_SEQUENCE<>, float> > >(
+            FUSION_SEQUENCE<int, FUSION_SEQUENCE<> , float>(
+                325, FUSION_SEQUENCE<>(), 2.0f
+            )
+        )
+    ));
+
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE< FUSION_SEQUENCE<int> > > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<int> >(FUSION_SEQUENCE<int>(400))
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<adapted_sequence> > >(
+            FUSION_SEQUENCE<adapted_sequence>(adapted_sequence(400))
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario<FUSION_SEQUENCE<FUSION_SEQUENCE<int>, int> > >(
+            FUSION_SEQUENCE<FUSION_SEQUENCE<int>, int>(
+                FUSION_SEQUENCE<int>(325), 400
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario<FUSION_SEQUENCE<adapted_sequence, int> > >(
+           FUSION_SEQUENCE<adapted_sequence, int>(adapted_sequence(325), 400)
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE< int, FUSION_SEQUENCE<int> > > >(
+            FUSION_SEQUENCE< int, FUSION_SEQUENCE<int> >(
+                325, FUSION_SEQUENCE<int>(400)
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<int, adapted_sequence> > >(
+            FUSION_SEQUENCE<int, adapted_sequence>(325, adapted_sequence(450))
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<int, FUSION_SEQUENCE<int>, int> > >(
+            FUSION_SEQUENCE<int, FUSION_SEQUENCE<int>, int>(
+                500, FUSION_SEQUENCE<int>(350), 200
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<int, adapted_sequence, int> > >(
+            FUSION_SEQUENCE<int, adapted_sequence, int>(
+                300, adapted_sequence(500), 400)
+        )
+    ));
+
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE< FUSION_SEQUENCE<int, int> > > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<int, int> >(
+                FUSION_SEQUENCE<int, int>(450, 500)
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE<FUSION_SEQUENCE<int, int>, int> > >(
+            FUSION_SEQUENCE<FUSION_SEQUENCE<int, int>, int>(
+                FUSION_SEQUENCE<int, int>(450, 500), 150
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario< FUSION_SEQUENCE< int, FUSION_SEQUENCE<int, int> > > >(
+            FUSION_SEQUENCE< int, FUSION_SEQUENCE<int, int> >(
+                450, FUSION_SEQUENCE<int, int>(500, 150)
+            )
+        )
+    ));
+    BOOST_TEST((
+        run<Scenario< FUSION_SEQUENCE<int, FUSION_SEQUENCE<int, int>, int> > >(
+            FUSION_SEQUENCE<int, FUSION_SEQUENCE<int, int>, int>(
+                150, FUSION_SEQUENCE<int, int>(250, 350), 450
+            )
+        )
+    ));
+
+    BOOST_TEST((
+        run<Scenario<FUSION_SEQUENCE<FUSION_SEQUENCE<>, FUSION_SEQUENCE<> > > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<>, FUSION_SEQUENCE<> >(
+                FUSION_SEQUENCE<>(), FUSION_SEQUENCE<>()
+            )
+        )
+    ));
+    BOOST_TEST((
+        run<Scenario<FUSION_SEQUENCE<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<> > > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<int>, FUSION_SEQUENCE<> >(
+                FUSION_SEQUENCE<int>(150), FUSION_SEQUENCE<>()
+            )
+        )
+    ));
+    BOOST_TEST((
+        run<Scenario<FUSION_SEQUENCE<FUSION_SEQUENCE<>, FUSION_SEQUENCE<int> > > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<>, FUSION_SEQUENCE<int> >(
+                FUSION_SEQUENCE<>(), FUSION_SEQUENCE<int>(500)
+            )
+        )
+    ));
+    BOOST_TEST((
+        run<Scenario<FUSION_SEQUENCE<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int> > > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int> >(
+                FUSION_SEQUENCE<int>(155), FUSION_SEQUENCE<int>(255)
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario<
+            FUSION_SEQUENCE< FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<int> >
+        > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<int> >(
+                FUSION_SEQUENCE<int, int>(222, 333), FUSION_SEQUENCE<int>(444)
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario<
+            FUSION_SEQUENCE< FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int, int> >
+        > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int, int> >(
+                FUSION_SEQUENCE<int>(100), FUSION_SEQUENCE<int, int>(300, 400)
+            )
+        )
+    ));
+    BOOST_TEST((
+        run< Scenario<
+            FUSION_SEQUENCE< FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<int, int> >
+        > >(
+            FUSION_SEQUENCE< FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<int, int> >(
+                FUSION_SEQUENCE<int, int>(600, 700)
+              , FUSION_SEQUENCE<int, int>(800, 900)
+            )
+        )
+    ));
+
+
+    // Ignore desired scenario, and cheat to make these work
+    BOOST_TEST((
+        run< can_lvalue_construct< FUSION_SEQUENCE<FUSION_SEQUENCE<>&> > >(
+            FUSION_SEQUENCE<>()
+          , FUSION_SEQUENCE< FUSION_SEQUENCE<> >()
+        )
+    ));
+    BOOST_TEST((
+        run< can_construct< FUSION_SEQUENCE<const FUSION_SEQUENCE<>&> > >(
+            FUSION_SEQUENCE<>()
+          , FUSION_SEQUENCE< FUSION_SEQUENCE<> >()
+        )
+    ));
+    BOOST_TEST((
+        run< can_lvalue_construct< FUSION_SEQUENCE<FUSION_SEQUENCE<int>&> > >(
+            FUSION_SEQUENCE<int>(300)
+          , FUSION_SEQUENCE< FUSION_SEQUENCE<int> >(FUSION_SEQUENCE<int>(300))
+        )
+    ));
+    BOOST_TEST((
+        run< can_construct< FUSION_SEQUENCE<const FUSION_SEQUENCE<int>&> > >(
+            FUSION_SEQUENCE<int>(400)
+          , FUSION_SEQUENCE< FUSION_SEQUENCE<int> >(FUSION_SEQUENCE<int>(400))
+        )
+    ));
+}
diff --git a/src/boost/libs/fusion/test/sequence/nil.cpp b/src/boost/libs/fusion/test/sequence/nil.cpp
new file mode 100644
index 00000000..bdc8c352
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/nil.cpp
@@ -0,0 +1,25 @@
+/*=============================================================================
+    Copyright (c) 2014 Louis Dionne
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/list/cons_iterator.hpp>
+#include <boost/fusion/container/list/nil.hpp>
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/bool.hpp>
+
+
+int main() {
+    using namespace boost::fusion;
+
+    // nil should be constexpr constructible
+    {
+        BOOST_CONSTEXPR nil x1 = nil();
+        BOOST_CONSTEXPR nil x2 = nil(nil_iterator(), boost::mpl::true_());
+        (void)x1; (void)x2;
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/nview.cpp b/src/boost/libs/fusion/test/sequence/nview.cpp
new file mode 100644
index 00000000..dab982a5
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/nview.cpp
@@ -0,0 +1,139 @@
+/*=============================================================================
+    Copyright (c) 2009 Hartmut Kaiser
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/fusion/include/vector.hpp>
+#include <boost/fusion/include/struct.hpp>
+#include <boost/fusion/include/equal_to.hpp>
+#include <boost/fusion/include/io.hpp>
+#include <boost/fusion/include/nview.hpp>
+
+#include <string>
+#include <iostream>
+
+struct test {
+    int int_;
+    std::string string_;
+    double double_;
+};
+
+BOOST_FUSION_ADAPT_STRUCT(
+    test, 
+    (int, int_)
+    (std::string, string_)
+    (double, double_)
+)
+
+namespace fusion = boost::fusion;
+
+template <typename Sequence>
+bool check_size(Sequence const& s, int seqsize)
+{
+    return fusion::size(s) == seqsize;
+}
+
+template <typename Sequence, typename T>
+bool check_deref_begin(Sequence const& s, T val)
+{
+    return fusion::deref(fusion::begin(s)) == val;
+}
+
+template <typename Sequence, typename T>
+bool check_deref_next(Sequence const& s, T val)
+{
+    return fusion::deref(fusion::next(fusion::begin(s))) == val;
+}
+
+template <int N, typename Sequence, typename T>
+bool check_deref_advance(Sequence const& s, T val)
+{
+    return fusion::deref(fusion::advance_c<N>(fusion::begin(s))) == val;
+}
+
+template <typename Sequence, typename T>
+bool check_deref_prior(Sequence const& s, T val)
+{
+    return fusion::deref(fusion::prior(fusion::end(s))) == val;
+}
+
+template <int N, typename Sequence, typename T>
+bool check_at(Sequence const& s, T val)
+{
+    return fusion::at_c<N>(s) == val;
+}
+
+template <typename Sequence>
+bool check_distance(Sequence const& s, int val)
+{
+    return fusion::distance(fusion::begin(s), fusion::end(s)) == val;
+}
+
+int main()
+{
+    test t;
+    t.int_ = 1;
+    t.string_ = "test";
+    t.double_ = 2.0;
+
+    using fusion::as_nview;
+
+    // check size()
+    {
+        BOOST_TEST(check_size(as_nview<0>(t), 1));
+        BOOST_TEST(check_size(as_nview<2, 1>(t), 2));
+        BOOST_TEST(check_size(as_nview<2, 1, 0>(t), 3));
+        BOOST_TEST(check_size(as_nview<2, 1, 0, 2, 0>(t), 5));
+    }
+
+    // check deref/begin
+    {
+        BOOST_TEST(check_deref_begin(as_nview<0>(t), 1));
+        BOOST_TEST(check_deref_begin(as_nview<2, 1>(t), 2.0));
+        BOOST_TEST(check_deref_begin(as_nview<1, 2, 0>(t), "test"));
+        BOOST_TEST(check_deref_begin(as_nview<2, 1, 0, 2, 0>(t), 2.0));
+    }
+
+    // check deref/next
+    {
+        BOOST_TEST(check_deref_next(as_nview<2, 1>(t), "test"));
+        BOOST_TEST(check_deref_next(as_nview<1, 2, 0>(t), 2.0));
+        BOOST_TEST(check_deref_next(as_nview<2, 0, 1, 2, 0>(t), 1));
+    }
+
+    // check deref/advance
+    {
+        BOOST_TEST(check_deref_advance<0>(as_nview<2, 1>(t), 2.0));
+        BOOST_TEST(check_deref_advance<2>(as_nview<1, 2, 0>(t), 1));
+        BOOST_TEST(check_deref_advance<4>(as_nview<2, 0, 1, 2, 0>(t), 1));
+    }
+
+    // check deref/prior
+    {
+        BOOST_TEST(check_deref_prior(as_nview<2, 1>(t), "test"));
+        BOOST_TEST(check_deref_prior(as_nview<1, 2, 0>(t), 1));
+        BOOST_TEST(check_deref_prior(as_nview<2, 0, 1, 2, 0>(t), 1));
+    }
+
+    // check at
+    {
+        BOOST_TEST(check_at<0>(as_nview<0>(t), 1));
+        BOOST_TEST(check_at<1>(as_nview<2, 1>(t), "test"));
+        BOOST_TEST(check_at<2>(as_nview<1, 2, 0>(t), 1));
+        BOOST_TEST(check_at<4>(as_nview<2, 1, 0, 2, 0>(t), 1));
+    }
+
+    // check distance
+    {
+        BOOST_TEST(check_distance(as_nview<0>(t), 1));
+        BOOST_TEST(check_distance(as_nview<2, 1>(t), 2));
+        BOOST_TEST(check_distance(as_nview<1, 2, 0>(t), 3));
+        BOOST_TEST(check_distance(as_nview<2, 1, 0, 2, 0>(t), 5));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/ref_vector.cpp b/src/boost/libs/fusion/test/sequence/ref_vector.cpp
new file mode 100644
index 00000000..8bd0929b
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/ref_vector.cpp
@@ -0,0 +1,64 @@
+/*=============================================================================
+    Copyright (c) 2012 Joel falcou
+
+    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 <iostream>
+#include <boost/mpl/transform.hpp>
+#include <boost/fusion/include/mpl.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/fusion/include/as_vector.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/fusion/include/adapt_struct.hpp>
+
+struct foo
+{
+  double d; float f; short c;
+};
+
+BOOST_FUSION_ADAPT_STRUCT(foo,(double,d)(float,f)(short,c))
+
+template<class T>
+class composite_reference
+    : public  boost::mpl::
+              transform < typename  boost::fusion::result_of::
+                                    as_vector<T>::type
+                        , boost::add_reference<boost::mpl::_>
+                        >::type
+{
+  public:
+  typedef typename  boost::mpl::
+          transform < typename  boost::fusion::result_of::
+                                    as_vector<T>::type
+                        , boost::add_reference<boost::mpl::_>
+                        >::type                                 parent;
+
+  composite_reference(T& src)       : parent( src ) {}
+  composite_reference(parent& src)  : parent(src) {}
+
+  composite_reference& operator=(T& src)
+  {
+    static_cast<parent&>(*this) = static_cast<parent&>(src);
+    return *this;
+  }
+
+  composite_reference& operator=(parent const& src)
+  {
+    static_cast<parent&>(*this) = src;
+    return *this;
+  }
+};
+
+int main(int,char**)
+{
+  foo f;
+  composite_reference<foo> ref_f(f);
+
+  boost::fusion::at_c<0>(ref_f) = 1.2;
+  boost::fusion::at_c<1>(ref_f) = 1.2f;
+  boost::fusion::at_c<2>(ref_f) = 12;
+
+  std::cout << f.d << " " << f.f << " " << f.c << "\n";
+}
diff --git a/src/boost/libs/fusion/test/sequence/repetitive_view.cpp b/src/boost/libs/fusion/test/sequence/repetitive_view.cpp
new file mode 100644
index 00000000..54da37bc
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/repetitive_view.cpp
@@ -0,0 +1,53 @@
+/*=============================================================================
+    Copyright (c) 2007 Tobias Schwinger
+  
+    Use modification and distribution are subject to the Boost Software 
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/view/repetitive_view.hpp>
+
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/view/joint_view.hpp>
+#include <boost/fusion/algorithm/transformation/zip.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/iterator/next.hpp>
+
+#include <boost/fusion/functional/generation/make_fused_procedure.hpp>
+
+struct check_equal
+{
+    template<typename LHS, typename RHS>
+    void operator()(LHS const& lhs, RHS const& rhs) const
+    {
+        BOOST_TEST(( boost::is_same<LHS,RHS>::value ));
+        BOOST_TEST(( lhs == rhs )); 
+    }
+};
+
+int main()
+{
+    using namespace boost::fusion;
+
+    typedef boost::fusion::vector<int,long,float,double> seq_t;
+    seq_t seq(1,2l,3.0f,4.0);
+
+    typedef repetitive_view<seq_t> view_t;
+    view_t view(seq);
+
+    typedef joint_view<seq_t,seq_t> seq_twice_t;
+    typedef joint_view<seq_t,seq_twice_t> seq_repeated_t;
+    seq_twice_t seq_twice(seq,seq);
+    seq_repeated_t seq_repeated(seq,seq_twice);
+
+    for_each(zip(view,seq_repeated), make_fused_procedure(check_equal()));
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/reverse_view.cpp b/src/boost/libs/fusion/test/sequence/reverse_view.cpp
new file mode 100644
index 00000000..fb96275d
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/reverse_view.cpp
@@ -0,0 +1,109 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/map/map.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/view/reverse_view/reverse_view.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/prior.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/range_c.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+/// Testing the reverse_view
+
+    {
+        typedef boost::mpl::range_c<int, 5, 9> mpl_list1;
+        mpl_list1 l;
+        reverse_view<mpl_list1> rev(l);
+
+        std::cout << rev << std::endl;
+        BOOST_TEST((rev == make_vector(8, 7, 6, 5)));
+    }
+
+    {
+        char const* s = "Hi Kim";
+        typedef vector<int, char, long, char const*> vector_type;
+        vector_type t(123, 'x', 123456789, s);
+        typedef reverse_view<vector_type> view_type;
+        view_type rev(t);
+
+        std::cout << rev << std::endl;
+        BOOST_TEST((rev == make_vector(s, 123456789, 'x', 123)));
+
+        typedef boost::fusion::result_of::begin<view_type>::type first_type;
+        first_type first_it(begin(rev));
+        typedef boost::fusion::result_of::next<first_type>::type second_type;
+        second_type second_it(next(first_it));
+        BOOST_TEST((*second_it == 123456789));
+        BOOST_TEST((*prior(second_it) == s));
+        BOOST_TEST((*advance_c<2>(first_it) == 'x'));
+        BOOST_TEST((distance(first_it, second_it) == 1));
+
+        BOOST_TEST((at_c<0>(rev)==s));
+        BOOST_TEST((at_c<1>(rev)==123456789));
+        BOOST_TEST((at_c<2>(rev)=='x'));
+        BOOST_TEST((at_c<3>(rev)==123));
+
+        BOOST_MPL_ASSERT((
+            boost::is_same<boost::fusion::result_of::value_at_c<view_type,0>::type,char const*>
+        ));
+        BOOST_MPL_ASSERT((
+            boost::is_same<boost::fusion::result_of::value_at_c<view_type,1>::type,long>
+        ));
+        BOOST_MPL_ASSERT((
+            boost::is_same<boost::fusion::result_of::value_at_c<view_type,2>::type,char>
+        ));
+        BOOST_MPL_ASSERT((
+            boost::is_same<boost::fusion::result_of::value_at_c<view_type,3>::type,int>
+        ));
+    }
+
+    //! Map
+    {
+        typedef pair<boost::mpl::int_<0>, std::string> pair0;
+        typedef pair<boost::mpl::int_<1>, std::string> pair1;
+        typedef pair<boost::mpl::int_<2>, std::string> pair2;
+        typedef pair<boost::mpl::int_<3>, std::string> pair3;
+        typedef pair<boost::mpl::int_<4>, std::string> pair4;
+
+        typedef map< pair0, pair1, pair2, pair3, pair4 > map_type;
+        map_type m( pair0("zero"), pair1("one"), pair2("two"), pair3("three"), pair4("four") );
+        typedef reverse_view<map_type> view_type;
+        view_type rev(m);
+        std::cout << rev << std::endl;
+        BOOST_TEST((rev == make_vector( pair4("four"), pair3("three"), pair2("two"), pair1("one"), pair0("zero"))));
+        BOOST_TEST((at_c<0>(rev) == pair4("four")));
+        BOOST_TEST((at_c<1>(rev) == pair3("three")));
+        BOOST_TEST((at_c<2>(rev) == pair2("two")));
+        BOOST_TEST((at_c<3>(rev) == pair1("one")));
+        BOOST_TEST((at_c<4>(rev) == pair0("zero")));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/segmented_iterator_range.cpp b/src/boost/libs/fusion/test/sequence/segmented_iterator_range.cpp
new file mode 100644
index 00000000..df49407a
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/segmented_iterator_range.cpp
@@ -0,0 +1,146 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2011 Eric Niebler
+
+    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 <sstream>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/fusion/algorithm/query/find_if.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/view/iterator_range/iterator_range.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/mpl/vector_c.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/static_assert.hpp>
+#include "tree.hpp"
+
+struct ostream_fun
+{
+    ostream_fun(std::ostream &sout)
+        : sout_(sout)
+    {}
+    template<typename T>
+    void operator ()(T const &t) const
+    {
+        sout_ << t << ' ';
+    }
+private:
+    std::ostream & sout_;
+};
+
+template<typename Tree>
+void
+process_tree(Tree const &tree)
+{
+    using namespace boost;
+    using namespace fusion;
+    using mpl::_;
+
+    typedef typename boost::fusion::result_of::find_if<Tree const, is_same<_,short> >::type short_iter;
+    typedef typename boost::fusion::result_of::find_if<Tree const, is_same<_,float> >::type float_iter;
+
+    typedef iterator_range<short_iter, float_iter> slice_t;
+    BOOST_STATIC_ASSERT(traits::is_segmented<slice_t>::value);
+
+    // find_if of a segmented data structure returns generic
+    // segmented iterators
+    short_iter si = find_if<is_same<_,short> >(tree);
+    float_iter fi = find_if<is_same<_,float> >(tree);
+
+    // If you put them in an iterator range, the range
+    // is automatically a segmented data structure.
+    slice_t slice(si, fi);
+
+    std::stringstream sout;
+    fusion::for_each(slice, ostream_fun(sout));
+    BOOST_TEST((sout.str() == "100 e f 0 B "));
+}
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        char const* s = "Ruby";
+        typedef vector<int, char, double, char const*> vector_type;
+        vector_type vec(1, 'x', 3.3, s);
+
+        {
+            typedef vector_iterator<vector_type, 1> i1t;
+            typedef vector_iterator<vector_type, 3> i3t;
+
+            i1t i1(vec);
+            i3t i3(vec);
+
+            typedef iterator_range<i1t, i3t> slice_t;
+            slice_t slice(i1, i3);
+            std::cout << slice << std::endl;
+            BOOST_TEST((slice == make_vector('x', 3.3)));
+            BOOST_STATIC_ASSERT(boost::fusion::result_of::size<slice_t>::value == 2);
+        }
+
+        {
+            typedef vector_iterator<vector_type, 0> i1t;
+            typedef vector_iterator<vector_type, 0> i3t;
+
+            i1t i1(vec);
+            i3t i3(vec);
+
+            typedef iterator_range<i1t, i3t> slice_t;
+            slice_t slice(i1, i3);
+            std::cout << slice << std::endl;
+            BOOST_TEST(slice == make_vector());
+            BOOST_STATIC_ASSERT(boost::fusion::result_of::size<slice_t>::value == 0);
+        }
+    }
+
+    {
+        typedef boost::mpl::vector_c<int, 2, 3, 4, 5, 6> mpl_vec;
+        typedef boost::mpl::begin<mpl_vec>::type it0;
+        typedef boost::mpl::next<it0>::type it1;
+        typedef boost::mpl::next<it1>::type it2;
+        typedef boost::mpl::next<it2>::type it3;
+
+        it1 f;
+        it3 l;
+        
+        typedef iterator_range<it1, it3> slice_t;
+        slice_t slice(f, l);
+        std::cout << slice << std::endl;
+        BOOST_TEST((slice == make_vector(3, 4)));
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<slice_t>::value == 2);
+    }
+
+    {
+        process_tree(
+            make_tree(
+                make_vector(double(0),'B')
+              , make_tree(
+                    make_vector(1,2,long(3))
+                  , make_tree(make_vector('a','b','c'))
+                  , make_tree(make_vector(short('d'),'e','f'))
+                )
+              , make_tree(
+                    make_vector(4,5,6)
+                  , make_tree(make_vector(float(1),'h','i'))
+                  , make_tree(make_vector('j','k','l'))
+                )
+            )
+        );
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/set.cpp b/src/boost/libs/fusion/test/sequence/set.cpp
new file mode 100644
index 00000000..714c36cd
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/set.cpp
@@ -0,0 +1,110 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/set/set.hpp>
+#include <boost/fusion/container/generation/make_set.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at_key.hpp>
+#include <boost/fusion/sequence/intrinsic/has_key.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/iterator/key_of.hpp>
+#include <boost/fusion/iterator/deref_data.hpp>
+#include <boost/fusion/iterator/value_of_data.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/support/pair.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <iostream>
+#include <string>
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+    namespace fusion = boost::fusion;
+    using boost::fusion::pair;
+    using boost::fusion::make_pair;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        typedef set<int, std::string> set_type;
+
+        BOOST_MPL_ASSERT((traits::is_associative<set_type>));
+        
+        set_type m(123, "Hola");
+        
+        std::cout << at_key<int>(m) << std::endl;
+        std::cout << at_key<std::string>(m) << std::endl;
+        
+        BOOST_TEST(at_key<int>(m) == 123);
+        BOOST_TEST(at_key<std::string>(m) == "Hola");
+
+        BOOST_STATIC_ASSERT((
+            boost::is_same<boost::fusion::result_of::value_at_key<set_type, int>::type, int>::value));
+        BOOST_STATIC_ASSERT((
+            boost::is_same<boost::fusion::result_of::value_at_key<set_type, std::string>::type, std::string>::value));
+
+        std::cout << m << std::endl;
+
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::has_key<set_type, int>::value));
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::has_key<set_type, std::string>::value));
+        BOOST_STATIC_ASSERT((!boost::fusion::result_of::has_key<set_type, double>::value));
+
+        std::cout << deref_data(begin(m)) << std::endl;
+        std::cout << deref_data(fusion::next(begin(m))) << std::endl;
+
+        BOOST_TEST(deref_data(begin(m)) == 123);
+        BOOST_TEST(deref_data(fusion::next(begin(m))) == "Hola");
+
+        BOOST_STATIC_ASSERT((boost::is_same<boost::fusion::result_of::key_of<boost::fusion::result_of::begin<set_type>::type>::type, int>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<boost::fusion::result_of::key_of<boost::fusion::result_of::next<boost::fusion::result_of::begin<set_type>::type>::type>::type, std::string>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<boost::fusion::result_of::value_of_data<boost::fusion::result_of::begin<set_type>::type>::type, int>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<boost::fusion::result_of::value_of_data<boost::fusion::result_of::next<boost::fusion::result_of::begin<set_type>::type>::type>::type, std::string>::value));
+    }
+    
+    {
+        std::cout << make_set('X', 123) << std::endl;
+        BOOST_TEST(at_key<char>(make_set('X', 123)) == 'X');
+        BOOST_TEST(at_key<int>(make_set('X', 123)) == 123);
+    }
+
+    {   // testing is_sequence
+
+        typedef set<int, float, double> t1;
+        typedef set<> t2;
+        typedef set<char> t3;
+
+        BOOST_MPL_ASSERT((traits::is_sequence<t1>));
+        BOOST_MPL_ASSERT((traits::is_sequence<t2>));
+        BOOST_MPL_ASSERT((traits::is_sequence<t3>));
+        BOOST_STATIC_ASSERT(traits::is_sequence<t1>::value);
+        BOOST_STATIC_ASSERT(traits::is_sequence<t2>::value);
+        BOOST_STATIC_ASSERT(traits::is_sequence<t3>::value);
+    }
+
+    {   // testing mpl::is_sequence
+
+        typedef set<int, float, double> t1;
+        typedef set<> t2;
+        typedef set<char> t3;
+
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<t1>));
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<t2>));
+        BOOST_MPL_ASSERT((boost::mpl::is_sequence<t3>));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/single_view.cpp b/src/boost/libs/fusion/test/sequence/single_view.cpp
new file mode 100644
index 00000000..6fa51755
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/single_view.cpp
@@ -0,0 +1,93 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2011 Eric Niebler
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/view/single_view/single_view.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/prior.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+struct X {};
+
+template <typename OS>
+OS& operator<<(OS& os, X const&)
+{
+    os << "<X-object>";
+    return os;
+}
+
+void foo() {}
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        single_view<int> view1(3);
+        std::cout << view1 << std::endl;
+        
+#ifdef FUSION_TEST_FAIL
+        // single_view is immutable
+        *begin(view1) += 4;
+#endif
+        std::cout << view1 << std::endl;
+        BOOST_TEST(*begin(view1) == 3);
+        BOOST_TEST(at<boost::mpl::int_<0> >(view1) == 3);
+        BOOST_TEST(view1.val == 3);
+        BOOST_TEST(3 == front(view1));
+        BOOST_TEST(3 == back(view1));
+        BOOST_TEST(!empty(view1));
+        BOOST_TEST(next(begin(view1)) == end(view1));
+        BOOST_TEST(prior(end(view1)) == begin(view1));
+        BOOST_TEST(!(next(begin(view1)) != end(view1)));
+        BOOST_TEST(!(prior(end(view1)) != begin(view1)));
+        BOOST_TEST(1 == distance(begin(view1), end(view1)));
+        BOOST_TEST(0 == distance(end(view1), end(view1)));
+        BOOST_TEST(0 == distance(begin(view1), begin(view1)));
+        BOOST_TEST(end(view1) == advance<boost::mpl::int_<1> >(begin(view1)));
+        BOOST_TEST(begin(view1) == advance<boost::mpl::int_<0> >(begin(view1)));
+        BOOST_TEST(end(view1) == advance<boost::mpl::int_<0> >(end(view1)));
+        BOOST_TEST(begin(view1) == advance<boost::mpl::int_<-1> >(end(view1)));
+        BOOST_TEST(end(view1) == advance_c<1>(begin(view1)));
+        BOOST_TEST(begin(view1) == advance_c<0>(begin(view1)));
+        BOOST_TEST(end(view1) == advance_c<0>(end(view1)));
+        BOOST_TEST(begin(view1) == advance_c<-1>(end(view1)));
+        BOOST_TEST(1 == size(view1));
+        BOOST_MPL_ASSERT((boost::is_same<int, boost::fusion::result_of::value_at<single_view<int>, boost::mpl::int_<0> >::type>));
+
+        single_view<X> view2;
+        std::cout << view2 << std::endl;
+    }
+    
+    {
+        std::cout << make_single_view(1) << std::endl;
+        std::cout << make_single_view("Hello, World") << std::endl;
+        std::cout << make_single_view(&foo) << std::endl;
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/size.cpp b/src/boost/libs/fusion/test/sequence/size.cpp
new file mode 100644
index 00000000..8c4c5a55
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/size.cpp
@@ -0,0 +1,103 @@
+/*=============================================================================
+    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)
+==============================================================================*/
+#include <boost/config.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/deque.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/set.hpp>
+#include <boost/fusion/container/map.hpp>
+#include <boost/fusion/support/pair.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/array.hpp>
+#include <boost/fusion/adapted/boost_array.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/fusion/adapted/boost_tuple.hpp>
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && \
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include <tuple>
+#include <boost/fusion/adapted/std_tuple.hpp>
+#endif
+
+template <typename LHS, typename RHS>
+void check_(LHS const&, RHS const&)
+{
+    BOOST_MPL_ASSERT((boost::is_same<LHS, RHS>));
+}
+
+template <typename S>
+void check()
+{
+    check_(
+        boost::fusion::result_of::size<S>::type::value
+      , boost::fusion::result_of::size<S>::value
+    );
+}
+
+void test()
+{
+    {
+        check<boost::fusion::vector<> >();
+        check<boost::fusion::vector<int> >();
+        check<boost::fusion::vector<int, int> >();
+        check<boost::fusion::vector<int, int, int> >();
+    }
+
+    {
+        check<boost::fusion::deque<> >();
+        check<boost::fusion::deque<int> >();
+        check<boost::fusion::deque<int, int> >();
+        check<boost::fusion::deque<int, int, int> >();
+    }
+
+    {
+        check<boost::fusion::list<> >();
+        check<boost::fusion::list<int> >();
+        check<boost::fusion::list<int, int> >();
+        check<boost::fusion::list<int, int, int> >();
+    }
+
+    {
+        check<boost::fusion::set<> >();
+        check<boost::fusion::set<int> >();
+        check<boost::fusion::set<int, float> >();
+        check<boost::fusion::set<int, float, double> >();
+    }
+
+    {
+        check<boost::fusion::map<> >();
+        check<boost::fusion::map<boost::fusion::pair<int, int> > >();
+        check<boost::fusion::map<boost::fusion::pair<int, int> , boost::fusion::pair<float, int> > >();
+        check<boost::fusion::map<boost::fusion::pair<int, int> , boost::fusion::pair<float, int> , boost::fusion::pair<double, int> > >();
+    }
+
+    {
+        check<boost::array<int, 1> >();
+        check<boost::array<int, 2> >();
+        check<boost::array<int, 3> >();
+    }
+
+    {
+        check<boost::tuples::tuple<> >();
+        check<boost::tuples::tuple<int> >();
+        check<boost::tuples::tuple<int, int> >();
+        check<boost::tuples::tuple<int, int, int> >();
+    }
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && \
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    {
+        check<std::tuple<> >();
+        check<std::tuple<int> >();
+        check<std::tuple<int, int> >();
+        check<std::tuple<int, int, int> >();
+    }
+#endif
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/std_array.cpp b/src/boost/libs/fusion/test/sequence/std_array.cpp
new file mode 100644
index 00000000..50e09b39
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/std_array.cpp
@@ -0,0 +1,51 @@
+//
+// Copyright (C) 2013 Mateusz Loskot <mateusz@loskot.net>
+//
+// 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>
+
+#ifdef BOOST_NO_CXX11_HDR_ARRAY
+#   error "does not meet requirements"
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(disable:4180)
+#endif
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/fusion/adapted/std_array.hpp>
+#include <array>
+
+#include <boost/fusion/sequence/intrinsic.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/fusion/iterator.hpp>
+
+#include <boost/mpl/assert.hpp>
+
+int main()
+{
+    using namespace boost::fusion;
+    typedef std::array<int,3> array_type;
+
+    BOOST_MPL_ASSERT((traits::is_sequence<array_type>));
+    BOOST_MPL_ASSERT_NOT((traits::is_view<array_type>));
+    BOOST_STATIC_ASSERT(traits::is_sequence<array_type>::value);
+    BOOST_STATIC_ASSERT(!traits::is_view<array_type>::value);
+
+    array_type arr = {{1,2,3}};
+
+    BOOST_TEST(*boost::fusion::begin(arr) == 1);
+    BOOST_TEST(*boost::fusion::next(boost::fusion::begin(arr)) == 2);
+    BOOST_TEST(*advance_c<2>(boost::fusion::begin(arr)) == 3);
+    BOOST_TEST(prior(boost::fusion::next(boost::fusion::begin(arr))) == boost::fusion::begin(arr));
+    BOOST_TEST(*prior(boost::fusion::end(arr)) == 3);
+    BOOST_TEST(at_c<2>(arr) == 3);
+    BOOST_TEST(boost::fusion::size(arr) == 3);
+    BOOST_TEST(distance(boost::fusion::begin(arr), boost::fusion::end(arr)) == 3);
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/std_pair.cpp b/src/boost/libs/fusion/test/sequence/std_pair.cpp
new file mode 100644
index 00000000..647e9b00
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/std_pair.cpp
@@ -0,0 +1,100 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/std_pair.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/list/list.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
+#include <boost/fusion/sequence/comparison/less.hpp>
+#include <boost/fusion/sequence/comparison/less_equal.hpp>
+#include <boost/fusion/sequence/comparison/greater.hpp>
+#include <boost/fusion/sequence/comparison/greater_equal.hpp>
+#include <boost/fusion/mpl.hpp>
+#include <boost/fusion/support/is_view.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/assert.hpp>
+#include <iostream>
+#include <string>
+#include <utility>
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+    {
+        typedef std::pair<int, std::string> pair_type;
+        BOOST_MPL_ASSERT_NOT((traits::is_view<pair_type>));
+        BOOST_STATIC_ASSERT(!traits::is_view<pair_type>::value);
+        pair_type p(123, "Hola!!!");
+
+        std::cout << at_c<0>(p) << std::endl;
+        std::cout << at_c<1>(p) << std::endl;
+        std::cout << p << std::endl;
+        BOOST_TEST(p == make_vector(123, "Hola!!!"));
+
+        at_c<0>(p) = 6;
+        at_c<1>(p) = "mama mia";
+        BOOST_TEST(p == make_vector(6, "mama mia"));
+
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<pair_type>::value == 2);
+        BOOST_STATIC_ASSERT(!boost::fusion::result_of::empty<pair_type>::value);
+
+        BOOST_TEST(front(p) == 6);
+        BOOST_TEST(back(p) == "mama mia");
+    }
+    
+    {
+        fusion::vector<int, float> v1(4, 3.3f);
+        std::pair<short, float> v2(5, 3.3f);
+        fusion::vector<long, double> v3(5, 4.4);
+        BOOST_TEST(v1 < v2);
+        BOOST_TEST(v1 <= v2);
+        BOOST_TEST(v2 > v1);
+        BOOST_TEST(v2 >= v1);
+        BOOST_TEST(v2 < v3);
+        BOOST_TEST(v2 <= v3);
+        BOOST_TEST(v3 > v2);
+        BOOST_TEST(v3 >= v2);
+    }
+
+    {
+        // conversion from pair to vector
+        fusion::vector<int, std::string> v(std::make_pair(123, "Hola!!!"));
+        v = std::make_pair(123, "Hola!!!");
+    }
+
+    {
+        // conversion from pair to list
+        fusion::list<int, std::string> l(std::make_pair(123, "Hola!!!"));
+        l = std::make_pair(123, "Hola!!!");
+    }
+
+    {
+        typedef std::pair<int, std::string> pair_type;
+        BOOST_MPL_ASSERT((mpl::is_sequence<pair_type>));
+        BOOST_MPL_ASSERT((boost::is_same<int, mpl::front<pair_type>::type>));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/std_tuple.cpp b/src/boost/libs/fusion/test/sequence/std_tuple.cpp
new file mode 100644
index 00000000..3d711071
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/std_tuple.cpp
@@ -0,0 +1,37 @@
+/*=============================================================================
+    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)
+==============================================================================*/
+
+#include <boost/config.hpp>
+
+// adapted/std_tuple.hpp only supports implementations using variadic templates
+#if defined(BOOST_NO_CXX11_HDR_TUPLE) || \
+    defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#   error "does not meet requirements"
+#endif
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/adapted/std_tuple.hpp>
+#include <boost/fusion/sequence/convert.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <tuple>
+#include <string>
+
+int main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    {
+        // conversion vector to std tuple
+        std::tuple<int, std::string> t = convert<std_tuple_tag>(make_vector(123, std::string("Hola!!!")));
+        BOOST_TEST(std::get<0>(t) == 123);
+        BOOST_TEST(std::get<1>(t) == "Hola!!!");
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/std_tuple_iterator.cpp b/src/boost/libs/fusion/test/sequence/std_tuple_iterator.cpp
new file mode 100644
index 00000000..df283331
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/std_tuple_iterator.cpp
@@ -0,0 +1,26 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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>
+
+// The std_tuple_iterator adaptor only supports implementations
+// using variadic templates
+#if defined(BOOST_NO_CXX11_HDR_TUPLE) || \
+    defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#   error "does not meet requirements"
+#endif
+
+#include <boost/fusion/adapted/std_tuple.hpp>
+
+#define FUSION_SEQUENCE std::tuple
+#define FUSION_TRAVERSAL_TAG random_access_traversal_tag
+#include "./iterator.hpp"
+
+int main()
+{
+    test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/swap.cpp b/src/boost/libs/fusion/test/sequence/swap.cpp
new file mode 100644
index 00000000..cac832b4
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/swap.cpp
@@ -0,0 +1,35 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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/swap.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <vector>
+
+int main()
+{
+    namespace fusion = boost::fusion;
+    {
+        typedef fusion::vector<std::vector<int>, char> test_vector;
+        BOOST_MPL_ASSERT((boost::is_same<void, boost::fusion::result_of::swap<test_vector, test_vector>::type>));
+
+        test_vector v1(std::vector<int>(1, 101), 'a'), v2(std::vector<int>(1, 202), 'b');
+
+        fusion::swap(v1, v2);
+
+        BOOST_TEST(v1 == fusion::make_vector(std::vector<int>(1, 202), 'b'));
+        BOOST_TEST(v2 == fusion::make_vector(std::vector<int>(1, 101), 'a'));
+    }
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/test_deduce_sequence.cpp b/src/boost/libs/fusion/test/sequence/test_deduce_sequence.cpp
new file mode 100644
index 00000000..d7a3b813
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/test_deduce_sequence.cpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 2009 Joel de Guzman
+
+    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/mpl/vector.hpp>
+#include <boost/fusion/support.hpp>
+
+typedef boost::fusion::traits::deduce_sequence < 
+
+boost::mpl::vector<int, char> 
+
+>::type seq1_t;
+
+
+typedef boost::fusion::traits::deduce_sequence < 
+
+boost::fusion::vector<int, char> 
+
+>::type seq2_t;
diff --git a/src/boost/libs/fusion/test/sequence/tie.hpp b/src/boost/libs/fusion/test/sequence/tie.hpp
new file mode 100644
index 00000000..536af1e9
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tie.hpp
@@ -0,0 +1,85 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+
+#if !defined(FUSION_AT)
+#define FUSION_AT at_c
+#endif
+
+#if !defined(FUSION_MAKE)
+#define FUSION_MAKE BOOST_PP_CAT(make_, FUSION_SEQUENCE)
+#endif
+
+#if !defined(FUSION_TIE)
+#define FUSION_TIE BOOST_PP_CAT(FUSION_SEQUENCE, _tie)
+#endif
+
+namespace test_detail
+{
+    // something to prevent warnings for unused variables
+    template<class T> void dummy(const T&) {}
+
+    // no public default constructor
+    class foo
+    {
+    public:
+
+        explicit foo(int v) : val(v) {}
+
+        bool operator==(const foo& other) const
+        {
+            return val == other.val;
+        }
+
+    private:
+
+        foo() {}
+        int val;
+    };
+}
+
+void
+test()
+{
+    using namespace boost::fusion;
+    using namespace test_detail;
+
+    int a;
+    char b;
+    foo c(5);
+
+    FUSION_TIE(a, b, c) = FUSION_MAKE(2, 'a', foo(3));
+    BOOST_TEST(a == 2);
+    BOOST_TEST(b == 'a');
+    BOOST_TEST(c == foo(3));
+
+    FUSION_TIE(a, ignore, c) = FUSION_MAKE((short int)5, false, foo(5));
+    BOOST_TEST(a == 5);
+    BOOST_TEST(b == 'a');
+    BOOST_TEST(c == foo(5));
+
+    int i, j;
+    FUSION_TIE(i, j) = FUSION_MAKE(1, 2);
+    BOOST_TEST(i == 1 && j == 2);
+
+    FUSION_SEQUENCE<int, int, float> ta;
+
+#if defined(FUSION_TEST_FAIL)
+    ta = std::FUSION_MAKE(1, 2); // should fail, tuple is of length 3, not 2
+#endif
+
+    dummy(ta);
+    
+    // ties cannot be rebound
+    int d = 3;
+    FUSION_SEQUENCE<int&> ti(a);
+    BOOST_TEST(&FUSION_AT<0>(ti) == &a);
+    ti = FUSION_SEQUENCE<int&>(d);
+    BOOST_TEST(&FUSION_AT<0>(ti) == &a);
+}
diff --git a/src/boost/libs/fusion/test/sequence/traits.hpp b/src/boost/libs/fusion/test/sequence/traits.hpp
new file mode 100644
index 00000000..3684604e
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/traits.hpp
@@ -0,0 +1,253 @@
+/*=============================================================================
+    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)
+==============================================================================*/
+
+#include <boost/config.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_constructible.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+struct convertible
+{
+    convertible(int) {}
+};
+
+template <typename From, typename To>
+bool is_convertible(bool has_conversion)
+{
+    typedef typename boost::remove_reference<
+        typename boost::remove_const<From>::type
+    >::type from_rvalue;
+    typedef typename boost::add_reference<from_rvalue>::type from_lvalue;
+    typedef typename boost::add_const<from_lvalue>::type from_const_lvalue;
+
+    return 
+        boost::is_convertible<from_rvalue, To>::value == has_conversion &&
+        boost::is_convertible<from_lvalue, To>::value == has_conversion &&
+        boost::is_convertible<from_const_lvalue, To>::value == has_conversion;
+}
+
+// is_constructible has a few requirements
+#ifdef BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING
+
+#define FUSION_TEST_HAS_CONSTRUCTIBLE
+
+template <typename To, typename... Args>
+bool is_lvalue_constructible(bool has_constructor)
+{
+    return has_constructor ==
+        boost::is_constructible<
+            To
+          , typename boost::add_reference<Args>::type...
+        >::value;
+}
+
+template <typename To, typename... Args>
+bool is_constructible_impl(bool has_constructor)
+{
+    return
+        boost::is_constructible<To, Args...>::value == has_constructor &&
+        is_lvalue_constructible<To, Args...>(has_constructor) &&
+        is_lvalue_constructible<
+            To, typename boost::add_const<Args>::type...
+        >(has_constructor);
+}
+
+template <typename To, typename... Args>
+bool is_constructible(bool has_constructor)
+{
+    return
+        is_constructible_impl<
+            To
+          , typename boost::remove_reference<
+                typename boost::remove_const<Args>::type
+            >::type...
+        >(has_constructor);
+}
+
+void test_constructible()
+{
+    BOOST_TEST((is_constructible< FUSION_SEQUENCE<> >(true)));
+
+    BOOST_TEST((is_constructible< FUSION_SEQUENCE<int> >(true)));
+    BOOST_TEST((is_constructible<FUSION_SEQUENCE<int>, int>(true)));
+
+    BOOST_TEST((is_constructible<FUSION_SEQUENCE<convertible>, int>(true)));
+    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)
+    ));
+
+    BOOST_TEST((
+        is_constructible<FUSION_SEQUENCE<convertible, int>, int, int>(true)
+    ));
+    BOOST_TEST((
+        is_constructible<
+            FUSION_SEQUENCE<convertible, int>, convertible, int
+        >(true)
+    ));
+    
+    BOOST_TEST((
+        is_constructible<FUSION_SEQUENCE<int, convertible>, int, int>(true)
+    ));
+    BOOST_TEST((
+        is_constructible<
+            FUSION_SEQUENCE<int, convertible>, int, convertible
+        >(true)
+    ));
+    
+    BOOST_TEST((
+        is_constructible<
+            FUSION_SEQUENCE<convertible, convertible>, int, int
+        >(true)
+    ));
+    BOOST_TEST((
+        is_constructible<
+            FUSION_SEQUENCE<convertible, convertible>, convertible, int
+        >(true)
+    ));
+    BOOST_TEST((
+        is_constructible<
+            FUSION_SEQUENCE<convertible, convertible>, int, convertible
+        >(true)
+    ));
+    BOOST_TEST((
+        is_constructible<
+            FUSION_SEQUENCE<convertible, convertible>, convertible, convertible
+        >(true)
+    ));
+#endif // !(gcc < 4.7)
+}
+
+#endif // is_constructible is available
+
+void test_convertible(bool has_seq_conversion)
+{
+    BOOST_TEST((is_convertible<int, FUSION_SEQUENCE<> >(false)));
+    BOOST_TEST((is_convertible<int, FUSION_SEQUENCE<int> >(false)));
+    BOOST_TEST((is_convertible<int, FUSION_SEQUENCE<const int&> >(false)));
+    BOOST_TEST((is_convertible<int, FUSION_SEQUENCE<convertible> >(false)));
+    BOOST_TEST((
+        is_convertible<int, FUSION_SEQUENCE<const convertible&> >(false)
+    ));
+    BOOST_TEST((is_convertible<int, FUSION_SEQUENCE<int, int> >(false)));
+    BOOST_TEST((
+        is_convertible<int, FUSION_SEQUENCE<const int&, const int&> >(false)
+    ));
+    BOOST_TEST((is_convertible<int, FUSION_SEQUENCE<convertible, int> >(false)));
+    BOOST_TEST((
+        is_convertible<int, FUSION_SEQUENCE<const convertible&, const int&> >(false)
+    ));
+    BOOST_TEST((is_convertible<int, FUSION_SEQUENCE<int, convertible> >(false)));
+    BOOST_TEST((
+        is_convertible<int, FUSION_SEQUENCE<const int&, const convertible&> >(false)
+    ));
+    BOOST_TEST((
+        is_convertible<int, FUSION_SEQUENCE<convertible, convertible> >(false)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            int, FUSION_SEQUENCE<const convertible&, const convertible&>
+        >(false)
+    ));
+
+    BOOST_TEST((is_convertible<FUSION_SEQUENCE<>, FUSION_SEQUENCE<> >(true)));
+    BOOST_TEST((
+        is_convertible<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int> >(true)
+    ));
+    BOOST_TEST((
+        is_convertible<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<const int&> >(true)
+    ));
+    BOOST_TEST((
+        is_convertible<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<convertible> >(true)
+    ));
+    BOOST_TEST((
+        is_convertible<FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<int, int> >(true)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<const int&, const int&>
+        >(true)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<convertible, int>
+        >(true)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<int, convertible>
+        >(true)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_SEQUENCE<int, int>
+          , FUSION_SEQUENCE<convertible, convertible>
+        >(true)
+    ));
+
+    BOOST_TEST((
+        is_convertible<
+            FUSION_ALT_SEQUENCE<>, FUSION_SEQUENCE<>
+        >(has_seq_conversion)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_ALT_SEQUENCE<int>, FUSION_SEQUENCE<int>
+        >(has_seq_conversion)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_ALT_SEQUENCE<int>, FUSION_SEQUENCE<const int&>
+        >(has_seq_conversion)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_ALT_SEQUENCE<int>, FUSION_SEQUENCE<convertible>
+        >(has_seq_conversion)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_ALT_SEQUENCE<int, int>, FUSION_SEQUENCE<int, int>
+        >(has_seq_conversion)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_ALT_SEQUENCE<int, int>
+          , FUSION_SEQUENCE<const int&, const int&>
+        >(has_seq_conversion)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_ALT_SEQUENCE<int, int>, FUSION_SEQUENCE<convertible, int>
+        >(has_seq_conversion)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_ALT_SEQUENCE<int, int>, FUSION_SEQUENCE<int, convertible>
+        >(has_seq_conversion)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            FUSION_ALT_SEQUENCE<int, int>
+          , FUSION_SEQUENCE<convertible, convertible>
+        >(has_seq_conversion)
+    ));
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/transform_view.cpp b/src/boost/libs/fusion/test/sequence/transform_view.cpp
new file mode 100644
index 00000000..b9e3f943
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/transform_view.cpp
@@ -0,0 +1,115 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector/vector.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/sequence/io/out.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/view/transform_view/transform_view.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/prior.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+
+#include <boost/mpl/range_c.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+struct square
+{
+    template<typename T>
+    struct result;
+
+    template <typename T>
+    struct result<square(T)>
+    {
+        typedef int type;
+    };
+
+    template <typename T>
+    int operator()(T x) const
+    {
+        return x * x;
+    }
+};
+
+struct add
+{
+    template<typename T>
+    struct result;
+
+    template <typename A, typename B>
+    struct result<add(A,B)>
+    {
+        typedef int type;
+    };
+
+    template <typename A, typename B>
+    int operator()(A a, B b) const
+    {
+        return a + b;
+    }
+};
+
+int
+main()
+{
+    using namespace boost::fusion;
+
+    std::cout << tuple_open('[');
+    std::cout << tuple_close(']');
+    std::cout << tuple_delimiter(", ");
+
+/// Testing the transform_view
+
+    {
+        typedef boost::mpl::range_c<int, 5, 9> sequence_type;
+        sequence_type sequence;
+        square sq;
+        typedef transform_view<sequence_type, square> xform_type;
+        xform_type xform(sequence, sq);
+
+        std::cout << xform << std::endl;
+        BOOST_TEST((xform == make_vector(25, 36, 49, 64)));
+
+        typedef boost::fusion::result_of::begin<xform_type>::type first_type;
+        first_type first_it(boost::fusion::begin(xform));
+
+        typedef boost::fusion::result_of::next<first_type>::type next_type;
+        next_type next_it(boost::fusion::next(first_it));
+        BOOST_TEST((*next_it == 36));
+        BOOST_TEST((*boost::fusion::prior(next_it) == 25));
+        BOOST_TEST((boost::fusion::distance(first_it, next_it) == 1));
+
+        BOOST_TEST((*boost::fusion::advance_c<3>(boost::fusion::begin(xform)) == 64));
+        BOOST_TEST((boost::fusion::at_c<2>(xform) == 49));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_c<xform_type, 0>::type, int>));
+    }
+    
+    {
+        typedef boost::mpl::range_c<int, 5, 9> sequence1_type;
+        typedef boost::mpl::range_c<int, 10, 14> sequence2_type;
+        sequence1_type sequence1;
+        sequence2_type sequence2;
+        add f;
+        typedef transform_view<sequence1_type, sequence2_type, add> xform_type;
+        xform_type xform(sequence1, sequence2, f);
+
+        std::cout << xform << std::endl;
+        BOOST_TEST((xform == make_vector(15, 17, 19, 21)));
+        BOOST_TEST((boost::fusion::at_c<2>(xform) == 19));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_c<xform_type, 0>::type, int>));
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/tree.hpp b/src/boost/libs/fusion/test/sequence/tree.hpp
new file mode 100644
index 00000000..a345a8f1
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tree.hpp
@@ -0,0 +1,100 @@
+/*=============================================================================
+   Copyright (c) 2006 Eric Niebler
+
+   Use, modification and distribution is subject to 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 FUSION_BINARY_TREE_EAN_05032006_1027
+#define FUSION_BINARY_TREE_EAN_05032006_1027
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/view/single_view.hpp>
+#include <boost/fusion/container/list/cons.hpp> // for nil
+#include <boost/fusion/container/vector/vector10.hpp>
+#include <boost/fusion/support/sequence_base.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/fusion/sequence/intrinsic/segments.hpp>
+
+namespace boost { namespace fusion
+{
+   struct tree_tag;
+
+   template <typename Data, typename Left = nil, typename Right = nil>
+   struct tree
+     : sequence_base<tree<Data, Left, Right> >
+   {
+       typedef Data data_type;
+       typedef Left left_type;
+       typedef Right right_type;
+       typedef tree_tag fusion_tag;
+       typedef forward_traversal_tag category;
+       typedef mpl::false_ is_view;
+
+       typedef typename mpl::if_<
+           traits::is_sequence<Data>
+         , Data
+         , single_view<Data>
+       >::type data_view;
+
+       explicit tree(
+           typename fusion::detail::call_param<Data>::type data_
+         , typename fusion::detail::call_param<Left>::type left_ = Left()
+         , typename fusion::detail::call_param<Right>::type right_ = Right()
+       )
+         : segments(left_, data_view(data_), right_)
+       {}
+
+       typedef vector3<Left, data_view, Right> segments_type;
+       segments_type segments;
+   };
+
+   template <typename Data>
+   tree<Data> make_tree(Data const &data)
+   {
+       return tree<Data>(data);
+   }
+
+   template <typename Data, typename Left, typename Right>
+   tree<Data, Left, Right> make_tree(Data const &data, Left const &left, Right const &right)
+   {
+       return tree<Data, Left, Right>(data, left, right);
+   }
+
+   namespace extension
+   {
+       template <>
+       struct is_segmented_impl<tree_tag>
+       {
+           template <typename Sequence>
+           struct apply : mpl::true_ {};
+       };
+
+       template <>
+       struct segments_impl<tree_tag>
+       {
+           template <typename Sequence>
+           struct apply
+           {
+               typedef typename mpl::if_<
+                   is_const<Sequence>
+                 , typename Sequence::segments_type const &
+                 , typename Sequence::segments_type &
+               >::type type;
+
+               static type call(Sequence &seq)
+               {
+                   return seq.segments;
+               }
+           };
+       };
+   }
+}}
+
+#endif
diff --git a/src/boost/libs/fusion/test/sequence/tuple_comparison.cpp b/src/boost/libs/fusion/test/sequence/tuple_comparison.cpp
new file mode 100644
index 00000000..2b443306
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_comparison.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+
+#define FUSION_SEQUENCE tuple
+#include "comparison.hpp"
+
+int
+main()
+{
+    equality_test();
+    ordering_test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/tuple_construction.cpp b/src/boost/libs/fusion/test/sequence/tuple_construction.cpp
new file mode 100644
index 00000000..12772027
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_construction.cpp
@@ -0,0 +1,49 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+
+#define NO_CONSTRUCT_FROM_NIL
+#define FUSION_SEQUENCE tuple
+#define FUSION_AT get
+#include "construction.hpp"
+
+// Bug in C++03 tuple? Cannot construct from a std::pair without including
+// std::pair fusion adaption
+#if !defined(BOOST_FUSION_HAS_VARIADIC_TUPLE)
+# include <boost/fusion/adapted/std_pair.hpp>
+#endif
+
+struct test_conversion
+{
+    test_conversion(int value) : value_(value) {}
+
+    int value_;
+};
+
+int
+main()
+{
+    test();
+
+    {
+        using namespace boost::fusion;
+        const tuple<int, test_conversion> instance(std::pair<int, int>(1, 9));
+        BOOST_TEST(boost::fusion::get<0>(instance) == 1);
+        BOOST_TEST(boost::fusion::get<1>(instance).value_ == 9);
+    }
+    {
+        using namespace boost::fusion;
+        const std::pair<int, int> init(16, 4);
+        const tuple<int, test_conversion> instance(init);
+        BOOST_TEST(boost::fusion::get<0>(instance) == 16);
+        BOOST_TEST(boost::fusion::get<1>(instance).value_ == 4);
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/tuple_conversion.cpp b/src/boost/libs/fusion/test/sequence/tuple_conversion.cpp
new file mode 100644
index 00000000..861365de
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_conversion.cpp
@@ -0,0 +1,51 @@
+/*=============================================================================
+    Copyright (c) 2016 Lee Clagett
+
+    Use modification and distribution are subject to the Boost Software
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/tuple.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::tuple
+#include "conversion.hpp"
+
+// Bug in C++03 tuple? Cannot construct from a std::pair without including
+// std::pair fusion adaption
+#if !defined(BOOST_FUSION_HAS_VARIADIC_TUPLE)
+# include <boost/fusion/adapted/std_pair.hpp>
+#endif
+
+using namespace test_detail;
+
+void test_tuple()
+{
+    BOOST_TEST((
+        run< can_copy< boost::fusion::tuple<int, int> > >(
+            std::pair<int, int>(1, 9)
+        )
+    ));
+    BOOST_TEST((
+        run< can_copy< boost::fusion::tuple<int, convertible> > >(
+            std::pair<int, int>(1, 9)
+        )
+    ));
+    BOOST_TEST((
+        run< can_copy< boost::fusion::tuple<convertible, int> > >(
+            std::pair<int, int>(1, 9)
+        )
+    ));
+    BOOST_TEST((
+        run< can_copy< boost::fusion::tuple<convertible, convertible> > >(
+            std::pair<int, int>(1, 9)
+        )
+    ));
+}
+
+int main()
+{
+    test<can_assign>(); // conversion construction not supported
+    test_tuple();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/tuple_copy.cpp b/src/boost/libs/fusion/test/sequence/tuple_copy.cpp
new file mode 100644
index 00000000..01297387
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_copy.cpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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.hpp>
+
+#define FUSION_SEQUENCE tuple
+#define FUSION_AT get
+#define FUSION_MAKE make_tuple
+#define FUSION_TIE tie
+#include "copy.hpp"
+
+int
+main()
+{
+    test<test_detail::can_copy>();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/tuple_element.cpp b/src/boost/libs/fusion/test/sequence/tuple_element.cpp
new file mode 100644
index 00000000..0932e627
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_element.cpp
@@ -0,0 +1,21 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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.hpp>
+
+#define FUSION_SEQUENCE tuple
+#define FUSION_AT get
+#define FUSION_VALUE_AT(S, N) tuple_element<N, S>
+#include "value_at.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/tuple_hash.cpp b/src/boost/libs/fusion/test/sequence/tuple_hash.cpp
new file mode 100644
index 00000000..e8f604ef
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_hash.cpp
@@ -0,0 +1,16 @@
+/*=============================================================================
+    Copyright (c) 2014 Christoph Weiss
+
+    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.hpp>
+
+#define FUSION_SEQUENCE tuple
+#include "hash.hpp"
+
+int main()
+{
+    hash_test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/tuple_make.cpp b/src/boost/libs/fusion/test/sequence/tuple_make.cpp
new file mode 100644
index 00000000..1a453b62
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_make.cpp
@@ -0,0 +1,21 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::tuple
+#define FUSION_AT get
+#define FUSION_MAKE boost::fusion::make_tuple
+#include "make.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/tuple_misc.cpp b/src/boost/libs/fusion/test/sequence/tuple_misc.cpp
new file mode 100644
index 00000000..473efb61
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_misc.cpp
@@ -0,0 +1,23 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+
+#define FUSION_SEQUENCE tuple
+#define FUSION_AT get
+#define FUSION_SIZE tuple_size
+#include "misc.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/tuple_mutate.cpp b/src/boost/libs/fusion/test/sequence/tuple_mutate.cpp
new file mode 100644
index 00000000..b6e72a61
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_mutate.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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.hpp>
+
+#define FUSION_SEQUENCE tuple
+#define FUSION_AT get
+#include "mutate.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/tuple_nest.cpp b/src/boost/libs/fusion/test/sequence/tuple_nest.cpp
new file mode 100644
index 00000000..3344c523
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_nest.cpp
@@ -0,0 +1,35 @@
+/*=============================================================================
+    Copyright (C) 2015 Kohei Takahshi
+
+    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.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::tuple
+#include "nest.hpp"
+
+
+// tuple does not support conversion construction from sequence by design
+template <typename T>
+struct skip_constructor_conversion
+{
+    template <typename Source, typename Expected>
+    bool operator()(Source const& source, Expected const& expected) const
+    {
+        using namespace test_detail;
+        return
+            run< can_copy<T> >(source, expected) &&
+            run< can_convert_using<can_assign>::to<T> >(source, expected) &&
+            run< can_construct_from_elements<T> >(source, expected);            
+    }
+};
+
+int
+main()
+{
+    test<skip_constructor_conversion>();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/tuple_tie.cpp b/src/boost/libs/fusion/test/sequence/tuple_tie.cpp
new file mode 100644
index 00000000..2d5ec24f
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_tie.cpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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.hpp>
+
+#define FUSION_SEQUENCE tuple
+#define FUSION_AT get
+#define FUSION_MAKE make_tuple
+#define FUSION_TIE tie
+#include "tie.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/tuple_traits.cpp b/src/boost/libs/fusion/test/sequence/tuple_traits.cpp
new file mode 100644
index 00000000..f065504a
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/tuple_traits.cpp
@@ -0,0 +1,89 @@
+/*=============================================================================
+    Copyright (c) 2016 Lee Clagett
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/tuple/tuple.hpp>
+#include <boost/config.hpp>
+#include <boost/type_traits/is_constructible.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::tuple
+#define FUSION_ALT_SEQUENCE boost::fusion::vector
+#include "traits.hpp"
+
+struct not_convertible {};
+
+/*  Some construction differences in fusion::tuple from std::tuple:
+      - Construction from elements cannot call an explicit constructor.
+      - There is no implicit construction from elements.
+      - Construction from std::pair is _enabled_ when tuple is not of size 2.
+      - Construction from tuple is _enabled_ when destination tuple is of
+        different size.
+      - Implicit construction from std::pair can call explicit constructors on
+        elements.
+      - Implicit construction from tuple can call explicit constructors on
+        elements.
+
+    These differences are historical. Matching the behavior of std::tuple
+    could break existing code, however, switching to fusion::vector would
+    restore the historical behavior. */
+int
+main()
+{
+    using namespace boost::fusion;
+
+    test_convertible(false /* no conversion construction */ );
+
+    BOOST_TEST((is_convertible<std::pair<int, int>, tuple<int, int> >(true)));
+    BOOST_TEST((
+        is_convertible<std::pair<int, int>, tuple<convertible, int> >(true)
+    ));
+    BOOST_TEST((
+        is_convertible<std::pair<int, int>, tuple<int, convertible> >(true)
+    ));
+    BOOST_TEST((
+        is_convertible<
+            std::pair<int, int>, tuple<convertible, convertible>
+        >(true)
+    ));
+
+#if defined(FUSION_TEST_HAS_CONSTRUCTIBLE)
+    test_constructible();
+
+    BOOST_TEST((is_constructible< tuple<> >(true)));
+    BOOST_TEST((is_constructible<tuple<>, int>(false)));
+
+    BOOST_TEST((is_constructible< tuple<int> >(true)));
+    BOOST_TEST((is_constructible<tuple<int>, int>(true)));
+    BOOST_TEST((is_constructible<tuple<convertible>, int>(true)));
+    BOOST_TEST((is_constructible<tuple<not_convertible>, int>(false)));
+    BOOST_TEST((is_constructible< tuple<int>, vector<int> >(false)));
+    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((
+        is_constructible<tuple<not_convertible, not_convertible>, int, int>(false)
+    ));
+#if defined(BOOST_FUSION_HAS_VARIADIC_VECTOR)
+    // C++03 fusion::tuple has constructors that can never be used
+    BOOST_TEST((is_constructible<tuple<int, int>, int>(false)));
+#endif
+    BOOST_TEST((is_constructible<tuple<int, int>, int, int, int>(false)));
+
+#endif // FUSION_TEST_HAS_CONSTRUCTIBLE
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/value_at.hpp b/src/boost/libs/fusion/test/sequence/value_at.hpp
new file mode 100644
index 00000000..ae03dd3c
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/value_at.hpp
@@ -0,0 +1,100 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#include <functional>
+#endif
+
+#if !defined(FUSION_AT)
+#define FUSION_AT at_c
+#endif
+
+#if !defined(FUSION_VALUE_AT)
+#define FUSION_VALUE_AT(S, N) boost::fusion::result_of::value_at_c<S, N>
+#endif
+
+namespace test_detail
+{
+    // something to prevent warnings for unused variables
+    template<class T> void dummy(const T&) {}
+
+    class A {};
+}
+
+void
+test()
+{
+    using namespace boost::fusion;
+    using namespace test_detail;
+
+    double d = 2.7;
+    A a;
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    // Note: C++11 will pickup the rvalue overload for the d argument
+    // since we do not have all permutations (expensive!) for all const&
+    // and && arguments. We either have all && or all const& arguments only.
+    // For that matter, use std::ref to disambiguate the call.
+
+    FUSION_SEQUENCE<int, double&, const A&, int> t(1, std::ref(d), a, 2);
+#else
+    FUSION_SEQUENCE<int, double&, const A&, int> t(1, d, a, 2);
+#endif
+    const FUSION_SEQUENCE<int, double&, const A, int> ct(t);
+
+    int i  = FUSION_AT<0>(t);
+    int i2 = FUSION_AT<3>(t);
+
+    BOOST_TEST(i == 1 && i2 == 2);
+
+    int j  = FUSION_AT<0>(ct);
+    BOOST_TEST(j == 1);
+
+    FUSION_AT<0>(t) = 5;
+    BOOST_TEST(FUSION_AT<0>(t) == 5);
+
+#if defined(FUSION_TEST_FAIL)
+    FUSION_AT<0>(ct) = 5; // can't assign to const
+#endif
+
+    double e = FUSION_AT<1>(t);
+    BOOST_TEST(e > 2.69 && e < 2.71);
+
+    FUSION_AT<1>(t) = 3.14+i;
+    BOOST_TEST(FUSION_AT<1>(t) > 4.13 && FUSION_AT<1>(t) < 4.15);
+
+#if defined(FUSION_TEST_FAIL)
+    FUSION_AT<4>(t) = A(); // can't assign to const
+    dummy(FUSION_AT<5>(ct)); // illegal index
+#endif
+
+    ++FUSION_AT<0>(t);
+    BOOST_TEST(FUSION_AT<0>(t) == 6);
+
+    typedef FUSION_SEQUENCE<int, float> seq_type;
+
+    BOOST_STATIC_ASSERT(!(
+        boost::is_const<FUSION_VALUE_AT(seq_type, 0)::type>::value));
+
+    // constness should not affect
+    BOOST_STATIC_ASSERT(!(
+        boost::is_const<FUSION_VALUE_AT(const seq_type, 0)::type>::value));
+
+    BOOST_STATIC_ASSERT(!(
+        boost::is_const<FUSION_VALUE_AT(seq_type, 1)::type>::value));
+
+    // constness should not affect
+    BOOST_STATIC_ASSERT(!(
+        boost::is_const<FUSION_VALUE_AT(const seq_type, 1)::type>::value));
+
+    dummy(i); dummy(i2); dummy(j); dummy(e); // avoid warns for unused variables
+}
diff --git a/src/boost/libs/fusion/test/sequence/vector_comparison.cpp b/src/boost/libs/fusion/test/sequence/vector_comparison.cpp
new file mode 100644
index 00000000..c23db833
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_comparison.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/vector.hpp>
+
+#define FUSION_SEQUENCE vector
+#include "comparison.hpp"
+
+int
+main()
+{
+    equality_test();
+    ordering_test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/vector_construction.cpp b/src/boost/libs/fusion/test/sequence/vector_construction.cpp
new file mode 100644
index 00000000..8af5bc04
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_construction.cpp
@@ -0,0 +1,18 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/vector.hpp>
+
+#define FUSION_SEQUENCE vector
+#include "construction.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/vector_conversion.cpp b/src/boost/libs/fusion/test/sequence/vector_conversion.cpp
new file mode 100644
index 00000000..1ffd77cc
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_conversion.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 2016 Lee Clagett
+
+    Use modification and distribution are subject to the Boost Software
+    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt).
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::vector
+#include "conversion.hpp"
+
+int main()
+{
+    test<test_detail::can_copy>();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/vector_copy.cpp b/src/boost/libs/fusion/test/sequence/vector_copy.cpp
new file mode 100644
index 00000000..8a4d26ce
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_copy.cpp
@@ -0,0 +1,21 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/container/generation/vector_tie.hpp>
+
+#define FUSION_SEQUENCE vector
+#include "copy.hpp"
+
+int
+main()
+{
+    test<test_detail::can_copy>();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/vector_hash.cpp b/src/boost/libs/fusion/test/sequence/vector_hash.cpp
new file mode 100644
index 00000000..6b6dcd24
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_hash.cpp
@@ -0,0 +1,16 @@
+/*=============================================================================
+    Copyright (c) 2014 Christoph Weiss
+
+    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/vector.hpp>
+
+#define FUSION_SEQUENCE vector 
+#include "hash.hpp"
+
+int main()
+{
+    hash_test();
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/vector_iterator.cpp b/src/boost/libs/fusion/test/sequence/vector_iterator.cpp
new file mode 100644
index 00000000..a2ca7df7
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_iterator.cpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/vector.hpp>
+#include <boost/fusion/container/vector/vector_iterator.hpp>
+
+#define FUSION_SEQUENCE vector
+#define FUSION_TRAVERSAL_TAG random_access_traversal_tag
+#include "./iterator.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
+
+
diff --git a/src/boost/libs/fusion/test/sequence/vector_make.cpp b/src/boost/libs/fusion/test/sequence/vector_make.cpp
new file mode 100644
index 00000000..8a687354
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_make.cpp
@@ -0,0 +1,20 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/vector.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+
+#define FUSION_SEQUENCE vector
+#include "make.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/vector_misc.cpp b/src/boost/libs/fusion/test/sequence/vector_misc.cpp
new file mode 100644
index 00000000..e2b27396
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_misc.cpp
@@ -0,0 +1,21 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+
+#define FUSION_SEQUENCE vector
+#include "misc.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/vector_move.cpp b/src/boost/libs/fusion/test/sequence/vector_move.cpp
new file mode 100644
index 00000000..3e9f0b6a
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_move.cpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 2012 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)
+==============================================================================*/
+#define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+#include <boost/fusion/container/vector/vector.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::vector<std::vector<x>>
+#define FUSION_SEQUENCE2 boost::fusion::vector<std::vector<x>, x>
+
+#include "move.hpp"
+
+int main()
+{
+    test();
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/vector_mutate.cpp b/src/boost/libs/fusion/test/sequence/vector_mutate.cpp
new file mode 100644
index 00000000..448bbf76
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_mutate.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/vector.hpp>
+
+#define FUSION_SEQUENCE vector
+#include "mutate.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/vector_n.cpp b/src/boost/libs/fusion/test/sequence/vector_n.cpp
new file mode 100644
index 00000000..65e1032d
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_n.cpp
@@ -0,0 +1,231 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector/vector10.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/value_at.hpp>
+
+#include <boost/fusion/container/vector/vector20.hpp>
+#include <boost/fusion/container/vector/vector30.hpp>
+#include <boost/fusion/container/vector/vector40.hpp>
+#include <boost/fusion/container/vector/vector50.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_empty.hpp>
+#include <boost/static_assert.hpp>
+#include <iostream>
+
+#include <boost/fusion/algorithm/transformation/push_back.hpp>
+#include <boost/mpl/vector_c.hpp>
+
+
+int
+main()
+{
+    using namespace boost::fusion;
+    using namespace boost;
+
+    {
+        vector0<> vec;
+        (void) vec;
+        std::cout << "(): " << sizeof(vec) << std::endl;
+        std::cout << (boost::is_empty<vector0<> >::value ? "is empty" : "is not empty") << std::endl;
+    }
+
+    {
+        typedef vector1<int> type;
+        type vec;
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<type>::value == 1);
+
+        BOOST_TEST(at_c<0>(vec) == 0);
+        BOOST_STATIC_ASSERT((boost::is_same<int, boost::fusion::result_of::value_at_c<type, 0>::type>::value));
+
+        // prove that it is mutable
+        at_c<0>(vec) = 987;
+        BOOST_TEST(at_c<0>(vec) == 987);
+    }
+
+    {
+        typedef vector1<int> type;
+        type vec(123);
+        BOOST_TEST(at_c<0>(vec) == 123);
+        std::cout << "(int): " << sizeof(vec) << std::endl;
+    }
+
+    { // testing const vector
+        vector1<short> const vec(999);
+        BOOST_TEST(at_c<0>(vec) == 999);
+
+#ifdef FUSION_TEST_COMPILE_FAIL
+        at_c<0>(vec) = 321;
+#endif
+    }
+
+    {
+        vector1<int> t1(123L); // try conversion from long to int
+        vector1<double> t2(t1); // try copy
+        (void)t2;
+    }
+
+    {
+        typedef vector2<int, char> type;
+        type vec;
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<type>::value == 2);
+
+        BOOST_TEST(at_c<0>(vec) == 0);
+        BOOST_TEST(at_c<1>(vec) == char());
+
+        BOOST_STATIC_ASSERT((boost::is_same<int, boost::fusion::result_of::value_at_c<type, 0>::type>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<char, boost::fusion::result_of::value_at_c<type, 1>::type>::value));
+    }
+
+    {
+        typedef vector2<int, char> type;
+        type vec(123, 'x');
+        BOOST_TEST(at_c<0>(vec) == 123);
+        BOOST_TEST(at_c<1>(vec) == 'x');
+        std::cout << "(int, char): " << sizeof(vec) << std::endl;
+    }
+
+    {
+        vector2<int, short> t1(123, 456);
+        vector2<double, float> t2(t1);
+        (void)t2;
+    }
+
+    {
+        typedef vector3<int, char, double> type;
+        type vec;
+        BOOST_STATIC_ASSERT(boost::fusion::result_of::size<type>::value == 3);
+
+        BOOST_TEST(at_c<0>(vec) == 0);
+        BOOST_TEST(at_c<1>(vec) == char());
+        BOOST_TEST(at_c<2>(vec) == double());
+
+        BOOST_STATIC_ASSERT((boost::is_same<int, boost::fusion::result_of::value_at_c<type, 0>::type>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<char, boost::fusion::result_of::value_at_c<type, 1>::type>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<double, boost::fusion::result_of::value_at_c<type, 2>::type>::value));
+    }
+
+    {
+        typedef vector3<int, char, double> type;
+        type vec(123, 'x', 123.456);
+        BOOST_TEST(at_c<0>(vec) == 123);
+        BOOST_TEST(at_c<1>(vec) == 'x');
+        BOOST_TEST(at_c<2>(vec) >= 123.455 && at_c<2>(vec) <= 123.457);
+        std::cout << "(int, char, double): " << sizeof(vec) << std::endl;
+    }
+
+    {
+        typedef vector4<int, char, double, bool> type;
+        type vec(123, 'x', 123.456, true);
+        std::cout << "(int, char, double, bool): " << sizeof(vec) << std::endl;
+    }
+
+    {
+        typedef vector4<int, char, bool, double> type;
+        type vec(123, 'x', true, 123.456);
+        std::cout << "(int, char, bool, double): " << sizeof(vec) << std::endl;
+    }
+
+    {
+        typedef vector7<bool, char, short, int, long, float, double> type;
+        type vec(false, 'x', 3, 4, 5, 6.f, 7.0);
+
+        BOOST_TEST(at_c<0>(vec) == false);
+        BOOST_TEST(at_c<1>(vec) == 'x');
+        BOOST_TEST(at_c<2>(vec) == 3);
+        BOOST_TEST(at_c<3>(vec) == 4);
+        BOOST_TEST(at_c<4>(vec) == 5);
+        BOOST_TEST(at_c<5>(vec) >= 5.9 && at_c<5>(vec) <= 6.1);
+        BOOST_TEST(at_c<6>(vec) >= 6.9 && at_c<6>(vec) <= 7.1);
+
+        BOOST_STATIC_ASSERT((boost::is_same<bool, boost::fusion::result_of::value_at_c<type, 0>::type>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<char, boost::fusion::result_of::value_at_c<type, 1>::type>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<short, boost::fusion::result_of::value_at_c<type, 2>::type>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<int, boost::fusion::result_of::value_at_c<type, 3>::type>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<long, boost::fusion::result_of::value_at_c<type, 4>::type>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<float, boost::fusion::result_of::value_at_c<type, 5>::type>::value));
+        BOOST_STATIC_ASSERT((boost::is_same<double, boost::fusion::result_of::value_at_c<type, 6>::type>::value));
+        std::cout << "(bool, char, short, int, long, float, double): " << sizeof(vec) << std::endl;
+    }
+
+    {
+        typedef vector10<int, int, int, int, int, int, int, int, int, int> type;
+        type vec; // compile check only
+        std::cout << "vector10 of int: " << sizeof(vec) << std::endl;
+    }
+
+    {
+        typedef vector20<
+            int, int, int, int, int, int, int, int, int, int
+          , int, int, int, int, int, int, int, int, int, int> type;
+
+        type vec; // compile check only
+        std::cout << "vector20 of int: " << sizeof(vec) << std::endl;
+    }
+
+    {
+        typedef vector30<
+            int, int, int, int, int, int, int, int, int, int
+          , int, int, int, int, int, int, int, int, int, int
+          , int, int, int, int, int, int, int, int, int, int> type;
+
+        type vec; // compile check only
+        std::cout << "vector30 of int: " << sizeof(vec) << std::endl;
+    }
+
+    {
+        typedef vector40<
+            int, int, int, int, int, int, int, int, int, int
+          , int, int, int, int, int, int, int, int, int, int
+          , int, int, int, int, int, int, int, int, int, int
+          , int, int, int, int, int, int, int, int, int, int> type;
+
+        type vec; // compile check only
+        std::cout << "vector40 of int: " << sizeof(vec) << std::endl;
+    }
+
+    {
+        typedef vector50<
+            int, int, int, int, int, int, int, int, int, int
+          , int, int, int, int, int, int, int, int, int, int
+          , int, int, int, int, int, int, int, int, int, int
+          , int, int, int, int, int, int, int, int, int, int
+          , int, int, int, int, int, int, int, int, int, int> type;
+
+        type vec; // compile check only
+        std::cout << "vector50 of int: " << sizeof(vec) << std::endl;
+    }
+    
+    {
+        // testing copy and assign from a view
+        vector0<> empty;
+        fusion::vector2<int, long> v(fusion::push_back(fusion::push_back(empty, 123), 456));
+        BOOST_TEST(at_c<0>(v) == 123);
+        BOOST_TEST(at_c<1>(v) == 456);
+        v = fusion::push_back(fusion::push_back(empty, 123), 456); // test assign
+        BOOST_TEST(at_c<0>(v) == 123);
+        BOOST_TEST(at_c<1>(v) == 456);
+    }
+
+    {
+        // testing copy and assign from a vector_c
+        mpl::vector_c<int, 123, 456> vec_c;
+        fusion::vector2<int, long> v(vec_c);
+        BOOST_TEST(at_c<0>(v) == 123);
+        BOOST_TEST(at_c<1>(v) == 456);
+        v = mpl::vector_c<int, 123, 456>(); // test assign
+        BOOST_TEST(at_c<0>(v) == 123);
+        BOOST_TEST(at_c<1>(v) == 456);
+    }
+
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/vector_nest.cpp b/src/boost/libs/fusion/test/sequence/vector_nest.cpp
new file mode 100644
index 00000000..2627b3d7
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_nest.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (C) 2015 Kohei Takahshi
+
+    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/vector.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::vector
+#include "nest.hpp"
+
+int
+main()
+{
+    test<test_detail::can_nest>();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/vector_tie.cpp b/src/boost/libs/fusion/test/sequence/vector_tie.cpp
new file mode 100644
index 00000000..123bf888
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_tie.cpp
@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/vector.hpp>
+#include <boost/fusion/container/generation/vector_tie.hpp>
+#include <boost/fusion/container/generation/ignore.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+
+#define FUSION_SEQUENCE vector
+#include "tie.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/vector_traits.cpp b/src/boost/libs/fusion/test/sequence/vector_traits.cpp
new file mode 100644
index 00000000..470f11e6
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_traits.cpp
@@ -0,0 +1,32 @@
+/*=============================================================================
+    Copyright (C) 2016 Lee Clagett
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/vector.hpp>
+
+#define FUSION_SEQUENCE boost::fusion::vector
+#define FUSION_ALT_SEQUENCE boost::fusion::list
+#include "traits.hpp"
+
+int main() {
+    test_convertible(true /* has conversion construction */ );
+
+    // C++11 models overly aggressive (bug) implicit conversion from C++03
+    BOOST_TEST((
+        is_convertible<
+            boost::fusion::list<int>
+          , boost::fusion::vector< boost::fusion::list<int> >
+        >(true)
+    ));
+
+#if defined(FUSION_TEST_HAS_CONSTRUCTIBLE)
+    test_constructible();
+#endif
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/vector_value_at.cpp b/src/boost/libs/fusion/test/sequence/vector_value_at.cpp
new file mode 100644
index 00000000..191da4cf
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/vector_value_at.cpp
@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 1999-2003 Jaakko Jarvi
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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/vector.hpp>
+
+#define FUSION_SEQUENCE vector
+#include "value_at.hpp"
+
+int
+main()
+{
+    test();
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/zip_view.cpp b/src/boost/libs/fusion/test/sequence/zip_view.cpp
new file mode 100644
index 00000000..83bfa879
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/zip_view.cpp
@@ -0,0 +1,87 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/view/zip_view.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/prior.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/vector_c.hpp>
+
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+
+int main()
+{
+    using namespace boost::fusion;
+    {
+        typedef vector2<int,int> int_vector;
+        typedef vector2<char,char> char_vector;
+        typedef vector<int_vector&, char_vector&> seqs_type;
+        typedef zip_view<seqs_type> view;
+
+        BOOST_MPL_ASSERT((boost::mpl::equal_to<boost::fusion::result_of::size<view>::type, boost::fusion::result_of::size<int_vector>::type>));
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::size<view>::value == 2));
+
+        int_vector iv(1,2);
+        char_vector cv('a', 'b');
+        seqs_type seqs(iv, cv);
+        view v(seqs);
+
+        BOOST_TEST(at_c<0>(v) == make_vector(1, 'a'));
+        BOOST_TEST(at_c<1>(v) == make_vector(2, 'b'));
+        BOOST_TEST(front(v) == make_vector(1, 'a'));
+        BOOST_TEST(back(v) == make_vector(2, 'b'));
+        BOOST_TEST(*next(begin(v)) == make_vector(2, 'b'));
+        BOOST_TEST(*prior(end(v)) == make_vector(2, 'b'));
+        BOOST_TEST(advance_c<2>(begin(v)) == end(v));
+        BOOST_TEST(advance_c<-2>(end(v)) == begin(v));
+        BOOST_TEST(distance(begin(v), end(v)) == 2);
+
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::distance<boost::fusion::result_of::begin<view>::type, boost::fusion::result_of::end<view>::type>::value == 2));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_c<view,0>::type, vector2<int,char> >));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_of<boost::fusion::result_of::begin<view>::type>::type, vector2<int,char> >));
+    }
+    {
+        using namespace boost;
+        typedef mpl::vector2<int,bool> v1_type;
+        typedef mpl::vector2<char,long> v2_type;
+        typedef fusion::vector<v1_type&, v2_type&> seqs_type;
+        typedef fusion::zip_view<seqs_type> view;
+
+        v1_type v1;
+        v2_type v2;
+        seqs_type seqs(v1,v2);
+        view v(seqs);
+        BOOST_TEST((fusion::at_c<0>(v) == mpl::vector2<int,char>()));
+        BOOST_TEST((fusion::at_c<1>(v) == mpl::vector2<bool,long>()));
+        BOOST_TEST((fusion::front(v) == mpl::vector2<int,char>()));
+        BOOST_TEST((fusion::back(v) == mpl::vector2<bool,long>()));
+        BOOST_TEST((*fusion::next(fusion::begin(v)) == mpl::vector2<bool,long>()));
+        BOOST_TEST((*fusion::prior(fusion::end(v)) == mpl::vector2<bool,long>()));
+        BOOST_TEST(fusion::advance_c<2>(fusion::begin(v)) == fusion::end(v));
+        BOOST_TEST(fusion::advance_c<-2>(fusion::end(v)) == fusion::begin(v));
+        BOOST_TEST(fusion::distance(fusion::begin(v), fusion::end(v)) == 2);
+    }
+    return boost::report_errors();
+}
+
diff --git a/src/boost/libs/fusion/test/sequence/zip_view2.cpp b/src/boost/libs/fusion/test/sequence/zip_view2.cpp
new file mode 100644
index 00000000..b63a2744
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/zip_view2.cpp
@@ -0,0 +1,64 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/view/zip_view.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/front.hpp>
+#include <boost/fusion/sequence/intrinsic/back.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/prior.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <boost/fusion/container/generation/make_vector.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/equal_to.hpp>
+
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+
+int main()
+{
+    {
+        using namespace boost::fusion;
+        typedef vector2<int,int> int_vector;
+        typedef vector2<char,char> char_vector;
+        typedef list<char,char> char_list;
+        typedef vector<int_vector&, char_vector&, char_list&> seqs_type;
+        typedef zip_view<seqs_type> view;
+
+        BOOST_MPL_ASSERT((boost::mpl::equal_to<boost::fusion::result_of::size<view>::type, boost::fusion::result_of::size<int_vector>::type>));
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::size<view>::value == 2));
+
+        int_vector iv(1,2);
+        char_vector cv('a', 'b');
+        char_list cl('y','z');
+        seqs_type seqs(iv, cv, cl);
+        view v(seqs);
+
+        BOOST_TEST(at_c<0>(v) == make_vector(1, 'a', 'y'));
+        BOOST_TEST(at_c<1>(v) == make_vector(2, 'b', 'z'));
+        BOOST_TEST(front(v) == make_vector(1, 'a', 'y'));
+        BOOST_TEST(*next(begin(v)) == make_vector(2, 'b', 'z'));
+        BOOST_TEST(advance_c<2>(begin(v)) == end(v));
+        BOOST_TEST(distance(begin(v), end(v)) == 2);
+        BOOST_STATIC_ASSERT((boost::fusion::result_of::distance<boost::fusion::result_of::begin<view>::type, boost::fusion::result_of::end<view>::type>::value == 2));
+
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_at_c<view,0>::type, vector3<int,char,char> >));
+        BOOST_MPL_ASSERT((boost::is_same<boost::fusion::result_of::value_of<boost::fusion::result_of::begin<view>::type>::type, vector3<int,char,char> >));
+    }
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/fusion/test/sequence/zip_view_ignore.cpp b/src/boost/libs/fusion/test/sequence/zip_view_ignore.cpp
new file mode 100644
index 00000000..d22bf70f
--- /dev/null
+++ b/src/boost/libs/fusion/test/sequence/zip_view_ignore.cpp
@@ -0,0 +1,58 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/view/zip_view.hpp>
+#include <boost/fusion/support/unused.hpp>
+#include <boost/fusion/iterator.hpp>
+#include <boost/fusion/sequence/intrinsic.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+int main()
+{
+    using namespace boost::fusion;
+    {
+        typedef vector2<int,int> int_vector;
+        typedef vector2<char,char> char_vector;
+        typedef vector<int_vector&, unused_type const&, char_vector&> seqs_type;
+        typedef zip_view<seqs_type> view;
+
+        int_vector iv(1,2);
+        char_vector cv('a','b');
+        seqs_type seq(iv, unused, cv);
+        view v(seq);
+
+        BOOST_TEST(at_c<0>(front(v)) == 1);
+        BOOST_TEST(at_c<2>(front(v)) == 'a');
+        BOOST_TEST(at_c<0>(back(v)) == 2);
+        BOOST_TEST(at_c<2>(back(v)) == 'b');
+
+        typedef boost::fusion::result_of::begin<view>::type first_iterator;
+        typedef boost::fusion::result_of::value_of<first_iterator>::type first_element;
+
+        typedef boost::fusion::result_of::at_c<first_element, 0>::type e0;
+        typedef boost::fusion::result_of::at_c<first_element, 2>::type e2;
+        BOOST_MPL_ASSERT((boost::is_same<e0, int&>));
+        BOOST_MPL_ASSERT((boost::is_same<e2, char&>));
+
+        BOOST_TEST(size(front(v)) == 3);
+
+        typedef boost::fusion::result_of::value_at_c<view, 0>::type first_value_at;
+        typedef boost::fusion::result_of::value_at_c<first_value_at, 0>::type v0;
+        typedef boost::fusion::result_of::value_at_c<first_value_at, 2>::type v2;
+
+        BOOST_MPL_ASSERT((boost::is_same<v0, int>));
+        BOOST_MPL_ASSERT((boost::is_same<v2, char>));
+
+        BOOST_TEST(at_c<0>(at_c<0>(v)) == 1);
+        BOOST_TEST(at_c<2>(at_c<0>(v)) == 'a');
+    }
+    return boost::report_errors();
+}