diff --git a/CMakeLists.txt b/CMakeLists.txt
index c53c5442..b3238468 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -146,6 +146,7 @@ endif()
 file (GLOB_RECURSE PROJECT_FILES
     ${PROJECT_SOURCE_DIR}/include/boost/json/*.hpp
     ${PROJECT_SOURCE_DIR}/include/boost/json/*.ipp
+    ${PROJECT_SOURCE_DIR}/include/boost/json/*.natvis
 )
 
 add_subdirectory (bench)
diff --git a/bench/CMakeLists.txt b/bench/CMakeLists.txt
index 19b2f798..c2b8efc1 100644
--- a/bench/CMakeLists.txt
+++ b/bench/CMakeLists.txt
@@ -16,6 +16,8 @@ GroupSources(bench "/")
 # Disable auto-linking
 add_definitions(-DBOOST_ALL_NO_LIB=1)
 
+include_directories(../test)
+
 if (MSVC)
     if (CMAKE_BUILD_TYPE EQUAL "Debug")
     else()
diff --git a/bench/Jamfile b/bench/Jamfile
index 16381928..b681cda6 100644
--- a/bench/Jamfile
+++ b/bench/Jamfile
@@ -24,6 +24,8 @@ else
 
 exe bench :
     bench.cpp
-    : :
+    :
+    <include>../test
+    :
     $(LIB)
     ;
diff --git a/bench/bench.cpp b/bench/bench.cpp
index e82fafd9..06b24902 100644
--- a/bench/bench.cpp
+++ b/bench/bench.cpp
@@ -19,7 +19,6 @@
 #include "lib/rapidjson/include/rapidjson/stringbuffer.h"
 
 #include <boost/json.hpp>
-#include <boost/beast/_experimental/unit_test/dstream.hpp>
 #include <algorithm>
 #include <chrono>
 #include <iostream>
@@ -27,6 +26,8 @@
 #include <cstdio>
 #include <vector>
 
+#include "test_suite.hpp"
+
 /*
 
 References
@@ -37,14 +38,12 @@ http://seriot.ch/parsing_json.php
 
 */
 
-namespace beast = boost::beast;
-
 namespace boost {
 namespace json {
 
 using clock_type = std::chrono::steady_clock;
 
-beast::unit_test::dstream dout(std::cerr);
+::test_suite::debug_stream dout(std::cerr);
 std::stringstream strout;
 
 #if defined(BOOST_MSVC)
diff --git a/include/boost/json/detail/impl/array_impl.ipp b/include/boost/json/detail/impl/array_impl.ipp
index 6f874595..e78e6b3d 100644
--- a/include/boost/json/detail/impl/array_impl.ipp
+++ b/include/boost/json/detail/impl/array_impl.ipp
@@ -33,7 +33,7 @@ array_impl(
              sizeof(table) + 1)
                 / sizeof(table)
                 * sizeof(table),
-            std::max(
+            (std::max)(
                 alignof(table),
                 alignof(value)))) table;
         tab_->capacity = static_cast<
@@ -88,7 +88,7 @@ destroy_impl(
             sizeof(table) + 1)
             / sizeof(table)
             * sizeof(table),
-        std::max(
+        (std::max)(
             alignof(table),
             alignof(value)));
 }
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 56cb848d..0e2d5dd9 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -7,14 +7,16 @@
 # Official repository: https://github.com/vinniefalco/json
 #
 
-source_group (json FILES ${PROJECT_SOURCE_DIR}/include/boost/json.hpp)
-source_group (json FILES ${PROJECT_SOURCE_DIR}/include/boost/pilfer.hpp)
+source_group (boost FILES ${PROJECT_SOURCE_DIR}/include/boost/json.hpp)
+source_group (boost FILES ${PROJECT_SOURCE_DIR}/include/boost/pilfer.hpp)
 source_group (TREE ${PROJECT_SOURCE_DIR}/include/boost/json PREFIX json FILES ${PROJECT_FILES})
 
 GroupSources(test "/")
 
 add_definitions(-DBOOST_JSON_HEADER_ONLY=1)
 
+include_directories(.)
+
 add_executable (json-tests
     ${BEAST_FILES}
     ${PROJECT_FILES}
@@ -24,6 +26,7 @@ add_executable (json-tests
     ${PROJECT_SOURCE_DIR}/src/src.cpp
     Jamfile
     test.hpp
+    test_suite.hpp
     parse-vectors.hpp
     main.cpp
     _detail_number.cpp
diff --git a/test/Jamfile b/test/Jamfile
index 891a726f..afaa5e65 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -58,6 +58,7 @@ for local f in $(SOURCES)
     RUN_TESTS += [
         run $(f) main.cpp : : :
             $(LIB)
+            <include>.
         ] ;
 }
 
@@ -66,6 +67,7 @@ for local f in $(LIMIT_SOURCES)
     RUN_TESTS += [
         run $(f) main.cpp : : :
             <source>../src/src.cpp
+            <include>.
             <define>BOOST_JSON_MAX_STRING_SIZE=1000
             <define>BOOST_JSON_MAX_OBJECT_SIZE=30
             <define>BOOST_JSON_MAX_ARRAY_SIZE=100
diff --git a/test/_detail_number.cpp b/test/_detail_number.cpp
index 4e543466..b74aa3dc 100644
--- a/test/_detail_number.cpp
+++ b/test/_detail_number.cpp
@@ -10,14 +10,15 @@
 // Test that header file is self-contained.
 #include <boost/json/detail/number.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <type_traits>
 
+#include "test_suite.hpp"
+
 namespace boost {
 namespace json {
 namespace detail {
 
-class number_parser_test : public beast::unit_test::suite
+class number_parser_test
 {
 public:
     template<class F>
@@ -30,9 +31,9 @@ public:
             error_code ec;
             number_parser p;
             p.write(s.data(), s.size(), ec);
-            if(BEAST_EXPECTS(! ec, ec.message()))
+            if(BOOST_TEST(! ec))
             {
-                BEAST_EXPECT(p.is_done());
+                BOOST_TEST(p.is_done());
                 f(p.get());
             }
         }
@@ -41,18 +42,17 @@ public:
             error_code ec;
             number_parser p;
             p.write_some(s.data(), s.size(), ec);
-            if(! BEAST_EXPECTS(
-                ! ec, ec.message()))
+            if(! BOOST_TEST(! ec))
                 break;
             auto n = p.write_some("x", 1, ec);
-            if(! BEAST_EXPECT(
+            if(! BOOST_TEST(
                 p.is_done()))
                 break;
-            if(! BEAST_EXPECT(n == 0))
+            if(! BOOST_TEST(n == 0))
                 break;
             f(p.get());
             p.finish(ec);
-            BEAST_EXPECTS(! ec, ec.message());
+            BOOST_TEST(! ec);
             break;
         }
         for(size_t i = 1; i < s.size(); ++i)
@@ -60,13 +60,13 @@ public:
             error_code ec;
             number_parser p;
             p.write_some(s.data(), i, ec);
-            if(! BEAST_EXPECTS(! ec, ec.message()))
+            if(! BOOST_TEST(! ec))
                 continue;
             p.write(
                 s.data() + i, s.size() - i, ec);
-            if(! BEAST_EXPECTS(! ec, ec.message()))
+            if(! BOOST_TEST(! ec))
                 continue;
-            BEAST_EXPECT(p.is_done());
+            BOOST_TEST(p.is_done());
             f(p.get());
         }
     }
@@ -78,7 +78,7 @@ public:
         {
             number_parser p;
             p.write(s.data(), s.size(), xec);
-            BEAST_EXPECT(xec);
+            BOOST_TEST(xec);
         }
         for(size_t i = 1; i < s.size(); ++i)
         {
@@ -87,14 +87,14 @@ public:
             p.write_some(s.data(), i, ec);
             if(ec == xec)
             {
-                BEAST_PASS();
+                BOOST_TEST_PASS();
                 continue;
             }
-            if(! BEAST_EXPECTS(! ec, ec.message()))
+            if(! BOOST_TEST(! ec))
                 continue;
             p.write(
                 s.data() + i, s.size() - i, ec);
-            BEAST_EXPECT(ec == xec);
+            BOOST_TEST(ec == xec);
         }
     }
 
@@ -106,9 +106,9 @@ public:
         grind(s,
             [&](detail::number num)
             {
-                if( BEAST_EXPECT(
+                if( BOOST_TEST(
                         num.kind == kind::int64))
-                    BEAST_EXPECT(num.i == i);
+                    BOOST_TEST(num.i == i);
             });
     }
 
@@ -120,9 +120,9 @@ public:
         grind(s,
             [&](detail::number num)
             {
-                if( BEAST_EXPECT(
+                if( BOOST_TEST(
                         num.kind == kind::uint64))
-                    BEAST_EXPECT(num.u == u);
+                    BOOST_TEST(num.u == u);
             });
     }
 
@@ -134,9 +134,9 @@ public:
         grind(s,
             [&](detail::number num)
             {
-                if( BEAST_EXPECT(
+                if( BOOST_TEST(
                         num.kind == kind::double_))
-                    BEAST_EXPECT(num.d == d);
+                    BOOST_TEST(num.d == d);
             });
     }
 
@@ -293,24 +293,24 @@ public:
         // maybe_init
         {
             number_parser p;
-            BEAST_EXPECT(! p.maybe_init(0));
-            BEAST_EXPECT(! p.maybe_init('A'));
-            BEAST_EXPECT(! p.maybe_init('a'));
-            BEAST_EXPECT(! p.maybe_init('.'));
-            BEAST_EXPECT(! p.maybe_init('!'));
-            BEAST_EXPECT(! p.maybe_init(' '));
-            BEAST_EXPECT(p.maybe_init('0')); p.reset();
-            BEAST_EXPECT(p.maybe_init('1')); p.reset();
-            BEAST_EXPECT(p.maybe_init('2')); p.reset();
-            BEAST_EXPECT(p.maybe_init('3')); p.reset();
-            BEAST_EXPECT(p.maybe_init('4')); p.reset();
-            BEAST_EXPECT(p.maybe_init('5')); p.reset();
-            BEAST_EXPECT(p.maybe_init('6')); p.reset();
-            BEAST_EXPECT(p.maybe_init('7')); p.reset();
-            BEAST_EXPECT(p.maybe_init('8')); p.reset();
-            BEAST_EXPECT(p.maybe_init('9')); p.reset();
-            BEAST_EXPECT(p.maybe_init('0')); p.reset();
-            BEAST_EXPECT(p.maybe_init('-')); p.reset();
+            BOOST_TEST(! p.maybe_init(0));
+            BOOST_TEST(! p.maybe_init('A'));
+            BOOST_TEST(! p.maybe_init('a'));
+            BOOST_TEST(! p.maybe_init('.'));
+            BOOST_TEST(! p.maybe_init('!'));
+            BOOST_TEST(! p.maybe_init(' '));
+            BOOST_TEST(p.maybe_init('0')); p.reset();
+            BOOST_TEST(p.maybe_init('1')); p.reset();
+            BOOST_TEST(p.maybe_init('2')); p.reset();
+            BOOST_TEST(p.maybe_init('3')); p.reset();
+            BOOST_TEST(p.maybe_init('4')); p.reset();
+            BOOST_TEST(p.maybe_init('5')); p.reset();
+            BOOST_TEST(p.maybe_init('6')); p.reset();
+            BOOST_TEST(p.maybe_init('7')); p.reset();
+            BOOST_TEST(p.maybe_init('8')); p.reset();
+            BOOST_TEST(p.maybe_init('9')); p.reset();
+            BOOST_TEST(p.maybe_init('0')); p.reset();
+            BOOST_TEST(p.maybe_init('-')); p.reset();
         }
 
         // finish
@@ -318,25 +318,23 @@ public:
             error_code ec;
             number_parser p;
             p.write_some("0x", 2, ec);
-            if(BEAST_EXPECTS(! ec,
-                ec.message()))
+            if(BOOST_TEST(! ec))
             {
                 p.finish(ec);
-                BEAST_EXPECTS(! ec,
-                    ec.message());
+                BOOST_TEST(! ec);
             }
         }
     }
 
     void
-    run() override
+    run()
     {
         testParse();
         testMembers();
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,number_parser);
+TEST_SUITE(number_parser_test, "boost.json.detail.number_parser");
 
 } // detail
 } // json
diff --git a/test/array.cpp b/test/array.cpp
index 3f9e32db..f409cc5a 100644
--- a/test/array.cpp
+++ b/test/array.cpp
@@ -10,14 +10,13 @@
 // Test that header file is self-contained.
 #include <boost/json/array.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
-
 #include "test.hpp"
+#include "test_suite.hpp"
 
 namespace boost {
 namespace json {
 
-class array_test : public beast::unit_test::suite
+class array_test
 {
 public:
     using init_list =
@@ -44,10 +43,10 @@ public:
     void
     check(array const& a)
     {
-        BEAST_EXPECT(a.size() == 3);
-        BEAST_EXPECT(a[0].is_number());
-        BEAST_EXPECT(a[1].is_bool());
-        BEAST_EXPECT(a[2].is_string());
+        BOOST_TEST(a.size() == 3);
+        BOOST_TEST(a[0].is_number());
+        BOOST_TEST(a[1].is_bool());
+        BOOST_TEST(a[2].is_string());
     }
 
     void
@@ -70,8 +69,8 @@ public:
         // array()
         {
             array a;
-            BEAST_EXPECT(a.empty());
-            BEAST_EXPECT(a.size() == 0);
+            BOOST_TEST(a.empty());
+            BOOST_TEST(a.size() == 0);
         }
 
         // array(storage_ptr)
@@ -85,9 +84,9 @@ public:
             // default storage
             {
                 array a(3, true);
-                BEAST_EXPECT(a.size() == 3);
+                BOOST_TEST(a.size() == 3);
                 for(auto const& v : a)
-                    BEAST_EXPECT(v.is_bool());
+                    BOOST_TEST(v.is_bool());
                 check_storage(a, storage_ptr{});
             }
 
@@ -100,7 +99,7 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 array a(3, true, sp);
-                BEAST_EXPECT(a.size() == 3);
+                BOOST_TEST(a.size() == 3);
                 check_storage(a, sp);
             });
         }
@@ -110,18 +109,18 @@ public:
             // default storage
             {
                 array a(3);
-                BEAST_EXPECT(a.size() == 3);
+                BOOST_TEST(a.size() == 3);
                 for(auto const& v : a)
-                    BEAST_EXPECT(v.is_null());
+                    BOOST_TEST(v.is_null());
                 check_storage(a, storage_ptr{});
             }
 
             fail_loop([&](storage_ptr const& sp)
             {
                 array a(3, sp);
-                BEAST_EXPECT(a.size() == 3);
+                BOOST_TEST(a.size() == 3);
                 for(auto const& v : a)
-                    BEAST_EXPECT(v.is_null());
+                    BOOST_TEST(v.is_null());
                 check_storage(a, sp);
             });
         }
@@ -133,11 +132,11 @@ public:
                 init_list init{ 0, 1, str_, 3, 4 };
                 array a(init.begin(), init.end());
                 check_storage(a, storage_ptr{});
-                BEAST_EXPECT(a[0].as_int64() == 0);
-                BEAST_EXPECT(a[1].as_int64() == 1);
-                BEAST_EXPECT(a[2].as_string() == str_);
-                BEAST_EXPECT(a[3].as_int64() == 3);
-                BEAST_EXPECT(a[4].as_int64() == 4);
+                BOOST_TEST(a[0].as_int64() == 0);
+                BOOST_TEST(a[1].as_int64() == 1);
+                BOOST_TEST(a[2].as_string() == str_);
+                BOOST_TEST(a[3].as_int64() == 3);
+                BOOST_TEST(a[4].as_int64() == 4);
             }
 
             // random iterator
@@ -198,7 +197,7 @@ public:
             init_list init{ 1, true, str_ };
             array a1(init.begin(), init.end());
             array a2(pilfer(a1));
-            BEAST_EXPECT(a1.empty());
+            BOOST_TEST(a1.empty());
             check(a2);
             check_storage(a2, storage_ptr{});
         }
@@ -208,7 +207,7 @@ public:
             init_list init{ 1, true, str_ };
             array a1(init.begin(), init.end());
             array a2 = std::move(a1);
-            BEAST_EXPECT(a1.empty());
+            BOOST_TEST(a1.empty());
             check(a2);
             check_storage(a2, storage_ptr{});
         }
@@ -220,7 +219,7 @@ public:
                 array a1(init.begin(), init.end());
                 array a2(
                     std::move(a1), storage_ptr{});
-                BEAST_EXPECT(a1.empty());
+                BOOST_TEST(a1.empty());
                 check(a2);
                 check_storage(a1, storage_ptr{});
                 check_storage(a2, storage_ptr{});
@@ -231,7 +230,7 @@ public:
                 init_list init{ 1, true, str_ };
                 array a1(init.begin(), init.end());
                 array a2(std::move(a1), sp);
-                BEAST_EXPECT(! a1.empty());
+                BOOST_TEST(! a1.empty());
                 check(a2);
                 check_storage(a1, storage_ptr{});
                 check_storage(a2, sp);
@@ -298,7 +297,7 @@ public:
                 array a1({1, true, str_});
                 array a2({nullptr, object{}, 1.f});
                 a2 = std::move(a1);
-                BEAST_EXPECT(a1.empty());
+                BOOST_TEST(a1.empty());
                 check(a2);
             }
 
@@ -307,8 +306,8 @@ public:
                 array a1;
                 array a2;
                 a2 = std::move(a1);
-                BEAST_EXPECT(a1.empty());
-                BEAST_EXPECT(a2.empty());
+                BOOST_TEST(a1.empty());
+                BOOST_TEST(a2.empty());
             }
 
             fail_loop([&](storage_ptr const& sp)
@@ -369,85 +368,85 @@ public:
         // at(pos)
         {
             array a({1, true, str_});
-            BEAST_EXPECT(a.at(0).is_number());
-            BEAST_EXPECT(a.at(1).is_bool());
-            BEAST_EXPECT(a.at(2).is_string());
+            BOOST_TEST(a.at(0).is_number());
+            BOOST_TEST(a.at(1).is_bool());
+            BOOST_TEST(a.at(2).is_string());
             try
             {
                 a.at(3);
-                BEAST_FAIL();
+                BOOST_TEST_FAIL();
             }
             catch(std::out_of_range const&)
             {
-                BEAST_PASS();
+                BOOST_TEST_PASS();
             }
         }
 
         // at(pos) const
         {
             array const a({1, true, str_});
-            BEAST_EXPECT(a.at(0).is_number());
-            BEAST_EXPECT(a.at(1).is_bool());
-            BEAST_EXPECT(a.at(2).is_string());
+            BOOST_TEST(a.at(0).is_number());
+            BOOST_TEST(a.at(1).is_bool());
+            BOOST_TEST(a.at(2).is_string());
             try
             {
                 a.at(3);
-                BEAST_FAIL();
+                BOOST_TEST_FAIL();
             }
             catch(std::out_of_range const&)
             {
-                BEAST_PASS();
+                BOOST_TEST_PASS();
             }
         }
 
         // operator[&](size_type)
         {
             array a({1, true, str_});
-            BEAST_EXPECT(a[0].is_number());
-            BEAST_EXPECT(a[1].is_bool());
-            BEAST_EXPECT(a[2].is_string());
+            BOOST_TEST(a[0].is_number());
+            BOOST_TEST(a[1].is_bool());
+            BOOST_TEST(a[2].is_string());
         }
 
         // operator[&](size_type) const
         {
             array const a({1, true, str_});
-            BEAST_EXPECT(a[0].is_number());
-            BEAST_EXPECT(a[1].is_bool());
-            BEAST_EXPECT(a[2].is_string());
+            BOOST_TEST(a[0].is_number());
+            BOOST_TEST(a[1].is_bool());
+            BOOST_TEST(a[2].is_string());
         }
 
         // front()
         {
             array a({1, true, str_});
-            BEAST_EXPECT(a.front().is_number());
+            BOOST_TEST(a.front().is_number());
         }
 
         // front() const
         {
             array const a({1, true, str_});
-            BEAST_EXPECT(a.front().is_number());
+            BOOST_TEST(a.front().is_number());
         }
 
         // back()
         {
             array a({1, true, str_});
-            BEAST_EXPECT(a.back().is_string());
+            BOOST_TEST(a.back().is_string());
         }
 
         // back() const
         {
             array const a({1, true, str_});
-            BEAST_EXPECT(a.back().is_string());
+            BOOST_TEST(a.back().is_string());
         }
 
         // data()
         {
             {
                 array a({1, true, str_});
-                BEAST_EXPECT(a.data() == &a[0]);
+                BOOST_TEST(a.data() == &a[0]);
             }
             {
-                BEAST_EXPECT(array{}.data() == nullptr);
+                BOOST_TEST(array{}.data() == nullptr);
             }
         }
 
@@ -455,11 +454,11 @@ public:
         {
             {
                 array const a({1, true, str_});
-                BEAST_EXPECT(a.data() == &a[0]);
+                BOOST_TEST(a.data() == &a[0]);
             }
             {
                 array const a{};
-                BEAST_EXPECT(a.data() == nullptr);
+                BOOST_TEST(a.data() == nullptr);
             }
         }
     }
@@ -472,104 +471,104 @@ public:
 
         {
             auto it = a.begin();
-            BEAST_EXPECT(it->is_number()); ++it;
-            BEAST_EXPECT(it->is_bool());   it++;
-            BEAST_EXPECT(it->is_string()); ++it;
-            BEAST_EXPECT(it == a.end());
+            BOOST_TEST(it->is_number()); ++it;
+            BOOST_TEST(it->is_bool());   it++;
+            BOOST_TEST(it->is_string()); ++it;
+            BOOST_TEST(it == a.end());
         }
         {
             auto it = a.cbegin();
-            BEAST_EXPECT(it->is_number()); ++it;
-            BEAST_EXPECT(it->is_bool());   it++;
-            BEAST_EXPECT(it->is_string()); ++it;
-            BEAST_EXPECT(it == a.cend());
+            BOOST_TEST(it->is_number()); ++it;
+            BOOST_TEST(it->is_bool());   it++;
+            BOOST_TEST(it->is_string()); ++it;
+            BOOST_TEST(it == a.cend());
         }
         {
             auto it = ac.begin();
-            BEAST_EXPECT(it->is_number()); ++it;
-            BEAST_EXPECT(it->is_bool());   it++;
-            BEAST_EXPECT(it->is_string()); ++it;
-            BEAST_EXPECT(it == ac.end());
+            BOOST_TEST(it->is_number()); ++it;
+            BOOST_TEST(it->is_bool());   it++;
+            BOOST_TEST(it->is_string()); ++it;
+            BOOST_TEST(it == ac.end());
         }
         {
             auto it = a.end();
-            --it; BEAST_EXPECT(it->is_string());
-            it--; BEAST_EXPECT(it->is_bool());
-            --it; BEAST_EXPECT(it->is_number());
-            BEAST_EXPECT(it == a.begin());
+            --it; BOOST_TEST(it->is_string());
+            it--; BOOST_TEST(it->is_bool());
+            --it; BOOST_TEST(it->is_number());
+            BOOST_TEST(it == a.begin());
         }
         {
             auto it = a.cend();
-            --it; BEAST_EXPECT(it->is_string());
-            it--; BEAST_EXPECT(it->is_bool());
-            --it; BEAST_EXPECT(it->is_number());
-            BEAST_EXPECT(it == a.cbegin());
+            --it; BOOST_TEST(it->is_string());
+            it--; BOOST_TEST(it->is_bool());
+            --it; BOOST_TEST(it->is_number());
+            BOOST_TEST(it == a.cbegin());
         }
         {
             auto it = ac.end();
-            --it; BEAST_EXPECT(it->is_string());
-            it--; BEAST_EXPECT(it->is_bool());
-            --it; BEAST_EXPECT(it->is_number());
-            BEAST_EXPECT(it == ac.begin());
+            --it; BOOST_TEST(it->is_string());
+            it--; BOOST_TEST(it->is_bool());
+            --it; BOOST_TEST(it->is_number());
+            BOOST_TEST(it == ac.begin());
         }
 
         {
             auto it = a.rbegin();
-            BEAST_EXPECT(it->is_string()); ++it;
-            BEAST_EXPECT(it->is_bool());   it++;
-            BEAST_EXPECT(it->is_number()); ++it;
-            BEAST_EXPECT(it == a.rend());
+            BOOST_TEST(it->is_string()); ++it;
+            BOOST_TEST(it->is_bool());   it++;
+            BOOST_TEST(it->is_number()); ++it;
+            BOOST_TEST(it == a.rend());
         }
         {
             auto it = a.crbegin();
-            BEAST_EXPECT(it->is_string()); ++it;
-            BEAST_EXPECT(it->is_bool());   it++;
-            BEAST_EXPECT(it->is_number()); ++it;
-            BEAST_EXPECT(it == a.crend());
+            BOOST_TEST(it->is_string()); ++it;
+            BOOST_TEST(it->is_bool());   it++;
+            BOOST_TEST(it->is_number()); ++it;
+            BOOST_TEST(it == a.crend());
         }
         {
             auto it = ac.rbegin();
-            BEAST_EXPECT(it->is_string()); ++it;
-            BEAST_EXPECT(it->is_bool());   it++;
-            BEAST_EXPECT(it->is_number()); ++it;
-            BEAST_EXPECT(it == ac.rend());
+            BOOST_TEST(it->is_string()); ++it;
+            BOOST_TEST(it->is_bool());   it++;
+            BOOST_TEST(it->is_number()); ++it;
+            BOOST_TEST(it == ac.rend());
         }
         {
             auto it = a.rend();
-            --it; BEAST_EXPECT(it->is_number());
-            it--; BEAST_EXPECT(it->is_bool());
-            --it; BEAST_EXPECT(it->is_string());
-            BEAST_EXPECT(it == a.rbegin());
+            --it; BOOST_TEST(it->is_number());
+            it--; BOOST_TEST(it->is_bool());
+            --it; BOOST_TEST(it->is_string());
+            BOOST_TEST(it == a.rbegin());
         }
         {
             auto it = a.crend();
-            --it; BEAST_EXPECT(it->is_number());
-            it--; BEAST_EXPECT(it->is_bool());
-            --it; BEAST_EXPECT(it->is_string());
-            BEAST_EXPECT(it == a.crbegin());
+            --it; BOOST_TEST(it->is_number());
+            it--; BOOST_TEST(it->is_bool());
+            --it; BOOST_TEST(it->is_string());
+            BOOST_TEST(it == a.crbegin());
         }
         {
             auto it = ac.rend();
-            --it; BEAST_EXPECT(it->is_number());
-            it--; BEAST_EXPECT(it->is_bool());
-            --it; BEAST_EXPECT(it->is_string());
-            BEAST_EXPECT(it == ac.rbegin());
+            --it; BOOST_TEST(it->is_number());
+            it--; BOOST_TEST(it->is_bool());
+            --it; BOOST_TEST(it->is_string());
+            BOOST_TEST(it == ac.rbegin());
         }
 
         {
             array a2;
             array const& ca2(a2);
-            BEAST_EXPECT(std::distance(
+            BOOST_TEST(std::distance(
                 a2.begin(), a2.end()) == 0);
-            BEAST_EXPECT(std::distance(
+            BOOST_TEST(std::distance(
                 ca2.begin(), ca2.end()) == 0);
-            BEAST_EXPECT(std::distance(
+            BOOST_TEST(std::distance(
                 ca2.cbegin(), ca2.cend()) == 0);
-            BEAST_EXPECT(std::distance(
+            BOOST_TEST(std::distance(
                 a2.rbegin(), a2.rend()) == 0);
-            BEAST_EXPECT(std::distance(
+            BOOST_TEST(std::distance(
                 ca2.rbegin(), ca2.rend()) == 0);
-            BEAST_EXPECT(std::distance(
+            BOOST_TEST(std::distance(
                 ca2.crbegin(), ca2.crend()) == 0);
         }
     }
@@ -581,32 +580,32 @@ public:
         {
             {
                 array a;
-                BEAST_EXPECT(a.empty());
+                BOOST_TEST(a.empty());
                 a.emplace_back(1);
-                BEAST_EXPECT(! a.empty());
+                BOOST_TEST(! a.empty());
             }
 
             {
                 array a({1, 2});
-                BEAST_EXPECT(! a.empty());
+                BOOST_TEST(! a.empty());
                 a.clear();
-                BEAST_EXPECT(a.empty());
-                BEAST_EXPECT(a.capacity() > 0);
+                BOOST_TEST(a.empty());
+                BOOST_TEST(a.capacity() > 0);
             }
         }
 
         // size()
         {
             array a;
-            BEAST_EXPECT(a.size() == 0);
+            BOOST_TEST(a.size() == 0);
             a.emplace_back(1);
-            BEAST_EXPECT(a.size() == 1);
+            BOOST_TEST(a.size() == 1);
         }
 
         // max_size()
         {
             array a;
-            BEAST_EXPECT(a.max_size() > 0);
+            BOOST_TEST(a.max_size() > 0);
         }
 
         // reserve()
@@ -629,7 +628,7 @@ public:
             {
                 array a;
                 a.reserve(50);
-                BEAST_EXPECT(a.capacity() >= 50);
+                BOOST_TEST(a.capacity() >= 50);
             }
 
             fail_loop([&](storage_ptr const& sp)
@@ -637,16 +636,16 @@ public:
                 array a(min_capacity_, 'c', sp);
                 a.reserve(a.capacity() + 1);
                 auto const new_cap = a.capacity();
-                BEAST_EXPECT(new_cap > min_capacity_);
+                BOOST_TEST(new_cap > min_capacity_);
                 a.reserve((min_capacity_ + new_cap) / 2);
-                BEAST_EXPECT(a.capacity() == new_cap);
+                BOOST_TEST(a.capacity() == new_cap);
             });
         }
 
         // capacity()
         {
             array a;
-            BEAST_EXPECT(a.capacity() == 0);
+            BOOST_TEST(a.capacity() == 0);
         }
 
         // shrink_to_fit()
@@ -654,16 +653,16 @@ public:
             {
                 array a(1);
                 a.shrink_to_fit();
-                BEAST_EXPECT(a.size() == 1);
-                BEAST_EXPECT(a.capacity() >= 1);
+                BOOST_TEST(a.size() == 1);
+                BOOST_TEST(a.capacity() >= 1);
             }
 
             {
                 array a(min_capacity_, 'c');
-                BEAST_EXPECT(a.capacity() >= min_capacity_);
+                BOOST_TEST(a.capacity() >= min_capacity_);
                 a.erase(a.begin(), a.begin() + 2);
                 a.shrink_to_fit();
-                BEAST_EXPECT(a.capacity() == min_capacity_);
+                BOOST_TEST(a.capacity() == min_capacity_);
             }
 
             fail_loop([&](storage_ptr const& sp)
@@ -671,23 +670,23 @@ public:
                 array a(1, sp);
                 a.resize(a.capacity());
                 a.shrink_to_fit();
-                BEAST_EXPECT(a.size() == a.capacity());
+                BOOST_TEST(a.size() == a.capacity());
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 array a(sp);
                 a.reserve(10);
-                BEAST_EXPECT(a.capacity() >= 10);
+                BOOST_TEST(a.capacity() >= 10);
                 a.shrink_to_fit();
-                BEAST_EXPECT(a.capacity() == 0);
+                BOOST_TEST(a.capacity() == 0);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 array a(min_capacity_, sp);
                 a.reserve(min_capacity_ * 2);
-                BEAST_EXPECT(a.capacity() >=
+                BOOST_TEST(a.capacity() >=
                     min_capacity_ * 2);
                 a.shrink_to_fit();
                 if(a.capacity() > min_capacity_)
@@ -703,17 +702,17 @@ public:
         {
             {
                 array a;
-                BEAST_EXPECT(a.size() == 0);
-                BEAST_EXPECT(a.capacity() == 0);
+                BOOST_TEST(a.size() == 0);
+                BOOST_TEST(a.capacity() == 0);
                 a.clear();
-                BEAST_EXPECT(a.size() == 0);
-                BEAST_EXPECT(a.capacity() == 0);
+                BOOST_TEST(a.size() == 0);
+                BOOST_TEST(a.capacity() == 0);
             }
             {
                 array a({1, true, str_});
                 a.clear();
-                BEAST_EXPECT(a.size() == 0);
-                BEAST_EXPECT(a.capacity() > 0);
+                BOOST_TEST(a.size() == 0);
+                BOOST_TEST(a.capacity() > 0);
             }
         }
 
@@ -744,11 +743,11 @@ public:
             value v({1,2,3});
             array a({1, str_}, sp);
             a.insert(a.begin() + 1, 3, v);
-            BEAST_EXPECT(a[0].is_number());
-            BEAST_EXPECT(a[1].as_array().size() == 3);
-            BEAST_EXPECT(a[2].as_array().size() == 3);
-            BEAST_EXPECT(a[3].as_array().size() == 3);
-            BEAST_EXPECT(a[4].is_string());
+            BOOST_TEST(a[0].is_number());
+            BOOST_TEST(a[1].as_array().size() == 3);
+            BOOST_TEST(a[2].as_array().size() == 3);
+            BOOST_TEST(a[3].as_array().size() == 3);
+            BOOST_TEST(a[4].is_string());
         });
 
         // insert(const_iterator, InputIt, InputIt)
@@ -772,7 +771,7 @@ public:
                      7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
                     17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
                     27, 28, 29, 30 };
-                BEAST_EXPECT(init.size() > min_capacity_);
+                BOOST_TEST(init.size() > min_capacity_);
                 array a(sp);
                 a.insert(a.begin(),
                     init.begin(), init.end());
@@ -785,7 +784,7 @@ public:
                 a.insert(a.begin(),
                     make_input_iterator(init.begin()),
                     make_input_iterator(init.end()));
-                BEAST_EXPECT(a.empty());
+                BOOST_TEST(a.empty());
             }
 
             // input iterator
@@ -809,7 +808,7 @@ public:
                 a.insert(a.begin(),
                     make_input_iterator(init.begin()),
                     make_input_iterator(init.end()));
-                BEAST_EXPECT(a.size() == init.size() + 1);
+                BOOST_TEST(a.size() == init.size() + 1);
             });
 
             // backward relocate
@@ -829,12 +828,12 @@ public:
             array a({0, 3, 4}, sp);
             auto it = a.insert(
                 a.begin() + 1, {1, str_});
-            BEAST_EXPECT(it == a.begin() + 1);
-            BEAST_EXPECT(a[0].as_int64() == 0);
-            BEAST_EXPECT(a[1].as_int64() == 1);
-            BEAST_EXPECT(a[2].as_string() == str_);
-            BEAST_EXPECT(a[3].as_int64() == 3);
-            BEAST_EXPECT(a[4].as_int64() == 4);
+            BOOST_TEST(it == a.begin() + 1);
+            BOOST_TEST(a[0].as_int64() == 0);
+            BOOST_TEST(a[1].as_int64() == 1);
+            BOOST_TEST(a[2].as_string() == str_);
+            BOOST_TEST(a[3].as_int64() == 3);
+            BOOST_TEST(a[4].as_int64() == 4);
         });
 
         // emplace(const_iterator, arg)
@@ -843,12 +842,12 @@ public:
             array a({0, 2, 3, 4}, sp);
             auto it = a.emplace(
                 a.begin() + 1, str_);
-            BEAST_EXPECT(it == a.begin() + 1);
-            BEAST_EXPECT(a[0].as_int64() == 0);
-            BEAST_EXPECT(a[1].as_string() == str_);
-            BEAST_EXPECT(a[2].as_int64() == 2);
-            BEAST_EXPECT(a[3].as_int64() == 3);
-            BEAST_EXPECT(a[4].as_int64() == 4);
+            BOOST_TEST(it == a.begin() + 1);
+            BOOST_TEST(a[0].as_int64() == 0);
+            BOOST_TEST(a[1].as_string() == str_);
+            BOOST_TEST(a[2].as_int64() == 2);
+            BOOST_TEST(a[3].as_int64() == 3);
+            BOOST_TEST(a[4].as_int64() == 4);
         });
 
         // erase(pos)
@@ -873,7 +872,7 @@ public:
             array a({1, true}, sp);
             value v(str_);
             a.push_back(v);
-            BEAST_EXPECT(
+            BOOST_TEST(
                 v.as_string() == str_);
             check(a);
             check_storage(a, sp);
@@ -920,7 +919,7 @@ public:
             {
                 array a(5, sp);
                 a.resize(3);
-                BEAST_EXPECT(a.size() == 3);
+                BOOST_TEST(a.size() == 3);
                 check_storage(a, sp);
             });
 
@@ -928,7 +927,7 @@ public:
             {
                 array a(sp);
                 a.resize(3);
-                BEAST_EXPECT(a.size() == 3);
+                BOOST_TEST(a.size() == 3);
                 check_storage(a, sp);
             });
         }
@@ -944,7 +943,7 @@ public:
             {
                 array a(5, v, sp);
                 a.resize(3, v);
-                BEAST_EXPECT(a.size() == 3);
+                BOOST_TEST(a.size() == 3);
                 check_storage(a, sp);
             });
 
@@ -952,7 +951,7 @@ public:
             {
                 array a(3, v, sp);
                 a.resize(5, v);
-                BEAST_EXPECT(a.size() == 5);
+                BOOST_TEST(a.size() == 5);
                 check_storage(a, sp);
             });
         }
@@ -965,9 +964,9 @@ public:
                 array a2 = {1.};
                 a1.swap(a2);
                 check(a2);
-                BEAST_EXPECT(a1.size() == 1);
-                BEAST_EXPECT(a1.front().is_number());
-                BEAST_EXPECT(a1.front().as_double() == 1.);
+                BOOST_TEST(a1.size() == 1);
+                BOOST_TEST(a1.front().is_number());
+                BOOST_TEST(a1.front().as_double() == 1.);
             }
 
             // different storage
@@ -977,7 +976,7 @@ public:
                 array a2 = {1.};
                 a1.swap(a2);
                 check(a2);
-                BEAST_EXPECT(a1.size() == 1);
+                BOOST_TEST(a1.size() == 1);
             });
             fail_loop([&](storage_ptr const& sp)
             {
@@ -985,7 +984,7 @@ public:
                 array a2({1, true, str_}, sp);
                 a1.swap(a2);
                 check(a1);
-                BEAST_EXPECT(a2.size() == 1);
+                BOOST_TEST(a2.size() == 1);
             });
         }
     }
@@ -1025,12 +1024,12 @@ public:
             a.insert(a.begin() + 1,
                 3, nullptr);
             a1 = a;
-            BEAST_EXPECT(a1.size() == 5);
-            BEAST_EXPECT(a1[0].is_number());
-            BEAST_EXPECT(a1[1].is_null());
-            BEAST_EXPECT(a1[2].is_null());
-            BEAST_EXPECT(a1[3].is_null());
-            BEAST_EXPECT(a1[4].is_bool());
+            BOOST_TEST(a1.size() == 5);
+            BOOST_TEST(a1[0].is_number());
+            BOOST_TEST(a1[1].is_null());
+            BOOST_TEST(a1[2].is_null());
+            BOOST_TEST(a1[3].is_null());
+            BOOST_TEST(a1[4].is_bool());
         });
 
         // insert(const_iterator, InputIt, InputIt)
@@ -1052,10 +1051,10 @@ public:
             array a({1, nullptr}, sp);
             a.emplace(a.begin() + 1, true);
             a1 = a;
-            BEAST_EXPECT(a1.size() == 3);
-            BEAST_EXPECT(a1[0].is_number());
-            BEAST_EXPECT(a1[1].is_bool());
-            BEAST_EXPECT(a1[2].is_null());
+            BOOST_TEST(a1.size() == 3);
+            BOOST_TEST(a1[0].is_number());
+            BOOST_TEST(a1[1].is_bool());
+            BOOST_TEST(a1[2].is_null());
         });
 
         // emplace(const_iterator, arg)
@@ -1066,15 +1065,15 @@ public:
             a.emplace(a.begin() + 1, true);
             a1 = a;
             check(a1);
-            BEAST_EXPECT(a1.size() == 3);
-            BEAST_EXPECT(a1[0].is_number());
-            BEAST_EXPECT(a1[1].is_bool());
-            BEAST_EXPECT(a1[2].is_string());
+            BOOST_TEST(a1.size() == 3);
+            BOOST_TEST(a1[0].is_number());
+            BOOST_TEST(a1[1].is_bool());
+            BOOST_TEST(a1[2].is_string());
         });
     }
 
     void
-    run() override
+    run()
     {
         testCtors();
         testAssignment();
@@ -1087,7 +1086,7 @@ public:
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,array);
+TEST_SUITE(array_test, "boost.json.array");
 
 } // json
 } // boost
diff --git a/test/basic_parser.cpp b/test/basic_parser.cpp
index cb4474b0..650ca04b 100644
--- a/test/basic_parser.cpp
+++ b/test/basic_parser.cpp
@@ -10,13 +10,13 @@
 // Test that header file is self-contained.
 #include <boost/json/basic_parser.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <memory>
 #include <string>
 #include <utility>
 
-#include "test.hpp"
 #include "parse-vectors.hpp"
+#include "test.hpp"
+#include "test_suite.hpp"
 
 namespace boost {
 namespace json {
@@ -140,9 +140,11 @@ validate( string_view s )
 
 } // (anon)
 
-class basic_parser_test : public beast::unit_test::suite
+class basic_parser_test
 {
 public:
+    ::test_suite::log_type log;
+
     void
     split_grind(
         string_view s,
@@ -153,7 +155,7 @@ public:
         for(std::size_t i = 1;
             i < s.size(); ++i)
         {
-            if(! BEAST_EXPECT(i < 100000))
+            if(! BOOST_TEST(i < 100000))
                 break;
             error_code ec;
             fail_parser p;
@@ -161,8 +163,7 @@ public:
                 p.write_some(s.data(), i, ec);
             if(ec)
             {
-                BEAST_EXPECTS(ec == ex,
-                    ec.message());
+                BOOST_TEST(ec == ex);
                 continue;
             }
             p.write(
@@ -170,8 +171,7 @@ public:
                 s.size() - n, ec);
             if(! ec)
                 p.finish(ec);
-            if(! BEAST_EXPECTS(ec == ex,
-                ec.message()))
+            if(! BOOST_TEST(ec == ex))
                 log << "should be " << ex.message() << std::endl;
         }
     }
@@ -184,7 +184,7 @@ public:
         // exercise all error paths
         for(std::size_t j = 1;;++j)
         {
-            if(! BEAST_EXPECT(j < 100000))
+            if(! BOOST_TEST(j < 100000))
                 break;
             error_code ec;
             fail_parser p(j);
@@ -194,8 +194,7 @@ public:
                 p.finish(ec);
             if(ec == error::test_failure)
                 continue;
-            BEAST_EXPECTS(ec == ex,
-                ec.message());
+            BOOST_TEST(ec == ex);
             break;
         }
     }
@@ -208,7 +207,7 @@ public:
         // exercise all exception paths
         for(std::size_t j = 1;;++j)
         {
-            if(! BEAST_EXPECT(j < 100000))
+            if(! BOOST_TEST(j < 100000))
                 break;
             error_code ec;
             throw_parser p(j);
@@ -218,8 +217,7 @@ public:
                     s.data(), s.size(), ec);
                 if(! ec)
                     p.finish(ec);
-                BEAST_EXPECTS(ec == ex,
-                    ec.message());
+                BOOST_TEST(ec == ex);
                 break;
             }
             catch(test_exception const&)
@@ -228,7 +226,7 @@ public:
             }
             catch(std::exception const& e)
             {
-                BEAST_FAIL();
+                BOOST_TEST_FAIL();
                 log << "  " <<
                     e.what() << std::endl;
             }
@@ -249,13 +247,12 @@ public:
                 p.finish(ex);
             if(good)
             {
-                if(! BEAST_EXPECTS(
-                    ! ex, ex.message()))
+                if(! BOOST_TEST(! ex))
                     return;
             }
             else
             {
-                if(! BEAST_EXPECT(ex))
+                if(! BOOST_TEST(ex))
                     return;
             }
         }
@@ -483,10 +480,9 @@ public:
             p.write_some(
                 s.data(), s.size(),
                 ec);
-            if(! BEAST_EXPECTS(! ec,
-                ec.message()))
+            if(! BOOST_TEST(! ec))
                 return;
-            BEAST_EXPECT(is_done ==
+            BOOST_TEST(is_done ==
                 p.is_done());
         };
 
@@ -537,43 +533,40 @@ public:
             {
                 error_code ec;
                 fail_parser p;
-                BEAST_EXPECT(
+                BOOST_TEST(
                     p.depth() == 0);
-                BEAST_EXPECT(
+                BOOST_TEST(
                     p.max_depth() > 0);
                 p.max_depth(1);
                 p.write("[{}]", 4, ec);
-                BEAST_EXPECTS(
-                    ec == error::too_deep,
-                    ec.message());
-                BEAST_EXPECT(! p.is_done());
+                BOOST_TEST(
+                    ec == error::too_deep);
+                BOOST_TEST(! p.is_done());
             }
             {
                 error_code ec;
                 fail_parser p;
-                BEAST_EXPECT(
+                BOOST_TEST(
                     p.max_depth() > 0);
                 p.max_depth(1);
                 p.write_some("[", 1, ec);
-                BEAST_EXPECT(p.depth() == 1);
-                if(BEAST_EXPECTS(! ec,
-                    ec.message()))
+                BOOST_TEST(p.depth() == 1);
+                if(BOOST_TEST(! ec))
                 {
                     p.write_some("{", 1, ec);
-                    BEAST_EXPECTS(
-                        ec == error::too_deep,
-                        ec.message());
+                    BOOST_TEST(
+                        ec == error::too_deep);
                 }
-                BEAST_EXPECT(! p.is_done());
+                BOOST_TEST(! p.is_done());
                 ec = {};
                 p.write_some("{}", 2, ec);
-                BEAST_EXPECT(ec);
+                BOOST_TEST(ec);
                 p.reset();
                 p.write("{}", 2, ec);
                 if(! ec)
                     p.finish(ec);
-                BEAST_EXPECTS(! ec, ec.message());
-                BEAST_EXPECT(p.is_done());
+                BOOST_TEST(! ec);
+                BOOST_TEST(p.is_done());
             }
         }
 
@@ -612,7 +605,7 @@ public:
             error_code ec;
             fail_parser p;
             p.finish(ec);
-            BEAST_EXPECT(ec);
+            BOOST_TEST(ec);
         }
     }
 
@@ -625,7 +618,7 @@ public:
                 error_code ec;
                 fail_parser p;
                 p.write_some("0", 1, ec);
-                BEAST_EXPECTS(! ec, ec.message());
+                BOOST_TEST(! ec);
             }
 
             // partial write
@@ -634,15 +627,15 @@ public:
                 fail_parser p;
                 auto const n =
                     p.write_some("null x", 6, ec);
-                BEAST_EXPECTS(! ec, ec.message());
-                BEAST_EXPECT(n < 6);
+                BOOST_TEST(! ec);
+                BOOST_TEST(n < 6);
             }
         }
 
         // write_some(char const*, size_t)
         {
             fail_parser p;
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 p.write_some("x", 1),
                 system_error);
         }
@@ -652,9 +645,8 @@ public:
             error_code ec;
             fail_parser p;
             p.write("0x", 2, ec);
-            BEAST_EXPECTS(
-                ec == error::extra_data,
-                ec.message());
+            BOOST_TEST(
+                ec == error::extra_data);
         }
 
         // write(char const*, size_t)
@@ -666,7 +658,7 @@ public:
 
             {
                 fail_parser p;
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     p.write("0x", 2),
                     system_error);
             }
@@ -677,9 +669,8 @@ public:
             error_code ec;
             fail_parser p;
             p.finish("{", 1, ec);
-            BEAST_EXPECTS(
-                ec == error::incomplete,
-                ec.message());
+            BOOST_TEST(
+                ec == error::incomplete);
         }
 
         // finish(char const*, size_t)
@@ -691,7 +682,7 @@ public:
 
             {
                 fail_parser p;
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     p.finish("{", 1),
                     system_error);
             }
@@ -702,16 +693,16 @@ public:
             {
                 fail_parser p;
                 p.write("{}", 2);
-                BEAST_EXPECT(! p.is_done());
+                BOOST_TEST(! p.is_done());
                 p.finish();
-                BEAST_EXPECT(p.is_done());
+                BOOST_TEST(p.is_done());
             }
 
             {
                 fail_parser p;
                 p.write("{", 1);
-                BEAST_EXPECT(! p.is_done());
-                BEAST_THROWS(
+                BOOST_TEST(! p.is_done());
+                BOOST_TEST_THROWS(
                     p.finish(),
                     system_error);
             }
@@ -797,11 +788,11 @@ public:
         base64::decode(
             p.get(), s.data(), s.size());
         string_view const js(p.get(), len);
-        BEAST_EXPECT(! validate(js));
+        BOOST_TEST(! validate(js));
     }
 
     void
-    run() override
+    run()
     {
         testObject();
         testArray();
@@ -818,7 +809,7 @@ public:
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,basic_parser);
+TEST_SUITE(basic_parser_test, "boost.json.basic_parser");
 
 } // json
 } // boost
diff --git a/test/error.cpp b/test/error.cpp
index d3e94cac..ef79f221 100644
--- a/test/error.cpp
+++ b/test/error.cpp
@@ -10,21 +10,22 @@
 // Test that header file is self-contained.
 #include <boost/json/error.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <memory>
 
+#include "test_suite.hpp"
+
 namespace boost {
 namespace json {
 
-class error_test : public beast::unit_test::suite
+class error_test
 {
 public:
     void check(error e)
     {
         auto const ec = make_error_code(e);
-        BEAST_EXPECT(ec.category().name() != nullptr);
-        BEAST_EXPECT(! ec.message().empty());
-        BEAST_EXPECT(ec.category().default_error_condition(
+        BOOST_TEST(ec.category().name() != nullptr);
+        BOOST_TEST(! ec.message().empty());
+        BOOST_TEST(ec.category().default_error_condition(
             static_cast<int>(e)).category() == ec.category());
     }
 
@@ -32,20 +33,20 @@ public:
     {
         {
             auto const ec = make_error_code(e);
-            BEAST_EXPECT(ec.category().name() != nullptr);
-            BEAST_EXPECT(! ec.message().empty());
-            BEAST_EXPECT(ec == c);
+            BOOST_TEST(ec.category().name() != nullptr);
+            BOOST_TEST(! ec.message().empty());
+            BOOST_TEST(ec == c);
         }
         {
             auto ec = make_error_condition(c);
-            BEAST_EXPECT(ec.category().name() != nullptr);
-            BEAST_EXPECT(! ec.message().empty());
-            BEAST_EXPECT(ec == c);
+            BOOST_TEST(ec.category().name() != nullptr);
+            BOOST_TEST(! ec.message().empty());
+            BOOST_TEST(ec == c);
         }
     }
 
     void
-    run() override
+    run()
     {
         check(condition::parse_error, error::syntax);
         check(condition::parse_error, error::extra_data);
@@ -88,7 +89,7 @@ public:
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,error);
+TEST_SUITE(error_test, "boost.json.error");
 
 } // json
 } // boost
diff --git a/test/json.cpp b/test/json.cpp
index d971aae3..caf43673 100644
--- a/test/json.cpp
+++ b/test/json.cpp
@@ -10,16 +10,18 @@
 // Test that header file is self-contained.
 #include <boost/json.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
+#include "test_suite.hpp"
 
 namespace boost {
-namespace json {
 
-struct zjson_test : public beast::unit_test::suite
+struct json_test
 {
+    ::test_suite::log_type log;
+
     void
-    run() override
+    run()
     {
+        using namespace json;
         log <<
             "sizeof(alignof)\n"
             "  object        == " << sizeof(object) << " (" << alignof(object) << ")\n"
@@ -28,16 +30,14 @@ struct zjson_test : public beast::unit_test::suite
             "  string        == " << sizeof(string) << " (" << alignof(string) << ")\n"
             "  value         == " << sizeof(value) << " (" << alignof(value) << ")\n"
             "  serializer    == " << sizeof(serializer) << "\n"
-            "  number_parser == " << sizeof(detail::number_parser) << "\n"
+            "  number_parser == " << sizeof(json::detail::number_parser) << "\n"
             "  basic_parser  == " << sizeof(basic_parser) << "\n"
-            "  parser        == " << sizeof(parser) << "\n"
-            << std::endl;
+            "  parser        == " << sizeof(parser)
             ;
-        pass();
+        BOOST_TEST_PASS();
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,zjson);
+TEST_SUITE(json_test, "boost.json.zsizes");
 
-} // json
 } // boost
diff --git a/test/kind.cpp b/test/kind.cpp
index b0967375..56281bfb 100644
--- a/test/kind.cpp
+++ b/test/kind.cpp
@@ -10,13 +10,14 @@
 // Test that header file is self-contained.
 #include <boost/json/kind.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <type_traits>
 
+#include "test_suite.hpp"
+
 namespace boost {
 namespace json {
 
-class kind_test : public beast::unit_test::suite
+class kind_test
 {
 public:
     BOOST_STATIC_ASSERT(
@@ -25,16 +26,16 @@ public:
     void
     testEnum()
     {
-        pass();
+        BOOST_TEST_PASS();
     }
 
-    void run() override
+    void run()
     {
         testEnum();
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,kind);
+TEST_SUITE(kind_test, "boost.json.kind");
 
 } // json
 } // boost
diff --git a/test/limits.cpp b/test/limits.cpp
index 90912888..be4eeeba 100644
--- a/test/limits.cpp
+++ b/test/limits.cpp
@@ -13,10 +13,11 @@
 #include <boost/json/value.hpp>
 #include <boost/json/parser.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
-#include "test.hpp"
 #include <vector>
 
+#include "test_suite.hpp"
+#include "test.hpp"
+
 namespace boost {
 namespace json {
 
@@ -26,7 +27,7 @@ namespace json {
     length.
 */
 
-class limits_test : public beast::unit_test::suite
+class limits_test
 {
 public:
     void
@@ -43,8 +44,8 @@ public:
             {"21",21},{"22",22},{"23",23},{"24",24},{"25",25},
             {"26",26},{"27",27},{"28",28},{"29",29},{"30",30},
             {"31",31}};
-            BEAST_EXPECT(init.size() > object::max_size());
-            BEAST_THROWS(value{init}, std::length_error);
+            BOOST_TEST(init.size() > object::max_size());
+            BOOST_TEST_THROWS(value{init}, std::length_error);
         }
     }
 
@@ -53,7 +54,7 @@ public:
     {
         // max size
         {
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 object(object::max_size()+1),
                 std::length_error);
         }
@@ -69,11 +70,11 @@ public:
             {"21",21},{"22",22},{"23",23},{"24",24},{"25",25},
             {"26",26},{"27",27},{"28",28},{"29",29},{"30",30},
             {"31",31}};
-            BEAST_EXPECT(init.size() > object::max_size());
-            BEAST_THROWS(
+            BOOST_TEST(init.size() > object::max_size());
+            BOOST_TEST_THROWS(
                 object(init.begin(), init.end()),
                 std::length_error);
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 object(
                     make_input_iterator(init.begin()),
                     make_input_iterator(init.end())),
@@ -84,7 +85,7 @@ public:
         {
             std::string const big(
                 string::max_size() + 1, '*');
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 object({ {big, nullptr} }),
                 std::length_error);
         }
@@ -94,7 +95,7 @@ public:
     testArray()
     {
         {
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 array(
                     array::max_size()+1,
                     value(nullptr)),
@@ -104,7 +105,7 @@ public:
         {
             std::vector<int> v(
                 array::max_size()+1, 42);
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 array(v.begin(), v.end()),
                 std::length_error);
         }
@@ -112,7 +113,7 @@ public:
         {
             std::vector<int> v(
                 array::max_size()+1, 42);
-            BEAST_THROWS(array(
+            BOOST_TEST_THROWS(array(
                 make_input_iterator(v.begin()),
                 make_input_iterator(v.end())),
                 std::length_error);
@@ -120,7 +121,7 @@ public:
 
         {
             array a;
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 a.insert(a.begin(),
                     array::max_size() + 1,
                     nullptr),
@@ -135,7 +136,7 @@ public:
         {
             {
                 string s;
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     (s.resize(s.max_size() + 1)),
                     std::length_error);
             }
@@ -143,7 +144,7 @@ public:
             {
                 string s;
                 s.resize(100);
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     (s.append(s.max_size() - 1, '*')),
                     std::length_error);
             }
@@ -171,7 +172,7 @@ public:
             auto const js =
                 "\"" + big + "\":null";
             value jv;
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 jv = parse(js),
                 std::length_error);
         }
@@ -184,7 +185,7 @@ public:
             auto const js =
                 "{\"" + big + "\":null}";
             value jv;
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 jv = parse(js),
                 std::length_error);
         }
@@ -197,7 +198,7 @@ public:
         {
             std::string big;
             value jv;
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 jv = parse(
                    "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
                     "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
@@ -231,7 +232,7 @@ public:
             auto const js =
                 "\"" + big + "\"";
             value jv;
-            BEAST_THROWS(jv = parse(js),
+            BOOST_TEST_THROWS(jv = parse(js),
                 decltype(detail::string_too_large_exception()));
         }
 
@@ -244,13 +245,13 @@ public:
             auto const js =
                 "\"" + big + "\"";
             value jv;
-            BEAST_THROWS(jv = parse(js),
+            BOOST_TEST_THROWS(jv = parse(js),
                 decltype(detail::string_too_large_exception()));
         }
     }
 
     void
-    run() override
+    run()
     {
     #if ! defined(BOOST_JSON_NO_MAX_OBJECT_SIZE) && \
         ! defined(BOOST_JSON_NO_MAX_ARRAY_SIZE) && \
@@ -266,12 +267,12 @@ public:
         testParser();
 
     #else
-        pass();
+        BOOST_TEST_PASS();
     #endif
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,limits);
+TEST_SUITE(limits_test, "boost.json.limits");
 
 } // json
 } // boost
diff --git a/test/main.cpp b/test/main.cpp
index cad92c74..562435c6 100644
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -7,4 +7,25 @@
 // Official repository: https://github.com/vinniefalco/json
 //
 
-#include <boost/beast/_experimental/unit_test/main.ipp>
+#include "test_suite.hpp"
+
+#include <iostream>
+#ifdef _MSC_VER
+#include <crtdbg.h>
+#endif
+
+// Simple main used to produce stand
+// alone executables that run unit tests.
+int main(int argc, char const* const* argv)
+{
+#ifdef _MSC_VER
+    {
+        int flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flags |= _CRTDBG_LEAK_CHECK_DF;
+        _CrtSetDbgFlag(flags);
+    }
+#endif
+
+    ::test_suite::debug_stream log(std::cerr);
+    return ::test_suite::run(log, argc, argv);
+}
diff --git a/test/number_cast.cpp b/test/number_cast.cpp
index 9a895325..61babb5f 100644
--- a/test/number_cast.cpp
+++ b/test/number_cast.cpp
@@ -10,10 +10,11 @@
 // Test that header file is self-contained.
 #include <boost/json/number_cast.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <type_traits>
 #include <limits.h>
 
+#include "test_suite.hpp"
+
 namespace boost {
 namespace json {
 
@@ -35,22 +36,22 @@ T min_of()
 
 } // (anon)
 
-class number_cast_test : public beast::unit_test::suite
+class number_cast_test
 {
 public:
     void
     testNumberCast()
     {
-#define EQAL(T) BEAST_EXPECT(number_cast<T>(jv) == V)
-#define EQUS(T) BEAST_EXPECT((V >= 0) && number_cast<T>(jv) == static_cast<std::uint64_t>(V))
-#define EQUF(T) BEAST_EXPECT(static_cast<float>(V) == static_cast<float>(number_cast<T>(jv)))
-#define THRO(T) BEAST_THROWS(number_cast<T>(jv), system_error)
+#define EQAL(T) BOOST_TEST(number_cast<T>(jv) == V)
+#define EQUS(T) BOOST_TEST((V >= 0) && number_cast<T>(jv) == static_cast<std::uint64_t>(V))
+#define EQUF(T) BOOST_TEST(static_cast<float>(V) == static_cast<float>(number_cast<T>(jv)))
+#define THRO(T) BOOST_TEST_THROWS(number_cast<T>(jv), system_error)
 
-        BEAST_THROWS(number_cast<int>(value(object_kind)), system_error);
-        BEAST_THROWS(number_cast<int>(value(array_kind)), system_error);
-        BEAST_THROWS(number_cast<int>(value(string_kind)), system_error);
-        BEAST_THROWS(number_cast<int>(value(false)), system_error);
-        BEAST_THROWS(number_cast<int>(value(nullptr)), system_error);
+        BOOST_TEST_THROWS(number_cast<int>(value(object_kind)), system_error);
+        BOOST_TEST_THROWS(number_cast<int>(value(array_kind)), system_error);
+        BOOST_TEST_THROWS(number_cast<int>(value(string_kind)), system_error);
+        BOOST_TEST_THROWS(number_cast<int>(value(false)), system_error);
+        BOOST_TEST_THROWS(number_cast<int>(value(nullptr)), system_error);
 
         {
             unsigned char V = 0;
@@ -298,13 +299,13 @@ public:
     }
 
     void
-    run() override
+    run()
     {
         testNumberCast();
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,number_cast);
+TEST_SUITE(number_cast_test, "boost.json.number_cast");
 
 } // json
 } // boost
diff --git a/test/object.cpp b/test/object.cpp
index 3d5646e7..de5e7243 100644
--- a/test/object.cpp
+++ b/test/object.cpp
@@ -12,16 +12,16 @@
 
 #include <boost/json/pool.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <cmath>
 #include <type_traits>
 
 #include "test.hpp"
+#include "test_suite.hpp"
 
 namespace boost {
 namespace json {
 
-class object_test : public beast::unit_test::suite
+class object_test
 {
 public:
     string_view const str_;
@@ -108,13 +108,13 @@ public:
         object const& o,
         std::size_t capacity)
     {
-        BEAST_EXPECT(! o.empty());
-        BEAST_EXPECT(o.size() == 3);
-        BEAST_EXPECT(
+        BOOST_TEST(! o.empty());
+        BOOST_TEST(o.size() == 3);
+        BOOST_TEST(
             o.capacity() == capacity);
-        BEAST_EXPECT(o.at("a").as_int64() == 1);
-        BEAST_EXPECT(o.at("b").as_bool());
-        BEAST_EXPECT(o.at("c").as_string() == "hello");
+        BOOST_TEST(o.at("a").as_int64() == 1);
+        BOOST_TEST(o.at("b").as_bool());
+        BOOST_TEST(o.at("c").as_string() == "hello");
         check_storage(o, o.storage());
     }
 
@@ -129,9 +129,9 @@ public:
         // object()
         {
             object o;
-            BEAST_EXPECT(o.empty());
-            BEAST_EXPECT(o.size() == 0);
-            BEAST_EXPECT(o.capacity() == 0);
+            BOOST_TEST(o.empty());
+            BOOST_TEST(o.size() == 0);
+            BOOST_TEST(o.capacity() == 0);
         }
 
         // object(storage_ptr)
@@ -139,27 +139,27 @@ public:
         {
             object o(sp);
             check_storage(o, sp);
-            BEAST_EXPECT(o.empty());
-            BEAST_EXPECT(o.size() == 0);
-            BEAST_EXPECT(o.capacity() == 0);
+            BOOST_TEST(o.empty());
+            BOOST_TEST(o.size() == 0);
+            BOOST_TEST(o.capacity() == 0);
         });
 
         // object(std::size_t, storage_ptr)
         {
             {
                 object o(10);
-                BEAST_EXPECT(o.empty());
-                BEAST_EXPECT(o.size() == 0);
-                BEAST_EXPECT(o.capacity() >= 10);
+                BOOST_TEST(o.empty());
+                BOOST_TEST(o.size() == 0);
+                BOOST_TEST(o.capacity() >= 10);
             }
 
             fail_loop([&](storage_ptr const& sp)
             {
                 object o(10, sp);
                 check_storage(o, sp);
-                BEAST_EXPECT(o.empty());
-                BEAST_EXPECT(o.size() == 0);
-                BEAST_EXPECT(o.capacity() >= 10);
+                BOOST_TEST(o.empty());
+                BOOST_TEST(o.size() == 0);
+                BOOST_TEST(o.capacity() >= 10);
             });
         }
 
@@ -193,9 +193,9 @@ public:
                         {"b", true},
                         {"c", "hello"}};
                 object o(init.begin(), init.end(), 5, sp);
-                BEAST_EXPECT(! o.empty());
-                BEAST_EXPECT(o.size() == 3);
-                BEAST_EXPECT(o.capacity() == 7);
+                BOOST_TEST(! o.empty());
+                BOOST_TEST(o.size() == 3);
+                BOOST_TEST(o.capacity() == 7);
                 check(o, 7);
                 check_storage(o, sp);
             });
@@ -211,9 +211,9 @@ public:
                     make_input_iterator(init.begin()),
                     make_input_iterator(init.end()),
                     5, sp);
-                BEAST_EXPECT(! o.empty());
-                BEAST_EXPECT(o.size() == 3);
-                BEAST_EXPECT(o.capacity() == 7);
+                BOOST_TEST(! o.empty());
+                BOOST_TEST(o.size() == 3);
+                BOOST_TEST(o.capacity() == 7);
                 check(o, 7);
                 check_storage(o, sp);
             });
@@ -230,8 +230,8 @@ public:
             auto const sp =
                 storage_ptr{};
             object o2(std::move(o1));
-            BEAST_EXPECT(o1.empty());
-            BEAST_EXPECT(o1.size() == 0);
+            BOOST_TEST(o1.empty());
+            BOOST_TEST(o1.size() == 0);
             check(o2, 3);
             check_storage(o1, sp);
             check_storage(o2, sp);
@@ -246,7 +246,7 @@ public:
                 {"c", "hello"}
                 });
             object o2(std::move(o1), sp);
-            BEAST_EXPECT(! o1.empty());
+            BOOST_TEST(! o1.empty());
             check(o2, 3);
             check_storage(o1,
                 storage_ptr{});
@@ -263,11 +263,11 @@ public:
                 {"c", "hello"}
                 }, sp);
             object o2(pilfer(o1));
-            BEAST_EXPECT(
+            BOOST_TEST(
                 o1.storage() == nullptr);
-            BEAST_EXPECT(
+            BOOST_TEST(
                 *o2.storage() == *sp);
-            BEAST_EXPECT(o1.empty());
+            BOOST_TEST(o1.empty());
             check(o2, 3);
         }
 
@@ -282,7 +282,7 @@ public:
                 {"c", "hello"}
                 });
             object o2(o1);
-            BEAST_EXPECT(! o1.empty());
+            BOOST_TEST(! o1.empty());
             check(o2, 3);
         }
 
@@ -295,7 +295,7 @@ public:
                 {"c", "hello"}
                 });
             object o2(o1, sp);
-            BEAST_EXPECT(! o1.empty());
+            BOOST_TEST(! o1.empty());
             check(o2, 3);
             check_storage(o2, sp);
         });
@@ -341,7 +341,7 @@ public:
                     {"c", "hello"}
                     },
                     5, sp);
-                BEAST_EXPECT(
+                BOOST_TEST(
                     *o.storage() == *sp);
                 check(o, 7);
             });
@@ -357,7 +357,7 @@ public:
                 object o2;
                 o2 = std::move(o1);
                 check(o2, 3);
-                BEAST_EXPECT(o1.empty());
+                BOOST_TEST(o1.empty());
                 check_storage(o1,
                     storage_ptr{});
                 check_storage(o2,
@@ -444,7 +444,7 @@ public:
                     {"a", 1},
                     {"b", true},
                     {"c", "hello"} },
-                BEAST_EXPECT(
+                BOOST_TEST(
                     *o.storage() == *sp);
                 check(o, 3);
                 check_storage(o, sp);
@@ -465,117 +465,117 @@ public:
 
         // empty container
         {
-            BEAST_EXPECT(no.begin() == no.end());
-            BEAST_EXPECT(cno.begin() == cno.end());
-            BEAST_EXPECT(no.cbegin() == no.cend());
+            BOOST_TEST(no.begin() == no.end());
+            BOOST_TEST(cno.begin() == cno.end());
+            BOOST_TEST(no.cbegin() == no.cend());
         }
 
         // begin()
         {
             auto it = o.begin();
-            BEAST_EXPECT(it->key() == "a"); ++it;
-            BEAST_EXPECT(it->key() == "b"); it++;
-            BEAST_EXPECT(it->key() == "c"); ++it;
-            BEAST_EXPECT(it == o.end());
+            BOOST_TEST(it->key() == "a"); ++it;
+            BOOST_TEST(it->key() == "b"); it++;
+            BOOST_TEST(it->key() == "c"); ++it;
+            BOOST_TEST(it == o.end());
         }
 
         // begin() const
         {
             auto it = co.begin();
-            BEAST_EXPECT(it->key() == "a"); ++it;
-            BEAST_EXPECT(it->key() == "b"); it++;
-            BEAST_EXPECT(it->key() == "c"); ++it;
-            BEAST_EXPECT(it == co.end());
+            BOOST_TEST(it->key() == "a"); ++it;
+            BOOST_TEST(it->key() == "b"); it++;
+            BOOST_TEST(it->key() == "c"); ++it;
+            BOOST_TEST(it == co.end());
         }
 
         // cbegin()
         {
             auto it = o.cbegin();
-            BEAST_EXPECT(it->key() == "a"); ++it;
-            BEAST_EXPECT(it->key() == "b"); it++;
-            BEAST_EXPECT(it->key() == "c"); ++it;
-            BEAST_EXPECT(it == o.cend());
+            BOOST_TEST(it->key() == "a"); ++it;
+            BOOST_TEST(it->key() == "b"); it++;
+            BOOST_TEST(it->key() == "c"); ++it;
+            BOOST_TEST(it == o.cend());
         }
 
         // end()
         {
             auto it = o.end();
-            --it; BEAST_EXPECT(it->key() == "c");
-            it--; BEAST_EXPECT(it->key() == "b");
-            --it; BEAST_EXPECT(it->key() == "a");
-            BEAST_EXPECT(it == o.begin());
+            --it; BOOST_TEST(it->key() == "c");
+            it--; BOOST_TEST(it->key() == "b");
+            --it; BOOST_TEST(it->key() == "a");
+            BOOST_TEST(it == o.begin());
         }
 
         // end() const
         {
             auto it = co.end();
-            --it; BEAST_EXPECT(it->key() == "c");
-            it--; BEAST_EXPECT(it->key() == "b");
-            --it; BEAST_EXPECT(it->key() == "a");
-            BEAST_EXPECT(it == co.begin());
+            --it; BOOST_TEST(it->key() == "c");
+            it--; BOOST_TEST(it->key() == "b");
+            --it; BOOST_TEST(it->key() == "a");
+            BOOST_TEST(it == co.begin());
         }
 
         // cend()
         {
             auto it = o.cend();
-            --it; BEAST_EXPECT(it->key() == "c");
-            it--; BEAST_EXPECT(it->key() == "b");
-            --it; BEAST_EXPECT(it->key() == "a");
-            BEAST_EXPECT(it == o.cbegin());
+            --it; BOOST_TEST(it->key() == "c");
+            it--; BOOST_TEST(it->key() == "b");
+            --it; BOOST_TEST(it->key() == "a");
+            BOOST_TEST(it == o.cbegin());
         }
 
         // rbegin()
         {
             auto it = o.rbegin();
-            BEAST_EXPECT(it->key() == "c"); ++it;
-            BEAST_EXPECT(it->key() == "b"); it++;
-            BEAST_EXPECT(it->key() == "a"); ++it;
-            BEAST_EXPECT(it == o.rend());
+            BOOST_TEST(it->key() == "c"); ++it;
+            BOOST_TEST(it->key() == "b"); it++;
+            BOOST_TEST(it->key() == "a"); ++it;
+            BOOST_TEST(it == o.rend());
         }
 
         // rbegin() const
         {
             auto it = co.rbegin();
-            BEAST_EXPECT(it->key() == "c"); ++it;
-            BEAST_EXPECT(it->key() == "b"); it++;
-            BEAST_EXPECT(it->key() == "a"); ++it;
-            BEAST_EXPECT(it == co.rend());
+            BOOST_TEST(it->key() == "c"); ++it;
+            BOOST_TEST(it->key() == "b"); it++;
+            BOOST_TEST(it->key() == "a"); ++it;
+            BOOST_TEST(it == co.rend());
         }
 
         // crbegin()
         {
             auto it = o.crbegin();
-            BEAST_EXPECT(it->key() == "c"); ++it;
-            BEAST_EXPECT(it->key() == "b"); it++;
-            BEAST_EXPECT(it->key() == "a"); ++it;
-            BEAST_EXPECT(it == o.crend());
+            BOOST_TEST(it->key() == "c"); ++it;
+            BOOST_TEST(it->key() == "b"); it++;
+            BOOST_TEST(it->key() == "a"); ++it;
+            BOOST_TEST(it == o.crend());
         }
 
         // rend()
         {
             auto it = o.rend();
-            --it; BEAST_EXPECT(it->key() == "a");
-            it--; BEAST_EXPECT(it->key() == "b");
-            --it; BEAST_EXPECT(it->key() == "c");
-            BEAST_EXPECT(it == o.rbegin());
+            --it; BOOST_TEST(it->key() == "a");
+            it--; BOOST_TEST(it->key() == "b");
+            --it; BOOST_TEST(it->key() == "c");
+            BOOST_TEST(it == o.rbegin());
         }
 
         // rend() const
         {
             auto it = co.rend();
-            --it; BEAST_EXPECT(it->key() == "a");
-            it--; BEAST_EXPECT(it->key() == "b");
-            --it; BEAST_EXPECT(it->key() == "c");
-            BEAST_EXPECT(it == co.rbegin());
+            --it; BOOST_TEST(it->key() == "a");
+            it--; BOOST_TEST(it->key() == "b");
+            --it; BOOST_TEST(it->key() == "c");
+            BOOST_TEST(it == co.rbegin());
         }
 
         // crend()
         {
             auto it = o.crend();
-            --it; BEAST_EXPECT(it->key() == "a");
-            it--; BEAST_EXPECT(it->key() == "b");
-            --it; BEAST_EXPECT(it->key() == "c");
-            BEAST_EXPECT(it == o.crbegin());
+            --it; BOOST_TEST(it->key() == "a");
+            it--; BOOST_TEST(it->key() == "b");
+            --it; BOOST_TEST(it->key() == "c");
+            BOOST_TEST(it == o.crbegin());
         }
     }
 
@@ -584,7 +584,7 @@ public:
     void
     testCapacity()
     {
-        BEAST_EXPECT(
+        BOOST_TEST(
             object{}.size() < object{}.max_size());
     }
 
@@ -598,15 +598,15 @@ public:
             {
                 object o;
                 o.clear();
-                BEAST_EXPECT(o.empty());
+                BOOST_TEST(o.empty());
             }
 
             {
                 object o;
                 o.emplace("x", 1);
-                BEAST_EXPECT(! o.empty());
+                BOOST_TEST(! o.empty());
                 o.clear();
-                BEAST_EXPECT(o.empty());
+                BOOST_TEST(o.empty());
             }
         }
 
@@ -617,9 +617,9 @@ public:
                 object o(sp);
                 auto result = o.insert(
                     std::make_pair("x", 1));
-                BEAST_EXPECT(result.second);
-                BEAST_EXPECT(result.first->key() == "x");
-                BEAST_EXPECT(result.first->value().as_int64() == 1);
+                BOOST_TEST(result.second);
+                BOOST_TEST(result.first->key() == "x");
+                BOOST_TEST(result.first->value().as_int64() == 1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -627,9 +627,9 @@ public:
                 object o(sp);
                 auto const p = std::make_pair("x", 1);
                 auto result = o.insert(p);
-                BEAST_EXPECT(result.second);
-                BEAST_EXPECT(result.first->key() == "x");
-                BEAST_EXPECT(result.first->value().as_int64() == 1);
+                BOOST_TEST(result.second);
+                BOOST_TEST(result.first->key() == "x");
+                BOOST_TEST(result.first->value().as_int64() == 1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -640,9 +640,9 @@ public:
                     {"c", 3}}, sp);
                 auto const result = o.insert(
                     std::make_pair("b", 4));
-                BEAST_EXPECT(
+                BOOST_TEST(
                     result.first->value().as_int64() == 2);
-                BEAST_EXPECT(! result.second);
+                BOOST_TEST(! result.second);
             });
         }
 
@@ -702,7 +702,7 @@ public:
             {
                 object o({{"a", 1}}, sp);
                 o.insert_or_assign("a", str_);
-                BEAST_EXPECT(o["a"].is_string());
+                BOOST_TEST(o["a"].is_string());
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -712,8 +712,8 @@ public:
                     {"b", 2},
                     {"c", 3}}, sp);
                 o.insert_or_assign("d", str_);
-                BEAST_EXPECT(o["d"].is_string());
-                BEAST_EXPECT(o.size() == 4);
+                BOOST_TEST(o["d"].is_string());
+                BOOST_TEST(o.size() == 4);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -727,9 +727,9 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 object o({{"a", 1}}, sp);
-                BEAST_EXPECT(
+                BOOST_TEST(
                     ! o.insert_or_assign("a", 2).second);
-                BEAST_EXPECT(o["a"].as_int64() == 2);
+                BOOST_TEST(o["a"].as_int64() == 2);
             });
         }
 
@@ -753,8 +753,8 @@ public:
                     {"b", true},
                     {"c", "hello"}}, sp);
                 auto it = o.erase(o.begin());
-                BEAST_EXPECT(it->key() == "c");
-                BEAST_EXPECT(
+                BOOST_TEST(it->key() == "c");
+                BOOST_TEST(
                     it->value().as_string() == "hello");
                 check(o, 7);
             });
@@ -767,7 +767,7 @@ public:
                     {"a", 1},
                     {"b", true},
                     {"c", "hello"}});
-                BEAST_EXPECT(o.erase("b2") == 0);
+                BOOST_TEST(o.erase("b2") == 0);
                 check(o, 3);
             }
 
@@ -777,7 +777,7 @@ public:
                     {"b", true},
                     {"b2", 2},
                     {"c", "hello"}});
-                BEAST_EXPECT(o.erase("b2") == 1);
+                BOOST_TEST(o.erase("b2") == 1);
                 check(o, 7);
             }
         }
@@ -788,9 +788,9 @@ public:
                 object o1 = {{"a",1}, {"b",true}, {"c", "hello"}};
                 object o2 = {{"d",{1,2,3}}};
                 swap(o1, o2);
-                BEAST_EXPECT(o1.size() == 1);
-                BEAST_EXPECT(o2.size() == 3);
-                BEAST_EXPECT(o1.count("d") == 1);
+                BOOST_TEST(o1.size() == 1);
+                BOOST_TEST(o2.size() == 3);
+                BOOST_TEST(o1.count("d") == 1);
             }
 
             fail_loop([&](storage_ptr const& sp)
@@ -798,9 +798,9 @@ public:
                 object o1 = {{"a",1}, {"b",true}, {"c", "hello"}};
                 object o2({{"d",{1,2,3}}}, sp);
                 swap(o1, o2);
-                BEAST_EXPECT(o1.size() == 1);
-                BEAST_EXPECT(o2.size() == 3);
-                BEAST_EXPECT(o1.count("d") == 1);
+                BOOST_TEST(o1.size() == 1);
+                BOOST_TEST(o2.size() == 3);
+                BOOST_TEST(o1.count("d") == 1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -808,9 +808,9 @@ public:
                 object o1({{"d",{1,2,3}}}, sp);
                 object o2 = {{"a",1}, {"b",true}, {"c", "hello"}};
                 swap(o1, o2);
-                BEAST_EXPECT(o1.size() == 3);
-                BEAST_EXPECT(o2.size() == 1);
-                BEAST_EXPECT(o2.count("d") == 1);
+                BOOST_TEST(o1.size() == 3);
+                BOOST_TEST(o2.size() == 1);
+                BOOST_TEST(o2.count("d") == 1);
             });
         }
     }
@@ -828,17 +828,17 @@ public:
 
         // at(key)
         {
-            BEAST_EXPECT(
+            BOOST_TEST(
                 o1.at("a").is_number());
-            BEAST_THROWS((o1.at("d")),
+            BOOST_TEST_THROWS((o1.at("d")),
                 std::out_of_range);
         }
 
         // at(key) const
         {
-            BEAST_EXPECT(
+            BOOST_TEST(
                 co1.at("a").is_number());
-            BEAST_THROWS((co1.at("d")),
+            BOOST_TEST_THROWS((co1.at("d")),
                 std::out_of_range);
         }
 
@@ -848,31 +848,31 @@ public:
                 {"a", 1},
                 {"b", true},
                 {"c", "hello"}});
-            BEAST_EXPECT(o.count("d") == 0);;
-            BEAST_EXPECT(o["a"].is_number());
-            BEAST_EXPECT(o["d"].is_null());
-            BEAST_EXPECT(o.count("d") == 1);
+            BOOST_TEST(o.count("d") == 0);;
+            BOOST_TEST(o["a"].is_number());
+            BOOST_TEST(o["d"].is_null());
+            BOOST_TEST(o.count("d") == 1);
         }
 
         // count(key)
         {
-            BEAST_EXPECT(o1.count("a") == 1);
-            BEAST_EXPECT(o1.count("d") == 0);
-            BEAST_EXPECT(o1.count("e") == 0);
+            BOOST_TEST(o1.count("a") == 1);
+            BOOST_TEST(o1.count("d") == 0);
+            BOOST_TEST(o1.count("e") == 0);
         }
 
         // find(key)
         {
-            BEAST_EXPECT(
+            BOOST_TEST(
                 o1.find("a")->key() == "a");
-            BEAST_EXPECT(
+            BOOST_TEST(
                 o1.find("e") == o1.end());
         }
 
         // contains(key)
         {
-            BEAST_EXPECT(o1.contains("a"));
-            BEAST_EXPECT(! o1.contains("e"));
+            BOOST_TEST(o1.contains("a"));
+            BOOST_TEST(! o1.contains("e"));
         }
     }
 
@@ -886,17 +886,17 @@ public:
                 for(std::size_t i = 0; i < 10; ++i)
                     o.emplace(std::to_string(i), i);
                 o.reserve(15);
-                BEAST_EXPECT(o.capacity() >= 15);
+                BOOST_TEST(o.capacity() >= 15);
                 o.reserve(20);
-                BEAST_EXPECT(o.capacity() >= 20);
+                BOOST_TEST(o.capacity() >= 20);
             }
 
             {
                 object o;
                 o.reserve(3);
-                BEAST_EXPECT(o.capacity() == 3);
+                BOOST_TEST(o.capacity() == 3);
                 o.reserve(7);
-                BEAST_EXPECT(o.capacity() == 7);
+                BOOST_TEST(o.capacity() == 7);
             }
         }
     }
@@ -913,18 +913,18 @@ public:
                 {"b", true},
                 {"b", {1,2,3}},
                 {"c", "hello"}});
-            BEAST_EXPECT(o.at("a").as_int64() == 1);
-            BEAST_EXPECT(o.at("b").as_bool());
-            BEAST_EXPECT(o.at("c").as_string() == "hello");
+            BOOST_TEST(o.at("a").as_int64() == 1);
+            BOOST_TEST(o.at("b").as_bool());
+            BOOST_TEST(o.at("c").as_string() == "hello");
         }
 
         // find in missing or empty tables
         {
             object o;
-            BEAST_EXPECT(o.find("a") == o.end());
+            BOOST_TEST(o.find("a") == o.end());
             o.reserve(3);
-            BEAST_EXPECT(o.capacity() > 0);
-            BEAST_EXPECT(o.find("a") == o.end());
+            BOOST_TEST(o.capacity() > 0);
+            BOOST_TEST(o.find("a") == o.end());
         }
 
         // destroy key_value_pair array with need_free=false
@@ -939,7 +939,7 @@ public:
     }
 
     void
-    run() override
+    run()
     {
         testSpecial();
         testIterators();
@@ -951,7 +951,7 @@ public:
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,object);
+TEST_SUITE(object_test, "boost.json.object");
 
 } // json
 } // boost
diff --git a/test/parser.cpp b/test/parser.cpp
index be7a46c4..63bab0b0 100644
--- a/test/parser.cpp
+++ b/test/parser.cpp
@@ -10,20 +10,23 @@
 // Test that header file is self-contained.
 #include <boost/json/parser.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <boost/json/pool.hpp>
 #include <boost/json/serializer.hpp>
+
 #include <sstream>
 
 #include "parse-vectors.hpp"
 #include "test.hpp"
+#include "test_suite.hpp"
 
 namespace boost {
 namespace json {
 
-class parser_test : public beast::unit_test::suite
+class parser_test
 {
 public:
+    ::test_suite::log_type log;
+
     value
     from_string_test(
         string_view s,
@@ -38,8 +41,7 @@ public:
             ec);
         if(! ec)
             p.finish(ec);
-        BEAST_EXPECTS(! ec,
-            ec.message());
+        BOOST_TEST(! ec);
         //log << "  " << to_string_test(p.get()) << std::endl;
         return p.release();
     }
@@ -54,7 +56,7 @@ public:
             to_string(jv1);
         auto jv2 =
             from_string_test(s2);
-        if(! BEAST_EXPECT(equal(jv1, jv2)))
+        if(! BOOST_TEST(equal(jv1, jv2)))
             log <<
                 "  " << s1 << "\n" <<
                 "  " << s2 << std::endl;
@@ -186,13 +188,11 @@ public:
                 parser p;
                 p.start();
                 p.write(js.data(), N, ec);
-                if(BEAST_EXPECTS(! ec,
-                    ec.message()))
+                if(BOOST_TEST(! ec))
                 {
                     p.finish(js.data() + N,
                         js.size() - N, ec);
-                    if(BEAST_EXPECTS(! ec,
-                        ec.message()))
+                    if(BOOST_TEST(! ec))
                         check_round_trip(
                             p.release(), js);
                 }   
@@ -246,9 +246,8 @@ public:
             parser p;
             error_code ec;
             p.write("", 0, ec);
-            BEAST_EXPECTS(
-                ec == error::need_start,
-                ec.message());
+            BOOST_TEST(
+                ec == error::need_start);
         }
 
         // destroy after start
@@ -260,7 +259,7 @@ public:
         // release before done
         {
             parser p;
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 p.release(),
                 std::logic_error);
         }
@@ -287,14 +286,14 @@ public:
             {
                 error_code ec;
                 auto jv = parse(js, ec);
-                BEAST_EXPECTS(! ec, ec.message());
+                BOOST_TEST(! ec);
                 check_round_trip(jv, js);
             }
             {
                 error_code ec;
                 auto jv = parse("xxx", ec);
-                BEAST_EXPECT(ec);
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(ec);
+                BOOST_TEST(jv.is_null());
             }
         }
 
@@ -304,7 +303,7 @@ public:
                 error_code ec;
                 scoped_storage<pool> sp;
                 auto jv = parse(js, ec, sp);
-                BEAST_EXPECTS(! ec, ec.message());
+                BOOST_TEST(! ec);
                 check_round_trip(jv, js);
             }
 
@@ -312,8 +311,8 @@ public:
                 error_code ec;
                 scoped_storage<pool> sp;
                 auto jv = parse("xxx", ec, sp);
-                BEAST_EXPECT(ec);
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(ec);
+                BOOST_TEST(jv.is_null());
             }
         }
 
@@ -327,7 +326,7 @@ public:
 
             {
                 value jv;
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     jv = parse("{,"),
                     system_error);
             }
@@ -343,7 +342,7 @@ public:
             {
                 scoped_storage<pool> sp;
                 value jv;
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     jv = parse("xxx", sp),
                     system_error);
             }
@@ -381,9 +380,9 @@ R"xx({
         error_code ec;
         p.start();
         p.finish(in.data(), in.size(), ec);
-        if(BEAST_EXPECTS(! ec, ec.message()))
+        if(BOOST_TEST(! ec))
         {
-            BEAST_EXPECT(to_string(p.release()) ==
+            BOOST_TEST(to_string(p.release()) ==
                 "{\"glossary\":{\"title\":\"example glossary\",\"GlossDiv\":"
                 "{\"title\":\"S\",\"GlossList\":{\"GlossEntry\":{\"ID\":\"SGML\","
                 "\"SortAs\":\"SGML\",\"GlossTerm\":\"Standard Generalized Markup "
@@ -399,7 +398,7 @@ R"xx({
     void
     testIssue15()
     {
-        BEAST_EXPECT(
+        BOOST_TEST(
             json::parse("{\"port\": 12345}")
                 .as_object()
                 .at("port")
@@ -422,7 +421,7 @@ R"xx({
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,parser);
+TEST_SUITE(parser_test, "boost.json.parser");
 
 } // json
 } // boost
diff --git a/test/pool.cpp b/test/pool.cpp
index 1b9859d4..58445787 100644
--- a/test/pool.cpp
+++ b/test/pool.cpp
@@ -11,12 +11,13 @@
 #include <boost/json/pool.hpp>
 
 #include <boost/json/parser.hpp>
-#include <boost/beast/_experimental/unit_test/suite.hpp>
+
+#include "test_suite.hpp"
 
 namespace boost {
 namespace json {
 
-class pool_test : public beast::unit_test::suite
+class pool_test
 {
 public:
     void
@@ -46,17 +47,17 @@ R"xx({
     }
 })xx"
         , make_storage<pool>());
-        pass();
+        BOOST_TEST_PASS();
     }
 
     void
-    run() override
+    run()
     {
         testStorage();
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,pool);
+TEST_SUITE(pool_test, "boost.json.pool");
 
 } // json
 } // boost
diff --git a/test/ryu/gtest.hpp b/test/ryu/gtest.hpp
index 79566570..944e3b38 100644
--- a/test/ryu/gtest.hpp
+++ b/test/ryu/gtest.hpp
@@ -10,18 +10,24 @@
 #ifndef GTEST_HPP
 #define GTEST_HPP
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <boost/utility/string_view.hpp>
 
-#define TEST(s1,s2) \
-struct s2 ## s1 ## _test; \
-BEAST_DEFINE_TESTSUITE(boost,Ryu,s2##s1); \
-struct s2 ## s1 ## _test : ::boost::beast::unit_test::suite { \
-  void run() override; }; void s2##s1##_test::run()
+#include "test_suite.hpp"
 
-#define EXPECT_STREQ(s1, s2) BEAST_EXPECT(::boost::string_view(s1) == ::boost::string_view(s2))
-#define ASSERT_STREQ(s1, s2) { auto const s1_ = (s1); auto const s2_ = (s2); \
+#define TEST(s1,s2) \
+struct s1 ## _ ## s2 ## _test; \
+TEST_SUITE(s1 ## _ ## s2 ## _test, "boost.Ryu." #s1 "." #s2); \
+struct s1 ## _ ## s2 ## _test { \
+  void run(); }; void s1 ## _ ## s2 ## _test::run()
+
+#define EXPECT_STREQ(s1, s2) \
+    BOOST_TEST(::boost::json::string_view(s1) == \
+               ::boost::json::string_view(s2))
+
+#define ASSERT_STREQ(s1, s2) \
+    { auto const s1_ = (s1); auto const s2_ = (s2); \
     EXPECT_STREQ(s1_, s2_); }
-#define ASSERT_EQ(e1, e2) BEAST_EXPECT((e1)==(e2))
+
+#define ASSERT_EQ(e1, e2) BOOST_TEST((e1)==(e2))
 
 #endif
diff --git a/test/serializer.cpp b/test/serializer.cpp
index f0676e13..19573c03 100644
--- a/test/serializer.cpp
+++ b/test/serializer.cpp
@@ -11,17 +11,20 @@
 #include <boost/json/serializer.hpp>
 
 #include <boost/json/parser.hpp>
-#include <boost/beast/_experimental/unit_test/suite.hpp>
+#include <iostream>
+
 #include "parse-vectors.hpp"
 #include "test.hpp"
-#include <iostream>
+#include "test_suite.hpp"
 
 namespace boost {
 namespace json {
 
-class serializer_test : public beast::unit_test::suite
+class serializer_test
 {
 public:
+    ::test_suite::log_type log;
+
     void
     grind_one(
         string_view s,
@@ -32,7 +35,7 @@ public:
             error_code ec;
             auto const s1 = to_string(jv);
             auto const jv2 = parse(s1, ec);
-            if(! BEAST_EXPECT(equal(jv, jv2)))
+            if(! BOOST_TEST(equal(jv, jv2)))
             {
                 if(name.empty())
                     log <<
@@ -58,7 +61,7 @@ public:
 
             auto const s1 = to_string(jv);
             auto const jv2 = parse(s1, ec);
-            BEAST_EXPECT(equal(jv, jv2));
+            BOOST_TEST(equal(jv, jv2));
         }
     }
 
@@ -94,7 +97,7 @@ public:
                         " " << s1 << "\n"
                         " " << s2 << std::endl;
             };
-            if(! BEAST_EXPECT(
+            if(! BOOST_TEST(
                 s2.size() == i))
             {
                 dump();
@@ -103,13 +106,13 @@ public:
             s2.grow(sr.read(
                 s2.data() + i,
                 s1.size() - i));
-            if(! BEAST_EXPECT(
+            if(! BOOST_TEST(
                 s2.size() == s1.size()))
             {
                 dump();
                 break;
             }
-            if(! BEAST_EXPECT(s2 == s1))
+            if(! BOOST_TEST(s2 == s1))
             {
                 dump();
                 break;
@@ -135,7 +138,7 @@ public:
         // is_done()
         {
             serializer sr(jv);
-            BEAST_EXPECT(! sr.is_done());
+            BOOST_TEST(! sr.is_done());
         }
 
         // read()
@@ -145,15 +148,15 @@ public:
                 char buf[1024];
                 auto n = sr.read(
                     buf, sizeof(buf));
-                BEAST_EXPECT(sr.is_done());
-                BEAST_EXPECT(string_view(
+                BOOST_TEST(sr.is_done());
+                BOOST_TEST(string_view(
                     buf, n) == "null");
             }
 
             {
                 char buf[32];
                 serializer sr;
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     sr.read(buf, sizeof(buf)),
                     std::logic_error);
             }
@@ -443,15 +446,13 @@ public:
         {
             error_code ec;
             auto const jv1 = parse(js, ec);
-            if(! BEAST_EXPECTS(! ec,
-                ec.message()))
+            if(! BOOST_TEST(! ec))
                 return;
             auto const jv2 =
                 parse(to_ostream(jv1), ec);
-            if(! BEAST_EXPECTS(! ec,
-                ec.message()))
+            if(! BOOST_TEST(! ec))
                 return;
-            if(! BEAST_EXPECT(equal(jv1, jv2)))
+            if(! BOOST_TEST(equal(jv1, jv2)))
                 log <<
                     " " << js << "\n"
                     " " << jv1 << "\n"
@@ -474,7 +475,7 @@ public:
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,serializer);
+TEST_SUITE(serializer_test, "boost.json.serializer");
 
 } // json
 } // boost
diff --git a/test/snippets.cpp b/test/snippets.cpp
index 0a7deb72..b9e8d6ad 100644
--- a/test/snippets.cpp
+++ b/test/snippets.cpp
@@ -9,10 +9,11 @@
 
 #include <boost/json.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <complex>
 #include <iostream>
 
+#include "test_suite.hpp"
+
 namespace boost {
 namespace json {
 
@@ -477,11 +478,11 @@ usingExchange2()
 
 //----------------------------------------------------------
 
-class snippets_test : public beast::unit_test::suite
+class snippets_test
 {
 public:
     void
-    run() override
+    run()
     {
         (void)&usingStrings;
         (void)&usingArrays;
@@ -494,11 +495,11 @@ public:
         (void)&usingSerializing;
         (void)&usingExchange1;
         (void)&usingExchange2;
-        pass();
+        BOOST_TEST_PASS();
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,snippets);
+TEST_SUITE(snippets_test, "boost.json.snippets");
 
 } // json
 } // boost
diff --git a/test/storage_ptr.cpp b/test/storage_ptr.cpp
index 2eb19fc5..f68b6c00 100644
--- a/test/storage_ptr.cpp
+++ b/test/storage_ptr.cpp
@@ -10,14 +10,13 @@
 // Test that header file is self-contained.
 #include <boost/json/storage_ptr.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
-
 #include "test.hpp"
+#include "test_suite.hpp"
 
 namespace boost {
 namespace json {
 
-class storage_ptr_test : public beast::unit_test::suite
+class storage_ptr_test
 {
 public:
     struct not_storage
@@ -91,22 +90,22 @@ public:
         // storage_ptr()
         {
             storage_ptr sp;
-            BEAST_EXPECT(sp.get());
+            BOOST_TEST(sp.get());
         }
 
         // storage_ptr(storage_ptr&&)
         {
             storage_ptr sp1 = dsp;
             storage_ptr sp2(std::move(sp1));
-            BEAST_EXPECT(sp1.get());
-            BEAST_EXPECT(*sp2 == *dsp);
+            BOOST_TEST(sp1.get());
+            BOOST_TEST(*sp2 == *dsp);
         }
 
         // storage_ptr(storage_ptr const&)
         {
             storage_ptr sp1 = dsp;
             storage_ptr sp2(sp1);
-            BEAST_EXPECT(sp1 == sp2);
+            BOOST_TEST(sp1 == sp2);
         }
 
         // operator=(storage_ptr&&)
@@ -114,7 +113,7 @@ public:
             storage_ptr sp1(dsp);
             storage_ptr sp2(usp);
             sp2 = std::move(sp1);
-            BEAST_EXPECT(*sp2 == *dsp);
+            BOOST_TEST(*sp2 == *dsp);
         }
 
         // operator=(storage_ptr const&)
@@ -122,43 +121,43 @@ public:
             storage_ptr sp1(dsp);
             storage_ptr sp2(usp);
             sp2 = sp1;
-            BEAST_EXPECT(*sp1 == *sp2);
+            BOOST_TEST(*sp1 == *sp2);
         }
 
         // get()
         {
             storage_ptr sp(dsp);
-            BEAST_EXPECT(sp.get() == dsp.get());
+            BOOST_TEST(sp.get() == dsp.get());
         }
 
         // operator->()
         {
             storage_ptr sp(dsp);
-            BEAST_EXPECT(sp.operator->() == dsp.get());
+            BOOST_TEST(sp.operator->() == dsp.get());
         }
 
         // operator*()
         {
             storage_ptr sp(dsp);
-            BEAST_EXPECT(&sp.operator*() == dsp.get());
+            BOOST_TEST(&sp.operator*() == dsp.get());
         }
 
         // exception in make_storage
         {
-            BEAST_THROWS(
+            BOOST_TEST_THROWS(
                 make_storage<throwing>(),
                 std::exception);
         }
     }
 
     void
-    run() override
+    run()
     {
         testMembers();
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,storage_ptr);
+TEST_SUITE(storage_ptr_test, "boost.json.storage_ptr");
 
 } // json
 } // boost
diff --git a/test/string.cpp b/test/string.cpp
index 9b48afc3..e9707714 100644
--- a/test/string.cpp
+++ b/test/string.cpp
@@ -10,18 +10,18 @@
 // Test that header file is self-contained.
 #include <boost/json/string.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <numeric>
 #include <sstream>
 #include <string>
 #include <stdint.h>
 
 #include "test.hpp"
+#include "test_suite.hpp"
 
 namespace boost {
 namespace json {
 
-class string_test : public beast::unit_test::suite
+class string_test
 {
 public:
 
@@ -65,8 +65,8 @@ public:
             v1 = s1;
             v2 = s2;
 
-            BEAST_EXPECT(std::string(INIT1) == s1);
-            BEAST_EXPECT(std::string(INIT2) == s2);
+            BOOST_TEST(std::string(INIT1) == s1);
+            BOOST_TEST(std::string(INIT2) == s2);
         }
     };
 
@@ -94,8 +94,8 @@ public:
             auto const sp =
                 make_storage<unique_storage>();
             string s(sp);
-            BEAST_EXPECT(s.empty());
-            BEAST_EXPECT(*s.storage() == *sp.get());
+            BOOST_TEST(s.empty());
+            BOOST_TEST(*s.storage() == *sp.get());
         }
 
         // string(size_type, char, storage_ptr)
@@ -103,12 +103,12 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1.size(), '*', sp);
-                BEAST_EXPECT(s == std::string(t.v1.size(), '*'));
+                BOOST_TEST(s == std::string(t.v1.size(), '*'));
             });
 
             {
                 string s(t.v2.size(), '*');
-                BEAST_EXPECT(s == std::string(t.v2.size(), '*'));
+                BOOST_TEST(s == std::string(t.v2.size(), '*'));
             }
         }
         
@@ -117,18 +117,18 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(string(t.v1), 1, 3, sp);
-                BEAST_EXPECT(s == "bcd");
+                BOOST_TEST(s == "bcd");
             });
 
             {
                 string s(string(t.v1), 1, 3);
-                BEAST_EXPECT(s.size() == 3);
-                BEAST_EXPECT(s == "bcd");
+                BOOST_TEST(s.size() == 3);
+                BOOST_TEST(s == "bcd");
             }
 
             {
                 string s(string(t.v1), 1);
-                BEAST_EXPECT(s == t.v1.substr(1));
+                BOOST_TEST(s == t.v1.substr(1));
             }
         }
 
@@ -137,23 +137,23 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.s1.c_str(), sp);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.s2.c_str(), sp);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             {
                 string s(t.s1.c_str());
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             }
 
             {
                 string s(t.s2.c_str());
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             }
         }
 
@@ -162,23 +162,23 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.s1.c_str(), 3, sp);
-                BEAST_EXPECT(s == "abc");
+                BOOST_TEST(s == "abc");
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.s2.c_str(), 3, sp);
-                BEAST_EXPECT(s == "ABC");
+                BOOST_TEST(s == "ABC");
             });
 
             {
                 string s(t.s1.c_str(), 3);
-                BEAST_EXPECT(s == "abc");
+                BOOST_TEST(s == "abc");
             }
 
             {
                 string s(t.s2.c_str(), 3);
-                BEAST_EXPECT(s == "ABC");
+                BOOST_TEST(s == "ABC");
             }
         }
 
@@ -187,13 +187,13 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1.begin(), t.v1.end(), sp);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.begin(), t.v2.end(), sp);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -201,7 +201,7 @@ public:
                 string s(
                     make_input_iterator(t.v1.begin()),
                     make_input_iterator(t.v1.end()), sp);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -209,31 +209,31 @@ public:
                 string s(
                     make_input_iterator(t.v2.begin()),
                     make_input_iterator(t.v2.end()), sp);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             {
                 string s(t.v1.begin(), t.v1.end());
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             }
 
             {
                 string s(t.v2.begin(), t.v2.end());
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             }
 
             {
                 string s(
                     make_input_iterator(t.v1.begin()),
                     make_input_iterator(t.v1.end()));
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             }
 
             {
                 string s(
                     make_input_iterator(t.v2.begin()),
                     make_input_iterator(t.v2.end()));
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             }
         }
 
@@ -242,13 +242,13 @@ public:
             {
                 string const s0(t.v1);
                 string s(s0);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             }
 
             {
                 string const s0(t.v2);
                 string s(s0);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             }
         }
 
@@ -258,14 +258,14 @@ public:
             {
                 string const s0(t.v1);
                 string s(s0, sp);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string const s0(t.v2);
                 string s(s0, sp);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
         }
 
@@ -274,18 +274,18 @@ public:
             {
                 string s1(t.v1);
                 string s2(pilfer(s1));
-                BEAST_EXPECT(s2 == t.v1);
-                BEAST_EXPECT(s1.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s2 == t.v1);
+                BOOST_TEST(s1.empty());
+                BOOST_TEST(
                     s1.storage() == nullptr);
             }
 
             {
                 string s1(t.v2);
                 string s2(pilfer(s1));
-                BEAST_EXPECT(s2 == t.v2);
-                BEAST_EXPECT(s1.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s2 == t.v2);
+                BOOST_TEST(s1.empty());
+                BOOST_TEST(
                     s1.storage() == nullptr);
             }
         }
@@ -295,9 +295,9 @@ public:
             {
                 string s1(t.v1);
                 string s2(std::move(s1));
-                BEAST_EXPECT(s2 == t.v1);
-                BEAST_EXPECT(s1.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s2 == t.v1);
+                BOOST_TEST(s1.empty());
+                BOOST_TEST(
                     *s1.storage() ==
                     *s2.storage());
             }
@@ -305,9 +305,9 @@ public:
             {
                 string s1(t.v2);
                 string s2(std::move(s1));
-                BEAST_EXPECT(s2 == t.v2);
-                BEAST_EXPECT(s1.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s2 == t.v2);
+                BOOST_TEST(s1.empty());
+                BOOST_TEST(
                     *s1.storage() ==
                     *s2.storage());
             }
@@ -321,9 +321,9 @@ public:
             {
                 string s1(t.v1, sp);
                 string s2(std::move(s1), sp);
-                BEAST_EXPECT(s2 == t.v1);
-                BEAST_EXPECT(s1.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s2 == t.v1);
+                BOOST_TEST(s1.empty());
+                BOOST_TEST(
                     *s1.storage() ==
                     *s2.storage());
             });
@@ -332,9 +332,9 @@ public:
             {
                 string s1(t.v2, sp);
                 string s2(std::move(s1));
-                BEAST_EXPECT(s2 == t.v2);
-                BEAST_EXPECT(s1.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s2 == t.v2);
+                BOOST_TEST(s1.empty());
+                BOOST_TEST(
                     *s1.storage() ==
                     *s2.storage());
             });
@@ -345,9 +345,9 @@ public:
             {
                 string s1(t.v1);
                 string s2(std::move(s1), sp);
-                BEAST_EXPECT(s2 == t.v1);
-                BEAST_EXPECT(s1 == t.v1);
-                BEAST_EXPECT(
+                BOOST_TEST(s2 == t.v1);
+                BOOST_TEST(s1 == t.v1);
+                BOOST_TEST(
                     *s1.storage() !=
                     *s2.storage());
             });
@@ -356,9 +356,9 @@ public:
             {
                 string s1(t.v2);
                 string s2(std::move(s1), sp);
-                BEAST_EXPECT(s2 == t.v2);
-                BEAST_EXPECT(s1 == t.v2);
-                BEAST_EXPECT(
+                BOOST_TEST(s2 == t.v2);
+                BOOST_TEST(s1 == t.v2);
+                BOOST_TEST(
                     *s1.storage() !=
                     *s2.storage());
             });
@@ -369,23 +369,23 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(INIT1, sp);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(INIT2, sp);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             {
                 string s(INIT1);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             }
 
             {
                 string s(INIT2);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             }
         }
 
@@ -394,23 +394,23 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1, sp);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             {
                 string s(t.v1);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             }
 
             {
                 string s(t.v2);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             }
         }
 
@@ -419,23 +419,23 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1, 1, 3, sp);
-                BEAST_EXPECT(s == "bcd");
+                BOOST_TEST(s == "bcd");
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, 1, 3, sp);
-                BEAST_EXPECT(s == "BCD");
+                BOOST_TEST(s == "BCD");
             });
 
             {
                 string s(t.v1, 1, 3);
-                BEAST_EXPECT(s == "bcd");
+                BOOST_TEST(s == "bcd");
             }
 
             {
                 string s(t.v2, 1, 3);
-                BEAST_EXPECT(s == "BCD");
+                BOOST_TEST(s == "BCD");
             }
         }
     }
@@ -453,7 +453,7 @@ public:
                 string s(c, sp);
                 string const s2(t.v1);
                 s = s2;
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -462,7 +462,7 @@ public:
                 string s(c, sp);
                 string const s2(t.v1);
                 s = s2;
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -471,7 +471,7 @@ public:
                 string s(c, sp);
                 string const s2(t.v2);
                 s = s2;
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -480,7 +480,7 @@ public:
                 string s(c, sp);
                 string const s2(t.v2);
                 s = s2;
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
         }
 
@@ -494,9 +494,9 @@ public:
                 string s(c, sp);
                 string s2(t.v1, sp);
                 s = std::move(s2);
-                BEAST_EXPECT(s == t.v1);
-                BEAST_EXPECT(s2.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v1);
+                BOOST_TEST(s2.empty());
+                BOOST_TEST(
                     *s.storage() ==
                     *s2.storage());
             });
@@ -507,9 +507,9 @@ public:
                 string s(c, sp);
                 string s2(t.v1, sp);
                 s = std::move(s2);
-                BEAST_EXPECT(s == t.v1);
-                BEAST_EXPECT(s2.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v1);
+                BOOST_TEST(s2.empty());
+                BOOST_TEST(
                     *s.storage() ==
                     *s2.storage());
             });
@@ -520,9 +520,9 @@ public:
                 string s(c, sp);
                 string s2(t.v2, sp);
                 s = std::move(s2);
-                BEAST_EXPECT(s == t.v2);
-                BEAST_EXPECT(s2.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v2);
+                BOOST_TEST(s2.empty());
+                BOOST_TEST(
                     *s.storage() ==
                     *s2.storage());
             });
@@ -533,9 +533,9 @@ public:
                 string s(c, sp);
                 string s2(t.v2, sp);
                 s = std::move(s2);
-                BEAST_EXPECT(s == t.v2);
-                BEAST_EXPECT(s2.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v2);
+                BOOST_TEST(s2.empty());
+                BOOST_TEST(
                     *s.storage() ==
                     *s2.storage());
             });
@@ -548,9 +548,9 @@ public:
                 string s(c, sp);
                 string s2(t.v1);
                 s = std::move(s2);
-                BEAST_EXPECT(s == t.v1);
-                BEAST_EXPECT(s2 == t.v1);
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v1);
+                BOOST_TEST(s2 == t.v1);
+                BOOST_TEST(
                     *s.storage() !=
                     *s2.storage());
             });
@@ -561,9 +561,9 @@ public:
                 string s(c, sp);
                 string s2(t.v1);
                 s = std::move(s2);
-                BEAST_EXPECT(s == t.v1);
-                BEAST_EXPECT(s2 == t.v1);
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v1);
+                BOOST_TEST(s2 == t.v1);
+                BOOST_TEST(
                     *s.storage() !=
                     *s2.storage());
             });
@@ -574,9 +574,9 @@ public:
                 string s(c, sp);
                 string s2(t.v2);
                 s = std::move(s2);
-                BEAST_EXPECT(s == t.v2);
-                BEAST_EXPECT(s2 == t.v2);
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v2);
+                BOOST_TEST(s2 == t.v2);
+                BOOST_TEST(
                     *s.storage() !=
                     *s2.storage());
             });
@@ -587,9 +587,9 @@ public:
                 string s(c, sp);
                 string s2(t.v2);
                 s = std::move(s2);
-                BEAST_EXPECT(s == t.v2);
-                BEAST_EXPECT(s2 == t.v2);
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v2);
+                BOOST_TEST(s2 == t.v2);
+                BOOST_TEST(
                     *s.storage() !=
                     *s2.storage());
             });
@@ -601,28 +601,28 @@ public:
             {
                 string s(t.v1.size(), '*', sp);
                 s = t.s1.c_str();
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s = t.s1.c_str();
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1.size(), '*', sp);
                 s = t.s2.c_str();
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s = t.s2.c_str();
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
         }
 
@@ -632,14 +632,14 @@ public:
             {
                 string s(sp);
                 s = INIT1;
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(sp);
                 s = INIT2;
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
         }
 
@@ -649,28 +649,28 @@ public:
             {
                 string s(t.v1.size(), '*', sp);
                 s = t.v1;
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s = t.v1;
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1.size(), '*', sp);
                 s = t.v2;
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s = t.v2;
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
         }
     }
@@ -686,7 +686,7 @@ public:
             {
                 string s(t.v1.size(), 'x', sp);
                 s.assign(t.v1.size(), '*');
-                BEAST_EXPECT(
+                BOOST_TEST(
                     s == std::string(t.v1.size(), '*'));
             });
 
@@ -694,7 +694,7 @@ public:
             {
                 string s(t.v2.size(), 'x', sp);
                 s.assign(t.v1.size(), '*');
-                BEAST_EXPECT(
+                BOOST_TEST(
                     s == std::string(t.v1.size(), '*'));
             });
 
@@ -702,7 +702,7 @@ public:
             {
                 string s(t.v1.size(), 'x', sp);
                 s.assign(t.v2.size(), '*');
-                BEAST_EXPECT(
+                BOOST_TEST(
                     s == std::string(t.v2.size(), '*'));
             });
 
@@ -710,7 +710,7 @@ public:
             {
                 string s(t.v2.size(), 'x', sp);
                 s.assign(t.v2.size(), '*');
-                BEAST_EXPECT(
+                BOOST_TEST(
                     s == std::string(t.v2.size(), '*'));
             });
         }
@@ -721,7 +721,7 @@ public:
             {
                 string s(t.v1.size(), 'x', sp);
                 s.assign(string(t.v1.size(), '*'));
-                BEAST_EXPECT(
+                BOOST_TEST(
                     s == std::string(t.v1.size(), '*'));
             });
 
@@ -729,7 +729,7 @@ public:
             {
                 string s(t.v2.size(), 'x', sp);
                 s.assign(string(t.v1.size(), '*'));
-                BEAST_EXPECT(
+                BOOST_TEST(
                     s == std::string(t.v1.size(), '*'));
             });
 
@@ -737,7 +737,7 @@ public:
             {
                 string s(t.v1.size(), 'x', sp);
                 s.assign(string(t.v2.size(), '*'));
-                BEAST_EXPECT(
+                BOOST_TEST(
                     s == std::string(t.v2.size(), '*'));
             });
 
@@ -745,7 +745,7 @@ public:
             {
                 string s(t.v2.size(), 'x', sp);
                 s.assign(string(t.v2.size(), '*'));
-                BEAST_EXPECT(
+                BOOST_TEST(
                     s == std::string(t.v2.size(), '*'));
             });
 
@@ -753,7 +753,7 @@ public:
             {
                 string s(t.v1);
                 s = static_cast<string const&>(s);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             }
         }
 
@@ -763,7 +763,7 @@ public:
             {
                 string s(t.v1.size(), 'x', sp);
                 s.assign(string(t.v1.size(), '*'), 1, 3);
-                BEAST_EXPECT(
+                BOOST_TEST(
                     s == std::string(3, '*'));
             });
 
@@ -771,7 +771,7 @@ public:
             {
                 string s(t.v2.size(), 'x', sp);
                 s.assign(string(t.v1.size(), '*'), 1, 3);
-                BEAST_EXPECT(
+                BOOST_TEST(
                     s == std::string(3, '*'));
             });
         }
@@ -786,9 +786,9 @@ public:
                 string s(c, sp);
                 string s2(t.v1, sp);
                 s.assign(std::move(s2));
-                BEAST_EXPECT(s == t.v1);
-                BEAST_EXPECT(s2.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v1);
+                BOOST_TEST(s2.empty());
+                BOOST_TEST(
                     *s.storage() ==
                     *s2.storage());
             });
@@ -799,9 +799,9 @@ public:
                 string s(c, sp);
                 string s2(t.v1, sp);
                 s.assign(std::move(s2));
-                BEAST_EXPECT(s == t.v1);
-                BEAST_EXPECT(s2.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v1);
+                BOOST_TEST(s2.empty());
+                BOOST_TEST(
                     *s.storage() ==
                     *s2.storage());
             });
@@ -812,9 +812,9 @@ public:
                 string s(c, sp);
                 string s2(t.v2, sp);
                 s.assign(std::move(s2));
-                BEAST_EXPECT(s == t.v2);
-                BEAST_EXPECT(s2.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v2);
+                BOOST_TEST(s2.empty());
+                BOOST_TEST(
                     *s.storage() ==
                     *s2.storage());
             });
@@ -825,9 +825,9 @@ public:
                 string s(c, sp);
                 string s2(t.v2, sp);
                 s.assign(std::move(s2));
-                BEAST_EXPECT(s == t.v2);
-                BEAST_EXPECT(s2.empty());
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v2);
+                BOOST_TEST(s2.empty());
+                BOOST_TEST(
                     *s.storage() ==
                     *s2.storage());
             });
@@ -840,9 +840,9 @@ public:
                 string s(c, sp);
                 string s2(t.v1);
                 s.assign(std::move(s2));
-                BEAST_EXPECT(s == t.v1);
-                BEAST_EXPECT(s2 == t.v1);
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v1);
+                BOOST_TEST(s2 == t.v1);
+                BOOST_TEST(
                     *s.storage() !=
                     *s2.storage());
             });
@@ -853,9 +853,9 @@ public:
                 string s(c, sp);
                 string s2(t.v1);
                 s.assign(std::move(s2));
-                BEAST_EXPECT(s == t.v1);
-                BEAST_EXPECT(s2 == t.v1);
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v1);
+                BOOST_TEST(s2 == t.v1);
+                BOOST_TEST(
                     *s.storage() !=
                     *s2.storage());
             });
@@ -866,9 +866,9 @@ public:
                 string s(c, sp);
                 string s2(t.v2);
                 s.assign(std::move(s2));
-                BEAST_EXPECT(s == t.v2);
-                BEAST_EXPECT(s2 == t.v2);
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v2);
+                BOOST_TEST(s2 == t.v2);
+                BOOST_TEST(
                     *s.storage() !=
                     *s2.storage());
             });
@@ -879,9 +879,9 @@ public:
                 string s(c, sp);
                 string s2(t.v2);
                 s.assign(std::move(s2));
-                BEAST_EXPECT(s == t.v2);
-                BEAST_EXPECT(s2 == t.v2);
-                BEAST_EXPECT(
+                BOOST_TEST(s == t.v2);
+                BOOST_TEST(s2 == t.v2);
+                BOOST_TEST(
                     *s.storage() !=
                     *s2.storage());
             });
@@ -893,28 +893,28 @@ public:
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(t.s1.c_str(), 3);
-                BEAST_EXPECT(s == "abc");
+                BOOST_TEST(s == "abc");
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(t.s1.c_str(), 3);
-                BEAST_EXPECT(s == "abc");
+                BOOST_TEST(s == "abc");
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(t.s2.c_str(), 3);
-                BEAST_EXPECT(s == "ABC");
+                BOOST_TEST(s == "ABC");
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(t.s2.c_str(), 3);
-                BEAST_EXPECT(s == "ABC");
+                BOOST_TEST(s == "ABC");
             });
         };
 
@@ -924,28 +924,28 @@ public:
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(t.s1.c_str());
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(t.s1.c_str());
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(t.s2.c_str());
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(t.s2.c_str());
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
         }
 
@@ -955,14 +955,14 @@ public:
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(t.s1.begin(), t.s1.end());
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(t.s1.begin(), t.s1.end());
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -971,7 +971,7 @@ public:
                 s.assign(
                     make_input_iterator(t.s1.begin()),
                     make_input_iterator(t.s1.end()));
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -980,21 +980,21 @@ public:
                 s.assign(
                     make_input_iterator(t.s1.begin()),
                     make_input_iterator(t.s1.end()));
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(t.s2.begin(), t.s2.end());
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(t.s2.begin(), t.s2.end());
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -1003,7 +1003,7 @@ public:
                 s.assign(
                     make_input_iterator(t.s2.begin()),
                     make_input_iterator(t.s2.end()));
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -1012,14 +1012,14 @@ public:
                 s.assign(
                     make_input_iterator(t.s2.begin()),
                     make_input_iterator(t.s2.end()));
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             // empty range
             {
                 string s(t.v1);
                 s.assign(t.s1.begin(), t.s1.begin());
-                BEAST_EXPECT(s.empty());
+                BOOST_TEST(s.empty());
             }
 
             // empty range
@@ -1028,7 +1028,7 @@ public:
                 s.assign(
                     make_input_iterator(t.s1.begin()),
                     make_input_iterator(t.s1.begin()));
-                BEAST_EXPECT(s.empty());
+                BOOST_TEST(s.empty());
             }
         }
 
@@ -1038,28 +1038,28 @@ public:
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(INIT1);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(INIT1);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(INIT2);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(INIT2);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
         }
 
@@ -1069,28 +1069,28 @@ public:
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(t.v1);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(t.v1);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(t.v2);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(t.v2);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
         }
         
@@ -1100,14 +1100,14 @@ public:
             {
                 string s(t.v1.size(), '*', sp);
                 s.assign(t.v1, 1, 3);
-                BEAST_EXPECT(s == "bcd");
+                BOOST_TEST(s == "bcd");
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2.size(), '*', sp);
                 s.assign(t.v2, 1, 3);
-                BEAST_EXPECT(s == "BCD");
+                BOOST_TEST(s == "BCD");
             });
         }
     }
@@ -1124,71 +1124,71 @@ public:
 
         // at(size_type)
         {
-            BEAST_EXPECT(s1.at(1) == 'b');
+            BOOST_TEST(s1.at(1) == 'b');
             s1.at(1) = '*';
-            BEAST_EXPECT(s1.at(1) == '*');
+            BOOST_TEST(s1.at(1) == '*');
             s1.at(1) = 'b';
-            BEAST_EXPECT(s1.at(1) == 'b');
+            BOOST_TEST(s1.at(1) == 'b');
 
-            BEAST_EXPECT(s2.at(1) == 'B');
+            BOOST_TEST(s2.at(1) == 'B');
             s2.at(1) = '*';
-            BEAST_EXPECT(s2.at(1) == '*');
+            BOOST_TEST(s2.at(1) == '*');
             s2.at(1) = 'B';
-            BEAST_EXPECT(s2.at(1) == 'B');
+            BOOST_TEST(s2.at(1) == 'B');
 
-            BEAST_THROWS(s1.at(s2.size()),
+            BOOST_TEST_THROWS(s1.at(s2.size()),
                 std::out_of_range);
         }
 
         // at(size_type) const
         {
-            BEAST_EXPECT(cs1.at(1) == 'b');
-            BEAST_EXPECT(cs2.at(1) == 'B');
+            BOOST_TEST(cs1.at(1) == 'b');
+            BOOST_TEST(cs2.at(1) == 'B');
 
-            BEAST_THROWS(cs1.at(cs2.size()),
+            BOOST_TEST_THROWS(cs1.at(cs2.size()),
                 std::out_of_range);
         }
 
         // operator[&](size_type)
         {
-            BEAST_EXPECT(s1[1] == 'b');
+            BOOST_TEST(s1[1] == 'b');
             s1[1] = '*';
-            BEAST_EXPECT(s1[1] == '*');
+            BOOST_TEST(s1[1] == '*');
             s1[1] = 'b';
-            BEAST_EXPECT(s1[1] == 'b');
+            BOOST_TEST(s1[1] == 'b');
 
-            BEAST_EXPECT(s2[1] == 'B');
+            BOOST_TEST(s2[1] == 'B');
             s2[1] = '*';
-            BEAST_EXPECT(s2[1] == '*');
+            BOOST_TEST(s2[1] == '*');
             s2[1] = 'B';
-            BEAST_EXPECT(s2[1] == 'B');
+            BOOST_TEST(s2[1] == 'B');
         }
 
         // operator[&](size_type) const
         {
-            BEAST_EXPECT(cs1[1] == 'b');
-            BEAST_EXPECT(cs2[1] == 'B');
+            BOOST_TEST(cs1[1] == 'b');
+            BOOST_TEST(cs2[1] == 'B');
         }
 
         // front()
         {
-            BEAST_EXPECT(s1.front() == 'a');
+            BOOST_TEST(s1.front() == 'a');
             s1.front() = '*';
-            BEAST_EXPECT(s1.front() == '*');
+            BOOST_TEST(s1.front() == '*');
             s1.front() = 'a';
-            BEAST_EXPECT(s1.front() == 'a');
+            BOOST_TEST(s1.front() == 'a');
 
-            BEAST_EXPECT(s2.front() == 'A');
+            BOOST_TEST(s2.front() == 'A');
             s2.front() = '*';
-            BEAST_EXPECT(s2.front() == '*');
+            BOOST_TEST(s2.front() == '*');
             s2.front() = 'A';
-            BEAST_EXPECT(s2.front() == 'A');
+            BOOST_TEST(s2.front() == 'A');
         }
 
         // front() const
         {
-            BEAST_EXPECT(cs1.front() == 'a');
-            BEAST_EXPECT(cs2.front() == 'A');
+            BOOST_TEST(cs1.front() == 'a');
+            BOOST_TEST(cs2.front() == 'A');
         }
 
         // back()
@@ -1196,17 +1196,17 @@ public:
             auto const ch1 = s1.at(s1.size()-1);
             auto const ch2 = s2.at(s2.size()-1);
 
-            BEAST_EXPECT(s1.back() == ch1);
+            BOOST_TEST(s1.back() == ch1);
             s1.back() = '*';
-            BEAST_EXPECT(s1.back() == '*');
+            BOOST_TEST(s1.back() == '*');
             s1.back() = ch1;
-            BEAST_EXPECT(s1.back() == ch1);
+            BOOST_TEST(s1.back() == ch1);
 
-            BEAST_EXPECT(s2.back() == ch2);
+            BOOST_TEST(s2.back() == ch2);
             s2.back() = '*';
-            BEAST_EXPECT(s2.back() == '*');
+            BOOST_TEST(s2.back() == '*');
             s2.back() = ch2;
-            BEAST_EXPECT(s2.back() == ch2);
+            BOOST_TEST(s2.back() == ch2);
         }
 
         // back() const
@@ -1214,38 +1214,38 @@ public:
             auto const ch1 = s1.at(s1.size()-1);
             auto const ch2 = s2.at(s2.size()-1);
 
-            BEAST_EXPECT(cs1.back() == ch1);
-            BEAST_EXPECT(cs2.back() == ch2);
+            BOOST_TEST(cs1.back() == ch1);
+            BOOST_TEST(cs2.back() == ch2);
         }
 
         // data()
         {
-            BEAST_EXPECT(
+            BOOST_TEST(
                 string_view(s1.data()) == t.v1);
-            BEAST_EXPECT(
+            BOOST_TEST(
                 string_view(s2.data()) == t.v2);
         }
         // data() const
         {
-            BEAST_EXPECT(
+            BOOST_TEST(
                 string_view(cs1.data()) == t.v1);
-            BEAST_EXPECT(
+            BOOST_TEST(
                 string_view(cs2.data()) == t.v2);
         }
 
         // c_str()
         {
-            BEAST_EXPECT(
+            BOOST_TEST(
                 string_view(cs1.c_str()) == t.v1);
-            BEAST_EXPECT(
+            BOOST_TEST(
                 string_view(cs2.c_str()) == t.v2);
         }
 
         // operator string_view()
         {
-            BEAST_EXPECT(
+            BOOST_TEST(
                 string_view(cs1) == t.v1);
-            BEAST_EXPECT(
+            BOOST_TEST(
                 string_view(cs2) == t.v2);
         }
     }
@@ -1258,100 +1258,100 @@ public:
 
         {
             auto it = s.begin();
-            BEAST_EXPECT(*it == 'a'); ++it;
-            BEAST_EXPECT(*it == 'b');   it++;
-            BEAST_EXPECT(*it == 'c'); ++it;
-            BEAST_EXPECT(it == s.end());
+            BOOST_TEST(*it == 'a'); ++it;
+            BOOST_TEST(*it == 'b');   it++;
+            BOOST_TEST(*it == 'c'); ++it;
+            BOOST_TEST(it == s.end());
         }
         {
             auto it = s.cbegin();
-            BEAST_EXPECT(*it == 'a'); ++it;
-            BEAST_EXPECT(*it == 'b');   it++;
-            BEAST_EXPECT(*it == 'c'); ++it;
-            BEAST_EXPECT(it == s.cend());
+            BOOST_TEST(*it == 'a'); ++it;
+            BOOST_TEST(*it == 'b');   it++;
+            BOOST_TEST(*it == 'c'); ++it;
+            BOOST_TEST(it == s.cend());
         }
         {
             auto it = ac.begin();
-            BEAST_EXPECT(*it == 'a'); ++it;
-            BEAST_EXPECT(*it == 'b');   it++;
-            BEAST_EXPECT(*it == 'c'); ++it;
-            BEAST_EXPECT(it == ac.end());
+            BOOST_TEST(*it == 'a'); ++it;
+            BOOST_TEST(*it == 'b');   it++;
+            BOOST_TEST(*it == 'c'); ++it;
+            BOOST_TEST(it == ac.end());
         }
         {
             auto it = s.end();
-            --it; BEAST_EXPECT(*it == 'c');
-            it--; BEAST_EXPECT(*it == 'b');
-            --it; BEAST_EXPECT(*it == 'a');
-            BEAST_EXPECT(it == s.begin());
+            --it; BOOST_TEST(*it == 'c');
+            it--; BOOST_TEST(*it == 'b');
+            --it; BOOST_TEST(*it == 'a');
+            BOOST_TEST(it == s.begin());
         }
         {
             auto it = s.cend();
-            --it; BEAST_EXPECT(*it == 'c');
-            it--; BEAST_EXPECT(*it == 'b');
-            --it; BEAST_EXPECT(*it == 'a');
-            BEAST_EXPECT(it == s.cbegin());
+            --it; BOOST_TEST(*it == 'c');
+            it--; BOOST_TEST(*it == 'b');
+            --it; BOOST_TEST(*it == 'a');
+            BOOST_TEST(it == s.cbegin());
         }
         {
             auto it = ac.end();
-            --it; BEAST_EXPECT(*it == 'c');
-            it--; BEAST_EXPECT(*it == 'b');
-            --it; BEAST_EXPECT(*it == 'a');
-            BEAST_EXPECT(it == ac.begin());
+            --it; BOOST_TEST(*it == 'c');
+            it--; BOOST_TEST(*it == 'b');
+            --it; BOOST_TEST(*it == 'a');
+            BOOST_TEST(it == ac.begin());
         }
 
         {
             auto it = s.rbegin();
-            BEAST_EXPECT(*it == 'c'); ++it;
-            BEAST_EXPECT(*it == 'b');   it++;
-            BEAST_EXPECT(*it == 'a'); ++it;
-            BEAST_EXPECT(it == s.rend());
+            BOOST_TEST(*it == 'c'); ++it;
+            BOOST_TEST(*it == 'b');   it++;
+            BOOST_TEST(*it == 'a'); ++it;
+            BOOST_TEST(it == s.rend());
         }
         {
             auto it = s.crbegin();
-            BEAST_EXPECT(*it == 'c'); ++it;
-            BEAST_EXPECT(*it == 'b');   it++;
-            BEAST_EXPECT(*it == 'a'); ++it;
-            BEAST_EXPECT(it == s.crend());
+            BOOST_TEST(*it == 'c'); ++it;
+            BOOST_TEST(*it == 'b');   it++;
+            BOOST_TEST(*it == 'a'); ++it;
+            BOOST_TEST(it == s.crend());
         }
         {
             auto it = ac.rbegin();
-            BEAST_EXPECT(*it == 'c'); ++it;
-            BEAST_EXPECT(*it == 'b');   it++;
-            BEAST_EXPECT(*it == 'a'); ++it;
-            BEAST_EXPECT(it == ac.rend());
+            BOOST_TEST(*it == 'c'); ++it;
+            BOOST_TEST(*it == 'b');   it++;
+            BOOST_TEST(*it == 'a'); ++it;
+            BOOST_TEST(it == ac.rend());
         }
         {
             auto it = s.rend();
-            --it; BEAST_EXPECT(*it == 'a');
-            it--; BEAST_EXPECT(*it == 'b');
-            --it; BEAST_EXPECT(*it == 'c');
-            BEAST_EXPECT(it == s.rbegin());
+            --it; BOOST_TEST(*it == 'a');
+            it--; BOOST_TEST(*it == 'b');
+            --it; BOOST_TEST(*it == 'c');
+            BOOST_TEST(it == s.rbegin());
         }
         {
             auto it = s.crend();
-            --it; BEAST_EXPECT(*it == 'a');
-            it--; BEAST_EXPECT(*it == 'b');
-            --it; BEAST_EXPECT(*it == 'c');
-            BEAST_EXPECT(it == s.crbegin());
+            --it; BOOST_TEST(*it == 'a');
+            it--; BOOST_TEST(*it == 'b');
+            --it; BOOST_TEST(*it == 'c');
+            BOOST_TEST(it == s.crbegin());
         }
         {
             auto it = ac.rend();
-            --it; BEAST_EXPECT(*it == 'a');
-            it--; BEAST_EXPECT(*it == 'b');
-            --it; BEAST_EXPECT(*it == 'c');
-            BEAST_EXPECT(it == ac.rbegin());
+            --it; BOOST_TEST(*it == 'a');
+            it--; BOOST_TEST(*it == 'b');
+            --it; BOOST_TEST(*it == 'c');
+            BOOST_TEST(it == ac.rbegin());
         }
 
         {
             string s2;
             string const& cs2(s2);
-            BEAST_EXPECT(std::distance(
+            BOOST_TEST(std::distance(
                 s2.begin(), s2.end()) == 0);
-            BEAST_EXPECT(std::distance(
+            BOOST_TEST(std::distance(
                 cs2.begin(), cs2.end()) == 0);
-            BEAST_EXPECT(std::distance(
+            BOOST_TEST(std::distance(
                 s2.rbegin(), s2.rend()) == 0);
-            BEAST_EXPECT(std::distance(
+            BOOST_TEST(std::distance(
                 cs2.rbegin(), cs2.rend()) == 0);
         }
     }
@@ -1365,11 +1365,11 @@ public:
         {
             {
                 string s;
-                BEAST_EXPECT(s.empty());
+                BOOST_TEST(s.empty());
             }
             {
                 string s = "abc";
-                BEAST_EXPECT(! s.empty());
+                BOOST_TEST(! s.empty());
             }
         }
 
@@ -1377,8 +1377,8 @@ public:
         // max_size()
         {
             string s = "abc";
-            BEAST_EXPECT(s.size() == 3);
-            BEAST_EXPECT(s.max_size() < string::npos);
+            BOOST_TEST(s.size() == 3);
+            BOOST_TEST(s.max_size() < string::npos);
         }
 
         // reserve(size_type)
@@ -1390,20 +1390,20 @@ public:
                 s.append(t.v2);
 
                 s.reserve(0);
-                BEAST_EXPECT(s.size() ==
+                BOOST_TEST(s.size() ==
                     t.v1.size() + t.v2.size());
 
                 s.reserve(t.v1.size() + t.v2.size());
-                BEAST_EXPECT(s.size() ==
+                BOOST_TEST(s.size() ==
                     t.v1.size() + t.v2.size());
 
                 s.reserve(s.size() * 2);
-                BEAST_EXPECT(s.capacity() >
+                BOOST_TEST(s.capacity() >
                     t.v1.size() + t.v2.size());
 
                 s.resize(t.v1.size());
                 s.reserve(t.v1.size());
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
         }
 
@@ -1420,23 +1420,23 @@ public:
 
             cap = s.capacity();
             s.shrink_to_fit();
-            BEAST_EXPECT(s.capacity() == cap);
+            BOOST_TEST(s.capacity() == cap);
 
             s.reserve(s.capacity() + 1);
             s.shrink_to_fit();
-            BEAST_EXPECT(s.capacity() == cap);
+            BOOST_TEST(s.capacity() == cap);
 
             s.resize(cap * 3, '*');
             cap = s.capacity();
             s.resize(cap - 1);
             s.shrink_to_fit();
-            BEAST_EXPECT(s.capacity() == cap);
+            BOOST_TEST(s.capacity() == cap);
 
             s.resize(cap / 2);
-            BEAST_EXPECT(s.capacity() == cap);
+            BOOST_TEST(s.capacity() == cap);
 
             s.shrink_to_fit();
-            BEAST_EXPECT(s.capacity() < cap);
+            BOOST_TEST(s.capacity() < cap);
         });
     }
 
@@ -1450,17 +1450,17 @@ public:
             {
                 string s(t.v1);
                 s.clear();
-                BEAST_EXPECT(s.empty());
-                BEAST_EXPECT(s.size() == 0);
-                BEAST_EXPECT(s.capacity() > 0);
+                BOOST_TEST(s.empty());
+                BOOST_TEST(s.size() == 0);
+                BOOST_TEST(s.capacity() > 0);
             }
 
             {
                 string s(t.v2);
                 s.clear();
-                BEAST_EXPECT(s.empty());
-                BEAST_EXPECT(s.size() == 0);
-                BEAST_EXPECT(s.capacity() > 0);
+                BOOST_TEST(s.empty());
+                BOOST_TEST(s.size() == 0);
+                BOOST_TEST(s.capacity() > 0);
             }
         }
     }
@@ -1476,7 +1476,7 @@ public:
             {
                 string s(t.v1, sp);
                 s.insert(1, 3, '*');
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v1).insert(1, 3, '*'));
             });
 
@@ -1484,14 +1484,14 @@ public:
             {
                 string s(t.v2, sp);
                 s.insert(1, 3, '*');
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v2).insert(1, 3, '*'));
             });
 
             // pos out of range
             {
                 string s(t.v1);
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     (s.insert(s.size() + 2, 1, '*')),
                     std::out_of_range);
             }
@@ -1499,7 +1499,7 @@ public:
             // size > max_size
             {
                 string s(t.v1);
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     (s.insert(1, "", s.max_size())),
                     std::length_error);
             }
@@ -1511,7 +1511,7 @@ public:
             {
                 string s(t.v1, sp);
                 s.insert(1, "***");
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v1).insert(1, "***"));
             });
 
@@ -1519,14 +1519,14 @@ public:
             {
                 string s(t.v2, sp);
                 s.insert(1, "***");
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v2).insert(1, "***"));
             });
 
             // pos out of range
             {
                 string s(t.v1);
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     (s.insert(s.size() + 2, "*", 1)),
                     std::out_of_range);
             }
@@ -1538,7 +1538,7 @@ public:
             {
                 string s(t.v1, sp);
                 s.insert(1, "*****", 3);
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v1).insert(1, "*****", 3));
             });
 
@@ -1546,7 +1546,7 @@ public:
             {
                 string s(t.v2, sp);
                 s.insert(1, "*****", 3);
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v2).insert(1, "*****", 3));
             });
         }
@@ -1557,7 +1557,7 @@ public:
             {
                 string s(t.v1, sp);
                 s.insert(1, string(t.v2));
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v1).insert(1, t.s2));
             });
 
@@ -1565,7 +1565,7 @@ public:
             {
                 string s(t.v2, sp);
                 s.insert(1, string(t.v1));
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v2).insert(1, t.s1));
             });
         }
@@ -1576,7 +1576,7 @@ public:
             {
                 string s(t.v1, sp);
                 s.insert(1, string(t.v2), 1, 3);
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v1).insert(1, t.s2, 1, 3));
             });
 
@@ -1584,7 +1584,7 @@ public:
             {
                 string s(t.v2, sp);
                 s.insert(1, string(t.v1), 1, 3);
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v2).insert(1, t.s1, 1, 3));
             });
 
@@ -1592,7 +1592,7 @@ public:
             {
                 string s(t.v1, sp);
                 s.insert(1, string(t.v2), 1);
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v1).insert(1, t.s2, 1, std::string::npos));
             });
 
@@ -1600,7 +1600,7 @@ public:
             {
                 string s(t.v2, sp);
                 s.insert(1, string(t.v1), 1);
-                BEAST_EXPECT(s == std::string(
+                BOOST_TEST(s == std::string(
                     t.v2).insert(1, t.s1, 1, std::string::npos));
             });
         }
@@ -1610,14 +1610,14 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1, sp);
-                BEAST_EXPECT(
+                BOOST_TEST(
                     *s.insert(s.begin()+2, '*') == '*');
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
-                BEAST_EXPECT(
+                BOOST_TEST(
                     *s.insert(s.begin()+2, '*') == '*');
             });
         }
@@ -1627,7 +1627,7 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1, sp);
-                BEAST_EXPECT(string_view(
+                BOOST_TEST(string_view(
                     s.insert(s.begin()+2, 3, '*'), 5) ==
                         "***cd");
             });
@@ -1635,7 +1635,7 @@ public:
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
-                BEAST_EXPECT(string_view(
+                BOOST_TEST(string_view(
                     s.insert(s.begin()+2, 3, '*'), 5) ==
                         "***CD");
             });
@@ -1649,7 +1649,7 @@ public:
                 s.insert(s.begin()+2, t.s2.begin(), t.s2.end());
                 std::string cs(t.s1);
                 cs.insert(2, &t.s2[0], t.s2.size());
-                BEAST_EXPECT(s == cs);
+                BOOST_TEST(s == cs);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -1658,7 +1658,7 @@ public:
                 s.insert(s.begin()+2, t.s1.begin(), t.s1.end());
                 std::string cs(t.s2);
                 cs.insert(2, &t.s1[0], t.s1.size());
-                BEAST_EXPECT(s == cs);
+                BOOST_TEST(s == cs);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -1669,7 +1669,7 @@ public:
                     make_input_iterator(t.s2.end()));
                 std::string cs(t.s1);
                 cs.insert(2, &t.s2[0], t.s2.size());
-                BEAST_EXPECT(s == cs);
+                BOOST_TEST(s == cs);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -1680,7 +1680,7 @@ public:
                     make_input_iterator(t.s1.end()));
                 std::string cs(t.s2);
                 cs.insert(2, &t.s1[0], t.s1.size());
-                BEAST_EXPECT(s == cs);
+                BOOST_TEST(s == cs);
             });
         }
 
@@ -1692,7 +1692,7 @@ public:
                 s.insert(s.begin()+2, INIT2);
                 std::string cs(t.s1);
                 cs.insert(2, &t.s2[0], t.s2.size());
-                BEAST_EXPECT(s == cs);
+                BOOST_TEST(s == cs);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -1701,7 +1701,7 @@ public:
                 s.insert(s.begin()+2, INIT1);
                 std::string cs(t.s2);
                 cs.insert(2, &t.s1[0], t.s1.size());
-                BEAST_EXPECT(s == cs);
+                BOOST_TEST(s == cs);
             });
         }
 
@@ -1713,7 +1713,7 @@ public:
                 s.insert(2, string_view(t.v2));
                 std::string cs(t.v1);
                 cs.insert(2, t.s2);
-                BEAST_EXPECT(s == cs);
+                BOOST_TEST(s == cs);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -1722,7 +1722,7 @@ public:
                 s.insert(2, string_view(t.v1));
                 std::string cs(t.v2);
                 cs.insert(2, t.s1);
-                BEAST_EXPECT(s == cs);
+                BOOST_TEST(s == cs);
             });
         }
 
@@ -1734,7 +1734,7 @@ public:
                 s.insert(2, string_view(t.v2), 2, 3);
                 std::string cs(t.v1);
                 cs.insert(2, t.s2, 2, 3);
-                BEAST_EXPECT(s == cs);
+                BOOST_TEST(s == cs);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -1743,7 +1743,7 @@ public:
                 s.insert(2, string_view(t.v1), 2, 3);
                 std::string cs(t.v2);
                 cs.insert(2, t.s1, 2, 3);
-                BEAST_EXPECT(s == cs);
+                BOOST_TEST(s == cs);
             });
         }
     }
@@ -1758,48 +1758,48 @@ public:
             {
                 string s(t.v1);
                 s.erase(1, 3);
-                BEAST_EXPECT(s ==
+                BOOST_TEST(s ==
                     std::string(t.v1).erase(1, 3));
             }
 
             {
                 string s(t.v2);
                 s.erase(1, 3);
-                BEAST_EXPECT(s ==
+                BOOST_TEST(s ==
                     std::string(t.v2).erase(1, 3));
             }
 
             {
                 string s(t.v1);
                 s.erase(3);
-                BEAST_EXPECT(s ==
+                BOOST_TEST(s ==
                     std::string(t.v1).erase(3));
             }
 
             {
                 string s(t.v2);
                 s.erase(3);
-                BEAST_EXPECT(s ==
+                BOOST_TEST(s ==
                     std::string(t.v2).erase(3));
             }
 
             {
                 string s(t.v1);
                 s.erase();
-                BEAST_EXPECT(s ==
+                BOOST_TEST(s ==
                     std::string(t.v1).erase());
             }
 
             {
                 string s(t.v2);
                 s.erase();
-                BEAST_EXPECT(s ==
+                BOOST_TEST(s ==
                     std::string(t.v2).erase());
             }
 
             {
                 string s(t.v1);
-                BEAST_THROWS(
+                BOOST_TEST_THROWS(
                     (s.erase(t.v1.size() + 1, 1)),
                     std::out_of_range);
             }
@@ -1812,7 +1812,7 @@ public:
                 std::string s2(t.v1);
                 s.erase(s.begin() + 3);
                 s2.erase(s2.begin() + 3);
-                BEAST_EXPECT(s == s2);
+                BOOST_TEST(s == s2);
             }
 
             {
@@ -1820,7 +1820,7 @@ public:
                 std::string s2(t.v2);
                 s.erase(s.begin() + 3);
                 s2.erase(s2.begin() + 3);
-                BEAST_EXPECT(s == s2);
+                BOOST_TEST(s == s2);
             }
         }
 
@@ -1830,7 +1830,7 @@ public:
             std::string s2(t.v1);
             s.erase(s.begin() + 1, s.begin() + 3);
             s2.erase(s2.begin() + 1, s2.begin() + 3);
-            BEAST_EXPECT(s == s2);
+            BOOST_TEST(s == s2);
         }
     }
 
@@ -1846,7 +1846,7 @@ public:
                 string s(sp);
                 for(auto ch : t.v1)
                     s.push_back(ch);
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -1854,7 +1854,7 @@ public:
                 string s(sp);
                 for(auto ch : t.v2)
                     s.push_back(ch);
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
         }
 
@@ -1864,16 +1864,16 @@ public:
                 string s(t.v1);
                 while(! s.empty())
                     s.pop_back();
-                BEAST_EXPECT(s.empty());
-                BEAST_EXPECT(s.capacity() > 0);
+                BOOST_TEST(s.empty());
+                BOOST_TEST(s.capacity() > 0);
             }
 
             {
                 string s(t.v2);
                 while(! s.empty())
                     s.pop_back();
-                BEAST_EXPECT(s.empty());
-                BEAST_EXPECT(s.capacity() > 0);
+                BOOST_TEST(s.empty());
+                BOOST_TEST(s.capacity() > 0);
             }
         }
     }
@@ -1889,7 +1889,7 @@ public:
             {
                 string s(t.v1, sp);
                 s.append(t.v2.size(), '*');
-                BEAST_EXPECT(s == t.s1 +
+                BOOST_TEST(s == t.s1 +
                     std::string(t.v2.size(), '*'));
             });
 
@@ -1897,7 +1897,7 @@ public:
             {
                 string s(t.v2, sp);
                 s.append(t.v1.size(), '*');
-                BEAST_EXPECT(s == t.s2 +
+                BOOST_TEST(s == t.s2 +
                     std::string(t.v1.size(), '*'));
             });
         }
@@ -1908,14 +1908,14 @@ public:
             {
                 string s(t.v1, sp);
                 s.append(string(t.v2));
-                BEAST_EXPECT(s == t.s1 + t.s2);
+                BOOST_TEST(s == t.s1 + t.s2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s.append(string(t.v1));
-                BEAST_EXPECT(s == t.s2 + t.s1);
+                BOOST_TEST(s == t.s2 + t.s1);
             });
         }
 
@@ -1925,28 +1925,28 @@ public:
             {
                 string s(t.v1, sp);
                 s.append(string(t.v2), 3);
-                BEAST_EXPECT(s == t.s1 + t.s2.substr(3));
+                BOOST_TEST(s == t.s1 + t.s2.substr(3));
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s.append(string(t.v1), 3);
-                BEAST_EXPECT(s == t.s2 + t.s1.substr(3));
+                BOOST_TEST(s == t.s2 + t.s1.substr(3));
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1, sp);
                 s.append(string(t.v2), 2, 3);
-                BEAST_EXPECT(s == t.s1 + t.s2.substr(2, 3));
+                BOOST_TEST(s == t.s1 + t.s2.substr(2, 3));
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s.append(string(t.v1), 2, 3);
-                BEAST_EXPECT(s == t.s2 + t.s1.substr(2, 3));
+                BOOST_TEST(s == t.s2 + t.s1.substr(2, 3));
             });
         }
 
@@ -1956,14 +1956,14 @@ public:
             {
                 string s(t.v1, sp);
                 s.append(t.s2.c_str());
-                BEAST_EXPECT(s == t.s1 + t.s2);
+                BOOST_TEST(s == t.s1 + t.s2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s.append(t.s1.c_str());
-                BEAST_EXPECT(s == t.s2 + t.s1);
+                BOOST_TEST(s == t.s2 + t.s1);
             });
         }
 
@@ -1973,14 +1973,14 @@ public:
             {
                 string s(t.v1, sp);
                 s.append(t.s2.c_str(), 5);
-                BEAST_EXPECT(s == t.s1 + t.s2.substr(0, 5));
+                BOOST_TEST(s == t.s1 + t.s2.substr(0, 5));
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s.append(t.s1.c_str(), 5);
-                BEAST_EXPECT(s == t.s2 + t.s1.substr(0, 5));
+                BOOST_TEST(s == t.s2 + t.s1.substr(0, 5));
             });
         }
 
@@ -1990,14 +1990,14 @@ public:
             {
                 string s(t.v1, sp);
                 s.append(INIT2);
-                BEAST_EXPECT(s == t.s1 + t.s2);
+                BOOST_TEST(s == t.s1 + t.s2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s.append(INIT1);
-                BEAST_EXPECT(s == t.s2 + t.s1);
+                BOOST_TEST(s == t.s2 + t.s1);
             });
         }
 
@@ -2007,14 +2007,14 @@ public:
             {
                 string s(t.v1, sp);
                 s.append(t.s2.begin(), t.s2.end());
-                BEAST_EXPECT(s == t.s1 + t.s2);
+                BOOST_TEST(s == t.s1 + t.s2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s.append(t.s1.begin(), t.s1.end());
-                BEAST_EXPECT(s == t.s2 + t.s1);
+                BOOST_TEST(s == t.s2 + t.s1);
             });
 
             // Fails on Visual Studio 2017 C++2a Strict
@@ -2024,7 +2024,7 @@ public:
                 s.append(
                     make_input_iterator(t.s2.begin()),
                     make_input_iterator(t.s2.end()));
-                BEAST_EXPECT(s == t.s1 + t.s2);
+                BOOST_TEST(s == t.s1 + t.s2);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -2033,7 +2033,7 @@ public:
                 s.append(
                     make_input_iterator(t.s1.begin()),
                     make_input_iterator(t.s1.end()));
-                BEAST_EXPECT(s == t.s2 + t.s1);
+                BOOST_TEST(s == t.s2 + t.s1);
             });
         }
 
@@ -2043,14 +2043,14 @@ public:
             {
                 string s(t.v1, sp);
                 s.append(t.v2);
-                BEAST_EXPECT(s == t.s1 + t.s2);
+                BOOST_TEST(s == t.s1 + t.s2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s.append(t.v1);
-                BEAST_EXPECT(s == t.s2 + t.s1);
+                BOOST_TEST(s == t.s2 + t.s1);
             });
         }
 
@@ -2060,28 +2060,28 @@ public:
             {
                 string s(t.v1, sp);
                 s.append(t.v2, 2);
-                BEAST_EXPECT(s == t.s1 + t.s2.substr(2));
+                BOOST_TEST(s == t.s1 + t.s2.substr(2));
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s.append(t.v1, 2);
-                BEAST_EXPECT(s == t.s2 + t.s1.substr(2));
+                BOOST_TEST(s == t.s2 + t.s1.substr(2));
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v1, sp);
                 s.append(t.v2, 2, 3);
-                BEAST_EXPECT(s == t.s1 + t.s2.substr(2, 3));
+                BOOST_TEST(s == t.s1 + t.s2.substr(2, 3));
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s.append(t.v1, 2, 3);
-                BEAST_EXPECT(s == t.s2 + t.s1.substr(2, 3));
+                BOOST_TEST(s == t.s2 + t.s1.substr(2, 3));
             });
         }
     }
@@ -2097,14 +2097,14 @@ public:
             {
                 string s(t.v1, sp);
                 s += string(t.v2);
-                BEAST_EXPECT(s == t.s1 + t.s2);
+                BOOST_TEST(s == t.s1 + t.s2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s += string(t.v1);
-                BEAST_EXPECT(s == t.s2 + t.s1);
+                BOOST_TEST(s == t.s2 + t.s1);
             });
         }
 
@@ -2115,7 +2115,7 @@ public:
                 string s(sp);
                 for(auto ch : t.v1)
                     s += ch;
-                BEAST_EXPECT(s == t.v1);
+                BOOST_TEST(s == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -2123,7 +2123,7 @@ public:
                 string s(sp);
                 for(auto ch : t.v2)
                     s += ch;
-                BEAST_EXPECT(s == t.v2);
+                BOOST_TEST(s == t.v2);
             });
         }
 
@@ -2133,14 +2133,14 @@ public:
             {
                 string s(t.v1, sp);
                 s += t.s2.c_str();
-                BEAST_EXPECT(s == t.s1 + t.s2);
+                BOOST_TEST(s == t.s1 + t.s2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s += t.s1.c_str();
-                BEAST_EXPECT(s == t.s2 + t.s1);
+                BOOST_TEST(s == t.s2 + t.s1);
             });
         }
 
@@ -2150,14 +2150,14 @@ public:
             {
                 string s(t.v1, sp);
                 s += INIT2;
-                BEAST_EXPECT(s == t.s1 + t.s2);
+                BOOST_TEST(s == t.s1 + t.s2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s += INIT1;
-                BEAST_EXPECT(s == t.s2 + t.s1);
+                BOOST_TEST(s == t.s2 + t.s1);
             });
         }
 
@@ -2167,14 +2167,14 @@ public:
             {
                 string s(t.v1, sp);
                 s += t.v2;
-                BEAST_EXPECT(s == t.s1 + t.s2);
+                BOOST_TEST(s == t.s1 + t.s2);
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(t.v2, sp);
                 s += t.v1;
-                BEAST_EXPECT(s == t.s2 + t.s1);
+                BOOST_TEST(s == t.s2 + t.s1);
             });
         }
     }
@@ -2186,49 +2186,49 @@ public:
         string const v1 = t.v1;
 
         // compare(string)
-        BEAST_EXPECT(v1.compare(string("aaaaaaa")) > 0);
-        BEAST_EXPECT(v1.compare(string(t.v1)) == 0);
-        BEAST_EXPECT(v1.compare(string("bbbbbbb")) < 0);
+        BOOST_TEST(v1.compare(string("aaaaaaa")) > 0);
+        BOOST_TEST(v1.compare(string(t.v1)) == 0);
+        BOOST_TEST(v1.compare(string("bbbbbbb")) < 0);
 
         // compare(size_type, size_type, string)
-        BEAST_EXPECT(v1.compare(2, 3, string("ccc")) > 0);
-        BEAST_EXPECT(v1.compare(2, 3, string("cde")) == 0);
-        BEAST_EXPECT(v1.compare(2, 3, string("eee")) < 0);
+        BOOST_TEST(v1.compare(2, 3, string("ccc")) > 0);
+        BOOST_TEST(v1.compare(2, 3, string("cde")) == 0);
+        BOOST_TEST(v1.compare(2, 3, string("eee")) < 0);
 
         // compare(size_type, size_type, string, size_type, size_type)
-        BEAST_EXPECT(v1.compare(2, 3, string("bbbbb"), 1, 3) > 0);
-        BEAST_EXPECT(v1.compare(2, 3, string("bcdef"), 1, 3) == 0);
-        BEAST_EXPECT(v1.compare(2, 3, string("fffff"), 1, 3) < 0);
+        BOOST_TEST(v1.compare(2, 3, string("bbbbb"), 1, 3) > 0);
+        BOOST_TEST(v1.compare(2, 3, string("bcdef"), 1, 3) == 0);
+        BOOST_TEST(v1.compare(2, 3, string("fffff"), 1, 3) < 0);
 
         // compare(char const*)
-        BEAST_EXPECT(v1.compare("aaaaaaa") > 0);
-        BEAST_EXPECT(v1.compare(t.s1.c_str()) == 0);
-        BEAST_EXPECT(v1.compare("bbbbbbb") < 0);
+        BOOST_TEST(v1.compare("aaaaaaa") > 0);
+        BOOST_TEST(v1.compare(t.s1.c_str()) == 0);
+        BOOST_TEST(v1.compare("bbbbbbb") < 0);
 
         // compare(size_type, size_type, char const*)
-        BEAST_EXPECT(v1.compare(2, 3, "ccc") > 0);
-        BEAST_EXPECT(v1.compare(2, 3, "cde") == 0);
-        BEAST_EXPECT(v1.compare(2, 3, "eee") < 0);
+        BOOST_TEST(v1.compare(2, 3, "ccc") > 0);
+        BOOST_TEST(v1.compare(2, 3, "cde") == 0);
+        BOOST_TEST(v1.compare(2, 3, "eee") < 0);
 
         // compare(size_type, size_type, char const*, size_type)
-        BEAST_EXPECT(v1.compare(2, 4, "cccc", 4) > 0);
-        BEAST_EXPECT(v1.compare(2, 4, "cdef", 4) == 0);
-        BEAST_EXPECT(v1.compare(2, 4, "ffff", 4) < 0);
+        BOOST_TEST(v1.compare(2, 4, "cccc", 4) > 0);
+        BOOST_TEST(v1.compare(2, 4, "cdef", 4) == 0);
+        BOOST_TEST(v1.compare(2, 4, "ffff", 4) < 0);
 
         // compare(string_view s)
-        BEAST_EXPECT(v1.compare(string_view("aaaaaaa")) > 0);
-        BEAST_EXPECT(v1.compare(t.v1) == 0);
-        BEAST_EXPECT(v1.compare(string_view("bbbbbbb")) < 0);
+        BOOST_TEST(v1.compare(string_view("aaaaaaa")) > 0);
+        BOOST_TEST(v1.compare(t.v1) == 0);
+        BOOST_TEST(v1.compare(string_view("bbbbbbb")) < 0);
 
         // compare(size_type, size_type, string_view)
-        BEAST_EXPECT(v1.compare(2, 3, string_view("ccc")) > 0);
-        BEAST_EXPECT(v1.compare(2, 3, string_view("cde")) == 0);
-        BEAST_EXPECT(v1.compare(2, 3, string_view("eee")) < 0);
+        BOOST_TEST(v1.compare(2, 3, string_view("ccc")) > 0);
+        BOOST_TEST(v1.compare(2, 3, string_view("cde")) == 0);
+        BOOST_TEST(v1.compare(2, 3, string_view("eee")) < 0);
 
         // compare(size_type, size_type, string_view, size_type, size_type)
-        BEAST_EXPECT(v1.compare(2, 3, string_view("bbbbb"), 1, 3) > 0);
-        BEAST_EXPECT(v1.compare(2, 3, string_view("bcdef"), 1, 3) == 0);
-        BEAST_EXPECT(v1.compare(2, 3, string_view("fffff"), 1, 3) < 0);
+        BOOST_TEST(v1.compare(2, 3, string_view("bbbbb"), 1, 3) > 0);
+        BOOST_TEST(v1.compare(2, 3, string_view("bcdef"), 1, 3) == 0);
+        BOOST_TEST(v1.compare(2, 3, string_view("fffff"), 1, 3) < 0);
     }
 
     void
@@ -2240,50 +2240,50 @@ public:
 
         // starts_with(string_view)
         {
-            BEAST_EXPECT(v1.starts_with(string_view("abc")));
-            BEAST_EXPECT(v2.starts_with(string_view("ABC")));
-            BEAST_EXPECT(! v1.starts_with(string_view("xyz")));
-            BEAST_EXPECT(! v2.starts_with(string_view("XYZ")));
+            BOOST_TEST(v1.starts_with(string_view("abc")));
+            BOOST_TEST(v2.starts_with(string_view("ABC")));
+            BOOST_TEST(! v1.starts_with(string_view("xyz")));
+            BOOST_TEST(! v2.starts_with(string_view("XYZ")));
         }
 
         // starts_with(char)
         {
-            BEAST_EXPECT(v1.starts_with('a'));
-            BEAST_EXPECT(v2.starts_with('A'));
-            BEAST_EXPECT(! v1.starts_with('x'));
-            BEAST_EXPECT(! v2.starts_with('X'));
+            BOOST_TEST(v1.starts_with('a'));
+            BOOST_TEST(v2.starts_with('A'));
+            BOOST_TEST(! v1.starts_with('x'));
+            BOOST_TEST(! v2.starts_with('X'));
         }
 
         // starts_with(char const*)
         {
-            BEAST_EXPECT(v1.starts_with("abc"));
-            BEAST_EXPECT(v2.starts_with("ABC"));
-            BEAST_EXPECT(! v1.starts_with("xyz"));
-            BEAST_EXPECT(! v2.starts_with("XYZ"));
+            BOOST_TEST(v1.starts_with("abc"));
+            BOOST_TEST(v2.starts_with("ABC"));
+            BOOST_TEST(! v1.starts_with("xyz"));
+            BOOST_TEST(! v2.starts_with("XYZ"));
         }
 
         // ends_with(string_view)
         {
-            BEAST_EXPECT(v1.ends_with(last_of(t.s1,3)));
-            BEAST_EXPECT(v2.ends_with(last_of(t.s2,3)));
-            BEAST_EXPECT(! v1.ends_with(string_view("abc")));
-            BEAST_EXPECT(! v2.ends_with(string_view("ABC")));
+            BOOST_TEST(v1.ends_with(last_of(t.s1,3)));
+            BOOST_TEST(v2.ends_with(last_of(t.s2,3)));
+            BOOST_TEST(! v1.ends_with(string_view("abc")));
+            BOOST_TEST(! v2.ends_with(string_view("ABC")));
         }
 
         // ends_with(char)
         {
-            BEAST_EXPECT(v1.ends_with(last_of(t.s1, 1)[0]));
-            BEAST_EXPECT(v2.ends_with(last_of(t.s2, 1)[0]));
-            BEAST_EXPECT(! v1.ends_with('a'));
-            BEAST_EXPECT(! v2.ends_with('A'));
+            BOOST_TEST(v1.ends_with(last_of(t.s1, 1)[0]));
+            BOOST_TEST(v2.ends_with(last_of(t.s2, 1)[0]));
+            BOOST_TEST(! v1.ends_with('a'));
+            BOOST_TEST(! v2.ends_with('A'));
         }
 
         // ends_with(char const*)
         {
-            BEAST_EXPECT(v1.ends_with(last_of(t.s1, 3).data()));
-            BEAST_EXPECT(v2.ends_with(last_of(t.s2, 3).data()));
-            BEAST_EXPECT(! v1.ends_with("abc"));
-            BEAST_EXPECT(! v2.ends_with("ABC"));
+            BOOST_TEST(v1.ends_with(last_of(t.s1, 3).data()));
+            BOOST_TEST(v2.ends_with(last_of(t.s2, 3).data()));
+            BOOST_TEST(! v1.ends_with("abc"));
+            BOOST_TEST(! v2.ends_with("ABC"));
         }
     }
 
@@ -2300,12 +2300,12 @@ public:
         string const s2 = t.v2;
 
         // substr(size_type, size_type)
-        BEAST_EXPECT(s1.substr() == t.v1);
-        BEAST_EXPECT(s1.substr(1) == t.v1.substr(1));
-        BEAST_EXPECT(s1.substr(1, 3) == t.v1.substr(1, 3));
-        BEAST_EXPECT(s2.substr() == t.v2);
-        BEAST_EXPECT(s2.substr(1) == t.v2.substr(1));
-        BEAST_EXPECT(s2.substr(1, 3) == t.v2.substr(1, 3));
+        BOOST_TEST(s1.substr() == t.v1);
+        BOOST_TEST(s1.substr(1) == t.v1.substr(1));
+        BOOST_TEST(s1.substr(1, 3) == t.v1.substr(1, 3));
+        BOOST_TEST(s2.substr() == t.v2);
+        BOOST_TEST(s2.substr(1) == t.v2.substr(1));
+        BOOST_TEST(s2.substr(1, 3) == t.v2.substr(1, 3));
     }
 
     void
@@ -2320,7 +2320,7 @@ public:
                 std::string d;
                 d.resize(s.size());
                 s.copy(&d[0], d.size(), 0);
-                BEAST_EXPECT(d == t.v1);
+                BOOST_TEST(d == t.v1);
             }
 
             {
@@ -2328,7 +2328,7 @@ public:
                 std::string d;
                 d.resize(s.size());
                 s.copy(&d[0], d.size());
-                BEAST_EXPECT(d == t.v1);
+                BOOST_TEST(d == t.v1);
             }
         }
     }
@@ -2344,16 +2344,16 @@ public:
             {
                 string s(sp);
                 s.resize(t.v1.size());
-                BEAST_EXPECT(s.size() == t.v1.size());
-                BEAST_EXPECT(s == string(t.v1.size(), '\0'));
+                BOOST_TEST(s.size() == t.v1.size());
+                BOOST_TEST(s == string(t.v1.size(), '\0'));
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(sp);
                 s.resize(t.v2.size());
-                BEAST_EXPECT(s.size() == t.v2.size());
-                BEAST_EXPECT(s == string(t.v2.size(), '\0'));
+                BOOST_TEST(s.size() == t.v2.size());
+                BOOST_TEST(s == string(t.v2.size(), '\0'));
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -2361,9 +2361,9 @@ public:
                 string s(sp);
                 s.resize(t.v1.size());
                 s.resize(t.v2.size());
-                BEAST_EXPECT(s == string(t.v2.size(), '\0'));
+                BOOST_TEST(s == string(t.v2.size(), '\0'));
                 s.resize(t.v1.size());
-                BEAST_EXPECT(s == string(t.v1.size(), '\0'));
+                BOOST_TEST(s == string(t.v1.size(), '\0'));
             });
         }
 
@@ -2373,16 +2373,16 @@ public:
             {
                 string s(sp);
                 s.resize(t.v1.size(), '*');
-                BEAST_EXPECT(s.size() == t.v1.size());
-                BEAST_EXPECT(s == string(t.v1.size(), '*'));
+                BOOST_TEST(s.size() == t.v1.size());
+                BOOST_TEST(s == string(t.v1.size(), '*'));
             });
 
             fail_loop([&](storage_ptr const& sp)
             {
                 string s(sp);
                 s.resize(t.v2.size(), '*');
-                BEAST_EXPECT(s.size() == t.v2.size());
-                BEAST_EXPECT(s == string(t.v2.size(), '*'));
+                BOOST_TEST(s.size() == t.v2.size());
+                BOOST_TEST(s == string(t.v2.size(), '*'));
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -2390,9 +2390,9 @@ public:
                 string s(sp);
                 s.resize(t.v1.size(), '*');
                 s.resize(t.v2.size(), '*');
-                BEAST_EXPECT(s == string(t.v2.size(), '*'));
+                BOOST_TEST(s == string(t.v2.size(), '*'));
                 s.resize(t.v1.size());
-                BEAST_EXPECT(s == string(t.v1.size(), '*'));
+                BOOST_TEST(s == string(t.v1.size(), '*'));
             });
         }
     }
@@ -2409,8 +2409,8 @@ public:
                 string s1(t.v1, sp);
                 string s2(t.v2, sp);
                 s1.swap(s2);
-                BEAST_EXPECT(s1 == t.v2);
-                BEAST_EXPECT(s2 == t.v1);
+                BOOST_TEST(s1 == t.v2);
+                BOOST_TEST(s2 == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -2418,8 +2418,8 @@ public:
                 string s1(t.v1, sp);
                 string s2(t.v2, sp);
                 swap(s1, s2);
-                BEAST_EXPECT(s1 == t.v2);
-                BEAST_EXPECT(s2 == t.v1);
+                BOOST_TEST(s1 == t.v2);
+                BOOST_TEST(s2 == t.v1);
             });
 
             fail_loop([&](storage_ptr const& sp)
@@ -2427,8 +2427,8 @@ public:
                 string s1(t.v1);
                 string s2(t.v2, sp);
                 s1.swap(s2);
-                BEAST_EXPECT(s1 == t.v2);
-                BEAST_EXPECT(s2 == t.v1);
+                BOOST_TEST(s1 == t.v2);
+                BOOST_TEST(s2 == t.v1);
             });
         }
     }
@@ -2441,29 +2441,29 @@ public:
         string const s2 = t.v2;
 
         // find(string, size_type)
-        BEAST_EXPECT(s1.find(string("bcd")) == 1);
-        BEAST_EXPECT(s1.find(string("cde"), 1) == 2);
-        BEAST_EXPECT(s1.find(string("efg"), 5) == string::npos);
+        BOOST_TEST(s1.find(string("bcd")) == 1);
+        BOOST_TEST(s1.find(string("cde"), 1) == 2);
+        BOOST_TEST(s1.find(string("efg"), 5) == string::npos);
 
         // find(char const*, size_type, size_type)
-        BEAST_EXPECT(s1.find("bcd*", 0, 3) == 1);
-        BEAST_EXPECT(s1.find("cde*", 1, 3) == 2);
-        BEAST_EXPECT(s1.find("efg*", 5, 3) == string::npos);
+        BOOST_TEST(s1.find("bcd*", 0, 3) == 1);
+        BOOST_TEST(s1.find("cde*", 1, 3) == 2);
+        BOOST_TEST(s1.find("efg*", 5, 3) == string::npos);
 
         // find(char const*, size_type)
-        BEAST_EXPECT(s1.find("bcd", 0) == 1);
-        BEAST_EXPECT(s1.find("cde", 1) == 2);
-        BEAST_EXPECT(s1.find("efg", 5) == string::npos);
+        BOOST_TEST(s1.find("bcd", 0) == 1);
+        BOOST_TEST(s1.find("cde", 1) == 2);
+        BOOST_TEST(s1.find("efg", 5) == string::npos);
 
         // find(char, size_type)
-        BEAST_EXPECT(s1.find('b') == 1);
-        BEAST_EXPECT(s1.find('c', 1) == 2);
-        BEAST_EXPECT(s1.find('e', 5) == string::npos);
+        BOOST_TEST(s1.find('b') == 1);
+        BOOST_TEST(s1.find('c', 1) == 2);
+        BOOST_TEST(s1.find('e', 5) == string::npos);
 
         // find(T const, size_type pos)
-        BEAST_EXPECT(s1.find(string_view("bcd")) == 1);
-        BEAST_EXPECT(s1.find(string_view("cde"), 1) == 2);
-        BEAST_EXPECT(s1.find(string_view("efg"), 5) == string::npos);
+        BOOST_TEST(s1.find(string_view("bcd")) == 1);
+        BOOST_TEST(s1.find(string_view("cde"), 1) == 2);
+        BOOST_TEST(s1.find(string_view("efg"), 5) == string::npos);
     }
 
     void
@@ -2502,90 +2502,90 @@ public:
         auto const c1 = t.s1.c_str();
         auto const c2 = t.s2.c_str();
 
-        BEAST_EXPECT(! operator< (s1, s2));
-        BEAST_EXPECT(! operator< (s1, v2));
-        BEAST_EXPECT(! operator< (s1, c2));
-        BEAST_EXPECT(! operator<=(s1, s2));
-        BEAST_EXPECT(! operator<=(s1, v2));
-        BEAST_EXPECT(! operator<=(s1, c2));
-        BEAST_EXPECT(! operator==(s1, s2));
-        BEAST_EXPECT(! operator==(s1, v2));
-        BEAST_EXPECT(! operator==(s1, c2));
-        BEAST_EXPECT(  operator!=(s1, s2));
-        BEAST_EXPECT(  operator!=(s1, v2));
-        BEAST_EXPECT(  operator!=(s1, c2));
-        BEAST_EXPECT(  operator>=(s1, s2));
-        BEAST_EXPECT(  operator>=(s1, v2));
-        BEAST_EXPECT(  operator>=(s1, c2));
-        BEAST_EXPECT(  operator> (s1, s2));
-        BEAST_EXPECT(  operator> (s1, v2));
-        BEAST_EXPECT(  operator> (s1, c2));
+        BOOST_TEST(! operator< (s1, s2));
+        BOOST_TEST(! operator< (s1, v2));
+        BOOST_TEST(! operator< (s1, c2));
+        BOOST_TEST(! operator<=(s1, s2));
+        BOOST_TEST(! operator<=(s1, v2));
+        BOOST_TEST(! operator<=(s1, c2));
+        BOOST_TEST(! operator==(s1, s2));
+        BOOST_TEST(! operator==(s1, v2));
+        BOOST_TEST(! operator==(s1, c2));
+        BOOST_TEST(  operator!=(s1, s2));
+        BOOST_TEST(  operator!=(s1, v2));
+        BOOST_TEST(  operator!=(s1, c2));
+        BOOST_TEST(  operator>=(s1, s2));
+        BOOST_TEST(  operator>=(s1, v2));
+        BOOST_TEST(  operator>=(s1, c2));
+        BOOST_TEST(  operator> (s1, s2));
+        BOOST_TEST(  operator> (s1, v2));
+        BOOST_TEST(  operator> (s1, c2));
 
-        BEAST_EXPECT(  operator< (s2, s1));
-        BEAST_EXPECT(  operator< (s2, v1));
-        BEAST_EXPECT(  operator< (s2, c1));
-        BEAST_EXPECT(  operator<=(s2, s1));
-        BEAST_EXPECT(  operator<=(s2, v1));
-        BEAST_EXPECT(  operator<=(s2, c1));
-        BEAST_EXPECT(  operator!=(s2, s1));
-        BEAST_EXPECT(  operator!=(s2, v1));
-        BEAST_EXPECT(  operator!=(s2, c1));
-        BEAST_EXPECT(! operator==(s2, s1));
-        BEAST_EXPECT(! operator==(s2, v1));
-        BEAST_EXPECT(! operator==(s2, c1));
-        BEAST_EXPECT(! operator>=(s2, s1));
-        BEAST_EXPECT(! operator>=(s2, v1));
-        BEAST_EXPECT(! operator>=(s2, c1));
-        BEAST_EXPECT(! operator> (s2, s1));
-        BEAST_EXPECT(! operator> (s2, v1));
-        BEAST_EXPECT(! operator> (s2, c1));
+        BOOST_TEST(  operator< (s2, s1));
+        BOOST_TEST(  operator< (s2, v1));
+        BOOST_TEST(  operator< (s2, c1));
+        BOOST_TEST(  operator<=(s2, s1));
+        BOOST_TEST(  operator<=(s2, v1));
+        BOOST_TEST(  operator<=(s2, c1));
+        BOOST_TEST(  operator!=(s2, s1));
+        BOOST_TEST(  operator!=(s2, v1));
+        BOOST_TEST(  operator!=(s2, c1));
+        BOOST_TEST(! operator==(s2, s1));
+        BOOST_TEST(! operator==(s2, v1));
+        BOOST_TEST(! operator==(s2, c1));
+        BOOST_TEST(! operator>=(s2, s1));
+        BOOST_TEST(! operator>=(s2, v1));
+        BOOST_TEST(! operator>=(s2, c1));
+        BOOST_TEST(! operator> (s2, s1));
+        BOOST_TEST(! operator> (s2, v1));
+        BOOST_TEST(! operator> (s2, c1));
 
-        BEAST_EXPECT(  operator< (s2, s1));
-        BEAST_EXPECT(  operator< (v2, s1));
-        BEAST_EXPECT(  operator< (c2, s1));
-        BEAST_EXPECT(  operator<=(s2, s1));
-        BEAST_EXPECT(  operator<=(v2, s1));
-        BEAST_EXPECT(  operator<=(c2, s1));
-        BEAST_EXPECT(  operator!=(s2, s1));
-        BEAST_EXPECT(  operator!=(v2, s1));
-        BEAST_EXPECT(  operator!=(c2, s1));
-        BEAST_EXPECT(! operator==(s2, s1));
-        BEAST_EXPECT(! operator==(v2, s1));
-        BEAST_EXPECT(! operator==(c2, s1));
-        BEAST_EXPECT(! operator>=(s2, s1));
-        BEAST_EXPECT(! operator>=(v2, s1));
-        BEAST_EXPECT(! operator>=(c2, s1));
-        BEAST_EXPECT(! operator> (s2, s1));
-        BEAST_EXPECT(! operator> (v2, s1));
-        BEAST_EXPECT(! operator> (c2, s1));
+        BOOST_TEST(  operator< (s2, s1));
+        BOOST_TEST(  operator< (v2, s1));
+        BOOST_TEST(  operator< (c2, s1));
+        BOOST_TEST(  operator<=(s2, s1));
+        BOOST_TEST(  operator<=(v2, s1));
+        BOOST_TEST(  operator<=(c2, s1));
+        BOOST_TEST(  operator!=(s2, s1));
+        BOOST_TEST(  operator!=(v2, s1));
+        BOOST_TEST(  operator!=(c2, s1));
+        BOOST_TEST(! operator==(s2, s1));
+        BOOST_TEST(! operator==(v2, s1));
+        BOOST_TEST(! operator==(c2, s1));
+        BOOST_TEST(! operator>=(s2, s1));
+        BOOST_TEST(! operator>=(v2, s1));
+        BOOST_TEST(! operator>=(c2, s1));
+        BOOST_TEST(! operator> (s2, s1));
+        BOOST_TEST(! operator> (v2, s1));
+        BOOST_TEST(! operator> (c2, s1));
 
-        BEAST_EXPECT(! operator< (s1, s2));
-        BEAST_EXPECT(! operator< (v1, s2));
-        BEAST_EXPECT(! operator< (c1, s2));
-        BEAST_EXPECT(! operator<=(s1, s2));
-        BEAST_EXPECT(! operator<=(v1, s2));
-        BEAST_EXPECT(! operator<=(c1, s2));
-        BEAST_EXPECT(! operator==(s1, s2));
-        BEAST_EXPECT(! operator==(v1, s2));
-        BEAST_EXPECT(! operator==(c1, s2));
-        BEAST_EXPECT(  operator!=(s1, s2));
-        BEAST_EXPECT(  operator!=(v1, s2));
-        BEAST_EXPECT(  operator!=(c1, s2));
-        BEAST_EXPECT(  operator>=(s1, s2));
-        BEAST_EXPECT(  operator>=(v1, s2));
-        BEAST_EXPECT(  operator>=(c1, s2));
-        BEAST_EXPECT(  operator> (s1, s2));
-        BEAST_EXPECT(  operator> (v1, s2));
-        BEAST_EXPECT(  operator> (c1, s2));
+        BOOST_TEST(! operator< (s1, s2));
+        BOOST_TEST(! operator< (v1, s2));
+        BOOST_TEST(! operator< (c1, s2));
+        BOOST_TEST(! operator<=(s1, s2));
+        BOOST_TEST(! operator<=(v1, s2));
+        BOOST_TEST(! operator<=(c1, s2));
+        BOOST_TEST(! operator==(s1, s2));
+        BOOST_TEST(! operator==(v1, s2));
+        BOOST_TEST(! operator==(c1, s2));
+        BOOST_TEST(  operator!=(s1, s2));
+        BOOST_TEST(  operator!=(v1, s2));
+        BOOST_TEST(  operator!=(c1, s2));
+        BOOST_TEST(  operator>=(s1, s2));
+        BOOST_TEST(  operator>=(v1, s2));
+        BOOST_TEST(  operator>=(c1, s2));
+        BOOST_TEST(  operator> (s1, s2));
+        BOOST_TEST(  operator> (v1, s2));
+        BOOST_TEST(  operator> (c1, s2));
 
         std::stringstream ss;
         string s = "Hello, world";
         ss << s;
-        BEAST_EXPECT(ss.str() == s);
+        BOOST_TEST(ss.str() == s);
     }
 
     void
-    run() override
+    run()
     {
         testConstruction();
         testAssignment();
@@ -2619,7 +2619,7 @@ public:
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,string);
+TEST_SUITE(string_test, "boost.json.string");
 
 } // json
 } // boost
diff --git a/test/test.hpp b/test/test.hpp
index ac851426..837f306a 100644
--- a/test/test.hpp
+++ b/test/test.hpp
@@ -15,12 +15,14 @@
 #include <boost/json/serializer.hpp>
 #include <boost/json/storage_ptr.hpp>
 #include <boost/json/detail/format.hpp>
-#include <boost/beast/_experimental/unit_test/suite.hpp>
+
 #include <cstddef>
 #include <iterator>
 #include <memory>
 #include <type_traits>
 
+#include "test_suite.hpp"
+
 namespace boost {
 namespace json {
 
@@ -54,7 +56,7 @@ struct fail_storage
 
     ~fail_storage()
     {
-        BEAST_EXPECT(nalloc == 0);
+        BOOST_TEST(nalloc == 0);
     }
 
     void*
@@ -79,7 +81,7 @@ struct fail_storage
         std::size_t,
         std::size_t) noexcept
     {
-        if(BEAST_EXPECT(nalloc > 0))
+        if(BOOST_TEST(nalloc > 0))
             --nalloc;
         ::operator delete(p);
     }
@@ -103,7 +105,7 @@ fail_loop(F&& f)
         }
         break;
     }
-    BEAST_EXPECT(ss->fail < 200);
+    BOOST_TEST(ss->fail < 200);
 }
 
 //----------------------------------------------------------
@@ -577,7 +579,7 @@ check_storage(
     object const& o,
     storage_ptr const& sp)
 {
-    BEAST_EXPECT(equal_storage(o, sp));
+    BOOST_TEST(equal_storage(o, sp));
 }
 
 inline
@@ -586,7 +588,7 @@ check_storage(
     array const& a,
     storage_ptr const& sp)
 {
-    BEAST_EXPECT(equal_storage(a, sp));
+    BOOST_TEST(equal_storage(a, sp));
 }
 
 inline
@@ -595,7 +597,7 @@ check_storage(
     value const& v,
     storage_ptr const& sp)
 {
-    BEAST_EXPECT(equal_storage(v, sp));
+    BOOST_TEST(equal_storage(v, sp));
 }
 
 //----------------------------------------------------------
diff --git a/test/test_suite.hpp b/test/test_suite.hpp
new file mode 100644
index 00000000..60e80706
--- /dev/null
+++ b/test/test_suite.hpp
@@ -0,0 +1,641 @@
+//
+// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/vinniefalco/json
+//
+
+#ifndef TEST_SUITE_HPP
+#define TEST_SUITE_HPP
+
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <cstdlib>
+#include <cstring>
+#include <iomanip>
+#include <ios>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <streambuf>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#ifdef _MSC_VER
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <debugapi.h>
+#endif
+
+//  This is a derivative work
+//  Copyright 2002-2018 Peter Dimov
+//  Copyright (c) 2002, 2009, 2014 Peter Dimov
+//  Copyright (2) Beman Dawes 2010, 2011
+//  Copyright (3) Ion Gaztanaga 2013
+//
+//  Copyright 2018 Glen Joseph Fernandes
+//  (glenjofe@gmail.com)
+
+namespace test_suite {
+
+//----------------------------------------------------------
+
+#ifdef _MSC_VER
+
+namespace detail {
+
+template<
+    class CharT, class Traits, class Allocator>
+class debug_streambuf
+    : public std::basic_stringbuf<
+        CharT, Traits, Allocator>
+{
+    using ostream =
+        std::basic_ostream<CharT, Traits>;
+
+    ostream& os_;
+    bool dbg_;
+
+    template<class T>
+    void write(T const*) = delete;
+
+    void write(char const* s)
+    {
+        if(dbg_)
+            ::OutputDebugStringA(s);
+        os_ << s;
+    }
+
+    void write(wchar_t const* s)
+    {
+        if(dbg_)
+            ::OutputDebugStringW(s);
+        os_ << s;
+    }
+
+public:
+    explicit
+    debug_streambuf(ostream& os)
+        : os_(os)
+        , dbg_(::IsDebuggerPresent() != 0)
+    {
+    }
+
+    ~debug_streambuf()
+    {
+        sync();
+    }
+
+    int
+    sync() override
+    {
+        write(this->str().c_str());
+        this->str("");
+        return 0;
+    }
+};
+
+/** std::ostream with Visual Studio IDE redirection.
+
+    Instances of this stream wrap a specified `std::ostream`
+    (such as `std::cout` or `std::cerr`). If the IDE debugger
+    is attached when the stream is created, output will be
+    additionally copied to the Visual Studio Output window.
+*/
+template<
+    class CharT,
+    class Traits = std::char_traits<CharT>,
+    class Allocator = std::allocator<CharT>
+>
+class basic_debug_stream
+    : public std::basic_ostream<CharT, Traits>
+{
+    detail::debug_streambuf<
+        CharT, Traits, Allocator> buf_;
+
+public:
+    /** Construct a stream.
+
+        @param os The output stream to wrap.
+    */
+    explicit
+    basic_debug_stream(std::ostream& os)
+        : std::basic_ostream<CharT, Traits>(&buf_)
+        , buf_(os)
+    {
+        if(os.flags() & std::ios::unitbuf)
+            std::unitbuf(*this);
+    }
+};
+
+} // detail
+
+using debug_stream  = detail::basic_debug_stream<char>;
+using debug_wstream = detail::basic_debug_stream<wchar_t>;
+
+#else
+
+using debug_stream  = std::ostream&;
+using debug_wstream = std::wostream&;
+
+#endif
+
+//----------------------------------------------------------
+
+namespace detail {
+
+struct suite_info
+{
+    char const* name;
+    void (*run)();
+};
+
+class runner;
+
+inline
+runner*&
+current() noexcept;
+
+class runner
+{
+    runner* saved_;
+
+public:
+    runner() noexcept
+        : saved_(current())
+    {
+        current() = this;
+    }
+
+    virtual
+    ~runner()
+    {
+        current() = saved_;
+    }
+
+    virtual void on_begin(char const* name) = 0;
+    virtual void on_end() = 0;
+
+    virtual void note(char const* msg) = 0;
+    virtual void pass(char const* expr, char const* file, int line, char const* func) = 0;
+    virtual void fail(char const* expr, char const* file, int line, char const* func) = 0;
+
+    template<class Bool
+#if 0
+        ,class = typename std::enable_if<
+            std::is_convertible<bool, Bool>::Value>::type
+#endif
+    >
+    bool
+    maybe_fail(
+        Bool cond,
+        char const* expr,
+        char const* file,
+        int line,
+        char const* func)
+    {
+        if(static_cast<bool>(cond))
+        {
+            pass(expr, file, line, func);
+            return true;
+        }
+        fail(expr, file, line, func);
+        return false;
+    }
+
+    void
+    run(suite_info const& si)
+    {
+        on_begin(si.name);
+        si.run();
+        on_end();
+    }
+};
+
+runner*&
+current() noexcept
+{
+    static runner* p = nullptr;
+    return p;
+}
+
+//----------------------------------------------------------
+
+using clock_type =
+    std::chrono::steady_clock;
+
+struct elapsed
+{
+    clock_type::duration d;
+};
+
+inline
+std::ostream&
+operator<<(
+    std::ostream& os,
+    elapsed const& e)
+{
+    using namespace std::chrono;
+    auto const ms = duration_cast<
+        milliseconds>(e.d);
+    if(ms < seconds{1})
+    {
+        os << ms.count() << "ms";
+    }
+    else
+    {
+        std::streamsize width{
+            os.width()};
+        std::streamsize precision{
+            os.precision()};
+        os << std::fixed <<
+            std::setprecision(1) <<
+            (ms.count() / 1000.0) << "s";
+        os.precision(precision);
+        os.width(width);
+    }
+    return os;
+}
+
+class simple_runner : public runner
+{
+    struct summary
+    {
+        char const* name;
+        clock_type::time_point start;
+        clock_type::duration elapsed;
+        std::atomic<std::size_t> failed;
+        std::atomic<std::size_t> total;
+
+        summary(summary const& other) noexcept
+            : name(other.name)
+            , start(other.start)
+            , elapsed(other.elapsed)
+            , failed(other.failed.load())
+            , total(other.total.load())
+        {
+        }
+
+        explicit
+        summary(char const* name_) noexcept
+            : name(name_)
+            , start(clock_type::now())
+            , failed(0)
+            , total(0)
+        {
+        }
+    };
+
+    summary all_;
+    std::ostream& log_;
+    std::vector<summary> v_;
+
+public:
+    explicit
+    simple_runner(
+        std::ostream& log)
+        : all_("(all)")
+        , log_(log)
+    {
+        std::unitbuf(log_);
+        v_.reserve(256);
+    }
+
+    ~simple_runner()
+    {
+        log_ <<
+            elapsed{clock_type::now() -
+                all_.start } << ", " <<
+            v_.size() << " suites, " <<
+            all_.failed.load() << " failures, " <<
+            all_.total.load() << " total." <<
+                std::endl;
+    }
+
+    // true if no failures
+    bool
+    success() const noexcept
+    {
+        return all_.failed.load() == 0;
+    }
+
+    void
+    on_begin(char const* name) override
+    {
+        v_.emplace_back(name);
+        log_ << name << "\n";
+    }
+
+    void
+    on_end() override
+    {
+        v_.back().elapsed =
+            clock_type::now() -
+            v_.back().start;
+    }
+
+    void
+    note(char const* msg) override
+    {
+        log_ << msg << "\n";
+    }
+
+    void
+    pass(char const*, char const*, int, char const*) override
+    {
+        ++all_.total;
+        ++v_.back().total;
+    }
+
+    void
+    fail(char const* expr, char const* file, int line, char const* func) override
+    {
+        ++all_.failed;
+        ++v_.back().total;
+        ++v_.back().failed;
+        auto const id = ++all_.total;
+        log_ <<
+            "#" << id <<
+            " failed: " << expr <<
+            ", file: " << file <<
+            "(" << line << ") " <<
+            func << "\n";
+    }
+};
+
+//----------------------------------------------------------
+
+template<
+    class CharT,
+    class Traits = std::char_traits<CharT>,
+    class Allocator = std::allocator<CharT>
+>
+class log_ostream
+    : public std::basic_ostream<CharT, Traits>
+{
+    struct buffer_type :
+        std::basic_stringbuf<
+            CharT, Traits, Allocator>
+    {
+        ~buffer_type()
+        {
+            sync();
+        }
+
+        int
+        sync() override
+        {
+            auto const& s = this->str();
+            if(s.size() > 0)
+                current()->note(s.c_str());
+            this->str("");
+            return 0;
+        }
+    };
+
+    buffer_type buf_;
+
+public:
+    log_ostream()
+        : std::basic_ostream<
+            CharT, Traits>(&buf_)
+    {
+    }
+};
+
+//----------------------------------------------------------
+
+class suite_list
+{
+    static std::size_t const max_size_ = 256;
+    std::size_t count_ = 0;
+    suite_info data_[max_size_];
+
+public:
+    void
+    insert(suite_info inf)
+    {
+    #ifndef BOOST_NO_EXCEPTIONS
+        if(count_ == max_size_)
+            throw std::length_error(
+                "too many test suites");
+    #endif
+        data_[count_++] = inf;
+    }
+
+    suite_info const*
+    begin() const noexcept
+    {
+        return data_;
+    }
+
+    suite_info const*
+    end() const noexcept
+    {
+        return begin() + count_;
+    }
+
+    void
+    sort()
+    {
+        std::sort(
+            data_,
+            data_ + count_,
+            []( detail::suite_info const& lhs,
+                detail::suite_info const& rhs)
+            {
+                return std::lexicographical_compare(
+                    lhs.name, lhs.name + std::strlen(lhs.name),
+                    rhs.name, rhs.name + std::strlen(rhs.name));
+            });
+    }
+};
+
+inline
+suite_list&
+suites()
+{
+    static suite_list list;
+    return list;
+}
+
+//----------------------------------------------------------
+
+template<class T>
+struct instance
+{
+    explicit
+    instance(
+        char const* name) noexcept
+    {
+        suites().insert(suite_info{
+            name, &instance::run });
+    }
+
+    static
+    void
+    run()
+    {
+        auto const saved =
+            current();
+        //current()->os_ 
+        T().run();
+        current() = saved;
+    }
+};
+
+//----------------------------------------------------------
+
+inline
+void
+current_function_helper()
+{
+#if  defined(__GNUC__) || \
+    (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || \
+    (defined(__ICC) && (__ICC >= 600)) || \
+        defined(__ghs__) || \
+        defined(__clang__)
+# define TEST_SUITE_FUNCTION __PRETTY_FUNCTION__
+
+#elif defined(__DMC__) && (__DMC__ >= 0x810)
+# define TEST_SUITE_FUNCTION __PRETTY_FUNCTION__
+
+#elif defined(__FUNCSIG__)
+# define TEST_SUITE_FUNCTION __FUNCSIG__
+
+#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || \
+        (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
+# define TEST_SUITE_FUNCTION __FUNCTION__
+
+#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
+# define TEST_SUITE_FUNCTION __FUNC__
+
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
+# define TEST_SUITE_FUNCTION __func__
+
+#elif defined(__cplusplus) && (__cplusplus >= 201103)
+# define TEST_SUITE_FUNCTION __func__
+
+#else
+# define TEST_SUITE_FUNCTION "(unknown)"
+
+#endif
+}
+
+} // detail
+
+//----------------------------------------------------------
+
+/** The type of log for output to the currently running suite.
+*/
+using log_type = detail::log_ostream<char>;
+
+#define BOOST_TEST(expr) \
+    ::test_suite::detail::current()->maybe_fail( \
+        (expr), #expr, __FILE__, __LINE__, TEST_SUITE_FUNCTION)
+
+#define BOOST_ERROR(msg) \
+    ::test_suite::detail::current()->fail( \
+        msg, __FILE__, __LINE__, TEST_SUITE_FUNCTION)
+
+#define BOOST_TEST_PASS() \
+    ::test_suite::detail::current()->pass( \
+        "", __FILE__, __LINE__, TEST_SUITE_FUNCTION)
+
+#define BOOST_TEST_FAIL() \
+    ::test_suite::detail::current()->fail( \
+        "", __FILE__, __LINE__, TEST_SUITE_FUNCTION)
+
+#define BOOST_TEST_NOT(expr) BOOST_TEST(!(expr))
+
+#ifndef BOOST_NO_EXCEPTIONS
+# define BOOST_TEST_THROWS( expr, except ) \
+    try { \
+        expr; \
+        ::test_suite::detail::current()->fail ( \
+            #except, __FILE__, __LINE__, \
+            TEST_SUITE_FUNCTION); \
+    } \
+    catch(except const&) { \
+        ::test_suite::detail::current()->pass( \
+            #except, __FILE__, __LINE__, \
+            TEST_SUITE_FUNCTION); \
+    } \
+    catch(...) { \
+        ::test_suite::detail::current()->fail( \
+            #except, __FILE__, __LINE__, \
+            TEST_SUITE_FUNCTION); \
+    }
+
+#else
+   #define BOOST_TEST_THROWS( expr, except )
+#endif
+
+#define TEST_SUITE(type, name) \
+    namespace { static ::test_suite::detail::instance<type> type##_(name); } 
+
+inline
+int
+run(std::ostream& log,
+    int argc, char const* const* argv)
+{
+    if(argc == 2)
+    {
+        std::string arg(argv[1]);
+        if(arg == "-h" || arg == "--help")
+        {
+            log <<
+                "Usage:\n"
+                "  " << argv[0] << ": { <suite-name>... }" <<
+                std::endl;
+            return EXIT_SUCCESS;
+        }
+    }
+
+    using namespace ::test_suite;
+
+    detail::simple_runner runner(log);
+    detail::suites().sort();
+    if(argc == 1)
+    {
+        for(auto const& e : detail::suites())
+            runner.run(e);
+    }
+    else
+    {
+        std::vector<std::string> args;
+        args.reserve(argc - 1);
+        for(int i = 0; i < argc - 1; ++i)
+            args.push_back(argv[i + 1]);
+        for(auto const& e : detail::suites())
+        {
+            std::string s(e.name);
+            if(std::find_if(
+                args.begin(), args.end(),
+                [&](std::string const& arg)
+                {
+                    if(arg.size() > s.size())
+                        return false;
+                    return s.compare(
+                        s.size() - arg.size(),
+                        arg.size(),
+                        arg.data(),
+                        arg.size()) == 0;
+                }) != args.end())
+            {
+                runner.run(e);
+            }
+        }
+    }
+    return runner.success() ?
+        EXIT_SUCCESS : EXIT_FAILURE;
+}
+
+} // test_suite
+
+#endif
diff --git a/test/value.cpp b/test/value.cpp
index 37f50ae6..eb799393 100644
--- a/test/value.cpp
+++ b/test/value.cpp
@@ -10,11 +10,11 @@
 // Test that header file is self-contained.
 #include <boost/json/value.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <memory>
 #include <vector>
 
 #include "test.hpp"
+#include "test_suite.hpp"
 
 namespace boost {
 namespace json {
@@ -56,7 +56,7 @@ struct value_exchange<value_test_ns::T3>
 
 //----------------------------------------------------------
 
-class value_test : public beast::unit_test::suite
+class value_test
 {
 public:
     //BOOST_STATIC_ASSERT(has_to_json<short>::value);
@@ -96,13 +96,13 @@ public:
         // value()
         {
             value jv;
-            BEAST_EXPECT(*jv.storage() == *dsp);
+            BOOST_TEST(*jv.storage() == *dsp);
         }
 
         // value(storage_ptr)
         {
             value jv(sp);
-            BEAST_EXPECT(*jv.storage() == *sp);
+            BOOST_TEST(*jv.storage() == *sp);
         }
 
         // value(pilfered<value>)
@@ -110,42 +110,42 @@ public:
             {
                 value jv1(object{});
                 value jv2(pilfer(jv1));
-                BEAST_EXPECT(jv2.is_object());
+                BOOST_TEST(jv2.is_object());
             }
             {
                 value jv1(array{});
                 value jv2(pilfer(jv1));
-                BEAST_EXPECT(jv2.is_array());
+                BOOST_TEST(jv2.is_array());
             }
             {
                 value jv1(string{});
                 value jv2(pilfer(jv1));
-                BEAST_EXPECT(jv2.is_string());
+                BOOST_TEST(jv2.is_string());
             }
             {
                 value jv1(std::int64_t{});
                 value jv2(pilfer(jv1));
-                BEAST_EXPECT(jv2.is_int64());
+                BOOST_TEST(jv2.is_int64());
             }
             {
                 value jv1(std::uint64_t{});
                 value jv2(pilfer(jv1));
-                BEAST_EXPECT(jv2.is_uint64());
+                BOOST_TEST(jv2.is_uint64());
             }
             {
                 value jv1(double{});
                 value jv2(pilfer(jv1));
-                BEAST_EXPECT(jv2.is_double());
+                BOOST_TEST(jv2.is_double());
             }
             {
                 value jv1(true);
                 value jv2(pilfer(jv1));
-                BEAST_EXPECT(jv2.is_bool());
+                BOOST_TEST(jv2.is_bool());
             }
             {
                 value jv1(nullptr);
                 value jv2(pilfer(jv1));
-                BEAST_EXPECT(jv2.is_null());
+                BOOST_TEST(jv2.is_null());
             }
         }
 
@@ -154,42 +154,42 @@ public:
             {
                 value jv1(object{});
                 value jv2(jv1);
-                BEAST_EXPECT(jv2.is_object());
+                BOOST_TEST(jv2.is_object());
             }
             {
                 value jv1(array{});
                 value jv2(jv1);
-                BEAST_EXPECT(jv2.is_array());
+                BOOST_TEST(jv2.is_array());
             }
             {
                 value jv1(string{});
                 value jv2(jv1);
-                BEAST_EXPECT(jv2.is_string());
+                BOOST_TEST(jv2.is_string());
             }
             {
                 value jv1(std::int64_t{});
                 value jv2(jv1);
-                BEAST_EXPECT(jv2.is_int64());
+                BOOST_TEST(jv2.is_int64());
             }
             {
                 value jv1(std::uint64_t{});
                 value jv2(jv1);
-                BEAST_EXPECT(jv2.is_uint64());
+                BOOST_TEST(jv2.is_uint64());
             }
             {
                 value jv1(double{});
                 value jv2(jv1);
-                BEAST_EXPECT(jv2.is_double());
+                BOOST_TEST(jv2.is_double());
             }
             {
                 value jv1(true);
                 value jv2(jv1);
-                BEAST_EXPECT(jv2.is_bool());
+                BOOST_TEST(jv2.is_bool());
             }
             {
                 value jv1(nullptr);
                 value jv2(jv1);
-                BEAST_EXPECT(jv2.is_null());
+                BOOST_TEST(jv2.is_null());
             }
         }
 
@@ -198,50 +198,50 @@ public:
             {
                 value jv1(object{});
                 value jv2(jv1, sp);
-                BEAST_EXPECT(jv2.is_object());
-                BEAST_EXPECT(*jv2.storage() == *sp);
+                BOOST_TEST(jv2.is_object());
+                BOOST_TEST(*jv2.storage() == *sp);
             }
             {
                 value jv1(array{});
                 value jv2(jv1, sp);
-                BEAST_EXPECT(jv2.is_array());
-                BEAST_EXPECT(*jv2.storage() == *sp);
+                BOOST_TEST(jv2.is_array());
+                BOOST_TEST(*jv2.storage() == *sp);
             }
             {
                 value jv1(string{});
                 value jv2(jv1, sp);
-                BEAST_EXPECT(jv2.is_string());
-                BEAST_EXPECT(*jv2.storage() == *sp);
+                BOOST_TEST(jv2.is_string());
+                BOOST_TEST(*jv2.storage() == *sp);
             }
             {
                 value jv1(std::int64_t{});
                 value jv2(jv1, sp);
-                BEAST_EXPECT(jv2.is_int64());
-                BEAST_EXPECT(*jv2.storage() == *sp);
+                BOOST_TEST(jv2.is_int64());
+                BOOST_TEST(*jv2.storage() == *sp);
             }
             {
                 value jv1(std::uint64_t{});
                 value jv2(jv1, sp);
-                BEAST_EXPECT(jv2.is_uint64());
-                BEAST_EXPECT(*jv2.storage() == *sp);
+                BOOST_TEST(jv2.is_uint64());
+                BOOST_TEST(*jv2.storage() == *sp);
             }
             {
                 value jv1(double{});
                 value jv2(jv1, sp);
-                BEAST_EXPECT(jv2.is_double());
-                BEAST_EXPECT(*jv2.storage() == *sp);
+                BOOST_TEST(jv2.is_double());
+                BOOST_TEST(*jv2.storage() == *sp);
             }
             {
                 value jv1(true);
                 value jv2(jv1, sp);
-                BEAST_EXPECT(jv2.is_bool());
-                BEAST_EXPECT(*jv2.storage() == *sp);
+                BOOST_TEST(jv2.is_bool());
+                BOOST_TEST(*jv2.storage() == *sp);
             }
             {
                 value jv1(nullptr);
                 value jv2(jv1, sp);
-                BEAST_EXPECT(jv2.is_null());
-                BEAST_EXPECT(*jv2.storage() == *sp);
+                BOOST_TEST(jv2.is_null());
+                BOOST_TEST(*jv2.storage() == *sp);
             }
         }
 
@@ -250,42 +250,42 @@ public:
             {
                 value jv1(object{});
                 value jv2(std::move(jv1));
-                BEAST_EXPECT(jv2.is_object());
+                BOOST_TEST(jv2.is_object());
             }
             {
                 value jv1(array{});
                 value jv2(std::move(jv1));
-                BEAST_EXPECT(jv2.is_array());
+                BOOST_TEST(jv2.is_array());
             }
             {
                 value jv1(string{});
                 value jv2(std::move(jv1));
-                BEAST_EXPECT(jv2.is_string());
+                BOOST_TEST(jv2.is_string());
             }
             {
                 value jv1(std::int64_t{});
                 value jv2(std::move(jv1));
-                BEAST_EXPECT(jv2.is_int64());
+                BOOST_TEST(jv2.is_int64());
             }
             {
                 value jv1(std::uint64_t{});
                 value jv2(std::move(jv1));
-                BEAST_EXPECT(jv2.is_uint64());
+                BOOST_TEST(jv2.is_uint64());
             }
             {
                 value jv1(double{});
                 value jv2(std::move(jv1));
-                BEAST_EXPECT(jv2.is_double());
+                BOOST_TEST(jv2.is_double());
             }
             {
                 value jv1(true);
                 value jv2(std::move(jv1));
-                BEAST_EXPECT(jv2.is_bool());
+                BOOST_TEST(jv2.is_bool());
             }
             {
                 value jv1(nullptr);
                 value jv2(std::move(jv1));
-                BEAST_EXPECT(jv2.is_null());
+                BOOST_TEST(jv2.is_null());
             }
         }
 
@@ -294,42 +294,42 @@ public:
             {
                 value jv1(object{});
                 value jv2(std::move(jv1), sp);
-                BEAST_EXPECT(jv2.is_object());
+                BOOST_TEST(jv2.is_object());
             }
             {
                 value jv1(array{});
                 value jv2(std::move(jv1), sp);
-                BEAST_EXPECT(jv2.is_array());
+                BOOST_TEST(jv2.is_array());
             }
             {
                 value jv1(string{});
                 value jv2(std::move(jv1), sp);
-                BEAST_EXPECT(jv2.is_string());
+                BOOST_TEST(jv2.is_string());
             }
             {
                 value jv1(std::int64_t{});
                 value jv2(std::move(jv1), sp);
-                BEAST_EXPECT(jv2.is_int64());
+                BOOST_TEST(jv2.is_int64());
             }
             {
                 value jv1(std::uint64_t{});
                 value jv2(std::move(jv1), sp);
-                BEAST_EXPECT(jv2.is_uint64());
+                BOOST_TEST(jv2.is_uint64());
             }
             {
                 value jv1(double{});
                 value jv2(std::move(jv1), sp);
-                BEAST_EXPECT(jv2.is_double());
+                BOOST_TEST(jv2.is_double());
             }
             {
                 value jv1(true);
                 value jv2(std::move(jv1), sp);
-                BEAST_EXPECT(jv2.is_bool());
+                BOOST_TEST(jv2.is_bool());
             }
             {
                 value jv1(nullptr);
                 value jv2(std::move(jv1), sp);
-                BEAST_EXPECT(jv2.is_null());
+                BOOST_TEST(jv2.is_null());
             }
         }
 
@@ -338,42 +338,42 @@ public:
             {
                 value jv;
                 jv = value(object{});
-                BEAST_EXPECT(jv.is_object());
+                BOOST_TEST(jv.is_object());
             }
             {
                 value jv;
                 jv = value(array{});
-                BEAST_EXPECT(jv.is_array());
+                BOOST_TEST(jv.is_array());
             }
             {
                 value jv;
                 jv = value(string{});
-                BEAST_EXPECT(jv.is_string());
+                BOOST_TEST(jv.is_string());
             }
             {
                 value jv;
                 jv = value(std::int64_t{});
-                BEAST_EXPECT(jv.is_int64());
+                BOOST_TEST(jv.is_int64());
             }
             {
                 value jv;
                 jv = value(std::uint64_t{});
-                BEAST_EXPECT(jv.is_uint64());
+                BOOST_TEST(jv.is_uint64());
             }
             {
                 value jv;
                 jv = value(double{});
-                BEAST_EXPECT(jv.is_double());
+                BOOST_TEST(jv.is_double());
             }
             {
                 value jv;
                 jv = value(true);
-                BEAST_EXPECT(jv.is_bool());
+                BOOST_TEST(jv.is_bool());
             }
             {
                 value jv;
                 jv = value(nullptr);
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(jv.is_null());
             }
 
             fail_loop([&](storage_ptr const sp)
@@ -389,7 +389,7 @@ public:
                     true,
                     nullptr
                     });
-                BEAST_EXPECT(jv.as_array().size() == 8);
+                BOOST_TEST(jv.as_array().size() == 8);
             });
 
             fail_loop([&](storage_ptr const sp)
@@ -405,14 +405,14 @@ public:
                     { "gg", true },
                     { "hh", nullptr },
                     });
-                BEAST_EXPECT(jv.as_object().size() == 8);
+                BOOST_TEST(jv.as_object().size() == 8);
             });
 
             fail_loop([&](storage_ptr const sp)
             {
                 value jv(sp);
                 jv = value(str_);
-                BEAST_EXPECT(jv.as_string() == str_);
+                BOOST_TEST(jv.as_string() == str_);
             });
         }
 
@@ -422,49 +422,49 @@ public:
                 value jv1(object{});
                 value jv2;
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.is_object());
+                BOOST_TEST(jv2.is_object());
             }
             {
                 value jv1(array{});
                 value jv2;
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.is_array());
+                BOOST_TEST(jv2.is_array());
             }
             {
                 value jv1(string{});
                 value jv2;
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.is_string());
+                BOOST_TEST(jv2.is_string());
             }
             {
                 value jv1(std::int64_t{});
                 value jv2;
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.is_int64());
+                BOOST_TEST(jv2.is_int64());
             }
             {
                 value jv1(std::uint64_t{});
                 value jv2;
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.is_uint64());
+                BOOST_TEST(jv2.is_uint64());
             }
             {
                 value jv1(double{});
                 value jv2;
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.is_double());
+                BOOST_TEST(jv2.is_double());
             }
             {
                 value jv1(true);
                 value jv2;
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.is_bool());
+                BOOST_TEST(jv2.is_bool());
             }
             {
                 value jv1(nullptr);
                 value jv2;
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.is_null());
+                BOOST_TEST(jv2.is_null());
             }
 
             fail_loop([&](storage_ptr const sp)
@@ -472,7 +472,7 @@ public:
                 value jv1({1, 2, 3, 4, 5});
                 value jv2(sp);
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.as_array().size() == 5);
+                BOOST_TEST(jv2.as_array().size() == 5);
             });
 
             fail_loop([&](storage_ptr const sp)
@@ -481,7 +481,7 @@ public:
                     {"a",1},{"b",2},{"c",3}});
                 value jv2(sp);
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.as_object().size() == 3);
+                BOOST_TEST(jv2.as_object().size() == 3);
             });
 
             fail_loop([&](storage_ptr const sp)
@@ -489,7 +489,7 @@ public:
                 value jv1(str_);
                 value jv2(sp);
                 jv2 = jv1;
-                BEAST_EXPECT(jv2.as_string() == str_);
+                BOOST_TEST(jv2.as_string() == str_);
             });
 
             // self-assign
@@ -512,28 +512,28 @@ public:
         {
             {
                 auto jv = value(object());
-                BEAST_EXPECT(jv.is_object());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_object());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 auto jv = value(object(sp));
-                BEAST_EXPECT(jv.is_object());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_object());
+                BOOST_TEST(*jv.storage() == *sp);
             }
             {
                 auto jv = value(object(), sp);
-                BEAST_EXPECT(jv.is_object());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_object());
+                BOOST_TEST(*jv.storage() == *sp);
             }
             {
                 auto jv = value(object_kind);
-                BEAST_EXPECT(jv.is_object());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_object());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 auto jv = value(object_kind, sp);
-                BEAST_EXPECT(jv.is_object());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_object());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -543,28 +543,28 @@ public:
         {
             {
                 auto jv = value(array());
-                BEAST_EXPECT(jv.is_array());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_array());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 auto jv = value(array(sp));
-                BEAST_EXPECT(jv.is_array());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_array());
+                BOOST_TEST(*jv.storage() == *sp);
             }
             {
                 auto jv = value(array(), sp);
-                BEAST_EXPECT(jv.is_array());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_array());
+                BOOST_TEST(*jv.storage() == *sp);
             }
             {
                 auto jv = value(array_kind);
-                BEAST_EXPECT(jv.is_array());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_array());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 auto jv = value(array_kind, sp);
-                BEAST_EXPECT(jv.is_array());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_array());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -573,18 +573,18 @@ public:
         {
             {
                 auto jv = value(string());
-                BEAST_EXPECT(jv.is_string());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_string());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 auto jv = value(string(sp));
-                BEAST_EXPECT(jv.is_string());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_string());
+                BOOST_TEST(*jv.storage() == *sp);
             }
             {
                 auto jv = value(string(), sp);
-                BEAST_EXPECT(jv.is_string());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_string());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -593,13 +593,13 @@ public:
         {
             {
                 auto jv = value(std::int64_t{-65536});
-                BEAST_EXPECT(jv.is_int64());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_int64());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 auto jv = value(std::int64_t{-65536}, sp);
-                BEAST_EXPECT(jv.is_int64());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_int64());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -608,13 +608,13 @@ public:
         {
             {
                 auto jv = value(std::uint64_t{65536});
-                BEAST_EXPECT(jv.is_uint64());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_uint64());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 auto jv = value(std::uint64_t{65536}, sp);
-                BEAST_EXPECT(jv.is_uint64());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_uint64());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -623,13 +623,13 @@ public:
         {
             {
                 auto jv = value(double{3.141});
-                BEAST_EXPECT(jv.is_double());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_double());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 auto jv = value(double{3.141}, sp);
-                BEAST_EXPECT(jv.is_double());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_double());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -638,13 +638,13 @@ public:
         {
             {
                 auto jv = value(true);
-                BEAST_EXPECT(jv.is_bool());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_bool());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 auto jv = value(true, sp);
-                BEAST_EXPECT(jv.is_bool());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_bool());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -653,13 +653,13 @@ public:
         {
             {
                 auto jv = value(nullptr);
-                BEAST_EXPECT(jv.is_null());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_null());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 auto jv = value(nullptr, sp);
-                BEAST_EXPECT(jv.is_null());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_null());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -668,23 +668,23 @@ public:
         {
             {
                 value jv({1, 2, 3});
-                BEAST_EXPECT(jv.is_array());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_array());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 value jv({1, 2, 3}, sp);
-                BEAST_EXPECT(jv.is_array());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_array());
+                BOOST_TEST(*jv.storage() == *sp);
             }
             {
                 value jv({{"a",1},{"b",2},{"c",3}});
-                BEAST_EXPECT(jv.is_object());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_object());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 value jv({{"a",1},{"b",2},{"c",3}}, sp);
-                BEAST_EXPECT(jv.is_object());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_object());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -693,14 +693,14 @@ public:
             {
                 value jv;
                 jv = object();
-                BEAST_EXPECT(*jv.storage() == *dsp);
-                BEAST_EXPECT(jv.is_object());
+                BOOST_TEST(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_object());
             }
             {
                 value jv(sp);
                 jv = object();
-                BEAST_EXPECT(jv.is_object());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_object());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -709,14 +709,14 @@ public:
             {
                 value jv;
                 jv = array();
-                BEAST_EXPECT(jv.is_array());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_array());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 value jv(sp);
                 jv = array();
-                BEAST_EXPECT(jv.is_array());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_array());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -725,14 +725,14 @@ public:
             {
                 value jv;
                 jv = string();
-                BEAST_EXPECT(jv.is_string());
-                BEAST_EXPECT(*jv.storage() == *dsp);
+                BOOST_TEST(jv.is_string());
+                BOOST_TEST(*jv.storage() == *dsp);
             }
             {
                 value jv(sp);
                 jv = string();
-                BEAST_EXPECT(jv.is_string());
-                BEAST_EXPECT(*jv.storage() == *sp);
+                BOOST_TEST(jv.is_string());
+                BOOST_TEST(*jv.storage() == *sp);
             }
         }
 
@@ -740,21 +740,21 @@ public:
         {
             value jv;
             jv = std::int64_t{-65536};
-            BEAST_EXPECT(jv.is_int64());
+            BOOST_TEST(jv.is_int64());
         }
 
         // operator=(uint64)
         {
             value jv;
             jv = std::uint64_t{65536};
-            BEAST_EXPECT(jv.is_uint64());
+            BOOST_TEST(jv.is_uint64());
         }
 
         // operator=(double)
         {
             value jv;
             jv = double{3.141};
-            BEAST_EXPECT(jv.is_double());
+            BOOST_TEST(jv.is_double());
         }
     }
 
@@ -763,52 +763,52 @@ public:
     {
         // emplace
         {
-            BEAST_EXPECT(value().emplace_object().empty());
-            BEAST_EXPECT(value().emplace_array().empty());
-            BEAST_EXPECT(value().emplace_string().empty());
-            BEAST_EXPECT(value().emplace_int64() == 0);
-            BEAST_EXPECT(value().emplace_uint64() == 0);
-            BEAST_EXPECT(value().emplace_double() == 0);
-            BEAST_EXPECT(value().emplace_bool() = true);
+            BOOST_TEST(value().emplace_object().empty());
+            BOOST_TEST(value().emplace_array().empty());
+            BOOST_TEST(value().emplace_string().empty());
+            BOOST_TEST(value().emplace_int64() == 0);
+            BOOST_TEST(value().emplace_uint64() == 0);
+            BOOST_TEST(value().emplace_double() == 0);
+            BOOST_TEST(value().emplace_bool() = true);
             {
                 value jv(object_kind);
                 jv.emplace_null();
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(jv.is_null());
             }
             {
                 value jv(array_kind);
                 jv.emplace_null();
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(jv.is_null());
             }
             {
                 value jv(string_kind);
                 jv.emplace_null();
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(jv.is_null());
             }
             {
                 value jv(-1);
                 jv.emplace_null();
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(jv.is_null());
             }
             {
                 value jv(1U);
                 jv.emplace_null();
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(jv.is_null());
             }
             {
                 value jv(1.0);
                 jv.emplace_null();
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(jv.is_null());
             }
             {
                 value jv(false);
                 jv.emplace_null();
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(jv.is_null());
             }
             {
                 value jv;
                 jv.emplace_null();
-                BEAST_EXPECT(jv.is_null());
+                BOOST_TEST(jv.is_null());
             }
         }
 
@@ -817,11 +817,11 @@ public:
             {
                 value jv1(1);
                 value jv2("abc");
-                BEAST_EXPECT(
+                BOOST_TEST(
                     *jv1.storage() == *jv2.storage());
                 swap(jv1, jv2);
-                BEAST_EXPECT(jv1.as_string() == "abc");
-                BEAST_EXPECT(jv2.as_int64() == 1);
+                BOOST_TEST(jv1.as_string() == "abc");
+                BOOST_TEST(jv2.as_int64() == 1);
             }
 
             // different storage
@@ -829,11 +829,11 @@ public:
             {
                 value jv1(1);
                 value jv2("abc", sp);
-                BEAST_EXPECT(
+                BOOST_TEST(
                     *jv1.storage() != *jv2.storage());
                 swap(jv1, jv2);
-                BEAST_EXPECT(jv1.as_string() == "abc");
-                BEAST_EXPECT(jv2.as_int64() == 1);
+                BOOST_TEST(jv1.as_string() == "abc");
+                BOOST_TEST(jv2.as_int64() == 1);
             });
         }
     }
@@ -846,56 +846,56 @@ public:
     {
         // string{}
         {
-            BEAST_EXPECT(value("abc").is_string());
-            BEAST_EXPECT(value(std::string()).is_string());
-            BEAST_EXPECT(value(string_view()).is_string());
+            BOOST_TEST(value("abc").is_string());
+            BOOST_TEST(value(std::string()).is_string());
+            BOOST_TEST(value(string_view()).is_string());
 
-            { value jv; BEAST_EXPECT((jv = "abc").is_string()); }
-            { value jv; BEAST_EXPECT((jv = std::string()).is_string()); }
-            { value jv; BEAST_EXPECT((jv = string_view()).is_string()); }
+            { value jv; BOOST_TEST((jv = "abc").is_string()); }
+            { value jv; BOOST_TEST((jv = std::string()).is_string()); }
+            { value jv; BOOST_TEST((jv = string_view()).is_string()); }
         }
 
         // numbers
         {
-            BEAST_EXPECT(value(tt<int>{}).is_int64());
-            BEAST_EXPECT(value(tt<short int>{}).is_int64());
-            BEAST_EXPECT(value(tt<long int>{}).is_int64());
-            BEAST_EXPECT(value(tt<long long int>{}).is_int64());
-            BEAST_EXPECT(value(tt<unsigned int>{}).is_uint64());
-            BEAST_EXPECT(value(tt<unsigned short int>{}).is_uint64());
-            BEAST_EXPECT(value(tt<unsigned long int>{}).is_uint64());
-            BEAST_EXPECT(value(tt<unsigned long long int>{}).is_uint64());
-            BEAST_EXPECT(value(tt<float>{}).is_double());
-            BEAST_EXPECT(value(tt<double>{}).is_double());
-            BEAST_EXPECT(value(tt<long double>{}).is_double());
+            BOOST_TEST(value(tt<int>{}).is_int64());
+            BOOST_TEST(value(tt<short int>{}).is_int64());
+            BOOST_TEST(value(tt<long int>{}).is_int64());
+            BOOST_TEST(value(tt<long long int>{}).is_int64());
+            BOOST_TEST(value(tt<unsigned int>{}).is_uint64());
+            BOOST_TEST(value(tt<unsigned short int>{}).is_uint64());
+            BOOST_TEST(value(tt<unsigned long int>{}).is_uint64());
+            BOOST_TEST(value(tt<unsigned long long int>{}).is_uint64());
+            BOOST_TEST(value(tt<float>{}).is_double());
+            BOOST_TEST(value(tt<double>{}).is_double());
+            BOOST_TEST(value(tt<long double>{}).is_double());
 
-            { value jv; BEAST_EXPECT((jv = tt<int>{}).is_int64()); }
-            { value jv; BEAST_EXPECT((jv = tt<short int>{}).is_int64()); }
-            { value jv; BEAST_EXPECT((jv = tt<long int>{}).is_int64()); }
-            { value jv; BEAST_EXPECT((jv = tt<long long int>{}).is_int64()); }
-            { value jv; BEAST_EXPECT((jv = tt<unsigned int>{}).is_uint64()); }
-            { value jv; BEAST_EXPECT((jv = tt<unsigned short int>{}).is_uint64()); }
-            { value jv; BEAST_EXPECT((jv = tt<unsigned long int>{}).is_uint64()); }
-            { value jv; BEAST_EXPECT((jv = tt<unsigned long long int>{}).is_uint64()); }
-            { value jv; BEAST_EXPECT((jv = tt<float>{}).is_double()); }
-            { value jv; BEAST_EXPECT((jv = tt<double>{}).is_double()); }
-            { value jv; BEAST_EXPECT((jv = tt<long double>{}).is_double()); }
+            { value jv; BOOST_TEST((jv = tt<int>{}).is_int64()); }
+            { value jv; BOOST_TEST((jv = tt<short int>{}).is_int64()); }
+            { value jv; BOOST_TEST((jv = tt<long int>{}).is_int64()); }
+            { value jv; BOOST_TEST((jv = tt<long long int>{}).is_int64()); }
+            { value jv; BOOST_TEST((jv = tt<unsigned int>{}).is_uint64()); }
+            { value jv; BOOST_TEST((jv = tt<unsigned short int>{}).is_uint64()); }
+            { value jv; BOOST_TEST((jv = tt<unsigned long int>{}).is_uint64()); }
+            { value jv; BOOST_TEST((jv = tt<unsigned long long int>{}).is_uint64()); }
+            { value jv; BOOST_TEST((jv = tt<float>{}).is_double()); }
+            { value jv; BOOST_TEST((jv = tt<double>{}).is_double()); }
+            { value jv; BOOST_TEST((jv = tt<long double>{}).is_double()); }
         }
 
         // bool
         {
-            BEAST_EXPECT(value(true).is_bool());
-            BEAST_EXPECT(value(false).is_bool());
+            BOOST_TEST(value(true).is_bool());
+            BOOST_TEST(value(false).is_bool());
 
-            { value jv; BEAST_EXPECT((jv = true).is_bool()); }
-            { value jv; BEAST_EXPECT((jv = false).is_bool()); }
+            { value jv; BOOST_TEST((jv = true).is_bool()); }
+            { value jv; BOOST_TEST((jv = false).is_bool()); }
         }
 
         // nullptr
         {
-            BEAST_EXPECT(value(nullptr).is_null());
+            BOOST_TEST(value(nullptr).is_null());
 
-            { value jv("x"); BEAST_EXPECT((jv = nullptr).is_null()); }
+            { value jv("x"); BOOST_TEST((jv = nullptr).is_null()); }
         }
 
         // VFALCO TODO store()
@@ -915,146 +915,146 @@ public:
 
         // kind()
         {
-            BEAST_EXPECT(obj.kind() == kind::object);
-            BEAST_EXPECT(arr.kind() == kind::array);
-            BEAST_EXPECT(str.kind() == kind::string);
-            BEAST_EXPECT(i64.kind() == kind::int64);
-            BEAST_EXPECT(u64.kind() == kind::uint64);
-            BEAST_EXPECT(dub.kind() == kind::double_);
-            BEAST_EXPECT(bln.kind() == kind::bool_);
-            BEAST_EXPECT(nul.kind() == kind::null);
+            BOOST_TEST(obj.kind() == kind::object);
+            BOOST_TEST(arr.kind() == kind::array);
+            BOOST_TEST(str.kind() == kind::string);
+            BOOST_TEST(i64.kind() == kind::int64);
+            BOOST_TEST(u64.kind() == kind::uint64);
+            BOOST_TEST(dub.kind() == kind::double_);
+            BOOST_TEST(bln.kind() == kind::bool_);
+            BOOST_TEST(nul.kind() == kind::null);
         }
 
         // is_object()
         {
-            BEAST_EXPECT(  obj.is_object());
-            BEAST_EXPECT(! arr.is_object());
-            BEAST_EXPECT(! str.is_object());
-            BEAST_EXPECT(! i64.is_object());
-            BEAST_EXPECT(! u64.is_object());
-            BEAST_EXPECT(! dub.is_object());
-            BEAST_EXPECT(! bln.is_object());
-            BEAST_EXPECT(! nul.is_object());
+            BOOST_TEST(  obj.is_object());
+            BOOST_TEST(! arr.is_object());
+            BOOST_TEST(! str.is_object());
+            BOOST_TEST(! i64.is_object());
+            BOOST_TEST(! u64.is_object());
+            BOOST_TEST(! dub.is_object());
+            BOOST_TEST(! bln.is_object());
+            BOOST_TEST(! nul.is_object());
         }
 
         // is_array()
         {
-            BEAST_EXPECT(! obj.is_array());
-            BEAST_EXPECT(  arr.is_array());
-            BEAST_EXPECT(! str.is_array());
-            BEAST_EXPECT(! i64.is_array());
-            BEAST_EXPECT(! u64.is_array());
-            BEAST_EXPECT(! dub.is_array());
-            BEAST_EXPECT(! bln.is_array());
-            BEAST_EXPECT(! nul.is_array());
+            BOOST_TEST(! obj.is_array());
+            BOOST_TEST(  arr.is_array());
+            BOOST_TEST(! str.is_array());
+            BOOST_TEST(! i64.is_array());
+            BOOST_TEST(! u64.is_array());
+            BOOST_TEST(! dub.is_array());
+            BOOST_TEST(! bln.is_array());
+            BOOST_TEST(! nul.is_array());
         }
 
         // is_string()
         {
-            BEAST_EXPECT(! obj.is_string());
-            BEAST_EXPECT(! arr.is_string());
-            BEAST_EXPECT(  str.is_string());
-            BEAST_EXPECT(! i64.is_string());
-            BEAST_EXPECT(! u64.is_string());
-            BEAST_EXPECT(! dub.is_string());
-            BEAST_EXPECT(! bln.is_string());
-            BEAST_EXPECT(! nul.is_string());
+            BOOST_TEST(! obj.is_string());
+            BOOST_TEST(! arr.is_string());
+            BOOST_TEST(  str.is_string());
+            BOOST_TEST(! i64.is_string());
+            BOOST_TEST(! u64.is_string());
+            BOOST_TEST(! dub.is_string());
+            BOOST_TEST(! bln.is_string());
+            BOOST_TEST(! nul.is_string());
         }
 
         // is_int64()
         {
-            BEAST_EXPECT(! obj.is_int64());
-            BEAST_EXPECT(! arr.is_int64());
-            BEAST_EXPECT(! str.is_int64());
-            BEAST_EXPECT(  i64.is_int64());
-            BEAST_EXPECT(! u64.is_int64());
-            BEAST_EXPECT(! dub.is_int64());
-            BEAST_EXPECT(! bln.is_int64());
-            BEAST_EXPECT(! nul.is_int64());
+            BOOST_TEST(! obj.is_int64());
+            BOOST_TEST(! arr.is_int64());
+            BOOST_TEST(! str.is_int64());
+            BOOST_TEST(  i64.is_int64());
+            BOOST_TEST(! u64.is_int64());
+            BOOST_TEST(! dub.is_int64());
+            BOOST_TEST(! bln.is_int64());
+            BOOST_TEST(! nul.is_int64());
         }
 
         // is_uint64()
         {
-            BEAST_EXPECT(! obj.is_uint64());
-            BEAST_EXPECT(! arr.is_uint64());
-            BEAST_EXPECT(! str.is_uint64());
-            BEAST_EXPECT(! i64.is_uint64());
-            BEAST_EXPECT(  u64.is_uint64());
-            BEAST_EXPECT(! dub.is_uint64());
-            BEAST_EXPECT(! bln.is_uint64());
-            BEAST_EXPECT(! nul.is_uint64());
+            BOOST_TEST(! obj.is_uint64());
+            BOOST_TEST(! arr.is_uint64());
+            BOOST_TEST(! str.is_uint64());
+            BOOST_TEST(! i64.is_uint64());
+            BOOST_TEST(  u64.is_uint64());
+            BOOST_TEST(! dub.is_uint64());
+            BOOST_TEST(! bln.is_uint64());
+            BOOST_TEST(! nul.is_uint64());
         }
 
         // is_double()
         {
-            BEAST_EXPECT(! obj.is_double());
-            BEAST_EXPECT(! arr.is_double());
-            BEAST_EXPECT(! str.is_double());
-            BEAST_EXPECT(! i64.is_double());
-            BEAST_EXPECT(! u64.is_double());
-            BEAST_EXPECT(  dub.is_double());
-            BEAST_EXPECT(! bln.is_double());
-            BEAST_EXPECT(! nul.is_double());
+            BOOST_TEST(! obj.is_double());
+            BOOST_TEST(! arr.is_double());
+            BOOST_TEST(! str.is_double());
+            BOOST_TEST(! i64.is_double());
+            BOOST_TEST(! u64.is_double());
+            BOOST_TEST(  dub.is_double());
+            BOOST_TEST(! bln.is_double());
+            BOOST_TEST(! nul.is_double());
         }
 
         // is_bool()
         {
-            BEAST_EXPECT(! obj.is_bool());
-            BEAST_EXPECT(! arr.is_bool());
-            BEAST_EXPECT(! str.is_bool());
-            BEAST_EXPECT(! i64.is_bool());
-            BEAST_EXPECT(! u64.is_bool());
-            BEAST_EXPECT(! dub.is_bool());
-            BEAST_EXPECT(  bln.is_bool());
-            BEAST_EXPECT(! nul.is_bool());
+            BOOST_TEST(! obj.is_bool());
+            BOOST_TEST(! arr.is_bool());
+            BOOST_TEST(! str.is_bool());
+            BOOST_TEST(! i64.is_bool());
+            BOOST_TEST(! u64.is_bool());
+            BOOST_TEST(! dub.is_bool());
+            BOOST_TEST(  bln.is_bool());
+            BOOST_TEST(! nul.is_bool());
         }
 
         // is_null()
         {
-            BEAST_EXPECT(! obj.is_null());
-            BEAST_EXPECT(! arr.is_null());
-            BEAST_EXPECT(! str.is_null());
-            BEAST_EXPECT(! i64.is_null());
-            BEAST_EXPECT(! u64.is_null());
-            BEAST_EXPECT(! dub.is_null());
-            BEAST_EXPECT(! bln.is_null());
-            BEAST_EXPECT(  nul.is_null());
+            BOOST_TEST(! obj.is_null());
+            BOOST_TEST(! arr.is_null());
+            BOOST_TEST(! str.is_null());
+            BOOST_TEST(! i64.is_null());
+            BOOST_TEST(! u64.is_null());
+            BOOST_TEST(! dub.is_null());
+            BOOST_TEST(! bln.is_null());
+            BOOST_TEST(  nul.is_null());
         }
 
         // is_number()
         {
-            BEAST_EXPECT(! obj.is_number());
-            BEAST_EXPECT(! arr.is_number());
-            BEAST_EXPECT(! str.is_number());
-            BEAST_EXPECT(  i64.is_number());
-            BEAST_EXPECT(  u64.is_number());
-            BEAST_EXPECT(  dub.is_number());
-            BEAST_EXPECT(! bln.is_number());
-            BEAST_EXPECT(! nul.is_number());
+            BOOST_TEST(! obj.is_number());
+            BOOST_TEST(! arr.is_number());
+            BOOST_TEST(! str.is_number());
+            BOOST_TEST(  i64.is_number());
+            BOOST_TEST(  u64.is_number());
+            BOOST_TEST(  dub.is_number());
+            BOOST_TEST(! bln.is_number());
+            BOOST_TEST(! nul.is_number());
         }
 
         // is_primitive()
         {
-            BEAST_EXPECT(! obj.is_primitive());
-            BEAST_EXPECT(! arr.is_primitive());
-            BEAST_EXPECT(  str.is_primitive());
-            BEAST_EXPECT(  i64.is_primitive());
-            BEAST_EXPECT(  u64.is_primitive());
-            BEAST_EXPECT(  dub.is_primitive());
-            BEAST_EXPECT(  bln.is_primitive());
-            BEAST_EXPECT(  nul.is_primitive());
+            BOOST_TEST(! obj.is_primitive());
+            BOOST_TEST(! arr.is_primitive());
+            BOOST_TEST(  str.is_primitive());
+            BOOST_TEST(  i64.is_primitive());
+            BOOST_TEST(  u64.is_primitive());
+            BOOST_TEST(  dub.is_primitive());
+            BOOST_TEST(  bln.is_primitive());
+            BOOST_TEST(  nul.is_primitive());
         }
 
         // is_structured()
         {
-            BEAST_EXPECT(  obj.is_structured());
-            BEAST_EXPECT(  arr.is_structured());
-            BEAST_EXPECT(! str.is_structured());
-            BEAST_EXPECT(! i64.is_structured());
-            BEAST_EXPECT(! u64.is_structured());
-            BEAST_EXPECT(! dub.is_structured());
-            BEAST_EXPECT(! bln.is_structured());
-            BEAST_EXPECT(! nul.is_structured());
+            BOOST_TEST(  obj.is_structured());
+            BOOST_TEST(  arr.is_structured());
+            BOOST_TEST(! str.is_structured());
+            BOOST_TEST(! i64.is_structured());
+            BOOST_TEST(! u64.is_structured());
+            BOOST_TEST(! dub.is_structured());
+            BOOST_TEST(! bln.is_structured());
+            BOOST_TEST(! nul.is_structured());
         }
     }
 
@@ -1081,14 +1081,14 @@ public:
 
         // storage()
         {
-            BEAST_EXPECT(*obj.storage() == *sp);
-            BEAST_EXPECT(*arr.storage() == *sp);
-            BEAST_EXPECT(*str.storage() == *sp);
-            BEAST_EXPECT(*i64.storage() == *sp);
-            BEAST_EXPECT(*u64.storage() == *sp);
-            BEAST_EXPECT(*dub.storage() == *sp);
-            BEAST_EXPECT(*bln.storage() == *sp);
-            BEAST_EXPECT(*nul.storage() == *sp);
+            BOOST_TEST(*obj.storage() == *sp);
+            BOOST_TEST(*arr.storage() == *sp);
+            BOOST_TEST(*str.storage() == *sp);
+            BOOST_TEST(*i64.storage() == *sp);
+            BOOST_TEST(*u64.storage() == *sp);
+            BOOST_TEST(*dub.storage() == *sp);
+            BOOST_TEST(*bln.storage() == *sp);
+            BOOST_TEST(*nul.storage() == *sp);
         }
     }
 
@@ -1115,170 +1115,170 @@ public:
 
         // if_object()
         {
-            BEAST_EXPECT(obj.if_object() != nullptr);
-            BEAST_EXPECT(arr.if_object() == nullptr);
-            BEAST_EXPECT(str.if_object() == nullptr);
-            BEAST_EXPECT(i64.if_object() == nullptr);
-            BEAST_EXPECT(u64.if_object() == nullptr);
-            BEAST_EXPECT(dub.if_object() == nullptr);
-            BEAST_EXPECT(bln.if_object() == nullptr);
-            BEAST_EXPECT(nul.if_object() == nullptr);
+            BOOST_TEST(obj.if_object() != nullptr);
+            BOOST_TEST(arr.if_object() == nullptr);
+            BOOST_TEST(str.if_object() == nullptr);
+            BOOST_TEST(i64.if_object() == nullptr);
+            BOOST_TEST(u64.if_object() == nullptr);
+            BOOST_TEST(dub.if_object() == nullptr);
+            BOOST_TEST(bln.if_object() == nullptr);
+            BOOST_TEST(nul.if_object() == nullptr);
         }
 
         // if_object() const
         {
-            BEAST_EXPECT(cobj.if_object() != nullptr);
-            BEAST_EXPECT(carr.if_object() == nullptr);
-            BEAST_EXPECT(cstr.if_object() == nullptr);
-            BEAST_EXPECT(ci64.if_object() == nullptr);
-            BEAST_EXPECT(cu64.if_object() == nullptr);
-            BEAST_EXPECT(cdub.if_object() == nullptr);
-            BEAST_EXPECT(cbln.if_object() == nullptr);
-            BEAST_EXPECT(cnul.if_object() == nullptr);
+            BOOST_TEST(cobj.if_object() != nullptr);
+            BOOST_TEST(carr.if_object() == nullptr);
+            BOOST_TEST(cstr.if_object() == nullptr);
+            BOOST_TEST(ci64.if_object() == nullptr);
+            BOOST_TEST(cu64.if_object() == nullptr);
+            BOOST_TEST(cdub.if_object() == nullptr);
+            BOOST_TEST(cbln.if_object() == nullptr);
+            BOOST_TEST(cnul.if_object() == nullptr);
         }
 
         // if_array()
         {
-            BEAST_EXPECT(obj.if_array() == nullptr);
-            BEAST_EXPECT(arr.if_array() != nullptr);
-            BEAST_EXPECT(str.if_array() == nullptr);
-            BEAST_EXPECT(i64.if_array() == nullptr);
-            BEAST_EXPECT(u64.if_array() == nullptr);
-            BEAST_EXPECT(dub.if_array() == nullptr);
-            BEAST_EXPECT(bln.if_array() == nullptr);
-            BEAST_EXPECT(nul.if_array() == nullptr);
+            BOOST_TEST(obj.if_array() == nullptr);
+            BOOST_TEST(arr.if_array() != nullptr);
+            BOOST_TEST(str.if_array() == nullptr);
+            BOOST_TEST(i64.if_array() == nullptr);
+            BOOST_TEST(u64.if_array() == nullptr);
+            BOOST_TEST(dub.if_array() == nullptr);
+            BOOST_TEST(bln.if_array() == nullptr);
+            BOOST_TEST(nul.if_array() == nullptr);
         }
 
         // if_array() const
         {
-            BEAST_EXPECT(cobj.if_array() == nullptr);
-            BEAST_EXPECT(carr.if_array() != nullptr);
-            BEAST_EXPECT(cstr.if_array() == nullptr);
-            BEAST_EXPECT(ci64.if_array() == nullptr);
-            BEAST_EXPECT(cu64.if_array() == nullptr);
-            BEAST_EXPECT(cdub.if_array() == nullptr);
-            BEAST_EXPECT(cbln.if_array() == nullptr);
-            BEAST_EXPECT(cnul.if_array() == nullptr);
+            BOOST_TEST(cobj.if_array() == nullptr);
+            BOOST_TEST(carr.if_array() != nullptr);
+            BOOST_TEST(cstr.if_array() == nullptr);
+            BOOST_TEST(ci64.if_array() == nullptr);
+            BOOST_TEST(cu64.if_array() == nullptr);
+            BOOST_TEST(cdub.if_array() == nullptr);
+            BOOST_TEST(cbln.if_array() == nullptr);
+            BOOST_TEST(cnul.if_array() == nullptr);
         }
 
         // if_string()
         {
-            BEAST_EXPECT(obj.if_string() == nullptr);
-            BEAST_EXPECT(arr.if_string() == nullptr);
-            BEAST_EXPECT(str.if_string() != nullptr);
-            BEAST_EXPECT(i64.if_string() == nullptr);
-            BEAST_EXPECT(u64.if_string() == nullptr);
-            BEAST_EXPECT(dub.if_string() == nullptr);
-            BEAST_EXPECT(bln.if_string() == nullptr);
-            BEAST_EXPECT(nul.if_string() == nullptr);
+            BOOST_TEST(obj.if_string() == nullptr);
+            BOOST_TEST(arr.if_string() == nullptr);
+            BOOST_TEST(str.if_string() != nullptr);
+            BOOST_TEST(i64.if_string() == nullptr);
+            BOOST_TEST(u64.if_string() == nullptr);
+            BOOST_TEST(dub.if_string() == nullptr);
+            BOOST_TEST(bln.if_string() == nullptr);
+            BOOST_TEST(nul.if_string() == nullptr);
         }
 
         // if_string() const
         {
-            BEAST_EXPECT(cobj.if_string() == nullptr);
-            BEAST_EXPECT(carr.if_string() == nullptr);
-            BEAST_EXPECT(cstr.if_string() != nullptr);
-            BEAST_EXPECT(ci64.if_string() == nullptr);
-            BEAST_EXPECT(cu64.if_string() == nullptr);
-            BEAST_EXPECT(cdub.if_string() == nullptr);
-            BEAST_EXPECT(cbln.if_string() == nullptr);
-            BEAST_EXPECT(cnul.if_string() == nullptr);
+            BOOST_TEST(cobj.if_string() == nullptr);
+            BOOST_TEST(carr.if_string() == nullptr);
+            BOOST_TEST(cstr.if_string() != nullptr);
+            BOOST_TEST(ci64.if_string() == nullptr);
+            BOOST_TEST(cu64.if_string() == nullptr);
+            BOOST_TEST(cdub.if_string() == nullptr);
+            BOOST_TEST(cbln.if_string() == nullptr);
+            BOOST_TEST(cnul.if_string() == nullptr);
         }
 
         // if_int64()
         {
-            BEAST_EXPECT(obj.if_int64() == nullptr);
-            BEAST_EXPECT(arr.if_int64() == nullptr);
-            BEAST_EXPECT(str.if_int64() == nullptr);
-            BEAST_EXPECT(i64.if_int64() != nullptr);
-            BEAST_EXPECT(u64.if_int64() == nullptr);
-            BEAST_EXPECT(dub.if_int64() == nullptr);
-            BEAST_EXPECT(bln.if_int64() == nullptr);
-            BEAST_EXPECT(nul.if_int64() == nullptr);
+            BOOST_TEST(obj.if_int64() == nullptr);
+            BOOST_TEST(arr.if_int64() == nullptr);
+            BOOST_TEST(str.if_int64() == nullptr);
+            BOOST_TEST(i64.if_int64() != nullptr);
+            BOOST_TEST(u64.if_int64() == nullptr);
+            BOOST_TEST(dub.if_int64() == nullptr);
+            BOOST_TEST(bln.if_int64() == nullptr);
+            BOOST_TEST(nul.if_int64() == nullptr);
         }
 
         // if_int64() const
         {
-            BEAST_EXPECT(cobj.if_int64() == nullptr);
-            BEAST_EXPECT(carr.if_int64() == nullptr);
-            BEAST_EXPECT(cstr.if_int64() == nullptr);
-            BEAST_EXPECT(ci64.if_int64() != nullptr);
-            BEAST_EXPECT(cu64.if_int64() == nullptr);
-            BEAST_EXPECT(cdub.if_int64() == nullptr);
-            BEAST_EXPECT(cbln.if_int64() == nullptr);
-            BEAST_EXPECT(cnul.if_int64() == nullptr);
+            BOOST_TEST(cobj.if_int64() == nullptr);
+            BOOST_TEST(carr.if_int64() == nullptr);
+            BOOST_TEST(cstr.if_int64() == nullptr);
+            BOOST_TEST(ci64.if_int64() != nullptr);
+            BOOST_TEST(cu64.if_int64() == nullptr);
+            BOOST_TEST(cdub.if_int64() == nullptr);
+            BOOST_TEST(cbln.if_int64() == nullptr);
+            BOOST_TEST(cnul.if_int64() == nullptr);
         }
 
         // if_uint64()
         {
-            BEAST_EXPECT(obj.if_uint64() == nullptr);
-            BEAST_EXPECT(arr.if_uint64() == nullptr);
-            BEAST_EXPECT(str.if_uint64() == nullptr);
-            BEAST_EXPECT(i64.if_uint64() == nullptr);
-            BEAST_EXPECT(u64.if_uint64() != nullptr);
-            BEAST_EXPECT(dub.if_uint64() == nullptr);
-            BEAST_EXPECT(bln.if_uint64() == nullptr);
-            BEAST_EXPECT(nul.if_uint64() == nullptr);
+            BOOST_TEST(obj.if_uint64() == nullptr);
+            BOOST_TEST(arr.if_uint64() == nullptr);
+            BOOST_TEST(str.if_uint64() == nullptr);
+            BOOST_TEST(i64.if_uint64() == nullptr);
+            BOOST_TEST(u64.if_uint64() != nullptr);
+            BOOST_TEST(dub.if_uint64() == nullptr);
+            BOOST_TEST(bln.if_uint64() == nullptr);
+            BOOST_TEST(nul.if_uint64() == nullptr);
         }
 
         // if_uint64() const
         {
-            BEAST_EXPECT(cobj.if_uint64() == nullptr);
-            BEAST_EXPECT(carr.if_uint64() == nullptr);
-            BEAST_EXPECT(cstr.if_uint64() == nullptr);
-            BEAST_EXPECT(ci64.if_uint64() == nullptr);
-            BEAST_EXPECT(cu64.if_uint64() != nullptr);
-            BEAST_EXPECT(cdub.if_uint64() == nullptr);
-            BEAST_EXPECT(cbln.if_uint64() == nullptr);
-            BEAST_EXPECT(cnul.if_uint64() == nullptr);
+            BOOST_TEST(cobj.if_uint64() == nullptr);
+            BOOST_TEST(carr.if_uint64() == nullptr);
+            BOOST_TEST(cstr.if_uint64() == nullptr);
+            BOOST_TEST(ci64.if_uint64() == nullptr);
+            BOOST_TEST(cu64.if_uint64() != nullptr);
+            BOOST_TEST(cdub.if_uint64() == nullptr);
+            BOOST_TEST(cbln.if_uint64() == nullptr);
+            BOOST_TEST(cnul.if_uint64() == nullptr);
         }
 
         // if_double()
         {
-            BEAST_EXPECT(obj.if_double() == nullptr);
-            BEAST_EXPECT(arr.if_double() == nullptr);
-            BEAST_EXPECT(str.if_double() == nullptr);
-            BEAST_EXPECT(i64.if_double() == nullptr);
-            BEAST_EXPECT(u64.if_double() == nullptr);
-            BEAST_EXPECT(dub.if_double() != nullptr);
-            BEAST_EXPECT(bln.if_double() == nullptr);
-            BEAST_EXPECT(nul.if_double() == nullptr);
+            BOOST_TEST(obj.if_double() == nullptr);
+            BOOST_TEST(arr.if_double() == nullptr);
+            BOOST_TEST(str.if_double() == nullptr);
+            BOOST_TEST(i64.if_double() == nullptr);
+            BOOST_TEST(u64.if_double() == nullptr);
+            BOOST_TEST(dub.if_double() != nullptr);
+            BOOST_TEST(bln.if_double() == nullptr);
+            BOOST_TEST(nul.if_double() == nullptr);
         }
 
         // if_double() const
         {
-            BEAST_EXPECT(cobj.if_double() == nullptr);
-            BEAST_EXPECT(carr.if_double() == nullptr);
-            BEAST_EXPECT(cstr.if_double() == nullptr);
-            BEAST_EXPECT(ci64.if_double() == nullptr);
-            BEAST_EXPECT(cu64.if_double() == nullptr);
-            BEAST_EXPECT(cdub.if_double() != nullptr);
-            BEAST_EXPECT(cbln.if_double() == nullptr);
-            BEAST_EXPECT(cnul.if_double() == nullptr);
+            BOOST_TEST(cobj.if_double() == nullptr);
+            BOOST_TEST(carr.if_double() == nullptr);
+            BOOST_TEST(cstr.if_double() == nullptr);
+            BOOST_TEST(ci64.if_double() == nullptr);
+            BOOST_TEST(cu64.if_double() == nullptr);
+            BOOST_TEST(cdub.if_double() != nullptr);
+            BOOST_TEST(cbln.if_double() == nullptr);
+            BOOST_TEST(cnul.if_double() == nullptr);
         }
 
         // if_bool()
         {
-            BEAST_EXPECT(obj.if_bool() == nullptr);
-            BEAST_EXPECT(arr.if_bool() == nullptr);
-            BEAST_EXPECT(str.if_bool() == nullptr);
-            BEAST_EXPECT(i64.if_bool() == nullptr);
-            BEAST_EXPECT(u64.if_bool() == nullptr);
-            BEAST_EXPECT(dub.if_bool() == nullptr);
-            BEAST_EXPECT(bln.if_bool() != nullptr);
-            BEAST_EXPECT(nul.if_bool() == nullptr);
+            BOOST_TEST(obj.if_bool() == nullptr);
+            BOOST_TEST(arr.if_bool() == nullptr);
+            BOOST_TEST(str.if_bool() == nullptr);
+            BOOST_TEST(i64.if_bool() == nullptr);
+            BOOST_TEST(u64.if_bool() == nullptr);
+            BOOST_TEST(dub.if_bool() == nullptr);
+            BOOST_TEST(bln.if_bool() != nullptr);
+            BOOST_TEST(nul.if_bool() == nullptr);
         }
 
         // if_bool() const
         {
-            BEAST_EXPECT(cobj.if_bool() == nullptr);
-            BEAST_EXPECT(carr.if_bool() == nullptr);
-            BEAST_EXPECT(cstr.if_bool() == nullptr);
-            BEAST_EXPECT(ci64.if_bool() == nullptr);
-            BEAST_EXPECT(cu64.if_bool() == nullptr);
-            BEAST_EXPECT(cdub.if_bool() == nullptr);
-            BEAST_EXPECT(cbln.if_bool() != nullptr);
-            BEAST_EXPECT(cnul.if_bool() == nullptr);
+            BOOST_TEST(cobj.if_bool() == nullptr);
+            BOOST_TEST(carr.if_bool() == nullptr);
+            BOOST_TEST(cstr.if_bool() == nullptr);
+            BOOST_TEST(ci64.if_bool() == nullptr);
+            BOOST_TEST(cu64.if_bool() == nullptr);
+            BOOST_TEST(cdub.if_bool() == nullptr);
+            BOOST_TEST(cbln.if_bool() != nullptr);
+            BOOST_TEST(cnul.if_bool() == nullptr);
         }
     }
 
@@ -1306,182 +1306,182 @@ public:
         // as_object()
         {
              object& x = obj.as_object();
-            BEAST_THROWS(arr.as_object(), system_error);
-            BEAST_THROWS(str.as_object(), system_error);
-            BEAST_THROWS(i64.as_object(), system_error);
-            BEAST_THROWS(u64.as_object(), system_error);
-            BEAST_THROWS(dub.as_object(), system_error);
-            BEAST_THROWS(bln.as_object(), system_error);
-            BEAST_THROWS(nul.as_object(), system_error);
+            BOOST_TEST_THROWS(arr.as_object(), system_error);
+            BOOST_TEST_THROWS(str.as_object(), system_error);
+            BOOST_TEST_THROWS(i64.as_object(), system_error);
+            BOOST_TEST_THROWS(u64.as_object(), system_error);
+            BOOST_TEST_THROWS(dub.as_object(), system_error);
+            BOOST_TEST_THROWS(bln.as_object(), system_error);
+            BOOST_TEST_THROWS(nul.as_object(), system_error);
             (void)x;
         }
 
         // as_object() const
         {
        object const& x = cobj.as_object();
-            BEAST_THROWS(carr.as_object(), system_error);
-            BEAST_THROWS(cstr.as_object(), system_error);
-            BEAST_THROWS(ci64.as_object(), system_error);
-            BEAST_THROWS(cu64.as_object(), system_error);
-            BEAST_THROWS(cdub.as_object(), system_error);
-            BEAST_THROWS(cbln.as_object(), system_error);
-            BEAST_THROWS(cnul.as_object(), system_error);
+            BOOST_TEST_THROWS(carr.as_object(), system_error);
+            BOOST_TEST_THROWS(cstr.as_object(), system_error);
+            BOOST_TEST_THROWS(ci64.as_object(), system_error);
+            BOOST_TEST_THROWS(cu64.as_object(), system_error);
+            BOOST_TEST_THROWS(cdub.as_object(), system_error);
+            BOOST_TEST_THROWS(cbln.as_object(), system_error);
+            BOOST_TEST_THROWS(cnul.as_object(), system_error);
             (void)x;
         }
 
         // as_array()
         {
-            BEAST_THROWS(obj.as_array(), system_error);
+            BOOST_TEST_THROWS(obj.as_array(), system_error);
               array& x = arr.as_array();
-            BEAST_THROWS(str.as_array(), system_error);
-            BEAST_THROWS(i64.as_array(), system_error);
-            BEAST_THROWS(u64.as_array(), system_error);
-            BEAST_THROWS(dub.as_array(), system_error);
-            BEAST_THROWS(bln.as_array(), system_error);
-            BEAST_THROWS(nul.as_array(), system_error);
+            BOOST_TEST_THROWS(str.as_array(), system_error);
+            BOOST_TEST_THROWS(i64.as_array(), system_error);
+            BOOST_TEST_THROWS(u64.as_array(), system_error);
+            BOOST_TEST_THROWS(dub.as_array(), system_error);
+            BOOST_TEST_THROWS(bln.as_array(), system_error);
+            BOOST_TEST_THROWS(nul.as_array(), system_error);
             (void)x;
         }
 
         // as_array() const
         {
-            BEAST_THROWS(cobj.as_array(), system_error);
+            BOOST_TEST_THROWS(cobj.as_array(), system_error);
         array const& x = carr.as_array();
-            BEAST_THROWS(cstr.as_array(), system_error);
-            BEAST_THROWS(ci64.as_array(), system_error);
-            BEAST_THROWS(cu64.as_array(), system_error);
-            BEAST_THROWS(cdub.as_array(), system_error);
-            BEAST_THROWS(cbln.as_array(), system_error);
-            BEAST_THROWS(cnul.as_array(), system_error);
+            BOOST_TEST_THROWS(cstr.as_array(), system_error);
+            BOOST_TEST_THROWS(ci64.as_array(), system_error);
+            BOOST_TEST_THROWS(cu64.as_array(), system_error);
+            BOOST_TEST_THROWS(cdub.as_array(), system_error);
+            BOOST_TEST_THROWS(cbln.as_array(), system_error);
+            BOOST_TEST_THROWS(cnul.as_array(), system_error);
             (void)x;
         }
 
         // as_string()
         {
-            BEAST_THROWS(obj.as_string(), system_error);
-            BEAST_THROWS(arr.as_string(), system_error);
+            BOOST_TEST_THROWS(obj.as_string(), system_error);
+            BOOST_TEST_THROWS(arr.as_string(), system_error);
              string& x = str.as_string();
-            BEAST_THROWS(i64.as_string(), system_error);
-            BEAST_THROWS(u64.as_string(), system_error);
-            BEAST_THROWS(dub.as_string(), system_error);
-            BEAST_THROWS(bln.as_string(), system_error);
-            BEAST_THROWS(nul.as_string(), system_error);
+            BOOST_TEST_THROWS(i64.as_string(), system_error);
+            BOOST_TEST_THROWS(u64.as_string(), system_error);
+            BOOST_TEST_THROWS(dub.as_string(), system_error);
+            BOOST_TEST_THROWS(bln.as_string(), system_error);
+            BOOST_TEST_THROWS(nul.as_string(), system_error);
             (void)x;
         }
 
         // as_string() const
         {
-            BEAST_THROWS(cobj.as_string(), system_error);
-            BEAST_THROWS(carr.as_string(), system_error);
+            BOOST_TEST_THROWS(cobj.as_string(), system_error);
+            BOOST_TEST_THROWS(carr.as_string(), system_error);
        string const& x = cstr.as_string();
-            BEAST_THROWS(ci64.as_string(), system_error);
-            BEAST_THROWS(cu64.as_string(), system_error);
-            BEAST_THROWS(cdub.as_string(), system_error);
-            BEAST_THROWS(cbln.as_string(), system_error);
-            BEAST_THROWS(cnul.as_string(), system_error);
+            BOOST_TEST_THROWS(ci64.as_string(), system_error);
+            BOOST_TEST_THROWS(cu64.as_string(), system_error);
+            BOOST_TEST_THROWS(cdub.as_string(), system_error);
+            BOOST_TEST_THROWS(cbln.as_string(), system_error);
+            BOOST_TEST_THROWS(cnul.as_string(), system_error);
             (void)x;
         }
 
         // as_int64()
         {
-            BEAST_THROWS(obj.as_int64(), system_error);
-            BEAST_THROWS(arr.as_int64(), system_error);
-            BEAST_THROWS(str.as_int64(), system_error);
+            BOOST_TEST_THROWS(obj.as_int64(), system_error);
+            BOOST_TEST_THROWS(arr.as_int64(), system_error);
+            BOOST_TEST_THROWS(str.as_int64(), system_error);
        std::int64_t& x = i64.as_int64();
-            BEAST_THROWS(u64.as_int64(), system_error);
-            BEAST_THROWS(dub.as_int64(), system_error);
-            BEAST_THROWS(bln.as_int64(), system_error);
-            BEAST_THROWS(nul.as_int64(), system_error);
+            BOOST_TEST_THROWS(u64.as_int64(), system_error);
+            BOOST_TEST_THROWS(dub.as_int64(), system_error);
+            BOOST_TEST_THROWS(bln.as_int64(), system_error);
+            BOOST_TEST_THROWS(nul.as_int64(), system_error);
             (void)x;
         }
 
         // as_int64() const
         {
-            BEAST_THROWS(cobj.as_int64(), system_error);
-            BEAST_THROWS(carr.as_int64(), system_error);
-            BEAST_THROWS(cstr.as_int64(), system_error);
+            BOOST_TEST_THROWS(cobj.as_int64(), system_error);
+            BOOST_TEST_THROWS(carr.as_int64(), system_error);
+            BOOST_TEST_THROWS(cstr.as_int64(), system_error);
  std::int64_t const& x = ci64.as_int64();
-            BEAST_THROWS(cu64.as_int64(), system_error);
-            BEAST_THROWS(cdub.as_int64(), system_error);
-            BEAST_THROWS(cbln.as_int64(), system_error);
-            BEAST_THROWS(cnul.as_int64(), system_error);
+            BOOST_TEST_THROWS(cu64.as_int64(), system_error);
+            BOOST_TEST_THROWS(cdub.as_int64(), system_error);
+            BOOST_TEST_THROWS(cbln.as_int64(), system_error);
+            BOOST_TEST_THROWS(cnul.as_int64(), system_error);
             (void)x;
         }
 
         // as_uint64()
         {
-            BEAST_THROWS(obj.as_uint64(), system_error);
-            BEAST_THROWS(arr.as_uint64(), system_error);
-            BEAST_THROWS(str.as_uint64(), system_error);
-            BEAST_THROWS(i64.as_uint64(), system_error);
+            BOOST_TEST_THROWS(obj.as_uint64(), system_error);
+            BOOST_TEST_THROWS(arr.as_uint64(), system_error);
+            BOOST_TEST_THROWS(str.as_uint64(), system_error);
+            BOOST_TEST_THROWS(i64.as_uint64(), system_error);
       std::uint64_t& x = u64.as_uint64();
-            BEAST_THROWS(dub.as_uint64(), system_error);
-            BEAST_THROWS(bln.as_uint64(), system_error);
-            BEAST_THROWS(nul.as_uint64(), system_error);
+            BOOST_TEST_THROWS(dub.as_uint64(), system_error);
+            BOOST_TEST_THROWS(bln.as_uint64(), system_error);
+            BOOST_TEST_THROWS(nul.as_uint64(), system_error);
             (void)x;
         }
 
         // as_uint64() const
         {
-            BEAST_THROWS(cobj.as_uint64(), system_error);
-            BEAST_THROWS(carr.as_uint64(), system_error);
-            BEAST_THROWS(cstr.as_uint64(), system_error);
-            BEAST_THROWS(ci64.as_uint64(), system_error);
+            BOOST_TEST_THROWS(cobj.as_uint64(), system_error);
+            BOOST_TEST_THROWS(carr.as_uint64(), system_error);
+            BOOST_TEST_THROWS(cstr.as_uint64(), system_error);
+            BOOST_TEST_THROWS(ci64.as_uint64(), system_error);
 std::uint64_t const& x = cu64.as_uint64();
-            BEAST_THROWS(cdub.as_uint64(), system_error);
-            BEAST_THROWS(cbln.as_uint64(), system_error);
-            BEAST_THROWS(cnul.as_uint64(), system_error);
+            BOOST_TEST_THROWS(cdub.as_uint64(), system_error);
+            BOOST_TEST_THROWS(cbln.as_uint64(), system_error);
+            BOOST_TEST_THROWS(cnul.as_uint64(), system_error);
             (void)x;
         }
 
         // as_double()
         {
-            BEAST_THROWS(obj.as_double(), system_error);
-            BEAST_THROWS(arr.as_double(), system_error);
-            BEAST_THROWS(str.as_double(), system_error);
-            BEAST_THROWS(i64.as_double(), system_error);
-            BEAST_THROWS(u64.as_double(), system_error);
+            BOOST_TEST_THROWS(obj.as_double(), system_error);
+            BOOST_TEST_THROWS(arr.as_double(), system_error);
+            BOOST_TEST_THROWS(str.as_double(), system_error);
+            BOOST_TEST_THROWS(i64.as_double(), system_error);
+            BOOST_TEST_THROWS(u64.as_double(), system_error);
              double& x = dub.as_double();
-            BEAST_THROWS(bln.as_double(), system_error);
-            BEAST_THROWS(nul.as_double(), system_error);
+            BOOST_TEST_THROWS(bln.as_double(), system_error);
+            BOOST_TEST_THROWS(nul.as_double(), system_error);
             (void)x;
         }
 
         // as_uint64() const
         {
-            BEAST_THROWS(cobj.as_double(), system_error);
-            BEAST_THROWS(carr.as_double(), system_error);
-            BEAST_THROWS(cstr.as_double(), system_error);
-            BEAST_THROWS(ci64.as_double(), system_error);
-            BEAST_THROWS(cu64.as_double(), system_error);
+            BOOST_TEST_THROWS(cobj.as_double(), system_error);
+            BOOST_TEST_THROWS(carr.as_double(), system_error);
+            BOOST_TEST_THROWS(cstr.as_double(), system_error);
+            BOOST_TEST_THROWS(ci64.as_double(), system_error);
+            BOOST_TEST_THROWS(cu64.as_double(), system_error);
        double const& x = cdub.as_double();
-            BEAST_THROWS(cbln.as_double(), system_error);
-            BEAST_THROWS(cnul.as_double(), system_error);
+            BOOST_TEST_THROWS(cbln.as_double(), system_error);
+            BOOST_TEST_THROWS(cnul.as_double(), system_error);
             (void)x;
         }
 
         // as_bool()
         {
-            BEAST_THROWS(obj.as_bool(), system_error);
-            BEAST_THROWS(arr.as_bool(), system_error);
-            BEAST_THROWS(str.as_bool(), system_error);
-            BEAST_THROWS(i64.as_bool(), system_error);
-            BEAST_THROWS(u64.as_bool(), system_error);
-            BEAST_THROWS(dub.as_bool(), system_error);
+            BOOST_TEST_THROWS(obj.as_bool(), system_error);
+            BOOST_TEST_THROWS(arr.as_bool(), system_error);
+            BOOST_TEST_THROWS(str.as_bool(), system_error);
+            BOOST_TEST_THROWS(i64.as_bool(), system_error);
+            BOOST_TEST_THROWS(u64.as_bool(), system_error);
+            BOOST_TEST_THROWS(dub.as_bool(), system_error);
                bool& x = bln.as_bool();
-            BEAST_THROWS(nul.as_bool(), system_error);
+            BOOST_TEST_THROWS(nul.as_bool(), system_error);
             (void)x;
         }
 
         // as_bool() const
         {
-            BEAST_THROWS(cobj.as_bool(), system_error);
-            BEAST_THROWS(carr.as_bool(), system_error);
-            BEAST_THROWS(cstr.as_bool(), system_error);
-            BEAST_THROWS(ci64.as_bool(), system_error);
-            BEAST_THROWS(cu64.as_bool(), system_error);
-            BEAST_THROWS(cdub.as_bool(), system_error);
+            BOOST_TEST_THROWS(cobj.as_bool(), system_error);
+            BOOST_TEST_THROWS(carr.as_bool(), system_error);
+            BOOST_TEST_THROWS(cstr.as_bool(), system_error);
+            BOOST_TEST_THROWS(ci64.as_bool(), system_error);
+            BOOST_TEST_THROWS(cu64.as_bool(), system_error);
+            BOOST_TEST_THROWS(cdub.as_bool(), system_error);
           bool const&x = cbln.as_bool();
-            BEAST_THROWS(cnul.as_bool(), system_error);
+            BOOST_TEST_THROWS(cnul.as_bool(), system_error);
             (void)x;
         }
     }
@@ -1593,19 +1593,19 @@ std::uint64_t const& x = cu64.as_uint64();
 
         kvp v1("key", "value");
         kvp v2(v1);
-        BEAST_EXPECT(v2.key() == "key");
-        BEAST_EXPECT(
+        BOOST_TEST(v2.key() == "key");
+        BOOST_TEST(
             v2.value().get_string() == "value");
         kvp v3(std::move(v2));
-        BEAST_EXPECT(v3.key() == "key");
-        BEAST_EXPECT(
+        BOOST_TEST(v3.key() == "key");
+        BOOST_TEST(
             v3.value().get_string() == "value");
     }
 
     //------------------------------------------------------
 
     void
-    run() override
+    run()
     {
         testSpecial();
         testConversion();
@@ -1621,7 +1621,7 @@ std::uint64_t const& x = cu64.as_uint64();
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,value);
+TEST_SUITE(value_test, "boost.json.value");
 
 } // json
 } // boost
diff --git a/test/value_ref.cpp b/test/value_ref.cpp
index ef272018..bd84d8b4 100644
--- a/test/value_ref.cpp
+++ b/test/value_ref.cpp
@@ -13,14 +13,12 @@
 #include <boost/json/value.hpp>
 #include <boost/json/serializer.hpp>
 
-#include <boost/beast/_experimental/unit_test/suite.hpp>
-
-#include "test.hpp"
+#include "test_suite.hpp"
 
 namespace boost {
 namespace json {
 
-class value_ref_test : public beast::unit_test::suite
+class value_ref_test
 {
 public:
     using init_list =
@@ -177,7 +175,7 @@ public:
         auto const jv =
             value_ref(init).make_value({});
         auto const js = to_string(jv);
-        BEAST_EXPECT(js == s);
+        BOOST_TEST(js == s);
     }
 
     void
@@ -276,7 +274,7 @@ public:
     {
         auto const jv = value(object(init));
         auto const js = to_string(jv);
-        BEAST_EXPECT(js == s);
+        BOOST_TEST(js == s);
     }
 
     void
@@ -297,7 +295,7 @@ public:
     }
 
     void
-    run() override
+    run()
     {
         testCtors();
         testInitList();
@@ -306,7 +304,7 @@ public:
     }
 };
 
-BEAST_DEFINE_TESTSUITE(boost,json,value_ref);
+TEST_SUITE(value_ref_test, "boost.json.value_ref");
 
 } // json
 } // boost