flat_stream tests and tidy

test/beast/core/flat_stream.cpp

@@ -12,26 +12,168 @@
 
 #include "stream_tests.hpp"
 
-#include <boost/beast/test/websocket.hpp>
-#include <boost/beast/test/yield_to.hpp>
 #include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <boost/beast/_experimental/test/stream.hpp>
+#include <boost/beast/websocket/role.hpp>
 #include <initializer_list>
 #include <vector>
 
 namespace boost {
 namespace beast {
 
-class flat_stream_test
-    : public unit_test::suite
-    , public test::enable_yield_to
+class flat_stream_test : public unit_test::suite
 {
 public:
     void
-    testStream()
+    testMembers()
     {
+        net::io_context ioc;
+
         test_sync_stream<flat_stream<test::stream>>();
+
         test_async_stream<flat_stream<test::stream>>();
+
+        // read/write
+
+        {
+            error_code ec;
+            flat_stream<test::stream> s(ioc);
+            {
+                // VFALCO Hack to make test stream code = eof
+                test::stream ts(ioc);
+                s.next_layer().connect(ts);
+            }
+            char buf[1];
+            net::mutable_buffer m1 = net::buffer(buf);
+
+            BEAST_EXPECT(s.read_some(net::mutable_buffer{}) == 0);
+            BEAST_EXPECT(s.read_some(net::mutable_buffer{}, ec) == 0);
+            BEAST_EXPECTS(! ec, ec.message());
+
+            try
+            {
+                s.read_some(m1);
+                BEAST_FAIL();
+            }
+            catch(std::exception const&)
+            {
+                BEAST_PASS();
+            }
+            catch(...)
+            {
+                BEAST_FAIL();
+            }
+
+            BEAST_EXPECT(s.write_some(net::const_buffer{}) == 0);
+            BEAST_EXPECT(s.write_some(net::const_buffer{}, ec) == 0);
+            BEAST_EXPECTS(! ec, ec.message());
+
+            try
+            {
+                s.write_some(m1);
+                BEAST_FAIL();
+            }
+            catch(std::exception const&)
+            {
+                BEAST_PASS();
+            }
+            catch(...)
+            {
+                BEAST_FAIL();
+            }
+
+            bool invoked;
+
+            invoked = false;
+            s.async_read_some(net::mutable_buffer{},
+                [&](error_code ec, std::size_t)
+                {
+                    invoked = true;
+                    BEAST_EXPECTS(! ec, ec.message());
+                });
+            ioc.run();
+            ioc.restart();
+            BEAST_EXPECT(invoked);
+
+            invoked = false;
+            s.async_write_some(net::const_buffer{},
+                [&](error_code ec, std::size_t)
+                {
+                    invoked = true;
+                    BEAST_EXPECTS(! ec, ec.message());
+                });
+            ioc.run();
+            ioc.restart();
+            BEAST_EXPECT(invoked);
+        }
+
+        // stack_write_some
+
+        {
+            char b[detail::flat_stream_base::max_size];
+            std::array<net::const_buffer, 3> bs;
+            bs[0] = net::const_buffer(b, 100);
+            bs[1] = net::const_buffer(b + 100, 200);
+            bs[2] = net::const_buffer(b + 100 + 200, 300);
+            BEAST_EXPECT(buffer_size(bs) <=
+                detail::flat_stream_base::max_stack);
+            flat_stream<test::stream> s(ioc);
+            error_code ec;
+            s.write_some(bs, ec);
+        }
+
+        // write_some
+
+        {
+            char b[detail::flat_stream_base::max_size];
+            std::array<net::const_buffer, 2> bs;
+            bs[0] = net::const_buffer(b,
+                detail::flat_stream_base::max_stack);
+            bs[1] = net::const_buffer(b + bs[0].size(), 1024);
+            BEAST_EXPECT(buffer_size(bs) <=
+                detail::flat_stream_base::max_size);
+            flat_stream<test::stream> s(ioc);
+            error_code ec;
+            s.write_some(bs, ec);
+        }
+
+        // async_write_some
+
+        {
+            char b[detail::flat_stream_base::max_size];
+            std::array<net::const_buffer, 2> bs;
+            bs[0] = net::const_buffer(b,
+                detail::flat_stream_base::max_stack);
+            bs[1] = net::const_buffer(b + bs[0].size(), 1024);
+            BEAST_EXPECT(buffer_size(bs) <=
+                detail::flat_stream_base::max_size);
+            flat_stream<test::stream> s(ioc);
+            error_code ec;
+            s.async_write_some(bs,
+                [](error_code, std::size_t)
+                {
+                });
+        }
+
+        // teardown
+
+        {
+            test::stream ts(ioc);
+            flat_stream<test::stream> s(ioc);
+            ts.connect(s.next_layer());
+            error_code ec;
+            teardown(websocket::role_type::client, s, ec);
+        }
+
+        {
+            test::stream ts(ioc);
+            flat_stream<test::stream> s(ioc);
+            ts.connect(s.next_layer());
+            async_teardown(websocket::role_type::client, s,
+                [](error_code)
+                {
+                });
+        }
     }
 
     void
@@ -49,9 +191,9 @@ public:
                 for(auto const n : v0)
                     v.emplace_back("", n);
                 auto const result =
-                    boost::beast::detail::flat_stream_base::coalesce(v, limit);
+                    boost::beast::detail::flat_stream_base::flatten(v, limit);
                 BEAST_EXPECT(result.size == count);
-                BEAST_EXPECT(result.needs_coalescing == copy);
+                BEAST_EXPECT(result.flatten == copy);
                 return result;
             };
         check({},           1,    0, false);
@@ -67,50 +209,11 @@ public:
         check({1,2,3,4},    3,    3, true);
     }
 
-    void
-    testHttp()
-    {
-        pass();
-    }
-
-    void
-    testWebsocket()
-    {
-        {
-            error_code ec;
-            test::ws_echo_server es{log};
-            net::io_context ioc;
-            websocket::stream<flat_stream<test::stream>> ws{ioc};
-            ws.next_layer().next_layer().connect(es.stream());
-            ws.handshake("localhost", "/", ec);
-            BEAST_EXPECTS(! ec, ec.message());
-            ws.close({}, ec);
-            BEAST_EXPECTS(! ec, ec.message());
-        }
-        {
-            test::ws_echo_server es{log};
-            net::io_context ioc;
-            websocket::stream<flat_stream<test::stream>> ws{ioc};
-            get_lowest_layer(ws).connect(es.stream());
-            ws.async_handshake("localhost", "/",
-                [&](error_code)
-                {
-                    ws.async_close({},
-                        [&](error_code)
-                        {
-                        });
-                });
-            ioc.run();
-        }
-    }
-
     void
     run() override
     {
-        testStream();
+        testMembers();
         testSplit();
-        testHttp();
-        testWebsocket();
     }
 };