add coroutine test

Author: MungoG

test/unit/body_write_stream.cpp

@@ -9,12 +9,17 @@
 
 #include <boost/beast2/body_read_stream.hpp>
 #include <boost/beast2/body_write_stream.hpp>
+#include <boost/beast2/detail/config.hpp>
+#include <boost/beast2/wrap_executor.hpp>
 
 #include <boost/asio/bind_cancellation_slot.hpp>
+#include <boost/asio/deferred.hpp>
 #include <boost/asio/read.hpp>
 #include <boost/asio/write.hpp>
 #include <boost/buffers/make_buffer.hpp>
+#include <boost/capy/async_op.hpp>
 #include <boost/capy/polystore.hpp>
+#include <boost/capy/task.hpp>
 #include <boost/http_proto/response.hpp>
 #include <boost/http_proto/request.hpp>
 
@@ -531,6 +536,113 @@ struct single_tester : public ctx_base
     }
 };
 
+#ifdef BOOST_BEAST2_HAS_CORO
+
+// Result type for async write operations
+struct write_result
+{
+    system::error_code ec;
+    std::size_t bytes_transferred;
+};
+
+// Helper to wrap async_write_some for coroutines
+template<class Stream, class ConstBufferSequence>
+capy::async_op<write_result>
+coro_write_some(
+    body_write_stream<Stream>& bws,
+    ConstBufferSequence const& buffers)
+{
+    return capy::make_async_op<write_result>(
+        bws.async_write_some(buffers, asio::deferred));
+}
+
+// Helper to wrap async_close for coroutines
+template<class Stream>
+capy::async_op<system::error_code>
+coro_close(body_write_stream<Stream>& bws)
+{
+    return capy::make_async_op<system::error_code>(
+        bws.async_close(asio::deferred));
+}
+
+capy::task<void>
+do_coro_write(
+    test::stream& wts,
+    test::stream& rts,
+    http_proto::serializer& sr,
+    http_proto::serializer::stream& srs,
+    std::string const& body,
+    std::string const& expected_msg)
+{
+    body_write_stream<test::stream> bws(wts, sr, srs);
+
+    // Write body data using co_await
+    buffers::const_buffer cb(body.data(), body.size());
+    std::size_t total_written = 0;
+
+    while(cb.size() > 0)
+    {
+        auto result = co_await coro_write_some(bws, cb);
+        BOOST_TEST(!result.ec.failed());
+        BOOST_TEST_GT(result.bytes_transferred, 0u);
+        total_written += result.bytes_transferred;
+        cb += result.bytes_transferred;
+    }
+
+    BOOST_TEST_EQ(total_written, body.size());
+    BOOST_TEST(!sr.is_done());
+
+    // Close the stream
+    auto ec = co_await coro_close(bws);
+    BOOST_TEST(!ec.failed());
+
+    BOOST_TEST(sr.is_done());
+    BOOST_TEST_EQ(rts.str(), expected_msg);
+
+    co_return;
+}
+
+void
+test_coroutine()
+{
+    // Set up context with parser and serializer services
+    capy::polystore capy_ctx;
+    http_proto::install_parser_service(capy_ctx, {});
+    http_proto::install_serializer_service(capy_ctx, {});
+
+    std::string body = "Hello World!";
+    std::string header =
+        "HTTP/1.1 200 OK\r\n"
+        "Content-Length: 12\r\n"
+        "\r\n";
+    std::string expected_msg = header + body;
+
+    asio::io_context ioc;
+
+    test::stream wts(ioc);
+    test::stream rts(ioc);
+    wts.connect(rts);
+
+    http_proto::serializer sr(capy_ctx);
+    sr.reset();
+
+    http_proto::response res(header);
+    auto srs = sr.start_stream(res);
+
+    capy::spawn(
+        wrap_executor(ioc.get_executor()),
+        do_coro_write(wts, rts, sr, srs, body, expected_msg),
+        [](system::result<void, std::exception_ptr> result)
+        {
+            if(result.has_error())
+                std::rethrow_exception(result.error());
+        });
+
+    ioc.run();
+}
+
+#endif // BOOST_BEAST2_HAS_CORO
+
 } // anonymous namespace.
 
 struct body_write_stream_test
@@ -594,6 +706,13 @@ struct body_write_stream_test
         {
             single_tester().test_close_errors();
         }
+
+#ifdef BOOST_BEAST2_HAS_CORO
+        // Test C++20 coroutine compatibility
+        {
+            test_coroutine();
+        }
+#endif
     }
 };