Method putChunkedStreamBody

Tests/Libraries/Http/HttpAsyncClientTest.cpp:1043–1150

        bool   responseSent = false;

        Result append(Span<const char> data)
        {
            GrowableBuffer<Buffer> gb(body);
            HttpStringAppend&      sb = static_cast<HttpStringAppend&>(static_cast<IGrowableBuffer&>(gb));
            return Result(sb.append(data, 0));
        }

        void onData(AsyncBufferView::ID bufferID)
        {
            SC_ASSERT_RELEASE(connection != nullptr);
            AsyncReadableStream& readable = connection->request.getReadableStream();
            Span<const char>     data;
            SC_ASSERT_RELEASE(readable.getBuffersPool().getReadableData(bufferID, data));
            SC_ASSERT_RELEASE(append(data));
            SC_ASSERT_RELEASE(connection->request.consumeBodyBytes(data.sizeInBytes()));
        }

        void onEnd()
        {
            SC_ASSERT_RELEASE(connection != nullptr);
            SC_ASSERT_RELEASE(connection->request.getBodyFramingKind() == HttpBodyFramingKind::Chunked);
            SC_ASSERT_RELEASE(StringView(StringSpan(body.toSpanConst(), false, StringEncoding::Ascii)) ==
                              "ChunkedBody");
            responseSent = true;
            SC_ASSERT_RELEASE(connection->response.startResponse(200));
            SC_ASSERT_RELEASE(connection->response.addHeader("Content-Length", "6"));
            SC_ASSERT_RELEASE(connection->response.sendHeaders());
            SC_ASSERT_RELEASE(connection->response.getWritableStream().write("stored"));
            SC_ASSERT_RELEASE(connection->response.end());
        }

        [[nodiscard]] StringSpan view() const { return {body.toSpanConst(), false, StringEncoding::Ascii}; }
    } serverCtx;

    httpServer.onRequest = [this, &serverCtx](HttpConnection& connection)
    {
        serverCtx.connection = &connection;
        const bool addedData =
            connection.request.getReadableStream().eventData.addListener<ServerContext, &ServerContext::onData>(
                serverCtx);
        SC_TEST_EXPECT(addedData);
        const bool addedEnd =
            connection.request.getReadableStream().eventEnd.addListener<ServerContext, &ServerContext::onEnd>(
                serverCtx);
        SC_TEST_EXPECT(addedEnd);
    };

    ClientConnection  clientStorage;
    HttpAsyncClient   client;
    ResponseCollector collector;
    ChunkedBodyStream bodyStream;
    TimeoutGuard      timeout;

    struct Context
    {
        ResponseCollector& collector;
        HttpAsyncServer&   httpServer;
        ServerContext&     serverCtx;