diff --git a/test/src/unit.cpp b/test/src/unit.cpp
index 3b8909ac..a12f0529 100644
--- a/test/src/unit.cpp
+++ b/test/src/unit.cpp
@@ -10309,252 +10309,261 @@ TEST_CASE("parser class")
 TEST_CASE("README", "[hide]")
 {
     {
-        // create an empty structure (null)
-        json j;
-
-        // add a number that is stored as double (note the implicit conversion of j to an object)
-        j["pi"] = 3.141;
-
-        // add a Boolean that is stored as bool
-        j["happy"] = true;
-
-        // add a string that is stored as std::string
-        j["name"] = "Niels";
-
-        // add another null object by passing nullptr
-        j["nothing"] = nullptr;
-
-        // add an object inside the object
-        j["answer"]["everything"] = 42;
-
-        // add an array that is stored as std::vector (using an initializer list)
-        j["list"] = { 1, 0, 2 };
-
-        // add another object (using an initializer list of pairs)
-        j["object"] = { {"currency", "USD"}, {"value", 42.99} };
-
-        // instead, you could also write (which looks very similar to the JSON above)
-        json j2 =
+        // redirect std::cout for the README file
+        auto old_cout_buffer = std::cout.rdbuf();
+        std::ostringstream new_stream;
+        std::cout.rdbuf(new_stream.rdbuf());
         {
-            {"pi", 3.141},
-            {"happy", true},
-            {"name", "Niels"},
-            {"nothing", nullptr},
+            // create an empty structure (null)
+            json j;
+
+            // add a number that is stored as double (note the implicit conversion of j to an object)
+            j["pi"] = 3.141;
+
+            // add a Boolean that is stored as bool
+            j["happy"] = true;
+
+            // add a string that is stored as std::string
+            j["name"] = "Niels";
+
+            // add another null object by passing nullptr
+            j["nothing"] = nullptr;
+
+            // add an object inside the object
+            j["answer"]["everything"] = 42;
+
+            // add an array that is stored as std::vector (using an initializer list)
+            j["list"] = { 1, 0, 2 };
+
+            // add another object (using an initializer list of pairs)
+            j["object"] = { {"currency", "USD"}, {"value", 42.99} };
+
+            // instead, you could also write (which looks very similar to the JSON above)
+            json j2 =
             {
-                "answer", {
-                    {"everything", 42}
+                {"pi", 3.141},
+                {"happy", true},
+                {"name", "Niels"},
+                {"nothing", nullptr},
+                {
+                    "answer", {
+                        {"everything", 42}
+                    }
+                },
+                {"list", {1, 0, 2}},
+                {
+                    "object", {
+                        {"currency", "USD"},
+                        {"value", 42.99}
+                    }
                 }
-            },
-            {"list", {1, 0, 2}},
-            {
-                "object", {
-                    {"currency", "USD"},
-                    {"value", 42.99}
-                }
-            }
-        };
-    }
+            };
+        }
 
-    {
-        // ways to express the empty array []
-        json empty_array_implicit = {{}};
-        json empty_array_explicit = json::array();
+        {
+            // ways to express the empty array []
+            json empty_array_implicit = {{}};
+            json empty_array_explicit = json::array();
 
-        // a way to express the empty object {}
-        json empty_object_explicit = json::object();
+            // a way to express the empty object {}
+            json empty_object_explicit = json::object();
 
-        // a way to express an _array_ of key/value pairs [["currency", "USD"], ["value", 42.99]]
-        json array_not_object = { json::array({"currency", "USD"}), json::array({"value", 42.99}) };
-    }
+            // a way to express an _array_ of key/value pairs [["currency", "USD"], ["value", 42.99]]
+            json array_not_object = { json::array({"currency", "USD"}), json::array({"value", 42.99}) };
+        }
 
-    {
-        // create object from string literal
-        json j = "{ \"happy\": true, \"pi\": 3.141 }"_json;
+        {
+            // create object from string literal
+            json j = "{ \"happy\": true, \"pi\": 3.141 }"_json;
 
-        // or even nicer with a raw string literal
-        auto j2 = R"(
+            // or even nicer with a raw string literal
+            auto j2 = R"(
           {
             "happy": true,
             "pi": 3.141
           }
         )"_json;
 
-        // or explicitly
-        auto j3 = json::parse("{ \"happy\": true, \"pi\": 3.141 }");
+            // or explicitly
+            auto j3 = json::parse("{ \"happy\": true, \"pi\": 3.141 }");
 
-        // explicit conversion to string
-        std::string s = j.dump();    // {\"happy\":true,\"pi\":3.141}
+            // explicit conversion to string
+            std::string s = j.dump();    // {\"happy\":true,\"pi\":3.141}
 
-        // serialization with pretty printing
-        // pass in the amount of spaces to indent
-        std::cout << j.dump(4) << std::endl;
-        // {
-        //     "happy": true,
-        //     "pi": 3.141
-        // }
+            // serialization with pretty printing
+            // pass in the amount of spaces to indent
+            std::cout << j.dump(4) << std::endl;
+            // {
+            //     "happy": true,
+            //     "pi": 3.141
+            // }
 
-        std::cout << std::setw(2) << j << std::endl;
-    }
-
-    {
-        // create an array using push_back
-        json j;
-        j.push_back("foo");
-        j.push_back(1);
-        j.push_back(true);
-
-        // iterate the array
-        for (json::iterator it = j.begin(); it != j.end(); ++it)
-        {
-            std::cout << *it << '\n';
+            std::cout << std::setw(2) << j << std::endl;
         }
 
-        // range-based for
-        for (auto element : j)
         {
-            std::cout << element << '\n';
+            // create an array using push_back
+            json j;
+            j.push_back("foo");
+            j.push_back(1);
+            j.push_back(true);
+
+            // iterate the array
+            for (json::iterator it = j.begin(); it != j.end(); ++it)
+            {
+                std::cout << *it << '\n';
+            }
+
+            // range-based for
+            for (auto element : j)
+            {
+                std::cout << element << '\n';
+            }
+
+            // getter/setter
+            const std::string tmp = j[0];
+            j[1] = 42;
+            bool foo = j.at(2);
+
+            // other stuff
+            j.size();     // 3 entries
+            j.empty();    // false
+            j.type();     // json::value_t::array
+            j.clear();    // the array is empty again
+
+            // comparison
+            j == "[\"foo\", 1, true]"_json;  // true
+
+            // create an object
+            json o;
+            o["foo"] = 23;
+            o["bar"] = false;
+            o["baz"] = 3.141;
+
+            // find an entry
+            if (o.find("foo") != o.end())
+            {
+                // there is an entry with key "foo"
+            }
         }
 
-        // getter/setter
-        const std::string tmp = j[0];
-        j[1] = 42;
-        bool foo = j.at(2);
-
-        // other stuff
-        j.size();     // 3 entries
-        j.empty();    // false
-        j.type();     // json::value_t::array
-        j.clear();    // the array is empty again
-
-        // comparison
-        j == "[\"foo\", 1, true]"_json;  // true
-
-        // create an object
-        json o;
-        o["foo"] = 23;
-        o["bar"] = false;
-        o["baz"] = 3.141;
-
-        // find an entry
-        if (o.find("foo") != o.end())
         {
-            // there is an entry with key "foo"
+            std::vector<int> c_vector {1, 2, 3, 4};
+            json j_vec(c_vector);
+            // [1, 2, 3, 4]
+
+            std::deque<float> c_deque {1.2f, 2.3f, 3.4f, 5.6f};
+            json j_deque(c_deque);
+            // [1.2, 2.3, 3.4, 5.6]
+
+            std::list<bool> c_list {true, true, false, true};
+            json j_list(c_list);
+            // [true, true, false, true]
+
+            std::forward_list<int64_t> c_flist {12345678909876, 23456789098765, 34567890987654, 45678909876543};
+            json j_flist(c_flist);
+            // [12345678909876, 23456789098765, 34567890987654, 45678909876543]
+
+            std::array<unsigned long, 4> c_array {{1, 2, 3, 4}};
+            json j_array(c_array);
+            // [1, 2, 3, 4]
+
+            std::set<std::string> c_set {"one", "two", "three", "four", "one"};
+            json j_set(c_set); // only one entry for "one" is used
+            // ["four", "one", "three", "two"]
+
+            std::unordered_set<std::string> c_uset {"one", "two", "three", "four", "one"};
+            json j_uset(c_uset); // only one entry for "one" is used
+            // maybe ["two", "three", "four", "one"]
+
+            std::multiset<std::string> c_mset {"one", "two", "one", "four"};
+            json j_mset(c_mset); // only one entry for "one" is used
+            // maybe ["one", "two", "four"]
+
+            std::unordered_multiset<std::string> c_umset {"one", "two", "one", "four"};
+            json j_umset(c_umset); // both entries for "one" are used
+            // maybe ["one", "two", "one", "four"]
         }
-    }
 
-    {
-        std::vector<int> c_vector {1, 2, 3, 4};
-        json j_vec(c_vector);
-        // [1, 2, 3, 4]
+        {
+            std::map<std::string, int> c_map { {"one", 1}, {"two", 2}, {"three", 3} };
+            json j_map(c_map);
+            // {"one": 1, "two": 2, "three": 3}
 
-        std::deque<float> c_deque {1.2f, 2.3f, 3.4f, 5.6f};
-        json j_deque(c_deque);
-        // [1.2, 2.3, 3.4, 5.6]
+            std::unordered_map<const char*, float> c_umap { {"one", 1.2f}, {"two", 2.3f}, {"three", 3.4f} };
+            json j_umap(c_umap);
+            // {"one": 1.2, "two": 2.3, "three": 3.4}
 
-        std::list<bool> c_list {true, true, false, true};
-        json j_list(c_list);
-        // [true, true, false, true]
+            std::multimap<std::string, bool> c_mmap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
+            json j_mmap(c_mmap); // only one entry for key "three" is used
+            // maybe {"one": true, "two": true, "three": true}
 
-        std::forward_list<int64_t> c_flist {12345678909876, 23456789098765, 34567890987654, 45678909876543};
-        json j_flist(c_flist);
-        // [12345678909876, 23456789098765, 34567890987654, 45678909876543]
+            std::unordered_multimap<std::string, bool> c_ummap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
+            json j_ummap(c_ummap); // only one entry for key "three" is used
+            // maybe {"one": true, "two": true, "three": true}
+        }
 
-        std::array<unsigned long, 4> c_array {{1, 2, 3, 4}};
-        json j_array(c_array);
-        // [1, 2, 3, 4]
+        {
+            // strings
+            std::string s1 = "Hello, world!";
+            json js = s1;
+            std::string s2 = js;
 
-        std::set<std::string> c_set {"one", "two", "three", "four", "one"};
-        json j_set(c_set); // only one entry for "one" is used
-        // ["four", "one", "three", "two"]
+            // Booleans
+            bool b1 = true;
+            json jb = b1;
+            bool b2 = jb;
 
-        std::unordered_set<std::string> c_uset {"one", "two", "three", "four", "one"};
-        json j_uset(c_uset); // only one entry for "one" is used
-        // maybe ["two", "three", "four", "one"]
+            // numbers
+            int i = 42;
+            json jn = i;
+            double f = jn;
 
-        std::multiset<std::string> c_mset {"one", "two", "one", "four"};
-        json j_mset(c_mset); // only one entry for "one" is used
-        // maybe ["one", "two", "four"]
+            // etc.
 
-        std::unordered_multiset<std::string> c_umset {"one", "two", "one", "four"};
-        json j_umset(c_umset); // both entries for "one" are used
-        // maybe ["one", "two", "one", "four"]
-    }
+            std::string vs = js.get<std::string>();
+            bool vb = jb.get<bool>();
+            int vi = jn.get<int>();
 
-    {
-        std::map<std::string, int> c_map { {"one", 1}, {"two", 2}, {"three", 3} };
-        json j_map(c_map);
-        // {"one": 1, "two": 2, "three": 3}
+            // etc.
+        }
 
-        std::unordered_map<const char*, float> c_umap { {"one", 1.2f}, {"two", 2.3f}, {"three", 3.4f} };
-        json j_umap(c_umap);
-        // {"one": 1.2, "two": 2.3, "three": 3.4}
-
-        std::multimap<std::string, bool> c_mmap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
-        json j_mmap(c_mmap); // only one entry for key "three" is used
-        // maybe {"one": true, "two": true, "three": true}
-
-        std::unordered_multimap<std::string, bool> c_ummap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
-        json j_ummap(c_ummap); // only one entry for key "three" is used
-        // maybe {"one": true, "two": true, "three": true}
-    }
-
-    {
-        // strings
-        std::string s1 = "Hello, world!";
-        json js = s1;
-        std::string s2 = js;
-
-        // Booleans
-        bool b1 = true;
-        json jb = b1;
-        bool b2 = jb;
-
-        // numbers
-        int i = 42;
-        json jn = i;
-        double f = jn;
-
-        // etc.
-
-        std::string vs = js.get<std::string>();
-        bool vb = jb.get<bool>();
-        int vi = jn.get<int>();
-
-        // etc.
-    }
-
-    {
-        // a JSON value
-        json j_original = R"({
+        {
+            // a JSON value
+            json j_original = R"({
           "baz": ["one", "two", "three"],
           "foo": "bar"
         })"_json;
 
-        // access members with a JSON pointer (RFC 6901)
-        j_original["/baz/1"_json_pointer];
-        // "two"
+            // access members with a JSON pointer (RFC 6901)
+            j_original["/baz/1"_json_pointer];
+            // "two"
 
-        // a JSON patch (RFC 6902)
-        json j_patch = R"([
+            // a JSON patch (RFC 6902)
+            json j_patch = R"([
           { "op": "replace", "path": "/baz", "value": "boo" },
           { "op": "add", "path": "/hello", "value": ["world"] },
           { "op": "remove", "path": "/foo"}
         ])"_json;
 
-        // apply the patch
-        json j_result = j_original.patch(j_patch);
-        // {
-        //    "baz": "boo",
-        //    "hello": ["world"]
-        // }
+            // apply the patch
+            json j_result = j_original.patch(j_patch);
+            // {
+            //    "baz": "boo",
+            //    "hello": ["world"]
+            // }
 
-        // calculate a JSON patch from two JSON values
-        json::diff(j_result, j_original);
-        // [
-        //   { "op":" replace", "path": "/baz", "value": ["one", "two", "three"] },
-        //   { "op":"remove","path":"/hello" },
-        //   { "op":"add","path":"/foo","value":"bar" }
-        // ]
+            // calculate a JSON patch from two JSON values
+            json::diff(j_result, j_original);
+            // [
+            //   { "op":" replace", "path": "/baz", "value": ["one", "two", "three"] },
+            //   { "op":"remove","path":"/hello" },
+            //   { "op":"add","path":"/foo","value":"bar" }
+            // ]
+        }
+
+        // restore old std::cout
+        std::cout.rdbuf(old_cout_buffer);
     }
 }