testing changes

Author: MungoG

include/boost/beast2/impl/body_write_stream.hpp

@@ -102,8 +102,6 @@ class body_write_stream_op : public asio::coroutine
     {
         boost::ignore_unused(bytes_transferred);
 
-        std::cout << ec.message() << std::endl;
-
         BOOST_ASIO_CORO_REENTER(*this)
         {
             self.reset_cancellation_state(asio::enable_total_cancellation());

test/unit/body_write_stream.cpp

@@ -237,31 +237,22 @@ struct single_tester : public ctx_base
 
     struct chunking_handler
     {
-        std::size_t n_;
         system::error_code ec_;
-        std::size_t* total_;
-        boost::buffers::string_buffer* buf_;
+        std::size_t* written_;
 
         chunking_handler(
-            std::size_t n,
             system::error_code ec,
-            std::size_t* total,
-            boost::buffers::string_buffer* buf = nullptr)
-            : n_(n)
-            , ec_(ec)
-            , total_(total)
-            , buf_(buf)
+            std::size_t* written)
+            : ec_(ec)
+            , written_(written)
         {
         }
 
         void
         operator()(system::error_code ec, std::size_t n)
         {
             BOOST_TEST_EQ(ec, ec_);
-            BOOST_TEST_EQ(n, n_);
-            if(buf_)
-                buf_->commit(n);
-            *total_ += n;
+            *written_ += n;
         }
     };
 
@@ -280,33 +271,82 @@ struct single_tester : public ctx_base
     {
         wts_.write_size(cs); // Limit und stream write size to cs
 
+        std::string finals;
+        finals.reserve(bs * iters);
+
         std::size_t total = 0;
+        std::size_t prev = 0;
         for(int i = 0; i < iters; i++)
         {
-            auto cb = make_test_buffer(bs);
+            std::string val = body_.substr(0, bs);
+            val.resize(bs, '.');
+            boost::buffers::string_buffer sb(&val);
+            auto cb = sb.data();
+
+            finals += test_to_string(cb);
 
             // Calculate how many bytes we expect to read on each iteration
             // std::size_t expected = chunking_expected_n(bs, cs, (i == 0),
             // total);
 
             // Read into a buffer of size bs
-            bws_.async_write_some(
-                buf_.prepare(bs),
-                chunking_handler(
-                    std::min(bs, cs), system::error_code{}, &total));
-
-            auto count = test::run(ioc_);
-            if(i > 0) // The initial run reads the header so can call multiple
-                      // handlers.
+            while(cb.size() > 0)
+            {
+                std::size_t emin, emax;
+                if(srs_.capacity())
+                {
+                    emin = std::max(
+                        (std::size_t)1, std::min({ bs, srs_.capacity() }));
+                    emax = emin;
+                }
+                else
+                {
+                    emin = 1;
+                    emax = std::max((std::size_t)1, bs);
+                }
+
+                std::size_t written = 0;
+                bws_.async_write_some(
+                    cb,
+                    chunking_handler(
+                        system::error_code{},
+                        &written));
+
+                auto count = test::run(ioc_);
                 BOOST_TEST_EQ(count, 1);
 
-            BOOST_TEST(sr_.is_done());
+                BOOST_TEST_GE(written, emin);
+                BOOST_TEST_LE(written, emax);
+
+                total += written;
+                cb += written;
+
+                BOOST_TEST_GE(rts_.nwrite_bytes() - prev, 1);
+                BOOST_TEST_LE(rts_.nwrite_bytes() - prev, cs);
+
+                prev = rts_.nwrite_bytes();
+
+                BOOST_TEST_LE(rts_.nwrite_bytes(), bs * (i+1) + header_length_);
+
+                BOOST_TEST(!sr_.is_done());
+            }
         }
 
+        BOOST_TEST_EQ(total, bs * iters);
+
+        bws_.async_close(test::success_handler());
+
+        auto count = test::run(ioc_);
+        BOOST_TEST_GE(count, 1);
+
+        BOOST_TEST_GT(rts_.nwrite_bytes(), iters + count - 1);
+        BOOST_TEST_LE(rts_.nwrite_bytes(), cs * (iters + count));
+
+        BOOST_TEST_EQ(rts_.nwrite_bytes(), bs * iters + header_length_);
+
         BOOST_TEST(sr_.is_done());
-        BOOST_TEST_EQ(buf_.size(), body_length_);
-        BOOST_TEST_EQ(total, body_length_);
-        BOOST_TEST(test_to_string(buf_.data()) == body_);
+
+        BOOST_TEST(rts_.str() == header_ + finals);
     }
 
     void
@@ -424,10 +464,11 @@ struct body_write_stream_test
         // sizes.
         {
             // Iterate through buffer sizes
-            for(std::size_t bs = 1; bs < msg_length + 2; bs++)
+            for(std::size_t bs = 1; bs < 1000; bs++)
             {
+                std::cout << bs << std::endl;
                 // Iterate through chunk sizes
-                for(std::size_t cs = 1; cs < msg_length + 2; cs++)
+                for(std::size_t cs = 1; cs < 1000; cs++)
                 {
                     single_tester().test_with_chunking(bs, cs);
                 }