* Verify that we get the same connection if we grab one, return it and grab
 * another.
 */
TEST_F(ConnectionPoolTest, SameConn) {
    auto pool = makePool();

    // Grab and stash an id for the first request
    size_t conn1Id = 0;
    ConnectionImpl::pushSetup(Status::OK());

            

Reported by Cppcheck.

                  std::vector<RemoteCommandOnAnyResponse> _responses;
};

TEST_F(MockNetworkTest, MockFixtureBasicTest) {
    mock().expect(kExampleCmdName, kExampleResponse);

    RemoteCommandRequestOnAny request{kExampleRequest};
    ASSERT_OK(startCommand(request));


            

Reported by Cppcheck.

                  return false;
}

TEST_F(NetworkInterfaceIntegrationFixture, Ping) {
    startNet();
    assertCommandOK("admin", BSON("ping" << 1));
}

TEST_F(NetworkInterfaceIntegrationFixture, PingWithoutStartup) {

            

Reported by Cppcheck.

                  ASSERT(gotCorrectCommandReply);
}

TEST_F(NetworkInterfaceMockTest, ConnectionHookFailedValidation) {
    net().setConnectionHook(makeTestHook(
        [&](const HostAndPort& remoteHost,
            const BSONObj&,
            const RemoteCommandResponse& isMasterReply) -> Status {
            // We just need some obscure non-OK code.

            

Reported by Cppcheck.

                  return t.millis();
}

TEST(NetworkInterfaceASIO, SerialPerf) {
    NetworkInterfaceASIO::Options options{};
    options.streamFactory = std::make_unique<AsyncStreamFactory>();
    options.timerFactory = std::make_unique<AsyncTimerFactoryASIO>();
    NetworkInterfaceASIO netAsio{std::move(options)};


            

Reported by Cppcheck.

                          returnConnection(status);

            const auto commandStatus = getStatusFromCommandResult(response.data);
            if (isHedge) {
                // Ignore maxTimeMS expiration, StaleDbVersion or any error belonging to
                // StaleShardVersionError
                //  error category for hedged reads without triggering the finish line.
                if (commandStatus == ErrorCodes::MaxTimeMSExpired ||
                    commandStatus == ErrorCodes::StaleDbVersion ||

            

Reported by Cppcheck.

                  boost::optional<ScopedTaskExecutor> _executor;
};

TEST_F(ScopedTaskExecutorTest, onEvent) {
    auto pf = makePromiseFuture<void>();

    auto event = uassertStatusOK(getExecutor()->makeEvent());

    ASSERT(getExecutor()

            

Reported by Cppcheck.

              

// Test that we can actually use a TaskExecutorCursor to read multiple batches from a remote host
TEST_F(TaskExecutorCursorFixture, Basic) {
    auto client = _serviceCtx->makeClient("TaskExecutorCursorTest");
    auto opCtx = client->makeOperationContext();

    // Write 100 documents to "test.test" via dbclient
    auto swConn = unittest::getFixtureConnectionString().connect("TaskExecutorCursorTest");

            

Reported by Cppcheck.

              /**
 * Ensure we work for a single simple batch
 */
TEST_F(TaskExecutorCursorFixture, SingleBatchWorks) {
    const auto findCmd = BSON("find"
                              << "test"
                              << "batchSize" << 2);
    const CursorId cursorId = 0;


            

Reported by Cppcheck.

                      };
};

TEST_F(TaskExecutorFixture, RunExhaustShouldReceiveMultipleResponses) {
    auto client = _serviceCtx->makeClient("TaskExecutorExhaustTest");
    auto opCtx = client->makeOperationContext();

    RemoteCommandRequest rcr(unittest::getFixtureConnectionString().getServers().front(),
                             "admin",

            

Reported by Cppcheck.