diff --git a/common/cpp/include/system_wrappers/io.h b/common/cpp/include/system_wrappers/io.h
index 607b56b76d825cdb388b51b6d4187dd7f5860967..a329ad37925ab3d6ed8d08adddd332a8415926cb 100644
--- a/common/cpp/include/system_wrappers/io.h
+++ b/common/cpp/include/system_wrappers/io.h
@@ -134,7 +134,9 @@ class IO {
SocketProtocols socket_protocol, Error* err) const = 0;
virtual void Listen(SocketDescriptor socket_fd, int backlog, Error* err) const = 0;
virtual void InetBind(SocketDescriptor socket_fd, const std::string& address, Error* err) const = 0;
- virtual std::unique_ptr<std::tuple<std::string, SocketDescriptor>> InetAccept(SocketDescriptor socket_fd,
+ virtual SocketDescriptor CreateAndBindIPTCPSocketListener(const std::string& address, int backlog,
+ Error* err) const = 0;
+ virtual std::unique_ptr<std::tuple<std::string, SocketDescriptor>> InetAcceptConnection(SocketDescriptor socket_fd,
Error* err) const = 0;
virtual std::string ResolveHostnameToIp(const std::string& hostname, Error* err) const = 0;
virtual void InetConnect(SocketDescriptor socket_fd, const std::string& address, Error* err) const = 0;
diff --git a/common/cpp/include/system_wrappers/system_io.h b/common/cpp/include/system_wrappers/system_io.h
index 0fd79ffae1d9b2ca32748bee03ee6b8d0f88271f..c979c7e5e52a941aad05145ff08c8f37731e8977 100644
--- a/common/cpp/include/system_wrappers/system_io.h
+++ b/common/cpp/include/system_wrappers/system_io.h
@@ -79,7 +79,9 @@ class SystemIO final : public IO {
Error* err) const;
void Listen(SocketDescriptor socket_fd, int backlog, Error* err) const;
void InetBind(SocketDescriptor socket_fd, const std::string& address, Error* err) const;
- std::unique_ptr<std::tuple<std::string, SocketDescriptor>> InetAccept(SocketDescriptor socket_fd, Error* err) const;
+ SocketDescriptor CreateAndBindIPTCPSocketListener(const std::string& address, int backlog, Error* err) const;
+ std::unique_ptr<std::tuple<std::string, SocketDescriptor>> InetAcceptConnection(SocketDescriptor socket_fd,
+ Error* err) const;
std::string ResolveHostnameToIp(const std::string& hostname, Error* err) const;
void InetConnect(SocketDescriptor socket_fd, const std::string& address, Error* err) const;
SocketDescriptor CreateAndConnectIPTCPSocket(const std::string& address, Error* err) const;
diff --git a/common/cpp/include/unittests/MockIO.h b/common/cpp/include/unittests/MockIO.h
index b1827f346b07a9abcdb2daa91f6b73de77a4795b..26f69e87a05cde3cb67b9b6534cc6d56a5f8cf48 100644
--- a/common/cpp/include/unittests/MockIO.h
+++ b/common/cpp/include/unittests/MockIO.h
@@ -38,8 +38,18 @@ class MockIO : public IO {
}
MOCK_CONST_METHOD3(InetBind_t, void(SocketDescriptor socket_fd, const std::string& address, ErrorInterface** err));
+ SocketDescriptor CreateAndBindIPTCPSocketListener(const std::string& address, int backlog, Error* err) const override {
+ ErrorInterface* error = nullptr;
+ auto data = CreateAndBindIPTCPSocketListener_t(address, backlog, &error);
+ err->reset(error);
+ return data;
+ }
+ MOCK_CONST_METHOD3(CreateAndBindIPTCPSocketListener_t, SocketDescriptor(const std::string& address, int backlog,
+ ErrorInterface** err));
+
- std::unique_ptr<std::tuple<std::string, SocketDescriptor>> InetAccept(SocketDescriptor socket_fd, Error* err) const {
+ std::unique_ptr<std::tuple<std::string, SocketDescriptor>> InetAcceptConnection(SocketDescriptor socket_fd,
+ Error* err) const {
ErrorInterface* error = nullptr;
auto data = InetAccept_t(socket_fd, &error);
err->reset(error);
diff --git a/common/cpp/src/system_io/system_io.cpp b/common/cpp/src/system_io/system_io.cpp
index 7a2878a5256cd3f945674363deba156d905d50f6..0a8106a5adb686075265c29232f2ce491550da60 100644
--- a/common/cpp/src/system_io/system_io.cpp
+++ b/common/cpp/src/system_io/system_io.cpp
@@ -261,7 +261,7 @@ void hidra2::SystemIO::InetConnect(SocketDescriptor socket_fd, const std::string
*err = nullptr;
}
-std::unique_ptr<std::tuple<std::string, SocketDescriptor>> SystemIO::InetAccept(SocketDescriptor socket_fd,
+std::unique_ptr<std::tuple<std::string, SocketDescriptor>> SystemIO::InetAcceptConnection(SocketDescriptor socket_fd,
Error* err) const {
static short family = AddressFamilyToPosixFamily(AddressFamilies::INET);
if (family == -1) {
@@ -417,6 +417,27 @@ void hidra2::SystemIO::Listen(SocketDescriptor socket_fd, int backlog, Error* er
}
}
+SocketDescriptor SystemIO::CreateAndBindIPTCPSocketListener(const std::string& address, int backlog, Error* err) const {
+ FileDescriptor listener_fd = CreateSocket(AddressFamilies::INET, SocketTypes::STREAM, SocketProtocols::IP, err);
+
+ if(*err) {
+ return -1;
+ }
+
+ InetBind(listener_fd, address, err);
+ if(*err) {
+ CloseSocket(listener_fd, nullptr);
+ return -1;
+ }
+
+ Listen(listener_fd, backlog, err);
+ if(*err) {
+ CloseSocket(listener_fd, nullptr);
+ return -1;
+ }
+
+ return listener_fd;
+}
size_t hidra2::SystemIO::ReceiveWithTimeout(SocketDescriptor socket_fd, void* buf, size_t length, long timeout_in_usec,
Error* err) const {
diff --git a/receiver/src/network_producer_peer_impl.h b/receiver/src/network_producer_peer_impl.h
index 10e1cdf18dfa77c36a85951ead2b469e81dd20ec..d334ed850126a9c01b52c2acf8b65eb586106857 100644
--- a/receiver/src/network_producer_peer_impl.h
+++ b/receiver/src/network_producer_peer_impl.h
@@ -15,7 +15,7 @@
namespace hidra2 {
class NetworkProducerPeerImpl : public NetworkProducerPeer, public HasIO {
- public:
+ public:
typedef void (* RequestHandler)(NetworkProducerPeerImpl* self, GenericNetworkRequest* request,
GenericNetworkResponse* response, Error* err);
struct RequestHandlerInformation {
@@ -23,7 +23,7 @@ class NetworkProducerPeerImpl : public NetworkProducerPeer, public HasIO {
size_t response_size;
RequestHandler handler;
};
- private:
+ private:
uint32_t connection_id_;
std::string address_;
int socket_fd_;
@@ -31,7 +31,7 @@ class NetworkProducerPeerImpl : public NetworkProducerPeer, public HasIO {
bool is_listening_ = false;
std::unique_ptr<std::thread> listener_thread_ = nullptr;
- public:
+ public:
static const std::vector<RequestHandlerInformation> kRequestHandlers;
static size_t kRequestHandlerMaxBufferSize;
@@ -53,19 +53,22 @@ class NetworkProducerPeerImpl : public NetworkProducerPeer, public HasIO {
virtual bool CheckIfValidFileSize(size_t file_size) const noexcept;
virtual bool CheckIfValidNetworkOpCode(Opcode opcode) const noexcept;
- public:
+ public:
/*
* Private functions but opened for unittest
*/
- virtual size_t HandleGenericRequest(GenericNetworkRequest* request, GenericNetworkResponse* response, Error* err) noexcept;
+ virtual size_t HandleGenericRequest(GenericNetworkRequest* request, GenericNetworkResponse* response,
+ Error* err) noexcept;
virtual void HandleSendDataRequest(const SendDataRequest* request, SendDataResponse* response, Error* err) noexcept;
//Preparation for up coming thread pool implementation
virtual void InternalPeerReceiverThreadEntryPoint() noexcept;
- virtual void InternalPeerReceiverDoWork(GenericNetworkRequest* request, GenericNetworkResponse* response, Error* err) noexcept;
- virtual void HandleRawRequestBuffer(GenericNetworkRequest* request, GenericNetworkResponse* response, Error* err) noexcept;
+ virtual void InternalPeerReceiverDoWork(GenericNetworkRequest* request, GenericNetworkResponse* response,
+ Error* err) noexcept;
+ virtual void HandleRawRequestBuffer(GenericNetworkRequest* request, GenericNetworkResponse* response,
+ Error* err) noexcept;
- private:
+ private:
static void HandleSendDataRequestInternalCaller(NetworkProducerPeerImpl* self,
const SendDataRequest* request,
SendDataResponse* response, Error* err) noexcept;
diff --git a/receiver/src/network_producer_peer_impl_handlers.cpp b/receiver/src/network_producer_peer_impl_handlers.cpp
index a19a43a0d2ab8600ec9a889d8fb7b2dc2d9a990a..4d82b5f846aba419a76ac9f7dfbb74092a3809d1 100644
--- a/receiver/src/network_producer_peer_impl_handlers.cpp
+++ b/receiver/src/network_producer_peer_impl_handlers.cpp
@@ -12,7 +12,7 @@ NetworkProducerPeerImpl::StaticInitRequestHandlerList() {
vec[kNetOpcodeSendData] = {
sizeof(SendDataRequest),
sizeof(SendDataResponse),
- (NetworkProducerPeerImpl::RequestHandler) &NetworkProducerPeerImpl::HandleSendDataRequestInternalCaller
+ (NetworkProducerPeerImpl::RequestHandler)& NetworkProducerPeerImpl::HandleSendDataRequestInternalCaller
};
for(RequestHandlerInformation& handler_information : vec) {
@@ -31,13 +31,14 @@ NetworkProducerPeerImpl::StaticInitRequestHandlerList() {
void NetworkProducerPeerImpl::HandleSendDataRequestInternalCaller(NetworkProducerPeerImpl* self,
- const SendDataRequest* request,
- SendDataResponse* response,
- Error* err) noexcept {
+ const SendDataRequest* request,
+ SendDataResponse* response,
+ Error* err) noexcept {
self->HandleSendDataRequest(request, response, err);
}
-void NetworkProducerPeerImpl::HandleSendDataRequest(const SendDataRequest* request, SendDataResponse* response, Error* err) noexcept {
+void NetworkProducerPeerImpl::HandleSendDataRequest(const SendDataRequest* request, SendDataResponse* response,
+ Error* err) noexcept {
ReceiveAndSaveFile(request->file_id, request->file_size, err);
if(!*err) {
diff --git a/receiver/src/receiver.cpp b/receiver/src/receiver.cpp
index 38a380ad40dcc804cae2cc578c2b84211cff7095..f7d16bcc894368618b958c5e82c317e02184311e 100644
--- a/receiver/src/receiver.cpp
+++ b/receiver/src/receiver.cpp
@@ -12,25 +12,13 @@ void hidra2::Receiver::StartListener(std::string listener_address, Error* err) {
*err = ReceiverErrorTemplates::kAlreadyListening.Generate();
return;
}
+ //TODO maybe use atomic exchange...
listener_running_ = true;
- FileDescriptor listener_fd = io->CreateSocket(AddressFamilies::INET, SocketTypes::STREAM, SocketProtocols::IP,
- err);
- if(*err) {
- listener_running_ = false;
- return;
- }
-
- io->InetBind(listener_fd, listener_address, err);
- if(*err) {
- io->CloseSocket(listener_fd, nullptr);
- listener_running_ = false;
- return;
- }
+ FileDescriptor listener_fd = io->CreateAndBindIPTCPSocketListener(listener_address, kMaxUnacceptedConnectionsBacklog,
+ err);
- io->Listen(listener_fd, kMaxUnacceptedConnectionsBacklog, err);
if(*err) {
- io->CloseSocket(listener_fd, nullptr);
listener_running_ = false;
return;
}
@@ -44,22 +32,28 @@ void hidra2::Receiver::StartListener(std::string listener_address, Error* err) {
}
void hidra2::Receiver::AcceptThreadLogic() {
+ Error err;
while(listener_running_) {
- std::string address;
- FileDescriptor peer_fd;
-
- Error err;
- auto client_info_tuple = io->InetAccept(listener_fd_, &err);
- if(err) {
- std::cerr << "An error occurred while accepting an incoming connection: " << err << std::endl;
- return;
- }
- std::tie(address, peer_fd) = *client_info_tuple;
-
- peer_list_.push_back(on_new_peer_(peer_fd, address));//TODO remove client when disconnect
+ err = nullptr;
+ AcceptThreadLogicWork(&err);
}
}
+void hidra2::Receiver::AcceptThreadLogicWork(hidra2::Error* err) {
+ std::string address;
+ FileDescriptor peer_fd;
+
+ //TODO: Use InetAcceptConnectionWithTimeout
+ auto client_info_tuple = io->InetAcceptConnection(listener_fd_, err);
+ if(*err) {
+ std::cerr << "An error occurred while accepting an incoming connection: " << err << std::endl;
+ return;
+ }
+ std::tie(address, peer_fd) = *client_info_tuple;
+
+ peer_list_.push_back(CreateNewPeer(peer_fd, address));//TODO remove client when disconnect
+}
+
void hidra2::Receiver::StopListener(Error* err) {
listener_running_ = false;
io->CloseSocket(listener_fd_, nullptr);
@@ -68,7 +62,8 @@ void hidra2::Receiver::StopListener(Error* err) {
accept_thread_ = nullptr;
}
-std::unique_ptr<hidra2::NetworkProducerPeer> hidra2::Receiver::on_new_peer_(int peer_socket_fd, std::string address) {
+std::unique_ptr<hidra2::NetworkProducerPeer> hidra2::Receiver::CreateNewPeer(int peer_socket_fd,
+ const std::string& address) {
auto peer = NetworkProducerPeer::CreateNetworkProducerPeer(peer_socket_fd, address);
std::cout << "[" << peer->GetConnectionId() << "] New connection from " << address << std::endl;
@@ -77,3 +72,7 @@ std::unique_ptr<hidra2::NetworkProducerPeer> hidra2::Receiver::on_new_peer_(int
return peer;
}
+
+const std::list<std::unique_ptr<hidra2::NetworkProducerPeer>>& hidra2::Receiver::GetConnectedPeers() {
+ return peer_list_;
+}
diff --git a/receiver/src/receiver.h b/receiver/src/receiver.h
index 5656a1fe705c228330819c0734c07fff885d9747..e06efa50a1ee661d9950ee228490ae4bac5d6eeb 100644
--- a/receiver/src/receiver.h
+++ b/receiver/src/receiver.h
@@ -16,10 +16,7 @@ class Receiver : public HasIO {
FileDescriptor listener_fd_ = -1;
std::unique_ptr<std::thread> accept_thread_ = nullptr;
- void AcceptThreadLogic();
std::list<std::unique_ptr<NetworkProducerPeer>> peer_list_;
- std::unique_ptr<NetworkProducerPeer> on_new_peer_(int peer_socket_fd, std::string address);
-
public:
static const int kMaxUnacceptedConnectionsBacklog;//TODO: Read from config
@@ -30,6 +27,13 @@ class Receiver : public HasIO {
void StartListener(std::string listener_address, Error* err);
void StopListener(Error* err);
+
+ std::unique_ptr<NetworkProducerPeer> CreateNewPeer(int peer_socket_fd, const std::string& address);
+ const std::list<std::unique_ptr<NetworkProducerPeer>>& GetConnectedPeers();
+
+ //Preparation for up coming thread pool implementation
+ void AcceptThreadLogic();
+ void AcceptThreadLogicWork(Error* err);
};
}
diff --git a/receiver/unittests/test_network_producer_peer_impl.cpp b/receiver/unittests/test_network_producer_peer_impl.cpp
index 949163075689f7febe548c02fb0003cc310616b3..b196f212075f8a7909b0049fe0e37a547fb6340b 100644
--- a/receiver/unittests/test_network_producer_peer_impl.cpp
+++ b/receiver/unittests/test_network_producer_peer_impl.cpp
@@ -65,10 +65,10 @@ TEST(CreateAndOpenFileByFileId, FolderUnknownIOError) {
hidra2::Error err;
EXPECT_CALL(mockIO, CreateNewDirectory_t("files", _))
- .Times(1)
- .WillOnce(
- testing::SetArgPointee<1>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release())
- );
+ .Times(1)
+ .WillOnce(
+ testing::SetArgPointee<1>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release())
+ );
NetworkProducerPeerImpl.CreateAndOpenFileByFileId(expected_file_id, &err);
ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kUnknownIOError));
}
@@ -83,22 +83,22 @@ TEST(CreateAndOpenFileByFileId, FolderAlreadyExsistsButFileAlreadyExists) {
hidra2::Error err;
EXPECT_CALL(mockIO, CreateNewDirectory_t("files", _))
- .Times(1)
- .WillOnce(
- testing::SetArgPointee<1>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release())
- );
+ .Times(1)
+ .WillOnce(
+ testing::SetArgPointee<1>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release())
+ );
EXPECT_CALL(mockIO, Open_t(
- "files/" + std::to_string(expected_file_id) + ".bin",
- hidra2::FileOpenMode::IO_OPEN_MODE_CREATE_AND_FAIL_IF_EXISTS |
- hidra2::FileOpenMode::IO_OPEN_MODE_RW, _))
- .Times(1)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<2>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release()),
- testing::Return(expected_fd)
- )
- );
+ "files/" + std::to_string(expected_file_id) + ".bin",
+ hidra2::FileOpenMode::IO_OPEN_MODE_CREATE_AND_FAIL_IF_EXISTS |
+ hidra2::FileOpenMode::IO_OPEN_MODE_RW, _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<2>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release()),
+ testing::Return(expected_fd)
+ )
+ );
hidra2::FileDescriptor fd = NetworkProducerPeerImpl.CreateAndOpenFileByFileId(expected_file_id, &err);
ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kFileAlreadyExists));
@@ -114,22 +114,22 @@ TEST(CreateAndOpenFileByFileId, FolderCreatedButFileAlreadyExists) {
hidra2::Error err;
EXPECT_CALL(mockIO, CreateNewDirectory_t("files", _))
- .Times(1)
- .WillOnce(
- testing::SetArgPointee<1>(nullptr)
- );
+ .Times(1)
+ .WillOnce(
+ testing::SetArgPointee<1>(nullptr)
+ );
EXPECT_CALL(mockIO, Open_t(
- "files/" + std::to_string(expected_file_id) + ".bin",
- hidra2::FileOpenMode::IO_OPEN_MODE_CREATE_AND_FAIL_IF_EXISTS |
- hidra2::FileOpenMode::IO_OPEN_MODE_RW, _))
- .Times(1)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<2>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release()),
- testing::Return(-1)
- )
- );
+ "files/" + std::to_string(expected_file_id) + ".bin",
+ hidra2::FileOpenMode::IO_OPEN_MODE_CREATE_AND_FAIL_IF_EXISTS |
+ hidra2::FileOpenMode::IO_OPEN_MODE_RW, _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<2>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release()),
+ testing::Return(-1)
+ )
+ );
hidra2::FileDescriptor fd = NetworkProducerPeerImpl.CreateAndOpenFileByFileId(expected_file_id, &err);
ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kFileAlreadyExists));
@@ -146,22 +146,22 @@ TEST(CreateAndOpenFileByFileId, Ok) {
hidra2::Error err;
EXPECT_CALL(mockIO, CreateNewDirectory_t("files", _))
- .Times(1)
- .WillOnce(
- testing::SetArgPointee<1>(nullptr)
- );
+ .Times(1)
+ .WillOnce(
+ testing::SetArgPointee<1>(nullptr)
+ );
EXPECT_CALL(mockIO, Open_t(
- "files/" + std::to_string(expected_file_id) + ".bin",
- hidra2::FileOpenMode::IO_OPEN_MODE_CREATE_AND_FAIL_IF_EXISTS |
- hidra2::FileOpenMode::IO_OPEN_MODE_RW, _))
- .Times(1)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<2>(nullptr),
- testing::Return(expected_fd)
- )
- );
+ "files/" + std::to_string(expected_file_id) + ".bin",
+ hidra2::FileOpenMode::IO_OPEN_MODE_CREATE_AND_FAIL_IF_EXISTS |
+ hidra2::FileOpenMode::IO_OPEN_MODE_RW, _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<2>(nullptr),
+ testing::Return(expected_fd)
+ )
+ );
hidra2::FileDescriptor fd = NetworkProducerPeerImpl.CreateAndOpenFileByFileId(expected_file_id, &err);
ASSERT_THAT(err, Eq(nullptr));
@@ -186,14 +186,14 @@ TEST(CheckIfValidNetworkOpCode, FalseOpcodeByNumber) {
TEST(CheckIfValidNetworkOpCode, FalseOpcodeByNegativNumber) {
hidra2::NetworkProducerPeerImpl NetworkProducerPeerImpl(0, "");
//Technically -1 is some big positive number since Opcode is an unsigned 8 bit number
- EXPECT_FALSE(NetworkProducerPeerImpl.CheckIfValidNetworkOpCode((hidra2::Opcode) -1));
+ EXPECT_FALSE(NetworkProducerPeerImpl.CheckIfValidNetworkOpCode((hidra2::Opcode) - 1));
}
class ReceiveAndSaveFileMock : public hidra2::NetworkProducerPeerImpl {
- public:
- ReceiveAndSaveFileMock(hidra2::SocketDescriptor socket_fd, const std::string &address) : NetworkProducerPeerImpl(
- socket_fd,
- address) {}
+ public:
+ ReceiveAndSaveFileMock(hidra2::SocketDescriptor socket_fd, const std::string& address) : NetworkProducerPeerImpl(
+ socket_fd,
+ address) {}
FileDescriptor CreateAndOpenFileByFileId(uint64_t file_id, Error* err) const noexcept override {
ErrorInterface* error = nullptr;
@@ -202,18 +202,18 @@ class ReceiveAndSaveFileMock : public hidra2::NetworkProducerPeerImpl {
return data;
}
MOCK_CONST_METHOD2(CreateAndOpenFileByFileId_t, FileDescriptor(uint64_t
- file_id, ErrorInterface * *err));
+ file_id, ErrorInterface * *err));
bool CheckIfValidFileSize(size_t file_size) const noexcept override {
return CheckIfValidFileSize_t(file_size);
}
MOCK_CONST_METHOD1(CheckIfValidFileSize_t, bool(size_t
- file_size));
+ file_size));
};
class ReceiveAndSaveFileFixture : public testing::Test {
- public:
+ public:
const hidra2::SocketDescriptor expected_socket_descriptor = 20;
const std::string expected_address = "somehost:13579";
const uint64_t expected_file_id = 314322;
@@ -235,9 +235,9 @@ TEST_F(ReceiveAndSaveFileFixture, CheckFileSizeError) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
- .WillOnce(
- Return(false)
- );
+ .WillOnce(
+ Return(false)
+ );
networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
@@ -248,15 +248,15 @@ TEST_F(ReceiveAndSaveFileFixture, CheckErrorWhenFileAlreadyExists) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
- .WillOnce(
- Return(true)
- );
+ .WillOnce(
+ Return(true)
+ );
EXPECT_CALL(*networkProducerPeer, CreateAndOpenFileByFileId_t(expected_file_id, _))
- .WillOnce(DoAll(
- SetArgPointee<1>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release()),
- Return(expected_fd))
- );
+ .WillOnce(DoAll(
+ SetArgPointee<1>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release()),
+ Return(expected_fd))
+ );
EXPECT_CALL(mockIO, Skip_t(_, _, _));
@@ -269,15 +269,15 @@ TEST_F(ReceiveAndSaveFileFixture, CheckErrorWhenUnknownErrorWhileOpenFile) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
- .WillOnce(
- Return(true)
- );
+ .WillOnce(
+ Return(true)
+ );
EXPECT_CALL(*networkProducerPeer, CreateAndOpenFileByFileId_t(expected_file_id, _))
- .WillOnce(DoAll(
- SetArgPointee<1>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
- Return(expected_fd))
- );
+ .WillOnce(DoAll(
+ SetArgPointee<1>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+ Return(expected_fd))
+ );
networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
@@ -288,21 +288,21 @@ TEST_F(ReceiveAndSaveFileFixture, CheckErrorWhenUnknownErrorWhileReceivingData)
err = nullptr;
EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
- .WillOnce(
- Return(true)
- );
+ .WillOnce(
+ Return(true)
+ );
EXPECT_CALL(*networkProducerPeer, CreateAndOpenFileByFileId_t(expected_file_id, _))
- .WillOnce(DoAll(
- SetArgPointee<1>(nullptr),
- Return(expected_fd)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<1>(nullptr),
+ Return(expected_fd)
+ ));
EXPECT_CALL(mockIO, Receive_t(expected_socket_descriptor, _, expected_file_size, _))
- .WillOnce(DoAll(
- SetArgPointee<3>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
- Return(-1)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<3>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+ Return(-1)
+ ));
networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
@@ -313,27 +313,27 @@ TEST_F(ReceiveAndSaveFileFixture, CheckErrorWhenUnknownErrorWhileSavingData) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
- .WillOnce(
- Return(true)
- );
+ .WillOnce(
+ Return(true)
+ );
EXPECT_CALL(*networkProducerPeer, CreateAndOpenFileByFileId_t(expected_file_id, _))
- .WillOnce(DoAll(
- SetArgPointee<1>(nullptr),
- Return(expected_fd)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<1>(nullptr),
+ Return(expected_fd)
+ ));
EXPECT_CALL(mockIO, Receive_t(expected_socket_descriptor, _, expected_file_size, _))
- .WillOnce(DoAll(
- SetArgPointee<3>(nullptr),
- Return(expected_file_size)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<3>(nullptr),
+ Return(expected_file_size)
+ ));
EXPECT_CALL(mockIO, Write_t(expected_fd, _, expected_file_size, _))
- .WillOnce(DoAll(
- SetArgPointee<3>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
- Return(expected_file_size)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<3>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+ Return(expected_file_size)
+ ));
networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
@@ -344,27 +344,27 @@ TEST_F(ReceiveAndSaveFileFixture, Ok) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, CheckIfValidFileSize_t(expected_file_size))
- .WillOnce(
- Return(true)
- );
+ .WillOnce(
+ Return(true)
+ );
EXPECT_CALL(*networkProducerPeer, CreateAndOpenFileByFileId_t(expected_file_id, _))
- .WillOnce(DoAll(
- SetArgPointee<1>(nullptr),
- Return(expected_fd)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<1>(nullptr),
+ Return(expected_fd)
+ ));
EXPECT_CALL(mockIO, Receive_t(expected_socket_descriptor, _, expected_file_size, _))
- .WillOnce(DoAll(
- SetArgPointee<3>(nullptr),
- Return(expected_file_size)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<3>(nullptr),
+ Return(expected_file_size)
+ ));
EXPECT_CALL(mockIO, Write_t(expected_fd, _, expected_file_size, _))
- .WillOnce(DoAll(
- SetArgPointee<3>(nullptr),
- Return(expected_file_size)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<3>(nullptr),
+ Return(expected_file_size)
+ ));
networkProducerPeer->ReceiveAndSaveFile(expected_file_id, expected_file_size, &err);
@@ -372,8 +372,8 @@ TEST_F(ReceiveAndSaveFileFixture, Ok) {
}
class HandleSendDataRequestMock : public ReceiveAndSaveFileMock {
- public:
- HandleSendDataRequestMock(SocketDescriptor socket_fd, const std::string &address)
+ public:
+ HandleSendDataRequestMock(SocketDescriptor socket_fd, const std::string& address)
: ReceiveAndSaveFileMock(socket_fd, address) {}
void ReceiveAndSaveFile(uint64_t file_id, size_t file_size, Error* err) const noexcept override {
@@ -382,12 +382,12 @@ class HandleSendDataRequestMock : public ReceiveAndSaveFileMock {
err->reset(error);
}
MOCK_CONST_METHOD3(ReceiveAndSaveFile_t, void(uint64_t
- file_id, size_t
- file_size, ErrorInterface * *err));
+ file_id, size_t
+ file_size, ErrorInterface * *err));
};
class HandleSendDataRequestFixture : public ReceiveAndSaveFileFixture {
- public:
+ public:
std::unique_ptr<HandleSendDataRequestMock> networkProducerPeer;
SendDataRequest send_data_request{};
@@ -406,9 +406,9 @@ TEST_F(HandleSendDataRequestFixture, Ok) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, ReceiveAndSaveFile_t(expected_file_id, expected_file_size, _))
- .WillOnce(
- SetArgPointee<2>(nullptr)
- );
+ .WillOnce(
+ SetArgPointee<2>(nullptr)
+ );
networkProducerPeer->HandleSendDataRequest(&send_data_request, &send_data_response, &err);
@@ -420,9 +420,9 @@ TEST_F(HandleSendDataRequestFixture, CheckErrorCodeWhenFileIdIsAlreadyUsed) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, ReceiveAndSaveFile_t(expected_file_id, expected_file_size, _))
- .WillOnce(
- SetArgPointee<2>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release())
- );
+ .WillOnce(
+ SetArgPointee<2>(hidra2::IOErrorTemplates::kFileAlreadyExists.Generate().release())
+ );
networkProducerPeer->HandleSendDataRequest(&send_data_request, &send_data_response, &err);
@@ -433,9 +433,9 @@ TEST_F(HandleSendDataRequestFixture, CheckErrorCodeWhenUnexpectedError) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, ReceiveAndSaveFile_t(expected_file_id, expected_file_size, _))
- .WillOnce(
- SetArgPointee<2>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release())
- );
+ .WillOnce(
+ SetArgPointee<2>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release())
+ );
networkProducerPeer->HandleSendDataRequest(&send_data_request, &send_data_response, &err);
@@ -443,8 +443,8 @@ TEST_F(HandleSendDataRequestFixture, CheckErrorCodeWhenUnexpectedError) {
}
class HandleGenericRequestMock : public HandleSendDataRequestMock {
- public:
- HandleGenericRequestMock(SocketDescriptor socket_fd, const std::string &address)
+ public:
+ HandleGenericRequestMock(SocketDescriptor socket_fd, const std::string& address)
: HandleSendDataRequestMock(socket_fd, address) {}
void HandleSendDataRequest(const SendDataRequest* request, SendDataResponse* response, Error* err) noexcept override {
@@ -452,7 +452,8 @@ class HandleGenericRequestMock : public HandleSendDataRequestMock {
HandleSendDataRequest_t(request, response, &error);
err->reset(error);
}
- MOCK_METHOD3(HandleSendDataRequest_t, void(const SendDataRequest* request, SendDataResponse* response, ErrorInterface** err));
+ MOCK_METHOD3(HandleSendDataRequest_t, void(const SendDataRequest* request, SendDataResponse* response,
+ ErrorInterface** err));
bool CheckIfValidNetworkOpCode(Opcode opcode) const noexcept override {
return CheckIfValidNetworkOpCode_t(opcode);
@@ -462,7 +463,7 @@ class HandleGenericRequestMock : public HandleSendDataRequestMock {
};
class HandleGenericRequestFixture : public HandleSendDataRequestFixture {
- public:
+ public:
std::unique_ptr<HandleGenericRequestMock> networkProducerPeer;
SendDataRequest generic_request{};
@@ -489,9 +490,9 @@ TEST_F(HandleGenericRequestFixture, CheckIfCheckIfValidNetworkOpCodeIsCalled) {
generic_request.request_id = expected_request_id;
EXPECT_CALL(*networkProducerPeer, CheckIfValidNetworkOpCode_t(expected_opcode))
- .WillOnce(
- Return(false)
- );
+ .WillOnce(
+ Return(false)
+ );
size_t return_size = networkProducerPeer->HandleGenericRequest(&generic_request, &generic_response, &err);
@@ -511,14 +512,14 @@ TEST_F(HandleGenericRequestFixture, CheckErrorWhenReceiveFails) {
generic_request.request_id = expected_request_id;
EXPECT_CALL(*networkProducerPeer, CheckIfValidNetworkOpCode_t(expected_opcode))
- .WillOnce(
- Return(true)
- );
+ .WillOnce(
+ Return(true)
+ );
EXPECT_CALL(mockIO, Receive_t(expected_socket_descriptor, _, expected_send_data_buffer_size, _))
- .WillOnce(DoAll(
- SetArgPointee<3>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
- Return(sizeof(expected_send_data_buffer_size))
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<3>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+ Return(sizeof(expected_send_data_buffer_size))
+ ));
size_t return_size = networkProducerPeer->HandleGenericRequest(&generic_request, &generic_response, &err);
ASSERT_THAT(return_size, Eq(0));
@@ -537,20 +538,20 @@ TEST_F(HandleGenericRequestFixture, CheckErrorWhenHandlerFails) {
generic_request.request_id = expected_request_id;
EXPECT_CALL(*networkProducerPeer, CheckIfValidNetworkOpCode_t(expected_opcode))
- .WillOnce(
- Return(true)
- );
+ .WillOnce(
+ Return(true)
+ );
EXPECT_CALL(mockIO, Receive_t(expected_socket_descriptor, _, expected_send_data_buffer_size, _))
- .WillOnce(DoAll(
- SetArgPointee<3>(nullptr),
- Return(sizeof(expected_send_data_buffer_size))
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<3>(nullptr),
+ Return(sizeof(expected_send_data_buffer_size))
+ ));
EXPECT_CALL(*networkProducerPeer, HandleSendDataRequest_t(_, _, _))
- .WillOnce(
- SetArgPointee<2>(hidra2::ErrorTemplates::kMemoryAllocationError.Generate().release())
- );
+ .WillOnce(
+ SetArgPointee<2>(hidra2::ErrorTemplates::kMemoryAllocationError.Generate().release())
+ );
size_t return_size = networkProducerPeer->HandleGenericRequest(&generic_request, &generic_response, &err);
@@ -570,20 +571,20 @@ TEST_F(HandleGenericRequestFixture, Ok) {
generic_request.request_id = expected_request_id;
EXPECT_CALL(*networkProducerPeer, CheckIfValidNetworkOpCode_t(expected_opcode))
- .WillOnce(
- Return(true)
- );
+ .WillOnce(
+ Return(true)
+ );
EXPECT_CALL(mockIO, Receive_t(expected_socket_descriptor, _, expected_send_data_buffer_size, _))
- .WillOnce(DoAll(
- SetArgPointee<3>(nullptr),
- Return(sizeof(expected_send_data_buffer_size))
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<3>(nullptr),
+ Return(sizeof(expected_send_data_buffer_size))
+ ));
EXPECT_CALL(*networkProducerPeer, HandleSendDataRequest_t(_, _, _))
- .WillOnce(
- SetArgPointee<2>(nullptr)
- );
+ .WillOnce(
+ SetArgPointee<2>(nullptr)
+ );
size_t return_size = networkProducerPeer->HandleGenericRequest(&generic_request, &generic_response, &err);
@@ -592,21 +593,23 @@ TEST_F(HandleGenericRequestFixture, Ok) {
}
class HandleRawRequestBufferMock : public HandleGenericRequestMock {
- public:
- HandleRawRequestBufferMock(SocketDescriptor socket_fd, const std::string &address)
+ public:
+ HandleRawRequestBufferMock(SocketDescriptor socket_fd, const std::string& address)
: HandleGenericRequestMock(socket_fd, address) {}
- size_t HandleGenericRequest(GenericNetworkRequest* request, GenericNetworkResponse* response, Error* err) noexcept override {
+ size_t HandleGenericRequest(GenericNetworkRequest* request, GenericNetworkResponse* response,
+ Error* err) noexcept override {
ErrorInterface* error = nullptr;
auto data = HandleGenericRequest_t(request, response, &error);
err->reset(error);
return data;
}
- MOCK_METHOD3(HandleGenericRequest_t, size_t(GenericNetworkRequest* request, GenericNetworkResponse* response, ErrorInterface** err));
+ MOCK_METHOD3(HandleGenericRequest_t, size_t(GenericNetworkRequest* request, GenericNetworkResponse* response,
+ ErrorInterface** err));
};
class HandleRawRequestBufferFixture : public HandleGenericRequestFixture {
- public:
+ public:
std::unique_ptr<HandleRawRequestBufferMock> networkProducerPeer;
void SetUp() override {
@@ -619,10 +622,10 @@ TEST_F(HandleRawRequestBufferFixture, CheckErrorWhenHandleGenericRequestFails) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, HandleGenericRequest_t(_, _, _))
- .WillOnce(DoAll(
- SetArgPointee<2>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
- Return(0)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<2>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+ Return(0)
+ ));
networkProducerPeer->HandleRawRequestBuffer(&generic_request, &generic_response, &err);
@@ -633,10 +636,10 @@ TEST_F(HandleRawRequestBufferFixture, ZeroReturnSize) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, HandleGenericRequest_t(_, _, _))
- .WillOnce(DoAll(
- SetArgPointee<2>(nullptr),
- Return(0)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<2>(nullptr),
+ Return(0)
+ ));
networkProducerPeer->HandleRawRequestBuffer(&generic_request, &generic_response, &err);
@@ -647,17 +650,17 @@ TEST_F(HandleRawRequestBufferFixture, SendResponseFaild) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, HandleGenericRequest_t(_, _, _))
- .WillOnce(DoAll(
- SetArgPointee<2>(nullptr),
- Return(expected_send_data_response_size)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<2>(nullptr),
+ Return(expected_send_data_response_size)
+ ));
EXPECT_CALL(mockIO, Send_t(expected_socket_descriptor, _, expected_send_data_response_size, _))
- .WillOnce(DoAll(
- SetArgPointee<3>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
- Return(0)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<3>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+ Return(0)
+ ));
networkProducerPeer->HandleRawRequestBuffer(&generic_request, &generic_response, &err);
@@ -668,17 +671,17 @@ TEST_F(HandleRawRequestBufferFixture, Ok) {
err = nullptr;
EXPECT_CALL(*networkProducerPeer, HandleGenericRequest_t(_, _, _))
- .WillOnce(DoAll(
- SetArgPointee<2>(nullptr),
- Return(expected_send_data_response_size)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<2>(nullptr),
+ Return(expected_send_data_response_size)
+ ));
EXPECT_CALL(mockIO, Send_t(expected_socket_descriptor, _, expected_send_data_response_size, _))
- .WillOnce(DoAll(
- SetArgPointee<3>(nullptr),
- Return(expected_send_data_response_size)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<3>(nullptr),
+ Return(expected_send_data_response_size)
+ ));
networkProducerPeer->HandleRawRequestBuffer(&generic_request, &generic_response, &err);
@@ -686,20 +689,22 @@ TEST_F(HandleRawRequestBufferFixture, Ok) {
}
class InternalPeerReceiverDoWorkMock : public HandleRawRequestBufferMock {
- public:
- InternalPeerReceiverDoWorkMock(SocketDescriptor socket_fd, const std::string &address)
+ public:
+ InternalPeerReceiverDoWorkMock(SocketDescriptor socket_fd, const std::string& address)
: HandleRawRequestBufferMock(socket_fd, address) {}
- void HandleRawRequestBuffer(GenericNetworkRequest* request, GenericNetworkResponse* response, Error* err) noexcept override {
+ void HandleRawRequestBuffer(GenericNetworkRequest* request, GenericNetworkResponse* response,
+ Error* err) noexcept override {
ErrorInterface* error = nullptr;
HandleRawRequestBuffer_t(request, response, &error);
err->reset(error);
}
- MOCK_METHOD3(HandleRawRequestBuffer_t, void(GenericNetworkRequest* request, GenericNetworkResponse* response, ErrorInterface** err));
+ MOCK_METHOD3(HandleRawRequestBuffer_t, void(GenericNetworkRequest* request, GenericNetworkResponse* response,
+ ErrorInterface** err));
};
class InternalPeerReceiverDoWorkFixture : public HandleRawRequestBufferFixture {
- public:
+ public:
std::unique_ptr<InternalPeerReceiverDoWorkMock> networkProducerPeer;
size_t expected_generic_request_size = sizeof(GenericNetworkRequest);
@@ -714,10 +719,10 @@ TEST_F(InternalPeerReceiverDoWorkFixture, CheckErrorWhenReceiveWithTimeoutFails)
err = nullptr;
EXPECT_CALL(mockIO, ReceiveWithTimeout_t(expected_socket_descriptor, _, expected_generic_request_size, _, _))
- .WillOnce(DoAll(
- SetArgPointee<4>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
- Return(0)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<4>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+ Return(0)
+ ));
networkProducerPeer->InternalPeerReceiverDoWork(&generic_request, &generic_response, &err);
@@ -728,10 +733,10 @@ TEST_F(InternalPeerReceiverDoWorkFixture, CheckErrorWhenReceiveWithTimeoutTimeou
err = nullptr;
EXPECT_CALL(mockIO, ReceiveWithTimeout_t(expected_socket_descriptor, _, expected_generic_request_size, _, _))
- .WillOnce(DoAll(
- SetArgPointee<4>(hidra2::IOErrorTemplates::kTimeout.Generate().release()),
- Return(0)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<4>(hidra2::IOErrorTemplates::kTimeout.Generate().release()),
+ Return(0)
+ ));
networkProducerPeer->InternalPeerReceiverDoWork(&generic_request, &generic_response, &err);
@@ -742,15 +747,15 @@ TEST_F(InternalPeerReceiverDoWorkFixture, HandleRawRequestBufferFails) {
err = nullptr;
EXPECT_CALL(mockIO, ReceiveWithTimeout_t(expected_socket_descriptor, _, expected_generic_request_size, _, _))
- .WillOnce(DoAll(
- SetArgPointee<4>(nullptr),
- Return(0)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<4>(nullptr),
+ Return(0)
+ ));
EXPECT_CALL(*networkProducerPeer, HandleRawRequestBuffer_t(_, _, _))
- .WillOnce(
- SetArgPointee<2>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release())
- );
+ .WillOnce(
+ SetArgPointee<2>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release())
+ );
networkProducerPeer->InternalPeerReceiverDoWork(&generic_request, &generic_response, &err);
@@ -761,15 +766,15 @@ TEST_F(InternalPeerReceiverDoWorkFixture, Ok) {
err = nullptr;
EXPECT_CALL(mockIO, ReceiveWithTimeout_t(expected_socket_descriptor, _, expected_generic_request_size, _, _))
- .WillOnce(DoAll(
- SetArgPointee<4>(nullptr),
- Return(0)
- ));
+ .WillOnce(DoAll(
+ SetArgPointee<4>(nullptr),
+ Return(0)
+ ));
EXPECT_CALL(*networkProducerPeer, HandleRawRequestBuffer_t(_, _, _))
- .WillOnce(
- SetArgPointee<2>(nullptr)
- );
+ .WillOnce(
+ SetArgPointee<2>(nullptr)
+ );
networkProducerPeer->InternalPeerReceiverDoWork(&generic_request, &generic_response, &err);
diff --git a/receiver/unittests/test_receiver.cpp b/receiver/unittests/test_receiver.cpp
index d2db9b3504c4ae1c68f698ad835388039faf4755..59b05cb41064f7c82157a6b79cd6461c3b91b4b0 100644
--- a/receiver/unittests/test_receiver.cpp
+++ b/receiver/unittests/test_receiver.cpp
@@ -7,44 +7,72 @@ using ::testing::Return;
using ::testing::_;
using ::testing::DoAll;
using ::testing::SetArgReferee;
+using ::testing::SetArgPointee;
using ::testing::Gt;
+using ::testing::Eq;
using ::testing::Mock;
using ::testing::InSequence;
+using ::hidra2::Error;
+using ::hidra2::FileDescriptor;
namespace {
-TEST(a, b) {
- hidra2::MockIO mockIO;
+class StartListenerMock : public hidra2::Receiver {
+ public:
- hidra2::Receiver receiver;
+};
-}
+class StartListenerFixture : public testing::Test {
+ public:
+ const hidra2::SocketDescriptor expected_socket_descriptor = 20;
+ const std::string expected_address = "somehost:13579";
+ const uint64_t expected_file_id = 314322;
+ const uint64_t expected_file_size = 784387;
+ const FileDescriptor expected_fd = 12643;
+
+ Error err;
-/*
- TEST(Receiver, start_Listener__InetBind_fail) {
hidra2::MockIO mockIO;
+ StartListenerMock receiver;
- hidra2::Receiver receiver;
+ void SetUp() override {
+ receiver.SetIO__(&mockIO);
+ }
+};
- receiver.SetIO__(&mockIO);
- InSequence sequence;
+TEST_F(StartListenerFixture, CreateAndBindIPTCPSocketListenerError) {
+ err = nullptr;
- std::string expected_address = "127.0.0.1:9876";
+ EXPECT_CALL(mockIO, CreateAndBindIPTCPSocketListener_t(expected_address, receiver.kMaxUnacceptedConnectionsBacklog, _))
+ .WillOnce(DoAll(
+ SetArgPointee<2>(hidra2::IOErrorTemplates::kUnknownIOError.Generate().release()),
+ Return(0)
+ ));
+
+ receiver.StartListener(expected_address, &err);
+
+ ASSERT_THAT(err, Eq(hidra2::IOErrorTemplates::kUnknownIOError));
+}
- EXPECT_CALL(mockIO, CreateSocket(hidra2::AddressFamilies::INET, hidra2::SocketTypes::STREAM,
- hidra2::SocketProtocols::IP, _))
- .Times(1)
+
+TEST_F(StartListenerFixture, Ok) {
+ err = nullptr;
+
+ EXPECT_CALL(mockIO, CreateAndBindIPTCPSocketListener_t(expected_address, receiver.kMaxUnacceptedConnectionsBacklog, _))
+ .WillOnce(DoAll(
+ SetArgPointee<2>(nullptr),
+ Return(0)
+ ));
+
+ EXPECT_CALL(mockIO, NewThread_t(_))
.WillOnce(
- DoAll(
- testing::SetArgPointee<3>(hidra2::IOErrors::kUnknownIOError),
- Return(-1)
- ));
-
- hidra2::ReceiverError receiver_error;
- receiver.StartListener(expected_address, &receiver_error);
- EXPECT_EQ(receiver_error, hidra2::ReceiverError::FailToCreateSocket);
+ Return(nullptr)
+ );
+
+ receiver.StartListener(expected_address, &err);
+
+ ASSERT_THAT(err, Eq(nullptr));
}
-*/
}
diff --git a/tests/system_io/ip_tcp_network/ip_tcp_network.cpp b/tests/system_io/ip_tcp_network/ip_tcp_network.cpp
index 0dc1f2a3f02d5b07e1477aa1823ed489cea82c32..9d077e9d2001134f4b66992a92397ba199e9a36b 100644
--- a/tests/system_io/ip_tcp_network/ip_tcp_network.cpp
+++ b/tests/system_io/ip_tcp_network/ip_tcp_network.cpp
@@ -48,8 +48,8 @@ std::unique_ptr<std::thread> CreateEchoServerThread() {
kThreadStarted.set_value();
for(int i = 0; i < kNumberOfChecks; i++) {
- std::cout << "[SERVER][" << i << "] InetAccept" << std::endl;
- auto client_info_tuple = io->InetAccept(socket, &err);
+ std::cout << "[SERVER][" << i << "] InetAcceptConnection" << std::endl;
+ auto client_info_tuple = io->InetAcceptConnection(socket, &err);
ExitIfErrIsNotOk(&err, 103);
std::string client_address;
FileDescriptor client_fd;
diff --git a/tests/system_io/ip_tcp_network_speedtest/ip_tcp_network_speedtest.cpp b/tests/system_io/ip_tcp_network_speedtest/ip_tcp_network_speedtest.cpp
index 2471403811a8759f7791d58e1ad95c657df9b077..32474803328dfda0735438832fdb5996b8ba3937 100644
--- a/tests/system_io/ip_tcp_network_speedtest/ip_tcp_network_speedtest.cpp
+++ b/tests/system_io/ip_tcp_network_speedtest/ip_tcp_network_speedtest.cpp
@@ -51,8 +51,8 @@ std::unique_ptr<std::thread> CreateEchoServerThread() {
ExitIfErrIsNotOk(&err, 102);
kThreadStarted.set_value();
- std::cout << "[SERVER] InetAccept" << std::endl;
- auto client_info_tuple = io->InetAccept(socket, &err);
+ std::cout << "[SERVER] InetAcceptConnection" << std::endl;
+ auto client_info_tuple = io->InetAcceptConnection(socket, &err);
ExitIfErrIsNotOk(&err, 103);
std::string client_address;
FileDescriptor client_fd;