diff --git a/test/exception/insert_exception_tests.cpp b/test/exception/insert_exception_tests.cpp
index b7ab6cdf..d5fc3f10 100644
--- a/test/exception/insert_exception_tests.cpp
+++ b/test/exception/insert_exception_tests.cpp
@@ -3,7 +3,6 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #include "./containers.hpp"
-#include <iostream>
 
 #include "../helpers/helpers.hpp"
 #include "../helpers/invariants.hpp"
diff --git a/test/exception/move_assign_exception_tests.cpp b/test/exception/move_assign_exception_tests.cpp
index 8e363f89..5fe909a2 100644
--- a/test/exception/move_assign_exception_tests.cpp
+++ b/test/exception/move_assign_exception_tests.cpp
@@ -8,7 +8,6 @@
 #include "../helpers/invariants.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
-#include <iostream>
 
 #if defined(BOOST_MSVC)
 #pragma warning(                                                               \
diff --git a/test/exception/rehash_exception_tests.cpp b/test/exception/rehash_exception_tests.cpp
index c6355071..f1386532 100644
--- a/test/exception/rehash_exception_tests.cpp
+++ b/test/exception/rehash_exception_tests.cpp
@@ -11,8 +11,6 @@
 #include "../helpers/tracker.hpp"
 #include <string>
 
-#include <iostream>
-
 test::seed_t initialize_seed(3298597);
 
 template <class T> struct rehash_test_base : public test::exception_base
diff --git a/test/helpers/count.hpp b/test/helpers/count.hpp
index c432fd1f..76248617 100644
--- a/test/helpers/count.hpp
+++ b/test/helpers/count.hpp
@@ -7,7 +7,6 @@
 #define BOOST_UNORDERED_TEST_HELPERS_COUNT_HEAD
 
 #include <boost/detail/lightweight_test.hpp>
-#include <iostream>
 
 namespace test {
 struct object_count
diff --git a/test/helpers/test.hpp b/test/helpers/test.hpp
index 4f21f0b9..c87a14dd 100644
--- a/test/helpers/test.hpp
+++ b/test/helpers/test.hpp
@@ -9,7 +9,6 @@
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/stringize.hpp>
-#include <iostream>
 
 #define UNORDERED_AUTO_TEST(x)                                                 \
     struct BOOST_PP_CAT(x, _type) : public ::test::registered_test_base        \
@@ -69,10 +68,10 @@ static inline void add_test(registered_test_base* test)
 static inline void run_tests()
 {
     for (registered_test_base* i = first(); i; i = i->next) {
-        std::cout << "Running " << i->name << "\n" << std::flush;
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Running " << i->name << "\n"
+                                       << std::flush;
         i->run();
-        std::cerr << std::flush;
-        std::cout << std::flush;
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << std::flush;
     }
 }
 }
@@ -86,18 +85,19 @@ static inline void run_tests()
 
 #define BOOST_UNORDERED_TEST_COMPILER_INFO()                                   \
     {                                                                          \
-        std::cout << "Compiler: " << BOOST_COMPILER << "\n"                    \
-                  << "Library: " << BOOST_STDLIB << "\n"                       \
-                  << "__cplusplus: " << BOOST_UNORDERED_CPLUSPLUS << "\n\n"    \
-                  << "BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT: "              \
-                  << BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT << "\n"          \
-                  << "BOOST_UNORDERED_EMPLACE_LIMIT: "                         \
-                  << BOOST_UNORDERED_EMPLACE_LIMIT << "\n"                     \
-                  << "BOOST_UNORDERED_USE_ALLOCATOR_TRAITS: "                  \
-                  << BOOST_UNORDERED_USE_ALLOCATOR_TRAITS << "\n"              \
-                  << "BOOST_UNORDERED_CXX11_CONSTRUCTION: "                    \
-                  << BOOST_UNORDERED_CXX11_CONSTRUCTION << "\n\n"              \
-                  << std::flush;                                               \
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM                                         \
+            << "Compiler: " << BOOST_COMPILER << "\n"                          \
+            << "Library: " << BOOST_STDLIB << "\n"                             \
+            << "__cplusplus: " << BOOST_UNORDERED_CPLUSPLUS << "\n\n"          \
+            << "BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT: "                    \
+            << BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT << "\n"                \
+            << "BOOST_UNORDERED_EMPLACE_LIMIT: "                               \
+            << BOOST_UNORDERED_EMPLACE_LIMIT << "\n"                           \
+            << "BOOST_UNORDERED_USE_ALLOCATOR_TRAITS: "                        \
+            << BOOST_UNORDERED_USE_ALLOCATOR_TRAITS << "\n"                    \
+            << "BOOST_UNORDERED_CXX11_CONSTRUCTION: "                          \
+            << BOOST_UNORDERED_CXX11_CONSTRUCTION << "\n\n"                    \
+            << std::flush;                                                     \
     }
 
 #include <boost/preprocessor/cat.hpp>
diff --git a/test/objects/exception.hpp b/test/objects/exception.hpp
index 01b39ee3..d0286797 100644
--- a/test/objects/exception.hpp
+++ b/test/objects/exception.hpp
@@ -15,7 +15,6 @@
 #include "./fwd.hpp"
 #include <boost/limits.hpp>
 #include <cstddef>
-#include <iostream>
 #include <new>
 
 namespace test {
diff --git a/test/unordered/assign_tests.cpp b/test/unordered/assign_tests.cpp
index f0e3aaae..3aee2198 100644
--- a/test/unordered/assign_tests.cpp
+++ b/test/unordered/assign_tests.cpp
@@ -17,8 +17,6 @@
 #include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
 
-#include <iostream>
-
 #if defined(BOOST_MSVC)
 #pragma warning(disable : 4127) // conditional expression is constant
 #endif
@@ -32,7 +30,7 @@ template <class T> void assign_tests1(T*, test::random_generator generator)
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
 
-    std::cerr << "assign_tests1.1\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests1.1\n";
     {
         test::check_instances check_;
 
@@ -43,7 +41,7 @@ template <class T> void assign_tests1(T*, test::random_generator generator)
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
     }
 
-    std::cerr << "assign_tests1.2\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests1.2\n";
     {
         test::check_instances check_;
 
@@ -79,7 +77,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
 
     typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
 
-    std::cerr << "assign_tests2.0 - empty container\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.0 - empty container\n";
     {
         test::check_instances check_;
 
@@ -93,7 +91,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
         test::check_container(x1, x2);
     }
 
-    std::cerr << "assign_tests2.1\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.1\n";
     {
         test::check_instances check_;
 
@@ -110,7 +108,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
         BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
-    std::cerr << "assign_tests2.1a\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.1a\n";
     {
         test::check_instances check_;
 
@@ -128,7 +126,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
         BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
-    std::cerr << "assign_tests2.2\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.2\n";
     {
         test::check_instances check_;
 
@@ -150,7 +148,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
         BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
-    std::cerr << "assign_tests2.3\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.3\n";
     {
         test::check_instances check_;
 
@@ -172,7 +170,7 @@ template <class T> void assign_tests2(T*, test::random_generator generator)
         BOOST_TEST(x2.load_factor() <= x2.max_load_factor());
     }
 
-    std::cerr << "assign_tests2.4\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "assign_tests2.4\n";
     {
         test::check_instances check_;
 
@@ -271,7 +269,7 @@ UNORDERED_TEST(
 
 UNORDERED_AUTO_TEST(assign_default_initializer_list)
 {
-    std::cerr << "Initializer List Tests\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
     std::initializer_list<std::pair<int const, int> > init;
     boost::unordered_map<int, int> x1;
     x1[25] = 3;
@@ -286,7 +284,7 @@ UNORDERED_AUTO_TEST(assign_default_initializer_list)
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 UNORDERED_AUTO_TEST(assign_initializer_list)
 {
-    std::cerr << "Initializer List Tests\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer List Tests\n";
 
     boost::unordered_set<int> x;
     x.insert(10);
diff --git a/test/unordered/bucket_tests.cpp b/test/unordered/bucket_tests.cpp
index 280c013e..9cb5bdd4 100644
--- a/test/unordered/bucket_tests.cpp
+++ b/test/unordered/bucket_tests.cpp
@@ -37,7 +37,8 @@ template <class X> void tests(X*, test::random_generator generator)
 
     BOOST_TEST(x.bucket_count() <= x.max_bucket_count());
     if (!(x.bucket_count() <= x.max_bucket_count())) {
-        std::cerr << x.bucket_count() << "<=" << x.max_bucket_count() << "\n";
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << x.bucket_count()
+                                       << "<=" << x.max_bucket_count() << "\n";
     }
 
     for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
diff --git a/test/unordered/compile_map.cpp b/test/unordered/compile_map.cpp
index 6293dfb8..863b56c1 100644
--- a/test/unordered/compile_map.cpp
+++ b/test/unordered/compile_map.cpp
@@ -12,7 +12,6 @@
 #include "../helpers/postfix.hpp"
 // clang-format on
 
-#include <iostream>
 #include "../helpers/test.hpp"
 #include "../objects/minimal.hpp"
 #include "./compile_tests.hpp"
@@ -46,7 +45,7 @@ UNORDERED_AUTO_TEST(test0)
         value_type;
     value_type value(x, x);
 
-    std::cout << "Test unordered_map.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
 
     boost::unordered_map<int, int> int_map;
 
@@ -64,7 +63,7 @@ UNORDERED_AUTO_TEST(test0)
     container_test(int_map2, std::pair<int const, int>(0, 0));
     container_test(map, value);
 
-    std::cout << "Test unordered_multimap.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
 
     boost::unordered_multimap<int, int> int_multimap;
 
@@ -139,7 +138,7 @@ UNORDERED_AUTO_TEST(test1)
     int value = 0;
     std::pair<int const, int> map_value(0, 0);
 
-    std::cout << "Test unordered_map.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
 
     boost::unordered_map<int, int> map;
 
@@ -157,7 +156,7 @@ UNORDERED_AUTO_TEST(test1)
     unordered_copyable_test(map2, value, map_value, hash, equal_to);
     unordered_map_functions(map2, value, value);
 
-    std::cout << "Test unordered_multimap.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
 
     boost::unordered_multimap<int, int> multimap;
 
@@ -188,7 +187,7 @@ UNORDERED_AUTO_TEST(test2)
         map_value_type;
     map_value_type map_value(assignable, assignable);
 
-    std::cout << "Test unordered_map.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
 
     boost::unordered_map<test::minimal::assignable, test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
@@ -212,7 +211,7 @@ UNORDERED_AUTO_TEST(test2)
 
     unordered_map_functions(map2, assignable, default_assignable);
 
-    std::cout << "Test unordered_multimap.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
 
     boost::unordered_multimap<test::minimal::assignable,
         test::minimal::assignable,
diff --git a/test/unordered/compile_set.cpp b/test/unordered/compile_set.cpp
index e0a07737..9ea71f73 100644
--- a/test/unordered/compile_set.cpp
+++ b/test/unordered/compile_set.cpp
@@ -12,7 +12,6 @@
 #include "../helpers/postfix.hpp"
 // clang-format on
 
-#include <iostream>
 #include "../helpers/test.hpp"
 #include "../objects/minimal.hpp"
 #include "./compile_tests.hpp"
@@ -42,7 +41,7 @@ UNORDERED_AUTO_TEST(test0)
 
     test::minimal::assignable assignable(x);
 
-    std::cout << "Test unordered_set.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
     boost::unordered_set<int> int_set;
 
@@ -60,7 +59,7 @@ UNORDERED_AUTO_TEST(test0)
     container_test(int_set2, 0);
     container_test(set, assignable);
 
-    std::cout << "Test unordered_multiset.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
     boost::unordered_multiset<int> int_multiset;
 
@@ -128,7 +127,7 @@ UNORDERED_AUTO_TEST(test1)
     std::equal_to<int> equal_to;
     int value = 0;
 
-    std::cout << "Test unordered_set." << std::endl;
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set." << std::endl;
 
     boost::unordered_set<int> set;
 
@@ -144,7 +143,7 @@ UNORDERED_AUTO_TEST(test1)
     unordered_set_test(set2, value);
     unordered_copyable_test(set2, value, value, hash, equal_to);
 
-    std::cout << "Test unordered_multiset." << std::endl;
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset." << std::endl;
 
     boost::unordered_multiset<int> multiset;
 
@@ -170,7 +169,7 @@ UNORDERED_AUTO_TEST(test2)
     test::minimal::hash<test::minimal::assignable> hash(x);
     test::minimal::equal_to<test::minimal::assignable> equal_to(x);
 
-    std::cout << "Test unordered_set.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
     boost::unordered_set<test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
@@ -183,7 +182,7 @@ UNORDERED_AUTO_TEST(test2)
     unordered_copyable_test(set, assignable, assignable, hash, equal_to);
     unordered_set_member_test(set, assignable);
 
-    std::cout << "Test unordered_multiset.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
     boost::unordered_multiset<test::minimal::assignable,
         test::minimal::hash<test::minimal::assignable>,
@@ -205,7 +204,7 @@ UNORDERED_AUTO_TEST(movable1_tests)
     test::minimal::hash<test::minimal::movable1> hash(x);
     test::minimal::equal_to<test::minimal::movable1> equal_to(x);
 
-    std::cout << "Test unordered_set.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
     boost::unordered_set<test::minimal::movable1,
         test::minimal::hash<test::minimal::movable1>,
@@ -217,7 +216,7 @@ UNORDERED_AUTO_TEST(movable1_tests)
     unordered_set_test(set, movable1);
     unordered_movable_test(set, movable1, movable1, hash, equal_to);
 
-    std::cout << "Test unordered_multiset.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
     boost::unordered_multiset<test::minimal::movable1,
         test::minimal::hash<test::minimal::movable1>,
@@ -238,7 +237,7 @@ UNORDERED_AUTO_TEST(movable2_tests)
     test::minimal::hash<test::minimal::movable2> hash(x);
     test::minimal::equal_to<test::minimal::movable2> equal_to(x);
 
-    std::cout << "Test unordered_set.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
     boost::unordered_set<test::minimal::movable2,
         test::minimal::hash<test::minimal::movable2>,
@@ -250,7 +249,7 @@ UNORDERED_AUTO_TEST(movable2_tests)
     unordered_set_test(set, movable2);
     unordered_movable_test(set, movable2, movable2, hash, equal_to);
 
-    std::cout << "Test unordered_multiset.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
     boost::unordered_multiset<test::minimal::movable2,
         test::minimal::hash<test::minimal::movable2>,
@@ -271,7 +270,7 @@ UNORDERED_AUTO_TEST(destructible_tests)
     test::minimal::hash<test::minimal::destructible> hash(x);
     test::minimal::equal_to<test::minimal::destructible> equal_to(x);
 
-    std::cout << "Test unordered_set.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
     boost::unordered_set<test::minimal::destructible,
         test::minimal::hash<test::minimal::destructible>,
@@ -280,7 +279,7 @@ UNORDERED_AUTO_TEST(destructible_tests)
 
     unordered_destructible_test(set);
 
-    std::cout << "Test unordered_multiset.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
     boost::unordered_multiset<test::minimal::destructible,
         test::minimal::hash<test::minimal::destructible>,
diff --git a/test/unordered/constructor_tests.cpp b/test/unordered/constructor_tests.cpp
index 25901353..a12d57ef 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;
 
-    std::cerr << "Construct 1\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 1\n";
     {
         test::check_instances check_;
 
@@ -40,7 +40,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "Construct 2\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 2\n";
     {
         test::check_instances check_;
 
@@ -53,7 +53,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "Construct 3\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 3\n";
     {
         test::check_instances check_;
 
@@ -66,7 +66,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "Construct 4\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 4\n";
     {
         test::check_instances check_;
 
@@ -78,7 +78,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "Construct 5\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 5\n";
     {
         test::check_instances check_;
 
@@ -92,7 +92,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "Construct 6\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 6\n";
     {
         test::check_instances check_;
 
@@ -106,7 +106,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "Construct 7\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 7\n";
     {
         test::check_instances check_;
 
@@ -120,7 +120,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "Construct 8\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 8\n";
     {
         test::check_instances check_;
 
@@ -133,7 +133,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "Construct 9\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 9\n";
     {
         test::check_instances check_;
 
@@ -145,7 +145,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "Construct 10\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 10\n";
     {
         test::check_instances check_;
 
@@ -159,7 +159,7 @@ template <class T> void constructor_tests1(T*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "Construct 11\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 11\n";
     {
         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);
 
-    std::cerr << "Construct 1\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 1\n";
     {
         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);
     }
 
-    std::cerr << "Construct 2\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 2\n";
     {
         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);
     }
 
-    std::cerr << "Construct 3\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 3\n";
     {
         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);
     }
 
-    std::cerr << "Construct 4\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 4\n";
     {
         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);
     }
 
-    std::cerr << "Construct 5\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 5\n";
     {
         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);
     }
 
-    std::cerr << "Construct 6\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 6\n";
     {
         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);
     }
 
-    std::cerr << "Construct 7\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 7\n";
     {
         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);
     }
 
-    std::cerr << "Construct 8 - from input iterator\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 8 - from input iterator\n";
     {
         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);
     }
 
-    std::cerr << "Construct 8.5 - from copy iterator\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 8.5 - from copy iterator\n";
     {
         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);
     }
 
-    std::cerr << "Construct 9\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Construct 9\n";
     {
         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;
 
-    std::cerr << "Initializer list construct 1\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 1\n";
     {
         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));
     }
 
-    std::cerr << "Initializer list construct 2\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 2\n";
     {
         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));
     }
 
-    std::cerr << "Initializer list construct 3\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 3\n";
     {
         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));
     }
 
-    std::cerr << "Initializer list construct 4\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 4\n";
     {
         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));
     }
 
-    std::cerr << "Initializer list construct 5\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Initializer list construct 5\n";
     {
         test::check_instances check_;
 
@@ -384,7 +384,7 @@ void constructor_tests2(T*, test::random_generator const& generator)
 template <class T>
 void map_constructor_test(T*, test::random_generator const& generator)
 {
-    std::cerr << "map_constructor_test\n";
+    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> >
@@ -429,7 +429,7 @@ UNORDERED_TEST(map_constructor_test,
 
 UNORDERED_AUTO_TEST(test_default_initializer_list)
 {
-    std::cerr << "Initializer List Tests\n";
+    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 +441,7 @@ UNORDERED_AUTO_TEST(test_default_initializer_list)
 
 UNORDERED_AUTO_TEST(test_initializer_list)
 {
-    std::cerr << "Initializer List Tests\n";
+    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());
diff --git a/test/unordered/detail_tests.cpp b/test/unordered/detail_tests.cpp
index b87bf943..2af4c4fb 100644
--- a/test/unordered/detail_tests.cpp
+++ b/test/unordered/detail_tests.cpp
@@ -3,8 +3,6 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <iostream>
-
 // clang-format off
 #include "../helpers/prefix.hpp"
 #include <boost/unordered_map.hpp>
diff --git a/test/unordered/equivalent_keys_tests.cpp b/test/unordered/equivalent_keys_tests.cpp
index 72ab057e..8e48d68c 100644
--- a/test/unordered/equivalent_keys_tests.cpp
+++ b/test/unordered/equivalent_keys_tests.cpp
@@ -17,8 +17,6 @@
 #include "../helpers/tracker.hpp"
 #include "../helpers/invariants.hpp"
 
-#include <iostream>
-
 template <class Container, class Iterator>
 void test_equal_insertion(Iterator begin, Iterator end)
 {
diff --git a/test/unordered/erase_equiv_tests.cpp b/test/unordered/erase_equiv_tests.cpp
index 1907ddd1..64510394 100644
--- a/test/unordered/erase_equiv_tests.cpp
+++ b/test/unordered/erase_equiv_tests.cpp
@@ -17,7 +17,6 @@
 #include "../helpers/invariants.hpp"
 #include "../helpers/helpers.hpp"
 #include <set>
-#include <iostream>
 #include <iterator>
 #include "../objects/test.hpp"
 
@@ -31,14 +30,15 @@ struct write_pair_type
     template <class X1, class X2>
     void operator()(std::pair<X1, X2> const& x) const
     {
-        std::cout << "(" << x.first << "," << x.second << ")";
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "(" << x.first << "," << x.second
+                                       << ")";
     }
 } write_pair;
 
 template <class Container> void write_container(Container const& x)
 {
     std::for_each(x.begin(), x.end(), write_pair);
-    std::cout << "\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
 }
 
 // Make everything collide - for testing erase in a single bucket.
@@ -165,8 +165,8 @@ template <class Container> void erase_subrange_tests(Container const& x)
             collide_list init(y.begin(), y.end());
             if (!general_erase_range_test(y, position, position + length)) {
                 BOOST_ERROR("general_erase_range_test failed.");
-                std::cout << "Erase: [" << position << "," << position + length
-                          << ")\n";
+                BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Erase: [" << position << ","
+                                               << position + length << ")\n";
                 write_container(init);
                 write_container(y);
             }
@@ -185,7 +185,8 @@ void x_by_y_erase_range_tests(Container*, int values, int duplicates)
         }
     }
 
-    std::cout << "Values: " << values << ", Duplicates: " << duplicates << "\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Values: " << values
+                                   << ", Duplicates: " << duplicates << "\n";
     erase_subrange_tests(y);
 }
 
@@ -201,24 +202,24 @@ void exhaustive_erase_tests(Container* x, int num_values, int num_duplicated)
 
 UNORDERED_AUTO_TEST(exhaustive_collide_tests)
 {
-    std::cout << "exhaustive_collide_tests:\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide_tests:\n";
     collide_map m;
     exhaustive_erase_tests((collide_map*)0, 4, 4);
-    std::cout << "\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
 }
 
 UNORDERED_AUTO_TEST(exhaustive_collide2_tests)
 {
-    std::cout << "exhaustive_collide2_tests:\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide2_tests:\n";
     exhaustive_erase_tests((collide_map2*)0, 8, 4);
-    std::cout << "\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
 }
 
 UNORDERED_AUTO_TEST(exhaustive_collide3_tests)
 {
-    std::cout << "exhaustive_collide3_tests:\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "exhaustive_collide3_tests:\n";
     exhaustive_erase_tests((collide_map3*)0, 8, 4);
-    std::cout << "\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
 }
 
 RUN_TESTS()
diff --git a/test/unordered/erase_tests.cpp b/test/unordered/erase_tests.cpp
index c763c66f..843e64f2 100644
--- a/test/unordered/erase_tests.cpp
+++ b/test/unordered/erase_tests.cpp
@@ -18,7 +18,6 @@
 #include "../helpers/helpers.hpp"
 #include "../helpers/invariants.hpp"
 #include <vector>
-#include <iostream>
 #include <cstdlib>
 
 namespace erase_tests {
@@ -31,7 +30,7 @@ void erase_tests1(Container*, test::random_generator generator)
     typedef BOOST_DEDUCED_TYPENAME Container::iterator iterator;
     typedef BOOST_DEDUCED_TYPENAME Container::const_iterator c_iterator;
 
-    std::cerr << "Erase by key.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Erase by key.\n";
     {
         test::check_instances check_;
 
@@ -52,7 +51,7 @@ void erase_tests1(Container*, test::random_generator generator)
         }
     }
 
-    std::cerr << "erase(begin()).\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(begin()).\n";
     {
         test::check_instances check_;
 
@@ -75,7 +74,7 @@ void erase_tests1(Container*, test::random_generator generator)
         BOOST_TEST(x.empty());
     }
 
-    std::cerr << "erase(random position).\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(random position).\n";
     {
         test::check_instances check_;
 
@@ -104,7 +103,8 @@ void erase_tests1(Container*, test::random_generator generator)
                     index == 0 ? next == x.begin() : next == test::next(prev));
             BOOST_TEST(x.count(key) == count - 1);
             if (x.count(key) != count - 1) {
-                std::cerr << count << " => " << x.count(key) << std::endl;
+                BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => "
+                                               << x.count(key) << std::endl;
             }
             BOOST_TEST(x.size() == size);
             if (++iterations % 20 == 0)
@@ -113,7 +113,7 @@ void erase_tests1(Container*, test::random_generator generator)
         BOOST_TEST(x.empty());
     }
 
-    std::cerr << "erase(ranges).\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(ranges).\n";
     {
         test::check_instances check_;
 
@@ -140,7 +140,7 @@ void erase_tests1(Container*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "erase(random ranges).\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "erase(random ranges).\n";
     {
         test::check_instances check_;
         Container x;
@@ -179,7 +179,7 @@ void erase_tests1(Container*, test::random_generator generator)
         }
     }
 
-    std::cerr << "quick_erase(begin()).\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "quick_erase(begin()).\n";
     {
         test::check_instances check_;
 
@@ -201,7 +201,7 @@ void erase_tests1(Container*, test::random_generator generator)
         BOOST_TEST(x.empty());
     }
 
-    std::cerr << "quick_erase(random position).\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "quick_erase(random position).\n";
     {
         test::check_instances check_;
 
@@ -230,7 +230,8 @@ void erase_tests1(Container*, test::random_generator generator)
                     index == 0 ? next == x.begin() : next == test::next(prev));
             BOOST_TEST(x.count(key) == count - 1);
             if (x.count(key) != count - 1) {
-                std::cerr << count << " => " << x.count(key) << std::endl;
+                BOOST_LIGHTWEIGHT_TEST_OSTREAM << count << " => "
+                                               << x.count(key) << std::endl;
             }
             BOOST_TEST(x.size() == size);
             if (++iterations % 20 == 0)
@@ -239,7 +240,7 @@ void erase_tests1(Container*, test::random_generator generator)
         BOOST_TEST(x.empty());
     }
 
-    std::cerr << "clear().\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "clear().\n";
     {
         test::check_instances check_;
 
@@ -250,7 +251,7 @@ void erase_tests1(Container*, test::random_generator generator)
         BOOST_TEST(x.begin() == x.end());
     }
 
-    std::cerr << "\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
 }
 
 boost::unordered_set<test::object, test::hash, test::equal_to,
diff --git a/test/unordered/extract_tests.cpp b/test/unordered/extract_tests.cpp
index 8e792793..b4f1e801 100644
--- a/test/unordered/extract_tests.cpp
+++ b/test/unordered/extract_tests.cpp
@@ -19,8 +19,6 @@
 #include "../objects/test.hpp"
 #include <boost/next_prior.hpp>
 
-#include <iostream>
-
 namespace extract_tests {
 
 test::seed_t initialize_seed(85638);
@@ -28,7 +26,7 @@ test::seed_t initialize_seed(85638);
 template <class Container>
 void extract_tests1(Container*, test::random_generator generator)
 {
-    std::cerr << "Extract by key.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Extract by key.\n";
     {
         test::check_instances check_;
 
@@ -58,7 +56,7 @@ void extract_tests1(Container*, test::random_generator generator)
         BOOST_TEST(x.empty());
     }
 
-    std::cerr << "extract(begin()).\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "extract(begin()).\n";
     {
         test::check_instances check_;
 
@@ -81,7 +79,7 @@ void extract_tests1(Container*, test::random_generator generator)
         BOOST_TEST(x.empty());
     }
 
-    std::cerr << "extract(random position).\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "extract(random position).\n";
     {
         test::check_instances check_;
 
@@ -117,7 +115,7 @@ void extract_tests1(Container*, test::random_generator generator)
         BOOST_TEST(x.empty());
     }
 
-    std::cerr << "\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
 }
 
 boost::unordered_set<test::object, test::hash, test::equal_to,
diff --git a/test/unordered/insert_hint_tests.cpp b/test/unordered/insert_hint_tests.cpp
index ea9c9b8e..5b4268bb 100644
--- a/test/unordered/insert_hint_tests.cpp
+++ b/test/unordered/insert_hint_tests.cpp
@@ -15,7 +15,6 @@
 
 #include <map>
 #include <set>
-#include <iostream>
 
 namespace insert_hint {
 UNORDERED_AUTO_TEST(insert_hint_empty)
diff --git a/test/unordered/insert_stable_tests.cpp b/test/unordered/insert_stable_tests.cpp
index afba2239..9915c10b 100644
--- a/test/unordered/insert_stable_tests.cpp
+++ b/test/unordered/insert_stable_tests.cpp
@@ -12,8 +12,6 @@
 
 #include "../helpers/test.hpp"
 
-#include <iostream>
-
 namespace insert_stable {
 struct member
 {
diff --git a/test/unordered/insert_tests.cpp b/test/unordered/insert_tests.cpp
index fd7b461d..fb4f78d9 100644
--- a/test/unordered/insert_tests.cpp
+++ b/test/unordered/insert_tests.cpp
@@ -21,8 +21,6 @@
 #include "../helpers/input_iterator.hpp"
 #include "../helpers/helpers.hpp"
 
-#include <iostream>
-
 namespace insert_tests {
 
 test::seed_t initialize_seed(243432);
@@ -35,7 +33,8 @@ void unique_insert_tests1(X*, test::random_generator generator)
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
 
-    std::cerr << "insert(value) tests for containers with unique keys.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+        << "insert(value) tests for containers with unique keys.\n";
 
     {
         X x;
@@ -68,7 +67,8 @@ void unique_insert_tests1(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert(rvalue) tests for containers with unique keys.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+        << "insert(rvalue) tests for containers with unique keys.\n";
 
     {
         X x;
@@ -108,7 +108,8 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
 {
     test::check_instances check_;
 
-    std::cerr << "insert(value) tests for containers with equivalent keys.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+        << "insert(value) tests for containers with equivalent keys.\n";
 
     {
         X x;
@@ -138,7 +139,8 @@ void equivalent_insert_tests1(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert(rvalue) tests for containers with equivalent keys.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+        << "insert(rvalue) tests for containers with equivalent keys.\n";
 
     {
         X x;
@@ -178,7 +180,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;
 
-    std::cerr << "insert(begin(), value) tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(begin(), value) tests.\n";
 
     {
         test::check_instances check_;
@@ -208,7 +210,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert(end(), value) tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(end(), value) tests.\n";
 
     {
         test::check_instances check_;
@@ -239,7 +241,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert(pos, value) tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(pos, value) tests.\n";
 
     {
         test::check_instances check_;
@@ -270,7 +272,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert(pos, rvalue) tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert(pos, rvalue) tests.\n";
 
     {
         test::check_instances check_;
@@ -302,7 +304,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert single item range tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert single item range tests.\n";
 
     {
         test::check_instances check_;
@@ -331,7 +333,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert range tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert range tests.\n";
 
     {
         test::check_instances check_;
@@ -345,7 +347,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert range with rehash tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert range with rehash tests.\n";
 
     {
         test::check_instances check_;
@@ -363,7 +365,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert input iterator range tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert input iterator range tests.\n";
 
     {
         test::check_instances check_;
@@ -380,7 +382,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert copy iterator range tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert copy iterator range tests.\n";
 
     {
         test::check_instances check_;
@@ -394,7 +396,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert copy iterator range test 2.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert copy iterator range test 2.\n";
 
     {
         test::check_instances check_;
@@ -411,7 +413,7 @@ template <class X> void insert_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert various ranges.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert various ranges.\n";
 
     {
         for (int i = 0; i < 100; ++i) {
@@ -458,7 +460,8 @@ void unique_emplace_tests1(X*, test::random_generator generator)
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
 
-    std::cerr << "emplace(value) tests for containers with unique keys.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+        << "emplace(value) tests for containers with unique keys.\n";
 
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
@@ -492,7 +495,8 @@ void unique_emplace_tests1(X*, test::random_generator generator)
 template <class X>
 void equivalent_emplace_tests1(X*, test::random_generator generator)
 {
-    std::cerr << "emplace(value) tests for containers with equivalent keys.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+        << "emplace(value) tests for containers with equivalent keys.\n";
 
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
@@ -522,7 +526,7 @@ void equivalent_emplace_tests1(X*, test::random_generator generator)
 
 template <class X> void move_emplace_tests(X*, test::random_generator generator)
 {
-    std::cerr
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
         << "emplace(move(value)) tests for containers with unique keys.\n";
 
     X x;
@@ -553,7 +557,7 @@ 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))
-    std::cerr << "emplace() tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "emplace() tests.\n";
     bool is_unique = test::has_unique_keys<X>::value;
 
     X x;
@@ -588,7 +592,7 @@ template <class X> void default_emplace_tests(X*, test::random_generator)
 
 template <class X> void map_tests(X*, test::random_generator generator)
 {
-    std::cerr << "map tests.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map tests.\n";
 
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
@@ -616,7 +620,7 @@ 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;
-    std::cerr << "insert_or_assign\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign\n";
 
     {
         test::check_instances check_;
@@ -648,7 +652,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert_or_assign(begin)\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign(begin)\n";
 
     {
         test::check_instances check_;
@@ -679,7 +683,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert_or_assign(end)\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign(end)\n";
 
     {
         test::check_instances check_;
@@ -710,7 +714,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "insert_or_assign(last)\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "insert_or_assign(last)\n";
 
     {
         test::check_instances check_;
@@ -747,7 +751,7 @@ template <class X> void map_tests2(X*, test::random_generator generator)
 
 template <class X> void try_emplace_tests(X*, test::random_generator generator)
 {
-    std::cerr << "try_emplace(key, value)\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(key, value)\n";
 
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
@@ -790,7 +794,7 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "try_emplace(begin(), key, value)\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(begin(), key, value)\n";
 
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
@@ -830,7 +834,7 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "try_emplace(end(), key, value)\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(end(), key, value)\n";
 
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
@@ -870,7 +874,7 @@ template <class X> void try_emplace_tests(X*, test::random_generator generator)
         test::check_equivalent_keys(x);
     }
 
-    std::cerr << "try_emplace(pos, key, value)\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "try_emplace(pos, key, value)\n";
 
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
@@ -916,7 +920,7 @@ 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)
 {
-    std::cerr << "map_insert_range_test1\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map_insert_range_test1\n";
 
     test::check_instances check_;
 
@@ -935,7 +939,7 @@ void map_insert_range_test1(X*, test::random_generator generator)
 template <class X>
 void map_insert_range_test2(X*, test::random_generator generator)
 {
-    std::cerr << "map_insert_range_test2\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "map_insert_range_test2\n";
 
     test::check_instances check_;
 
@@ -1391,7 +1395,6 @@ UNORDERED_AUTO_TEST(set_emplace_test2)
 #include "./insert_tests.cpp"
 
 #endif
-
 }
 
 RUN_TESTS()
diff --git a/test/unordered/noexcept_tests.cpp b/test/unordered/noexcept_tests.cpp
index cadf8b70..d801ae1c 100644
--- a/test/unordered/noexcept_tests.cpp
+++ b/test/unordered/noexcept_tests.cpp
@@ -36,7 +36,8 @@ bool throwing_test_exception = false;
 void test_throw(char const* name)
 {
     if (throwing_test_exception) {
-        std::cerr << "Throw exception in: " << name << std::endl;
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Throw exception in: " << name
+                                       << std::endl;
         throw test_exception();
     }
 }
diff --git a/test/unordered/simple_tests.cpp b/test/unordered/simple_tests.cpp
index 05d5523d..40ba5fc3 100644
--- a/test/unordered/simple_tests.cpp
+++ b/test/unordered/simple_tests.cpp
@@ -93,7 +93,7 @@ UNORDERED_AUTO_TEST(simple_tests)
     using namespace std;
     srand(14878);
 
-    std::cout << "Test unordered_set.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
     boost::unordered_set<int> set;
     simple_test(set);
 
@@ -102,7 +102,7 @@ UNORDERED_AUTO_TEST(simple_tests)
     set.insert(1456);
     simple_test(set);
 
-    std::cout << "Test unordered_multiset.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
     boost::unordered_multiset<int> multiset;
     simple_test(multiset);
 
@@ -113,7 +113,7 @@ UNORDERED_AUTO_TEST(simple_tests)
     }
     simple_test(multiset);
 
-    std::cout << "Test unordered_map.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
     boost::unordered_map<int, int> map;
 
     for (int i2 = 0; i2 < 1000; ++i2) {
@@ -121,7 +121,7 @@ UNORDERED_AUTO_TEST(simple_tests)
     }
     simple_test(map);
 
-    std::cout << "Test unordered_multimap.\n";
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
     boost::unordered_multimap<int, int> multimap;
 
     for (int i3 = 0; i3 < 1000; ++i3) {
diff --git a/test/unordered/unnecessary_copy_tests.cpp b/test/unordered/unnecessary_copy_tests.cpp
index 3a5424bb..0322eade 100644
--- a/test/unordered/unnecessary_copy_tests.cpp
+++ b/test/unordered/unnecessary_copy_tests.cpp
@@ -10,7 +10,6 @@
 #include "../helpers/postfix.hpp"
 // clang-format on
 
-#include <iostream>
 #include "../helpers/test.hpp"
 
 namespace unnecessary_copy_tests {
@@ -138,32 +137,36 @@ std::size_t hash_value(unnecessary_copy_tests::count_copies const& x)
 #define COPY_COUNT(n)                                                          \
     if (::unnecessary_copy_tests::count_copies::copies != n) {                 \
         BOOST_ERROR("Wrong number of copies.");                                \
-        std::cerr << "Number of copies: "                                      \
-                  << ::unnecessary_copy_tests::count_copies::copies            \
-                  << " expecting: " << n << std::endl;                         \
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM                                         \
+            << "Number of copies: "                                            \
+            << ::unnecessary_copy_tests::count_copies::copies                  \
+            << " expecting: " << n << std::endl;                               \
     }
 #define MOVE_COUNT(n)                                                          \
     if (::unnecessary_copy_tests::count_copies::moves != n) {                  \
         BOOST_ERROR("Wrong number of moves.");                                 \
-        std::cerr << "Number of moves: "                                       \
-                  << ::unnecessary_copy_tests::count_copies::moves             \
-                  << " expecting: " << n << std::endl;                         \
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM                                         \
+            << "Number of moves: "                                             \
+            << ::unnecessary_copy_tests::count_copies::moves                   \
+            << " expecting: " << n << std::endl;                               \
     }
 #define COPY_COUNT_RANGE(a, b)                                                 \
     if (::unnecessary_copy_tests::count_copies::copies < a ||                  \
         ::unnecessary_copy_tests::count_copies::copies > b) {                  \
         BOOST_ERROR("Wrong number of copies.");                                \
-        std::cerr << "Number of copies: "                                      \
-                  << ::unnecessary_copy_tests::count_copies::copies            \
-                  << " expecting: [" << a << ", " << b << "]" << std::endl;    \
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM                                         \
+            << "Number of copies: "                                            \
+            << ::unnecessary_copy_tests::count_copies::copies                  \
+            << " expecting: [" << a << ", " << b << "]" << std::endl;          \
     }
 #define MOVE_COUNT_RANGE(a, b)                                                 \
     if (::unnecessary_copy_tests::count_copies::moves < a ||                   \
         ::unnecessary_copy_tests::count_copies::moves > b) {                   \
         BOOST_ERROR("Wrong number of moves.");                                 \
-        std::cerr << "Number of moves: "                                       \
-                  << ::unnecessary_copy_tests::count_copies::moves             \
-                  << " expecting: [" << a << ", " << b << "]" << std::endl;    \
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM                                         \
+            << "Number of moves: "                                             \
+            << ::unnecessary_copy_tests::count_copies::moves                   \
+            << " expecting: [" << a << ", " << b << "]" << std::endl;          \
     }
 #define COPY_COUNT_EXTRA(a, b) COPY_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)
 #define MOVE_COUNT_EXTRA(a, b) MOVE_COUNT_RANGE(a, a + b * EXTRA_CONSTRUCT_COST)