diff --git a/.travis.yml b/.travis.yml
index 2f524e426..8e6e52dab 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,75 +3,75 @@ compiler: clang
 os: linux
 
 env:
-  - CLANG_VERSION=3.5
-  - CLANG_VERSION=3.6
-  - CLANG_VERSION=3.7
+  - CLANG_VERSION=3.5 BOOST_VERSION=1.57.0
+  - CLANG_VERSION=3.6 BOOST_VERSION=1.57.0
+  - CLANG_VERSION=3.7 BOOST_VERSION=1.57.0
+
+  - CLANG_VERSION=3.5 BOOST_VERSION=1.58.0
+  - CLANG_VERSION=3.6 BOOST_VERSION=1.58.0
+  - CLANG_VERSION=3.7 BOOST_VERSION=1.58.0
+
 
 before_install:
+    # All the dependencies are installed to the deps/ subdirectory.
+    - mkdir deps
+    - DEPS_DIR="${PWD}/deps"
+
     # Add deb repositories to get different versions of LLVM/Clang.
     # The latest version of those repositories doesn't need a -3.x suffix,
     # so we jump through the little hoop with _suffix below.
     - sudo apt-add-repository "deb http://ppa.launchpad.net/ubuntu-toolchain-r/test/ubuntu precise main"
-    - if [ "$CLANG_VERSION" != "3.7" ]; then _suffix="-${CLANG_VERSION}"; fi
+    - if [ "${CLANG_VERSION}" != "3.7" ]; then _suffix="-${CLANG_VERSION}"; fi
     - sudo apt-add-repository "deb http://llvm.org/apt/precise/ llvm-toolchain-precise${_suffix} main"
     - sudo apt-get -qq update
 
     # Checkout the latest libc++
-    - svn --quiet co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx
+    - svn --quiet co http://llvm.org/svn/llvm-project/libcxx/trunk ${DEPS_DIR}/libcxx
 
-    # Install linuxbrew and its dependencies.
-    # We use </dev/null to bypass confirmations.
-    - sudo apt-get install build-essential curl git m4 ruby texinfo libbz2-dev libcurl4-openssl-dev libexpat-dev libncurses-dev zlib1g-dev
-    - ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/linuxbrew/go/install)" </dev/null
-    - export PATH=$HOME/.linuxbrew/bin:$PATH
+    # Install Boost headers
+    - if [ "${BOOST_VERSION}" == "1.57.0" ]; then wget --quiet -O ${DEPS_DIR}/boost.tar.gz http://sourceforge.net/projects/boost/files/boost/1.57.0/boost_1_57_0.tar.gz; fi
+    - if [ "${BOOST_VERSION}" == "1.58.0" ]; then wget --quiet -O ${DEPS_DIR}/boost.tar.gz http://sourceforge.net/projects/boost/files/boost/1.58.0.beta.1/boost_1_58_0_b1.tar.gz; fi
+    - mkdir ${DEPS_DIR}/boost && tar --strip-components=1 -C ${DEPS_DIR}/boost -xzf ${DEPS_DIR}/boost.tar.gz
 
-    # Clone the Boost modularized repository from GitHub.
-    # - git clone --quiet git://github.com/boostorg/boost.git boost
-    # - (cd boost && git submodule --quiet update --init)
 
 install:
     # Install Clang
-    - sudo apt-get --allow-unauthenticated -qq install clang-${CLANG_VERSION}
+    - sudo apt-get -qq --allow-unauthenticated install clang-${CLANG_VERSION}
 
-    # Install the latest CMake
-    - brew install cmake --without-docs
+    # Install a more recent CMake
+    - wget --quiet -O ${DEPS_DIR}/cmake.tar.gz http://www.cmake.org/files/v3.2/cmake-3.2.1-Linux-x86_64.tar.gz
+    - mkdir ${DEPS_DIR}/cmake && tar --strip-components=1 -C ${DEPS_DIR}/cmake -xzf ${DEPS_DIR}/cmake.tar.gz
+    - export PATH=${DEPS_DIR}/cmake/bin:${PATH}
 
     # Install libc++
-    - (cd libcxx/lib && bash buildit)
-    - sudo cp libcxx/lib/libc++.so.1.0 /usr/lib/
+    - (cd ${DEPS_DIR}/libcxx/lib && bash buildit)
+    - sudo cp ${DEPS_DIR}/libcxx/lib/libc++.so.1.0 /usr/lib/
     - sudo mkdir /usr/include/c++/v1
-    - sudo cp -r libcxx/include/* /usr/include/c++/v1/
+    - sudo cp -r ${DEPS_DIR}/libcxx/include/* /usr/include/c++/v1/
     - sudo ln -sf /usr/lib/libc++.so.1.0 /usr/lib/libc++.so
     - sudo ln -sf /usr/lib/libc++.so.1.0 /usr/lib/libc++.so.1
 
-    # Setup Boost's headers
-    # - brew install boost --HEAD
-    # - (cd boost && ./bootstrap.sh && ./b2 headers)
-
     # Setup the build directory
-    - (mkdir build && cd build && cmake .. -DCMAKE_CXX_COMPILER=clang++-${CLANG_VERSION})
+    - (mkdir build && cd build && cmake .. -DCMAKE_CXX_COMPILER=clang++-${CLANG_VERSION} -DBOOST_ROOT=${DEPS_DIR}/boost)
+
 
 before_script:
     # Check baseline memory usage; for compare with after_failure when OOMs occur
     - free
     - vmstat
-    - ps aux --sort -rss | head -n 10
+    - ps aux --sort=-rss | head -n 10
+
 
 script:
-    # It often happens that compilation is aborted because the
-    # VM is out of memory. We attempt to compile the tests several
-    # times, knowing only those that were not compiled in previous
-    # passes will be compiled.
-    - (cd build && make compile.all -k)
-    - (cd build && make compile.all -k)
-    - (cd build && make compile.all -k)
-    - (cd build && make compile.all -k)
-
+    # We use the -k switch because it will cause the build to continue even
+    # when there's a failure. However, the tests will still globally fail
+    # (as expected) because running ctest will fail.
     - (cd build && make run.all -k)
 
+
 after_failure:
     # check for OOMs
     - sudo dmesg
     - free
     - vmstat
-    - ps aux --sort -rss | head -n 10
+    - ps aux --sort=-rss
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 84b39acdc..c09c56d85 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -48,16 +48,21 @@ list(REMOVE_ITEM BOOST_HANA_PUBLIC_HEADERS ${_detail_headers})
 # This list must not be modified by the caveats below; when a source file is
 # not available in BOOST_HANA_TEST_SOURCES, it won't be split regardless of
 # whether it appears in this list.
-file(GLOB_RECURSE BOOST_HANA_SPLIT_TEST_SOURCES
+file(GLOB BOOST_HANA_SPLIT_TEST_SOURCES
     "cnumeric.cpp"
     "detail/canonical_constant.cpp"
     "either.cpp"
+    "ext/std/array.cpp"
+    "ext/std/integer_sequence.cpp"
     "ext/std/integral_constant.cpp"
+    "ext/std/ratio.cpp"
     "ext/std/tuple.cpp"
+    "integral_constant.cpp"
     "maybe.cpp"
     "minimal_record.cpp"
     "set.cpp"
     "string.cpp"
+    "tuple.cpp"
 )
 
 
@@ -134,8 +139,16 @@ if ($ENV{TRAVIS})
     list(REMOVE_ITEM BOOST_HANA_TEST_SOURCES ${_non_minimal_mcds})
 endif()
 
-# The Fusion adapters are currently broken; I'm working on it.
-file(GLOB_RECURSE _ext_fusion_broken_tests "ext/boost/fusion/*.cpp")
+# Some Fusion adapters are currently broken; I'm working on it.
+file(GLOB _ext_fusion_broken_tests
+    "ext/boost/fusion/vector/searchable.cpp"
+    "ext/boost/fusion/vector/sequence.cpp"
+    "ext/boost/fusion/tuple/monad.cpp"
+    "ext/boost/fusion/tuple/searchable.cpp"
+    "ext/boost/fusion/tuple/sequence.cpp"
+    "ext/boost/fusion/deque/searchable.cpp"
+    "ext/boost/fusion/deque/sequence.cpp"
+)
 list(REMOVE_ITEM BOOST_HANA_TEST_SOURCES ${_ext_fusion_broken_tests})
 
 
diff --git a/test/ext/std/array.cpp b/test/ext/std/array.cpp
new file mode 100644
index 000000000..c9a6f7635
--- /dev/null
+++ b/test/ext/std/array.cpp
@@ -0,0 +1,117 @@
+/*
+@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/assert.hpp>
+#include <boost/hana/ext/std/array.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/base.hpp>
+#include <laws/comparable.hpp>
+#include <laws/foldable.hpp>
+#include <laws/iterable.hpp>
+#include <laws/orderable.hpp>
+#include <laws/searchable.hpp>
+
+#include <array>
+using namespace boost::hana;
+
+
+template <int ...i>
+constexpr auto array() { return std::array<int, sizeof...(i)>{{i...}}; }
+
+using test::ct_eq;
+
+int main() {
+    auto int_arrays = make<Tuple>(
+          array<>()
+        , array<0>()
+        , array<0, 1>()
+        , array<0, 1, 2>()
+        , array<0, 1, 2, 3>()
+        , array<0, 1, 2, 3, 4>()
+    );
+    (void)int_arrays;
+
+#if BOOST_HANA_TEST_PART == 1
+    //////////////////////////////////////////////////////////////////////////
+    // Comparable
+    //////////////////////////////////////////////////////////////////////////
+    test::TestComparable<ext::std::Array>{int_arrays};
+
+#elif BOOST_HANA_TEST_PART == 2
+    //////////////////////////////////////////////////////////////////////////
+    // Orderable
+    //////////////////////////////////////////////////////////////////////////
+    test::TestOrderable<ext::std::Array>{int_arrays};
+
+#elif BOOST_HANA_TEST_PART == 3
+    //////////////////////////////////////////////////////////////////////////
+    // Foldable
+    //////////////////////////////////////////////////////////////////////////
+    test::TestFoldable<ext::std::Array>{int_arrays};
+
+#elif BOOST_HANA_TEST_PART == 4
+    //////////////////////////////////////////////////////////////////////////
+    // Iterable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // is_empty
+        {
+            BOOST_HANA_CONSTANT_CHECK(is_empty(array<>()));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(array<0>())));
+            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(array<0, 1>())));
+        }
+
+        // head
+        {
+            BOOST_HANA_CONSTEXPR_CHECK(head(array<0>()) == 0);
+            BOOST_HANA_CONSTEXPR_CHECK(head(array<0, 1>()) == 0);
+            BOOST_HANA_CONSTEXPR_CHECK(head(array<0, 1, 2>()) == 0);
+        }
+
+        // tail
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                tail(array<0>()),
+                array<>()
+            ));
+            BOOST_HANA_CONSTEXPR_CHECK(equal(
+                tail(array<0, 1>()),
+                array<1>()
+            ));
+            BOOST_HANA_CONSTEXPR_CHECK(equal(
+                tail(array<0, 1, 2>()),
+                array<1, 2>()
+            ));
+            BOOST_HANA_CONSTEXPR_CHECK(equal(
+                tail(array<0, 1, 2, 3>()),
+                array<1, 2, 3>()
+            ));
+        }
+
+        // laws
+        test::TestIterable<ext::std::Array>{int_arrays};
+    }
+
+#elif BOOST_HANA_TEST_PART == 5
+    //////////////////////////////////////////////////////////////////////////
+    // Searchable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        auto eq_arrays = make<Tuple>(
+              std::array<ct_eq<0>, 0>{}
+            , std::array<ct_eq<0>, 1>{}
+            , std::array<ct_eq<0>, 2>{}
+            , std::array<ct_eq<0>, 3>{}
+            , std::array<ct_eq<0>, 4>{}
+        );
+
+        auto eq_keys = make<Tuple>(ct_eq<0>{});
+
+        test::TestSearchable<ext::std::Array>{eq_arrays, eq_keys};
+    }
+#endif
+}
diff --git a/test/ext/std/array/comparable.cpp b/test/ext/std/array/comparable.cpp
deleted file mode 100644
index fa1b010df..000000000
--- a/test/ext/std/array/comparable.cpp
+++ /dev/null
@@ -1,33 +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/array.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/comparable.hpp>
-
-#include <array>
-using namespace boost::hana;
-
-
-template <int ...i>
-constexpr auto array = std::array<int, sizeof...(i)>{{i...}};
-
-int main() {
-    auto int_arrays = make<Tuple>(
-          array<>
-        , array<0>
-        , array<0, 1>
-        , array<0, 1, 2>
-        , array<0, 1, 2, 3>
-        , array<0, 1, 2, 3, 4>
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Comparable
-    //////////////////////////////////////////////////////////////////////////
-    test::TestComparable<ext::std::Array>{int_arrays};
-}
diff --git a/test/ext/std/array/iterable.cpp b/test/ext/std/array/iterable.cpp
deleted file mode 100644
index 3a74fa56a..000000000
--- a/test/ext/std/array/iterable.cpp
+++ /dev/null
@@ -1,77 +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/assert.hpp>
-#include <boost/hana/ext/std/array.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/foldable.hpp>
-#include <laws/iterable.hpp>
-
-#include <array>
-using namespace boost::hana;
-
-
-template <int ...i>
-constexpr auto array = std::array<int, sizeof...(i)>{{i...}};
-
-int main() {
-    auto int_arrays = make<Tuple>(
-          array<>
-        , array<0>
-        , array<0, 1>
-        , array<0, 1, 2>
-        , array<0, 1, 2, 3>
-        , array<0, 1, 2, 3, 4>
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Foldable
-    //////////////////////////////////////////////////////////////////////////
-    test::TestFoldable<ext::std::Array>{int_arrays};
-
-    //////////////////////////////////////////////////////////////////////////
-    // Iterable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // is_empty
-        {
-            BOOST_HANA_CONSTANT_CHECK(is_empty(array<>));
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(array<0>)));
-            BOOST_HANA_CONSTANT_CHECK(not_(is_empty(array<0, 1>)));
-        }
-
-        // head
-        {
-            BOOST_HANA_CONSTEXPR_CHECK(head(array<0>) == 0);
-            BOOST_HANA_CONSTEXPR_CHECK(head(array<0, 1>) == 0);
-            BOOST_HANA_CONSTEXPR_CHECK(head(array<0, 1, 2>) == 0);
-        }
-
-        // tail
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                tail(array<0>),
-                array<>
-            ));
-            BOOST_HANA_CONSTEXPR_CHECK(equal(
-                tail(array<0, 1>),
-                array<1>
-            ));
-            BOOST_HANA_CONSTEXPR_CHECK(equal(
-                tail(array<0, 1, 2>),
-                array<1, 2>
-            ));
-            BOOST_HANA_CONSTEXPR_CHECK(equal(
-                tail(array<0, 1, 2, 3>),
-                array<1, 2, 3>
-            ));
-        }
-
-        // laws
-        test::TestIterable<ext::std::Array>{int_arrays};
-    }
-}
diff --git a/test/ext/std/array/orderable.cpp b/test/ext/std/array/orderable.cpp
deleted file mode 100644
index 22b487da4..000000000
--- a/test/ext/std/array/orderable.cpp
+++ /dev/null
@@ -1,33 +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/array.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/orderable.hpp>
-
-#include <array>
-using namespace boost::hana;
-
-
-template <int ...i>
-constexpr auto array = std::array<int, sizeof...(i)>{{i...}};
-
-int main() {
-    auto int_arrays = make<Tuple>(
-          array<>
-        , array<0>
-        , array<0, 1>
-        , array<0, 1, 2>
-        , array<0, 1, 2, 3>
-        , array<0, 1, 2, 3, 4>
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Orderable
-    //////////////////////////////////////////////////////////////////////////
-    test::TestOrderable<ext::std::Array>{int_arrays};
-}
diff --git a/test/ext/std/array/searchable.cpp b/test/ext/std/array/searchable.cpp
deleted file mode 100644
index 9c695b988..000000000
--- a/test/ext/std/array/searchable.cpp
+++ /dev/null
@@ -1,34 +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/array.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/base.hpp>
-#include <laws/searchable.hpp>
-
-#include <array>
-using namespace boost::hana;
-
-
-using test::ct_eq;
-
-int main() {
-    auto eq_arrays = make<Tuple>(
-          std::array<ct_eq<0>, 0>{}
-        , std::array<ct_eq<0>, 1>{}
-        , std::array<ct_eq<0>, 2>{}
-        , std::array<ct_eq<0>, 3>{}
-        , std::array<ct_eq<0>, 4>{}
-    );
-
-    auto eq_keys = make<Tuple>(ct_eq<0>{});
-
-    //////////////////////////////////////////////////////////////////////////
-    // Searchable
-    //////////////////////////////////////////////////////////////////////////
-    test::TestSearchable<ext::std::Array>{eq_arrays, eq_keys};
-}
diff --git a/test/ext/std/integer_sequence.cpp b/test/ext/std/integer_sequence.cpp
new file mode 100644
index 000000000..58d41ff36
--- /dev/null
+++ b/test/ext/std/integer_sequence.cpp
@@ -0,0 +1,196 @@
+/*
+@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/assert.hpp>
+#include <boost/hana/ext/std/integer_sequence.hpp>
+#include <boost/hana/ext/std/integral_constant.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/base.hpp>
+#include <laws/comparable.hpp>
+#include <laws/foldable.hpp>
+#include <laws/iterable.hpp>
+#include <laws/searchable.hpp>
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+using namespace boost::hana;
+
+
+using T = int;
+using U = long long;
+
+int main() {
+    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>{}
+    );
+    (void)sequences;
+
+#if BOOST_HANA_TEST_PART == 1
+    //////////////////////////////////////////////////////////////////////////
+    // 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};
+    }
+
+#elif BOOST_HANA_TEST_PART == 2
+    //////////////////////////////////////////////////////////////////////////
+    // Foldable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // unpack
+        {
+            test::_injection<0> f{};
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(std::integer_sequence<T>{}, f),
+                f()
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(std::integer_sequence<T, 0>{}, f),
+                f(std::integral_constant<T, 0>{})
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(std::integer_sequence<T, 0, 1>{}, f),
+                f(std::integral_constant<T, 0>{}, std::integral_constant<T, 1>{})
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(std::integer_sequence<T, 0, 1, 2>{}, f),
+                f(std::integral_constant<T, 0>{}, std::integral_constant<T, 1>{},
+                  std::integral_constant<T, 2>{})
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                unpack(std::integer_sequence<T, 0, 1, 2, 3>{}, f),
+                f(std::integral_constant<T, 0>{}, std::integral_constant<T, 1>{},
+                  std::integral_constant<T, 2>{}, std::integral_constant<T, 3>{})
+            ));
+        }
+
+        // laws
+        test::TestFoldable<ext::std::IntegerSequence>{sequences};
+    }
+
+#elif BOOST_HANA_TEST_PART == 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>{}
+            ));
+        }
+
+        // laws
+        test::TestIterable<ext::std::IntegerSequence>{sequences};
+    }
+
+#elif BOOST_HANA_TEST_PART == 4
+    //////////////////////////////////////////////////////////////////////////
+    // Searchable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        auto sequences = make<Tuple>(
+            std::integer_sequence<T>{},
+            std::integer_sequence<T, 2>{},
+            std::integer_sequence<T, 3>{},
+            std::integer_sequence<T, 3, 4>{},
+            std::integer_sequence<T, 3, 4, 5>{}
+        );
+
+        auto keys = make<Tuple>(
+            std::integral_constant<T, 3>{}, std::integral_constant<U, 4>{}
+        );
+
+        // laws
+        test::TestSearchable<ext::std::IntegerSequence>{sequences, keys};
+    }
+#endif
+}
diff --git a/test/ext/std/integer_sequence/comparable.cpp b/test/ext/std/integer_sequence/comparable.cpp
deleted file mode 100644
index 49f03681f..000000000
--- a/test/ext/std/integer_sequence/comparable.cpp
+++ /dev/null
@@ -1,84 +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/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
deleted file mode 100644
index adb9e8bef..000000000
--- a/test/ext/std/integer_sequence/foldable.cpp
+++ /dev/null
@@ -1,80 +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/assert.hpp>
-#include <boost/hana/ext/std/integer_sequence.hpp>
-#include <boost/hana/ext/std/integral_constant.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/base.hpp>
-#include <laws/foldable.hpp>
-
-#include <type_traits>
-#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
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // unpack
-        {
-            test::_injection<0> f{};
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(std::integer_sequence<T>{}, f),
-                f()
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(std::integer_sequence<T, 0>{}, f),
-                f(std::integral_constant<T, 0>{})
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(std::integer_sequence<T, 0, 1>{}, f),
-                f(std::integral_constant<T, 0>{}, std::integral_constant<T, 1>{})
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(std::integer_sequence<T, 0, 1, 2>{}, f),
-                f(std::integral_constant<T, 0>{}, std::integral_constant<T, 1>{},
-                  std::integral_constant<T, 2>{})
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                unpack(std::integer_sequence<T, 0, 1, 2, 3>{}, f),
-                f(std::integral_constant<T, 0>{}, std::integral_constant<T, 1>{},
-                  std::integral_constant<T, 2>{}, std::integral_constant<T, 3>{})
-            ));
-        }
-
-        // 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
deleted file mode 100644
index 047d59d76..000000000
--- a/test/ext/std/integer_sequence/iterable.cpp
+++ /dev/null
@@ -1,81 +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/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
deleted file mode 100644
index e1c86f8de..000000000
--- a/test/ext/std/integer_sequence/searchable.cpp
+++ /dev/null
@@ -1,44 +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/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<T, 2>{},
-        std::integer_sequence<U, 3>{},
-        std::integer_sequence<T, 3, 4>{},
-        std::integer_sequence<U, 3, 4, 5>{},
-        std::integer_sequence<U, 4, 3, 5>{}
-    );
-
-    auto keys = make<Tuple>(
-        integral_constant<T, 3>, integral_constant<U, 4>
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Searchable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // laws
-        test::TestSearchable<ext::std::IntegerSequence>{sequences, keys};
-    }
-}
diff --git a/test/ext/std/ratio.cpp b/test/ext/std/ratio.cpp
new file mode 100644
index 000000000..07aeea96a
--- /dev/null
+++ b/test/ext/std/ratio.cpp
@@ -0,0 +1,234 @@
+/*
+@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/ratio.hpp>
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/comparable.hpp>
+#include <laws/group.hpp>
+#include <laws/integral_domain.hpp>
+#include <laws/monoid.hpp>
+#include <laws/orderable.hpp>
+#include <laws/ring.hpp>
+#include <test/cnumeric.hpp>
+
+#include <ratio>
+using namespace boost::hana;
+
+
+int main() {
+    auto ratios = make<Tuple>(
+          std::ratio<0>{}
+        , std::ratio<1, 3>{}
+        , std::ratio<1, 2>{}
+        , std::ratio<2, 6>{}
+        , std::ratio<3, 1>{}
+        , std::ratio<7, 8>{}
+        , std::ratio<3, 5>{}
+        , std::ratio<2, 1>{}
+    );
+    (void)ratios;
+
+#if BOOST_HANA_TEST_PART == 1
+    //////////////////////////////////////////////////////////////////////////
+    // Conversions
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // Constant -> Ratio
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                to<ext::std::Ratio>(test::cnumeric<int, 0>),
+                std::ratio<0>{}
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                to<ext::std::Ratio>(test::cnumeric<int, 1>),
+                std::ratio<1>{}
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                to<ext::std::Ratio>(test::cnumeric<int, 3>),
+                std::ratio<3>{}
+            ));
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Comparable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // equal
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                std::ratio<0>{},
+                std::ratio<0>{}
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                std::ratio<3, 5>{},
+                std::ratio<6, 10>{}
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(not_(equal(
+                std::ratio<4, 5>{},
+                std::ratio<6, 10>{}
+            )));
+        }
+
+        // laws
+        test::TestComparable<ext::std::Ratio>{ratios};
+    }
+
+#elif BOOST_HANA_TEST_PART == 2
+    //////////////////////////////////////////////////////////////////////////
+    // Orderable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // less
+        {
+            BOOST_HANA_CONSTANT_CHECK(less(
+                std::ratio<1>{},
+                std::ratio<3>{}
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(less(
+                std::ratio<4, 10>{},
+                std::ratio<3, 5>{}
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(not_(less(
+                std::ratio<3, 5>{},
+                std::ratio<4, 10>{}
+            )));
+        }
+
+        // laws
+        auto ratios = make<Tuple>(
+              std::ratio<0>{}
+            , std::ratio<1, 3>{}
+            , std::ratio<1, 2>{}
+            , std::ratio<2, 6>{}
+            , std::ratio<7, 8>{}
+            , std::ratio<3, 5>{}
+        );
+
+        test::TestOrderable<ext::std::Ratio>{ratios};
+    }
+
+#elif BOOST_HANA_TEST_PART == 3
+    //////////////////////////////////////////////////////////////////////////
+    // Monoid
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // plus
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                plus(std::ratio<3, 4>{}, std::ratio<5, 10>{}),
+                std::ratio<3*10 + 5*4, 4*10>{}
+            ));
+        }
+
+        // zero
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                zero<ext::std::Ratio>(),
+                std::ratio<0, 1>{}
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                zero<ext::std::Ratio>(),
+                std::ratio<0, 2>{}
+            ));
+        }
+
+        // laws
+        test::TestMonoid<ext::std::Ratio>{ratios};
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Group
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // minus
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                minus(std::ratio<3, 4>{}, std::ratio<5, 10>{}),
+                std::ratio<3*10 - 5*4, 4*10>{}
+            ));
+        }
+
+        // laws
+        test::TestGroup<ext::std::Ratio>{ratios};
+    }
+
+#elif BOOST_HANA_TEST_PART == 4
+    //////////////////////////////////////////////////////////////////////////
+    // Ring
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // mult
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                mult(std::ratio<3, 4>{}, std::ratio<5, 10>{}),
+                std::ratio<3*5, 4*10>{}
+            ));
+        }
+
+        // one
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                one<ext::std::Ratio>(),
+                std::ratio<1, 1>{}
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                one<ext::std::Ratio>(),
+                std::ratio<2, 2>{}
+            ));
+        }
+
+        // laws
+        test::TestRing<ext::std::Ratio>{ratios};
+    }
+
+#elif BOOST_HANA_TEST_PART == 5
+    //////////////////////////////////////////////////////////////////////////
+    // IntegralDomain
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // quot
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                quot(std::ratio<6>{}, std::ratio<4>{}),
+                std::ratio<6, 4>{}
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                quot(std::ratio<3, 4>{}, std::ratio<5, 10>{}),
+                std::ratio<3*10, 4*5>{}
+            ));
+        }
+
+        // rem
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                rem(std::ratio<6>{}, std::ratio<4>{}),
+                std::ratio<0>{}
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                rem(std::ratio<3, 4>{}, std::ratio<5, 10>{}),
+                std::ratio<0>{}
+            ));
+        }
+
+        // laws
+        test::TestIntegralDomain<ext::std::Ratio>{ratios};
+    }
+#endif
+}
diff --git a/test/ext/std/ratio/comparable.cpp b/test/ext/std/ratio/comparable.cpp
deleted file mode 100644
index a8e95e42b..000000000
--- a/test/ext/std/ratio/comparable.cpp
+++ /dev/null
@@ -1,55 +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/ratio.hpp>
-
-#include <boost/hana/assert.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/comparable.hpp>
-
-#include <ratio>
-using namespace boost::hana;
-
-
-int main() {
-    auto ratios = make<Tuple>(
-          std::ratio<0>{}
-        , std::ratio<1, 3>{}
-        , std::ratio<1, 2>{}
-        , std::ratio<2, 6>{}
-        , std::ratio<3, 1>{}
-        , std::ratio<7, 8>{}
-        , std::ratio<3, 5>{}
-        , std::ratio<2, 1>{}
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Comparable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // equal
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                std::ratio<0>{},
-                std::ratio<0>{}
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                std::ratio<3, 5>{},
-                std::ratio<6, 10>{}
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(not_(equal(
-                std::ratio<4, 5>{},
-                std::ratio<6, 10>{}
-            )));
-        }
-
-        // laws
-        test::TestComparable<ext::std::Ratio>{ratios};
-    }
-}
diff --git a/test/ext/std/ratio/conversions.cpp b/test/ext/std/ratio/conversions.cpp
deleted file mode 100644
index 027bff526..000000000
--- a/test/ext/std/ratio/conversions.cpp
+++ /dev/null
@@ -1,40 +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/ratio.hpp>
-
-#include <boost/hana/assert.hpp>
-
-#include <test/cnumeric.hpp>
-
-#include <ratio>
-using namespace boost::hana;
-
-
-int main() {
-    //////////////////////////////////////////////////////////////////////////
-    // Conversions
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // Constant -> Ratio
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                to<ext::std::Ratio>(test::cnumeric<int, 0>),
-                std::ratio<0>{}
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                to<ext::std::Ratio>(test::cnumeric<int, 1>),
-                std::ratio<1>{}
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                to<ext::std::Ratio>(test::cnumeric<int, 3>),
-                std::ratio<3>{}
-            ));
-        }
-    }
-}
diff --git a/test/ext/std/ratio/group.cpp b/test/ext/std/ratio/group.cpp
deleted file mode 100644
index 77e1b27ed..000000000
--- a/test/ext/std/ratio/group.cpp
+++ /dev/null
@@ -1,75 +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/ratio.hpp>
-
-#include <boost/hana/assert.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/group.hpp>
-#include <laws/monoid.hpp>
-
-#include <ratio>
-using namespace boost::hana;
-
-
-int main() {
-    auto ratios = make<Tuple>(
-          std::ratio<0>{}
-        , std::ratio<1, 3>{}
-        , std::ratio<1, 2>{}
-        , std::ratio<2, 6>{}
-        , std::ratio<3, 1>{}
-        , std::ratio<7, 8>{}
-        , std::ratio<3, 5>{}
-        , std::ratio<2, 1>{}
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Monoid
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // plus
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                plus(std::ratio<3, 4>{}, std::ratio<5, 10>{}),
-                std::ratio<3*10 + 5*4, 4*10>{}
-            ));
-        }
-
-        // zero
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                zero<ext::std::Ratio>(),
-                std::ratio<0, 1>{}
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                zero<ext::std::Ratio>(),
-                std::ratio<0, 2>{}
-            ));
-        }
-
-        // laws
-        test::TestMonoid<ext::std::Ratio>{ratios};
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Group
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // minus
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                minus(std::ratio<3, 4>{}, std::ratio<5, 10>{}),
-                std::ratio<3*10 - 5*4, 4*10>{}
-            ));
-        }
-
-        // laws
-        test::TestGroup<ext::std::Ratio>{ratios};
-    }
-}
diff --git a/test/ext/std/ratio/integral_domain.cpp b/test/ext/std/ratio/integral_domain.cpp
deleted file mode 100644
index 1454d033f..000000000
--- a/test/ext/std/ratio/integral_domain.cpp
+++ /dev/null
@@ -1,63 +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/ratio.hpp>
-
-#include <boost/hana/assert.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/integral_domain.hpp>
-
-#include <ratio>
-using namespace boost::hana;
-
-
-int main() {
-    auto ratios = make<Tuple>(
-          std::ratio<0>{}
-        , std::ratio<1, 3>{}
-        , std::ratio<1, 2>{}
-        , std::ratio<2, 6>{}
-        , std::ratio<3, 1>{}
-        , std::ratio<7, 8>{}
-        , std::ratio<3, 5>{}
-        , std::ratio<2, 1>{}
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // IntegralDomain
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // quot
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                quot(std::ratio<6>{}, std::ratio<4>{}),
-                std::ratio<6, 4>{}
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                quot(std::ratio<3, 4>{}, std::ratio<5, 10>{}),
-                std::ratio<3*10, 4*5>{}
-            ));
-        }
-
-        // rem
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                rem(std::ratio<6>{}, std::ratio<4>{}),
-                std::ratio<0>{}
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                rem(std::ratio<3, 4>{}, std::ratio<5, 10>{}),
-                std::ratio<0>{}
-            ));
-        }
-
-        // laws
-        test::TestIntegralDomain<ext::std::Ratio>{ratios};
-    }
-}
diff --git a/test/ext/std/ratio/orderable.cpp b/test/ext/std/ratio/orderable.cpp
deleted file mode 100644
index b0bb6b1f0..000000000
--- a/test/ext/std/ratio/orderable.cpp
+++ /dev/null
@@ -1,53 +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/ratio.hpp>
-
-#include <boost/hana/assert.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/orderable.hpp>
-
-#include <ratio>
-using namespace boost::hana;
-
-
-int main() {
-    auto ratios = make<Tuple>(
-          std::ratio<0>{}
-        , std::ratio<1, 3>{}
-        , std::ratio<1, 2>{}
-        , std::ratio<2, 6>{}
-        , std::ratio<7, 8>{}
-        , std::ratio<3, 5>{}
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Orderable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // less
-        {
-            BOOST_HANA_CONSTANT_CHECK(less(
-                std::ratio<1>{},
-                std::ratio<3>{}
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(less(
-                std::ratio<4, 10>{},
-                std::ratio<3, 5>{}
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(not_(less(
-                std::ratio<3, 5>{},
-                std::ratio<4, 10>{}
-            )));
-        }
-
-        // laws
-        test::TestOrderable<ext::std::Ratio>{ratios};
-    }
-}
diff --git a/test/ext/std/ratio/ring.cpp b/test/ext/std/ratio/ring.cpp
deleted file mode 100644
index f670cae62..000000000
--- a/test/ext/std/ratio/ring.cpp
+++ /dev/null
@@ -1,58 +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/ratio.hpp>
-
-#include <boost/hana/assert.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/ring.hpp>
-
-#include <ratio>
-using namespace boost::hana;
-
-
-int main() {
-    auto ratios = make<Tuple>(
-          std::ratio<0>{}
-        , std::ratio<1, 3>{}
-        , std::ratio<1, 2>{}
-        , std::ratio<2, 6>{}
-        , std::ratio<3, 1>{}
-        , std::ratio<7, 8>{}
-        , std::ratio<3, 5>{}
-        , std::ratio<2, 1>{}
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Ring
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // mult
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                mult(std::ratio<3, 4>{}, std::ratio<5, 10>{}),
-                std::ratio<3*5, 4*10>{}
-            ));
-        }
-
-        // one
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                one<ext::std::Ratio>(),
-                std::ratio<1, 1>{}
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                one<ext::std::Ratio>(),
-                std::ratio<2, 2>{}
-            ));
-        }
-
-        // laws
-        test::TestRing<ext::std::Ratio>{ratios};
-    }
-}
diff --git a/test/integral_constant/constexpr_init.cpp b/test/integral_constant.constexpr_init.cpp
similarity index 100%
rename from test/integral_constant/constexpr_init.cpp
rename to test/integral_constant.constexpr_init.cpp
diff --git a/test/integral_constant.cpp b/test/integral_constant.cpp
new file mode 100644
index 000000000..fb486049c
--- /dev/null
+++ b/test/integral_constant.cpp
@@ -0,0 +1,256 @@
+/*
+@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/integral_constant.hpp>
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/core/datatype.hpp>
+#include <boost/hana/tuple.hpp>
+
+#include <laws/base.hpp>
+#include <laws/comparable.hpp>
+#include <laws/constant.hpp>
+#include <laws/enumerable.hpp>
+#include <laws/group.hpp>
+#include <laws/integral_domain.hpp>
+#include <laws/logical.hpp>
+#include <laws/monoid.hpp>
+#include <laws/orderable.hpp>
+#include <laws/ring.hpp>
+
+#include <cstddef>
+#include <type_traits>
+using namespace boost::hana;
+
+
+int main() {
+    auto ints = make<Tuple>(
+        int_<-10>, int_<-2>, int_<0>, int_<1>, int_<3>, int_<4>
+    );
+    (void)ints;
+
+    auto bools = make<Tuple>(true_, false_);
+    (void)bools;
+
+#if BOOST_HANA_TEST_PART == 1
+    //////////////////////////////////////////////////////////////////////////
+    // IntegralConstant's API (like std::integral_constant)
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // operator()
+        static_assert(size_t<0>() == 0, "");
+        static_assert(size_t<1>() == 1, "");
+        static_assert(int_<-3>() == -3, "");
+
+        // decltype(operator())
+        static_assert(std::is_same<decltype(size_t<0>()), std::size_t>{}, "");
+        static_assert(std::is_same<decltype(int_<-3>()), int>{}, "");
+
+        // conversions
+        constexpr std::size_t a = size_t<0>, b = size_t<1>;
+        static_assert(a == 0 && b == 1, "");
+
+        constexpr int c = int_<0>, d = int_<-3>;
+        static_assert(c == 0 && d == -3, "");
+
+        // nested ::value
+        static_assert(decltype(int_<1>)::value == 1, "");
+
+        // nested ::type
+        static_assert(std::is_same<
+            decltype(int_<1>)::type,
+            std::remove_cv_t<decltype(int_<1>)>
+        >{}, "");
+
+        // nested ::value_type
+        static_assert(std::is_same<decltype(int_<1>)::value_type, int>{}, "");
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Make sure we can inherit _integral_constant and retain the same
+    // data type.
+    //////////////////////////////////////////////////////////////////////////
+    {
+        struct derived : _integral_constant<int, 10> { };
+        static_assert(std::is_same<datatype_t<derived>, IntegralConstant<int>>{}, "");
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Extensions to std::integral_constant
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // times member function (the other ones are tested in the examples)
+        {
+            int counter = 0;
+            int_<3>.times([&] { ++counter; });
+            BOOST_HANA_RUNTIME_CHECK(counter == 3);
+        }
+
+        // Arithmetic operators
+        {
+            BOOST_HANA_CONSTANT_CHECK(+int_<1> == int_<1>);
+            BOOST_HANA_CONSTANT_CHECK(-int_<1> == int_<-1>);
+            BOOST_HANA_CONSTANT_CHECK(int_<1> + int_<2> == int_<3>);
+            BOOST_HANA_CONSTANT_CHECK(int_<1> - int_<2> == int_<-1>);
+            BOOST_HANA_CONSTANT_CHECK(int_<3> * int_<2> == int_<6>);
+            BOOST_HANA_CONSTANT_CHECK(int_<6> / int_<3> == int_<2>);
+            BOOST_HANA_CONSTANT_CHECK(int_<6> % int_<4> == int_<2>);
+            BOOST_HANA_CONSTANT_CHECK(~int_<6> == int_<~6>);
+            BOOST_HANA_CONSTANT_CHECK((int_<6> & int_<3>) == int_<6 & 3>);
+            BOOST_HANA_CONSTANT_CHECK((int_<4> | int_<2>) == int_<4 | 2>);
+            BOOST_HANA_CONSTANT_CHECK((int_<6> ^ int_<3>) == int_<6 ^ 3>);
+            BOOST_HANA_CONSTANT_CHECK((int_<6> << int_<3>) == int_<(6 << 3)>);
+            BOOST_HANA_CONSTANT_CHECK((int_<6> >> int_<3>) == int_<(6 >> 3)>);
+        }
+
+        // Comparison operators
+        {
+            BOOST_HANA_CONSTANT_CHECK(int_<0> == int_<0>);
+            BOOST_HANA_CONSTANT_CHECK(int_<1> != int_<0>);
+            BOOST_HANA_CONSTANT_CHECK(int_<0> < int_<1>);
+            BOOST_HANA_CONSTANT_CHECK(int_<0> <= int_<1>);
+            BOOST_HANA_CONSTANT_CHECK(int_<0> <= int_<0>);
+            BOOST_HANA_CONSTANT_CHECK(int_<1> > int_<0>);
+            BOOST_HANA_CONSTANT_CHECK(int_<1> >= int_<0>);
+            BOOST_HANA_CONSTANT_CHECK(int_<0> >= int_<0>);
+        }
+
+        // Logical operators
+        {
+            BOOST_HANA_CONSTANT_CHECK(int_<3> || int_<0>);
+            BOOST_HANA_CONSTANT_CHECK(int_<3> && int_<1>);
+            BOOST_HANA_CONSTANT_CHECK(!int_<0>);
+            BOOST_HANA_CONSTANT_CHECK(!!int_<3>);
+        }
+
+        // Creation with user-defined literals
+        {
+            using namespace boost::hana::literals;
+
+            BOOST_HANA_CONSTANT_CHECK(0_c == llong<0>);
+            BOOST_HANA_CONSTANT_CHECK(1_c == llong<1>);
+            BOOST_HANA_CONSTANT_CHECK(12_c == llong<12>);
+            BOOST_HANA_CONSTANT_CHECK(123_c == llong<123>);
+            BOOST_HANA_CONSTANT_CHECK(1234567_c == llong<1234567>);
+            BOOST_HANA_CONSTANT_CHECK(-34_c == llong<-34>);
+
+            BOOST_HANA_CONSTANT_CHECK(decltype_(-1234_c) == decltype_(llong<-1234>));
+            BOOST_HANA_CONSTANT_CHECK(-12_c < 0_c);
+        }
+    }
+
+#elif BOOST_HANA_TEST_PART == 2
+    //////////////////////////////////////////////////////////////////////////
+    // Constant
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // value
+        static_assert(value(integral_constant<int, 0>) == 0, "");
+        static_assert(value(integral_constant<int, 1>) == 1, "");
+
+        // laws
+        test::TestConstant<IntegralConstant<int>>{ints};
+        test::TestConstant<IntegralConstant<bool>>{bools};
+    }
+
+#elif BOOST_HANA_TEST_PART == 3
+    //////////////////////////////////////////////////////////////////////////
+    // Enumerable, Monoid, Group
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // operators
+        static_assert(has_operator<IntegralConstant<int>, decltype(plus)>{}, "");
+        static_assert(has_operator<IntegralConstant<int>, decltype(minus)>{}, "");
+        static_assert(has_operator<IntegralConstant<int>, decltype(negate)>{}, "");
+
+        // laws
+        test::TestEnumerable<IntegralConstant<int>>{ints};
+        test::TestMonoid<IntegralConstant<int>>{ints};
+        test::TestGroup<IntegralConstant<int>>{ints};
+    }
+
+#elif BOOST_HANA_TEST_PART == 4
+    //////////////////////////////////////////////////////////////////////////
+    // Ring, IntegralDomain
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // operators
+        static_assert(has_operator<IntegralConstant<int>, decltype(mult)>{}, "");
+        static_assert(has_operator<IntegralConstant<int>, decltype(quot)>{}, "");
+        static_assert(has_operator<IntegralConstant<int>, decltype(rem)>{}, "");
+
+        // laws
+        test::TestRing<IntegralConstant<int>>{ints};
+        test::TestIntegralDomain<IntegralConstant<int>>{ints};
+    }
+
+#elif BOOST_HANA_TEST_PART == 5
+    //////////////////////////////////////////////////////////////////////////
+    // Logical
+    //////////////////////////////////////////////////////////////////////////
+    {
+        auto t = test::ct_eq<3>{};
+        auto e = test::ct_eq<4>{};
+
+        // eval_if
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                eval_if(true_, always(t), always(e)),
+                t
+            ));
+
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                eval_if(false_, always(t), always(e)),
+                e
+            ));
+        }
+
+        // not_
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(not_(true_), false_));
+            BOOST_HANA_CONSTANT_CHECK(equal(not_(false_), true_));
+        }
+
+        // operators
+        static_assert(has_operator<IntegralConstant<int>, decltype(not_)>{}, "");
+        static_assert(has_operator<IntegralConstant<int>, decltype(and_)>{}, "");
+        static_assert(has_operator<IntegralConstant<int>, decltype(or_)>{}, "");
+
+        // laws
+        auto ints = make<Tuple>(int_<-2>, int_<0>, int_<1>, int_<3>);
+        test::TestLogical<IntegralConstant<int>>{ints};
+        test::TestLogical<IntegralConstant<bool>>{bools};
+    }
+
+#elif BOOST_HANA_TEST_PART == 6
+    //////////////////////////////////////////////////////////////////////////
+    // Comparable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // operators
+        static_assert(has_operator<IntegralConstant<int>, decltype(equal)>{}, "");
+        static_assert(has_operator<IntegralConstant<int>, decltype(not_equal)>{}, "");
+
+        // laws
+        test::TestComparable<IntegralConstant<int>>{ints};
+    }
+
+#elif BOOST_HANA_TEST_PART == 7
+    //////////////////////////////////////////////////////////////////////////
+    // Orderable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // operators
+        static_assert(has_operator<IntegralConstant<int>, decltype(less)>{}, "");
+        static_assert(has_operator<IntegralConstant<int>, decltype(less_equal)>{}, "");
+        static_assert(has_operator<IntegralConstant<int>, decltype(greater)>{}, "");
+        static_assert(has_operator<IntegralConstant<int>, decltype(greater_equal)>{}, "");
+
+        // laws
+        test::TestOrderable<IntegralConstant<int>>{ints};
+    }
+#endif
+}
diff --git a/test/integral_constant/api.cpp b/test/integral_constant/api.cpp
deleted file mode 100644
index fb8c47b7a..000000000
--- a/test/integral_constant/api.cpp
+++ /dev/null
@@ -1,125 +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/integral_constant.hpp>
-
-#include <boost/hana/assert.hpp>
-#include <boost/hana/core/datatype.hpp>
-#include <boost/hana/tuple.hpp>
-#include <boost/hana/type.hpp>
-
-#include <cstddef>
-#include <type_traits>
-using namespace boost::hana;
-
-
-int main() {
-    //////////////////////////////////////////////////////////////////////////
-    // IntegralConstant's API (like std::integral_constant)
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // operator()
-        static_assert(size_t<0>() == 0, "");
-        static_assert(size_t<1>() == 1, "");
-        static_assert(int_<-3>() == -3, "");
-
-        // decltype(operator())
-        BOOST_HANA_CONSTANT_CHECK(decltype_(size_t<0>()) == type<std::size_t>);
-        BOOST_HANA_CONSTANT_CHECK(decltype_(int_<-3>()) == type<int>);
-
-        // conversions
-        constexpr std::size_t a = size_t<0>, b = size_t<1>;
-        static_assert(a == 0 && b == 1, "");
-
-        constexpr int c = int_<0>, d = int_<-3>;
-        static_assert(c == 0 && d == -3, "");
-
-        // nested ::value
-        static_assert(decltype(int_<1>)::value == 1, "");
-
-        // nested ::type
-        static_assert(std::is_same<
-            decltype(int_<1>)::type,
-            std::remove_cv_t<decltype(int_<1>)>
-        >{}, "");
-
-        // nested ::value_type
-        static_assert(std::is_same<decltype(int_<1>)::value_type, int>{}, "");
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Make sure we can inherit _integral_constant and retain the same
-    // data type.
-    //////////////////////////////////////////////////////////////////////////
-    {
-        struct derived : _integral_constant<int, 10> { };
-        static_assert(std::is_same<datatype_t<derived>, IntegralConstant<int>>{}, "");
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Extensions to std::integral_constant
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // times member function (the other ones are tested in the examples)
-        {
-            int counter = 0;
-            int_<3>.times([&] { ++counter; });
-            BOOST_HANA_RUNTIME_CHECK(counter == 3);
-        }
-
-        // Arithmetic operators
-        {
-            BOOST_HANA_CONSTANT_CHECK(+int_<1> == int_<1>);
-            BOOST_HANA_CONSTANT_CHECK(-int_<1> == int_<-1>);
-            BOOST_HANA_CONSTANT_CHECK(int_<1> + int_<2> == int_<3>);
-            BOOST_HANA_CONSTANT_CHECK(int_<1> - int_<2> == int_<-1>);
-            BOOST_HANA_CONSTANT_CHECK(int_<3> * int_<2> == int_<6>);
-            BOOST_HANA_CONSTANT_CHECK(int_<6> / int_<3> == int_<2>);
-            BOOST_HANA_CONSTANT_CHECK(int_<6> % int_<4> == int_<2>);
-            BOOST_HANA_CONSTANT_CHECK(~int_<6> == int_<~6>);
-            BOOST_HANA_CONSTANT_CHECK((int_<6> & int_<3>) == int_<6 & 3>);
-            BOOST_HANA_CONSTANT_CHECK((int_<4> | int_<2>) == int_<4 | 2>);
-            BOOST_HANA_CONSTANT_CHECK((int_<6> ^ int_<3>) == int_<6 ^ 3>);
-            BOOST_HANA_CONSTANT_CHECK((int_<6> << int_<3>) == int_<(6 << 3)>);
-            BOOST_HANA_CONSTANT_CHECK((int_<6> >> int_<3>) == int_<(6 >> 3)>);
-        }
-
-        // Comparison operators
-        {
-            BOOST_HANA_CONSTANT_CHECK(int_<0> == int_<0>);
-            BOOST_HANA_CONSTANT_CHECK(int_<1> != int_<0>);
-            BOOST_HANA_CONSTANT_CHECK(int_<0> < int_<1>);
-            BOOST_HANA_CONSTANT_CHECK(int_<0> <= int_<1>);
-            BOOST_HANA_CONSTANT_CHECK(int_<0> <= int_<0>);
-            BOOST_HANA_CONSTANT_CHECK(int_<1> > int_<0>);
-            BOOST_HANA_CONSTANT_CHECK(int_<1> >= int_<0>);
-            BOOST_HANA_CONSTANT_CHECK(int_<0> >= int_<0>);
-        }
-
-        // Logical operators
-        {
-            BOOST_HANA_CONSTANT_CHECK(int_<3> || int_<0>);
-            BOOST_HANA_CONSTANT_CHECK(int_<3> && int_<1>);
-            BOOST_HANA_CONSTANT_CHECK(!int_<0>);
-            BOOST_HANA_CONSTANT_CHECK(!!int_<3>);
-        }
-
-        // Creation with user-defined literals
-        {
-            using namespace boost::hana::literals;
-
-            BOOST_HANA_CONSTANT_CHECK(0_c == llong<0>);
-            BOOST_HANA_CONSTANT_CHECK(1_c == llong<1>);
-            BOOST_HANA_CONSTANT_CHECK(12_c == llong<12>);
-            BOOST_HANA_CONSTANT_CHECK(123_c == llong<123>);
-            BOOST_HANA_CONSTANT_CHECK(1234567_c == llong<1234567>);
-            BOOST_HANA_CONSTANT_CHECK(-34_c == llong<-34>);
-
-            BOOST_HANA_CONSTANT_CHECK(decltype_(-1234_c) == decltype_(llong<-1234>));
-            BOOST_HANA_CONSTANT_CHECK(-12_c < 0_c);
-        }
-    }
-}
diff --git a/test/integral_constant/constant.cpp b/test/integral_constant/constant.cpp
deleted file mode 100644
index 559bf7f48..000000000
--- a/test/integral_constant/constant.cpp
+++ /dev/null
@@ -1,28 +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/integral_constant.hpp>
-
-#include <boost/hana/tuple.hpp>
-
-#include <laws/constant.hpp>
-using namespace boost::hana;
-
-
-int main() {
-    //////////////////////////////////////////////////////////////////////////
-    // Constant
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // value
-        static_assert(value(integral_constant<int, 0>) == 0, "");
-        static_assert(value(integral_constant<int, 1>) == 1, "");
-
-        // laws
-        test::TestConstant<IntegralConstant<int>>{tuple_c<int, -10, -2, 0, 1, 3, 4>};
-        test::TestConstant<IntegralConstant<bool>>{tuple_c<bool, true, false>};
-    }
-}
diff --git a/test/integral_constant/integral_domain.cpp b/test/integral_constant/integral_domain.cpp
deleted file mode 100644
index f1d95c24f..000000000
--- a/test/integral_constant/integral_domain.cpp
+++ /dev/null
@@ -1,41 +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/integral_constant.hpp>
-
-#include <boost/hana/tuple.hpp>
-
-#include <laws/enumerable.hpp>
-#include <laws/group.hpp>
-#include <laws/integral_domain.hpp>
-#include <laws/monoid.hpp>
-#include <laws/ring.hpp>
-using namespace boost::hana;
-
-
-int main() {
-    auto int_constants = tuple_c<int, -10, -2, 0, 1, 3, 4>;
-
-    //////////////////////////////////////////////////////////////////////////
-    // Enumerable, Monoid, Group, Ring, IntegralDomain
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // operators
-        static_assert(has_operator<IntegralConstant<int>, decltype(plus)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(minus)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(negate)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(mult)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(quot)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(rem)>{}, "");
-
-        // laws
-        test::TestEnumerable<IntegralConstant<int>>{int_constants};
-        test::TestMonoid<IntegralConstant<int>>{int_constants};
-        test::TestGroup<IntegralConstant<int>>{int_constants};
-        test::TestRing<IntegralConstant<int>>{int_constants};
-        test::TestIntegralDomain<IntegralConstant<int>>{int_constants};
-    }
-}
diff --git a/test/integral_constant/logical.cpp b/test/integral_constant/logical.cpp
deleted file mode 100644
index 786b84030..000000000
--- a/test/integral_constant/logical.cpp
+++ /dev/null
@@ -1,53 +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/integral_constant.hpp>
-
-#include <boost/hana/assert.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/base.hpp>
-#include <laws/logical.hpp>
-using namespace boost::hana;
-
-
-int main() {
-    //////////////////////////////////////////////////////////////////////////
-    // Logical
-    //////////////////////////////////////////////////////////////////////////
-    {
-        auto t = test::ct_eq<3>{};
-        auto e = test::ct_eq<4>{};
-
-        // eval_if
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                eval_if(true_, always(t), always(e)),
-                t
-            ));
-
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                eval_if(false_, always(t), always(e)),
-                e
-            ));
-        }
-
-        // not_
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(not_(true_), false_));
-            BOOST_HANA_CONSTANT_CHECK(equal(not_(false_), true_));
-        }
-
-        // operators
-        static_assert(has_operator<IntegralConstant<int>, decltype(not_)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(and_)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(or_)>{}, "");
-
-        // laws
-        test::TestLogical<IntegralConstant<int>>{tuple_c<int, -2, 0, 1, 2>};
-        test::TestLogical<IntegralConstant<bool>>{tuple_c<bool, true, false>};
-    }
-}
diff --git a/test/integral_constant/orderable.cpp b/test/integral_constant/orderable.cpp
deleted file mode 100644
index 6bf06667a..000000000
--- a/test/integral_constant/orderable.cpp
+++ /dev/null
@@ -1,39 +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/integral_constant.hpp>
-#include <boost/hana/tuple.hpp>
-
-#include <laws/base.hpp>
-#include <laws/comparable.hpp>
-#include <laws/orderable.hpp>
-using namespace boost::hana;
-
-
-int main() {
-    //////////////////////////////////////////////////////////////////////////
-    // Setup for the laws below
-    //////////////////////////////////////////////////////////////////////////
-    auto int_constants = tuple_c<int, -10, -2, 0, 1, 3, 4>;
-
-    //////////////////////////////////////////////////////////////////////////
-    // Comparable and Orderable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // operators
-        static_assert(has_operator<IntegralConstant<int>, decltype(equal)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(not_equal)>{}, "");
-
-        static_assert(has_operator<IntegralConstant<int>, decltype(less)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(less_equal)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(greater)>{}, "");
-        static_assert(has_operator<IntegralConstant<int>, decltype(greater_equal)>{}, "");
-
-        // laws
-        test::TestComparable<IntegralConstant<int>>{int_constants};
-        test::TestOrderable<IntegralConstant<int>>{int_constants};
-    }
-}
diff --git a/test/string.cpp b/test/string.cpp
index 7792ff6f1..ed056fd38 100644
--- a/test/string.cpp
+++ b/test/string.cpp
@@ -295,6 +295,14 @@ int main() {
         static_assert(has_operator<String, decltype(greater_equal)>{}, "");
 
         // laws
+        auto strings = make<Tuple>(
+            BOOST_HANA_STRING(""),
+            BOOST_HANA_STRING("a"),
+            BOOST_HANA_STRING("ab"),
+            BOOST_HANA_STRING("abc"),
+            BOOST_HANA_STRING("ba"),
+            BOOST_HANA_STRING("abd")
+        );
         test::TestOrderable<String>{strings};
     }
 
diff --git a/test/tuple/tuple.cpp b/test/tuple.cpp
similarity index 53%
rename from test/tuple/tuple.cpp
rename to test/tuple.cpp
index a3c2a2b8a..536844895 100644
--- a/test/tuple/tuple.cpp
+++ b/test/tuple.cpp
@@ -8,11 +8,16 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/integral_constant.hpp>
 
+#include <laws/applicative.hpp>
 #include <laws/base.hpp>
 #include <laws/comparable.hpp>
 #include <laws/foldable.hpp>
+#include <laws/functor.hpp>
 #include <laws/iterable.hpp>
+#include <laws/monad.hpp>
+#include <laws/monad_plus.hpp>
 #include <laws/orderable.hpp>
+#include <laws/searchable.hpp>
 #include <laws/sequence.hpp>
 #include <laws/traversable.hpp>
 
@@ -27,9 +32,44 @@ using eq = test::ct_eq<i>;
 template <int i>
 using ord = test::ct_ord<i>;
 
-struct x0; struct x1; struct x2; struct x3;
+struct x0; struct x1; struct x2; struct x3; struct x4;
+
+template <typename ...>
+struct F { struct type; };
 
 int main() {
+    auto eq_tuples = make<Tuple>(
+          make<Tuple>()
+        , make<Tuple>(eq<0>{})
+        , make<Tuple>(eq<0>{}, eq<1>{})
+        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{})
+        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{})
+        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{})
+        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{}, eq<5>{})
+    );
+    (void)eq_tuples;
+
+    auto ord_tuples = make<Tuple>(
+          make<Tuple>()
+        , make<Tuple>(ord<0>{})
+        , make<Tuple>(ord<0>{}, ord<1>{})
+        , make<Tuple>(ord<0>{}, ord<1>{}, ord<2>{})
+        , make<Tuple>(ord<0>{}, ord<1>{}, ord<2>{}, ord<3>{})
+        , make<Tuple>(ord<0>{}, ord<1>{}, ord<2>{}, ord<3>{}, ord<4>{})
+    );
+    (void)ord_tuples;
+
+    auto nested_eqs = make<Tuple>(
+          make<Tuple>()
+        , make<Tuple>(make<Tuple>(eq<0>{}))
+        , make<Tuple>(make<Tuple>(eq<0>{}), make<Tuple>(eq<1>{}, eq<2>{}))
+        , make<Tuple>(make<Tuple>(eq<0>{}),
+                      make<Tuple>(eq<1>{}, eq<2>{}),
+                      make<Tuple>(eq<3>{}, eq<4>{}))
+    );
+    (void)nested_eqs;
+
+#if BOOST_HANA_TEST_PART == 1
     //////////////////////////////////////////////////////////////////////////
     // Move-only friendliness and reference semantics
     //////////////////////////////////////////////////////////////////////////
@@ -94,18 +134,41 @@ int main() {
     }
 
     //////////////////////////////////////////////////////////////////////////
-    // Setup for the laws below
+    // Comparable
     //////////////////////////////////////////////////////////////////////////
-    auto eq_tuples = make<Tuple>(
-          make<Tuple>()
-        , make<Tuple>(eq<0>{})
-        , make<Tuple>(eq<0>{}, eq<1>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{}, eq<5>{})
-    );
+    {
+        // equal
 
+        // tuple_t
+        BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<>, tuple_t<>));
+        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<x0>, tuple_t<>)));
+        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<>, tuple_t<x0>)));
+        BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<x0>, tuple_t<x0>));
+        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<x0, x1>, tuple_t<x0>)));
+        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<x0>, tuple_t<x0, x1>)));
+        BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<x0, x1>, tuple_t<x0, x1>));
+        BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<x0, x1, x2>, tuple_t<x0, x1, x2>));
+
+        // tuple_c
+        BOOST_HANA_CONSTANT_CHECK(equal(tuple_c<int>, tuple_c<int>));
+        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_c<int, 0>, tuple_c<int>)));
+        BOOST_HANA_CONSTANT_CHECK(equal(tuple_c<int, 0>, tuple_c<int, 0>));
+        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_c<int, 0, 1>, tuple_c<int, 0>)));
+        BOOST_HANA_CONSTANT_CHECK(equal(tuple_c<int, 0, 1>, tuple_c<int, 0, 1>));
+        BOOST_HANA_CONSTANT_CHECK(equal(tuple_c<int, 0, 1, 2>, tuple_c<int, 0, 1, 2>));
+
+        test::TestComparable<Tuple>{eq_tuples};
+    }
+
+#elif BOOST_HANA_TEST_PART == 2
+    //////////////////////////////////////////////////////////////////////////
+    // Orderable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        test::TestOrderable<Tuple>{ord_tuples};
+    }
+
+#elif BOOST_HANA_TEST_PART == 3
     //////////////////////////////////////////////////////////////////////////
     // Foldable
     //////////////////////////////////////////////////////////////////////////
@@ -158,6 +221,7 @@ int main() {
         test::TestFoldable<Tuple>{eq_tuples};
     }
 
+#elif BOOST_HANA_TEST_PART == 4
     //////////////////////////////////////////////////////////////////////////
     // Iterable
     //////////////////////////////////////////////////////////////////////////
@@ -223,10 +287,131 @@ int main() {
         test::TestTraversable<Tuple>{};
     }
 
+#elif BOOST_HANA_TEST_PART == 5
+    //////////////////////////////////////////////////////////////////////////
+    // Searchable
+    //////////////////////////////////////////////////////////////////////////
+    {
+        auto eq_tuples = make<Tuple>(
+              make<Tuple>()
+            , make<Tuple>(eq<0>{})
+            , make<Tuple>(eq<0>{}, eq<1>{})
+            , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{})
+            , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{})
+            , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{})
+        );
+
+        auto eq_tuple_keys = make<Tuple>(eq<3>{}, eq<5>{});
+        test::TestSearchable<Tuple>{eq_tuples, eq_tuple_keys};
+    }
+
+#elif BOOST_HANA_TEST_PART == 6
     //////////////////////////////////////////////////////////////////////////
     // Sequence
     //////////////////////////////////////////////////////////////////////////
     {
         test::TestSequence<Tuple>{};
     }
+
+#elif BOOST_HANA_TEST_PART == 7
+    //////////////////////////////////////////////////////////////////////////
+    // Functor
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // Test transform with tuple_t and Metafunctions
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            transform(tuple_t<>, metafunction<F>),
+            tuple_t<>
+        ));
+
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            transform(tuple_t<x1>, metafunction<F>),
+            tuple_t<F<x1>::type>
+        ));
+
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            transform(tuple_t<x1, x2>, metafunction<F>),
+            tuple_t<F<x1>::type, F<x2>::type>
+        ));
+
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            transform(tuple_t<x1, x2, x3>, metafunction<F>),
+            tuple_t<F<x1>::type, F<x2>::type, F<x3>::type>
+        ));
+
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            transform(tuple_t<x1, x2, x3, x4>, metafunction<F>),
+            tuple_t<F<x1>::type, F<x2>::type, F<x3>::type, F<x4>::type>
+        ));
+
+        BOOST_HANA_CONSTANT_CHECK(equal(
+            transform(tuple_t<x1, x2, x3, x4>, template_<F>),
+            tuple_t<F<x1>, F<x2>, F<x3>, F<x4>>
+        ));
+
+        // laws
+        auto eq_values = make<Tuple>(eq<0>{}, eq<2>{});
+        test::TestFunctor<Tuple>{eq_tuples, eq_values};
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Applicative
+    //////////////////////////////////////////////////////////////////////////
+    {
+        test::TestApplicative<Tuple>{};
+    }
+
+#elif BOOST_HANA_TEST_PART == 8
+    //////////////////////////////////////////////////////////////////////////
+    // Monad
+    //////////////////////////////////////////////////////////////////////////
+    {
+        test::TestMonad<Tuple>{eq_tuples, nested_eqs};
+    }
+
+#elif BOOST_HANA_TEST_PART == 9
+    //////////////////////////////////////////////////////////////////////////
+    // MonadPlus
+    //////////////////////////////////////////////////////////////////////////
+    {
+        // prepend
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                prepend(long_<0>, tuple_c<long>),
+                tuple_c<long, 0>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                prepend(uint<0>, tuple_c<unsigned int, 1>),
+                tuple_c<unsigned int, 0, 1>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                prepend(llong<0>, tuple_c<long long, 1, 2>),
+                tuple_c<long long, 0, 1, 2>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                prepend(ulong<0>, tuple_c<unsigned long, 1, 2, 3>),
+                tuple_c<unsigned long, 0, 1, 2, 3>
+            ));
+        }
+
+        // empty
+        {
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                empty<Tuple>(),
+                tuple_c<int>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                empty<Tuple>(),
+                tuple_c<long>
+            ));
+            BOOST_HANA_CONSTANT_CHECK(equal(
+                empty<Tuple>(),
+                tuple_c<void>
+            ));
+        }
+
+        // laws
+        test::TestMonadPlus<Tuple>{eq_tuples};
+    }
+#endif
 }
diff --git a/test/tuple/tuple_t_adl.cpp b/test/tuple.tuple_t_adl.cpp
similarity index 100%
rename from test/tuple/tuple_t_adl.cpp
rename to test/tuple.tuple_t_adl.cpp
diff --git a/test/tuple/usability_of_types.cpp b/test/tuple.usability_of_types.cpp
similarity index 100%
rename from test/tuple/usability_of_types.cpp
rename to test/tuple.usability_of_types.cpp
diff --git a/test/tuple/monad_plus.cpp b/test/tuple/monad_plus.cpp
deleted file mode 100644
index 45323110a..000000000
--- a/test/tuple/monad_plus.cpp
+++ /dev/null
@@ -1,145 +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/tuple.hpp>
-
-#include <boost/hana/integral_constant.hpp>
-
-#include <laws/applicative.hpp>
-#include <laws/base.hpp>
-#include <laws/functor.hpp>
-#include <laws/monad.hpp>
-#include <laws/monad_plus.hpp>
-using namespace boost::hana;
-
-
-// This test is in its own file to avoid crashing the compiler.
-
-template <int i>
-using eq = test::ct_eq<i>;
-
-template <typename ...>
-struct F { struct type; };
-struct t1; struct t2; struct t3; struct t4;
-
-int main() {
-    //////////////////////////////////////////////////////////////////////////
-    // Setup for the laws below
-    //////////////////////////////////////////////////////////////////////////
-    auto eq_tuples = make<Tuple>(
-          make<Tuple>()
-        , make<Tuple>(eq<0>{})
-        , make<Tuple>(eq<0>{}, eq<1>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{}, eq<5>{})
-    );
-
-    auto eq_values = make<Tuple>(eq<0>{}, eq<2>{});
-
-    auto eq_tuples_tuples = make<Tuple>(
-          make<Tuple>()
-        , make<Tuple>(make<Tuple>(eq<0>{}))
-        , make<Tuple>(make<Tuple>(eq<0>{}), make<Tuple>(eq<1>{}, eq<2>{}))
-        , make<Tuple>(make<Tuple>(eq<0>{}),
-                      make<Tuple>(eq<1>{}, eq<2>{}),
-                      make<Tuple>(eq<3>{}, eq<4>{}))
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Functor
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // Test transform with tuple_t and Metafunctions
-        BOOST_HANA_CONSTANT_CHECK(equal(
-            transform(tuple_t<>, metafunction<F>),
-            tuple_t<>
-        ));
-
-        BOOST_HANA_CONSTANT_CHECK(equal(
-            transform(tuple_t<t1>, metafunction<F>),
-            tuple_t<F<t1>::type>
-        ));
-
-        BOOST_HANA_CONSTANT_CHECK(equal(
-            transform(tuple_t<t1, t2>, metafunction<F>),
-            tuple_t<F<t1>::type, F<t2>::type>
-        ));
-
-        BOOST_HANA_CONSTANT_CHECK(equal(
-            transform(tuple_t<t1, t2, t3>, metafunction<F>),
-            tuple_t<F<t1>::type, F<t2>::type, F<t3>::type>
-        ));
-
-        BOOST_HANA_CONSTANT_CHECK(equal(
-            transform(tuple_t<t1, t2, t3, t4>, metafunction<F>),
-            tuple_t<F<t1>::type, F<t2>::type, F<t3>::type, F<t4>::type>
-        ));
-
-        BOOST_HANA_CONSTANT_CHECK(equal(
-            transform(tuple_t<t1, t2, t3, t4>, template_<F>),
-            tuple_t<F<t1>, F<t2>, F<t3>, F<t4>>
-        ));
-
-        test::TestFunctor<Tuple>{eq_tuples, eq_values};
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Applicative
-    //////////////////////////////////////////////////////////////////////////
-    {
-        test::TestApplicative<Tuple>{};
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Monad
-    //////////////////////////////////////////////////////////////////////////
-    {
-        test::TestMonad<Tuple>{eq_tuples, eq_tuples_tuples};
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // MonadPlus
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // prepend
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                prepend(long_<0>, tuple_c<long>),
-                tuple_c<long, 0>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                prepend(uint<0>, tuple_c<unsigned int, 1>),
-                tuple_c<unsigned int, 0, 1>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                prepend(llong<0>, tuple_c<long long, 1, 2>),
-                tuple_c<long long, 0, 1, 2>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                prepend(ulong<0>, tuple_c<unsigned long, 1, 2, 3>),
-                tuple_c<unsigned long, 0, 1, 2, 3>
-            ));
-        }
-
-        // empty
-        {
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                empty<Tuple>(),
-                tuple_c<int>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                empty<Tuple>(),
-                tuple_c<long>
-            ));
-            BOOST_HANA_CONSTANT_CHECK(equal(
-                empty<Tuple>(),
-                tuple_c<void>
-            ));
-        }
-
-        test::TestMonadPlus<Tuple>{eq_tuples};
-    }
-}
diff --git a/test/tuple/orderable.cpp b/test/tuple/orderable.cpp
deleted file mode 100644
index 07f350a8c..000000000
--- a/test/tuple/orderable.cpp
+++ /dev/null
@@ -1,81 +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/tuple.hpp>
-
-#include <laws/base.hpp>
-#include <laws/comparable.hpp>
-#include <laws/orderable.hpp>
-
-#include <type_traits>
-#include <utility>
-using namespace boost::hana;
-
-
-template <int i>
-using eq = test::ct_eq<i>;
-
-template <int i>
-using ord = test::ct_ord<i>;
-
-struct x0; struct x1; struct x2; struct x3;
-
-int main() {
-    //////////////////////////////////////////////////////////////////////////
-    // Setup for the laws below
-    //////////////////////////////////////////////////////////////////////////
-    auto eq_tuples = make<Tuple>(
-          make<Tuple>()
-        , make<Tuple>(eq<0>{})
-        , make<Tuple>(eq<0>{}, eq<1>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{})
-    );
-
-    auto ord_tuples = make<Tuple>(
-          make<Tuple>()
-        , make<Tuple>(ord<0>{})
-        , make<Tuple>(ord<0>{}, ord<1>{})
-        , make<Tuple>(ord<0>{}, ord<1>{}, ord<2>{})
-        , make<Tuple>(ord<0>{}, ord<1>{}, ord<2>{}, ord<3>{})
-        , make<Tuple>(ord<0>{}, ord<1>{}, ord<2>{}, ord<3>{}, ord<4>{})
-    );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Comparable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        // equal
-
-        // tuple_t
-        BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<>, tuple_t<>));
-        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<x0>, tuple_t<>)));
-        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<>, tuple_t<x0>)));
-        BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<x0>, tuple_t<x0>));
-        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<x0, x1>, tuple_t<x0>)));
-        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_t<x0>, tuple_t<x0, x1>)));
-        BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<x0, x1>, tuple_t<x0, x1>));
-        BOOST_HANA_CONSTANT_CHECK(equal(tuple_t<x0, x1, x2>, tuple_t<x0, x1, x2>));
-
-        // tuple_c
-        BOOST_HANA_CONSTANT_CHECK(equal(tuple_c<int>, tuple_c<int>));
-        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_c<int, 0>, tuple_c<int>)));
-        BOOST_HANA_CONSTANT_CHECK(equal(tuple_c<int, 0>, tuple_c<int, 0>));
-        BOOST_HANA_CONSTANT_CHECK(not_(equal(tuple_c<int, 0, 1>, tuple_c<int, 0>)));
-        BOOST_HANA_CONSTANT_CHECK(equal(tuple_c<int, 0, 1>, tuple_c<int, 0, 1>));
-        BOOST_HANA_CONSTANT_CHECK(equal(tuple_c<int, 0, 1, 2>, tuple_c<int, 0, 1, 2>));
-
-        test::TestComparable<Tuple>{eq_tuples};
-    }
-
-    //////////////////////////////////////////////////////////////////////////
-    // Orderable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        test::TestOrderable<Tuple>{ord_tuples};
-    }
-}
diff --git a/test/tuple/searchable.cpp b/test/tuple/searchable.cpp
deleted file mode 100644
index d49a7efef..000000000
--- a/test/tuple/searchable.cpp
+++ /dev/null
@@ -1,39 +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/tuple.hpp>
-
-#include <laws/base.hpp>
-#include <laws/searchable.hpp>
-using namespace boost::hana;
-
-
-// This test is in its own file to avoid crashing the compiler.
-
-template <int i>
-using eq = test::ct_eq<i>;
-
-int main() {
-    //////////////////////////////////////////////////////////////////////////
-    // Setup for the laws below
-    //////////////////////////////////////////////////////////////////////////
-    auto eq_tuples = make<Tuple>(
-          make<Tuple>()
-        , make<Tuple>(eq<0>{})
-        , make<Tuple>(eq<0>{}, eq<1>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{})
-        , make<Tuple>(eq<0>{}, eq<1>{}, eq<2>{}, eq<3>{}, eq<4>{}, eq<5>{})
-    );
-
-    auto eq_tuple_keys = make<Tuple>(eq<3>{}, eq<5>{});
-
-    //////////////////////////////////////////////////////////////////////////
-    // Searchable
-    //////////////////////////////////////////////////////////////////////////
-    {
-        test::TestSearchable<Tuple>{eq_tuples, eq_tuple_keys};
-    }
-}
diff --git a/test/type.cpp b/test/type.cpp
index d663856d9..684da2290 100644
--- a/test/type.cpp
+++ b/test/type.cpp
@@ -104,8 +104,6 @@ int main() {
 
         // laws
         auto types = make<Tuple>(
-            type<void>,
-            type<char>,
             type<T>,
             type<T*>,
             type<T&>,