diff --git a/test/helpers/test.hpp b/test/helpers/test.hpp
index c65701b6..617946c7 100644
--- a/test/helpers/test.hpp
+++ b/test/helpers/test.hpp
@@ -39,7 +39,39 @@
         return boost::report_errors();                                         \
     }
 
+#define UNORDERED_SUB_TEST(x)                                                  \
+    for (int UNORDERED_SUB_TEST_VALUE = ::test::start_sub_test(x);             \
+         UNORDERED_SUB_TEST_VALUE;                                             \
+         UNORDERED_SUB_TEST_VALUE =                                            \
+             ::test::end_sub_test(x, UNORDERED_SUB_TEST_VALUE))
+
 namespace test {
+
+static inline bool& is_quiet()
+{
+    static bool value = false;
+    return value;
+}
+
+static inline int start_sub_test(char const* name)
+{
+    if (!is_quiet()) {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Sub-test: " << name << "\n"
+                                       << std::flush;
+    }
+    // Add one because it's used as a loop condition.
+    return boost::detail::test_errors() + 1;
+}
+
+static inline int end_sub_test(char const* name, int value)
+{
+    if (is_quiet() && value != boost::detail::test_errors() + 1) {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Error in sub-test: " << name << "\n"
+                                       << std::flush;
+    }
+    return 0;
+}
+
 struct registered_test_base
 {
     registered_test_base* next;
@@ -75,6 +107,8 @@ static inline void add_test(registered_test_base* test)
 
 static inline void run_tests(bool quiet = false)
 {
+    test::is_quiet() = quiet;
+
     for (registered_test_base* i = first(); i; i = i->next) {
         int error_count = boost::detail::test_errors();
         if (!quiet) {
@@ -160,6 +194,8 @@ static inline void run_tests(bool quiet = false)
         BOOST_PP_SEQ_TAIL(BOOST_PP_SEQ_TAIL(product)))
 
 #define UNORDERED_MULTI_TEST_OP2(name, n, params)                              \
+    UNORDERED_SUB_TEST(BOOST_PP_STRINGIZE(                                     \
+        BOOST_PP_SEQ_FOLD_LEFT(UNORDERED_TEST_OP_JOIN, name, params)))         \
     {                                                                          \
         for (int i = 0; i < n; ++i)                                            \
             name BOOST_PP_SEQ_TO_TUPLE(params);                                \
diff --git a/test/unordered/constructor_tests.cpp b/test/unordered/constructor_tests.cpp
index a12d57ef..4c967ded 100644
--- a/test/unordered/constructor_tests.cpp
+++ b/test/unordered/constructor_tests.cpp
@@ -28,7 +28,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
     BOOST_DEDUCED_TYPENAME T::allocator_type al;
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 1\n";
+    UNORDERED_SUB_TEST("Construct 1")
     {
         test::check_instances check_;
 
@@ -40,7 +40,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 2\n";
+    UNORDERED_SUB_TEST("Construct 2")
     {
         test::check_instances check_;
 
@@ -53,7 +53,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 3\n";
+    UNORDERED_SUB_TEST("Construct 3")
     {
         test::check_instances check_;
 
@@ -66,7 +66,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 4\n";
+    UNORDERED_SUB_TEST("Construct 4")
     {
         test::check_instances check_;
 
@@ -78,7 +78,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 5\n";
+    UNORDERED_SUB_TEST("Construct 5")
     {
         test::check_instances check_;
 
@@ -92,7 +92,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 6\n";
+    UNORDERED_SUB_TEST("Construct 6")
     {
         test::check_instances check_;
 
@@ -106,7 +106,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 7\n";
+    UNORDERED_SUB_TEST("Construct 7")
     {
         test::check_instances check_;
 
@@ -120,7 +120,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 8\n";
+    UNORDERED_SUB_TEST("Construct 8")
     {
         test::check_instances check_;
 
@@ -133,7 +133,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 9\n";
+    UNORDERED_SUB_TEST("Construct 9")
     {
         test::check_instances check_;
 
@@ -145,7 +145,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 10\n";
+    UNORDERED_SUB_TEST("Construct 10")
     {
         test::check_instances check_;
 
@@ -159,7 +159,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 11\n";
+    UNORDERED_SUB_TEST("Construct 11")
     {
         test::check_instances check_;
 
@@ -185,7 +185,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
     BOOST_DEDUCED_TYPENAME T::allocator_type al1(1);
     BOOST_DEDUCED_TYPENAME T::allocator_type al2(2);
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 1\n";
+    UNORDERED_SUB_TEST("Construct 1")
     {
         test::check_instances check_;
         T x(10000, hf1, eq1);
@@ -196,7 +196,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 2\n";
+    UNORDERED_SUB_TEST("Construct 2")
     {
         test::check_instances check_;
         T x(100, hf1);
@@ -208,7 +208,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 3\n";
+    UNORDERED_SUB_TEST("Construct 3")
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
@@ -220,7 +220,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 4\n";
+    UNORDERED_SUB_TEST("Construct 4")
     {
         test::check_instances check_;
         test::random_values<T> v(5, generator);
@@ -233,7 +233,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 5\n";
+    UNORDERED_SUB_TEST("Construct 5")
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
@@ -245,7 +245,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(y);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 6\n";
+    UNORDERED_SUB_TEST("Construct 6")
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
@@ -257,7 +257,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(y);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 7\n";
+    UNORDERED_SUB_TEST("Construct 7")
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
@@ -269,7 +269,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(y);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 8 - from input iterator\n";
+    UNORDERED_SUB_TEST("Construct 8 - from input iterator")
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
@@ -288,7 +288,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(y);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 8.5 - from copy iterator\n";
+    UNORDERED_SUB_TEST("Construct 8.5 - from copy iterator")
     {
         test::check_instances check_;
         test::random_values<T> v(100, generator);
@@ -302,7 +302,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         test::check_equivalent_keys(y);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 9\n";
+    UNORDERED_SUB_TEST("Construct 9")
     {
         test::check_instances check_;
 
@@ -320,7 +320,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
     std::initializer_list<BOOST_DEDUCED_TYPENAME T::value_type> list;
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 1\n";
+    UNORDERED_SUB_TEST("Initializer list construct 1")
     {
         test::check_instances check_;
 
@@ -331,7 +331,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 2\n";
+    UNORDERED_SUB_TEST("Initializer list construct 2")
     {
         test::check_instances check_;
 
@@ -343,7 +343,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 3\n";
+    UNORDERED_SUB_TEST("Initializer list construct 3")
     {
         test::check_instances check_;
 
@@ -355,7 +355,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 4\n";
+    UNORDERED_SUB_TEST("Initializer list construct 4")
     {
         test::check_instances check_;
 
@@ -367,7 +367,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
         BOOST_TEST(test::equivalent(x.get_allocator(), al));
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 5\n";
+    UNORDERED_SUB_TEST("Initializer list construct 5")
     {
         test::check_instances check_;
 
@@ -384,8 +384,6 @@ void constructor_tests2(T*, test::random_generator const& generator)
 template <class T>
 void map_constructor_test(T*, test::random_generator const& generator)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map_constructor_test\n";
-
     typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME T::key_type,
         BOOST_DEDUCED_TYPENAME T::mapped_type> >
         list;
@@ -429,7 +427,6 @@ UNORDERED_TEST(map_constructor_test,
 
 UNORDERED_AUTO_TEST(test_default_initializer_list)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
     std::initializer_list<int> init;
     boost::unordered_set<int> x1 = init;
     BOOST_TEST(x1.empty());
@@ -441,7 +438,6 @@ UNORDERED_AUTO_TEST(test_default_initializer_list)
 
 UNORDERED_AUTO_TEST(test_initializer_list)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
     boost::unordered_set<int> x1 = {2, 10, 45, -5};
     BOOST_TEST(x1.find(10) != x1.end());
     BOOST_TEST(x1.find(46) == x1.end());
@@ -450,4 +446,4 @@ UNORDERED_AUTO_TEST(test_initializer_list)
 #endif
 }
 
-RUN_TESTS()
+RUN_TESTS_QUIET()
diff --git a/test/unordered/insert_tests.cpp b/test/unordered/insert_tests.cpp
index fb4f78d9..26141d0e 100644
--- a/test/unordered/insert_tests.cpp
+++ b/test/unordered/insert_tests.cpp
@@ -33,9 +33,7 @@ void unique_insert_tests1(X*, test::random_generator generator)
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-        << "insert(value) tests for containers with unique keys.\n";
-
+    UNORDERED_SUB_TEST("insert(value) tests for containers with unique keys")
     {
         X x;
         test::ordered<X> tracker = test::create_ordered(x);
@@ -67,9 +65,7 @@ void unique_insert_tests1(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-        << "insert(rvalue) tests for containers with unique keys.\n";
-
+    UNORDERED_SUB_TEST("insert(rvalue) tests for containers with unique keys")
     {
         X x;
         test::ordered<X> tracker = test::create_ordered(x);
@@ -108,9 +104,8 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
 {
     test::check_instances check_;
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-        << "insert(value) tests for containers with equivalent keys.\n";
-
+    UNORDERED_SUB_TEST(
+        "insert(value) tests for containers with equivalent keys")
     {
         X x;
         test::ordered<X> tracker = test::create_ordered(x);
@@ -139,9 +134,8 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-        << "insert(rvalue) tests for containers with equivalent keys.\n";
-
+    UNORDERED_SUB_TEST(
+        "insert(rvalue) tests for containers with equivalent keys")
     {
         X x;
         test::ordered<X> tracker = test::create_ordered(x);
@@ -180,8 +174,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
     typedef BOOST_DEDUCED_TYPENAME X::const_iterator const_iterator;
     typedef BOOST_DEDUCED_TYPENAME tracker_type::iterator tracker_iterator;
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(begin(), value) tests.\n";
-
+    UNORDERED_SUB_TEST("insert(begin(), value) tests")
     {
         test::check_instances check_;
 
@@ -210,8 +203,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(end(), value) tests.\n";
-
+    UNORDERED_SUB_TEST("insert(end(), value) tests")
     {
         test::check_instances check_;
 
@@ -241,8 +233,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(pos, value) tests.\n";
-
+    UNORDERED_SUB_TEST("insert(pos, value) tests")
     {
         test::check_instances check_;
 
@@ -272,8 +263,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(pos, rvalue) tests.\n";
-
+    UNORDERED_SUB_TEST("insert(pos, rvalue) tests")
     {
         test::check_instances check_;
 
@@ -304,8 +294,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert single item range tests.\n";
-
+    UNORDERED_SUB_TEST("insert single item range tests")
     {
         test::check_instances check_;
 
@@ -333,8 +322,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert range tests.\n";
-
+    UNORDERED_SUB_TEST("insert range tests")
     {
         test::check_instances check_;
 
@@ -347,8 +335,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert range with rehash tests.\n";
-
+    UNORDERED_SUB_TEST("insert range with rehash tests")
     {
         test::check_instances check_;
 
@@ -365,8 +352,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert input iterator range tests.\n";
-
+    UNORDERED_SUB_TEST("insert input iterator range tests")
     {
         test::check_instances check_;
 
@@ -382,8 +368,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert copy iterator range tests.\n";
-
+    UNORDERED_SUB_TEST("insert copy iterator range tests")
     {
         test::check_instances check_;
 
@@ -396,8 +381,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert copy iterator range test 2.\n";
-
+    UNORDERED_SUB_TEST("insert copy iterator range test 2")
     {
         test::check_instances check_;
 
@@ -413,8 +397,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert various ranges.\n";
-
+    UNORDERED_SUB_TEST("insert various ranges")
     {
         for (int i = 0; i < 100; ++i) {
             X x;
@@ -460,9 +443,6 @@ void unique_emplace_tests1(X*, test::random_generator generator)
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-        << "emplace(value) tests for containers with unique keys.\n";
-
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -495,9 +475,6 @@ void unique_emplace_tests1(X*, test::random_generator generator)
 template <class X>
 void equivalent_emplace_tests1(X*, test::random_generator generator)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-        << "emplace(value) tests for containers with equivalent keys.\n";
-
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -526,9 +503,6 @@ void equivalent_emplace_tests1(X*, test::random_generator generator)
 
 template <class X> void move_emplace_tests(X*, test::random_generator generator)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-        << "emplace(move(value)) tests for containers with unique keys.\n";
-
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -557,7 +531,6 @@ template <class X> void move_emplace_tests(X*, test::random_generator generator)
 template <class X> void default_emplace_tests(X*, test::random_generator)
 {
 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "emplace() tests.\n";
     bool is_unique = test::has_unique_keys<X>::value;
 
     X x;
@@ -592,8 +565,6 @@ template <class X> void default_emplace_tests(X*, test::random_generator)
 
 template <class X> void map_tests(X*, test::random_generator generator)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map tests.\n";
-
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
@@ -620,8 +591,8 @@ template <class X> void map_tests(X*, test::random_generator generator)
 template <class X> void map_tests2(X*, test::random_generator generator)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign\n";
 
+    UNORDERED_SUB_TEST("insert_or_assign")
     {
         test::check_instances check_;
 
@@ -652,8 +623,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign(begin)\n";
-
+    UNORDERED_SUB_TEST("insert_or_assign(begin)")
     {
         test::check_instances check_;
 
@@ -683,8 +653,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign(end)\n";
-
+    UNORDERED_SUB_TEST("insert_or_assign(end)")
     {
         test::check_instances check_;
 
@@ -714,8 +683,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign(last)\n";
-
+    UNORDERED_SUB_TEST("insert_or_assign(last)")
     {
         test::check_instances check_;
 
@@ -751,10 +719,9 @@ template <class X> void map_tests2(X*, test::random_generator generator)
 
 template <class X> void try_emplace_tests(X*, test::random_generator generator)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(key, value)\n";
-
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
+    UNORDERED_SUB_TEST("try_emplace(key, value)")
     {
         test::check_instances check_;
 
@@ -794,10 +761,9 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(begin(), key, value)\n";
-
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
+    UNORDERED_SUB_TEST("try_emplace(begin(), key, value)")
     {
         test::check_instances check_;
 
@@ -834,10 +800,9 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(end(), key, value)\n";
-
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
+    UNORDERED_SUB_TEST("try_emplace(end(), key, value)")
     {
         test::check_instances check_;
 
@@ -874,10 +839,9 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(pos, key, value)\n";
-
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
+    UNORDERED_SUB_TEST("try_emplace(pos, key, value)")
     {
         test::check_instances check_;
 
@@ -920,8 +884,6 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
 template <class X>
 void map_insert_range_test1(X*, test::random_generator generator)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map_insert_range_test1\n";
-
     test::check_instances check_;
 
     typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type,
@@ -939,8 +901,6 @@ void map_insert_range_test1(X*, test::random_generator generator)
 template <class X>
 void map_insert_range_test2(X*, test::random_generator generator)
 {
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map_insert_range_test2\n";
-
     test::check_instances check_;
 
     typedef test::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type const,
@@ -1397,7 +1357,7 @@ UNORDERED_AUTO_TEST(set_emplace_test2)
 #endif
 }
 
-RUN_TESTS()
+RUN_TESTS_QUIET()
 
 #else // PIECEWISE_TEST_NAME