Method commonMethodWrappers

Tests/Libraries/Http/HttpAsyncClientTest.cpp:593–788

        Buffer patchBody;

        int patchRequests   = 0;
        int optionsRequests = 0;
        int deleteRequests  = 0;

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

        Result sendEmptyResponse(int statusCode)
        {
            SC_TRY(connection->response.startResponse(statusCode));
            SC_TRY(connection->response.addHeader("Content-Length", "0"));
            SC_TRY(connection->response.sendHeaders());
            return connection->response.end();
        }

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

        void onPatchEnd()
        {
            test->recordExpectation("patch body",
                                    StringView(patchBody.toSpanConst(), false, StringEncoding::Ascii) == "patch");
            test->recordExpectation("patch response", sendEmptyResponse(200));
        }

        explicit ServerContext(HttpAsyncClientTest* testCase) : test(testCase) {}
    } serverContext(this);

    httpServer.onRequest = [this, &serverContext](HttpConnection& connection)
    {
        serverContext.connection = &connection;
        if (connection.request.getParser().method == HttpParser::Method::HttpPATCH)
        {
            serverContext.patchRequests++;
            SC_TEST_EXPECT(connection.request.getRequestTarget() == "/patch");
            const bool addedData =
                connection.request.getReadableStream()
                    .eventData.addListener<ServerContext, &ServerContext::onPatchData>(serverContext);
            const bool addedEnd =
                connection.request.getReadableStream().eventEnd.addListener<ServerContext, &ServerContext::onPatchEnd>(
                    serverContext);
            SC_TEST_EXPECT(addedData);
            SC_TEST_EXPECT(addedEnd);
            return;
        }
        if (connection.request.getParser().method == HttpParser::Method::HttpOPTIONS)
        {
            serverContext.optionsRequests++;