Method zeroLengthResponse

Tests/Libraries/Http/HttpAsyncClientTest.cpp:1640–1691

                                  }});
    client.setTransportSetup({[&setupCalled](HttpAsyncClientTransportSetup&) -> Result
                              {
                                  setupCalled = true;
                                  return fixtureError(HttpAsyncClientFixtureError::UnexpectedTransportSetup);
                              }});

    const Result result = client.get(loop, "https://not-resolvable.invalid/");
    SC_TEST_EXPECT(result.isError(HttpAsyncClientFixtureCategory, HttpAsyncClientFixtureError::PreflightRejected));
    SC_TEST_EXPECT(preflightCalled);
    SC_TEST_EXPECT(not setupCalled);
    SC_TEST_EXPECT(client.close());
    SC_TEST_EXPECT(loop.close());
}

void SC::HttpAsyncClientTest::externalConnectorOwnsConnectionEstablishment()
{
    AsyncEventLoop loop;
    SC_TEST_EXPECT(loop.create());

    ServerConnection connections[1];
    HttpAsyncServer  httpServer;
    const uint16_t   port = report.mapPort(26130);
    SC_TEST_EXPECT(httpServer.init(Span<ServerConnection>(connections)));
    SC_TEST_EXPECT(httpServer.start(loop, "127.0.0.1", port));

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

    struct Context
    {
        HttpAsyncClientTest* test      = nullptr;
        ResponseCollector*   collector = nullptr;
        HttpAsyncServer*     server    = nullptr;

        HttpConnectionBase* connection = nullptr;
        AsyncEventLoop*     loop       = nullptr;
        AsyncSocketConnect  connect;

        Function<void(Result)> complete;
        Function<void(Result)> fail;

        bool connectorCalled = false;
        bool connected       = false;
        bool setupCalled     = false;

        Result onConnect(HttpAsyncClientExternalConnection& request)
        {
            test->recordExpectation("external connector connection", request.connection != nullptr);
            test->recordExpectation("external connector loop", request.eventLoop != nullptr);
            test->recordExpectation("external connector URL",
                                    request.url != nullptr and request.url->hostname == "not-resolvable.invalid");
            test->recordExpectation("external connector complete", request.complete.isValid());
            test->recordExpectation("external connector fail", request.fail.isValid());