diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 08b90f415..9dcfeea1e 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -75,7 +75,7 @@ if (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" AND
         "boost/hana/fwd/ext/std/tuple.hpp"
         "boost/hana/ext/std/tuple.hpp")
 
-    file(GLOB_RECURSE _ext_std_tuple_tests "ext/std/tuple.cpp")
+    file(GLOB_RECURSE _ext_std_tuple_tests "ext/std/tuple/*.cpp")
     list(REMOVE_ITEM BOOST_HANA_TEST_SOURCES ${_ext_std_tuple_tests})
 endif()
 
@@ -86,8 +86,8 @@ list(REMOVE_ITEM BOOST_HANA_TEST_SOURCES ${_ext_fusion_broken_tests})
 # More adapters are currently broken on Clang 3.5; working on it too.
 if (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" AND
     "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "3.7.0")
-    file(GLOB_RECURSE _ext_other_broken_tests "ext/boost/mpl/vector.cpp"
-                                              "ext/std/integer_sequence.cpp")
+    file(GLOB_RECURSE _ext_other_broken_tests "ext/boost/mpl/vector/*.cpp"
+                                              "ext/std/integer_sequence/*.cpp")
     list(REMOVE_ITEM BOOST_HANA_TEST_SOURCES ${_ext_other_broken_tests})
 endif()
 
diff --git a/test/ext/boost/mpl/vector.cpp b/test/ext/boost/mpl/vector.cpp
deleted file mode 100644
index 9541d5724..000000000
--- a/test/ext/boost/mpl/vector.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
-@copyright Louis Dionne 2015
-Distributed under the Boost Software License, Version 1.0.
-(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
- */
-
-#include <boost/hana/ext/boost/mpl/vector.hpp>
-
-#include <boost/hana/assert.hpp>
-#include <boost/hana/core/datatype.hpp>
-#include <boost/hana/tuple.hpp>
-#include <boost/hana/type.hpp>
-
-#include <test/auto/base.hpp>
-#include <test/auto/comparable.hpp>
-#include <test/auto/foldable.hpp>
-#include <test/auto/iterable.hpp>
-#include <test/auto/searchable.hpp>
-#include <test/injection.hpp>
-
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/quote.hpp>
-#include <boost/mpl/transform.hpp>
-#include <boost/mpl/vector.hpp>
-#include <type_traits>
-using namespace boost::hana;
-
-
-struct x1; struct x2; struct x3;
-
-namespace boost { namespace hana { namespace test {
-    template <>
-    auto instances<ext::boost::mpl::Vector> = make<Tuple>(
-        type<Comparable>,
-        type<Foldable>,
-        type<Iterable>,
-        type<Searchable>
-    );
-
-    template <>
-    auto objects<ext::boost::mpl::Vector> = make<Tuple>(
-        ::boost::mpl::vector<>{},
-        ::boost::mpl::vector<x1>{},
-        ::boost::mpl::vector<x1, x2>{},
-        ::boost::mpl::vector<x1, x2, x3>{}
-    );
-}}}
-
-
-int main() {
-    test::check_datatype<ext::boost::mpl::Vector>();
-
-    // make sure the data type is resolved correctly
-    {
-        using mpl_id = boost::mpl::quote1<boost::mpl::identity>;
-
-        static_assert(std::is_same<
-            datatype_t<boost::mpl::vector<>>,
-            ext::boost::mpl::Vector
-        >{}, "");
-        static_assert(std::is_same<
-            datatype_t<boost::mpl::vector<>::type>,
-            ext::boost::mpl::Vector
-        >{}, "");
-        static_assert(std::is_same<
-            datatype_t<boost::mpl::transform<boost::mpl::vector<>, mpl_id>::type>,
-            ext::boost::mpl::Vector
-        >{}, "");
-
-        static_assert(std::is_same<
-            datatype_t<boost::mpl::vector<x1>>,
-            ext::boost::mpl::Vector
-        >{}, "");
-        static_assert(std::is_same<
-            datatype_t<boost::mpl::vector<x1>::type>,
-            ext::boost::mpl::Vector
-        >{}, "");
-        static_assert(std::is_same<
-            datatype_t<boost::mpl::transform<boost::mpl::vector<x1>, mpl_id>::type>,
-            ext::boost::mpl::Vector
-        >{}, "");
-
-        static_assert(std::is_same<
-            datatype_t<boost::mpl::vector<x1, x2>>,
-            ext::boost::mpl::Vector
-        >{}, "");
-        static_assert(std::is_same<
-            datatype_t<boost::mpl::vector<x1, x2>::type>,
-            ext::boost::mpl::Vector
-        >{}, "");
-        static_assert(std::is_same<
-            datatype_t<boost::mpl::transform<boost::mpl::vector<x1, x2>, mpl_id>::type>,
-            ext::boost::mpl::Vector
-        >{}, "");
-    }
-
-    // Foldable
-    {
-        // unpack
-        {
-            auto f = test::injection([]{});
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(::boost::mpl::vector<>{}, f),
-                f()
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(::boost::mpl::vector<x1>{}, f),
-                f(type<x1>)
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(::boost::mpl::vector<x1, x2>{}, f),
-                f(type<x1>, type<x2>)
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(::boost::mpl::vector<x1, x2, x3>{}, f),
-                f(type<x1>, type<x2>, type<x3>)
-            ));
-        }
-    }
-
-    // Iterable
-    {
-        // head
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                head(::boost::mpl::vector<x1>{}),
-                type<x1>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                head(::boost::mpl::vector<x1, x2>{}),
-                type<x1>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                head(::boost::mpl::vector<x1, x2, x3>{}),
-                type<x1>
-            ));
-        }
-
-        // tail
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(::boost::mpl::vector<x1>{}),
-                ::boost::mpl::vector<>{}
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(::boost::mpl::vector<x1, x2>{}),
-                ::boost::mpl::vector<x2>{}
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(::boost::mpl::vector<x1, x2, x3>{}),
-                ::boost::mpl::vector<x2, x3>{}
-            ));
-        }
-
-        // is_empty
-        {
-            BOOST_HANA_CONSTANT_CHECK(is_empty(::boost::mpl::vector<>{}));
-            BOOST_HANA_CONSTANT_CHECK(is_empty(::boost::mpl::vector0<>{}));
-
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(::boost::mpl::vector<x1>{})));
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(::boost::mpl::vector1<x1>{})));
-
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(::boost::mpl::vector<x1, x2>{})));
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(::boost::mpl::vector2<x1, x2>{})));
-        }
-    }
-}
diff --git a/test/ext/boost/mpl/vector/comparable.cpp b/test/ext/boost/mpl/vector/comparable.cpp
new file mode 100644
index 000000000..b07395330
--- /dev/null
+++ b/test/ext/boost/mpl/vector/comparable.cpp
@@ -0,0 +1,37 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/boost/mpl/vector.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/comparable.hpp>
+
+#include <boost/mpl/vector.hpp>
+using namespace boost::hana;
+namespace mpl = boost::mpl;
+
+
+struct t1; struct t2; struct t3; struct t4;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto vectors = make<Tuple>(
+          mpl::vector<>{}
+        , mpl::vector<t1>{}
+        , mpl::vector<t1, t2>{}
+        , mpl::vector<t1, t2, t3>{}
+        , mpl::vector<t1, t2, t3, t4>{}
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Comparable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        test::TestComparable<ext::boost::mpl::Vector>{vectors};
+    }
+}
diff --git a/test/ext/boost/mpl/vector/datatype.cpp b/test/ext/boost/mpl/vector/datatype.cpp
new file mode 100644
index 000000000..17df31463
--- /dev/null
+++ b/test/ext/boost/mpl/vector/datatype.cpp
@@ -0,0 +1,67 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/core/datatype.hpp>
+#include <boost/hana/ext/boost/mpl/vector.hpp>
+
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/quote.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/vector.hpp>
+#include <type_traits>
+using namespace boost::hana;
+namespace mpl = boost::mpl;
+
+
+struct t1; struct t2;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Make sure the data type is resolved correctly
+    //////////////////////////////////////////////////////////////////////////
+    {
+        using mpl_id = mpl::quote1<mpl::identity>;
+
+        static_assert(std::is_same<
+            datatype_t<mpl::vector<>>,
+            ext::boost::mpl::Vector
+        >{}, "");
+        static_assert(std::is_same<
+            datatype_t<mpl::vector<>::type>,
+            ext::boost::mpl::Vector
+        >{}, "");
+        static_assert(std::is_same<
+            datatype_t<mpl::transform<mpl::vector<>, mpl_id>::type>,
+            ext::boost::mpl::Vector
+        >{}, "");
+
+        static_assert(std::is_same<
+            datatype_t<mpl::vector<t1>>,
+            ext::boost::mpl::Vector
+        >{}, "");
+        static_assert(std::is_same<
+            datatype_t<mpl::vector<t1>::type>,
+            ext::boost::mpl::Vector
+        >{}, "");
+        static_assert(std::is_same<
+            datatype_t<mpl::transform<mpl::vector<t1>, mpl_id>::type>,
+            ext::boost::mpl::Vector
+        >{}, "");
+
+        static_assert(std::is_same<
+            datatype_t<mpl::vector<t1, t2>>,
+            ext::boost::mpl::Vector
+        >{}, "");
+        static_assert(std::is_same<
+            datatype_t<mpl::vector<t1, t2>::type>,
+            ext::boost::mpl::Vector
+        >{}, "");
+        static_assert(std::is_same<
+            datatype_t<mpl::transform<mpl::vector<t1, t2>, mpl_id>::type>,
+            ext::boost::mpl::Vector
+        >{}, "");
+    }
+}
diff --git a/test/ext/boost/mpl/vector/foldable.cpp b/test/ext/boost/mpl/vector/foldable.cpp
new file mode 100644
index 000000000..3df8e324a
--- /dev/null
+++ b/test/ext/boost/mpl/vector/foldable.cpp
@@ -0,0 +1,66 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/boost/mpl/vector.hpp>
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/tuple.hpp>
+#include <boost/hana/type.hpp>
+
+#include <laws/base.hpp>
+#include <laws/foldable.hpp>
+
+#include <boost/mpl/vector.hpp>
+using namespace boost::hana;
+namespace mpl = boost::mpl;
+
+
+struct t1; struct t2; struct t3; struct t4;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto vectors = make<Tuple>(
+          mpl::vector<>{}
+        , mpl::vector<t1>{}
+        , mpl::vector<t1, t2>{}
+        , mpl::vector<t1, t2, t3>{}
+        , mpl::vector<t1, t2, t3, t4>{}
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Foldable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // unpack
+        {
+            test::_injection<0> f{};
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(mpl::vector<>{}, f),
+                f()
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(mpl::vector<t1>{}, f),
+                f(type<t1>)
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(mpl::vector<t1, t2>{}, f),
+                f(type<t1>, type<t2>)
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(mpl::vector<t1, t2, t3>{}, f),
+                f(type<t1>, type<t2>, type<t3>)
+            ));
+        }
+
+        // laws
+        test::TestFoldable<ext::boost::mpl::Vector>{vectors};
+    }
+}
diff --git a/test/ext/boost/mpl/vector/iterable.cpp b/test/ext/boost/mpl/vector/iterable.cpp
new file mode 100644
index 000000000..2d231429f
--- /dev/null
+++ b/test/ext/boost/mpl/vector/iterable.cpp
@@ -0,0 +1,85 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/boost/mpl/vector.hpp>
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/tuple.hpp>
+#include <boost/hana/type.hpp>
+
+#include <laws/iterable.hpp>
+
+#include <boost/mpl/vector.hpp>
+using namespace boost::hana;
+namespace mpl = boost::mpl;
+
+
+struct t1; struct t2; struct t3; struct t4;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto vectors = make<Tuple>(
+          mpl::vector<>{}
+        , mpl::vector<t1>{}
+        , mpl::vector<t1, t2>{}
+        , mpl::vector<t1, t2, t3>{}
+        , mpl::vector<t1, t2, t3, t4>{}
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Iterable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // head
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                head(mpl::vector<t1>{}),
+                type<t1>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                head(mpl::vector<t1, t2>{}),
+                type<t1>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                head(mpl::vector<t1, t2, t3>{}),
+                type<t1>
+            ));
+        }
+
+        // tail
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(mpl::vector<t1>{}),
+                mpl::vector<>{}
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(mpl::vector<t1, t2>{}),
+                mpl::vector<t2>{}
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(mpl::vector<t1, t2, t3>{}),
+                mpl::vector<t2, t3>{}
+            ));
+        }
+
+        // is_empty
+        {
+            BOOST_HANA_CONSTANT_CHECK(is_empty(mpl::vector<>{}));
+            BOOST_HANA_CONSTANT_CHECK(is_empty(mpl::vector0<>{}));
+
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(mpl::vector<t1>{})));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(mpl::vector1<t1>{})));
+
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(mpl::vector<t1, t2>{})));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(mpl::vector2<t1, t2>{})));
+        }
+
+        // laws
+        test::TestIterable<ext::boost::mpl::Vector>{vectors};
+    }
+}
diff --git a/test/ext/boost/mpl/vector/searchable.cpp b/test/ext/boost/mpl/vector/searchable.cpp
new file mode 100644
index 000000000..813d42176
--- /dev/null
+++ b/test/ext/boost/mpl/vector/searchable.cpp
@@ -0,0 +1,39 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/boost/mpl/vector.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/searchable.hpp>
+
+#include <boost/mpl/vector.hpp>
+using namespace boost::hana;
+namespace mpl = boost::mpl;
+
+
+struct t1; struct t2; struct t3; struct t4;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto vectors = make<Tuple>(
+          mpl::vector<>{}
+        , mpl::vector<t1>{}
+        , mpl::vector<t1, t2>{}
+        , mpl::vector<t1, t2, t3>{}
+        , mpl::vector<t1, t2, t3, t4>{}
+    );
+
+    auto keys = tuple_t<t1, t2, void>;
+
+    //////////////////////////////////////////////////////////////////////////
+    // Searchable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        test::TestSearchable<ext::boost::mpl::Vector>{vectors, keys};
+    }
+}
diff --git a/test/ext/boost/tuple/tuple.cpp b/test/ext/boost/tuple/datatype.cpp
similarity index 71%
rename from test/ext/boost/tuple/tuple.cpp
rename to test/ext/boost/tuple/datatype.cpp
index e73f13893..602e4c20c 100644
--- a/test/ext/boost/tuple/tuple.cpp
+++ b/test/ext/boost/tuple/datatype.cpp
@@ -4,45 +4,19 @@ Distributed under the Boost Software License, Version 1.0.
 (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
  */
 
+#include <boost/hana/core/datatype.hpp>
 #include <boost/hana/ext/boost/tuple.hpp>
 
-#include <boost/hana/core/datatype.hpp>
-#include <boost/hana/tuple.hpp>
-#include <boost/hana/type.hpp>
-
-#include <test/auto/sequence.hpp>
-#include <test/cnumeric.hpp>
-#include <test/injection.hpp>
-
 #include <boost/tuple/tuple.hpp>
+
 #include <type_traits>
 using namespace boost::hana;
 
 
-template <int i>
-constexpr auto ord = test::cnumeric<int, i>;
-
-namespace boost { namespace hana { namespace test {
-    template <>
-    auto instances<ext::boost::Tuple> = make<Tuple>(
-        type<Sequence>
-    );
-
-    template <>
-    auto objects<ext::boost::Tuple> = make<Tuple>(
-        ::boost::make_tuple(),
-        ::boost::make_tuple(ord<0>),
-        ::boost::make_tuple(ord<0>, ord<1>),
-        ::boost::make_tuple(ord<0>, ord<1>, ord<2>),
-        ::boost::make_tuple(ord<0>, ord<1>, ord<2>, ord<3>)
-    );
-}}}
-
-
 int main() {
-    test::check_datatype<ext::boost::Tuple>();
-
+    //////////////////////////////////////////////////////////////////////////
     // make sure the datatype is correct
+    //////////////////////////////////////////////////////////////////////////
     {
         auto make_cons = [](auto x, auto xs) {
             return boost::tuples::cons<decltype(x), decltype(xs)>{x, xs};
diff --git a/test/ext/boost/tuple/iterable.cpp b/test/ext/boost/tuple/iterable.cpp
new file mode 100644
index 000000000..457b65804
--- /dev/null
+++ b/test/ext/boost/tuple/iterable.cpp
@@ -0,0 +1,39 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/boost/tuple.hpp>
+
+#include <boost/hana/tuple.hpp>
+
+#include <laws/foldable.hpp>
+#include <laws/iterable.hpp>
+#include <laws/traversable.hpp>
+
+#include <boost/tuple/tuple.hpp>
+using namespace boost::hana;
+
+
+template <int i>
+using eq = test::ct_eq<i>;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto eq_tuples = make<Tuple>(
+          ::boost::make_tuple()
+        , ::boost::make_tuple(eq<0>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{}, eq<2>{})
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Foldable, Iterable, Traversable
+    //////////////////////////////////////////////////////////////////////////
+    test::TestFoldable<ext::boost::Tuple>{eq_tuples};
+    test::TestIterable<ext::boost::Tuple>{eq_tuples};
+    test::TestTraversable<ext::boost::Tuple>{};
+}
diff --git a/test/ext/boost/tuple/monad.cpp b/test/ext/boost/tuple/monad.cpp
new file mode 100644
index 000000000..1f9af2107
--- /dev/null
+++ b/test/ext/boost/tuple/monad.cpp
@@ -0,0 +1,53 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/boost/tuple.hpp>
+
+#include <boost/hana/tuple.hpp>
+
+#include <laws/applicative.hpp>
+#include <laws/base.hpp>
+#include <laws/functor.hpp>
+#include <laws/monad.hpp>
+
+#include <boost/tuple/tuple.hpp>
+using namespace boost::hana;
+
+
+template <int i>
+using eq = test::ct_eq<i>;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto eq_tuples = make<Tuple>(
+          ::boost::make_tuple()
+        , ::boost::make_tuple(eq<0>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{})
+    );
+
+    auto eq_tuples_tuples = make<Tuple>(
+          ::boost::make_tuple()
+        , ::boost::make_tuple(
+            ::boost::make_tuple(eq<0>{}))
+        , ::boost::make_tuple(
+            ::boost::make_tuple(eq<0>{}),
+            ::boost::make_tuple(eq<1>{}, eq<2>{}))
+        , ::boost::make_tuple(
+            ::boost::make_tuple(eq<0>{}),
+            ::boost::make_tuple(eq<1>{}, eq<2>{}),
+            ::boost::make_tuple(eq<3>{}, eq<4>{}))
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Functor up to Monad
+    //////////////////////////////////////////////////////////////////////////
+    test::TestFunctor<ext::boost::Tuple>{eq_tuples};
+    test::TestApplicative<ext::boost::Tuple>{};
+    test::TestMonad<ext::boost::Tuple>{eq_tuples, eq_tuples_tuples};
+}
diff --git a/test/ext/boost/tuple/monad_plus.cpp b/test/ext/boost/tuple/monad_plus.cpp
new file mode 100644
index 000000000..6f2cdd75c
--- /dev/null
+++ b/test/ext/boost/tuple/monad_plus.cpp
@@ -0,0 +1,35 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/boost/tuple.hpp>
+
+#include <boost/hana/tuple.hpp>
+
+#include <laws/base.hpp>
+#include <laws/monad_plus.hpp>
+
+#include <boost/tuple/tuple.hpp>
+using namespace boost::hana;
+
+
+template <int i>
+using eq = test::ct_eq<i>;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto eq_tuples = make<Tuple>(
+          ::boost::make_tuple(eq<0>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{}, eq<2>{})
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // MonadPlus
+    //////////////////////////////////////////////////////////////////////////
+    test::TestMonadPlus<ext::boost::Tuple>{eq_tuples};
+}
diff --git a/test/ext/boost/tuple/orderable.hpp b/test/ext/boost/tuple/orderable.hpp
new file mode 100644
index 000000000..502f91e2b
--- /dev/null
+++ b/test/ext/boost/tuple/orderable.hpp
@@ -0,0 +1,49 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/boost/tuple.hpp>
+
+#include <boost/hana/tuple.hpp>
+
+#include <laws/comparable.hpp>
+#include <laws/orderable.hpp>
+
+#include <boost/tuple/tuple.hpp>
+using namespace boost::hana;
+
+
+template <int i>
+using eq = test::ct_eq<i>;
+
+template <int i>
+using ord = test::ct_ord<i>;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto eq_tuples = make<Tuple>(
+          ::boost::make_tuple()
+        , ::boost::make_tuple(eq<0>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{}, eq<2>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{})
+    );
+
+    auto ord_tuples = make<Tuple>(
+          ::boost::make_tuple()
+        , ::boost::make_tuple(ord<0>{})
+        , ::boost::make_tuple(ord<0>{}, ord<1>{})
+        , ::boost::make_tuple(ord<0>{}, ord<1>{}, ord<2>{})
+        , ::boost::make_tuple(ord<0>{}, ord<1>{}, ord<2>{}, ord<3>{}, ord<4>{})
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Comparable and Orderable
+    //////////////////////////////////////////////////////////////////////////
+    test::TestComparable<ext::boost::Tuple>{eq_tuples};
+    test::TestOrderable<ext::boost::Tuple>{ord_tuples};
+}
diff --git a/test/ext/boost/tuple/searchable.cpp b/test/ext/boost/tuple/searchable.cpp
new file mode 100644
index 000000000..ae553d258
--- /dev/null
+++ b/test/ext/boost/tuple/searchable.cpp
@@ -0,0 +1,42 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/boost/tuple.hpp>
+
+#include <boost/hana/tuple.hpp>
+
+#include <laws/base.hpp>
+#include <laws/searchable.hpp>
+
+#include <boost/tuple/tuple.hpp>
+using namespace boost::hana;
+
+
+template <int i>
+using eq = test::ct_eq<i>;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto eq_tuples = make<Tuple>(
+          ::boost::make_tuple()
+        , ::boost::make_tuple(eq<0>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{})
+        , ::boost::make_tuple(eq<0>{}, eq<1>{}, eq<2>{})
+    );
+
+    auto eq_tuple_keys = make<Tuple>(
+        eq<3>{}, eq<5>{}, eq<7>{}
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Searchable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        test::TestSearchable<ext::boost::Tuple>{eq_tuples, eq_tuple_keys};
+    }
+}
diff --git a/test/ext/boost/tuple/sequence.cpp b/test/ext/boost/tuple/sequence.cpp
new file mode 100644
index 000000000..b28a4375b
--- /dev/null
+++ b/test/ext/boost/tuple/sequence.cpp
@@ -0,0 +1,20 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/boost/tuple.hpp>
+
+#include <laws/sequence.hpp>
+
+#include <boost/tuple/tuple.hpp>
+using namespace boost::hana;
+
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Sequence
+    //////////////////////////////////////////////////////////////////////////
+    test::TestSequence<ext::boost::Tuple>{};
+}
diff --git a/test/ext/std/integer_sequence.cpp b/test/ext/std/integer_sequence.cpp
deleted file mode 100644
index fbeeffdee..000000000
--- a/test/ext/std/integer_sequence.cpp
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
-@copyright Louis Dionne 2015
-Distributed under the Boost Software License, Version 1.0.
-(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
- */
-
-#include <boost/hana/ext/std/integer_sequence.hpp>
-#include <boost/hana/ext/std/integral_constant.hpp>
-
-#include <boost/hana/assert.hpp>
-#include <boost/hana/type.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <test/auto/base.hpp>
-
-// instances
-#include <test/auto/comparable.hpp>
-#include <test/auto/iterable.hpp>
-
-#include <cstddef>
-#include <utility>
-using namespace boost::hana;
-
-
-using T = int;
-using U = long long;
-
-namespace boost { namespace hana { namespace test {
-    template <>
-    auto instances<ext::std::IntegerSequence> = make<Tuple>(
-        type<Iterable>,
-        type<Comparable>
-    );
-
-    template <>
-    auto objects<ext::std::IntegerSequence> = make<Tuple>(
-        ::std::integer_sequence<T>{},
-        ::std::integer_sequence<U>{},
-
-        ::std::integer_sequence<T, 0>{},
-        ::std::integer_sequence<U, 0>{},
-
-        ::std::integer_sequence<T, 0, 1>{},
-        ::std::integer_sequence<U, 0, 1>{},
-
-        ::std::integer_sequence<T, 1, 0, 2>{},
-        ::std::integer_sequence<U, 1, 0, 2>{}
-    );
-}}}
-
-
-int main() {
-    test::check_datatype<ext::std::IntegerSequence>();
-
-    // Comparable
-    {
-        // equal
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                std::integer_sequence<T>{},
-                std::integer_sequence<U>{}
-            ));
-            BOOST_HANA_CONSTANT_CHECK(not_(equal(
-                std::integer_sequence<T, 0>{},
-                std::integer_sequence<U>{}
-            )));
-            BOOST_HANA_CONSTANT_CHECK(not_(equal(
-                std::integer_sequence<T>{},
-                std::integer_sequence<U, 0>{}
-            )));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                std::integer_sequence<T, 0>{},
-                std::integer_sequence<U, 0>{}
-            ));
-            BOOST_HANA_CONSTANT_CHECK(not_(equal(
-                std::integer_sequence<T, 0>{},
-                std::integer_sequence<U, 0, 1>{}
-            )));
-            BOOST_HANA_CONSTANT_CHECK(not_(equal(
-                std::integer_sequence<T, 0, 2>{},
-                std::integer_sequence<U, 0, 1>{}
-            )));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                std::integer_sequence<T, 0, 1, 2, 3>{},
-                std::integer_sequence<U, 0, 1, 2, 3>{}
-            ));
-            BOOST_HANA_CONSTANT_CHECK(not_(equal(
-                std::integer_sequence<T, 0, 1, 2, 3, 5>{},
-                std::integer_sequence<U, 0, 1, 2, 3>{}
-            )));
-        }
-    }
-
-    // Iterable
-    {
-        // head
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                head(std::index_sequence<0>{}),
-                std::integral_constant<std::size_t, 0>{}
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                head(std::index_sequence<0, 1>{}),
-                std::integral_constant<std::size_t, 0>{}
-            ));
-        }
-
-        // is_empty
-        {
-            BOOST_HANA_CONSTANT_CHECK(is_empty(std::index_sequence<>{}));
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(std::index_sequence<0>{})));
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(std::index_sequence<1>{})));
-        }
-
-        // tail
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(std::index_sequence<0>{}),
-                std::index_sequence<>{}
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(std::index_sequence<0, 1>{}),
-                std::index_sequence<1>{}
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(std::index_sequence<0, 1, 2>{}),
-                std::index_sequence<1, 2>{}
-            ));
-        }
-    }
-}
diff --git a/test/ext/std/integer_sequence/comparable.cpp b/test/ext/std/integer_sequence/comparable.cpp
new file mode 100644
index 000000000..49f03681f
--- /dev/null
+++ b/test/ext/std/integer_sequence/comparable.cpp
@@ -0,0 +1,84 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/std/integer_sequence.hpp>
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/comparable.hpp>
+
+#include <utility>
+using namespace boost::hana;
+
+
+using T = int;
+using U = long long;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto sequences = make<Tuple>(
+        std::integer_sequence<T>{},
+        std::integer_sequence<U>{},
+
+        std::integer_sequence<T, 0>{},
+        std::integer_sequence<U, 0>{},
+
+        std::integer_sequence<T, 0, 1>{},
+        std::integer_sequence<U, 0, 1>{},
+
+        std::integer_sequence<T, 1, 0, 2>{},
+        std::integer_sequence<U, 1, 0, 2>{}
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Comparable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // equal
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                std::integer_sequence<T>{},
+                std::integer_sequence<U>{}
+            ));
+            BOOST_HANA_CONSTANT_CHECK(not_(equal(
+                std::integer_sequence<T, 0>{},
+                std::integer_sequence<U>{}
+            )));
+            BOOST_HANA_CONSTANT_CHECK(not_(equal(
+                std::integer_sequence<T>{},
+                std::integer_sequence<U, 0>{}
+            )));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                std::integer_sequence<T, 0>{},
+                std::integer_sequence<U, 0>{}
+            ));
+            BOOST_HANA_CONSTANT_CHECK(not_(equal(
+                std::integer_sequence<T, 0>{},
+                std::integer_sequence<U, 0, 1>{}
+            )));
+            BOOST_HANA_CONSTANT_CHECK(not_(equal(
+                std::integer_sequence<T, 0, 2>{},
+                std::integer_sequence<U, 0, 1>{}
+            )));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                std::integer_sequence<T, 0, 1, 2, 3>{},
+                std::integer_sequence<U, 0, 1, 2, 3>{}
+            ));
+            BOOST_HANA_CONSTANT_CHECK(not_(equal(
+                std::integer_sequence<T, 0, 1, 2, 3, 5>{},
+                std::integer_sequence<U, 0, 1, 2, 3>{}
+            )));
+        }
+
+        // laws
+        test::TestComparable<ext::std::IntegerSequence>{sequences};
+    }
+}
diff --git a/test/ext/std/integer_sequence/foldable.cpp b/test/ext/std/integer_sequence/foldable.cpp
new file mode 100644
index 000000000..ca6948bc6
--- /dev/null
+++ b/test/ext/std/integer_sequence/foldable.cpp
@@ -0,0 +1,44 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/std/integer_sequence.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/foldable.hpp>
+
+#include <utility>
+using namespace boost::hana;
+
+
+using T = int;
+using U = long long;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto sequences = make<Tuple>(
+        std::integer_sequence<T>{},
+        std::integer_sequence<U>{},
+
+        std::integer_sequence<T, 0>{},
+        std::integer_sequence<U, 0>{},
+
+        std::integer_sequence<T, 0, 1>{},
+        std::integer_sequence<U, 0, 1>{},
+
+        std::integer_sequence<T, 1, 0, 2>{},
+        std::integer_sequence<U, 1, 0, 2>{}
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Foldable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // laws
+        test::TestFoldable<ext::std::IntegerSequence>{sequences};
+    }
+}
diff --git a/test/ext/std/integer_sequence/iterable.cpp b/test/ext/std/integer_sequence/iterable.cpp
new file mode 100644
index 000000000..047d59d76
--- /dev/null
+++ b/test/ext/std/integer_sequence/iterable.cpp
@@ -0,0 +1,81 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/std/integer_sequence.hpp>
+#include <boost/hana/ext/std/integral_constant.hpp>
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/iterable.hpp>
+
+#include <cstddef>
+#include <utility>
+using namespace boost::hana;
+
+
+using T = int;
+using U = long long;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto sequences = make<Tuple>(
+        std::integer_sequence<T>{},
+        std::integer_sequence<U>{},
+
+        std::integer_sequence<T, 0>{},
+        std::integer_sequence<U, 0>{},
+
+        std::integer_sequence<T, 0, 1>{},
+        std::integer_sequence<U, 0, 1>{},
+
+        std::integer_sequence<T, 1, 0, 2>{},
+        std::integer_sequence<U, 1, 0, 2>{}
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Iterable
+    //////////////////////////////////////////////////////////////////////////
+    // head
+    {
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            head(std::index_sequence<0>{}),
+            std::integral_constant<std::size_t, 0>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            head(std::index_sequence<0, 1>{}),
+            std::integral_constant<std::size_t, 0>{}
+        ));
+    }
+
+    // is_empty
+    {
+        BOOST_HANA_CONSTANT_CHECK(is_empty(std::index_sequence<>{}));
+        BOOST_HANA_CONSTANT_CHECK(not_(is_empty(std::index_sequence<0>{})));
+        BOOST_HANA_CONSTANT_CHECK(not_(is_empty(std::index_sequence<1>{})));
+    }
+
+    // tail
+    {
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            tail(std::index_sequence<0>{}),
+            std::index_sequence<>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            tail(std::index_sequence<0, 1>{}),
+            std::index_sequence<1>{}
+        ));
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            tail(std::index_sequence<0, 1, 2>{}),
+            std::index_sequence<1, 2>{}
+        ));
+    }
+
+    // laws
+    test::TestIterable<ext::std::IntegerSequence>{sequences};
+}
diff --git a/test/ext/std/integer_sequence/searchable.cpp b/test/ext/std/integer_sequence/searchable.cpp
new file mode 100644
index 000000000..dcf32d786
--- /dev/null
+++ b/test/ext/std/integer_sequence/searchable.cpp
@@ -0,0 +1,49 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/std/integer_sequence.hpp>
+#include <boost/hana/ext/std/integral_constant.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/searchable.hpp>
+
+#include <utility>
+using namespace boost::hana;
+
+
+using T = int;
+using U = long long;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto sequences = make<Tuple>(
+        std::integer_sequence<T>{},
+        std::integer_sequence<U>{},
+
+        std::integer_sequence<T, 0>{},
+        std::integer_sequence<U, 0>{},
+
+        std::integer_sequence<T, 0, 1>{},
+        std::integer_sequence<U, 0, 1>{},
+
+        std::integer_sequence<T, 1, 0, 2>{},
+        std::integer_sequence<U, 1, 0, 2>{}
+    );
+
+    auto keys = make<Tuple>(
+        integral_constant<T, 0>, integral_constant<U, 1>
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Searchable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // laws
+        test::TestSearchable<ext::std::IntegerSequence>{sequences, keys};
+    }
+}
diff --git a/test/ext/std/tuple.cpp b/test/ext/std/tuple.cpp
deleted file mode 100644
index 59eb01136..000000000
--- a/test/ext/std/tuple.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-@copyright Louis Dionne 2015
-Distributed under the Boost Software License, Version 1.0.
-(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
- */
-
-#include <boost/hana/ext/std/tuple.hpp>
-
-#include <boost/hana/tuple.hpp>
-#include <boost/hana/type.hpp>
-
-#include <test/auto/sequence.hpp>
-#include <test/cnumeric.hpp>
-#include <test/injection.hpp>
-
-#include <tuple>
-using namespace boost::hana;
-
-
-template <int i>
-constexpr auto ord = test::cnumeric<int, i>;
-
-namespace boost { namespace hana { namespace test {
-    template <>
-    auto instances<ext::std::Tuple> = make<Tuple>(
-        type<Sequence>
-    );
-
-    template <>
-    auto objects<ext::std::Tuple> = make<Tuple>(
-        ::std::make_tuple(),
-        ::std::make_tuple(ord<0>),
-        ::std::make_tuple(ord<0>, ord<1>),
-        ::std::make_tuple(ord<0>, ord<1>, ord<2>),
-        ::std::make_tuple(ord<0>, ord<1>, ord<2>, ord<3>)
-    );
-}}}
-
-
-int main() {
-    test::check_datatype<ext::std::Tuple>();
-}
diff --git a/test/ext/std/tuple/iterable.cpp b/test/ext/std/tuple/iterable.cpp
new file mode 100644
index 000000000..eb683be9e
--- /dev/null
+++ b/test/ext/std/tuple/iterable.cpp
@@ -0,0 +1,39 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/std/tuple.hpp>
+
+#include <boost/hana/tuple.hpp>
+
+#include <laws/foldable.hpp>
+#include <laws/iterable.hpp>
+#include <laws/traversable.hpp>
+
+#include <tuple>
+using namespace boost::hana;
+
+
+template <int i>
+using eq = test::ct_eq<i>;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto eq_tuples = make<Tuple>(
+          std::make_tuple()
+        , std::make_tuple(eq<0>{})
+        , std::make_tuple(eq<0>{}, eq<1>{})
+        , std::make_tuple(eq<0>{}, eq<1>{}, eq<2>{})
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Foldable, Iterable, Traversable
+    //////////////////////////////////////////////////////////////////////////
+    test::TestFoldable<ext::std::Tuple>{eq_tuples};
+    test::TestIterable<ext::std::Tuple>{eq_tuples};
+    test::TestTraversable<ext::std::Tuple>{};
+}
diff --git a/test/ext/std/tuple/monad.cpp b/test/ext/std/tuple/monad.cpp
new file mode 100644
index 000000000..e09a835be
--- /dev/null
+++ b/test/ext/std/tuple/monad.cpp
@@ -0,0 +1,53 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/std/tuple.hpp>
+
+#include <boost/hana/tuple.hpp>
+
+#include <laws/applicative.hpp>
+#include <laws/base.hpp>
+#include <laws/functor.hpp>
+#include <laws/monad.hpp>
+
+#include <tuple>
+using namespace boost::hana;
+
+
+template <int i>
+using eq = test::ct_eq<i>;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto eq_tuples = make<Tuple>(
+          std::make_tuple()
+        , std::make_tuple(eq<0>{})
+        , std::make_tuple(eq<0>{}, eq<1>{})
+        , std::make_tuple(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{})
+    );
+
+    auto eq_tuples_tuples = make<Tuple>(
+          std::make_tuple()
+        , std::make_tuple(
+            std::make_tuple(eq<0>{}))
+        , std::make_tuple(
+            std::make_tuple(eq<0>{}),
+            std::make_tuple(eq<1>{}, eq<2>{}))
+        , std::make_tuple(
+            std::make_tuple(eq<0>{}),
+            std::make_tuple(eq<1>{}, eq<2>{}),
+            std::make_tuple(eq<3>{}, eq<4>{}))
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Functor up to Monad
+    //////////////////////////////////////////////////////////////////////////
+    test::TestFunctor<ext::std::Tuple>{eq_tuples};
+    test::TestApplicative<ext::std::Tuple>{};
+    test::TestMonad<ext::std::Tuple>{eq_tuples, eq_tuples_tuples};
+}
diff --git a/test/ext/std/tuple/monad_plus.cpp b/test/ext/std/tuple/monad_plus.cpp
new file mode 100644
index 000000000..2ced05d20
--- /dev/null
+++ b/test/ext/std/tuple/monad_plus.cpp
@@ -0,0 +1,35 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/std/tuple.hpp>
+
+#include <boost/hana/tuple.hpp>
+
+#include <laws/base.hpp>
+#include <laws/monad_plus.hpp>
+
+#include <tuple>
+using namespace boost::hana;
+
+
+template <int i>
+using eq = test::ct_eq<i>;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto eq_tuples = make<Tuple>(
+          std::make_tuple(eq<0>{})
+        , std::make_tuple(eq<0>{}, eq<1>{})
+        , std::make_tuple(eq<0>{}, eq<1>{}, eq<2>{})
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // MonadPlus
+    //////////////////////////////////////////////////////////////////////////
+    test::TestMonadPlus<ext::std::Tuple>{eq_tuples};
+}
diff --git a/test/ext/std/tuple/orderable.cpp b/test/ext/std/tuple/orderable.cpp
new file mode 100644
index 000000000..b73be13b2
--- /dev/null
+++ b/test/ext/std/tuple/orderable.cpp
@@ -0,0 +1,49 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/std/tuple.hpp>
+
+#include <boost/hana/tuple.hpp>
+
+#include <laws/comparable.hpp>
+#include <laws/orderable.hpp>
+
+#include <tuple>
+using namespace boost::hana;
+
+
+template <int i>
+using eq = test::ct_eq<i>;
+
+template <int i>
+using ord = test::ct_ord<i>;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto eq_tuples = make<Tuple>(
+          std::make_tuple()
+        , std::make_tuple(eq<0>{})
+        , std::make_tuple(eq<0>{}, eq<1>{})
+        , std::make_tuple(eq<0>{}, eq<1>{}, eq<2>{})
+        , std::make_tuple(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{})
+    );
+
+    auto ord_tuples = make<Tuple>(
+          std::make_tuple()
+        , std::make_tuple(ord<0>{})
+        , std::make_tuple(ord<0>{}, ord<1>{})
+        , std::make_tuple(ord<0>{}, ord<1>{}, ord<2>{})
+        , std::make_tuple(ord<0>{}, ord<1>{}, ord<2>{}, ord<3>{}, ord<4>{})
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Comparable and Orderable
+    //////////////////////////////////////////////////////////////////////////
+    test::TestComparable<ext::std::Tuple>{eq_tuples};
+    test::TestOrderable<ext::std::Tuple>{ord_tuples};
+}
diff --git a/test/ext/std/tuple/searchable.cpp b/test/ext/std/tuple/searchable.cpp
new file mode 100644
index 000000000..90f1ddbc6
--- /dev/null
+++ b/test/ext/std/tuple/searchable.cpp
@@ -0,0 +1,42 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/std/tuple.hpp>
+
+#include <boost/hana/tuple.hpp>
+
+#include <laws/base.hpp>
+#include <laws/searchable.hpp>
+
+#include <tuple>
+using namespace boost::hana;
+
+
+template <int i>
+using eq = test::ct_eq<i>;
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto eq_tuples = make<Tuple>(
+          std::make_tuple()
+        , std::make_tuple(eq<0>{})
+        , std::make_tuple(eq<0>{}, eq<1>{})
+        , std::make_tuple(eq<0>{}, eq<1>{}, eq<2>{})
+    );
+
+    auto eq_tuple_keys = make<Tuple>(
+        eq<3>{}, eq<5>{}, eq<7>{}
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Searchable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        test::TestSearchable<ext::std::Tuple>{eq_tuples, eq_tuple_keys};
+    }
+}
diff --git a/test/ext/std/tuple/sequence.cpp b/test/ext/std/tuple/sequence.cpp
new file mode 100644
index 000000000..99c0559e1
--- /dev/null
+++ b/test/ext/std/tuple/sequence.cpp
@@ -0,0 +1,20 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/ext/std/tuple.hpp>
+
+#include <laws/sequence.hpp>
+
+#include <tuple>
+using namespace boost::hana;
+
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Sequence
+    //////////////////////////////////////////////////////////////////////////
+    test::TestSequence<ext::std::Tuple>{};
+}
diff --git a/test/string/foldable.cpp b/test/string/foldable.cpp
new file mode 100644
index 000000000..9466b38e3
--- /dev/null
+++ b/test/string/foldable.cpp
@@ -0,0 +1,86 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/string.hpp>
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/base.hpp>
+#include <laws/foldable.hpp>
+using namespace boost::hana;
+
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto strings = make<Tuple>(
+        BOOST_HANA_STRING(""),
+        BOOST_HANA_STRING("a"),
+        BOOST_HANA_STRING("ab"),
+        BOOST_HANA_STRING("abc"),
+        BOOST_HANA_STRING("abcd"),
+        BOOST_HANA_STRING("abcde"),
+        BOOST_HANA_STRING("ba"),
+        BOOST_HANA_STRING("afcd")
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Foldable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        test::_injection<0> f{};
+
+        // unpack
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(BOOST_HANA_STRING(""), f),
+                f()
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(BOOST_HANA_STRING("a"), f),
+                f(char_<'a'>)
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(BOOST_HANA_STRING("ab"), f),
+                f(char_<'a'>, char_<'b'>)
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(BOOST_HANA_STRING("abc"), f),
+                f(char_<'a'>, char_<'b'>, char_<'c'>)
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(BOOST_HANA_STRING("abcd"), f),
+                f(char_<'a'>, char_<'b'>, char_<'c'>, char_<'d'>)
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(BOOST_HANA_STRING("abcde"), f),
+                f(char_<'a'>, char_<'b'>, char_<'c'>, char_<'d'>, char_<'e'>)
+            ));
+        }
+
+        // length
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                length(BOOST_HANA_STRING("")), size_t<0>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                length(BOOST_HANA_STRING("a")), size_t<1>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                length(BOOST_HANA_STRING("ab")), size_t<2>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                length(BOOST_HANA_STRING("abc")), size_t<3>
+            ));
+        }
+
+        // laws
+        test::TestFoldable<String>{strings};
+    }
+}
diff --git a/test/string/iterable.cpp b/test/string/iterable.cpp
new file mode 100644
index 000000000..45c206525
--- /dev/null
+++ b/test/string/iterable.cpp
@@ -0,0 +1,133 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/string.hpp>
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/core/operators.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/iterable.hpp>
+using namespace boost::hana;
+
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto strings = make<Tuple>(
+        BOOST_HANA_STRING(""),
+        BOOST_HANA_STRING("a"),
+        BOOST_HANA_STRING("ab"),
+        BOOST_HANA_STRING("abc"),
+        BOOST_HANA_STRING("abcd"),
+        BOOST_HANA_STRING("abcde"),
+        BOOST_HANA_STRING("ba"),
+        BOOST_HANA_STRING("afcd")
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Iterable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // head
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                head(BOOST_HANA_STRING("a")),
+                char_<'a'>
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                head(BOOST_HANA_STRING("ab")),
+                char_<'a'>
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                head(BOOST_HANA_STRING("abc")),
+                char_<'a'>
+            ));
+        }
+
+        // tail
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(BOOST_HANA_STRING("a")),
+                BOOST_HANA_STRING("")
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(BOOST_HANA_STRING("ab")),
+                BOOST_HANA_STRING("b")
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(BOOST_HANA_STRING("abc")),
+                BOOST_HANA_STRING("bc")
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(BOOST_HANA_STRING("abcdefghijk")),
+                BOOST_HANA_STRING("bcdefghijk")
+            ));
+        }
+
+        // is_empty
+        {
+            BOOST_HANA_CONSTANT_CHECK(is_empty(BOOST_HANA_STRING("")));
+            BOOST_HANA_CONSTANT_CHECK(is_empty(string<>));
+
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(BOOST_HANA_STRING("a"))));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(BOOST_HANA_STRING("ab"))));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(BOOST_HANA_STRING("abc"))));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(string<'a'>)));
+        }
+
+        // at
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                at(int_<0>, BOOST_HANA_STRING("a")),
+                char_<'a'>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                at(int_<0>, BOOST_HANA_STRING("ab")),
+                char_<'a'>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                at(int_<0>, BOOST_HANA_STRING("abc")),
+                char_<'a'>
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                at(int_<1>, BOOST_HANA_STRING("ab")),
+                char_<'b'>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                at(int_<1>, BOOST_HANA_STRING("abc")),
+                char_<'b'>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                at(int_<1>, BOOST_HANA_STRING("abcd")),
+                char_<'b'>
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                at(int_<2>, BOOST_HANA_STRING("abc")),
+                char_<'c'>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                at(int_<2>, BOOST_HANA_STRING("abcd")),
+                char_<'c'>
+            ));
+        }
+
+        // operators
+        static_assert(has_operator<String, decltype(at)>{}, "");
+
+        // laws
+        test::TestIterable<String>{strings};
+    }
+}
diff --git a/test/string/orderable.cpp b/test/string/orderable.cpp
new file mode 100644
index 000000000..09f4f9a8a
--- /dev/null
+++ b/test/string/orderable.cpp
@@ -0,0 +1,122 @@
+/*
+@copyright Louis Dionne 2015
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+ */
+
+#include <boost/hana/string.hpp>
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/core/operators.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/comparable.hpp>
+#include <laws/orderable.hpp>
+
+#include <type_traits>
+using namespace boost::hana;
+
+
+int main() {
+    //////////////////////////////////////////////////////////////////////////
+    // Setup for the laws below
+    //////////////////////////////////////////////////////////////////////////
+    auto strings = make<Tuple>(
+        BOOST_HANA_STRING(""),
+        BOOST_HANA_STRING("a"),
+        BOOST_HANA_STRING("ab"),
+        BOOST_HANA_STRING("abc"),
+        BOOST_HANA_STRING("abcd"),
+        BOOST_HANA_STRING("abcde"),
+        BOOST_HANA_STRING("ba"),
+        BOOST_HANA_STRING("afcd")
+    );
+
+    //////////////////////////////////////////////////////////////////////////
+    // Comparable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // equal
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            BOOST_HANA_STRING("abcd"),
+            BOOST_HANA_STRING("abcd")
+        ));
+
+        BOOST_HANA_CONSTANT_CHECK(not_(equal(
+            BOOST_HANA_STRING("abcd"),
+            BOOST_HANA_STRING("abcde")
+        )));
+
+        BOOST_HANA_CONSTANT_CHECK(not_(equal(
+            BOOST_HANA_STRING("abcd"),
+            BOOST_HANA_STRING("")
+        )));
+
+        BOOST_HANA_CONSTANT_CHECK(not_(equal(
+            BOOST_HANA_STRING(""),
+            BOOST_HANA_STRING("abcde")
+        )));
+
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            BOOST_HANA_STRING(""),
+            BOOST_HANA_STRING("")
+        ));
+
+        // operators
+        static_assert(has_operator<String, decltype(equal)>{}, "");
+        static_assert(has_operator<String, decltype(not_equal)>{}, "");
+
+        // laws
+        test::TestComparable<String>{strings};
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Orderable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // less
+        BOOST_HANA_CONSTANT_CHECK(not_(less(
+            BOOST_HANA_STRING(""),
+            BOOST_HANA_STRING("")
+        )));
+
+        BOOST_HANA_CONSTANT_CHECK(less(
+            BOOST_HANA_STRING(""),
+            BOOST_HANA_STRING("a")
+        ));
+
+        BOOST_HANA_CONSTANT_CHECK(not_(less(
+            BOOST_HANA_STRING("a"),
+            BOOST_HANA_STRING("")
+        )));
+
+        BOOST_HANA_CONSTANT_CHECK(less(
+            BOOST_HANA_STRING("a"),
+            BOOST_HANA_STRING("ab")
+        ));
+
+        BOOST_HANA_CONSTANT_CHECK(not_(less(
+            BOOST_HANA_STRING("ab"),
+            BOOST_HANA_STRING("ab")
+        )));
+
+        BOOST_HANA_CONSTANT_CHECK(less(
+            BOOST_HANA_STRING("abc"),
+            BOOST_HANA_STRING("abcde")
+        ));
+
+        BOOST_HANA_CONSTANT_CHECK(less(
+            BOOST_HANA_STRING("abcde"),
+            BOOST_HANA_STRING("abfde")
+        ));
+
+        // operators
+        static_assert(has_operator<String, decltype(less)>{}, "");
+        static_assert(has_operator<String, decltype(less_equal)>{}, "");
+        static_assert(has_operator<String, decltype(greater)>{}, "");
+        static_assert(has_operator<String, decltype(greater_equal)>{}, "");
+
+        // laws
+        test::TestOrderable<String>{strings};
+    }
+}
diff --git a/test/string/string.cpp b/test/string/string.cpp
index 2c9085bd1..b9622d5f8 100644
--- a/test/string/string.cpp
+++ b/test/string/string.cpp
@@ -5,19 +5,7 @@ Distributed under the Boost Software License, Version 1.0.
  */
 
 #include <boost/hana/string.hpp>
-
-#include <boost/hana/assert.hpp>
 #include <boost/hana/config.hpp>
-#include <boost/hana/core/operators.hpp>
-#include <boost/hana/integral_constant.hpp>
-#include <boost/hana/tuple.hpp>
-#include <boost/hana/type.hpp>
-
-#include <laws/base.hpp>
-#include <laws/comparable.hpp>
-#include <laws/foldable.hpp>
-#include <laws/iterable.hpp>
-#include <laws/orderable.hpp>
 
 #include <type_traits>
 using namespace boost::hana;
@@ -35,261 +23,4 @@ int main() {
             decltype(s1), decltype(s2)
         >::value, "");
     }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Setup for the laws below
-    //////////////////////////////////////////////////////////////////////////
-    auto strings = make<Tuple>(
-        BOOST_HANA_STRING(""),
-        BOOST_HANA_STRING("a"),
-        BOOST_HANA_STRING("ab"),
-        BOOST_HANA_STRING("abc"),
-        BOOST_HANA_STRING("abcd"),
-        BOOST_HANA_STRING("abcde"),
-        BOOST_HANA_STRING("ba"),
-        BOOST_HANA_STRING("afcd")
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Comparable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // equal
-        BOOST_HANA_CONSTANT_CHECK(equal(
-            BOOST_HANA_STRING("abcd"),
-            BOOST_HANA_STRING("abcd")
-        ));
-
-        BOOST_HANA_CONSTANT_CHECK(not_(equal(
-            BOOST_HANA_STRING("abcd"),
-            BOOST_HANA_STRING("abcde")
-        )));
-
-        BOOST_HANA_CONSTANT_CHECK(not_(equal(
-            BOOST_HANA_STRING("abcd"),
-            BOOST_HANA_STRING("")
-        )));
-
-        BOOST_HANA_CONSTANT_CHECK(not_(equal(
-            BOOST_HANA_STRING(""),
-            BOOST_HANA_STRING("abcde")
-        )));
-
-        BOOST_HANA_CONSTANT_CHECK(equal(
-            BOOST_HANA_STRING(""),
-            BOOST_HANA_STRING("")
-        ));
-
-        // operators
-        static_assert(has_operator<String, decltype(equal)>{}, "");
-        static_assert(has_operator<String, decltype(not_equal)>{}, "");
-
-        // laws
-        test::TestComparable<String>{strings};
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Orderable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // less
-        BOOST_HANA_CONSTANT_CHECK(not_(less(
-            BOOST_HANA_STRING(""),
-            BOOST_HANA_STRING("")
-        )));
-
-        BOOST_HANA_CONSTANT_CHECK(less(
-            BOOST_HANA_STRING(""),
-            BOOST_HANA_STRING("a")
-        ));
-
-        BOOST_HANA_CONSTANT_CHECK(not_(less(
-            BOOST_HANA_STRING("a"),
-            BOOST_HANA_STRING("")
-        )));
-
-        BOOST_HANA_CONSTANT_CHECK(less(
-            BOOST_HANA_STRING("a"),
-            BOOST_HANA_STRING("ab")
-        ));
-
-        BOOST_HANA_CONSTANT_CHECK(not_(less(
-            BOOST_HANA_STRING("ab"),
-            BOOST_HANA_STRING("ab")
-        )));
-
-        BOOST_HANA_CONSTANT_CHECK(less(
-            BOOST_HANA_STRING("abc"),
-            BOOST_HANA_STRING("abcde")
-        ));
-
-        BOOST_HANA_CONSTANT_CHECK(less(
-            BOOST_HANA_STRING("abcde"),
-            BOOST_HANA_STRING("abfde")
-        ));
-
-        // operators
-        static_assert(has_operator<String, decltype(less)>{}, "");
-        static_assert(has_operator<String, decltype(less_equal)>{}, "");
-        static_assert(has_operator<String, decltype(greater)>{}, "");
-        static_assert(has_operator<String, decltype(greater_equal)>{}, "");
-
-        // laws
-        test::TestOrderable<String>{strings};
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Foldable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        test::_injection<0> f{};
-
-        // unpack
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(BOOST_HANA_STRING(""), f),
-                f()
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(BOOST_HANA_STRING("a"), f),
-                f(char_<'a'>)
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(BOOST_HANA_STRING("ab"), f),
-                f(char_<'a'>, char_<'b'>)
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(BOOST_HANA_STRING("abc"), f),
-                f(char_<'a'>, char_<'b'>, char_<'c'>)
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(BOOST_HANA_STRING("abcd"), f),
-                f(char_<'a'>, char_<'b'>, char_<'c'>, char_<'d'>)
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(BOOST_HANA_STRING("abcde"), f),
-                f(char_<'a'>, char_<'b'>, char_<'c'>, char_<'d'>, char_<'e'>)
-            ));
-        }
-
-        // length
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                length(BOOST_HANA_STRING("")), size_t<0>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                length(BOOST_HANA_STRING("a")), size_t<1>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                length(BOOST_HANA_STRING("ab")), size_t<2>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                length(BOOST_HANA_STRING("abc")), size_t<3>
-            ));
-        }
-
-        // laws
-        test::TestFoldable<String>{strings};
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Iterable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // head
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                head(BOOST_HANA_STRING("a")),
-                char_<'a'>
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                head(BOOST_HANA_STRING("ab")),
-                char_<'a'>
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                head(BOOST_HANA_STRING("abc")),
-                char_<'a'>
-            ));
-        }
-
-        // tail
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(BOOST_HANA_STRING("a")),
-                BOOST_HANA_STRING("")
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(BOOST_HANA_STRING("ab")),
-                BOOST_HANA_STRING("b")
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(BOOST_HANA_STRING("abc")),
-                BOOST_HANA_STRING("bc")
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(BOOST_HANA_STRING("abcdefghijk")),
-                BOOST_HANA_STRING("bcdefghijk")
-            ));
-        }
-
-        // is_empty
-        {
-            BOOST_HANA_CONSTANT_CHECK(is_empty(BOOST_HANA_STRING("")));
-            BOOST_HANA_CONSTANT_CHECK(is_empty(string<>));
-
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(BOOST_HANA_STRING("a"))));
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(BOOST_HANA_STRING("ab"))));
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(BOOST_HANA_STRING("abc"))));
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(string<'a'>)));
-        }
-
-        // at
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                at(int_<0>, BOOST_HANA_STRING("a")),
-                char_<'a'>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                at(int_<0>, BOOST_HANA_STRING("ab")),
-                char_<'a'>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                at(int_<0>, BOOST_HANA_STRING("abc")),
-                char_<'a'>
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                at(int_<1>, BOOST_HANA_STRING("ab")),
-                char_<'b'>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                at(int_<1>, BOOST_HANA_STRING("abc")),
-                char_<'b'>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                at(int_<1>, BOOST_HANA_STRING("abcd")),
-                char_<'b'>
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                at(int_<2>, BOOST_HANA_STRING("abc")),
-                char_<'c'>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                at(int_<2>, BOOST_HANA_STRING("abcd")),
-                char_<'c'>
-            ));
-        }
-
-        // operators
-        static_assert(has_operator<String, decltype(at)>{}, "");
-
-        // laws
-        test::TestIterable<String>{strings};
-    }
 }