Method chunkedRequestBurstSmoke

Tests/Libraries/Http/HttpStressTest.cpp:221–391

    SC_TEST_EXPECT(httpServer.getConnections().getNumActiveConnections() <= 1);
    SC_TEST_EXPECT(eventLoop.close());
}

void SC::HttpStressTest::chunkedRequestBurstSmoke()
{
    constexpr int    NumRequests       = 32;
    constexpr int    NumConnections    = 4;
    constexpr int    RequestSlices     = 2;
    constexpr int    HeaderBytes       = 8 * 1024;
    constexpr int    StreamBytes       = 1024;
    constexpr size_t ExpectedBodyBytes = 32;
    const uint16_t   serverPort        = report.mapPort(6211);

    AsyncEventLoop eventLoop;
    SC_TEST_EXPECT(eventLoop.create());

    using HttpConnectionType = HttpAsyncConnection<RequestSlices, RequestSlices, HeaderBytes, StreamBytes>;

    HttpConnectionType connections[NumConnections];
    HttpAsyncServer    httpServer;
    SC_TEST_EXPECT(httpServer.init(Span<HttpConnectionType>(connections)));
    SC_TEST_EXPECT(httpServer.start(eventLoop, "127.0.0.1", serverPort));

    struct RequestSlot
    {
        void onData(AsyncBufferView::ID bufferID)
        {
            SC_ASSERT_RELEASE(connection != nullptr);

            Span<const char> data;
            SC_ASSERT_RELEASE(connection->request.getReadableStream().getBuffersPool().getReadableData(bufferID, data));

            const size_t index = connection->getConnectionID().getIndex();
            SC_ASSERT_RELEASE(index < NumConnections);
            bodyBytes[index] += data.sizeInBytes();
            SC_ASSERT_RELEASE(connection->request.consumeBodyBytes(data.sizeInBytes()));
        }

        void onEnd()
        {
            SC_ASSERT_RELEASE(connection != nullptr);
            if (responded)
            {
                return;
            }
            responded = true;
            (void)connection->request.getReadableStream().eventData.removeListener<RequestSlot, &RequestSlot::onData>(
                *this);
            (void)connection->request.getReadableStream().eventEnd.removeListener<RequestSlot, &RequestSlot::onEnd>(
                *this);

            const size_t index = connection->getConnectionID().getIndex();
            test->recordExpectation("chunked stress connection index", index < NumConnections);
            test->recordExpectation("chunked stress decoded body size", bodyBytes[index] == expectedBodyBytes);
            test->recordExpectation("chunked stress response", connection->response.sendEmpty(200));
            (*ended)++;
        }

        HttpStressTest* test              = nullptr;