From d35f8e02772d8508e18c802d5880b930c34bb1a8 Mon Sep 17 00:00:00 2001
From: Sergey Yakubov <sergey.yakubov@desy.de>
Date: Sat, 19 May 2018 07:53:24 +0200
Subject: [PATCH] refactor tests
---
producer/api/src/producer_impl.cpp | 2 +-
producer/api/src/request_handler_factory.cpp | 17 ++---
producer/api/src/request_handler_factory.h | 16 ++---
producer/api/src/request_handler_tcp.cpp | 29 +++++----
producer/api/src/request_handler_tcp.h | 13 ++--
producer/api/src/request_pool.cpp | 11 ++--
producer/api/src/request_pool.h | 3 +-
producer/api/unittests/test_producer_impl.cpp | 4 +-
.../test_request_handler_factory.cpp | 4 +-
.../unittests/test_request_handler_tcp.cpp | 65 ++++++++-----------
producer/api/unittests/test_request_pool.cpp | 25 ++++---
11 files changed, 93 insertions(+), 96 deletions(-)
diff --git a/producer/api/src/producer_impl.cpp b/producer/api/src/producer_impl.cpp
index c24fa2ec6..3d7e84e46 100644
--- a/producer/api/src/producer_impl.cpp
+++ b/producer/api/src/producer_impl.cpp
@@ -13,7 +13,7 @@ const size_t ProducerImpl::kDiscoveryServiceUpdateFrequencyMs = 10000; // 10s
ProducerImpl::ProducerImpl(std::string endpoint, uint8_t n_processing_threads): log__{GetDefaultProducerLogger()} {
discovery_service_.reset(new ReceiverDiscoveryService{endpoint, ProducerImpl::kDiscoveryServiceUpdateFrequencyMs});
- request_handler_factory_.reset(new RequestHandlerFactory{RequestHandlerType::kTcp,discovery_service_.get()});
+ request_handler_factory_.reset(new RequestHandlerFactory{RequestHandlerType::kTcp, discovery_service_.get()});
request_pool__.reset(new RequestPool{n_processing_threads, request_handler_factory_.get()});
}
diff --git a/producer/api/src/request_handler_factory.cpp b/producer/api/src/request_handler_factory.cpp
index d2753d7e6..7dedc995b 100644
--- a/producer/api/src/request_handler_factory.cpp
+++ b/producer/api/src/request_handler_factory.cpp
@@ -4,19 +4,20 @@
namespace asapo {
-std::unique_ptr<RequestHandler> RequestHandlerFactory::NewRequestHandler(uint64_t thread_id) {
+std::unique_ptr<RequestHandler> RequestHandlerFactory::NewRequestHandler(uint64_t thread_id, uint64_t* shared_counter) {
switch (type_) {
- case asapo::RequestHandlerType::kTcp:
- return std::unique_ptr<RequestHandler>{new RequestHandlerTcp(discovery_service_,thread_id)};
+ case asapo::RequestHandlerType::kTcp:
+ return std::unique_ptr<RequestHandler> {new RequestHandlerTcp(discovery_service_, thread_id, shared_counter)};
}
return nullptr;
}
-RequestHandlerFactory::RequestHandlerFactory(RequestHandlerType type,ReceiverDiscoveryService* discovery_service): type_{type},
-discovery_service_{discovery_service}{
-if (discovery_service_) {
- discovery_service_->StartCollectingData();
-}
+RequestHandlerFactory::RequestHandlerFactory(RequestHandlerType type,
+ ReceiverDiscoveryService* discovery_service): type_{type},
+ discovery_service_{discovery_service} {
+ if (discovery_service_) {
+ discovery_service_->StartCollectingData();
+ }
}
diff --git a/producer/api/src/request_handler_factory.h b/producer/api/src/request_handler_factory.h
index 22a68d642..32cffafd8 100644
--- a/producer/api/src/request_handler_factory.h
+++ b/producer/api/src/request_handler_factory.h
@@ -12,17 +12,17 @@ namespace asapo {
#endif
enum class RequestHandlerType {
- kTcp,
- kFilesystem
+ kTcp,
+ kFilesystem
};
class RequestHandlerFactory {
- public:
- RequestHandlerFactory(RequestHandlerType type, ReceiverDiscoveryService* discovery_service);
- VIRTUAL std::unique_ptr<RequestHandler> NewRequestHandler(uint64_t thread_id);
- private:
- RequestHandlerType type_;
- ReceiverDiscoveryService* discovery_service_;
+ public:
+ RequestHandlerFactory(RequestHandlerType type, ReceiverDiscoveryService* discovery_service);
+ VIRTUAL std::unique_ptr<RequestHandler> NewRequestHandler(uint64_t thread_id, uint64_t* shared_counter);
+ private:
+ RequestHandlerType type_;
+ ReceiverDiscoveryService* discovery_service_;
};
diff --git a/producer/api/src/request_handler_tcp.cpp b/producer/api/src/request_handler_tcp.cpp
index 3f7faa34d..f5732764a 100644
--- a/producer/api/src/request_handler_tcp.cpp
+++ b/producer/api/src/request_handler_tcp.cpp
@@ -7,8 +7,10 @@
namespace asapo {
-RequestHandlerTcp::RequestHandlerTcp(ReceiverDiscoveryService* discovery_service,uint64_t thread_id):
- io__{GenerateDefaultIO()}, log__{GetDefaultProducerLogger()},discovery_service__{discovery_service},thread_id_{thread_id} {
+RequestHandlerTcp::RequestHandlerTcp(ReceiverDiscoveryService* discovery_service, uint64_t thread_id,
+ uint64_t* shared_counter):
+ io__{GenerateDefaultIO()}, log__{GetDefaultProducerLogger()}, discovery_service__{discovery_service}, thread_id_{thread_id},
+ ncurrent_connections_{shared_counter} {
}
@@ -23,7 +25,7 @@ Error RequestHandlerTcp::ConnectToReceiver(const std::string& receiver_address)
return nullptr;
}
-Error RequestHandlerTcp::SendHeaderAndData(const Request* request,const std::string& receiver_address) {
+Error RequestHandlerTcp::SendHeaderAndData(const Request* request, const std::string& receiver_address) {
Error io_error;
io__->Send(sd_, &(request->header), sizeof(request->header), &io_error);
if(io_error) {
@@ -59,8 +61,8 @@ Error RequestHandlerTcp::ReceiveResponse(const std::string& receiver_address) {
return nullptr;
}
-Error RequestHandlerTcp::TrySendToReceiver(const Request* request,const std::string& receiver_address) {
- auto err = SendHeaderAndData(request ,receiver_address);
+Error RequestHandlerTcp::TrySendToReceiver(const Request* request, const std::string& receiver_address) {
+ auto err = SendHeaderAndData(request, receiver_address);
if (err) {
return err;
}
@@ -81,7 +83,7 @@ void RequestHandlerTcp::UpdateReceiversUriIfNewConnection() {
receivers_list_ = discovery_service__->RotatedUriList(thread_id_);
last_receivers_uri_update_ = high_resolution_clock::now();
- ncurrent_connections_++;
+ (*ncurrent_connections_)++;
}
bool RequestHandlerTcp::CheckForRebalance() {
@@ -90,7 +92,7 @@ bool RequestHandlerTcp::CheckForRebalance() {
auto now = high_resolution_clock::now();
uint64_t elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>( now -
- last_receivers_uri_update_).count();
+ last_receivers_uri_update_).count();
bool rebalance = false;
if (elapsed_ms > discovery_service__->UpdateFrequency()) {
auto thread_receivers_new = discovery_service__->RotatedUriList(thread_id_);
@@ -104,7 +106,7 @@ bool RequestHandlerTcp::CheckForRebalance() {
}
-Error RequestHandlerTcp::ProcessRequestUnlocked(const Request* request){
+Error RequestHandlerTcp::ProcessRequestUnlocked(const Request* request) {
bool rebalance = CheckForRebalance();
if (rebalance && sd_ != kDisconnectedSocketDescriptor) {
io__->CloseSocket(sd_, nullptr);
@@ -117,7 +119,7 @@ Error RequestHandlerTcp::ProcessRequestUnlocked(const Request* request){
if (err != nullptr ) continue;
}
- auto err = TrySendToReceiver(request,receiver_uri);
+ auto err = TrySendToReceiver(request, receiver_uri);
if (err != nullptr && err != ProducerErrorTemplates::kFileIdAlreadyInUse) {
io__->CloseSocket(sd_, nullptr);
sd_ = kDisconnectedSocketDescriptor;
@@ -138,7 +140,7 @@ bool RequestHandlerTcp::IsConnected() {
}
bool RequestHandlerTcp::CanCreateNewConnections() {
- return ncurrent_connections_ < discovery_service__->MaxConnections();
+ return (*ncurrent_connections_) < discovery_service__->MaxConnections();
}
bool RequestHandlerTcp::ReadyProcessRequest() {
@@ -149,8 +151,11 @@ void RequestHandlerTcp::PrepareProcessingRequestLocked() {
UpdateReceiversUriIfNewConnection();
}
-void RequestHandlerTcp::TearDownProcessingRequestLocked(const Error &error_from_process) {
- ncurrent_connections_--;
+void RequestHandlerTcp::TearDownProcessingRequestLocked(const Error& error_from_process) {
+ if (error_from_process) {
+ (*ncurrent_connections_)--;
+ }
+
}
}
diff --git a/producer/api/src/request_handler_tcp.h b/producer/api/src/request_handler_tcp.h
index 27f25e356..6ed212294 100644
--- a/producer/api/src/request_handler_tcp.h
+++ b/producer/api/src/request_handler_tcp.h
@@ -18,11 +18,11 @@ namespace asapo {
class RequestHandlerTcp: public RequestHandler {
public:
- explicit RequestHandlerTcp(ReceiverDiscoveryService* discovery_service,uint64_t thread_id);
+ explicit RequestHandlerTcp(ReceiverDiscoveryService* discovery_service, uint64_t thread_id, uint64_t* shared_counter);
Error ProcessRequestUnlocked(const Request* request) override;
bool ReadyProcessRequest() override;
void PrepareProcessingRequestLocked() override;
- void TearDownProcessingRequestLocked(const Error &error_from_process) override;
+ void TearDownProcessingRequestLocked(const Error& error_from_process) override;
virtual ~RequestHandlerTcp() = default;
std::unique_ptr<IO> io__;
@@ -30,20 +30,19 @@ class RequestHandlerTcp: public RequestHandler {
ReceiverDiscoveryService* discovery_service__;
private:
Error ConnectToReceiver(const std::string& receiver_address);
- Error SendHeaderAndData(const Request*,const std::string& receiver_address);
+ Error SendHeaderAndData(const Request*, const std::string& receiver_address);
Error ReceiveResponse(const std::string& receiver_address);
- Error TrySendToReceiver(const Request* request,const std::string& receiver_address);
+ Error TrySendToReceiver(const Request* request, const std::string& receiver_address);
SocketDescriptor sd_{kDisconnectedSocketDescriptor};
void UpdateReceiversUriIfNewConnection();
bool CheckForRebalance();
ReceiversList receivers_list_;
high_resolution_clock::time_point last_receivers_uri_update_;
- uint64_t ncurrent_connections_{0};
bool IsConnected();
bool CanCreateNewConnections();
uint64_t thread_id_;
-
- };
+ uint64_t* ncurrent_connections_;
+};
}
#endif //ASAPO_REQUEST_H
diff --git a/producer/api/src/request_pool.cpp b/producer/api/src/request_pool.cpp
index eba0be22f..8eb18321f 100644
--- a/producer/api/src/request_pool.cpp
+++ b/producer/api/src/request_pool.cpp
@@ -6,7 +6,7 @@ namespace asapo {
RequestPool:: RequestPool(uint8_t n_threads,
RequestHandlerFactory* request_handler_factory): log__{GetDefaultProducerLogger()},
- request_handler_factory__{request_handler_factory},
+ request_handler_factory__{request_handler_factory},
threads_{n_threads} {
for(size_t i = 0; i < threads_.size(); i++) {
log__->Debug("starting thread " + std::to_string(i));
@@ -40,7 +40,8 @@ void RequestPool::PutRequestBackToQueue(std::unique_ptr<Request> request) {
request_queue_.emplace_front(std::move(request));
}
-void RequestPool::ProcessRequest(const std::unique_ptr<RequestHandler>& request_handler,ThreadInformation* thread_info) {
+void RequestPool::ProcessRequest(const std::unique_ptr<RequestHandler>& request_handler,
+ ThreadInformation* thread_info) {
request_handler->PrepareProcessingRequestLocked();
@@ -57,14 +58,14 @@ void RequestPool::ProcessRequest(const std::unique_ptr<RequestHandler>& request_
void RequestPool::ThreadHandler(uint64_t id) {
ThreadInformation thread_info;
thread_info.lock = std::unique_lock<std::mutex>(mutex_);
- auto request_handler = request_handler_factory__->NewRequestHandler(id);
+ auto request_handler = request_handler_factory__->NewRequestHandler(id, &shared_counter_);
do {
- condition_.wait(thread_info.lock, [this,&request_handler] {
+ condition_.wait(thread_info.lock, [this, &request_handler] {
return (CanProcessRequest(request_handler) || quit_);
});
//after wait, we own the lock
if (!quit_) {
- ProcessRequest(request_handler,&thread_info);
+ ProcessRequest(request_handler, &thread_info);
};
} while (!quit_);
}
diff --git a/producer/api/src/request_pool.h b/producer/api/src/request_pool.h
index b4b0d4fd5..bfe0a9018 100644
--- a/producer/api/src/request_pool.h
+++ b/producer/api/src/request_pool.h
@@ -40,9 +40,10 @@ class RequestPool {
std::mutex mutex_;
std::deque<std::unique_ptr<Request>> request_queue_;
bool CanProcessRequest(const std::unique_ptr<RequestHandler>& request_handler);
- void ProcessRequest(const std::unique_ptr<RequestHandler>& request_handler,ThreadInformation* thread_info);
+ void ProcessRequest(const std::unique_ptr<RequestHandler>& request_handler, ThreadInformation* thread_info);
std::unique_ptr<Request> GetRequestFromQueue();
void PutRequestBackToQueue(std::unique_ptr<Request>request);
+ uint64_t shared_counter_{0};
};
diff --git a/producer/api/unittests/test_producer_impl.cpp b/producer/api/unittests/test_producer_impl.cpp
index 777c7779a..be807c26e 100644
--- a/producer/api/unittests/test_producer_impl.cpp
+++ b/producer/api/unittests/test_producer_impl.cpp
@@ -37,7 +37,7 @@ TEST(ProducerImpl, Constructor) {
class ProducerImplTests : public testing::Test {
public:
testing::NiceMock<MockDiscoveryService> service;
- asapo::RequestHandlerFactory factory{asapo::RequestHandlerType::kTcp,&service};
+ asapo::RequestHandlerFactory factory{asapo::RequestHandlerType::kTcp, &service};
testing::NiceMock<asapo::MockLogger> mock_logger;
testing::NiceMock<MockRequestPull> mock_pull{&factory};
asapo::ProducerImpl producer{"", 1};
@@ -67,7 +67,7 @@ TEST_F(ProducerImplTests, OKSendingRequest) {
uint64_t expected_size = 100;
Request request{asapo::GenericNetworkRequestHeader{}, nullptr, nullptr};
EXPECT_CALL(mock_pull, AddRequest_t(_)).WillOnce(Return(
- nullptr));
+ nullptr));
auto err = producer.Send(1, nullptr, expected_size, nullptr);
diff --git a/producer/api/unittests/test_request_handler_factory.cpp b/producer/api/unittests/test_request_handler_factory.cpp
index 34e91d2e9..8d3bb0b6d 100644
--- a/producer/api/unittests/test_request_handler_factory.cpp
+++ b/producer/api/unittests/test_request_handler_factory.cpp
@@ -18,9 +18,9 @@ TEST(CreateFactory, Tcp) {
MockDiscoveryService mock_discovery;
EXPECT_CALL(mock_discovery, StartCollectingData());
- RequestHandlerFactory factory{asapo::RequestHandlerType::kTcp,&mock_discovery};
+ RequestHandlerFactory factory{asapo::RequestHandlerType::kTcp, &mock_discovery};
- auto handler = factory.NewRequestHandler(1);
+ auto handler = factory.NewRequestHandler(1, nullptr);
ASSERT_THAT(dynamic_cast<asapo::RequestHandlerTcp*>(handler.get()), Ne(nullptr));
diff --git a/producer/api/unittests/test_request_handler_tcp.cpp b/producer/api/unittests/test_request_handler_tcp.cpp
index f923a3b52..538d8cc73 100644
--- a/producer/api/unittests/test_request_handler_tcp.cpp
+++ b/producer/api/unittests/test_request_handler_tcp.cpp
@@ -34,7 +34,7 @@ using ::testing::HasSubstr;
TEST(RequestHandlerTcp, Constructor) {
MockDiscoveryService ds;
- asapo::RequestHandlerTcp request{&ds,1};
+ asapo::RequestHandlerTcp request{&ds, 1, nullptr};
ASSERT_THAT(dynamic_cast<const asapo::IO*>(request.io__.get()), Ne(nullptr));
ASSERT_THAT(dynamic_cast<const asapo::AbstractLogger*>(request.log__), Ne(nullptr));
@@ -47,26 +47,26 @@ class RequestHandlerTcpTests : public testing::Test {
NiceMock<asapo::MockIO> mock_io;
NiceMock<MockDiscoveryService> mock_discovery_service;
- uint64_t expected_file_id = 42k;
+ uint64_t expected_file_id = 42;
uint64_t expected_file_size = 1337;
uint64_t expected_thread_id = 2;
- asapo::Opcode expected_op_code = asapo::kNetOpcodeSendData;
+ asapo::Opcode expected_op_code = asapo::kNetOpcodeSendData;
void* expected_file_pointer = (void*)0xC00FE;
asapo::Error callback_err;
asapo::GenericNetworkRequestHeader header{expected_op_code, expected_file_id, expected_file_size};
bool called = false;
asapo::GenericNetworkRequestHeader callback_header;
asapo::Request request{header, expected_file_pointer, [this](asapo::GenericNetworkRequestHeader header, asapo::Error err) {
- called = true;
- callback_err = std::move(err);
- callback_header = header;
- }};
+ called = true;
+ callback_err = std::move(err);
+ callback_header = header;
+ }};
asapo::Request request_nocallback{header, expected_file_pointer, nullptr};
testing::NiceMock<asapo::MockLogger> mock_logger;
-
- asapo::RequestHandlerTcp request_handler{&mock_discovery_service,expected_thread_id};
+ uint64_t n_connections{0};
+ asapo::RequestHandlerTcp request_handler{&mock_discovery_service, expected_thread_id, &n_connections};
asapo::SocketDescriptor sd = asapo::kDisconnectedSocketDescriptor;
std::string expected_address1 = {"127.0.0.1:9090"};
@@ -74,7 +74,7 @@ class RequestHandlerTcpTests : public testing::Test {
asapo::ReceiversList receivers_list{expected_address1, expected_address2};
asapo::ReceiversList receivers_list_single{expected_address1};
- std::vector<asapo::SocketDescriptor> expected_sds{83942, 83943};
+ std::vector<asapo::SocketDescriptor> expected_sds{83942, 83943};
void ExpectFailConnect(bool only_once = false);
void ExpectFailSendHeader(bool only_once = false);
@@ -84,7 +84,7 @@ class RequestHandlerTcpTests : public testing::Test {
void ExpectOKSendData(bool only_once = false);
void ExpectFailReceive(bool only_once = false);
void ExpectOKReceive(bool only_once = true);
- void DoSingleSend(bool success = true);
+ void DoSingleSend(bool connect = true, bool success = true);
void SetUp() override {
request_handler.log__ = &mock_logger;
@@ -262,25 +262,20 @@ void RequestHandlerTcpTests::ExpectOKReceive(bool only_once) {
}
}
-TEST_F(RequestHandlerTcpTests, CannotProcessRequestIfNotEnoughConnections) {
- EXPECT_CALL(mock_discovery_service, MaxConnections()).WillOnce(Return(0));
- auto res = request_handler.ReadyProcessRequest();
- ASSERT_THAT(res, Eq(false));
-}
-
-void RequestHandlerTcpTests::DoSingleSend(bool success) {
- if (success) ExpectOKConnect(true);
+void RequestHandlerTcpTests::DoSingleSend(bool connect, bool success) {
+ if (connect) ExpectOKConnect(true);
ExpectOKSendHeader(true);
ExpectOKSendData(true);
if (success) {
ExpectOKReceive(true);
- }else {
+ } else {
ExpectFailReceive(true);
}
-
- EXPECT_CALL(mock_discovery_service, RotatedUriList(_)).
+ if (connect) {
+ EXPECT_CALL(mock_discovery_service, RotatedUriList(_)).
WillOnce(Return(receivers_list_single));
+ }
request_handler.PrepareProcessingRequestLocked();
request_handler.ProcessRequestUnlocked(&request);
@@ -288,7 +283,12 @@ void RequestHandlerTcpTests::DoSingleSend(bool success) {
Mock::VerifyAndClearExpectations(&mock_io);
Mock::VerifyAndClearExpectations(&mock_logger);
Mock::VerifyAndClearExpectations(&mock_discovery_service);
+}
+TEST_F(RequestHandlerTcpTests, CannotProcessRequestIfNotEnoughConnections) {
+ EXPECT_CALL(mock_discovery_service, MaxConnections()).WillOnce(Return(0));
+ auto res = request_handler.ReadyProcessRequest();
+ ASSERT_THAT(res, Eq(false));
}
TEST_F(RequestHandlerTcpTests, CanProcessRequestIfAlreadyConnected) {
@@ -307,35 +307,26 @@ TEST_F(RequestHandlerTcpTests, GetsUriListINotConnected) {
TEST_F(RequestHandlerTcpTests, DoesNotGetsUriIfAlreadyConnected) {
DoSingleSend();
+ EXPECT_CALL(mock_discovery_service, RotatedUriList(_)).Times(0);
request_handler.PrepareProcessingRequestLocked();
}
TEST_F(RequestHandlerTcpTests, ReduceConnectionNumberAtTearDownIfError) {
- DoSingleSend(false);
-
auto err = asapo::TextError("error");
+ n_connections = 1;
request_handler.TearDownProcessingRequestLocked(err);
-
- EXPECT_CALL(mock_discovery_service, MaxConnections()).WillOnce(Return(1));
- auto res = request_handler.ReadyProcessRequest();
- ASSERT_THAT(res, Eq(true));
+ ASSERT_THAT(n_connections, Eq(0));
}
-
TEST_F(RequestHandlerTcpTests, DoNotReduceConnectionNumberAtTearDownIfNoError) {
- DoSingleSend(true);
- DoSingleSend(false);
-
- auto err = asapo::TextError("error");
- request_handler.TearDownProcessingRequestLocked(err);
+ n_connections = 1;
-// EXPECT_CALL(mock_discovery_service, MaxConnections()).WillOnce(Return(1));
- auto res = request_handler.ReadyProcessRequest();
- ASSERT_THAT(res, Eq(false));
+ request_handler.TearDownProcessingRequestLocked(nullptr);
+ ASSERT_THAT(n_connections, Eq(1));
}
diff --git a/producer/api/unittests/test_request_pool.cpp b/producer/api/unittests/test_request_pool.cpp
index a665ffcdc..d3b50af57 100644
--- a/producer/api/unittests/test_request_pool.cpp
+++ b/producer/api/unittests/test_request_pool.cpp
@@ -41,16 +41,15 @@ using asapo::GenericNetworkRequestHeader;
class MockRequestHandlerFactory : public asapo::RequestHandlerFactory {
- public:
- MockRequestHandlerFactory(RequestHandler* request_handler):
- RequestHandlerFactory(asapo::RequestHandlerType::kTcp, nullptr)
- {
- request_handler_ = request_handler;
- }
- std::unique_ptr<RequestHandler> NewRequestHandler(uint64_t thread_id) override {
- return std::unique_ptr<RequestHandler>{request_handler_};
- }
- private:
+ public:
+ MockRequestHandlerFactory(RequestHandler* request_handler):
+ RequestHandlerFactory(asapo::RequestHandlerType::kTcp, nullptr) {
+ request_handler_ = request_handler;
+ }
+ std::unique_ptr<RequestHandler> NewRequestHandler(uint64_t thread_id, uint64_t* shared_counter) override {
+ return std::unique_ptr<RequestHandler> {request_handler_};
+ }
+ private:
RequestHandler* request_handler_;
};
@@ -74,7 +73,7 @@ class RequestPoolTests : public testing::Test {
TEST(RequestPool, Constructor) {
NiceMock<MockDiscoveryService> ds;
- NiceMock<asapo::RequestHandlerFactory> request_handler_factory{asapo::RequestHandlerType::kTcp,&ds};
+ NiceMock<asapo::RequestHandlerFactory> request_handler_factory{asapo::RequestHandlerType::kTcp, &ds};
asapo::RequestPool pool{4, &request_handler_factory};
@@ -97,7 +96,7 @@ TEST_F(RequestPoolTests, NRequestsInQueue) {
ASSERT_THAT(nreq, Eq(0));
}
-void ExpectSend(MockRequestHandler* mock_handler,int ntimes = 1) {
+void ExpectSend(MockRequestHandler* mock_handler, int ntimes = 1) {
EXPECT_CALL(*mock_handler, ReadyProcessRequest()).Times(ntimes).WillRepeatedly(Return(true));
EXPECT_CALL(*mock_handler, PrepareProcessingRequestLocked()).Times(ntimes);
EXPECT_CALL(*mock_handler, ProcessRequestUnlocked_t(_)).Times(ntimes).WillRepeatedly(Return(nullptr));
@@ -121,7 +120,7 @@ TEST_F(RequestPoolTests, AddRequestCallsSendTwoRequests) {
Request* request2 = new Request{GenericNetworkRequestHeader{}, nullptr, nullptr};
- ExpectSend(mock_request_handler,2);
+ ExpectSend(mock_request_handler, 2);
--
GitLab