diff --git a/common/cpp/include/system_wrappers/io.h b/common/cpp/include/system_wrappers/io.h
index 52bde3aebf6eaf9c40a4c54bdd945c27c090dd1c..0e9ec9e65920e9d4015e8a9f2fa20c4247ab27a6 100644
--- a/common/cpp/include/system_wrappers/io.h
+++ b/common/cpp/include/system_wrappers/io.h
@@ -68,45 +68,46 @@ class IO {
/*
* Special
*/
- virtual FileData GetDataFromFile(const std::string& fname, uint64_t fsize, IOErrors* err) = 0;
- virtual std::vector<FileInfo> FilesInFolder (const std::string& folder, IOErrors* err) = 0;
+ virtual FileData GetDataFromFile(const std::string& fname, uint64_t fsize, IOErrors* err) const = 0;
+ virtual std::vector<FileInfo> FilesInFolder (const std::string& folder, IOErrors* err) const = 0;
- virtual std::thread* NewThread (std::function<void()> function) = 0;
+ virtual std::thread* NewThread (std::function<void()> function) const = 0;
/*
* Network
*/
virtual FileDescriptor CreateSocket (AddressFamilies address_family, SocketTypes socket_type,
- SocketProtocols socket_protocol, IOErrors* err) = 0;
- virtual void Listen (FileDescriptor socket_fd, int backlog, IOErrors* err) = 0;
+ SocketProtocols socket_protocol, IOErrors* err) const = 0;
+ virtual void Listen (FileDescriptor socket_fd, int backlog, IOErrors* err) const = 0;
virtual void InetBind (FileDescriptor socket_fd, const std::string& address, uint16_t port,
- IOErrors* err) = 0;
+ IOErrors* err) const = 0;
virtual std::unique_ptr<std::tuple<std::string, FileDescriptor>> InetAccept(FileDescriptor socket_fd,
- IOErrors* err) = 0;
- virtual void InetConnect (FileDescriptor socket_fd, const std::string& address, IOErrors* err) = 0;
- virtual FileDescriptor CreateAndConnectIPTCPSocket(const std::string& address, IOErrors* err) = 0;
+ IOErrors* err) const = 0;
+ virtual void InetConnect (FileDescriptor socket_fd, const std::string& address, IOErrors* err) const = 0;
+ virtual FileDescriptor CreateAndConnectIPTCPSocket(const std::string& address, IOErrors* err) const = 0;
- virtual size_t Receive (FileDescriptor socket_fd, void* buf, size_t length, IOErrors* err) = 0;
+ virtual size_t Receive (FileDescriptor socket_fd, void* buf, size_t length, IOErrors* err) const = 0;
virtual size_t ReceiveTimeout (FileDescriptor socket_fd,
void* buf,
size_t length,
uint16_t timeout_in_sec,
- IOErrors* err) = 0;
- virtual size_t Send (FileDescriptor socket_fd, const void* buf, size_t length, IOErrors* err) = 0;
- virtual void Skip (FileDescriptor socket_fd, size_t length, IOErrors* err) = 0;
+ IOErrors* err) const = 0;
+ virtual size_t Send (FileDescriptor socket_fd, const void* buf, size_t length,
+ IOErrors* err) const = 0;
+ virtual void Skip (FileDescriptor socket_fd, size_t length, IOErrors* err) const = 0;
/*
* Filesystem
*/
- virtual FileDescriptor Open (const std::string& filename, int open_flags, IOErrors* err) = 0;
+ virtual FileDescriptor Open (const std::string& filename, int open_flags, IOErrors* err) const = 0;
/**
* @param err Since close if often used in an error case, it's able to accept nullptr.
*/
- virtual void Close (FileDescriptor fd, IOErrors* err) = 0;
+ virtual void Close (FileDescriptor fd, IOErrors* err) const = 0;
- virtual size_t Write (FileDescriptor fd, const void* buf, size_t length, IOErrors* err) = 0;
+ virtual size_t Write (FileDescriptor fd, const void* buf, size_t length, IOErrors* err) const = 0;
- virtual void CreateDirectory(const std::string& directory_name, hidra2::IOErrors* err) = 0;
+ virtual void CreateDirectory(const std::string& directory_name, hidra2::IOErrors* err) const = 0;
};
}
diff --git a/common/cpp/include/system_wrappers/system_io.h b/common/cpp/include/system_wrappers/system_io.h
index 2a813431b7f736e7958cb47ea57489a55bc0ecfb..ee0e29877704eb3a81d1adabeb0e7b2e265dd49b 100644
--- a/common/cpp/include/system_wrappers/system_io.h
+++ b/common/cpp/include/system_wrappers/system_io.h
@@ -12,41 +12,41 @@ class SystemIO final : public IO {
/*
* Special
*/
- std::thread* NewThread(std::function<void()> function);
- FileData GetDataFromFile(const std::string& fname, uint64_t fsize, IOErrors* err);
+ std::thread* NewThread(std::function<void()> function) const;
+ FileData GetDataFromFile(const std::string& fname, uint64_t fsize, IOErrors* err) const;
// this is not standard function - to be implemented differently in windows and linux
- std::vector<FileInfo> FilesInFolder (const std::string& folder, IOErrors* err);
+ std::vector<FileInfo> FilesInFolder (const std::string& folder, IOErrors* err) const;
/*
* Network
*/
FileDescriptor CreateSocket(AddressFamilies address_family, SocketTypes socket_type,
- SocketProtocols socket_protocol, IOErrors* err);
- void Listen(FileDescriptor socket_fd, int backlog, IOErrors* err);
+ SocketProtocols socket_protocol, IOErrors* err) const;
+ void Listen(FileDescriptor socket_fd, int backlog, IOErrors* err) const;
void InetBind(FileDescriptor socket_fd, const std::string& address, uint16_t port,
- IOErrors* err);
- std::unique_ptr<std::tuple<std::string, FileDescriptor>> InetAccept(FileDescriptor socket_fd, IOErrors* err);
- void InetConnect(FileDescriptor socket_fd, const std::string& address, IOErrors* err);
- FileDescriptor CreateAndConnectIPTCPSocket(const std::string& address, IOErrors* err);
+ IOErrors* err) const;
+ std::unique_ptr<std::tuple<std::string, FileDescriptor>> InetAccept(FileDescriptor socket_fd, IOErrors* err) const;
+ void InetConnect(FileDescriptor socket_fd, const std::string& address, IOErrors* err) const;
+ FileDescriptor CreateAndConnectIPTCPSocket(const std::string& address, IOErrors* err) const;
- size_t Receive(FileDescriptor socket_fd, void* buf, size_t length, IOErrors* err);
+ size_t Receive(FileDescriptor socket_fd, void* buf, size_t length, IOErrors* err) const;
size_t ReceiveTimeout(FileDescriptor socket_fd,
void* buf,
size_t length,
uint16_t timeout_in_sec,
- IOErrors* err);
- size_t Send(FileDescriptor socket_fd, const void* buf, size_t length, IOErrors* err);
- void Skip(FileDescriptor socket_fd, size_t length, IOErrors* err);
+ IOErrors* err) const;
+ size_t Send(FileDescriptor socket_fd, const void* buf, size_t length, IOErrors* err) const;
+ void Skip(FileDescriptor socket_fd, size_t length, IOErrors* err) const;
/*
* Filesystem
*/
- FileDescriptor Open(const std::string& filename, int open_flags, IOErrors* err);
- void Close(FileDescriptor fd, IOErrors* err);
- size_t Write(FileDescriptor fd, const void* buf, size_t length, IOErrors* err);
- uint64_t Read(int fd, uint8_t* array, uint64_t fsize, IOErrors* err) const noexcept;
- void CreateDirectory(const std::string& directory_name, hidra2::IOErrors* err);
+ FileDescriptor Open(const std::string& filename, int open_flags, IOErrors* err) const;
+ void Close(FileDescriptor fd, IOErrors* err) const;
+ size_t Write(FileDescriptor fd, const void* buf, size_t length, IOErrors* err) const;
+ uint64_t Read(int fd, uint8_t* array, uint64_t fsize, IOErrors* err) const;
+ void CreateDirectory(const std::string& directory_name, hidra2::IOErrors* err) const;
};
}
diff --git a/common/cpp/src/system_io.cpp b/common/cpp/src/system_io.cpp
index c1b723edd8bb1079ed8394e60688f7c0f8c1ab67..9890158053a6f73c976ad69897fdfb6ca308f7fb 100644
--- a/common/cpp/src/system_io.cpp
+++ b/common/cpp/src/system_io.cpp
@@ -9,11 +9,11 @@ namespace hidra2 {
* THIS FILE HOLDS GENERAL FUNCTIONS THAT CAN BE USED ON WINDOWS AND ON LINUX *
*******************************************************************************/
-std::thread* hidra2::SystemIO::NewThread(std::function<void()> function) {
+std::thread* hidra2::SystemIO::NewThread(std::function<void()> function) const {
return new std::thread(function);
}
-void hidra2::SystemIO::Skip(hidra2::FileDescriptor socket_fd, size_t length, hidra2::IOErrors* err) {
+void hidra2::SystemIO::Skip(hidra2::FileDescriptor socket_fd, size_t length, hidra2::IOErrors* err) const {
static const size_t kSkipBufferSize = 1024;
//TODO need to find a better way to skip bytes
@@ -40,7 +40,7 @@ void hidra2::SystemIO::Skip(hidra2::FileDescriptor socket_fd, size_t length, hid
}
hidra2::FileDescriptor hidra2::SystemIO::CreateAndConnectIPTCPSocket(const std::string& address,
- hidra2::IOErrors* err) {
+ hidra2::IOErrors* err) const {
*err = hidra2::IOErrors::kNoError;
FileDescriptor fd = CreateSocket(AddressFamilies::INET, SocketTypes::STREAM, SocketProtocols::IP, err);
diff --git a/common/cpp/src/system_io_linux.cpp b/common/cpp/src/system_io_linux.cpp
index 598b51a8c57c68cace399de5b45bb08c2f312d38..d4d7b83ddb8f83db2aec84f75ef6bba838adf1bc 100644
--- a/common/cpp/src/system_io_linux.cpp
+++ b/common/cpp/src/system_io_linux.cpp
@@ -177,7 +177,7 @@ void CollectFileInformationRecursivly(const std::string& path,
hidra2::FileDescriptor hidra2::SystemIO::CreateSocket(hidra2::AddressFamilies address_family,
hidra2::SocketTypes socket_type,
hidra2::SocketProtocols socket_protocol,
- hidra2::IOErrors* err) {
+ hidra2::IOErrors* err) const {
*err = IOErrors::kNoError;
int domain = AddressFamilyToPosixFamily(address_family);
@@ -221,7 +221,7 @@ hidra2::FileDescriptor hidra2::SystemIO::CreateSocket(hidra2::AddressFamilies ad
void hidra2::SystemIO::InetBind(hidra2::FileDescriptor socket_fd,
const std::string& address,
uint16_t port,
- hidra2::IOErrors* err) {
+ hidra2::IOErrors* err) const {
*err = IOErrors::kNoError;
sa_family_t family = AddressFamilyToPosixFamily(AddressFamilies::INET);
@@ -241,7 +241,7 @@ void hidra2::SystemIO::InetBind(hidra2::FileDescriptor socket_fd,
}
-void hidra2::SystemIO::Listen(hidra2::FileDescriptor socket_fd, int backlog, hidra2::IOErrors* err) {
+void hidra2::SystemIO::Listen(hidra2::FileDescriptor socket_fd, int backlog, hidra2::IOErrors* err) const {
*err = IOErrors::kNoError;
if(::listen(socket_fd, backlog) == -1) {
@@ -250,7 +250,7 @@ void hidra2::SystemIO::Listen(hidra2::FileDescriptor socket_fd, int backlog, hid
}
std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>> hidra2::SystemIO::InetAccept(
- hidra2::FileDescriptor socket_fd, IOErrors* err) {
+hidra2::FileDescriptor socket_fd, IOErrors* err) const {
*err = IOErrors::kNoError;
sa_family_t family = AddressFamilyToPosixFamily(AddressFamilies::INET);
if(family == -1) {
@@ -273,7 +273,7 @@ std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>> hidra2::SystemI
std::tuple<std::string, hidra2::FileDescriptor>(address, peer_fd));
}
-void hidra2::SystemIO::InetConnect(FileDescriptor socket_fd, const std::string& address, hidra2::IOErrors* err) {
+void hidra2::SystemIO::InetConnect(FileDescriptor socket_fd, const std::string& address, hidra2::IOErrors* err) const {
*err = IOErrors::kNoError;
std::string host;
uint16_t port = 0;
@@ -305,7 +305,8 @@ void hidra2::SystemIO::InetConnect(FileDescriptor socket_fd, const std::string&
}
}
-size_t hidra2::SystemIO::Receive(hidra2::FileDescriptor socket_fd, void* buf, size_t length, hidra2::IOErrors* err) {
+size_t hidra2::SystemIO::Receive(hidra2::FileDescriptor socket_fd, void* buf, size_t length,
+ hidra2::IOErrors* err) const {
*err = hidra2::IOErrors::kNoError;
size_t already_received = 0;
@@ -330,7 +331,7 @@ size_t hidra2::SystemIO::ReceiveTimeout(hidra2::FileDescriptor socket_fd,
void* buf,
size_t length,
uint16_t timeout_in_sec,
- hidra2::IOErrors* err) {
+ hidra2::IOErrors* err) const {
*err = hidra2::IOErrors::kNoError;
fd_set read_fds;
@@ -355,7 +356,7 @@ size_t hidra2::SystemIO::ReceiveTimeout(hidra2::FileDescriptor socket_fd,
size_t hidra2::SystemIO::Send(hidra2::FileDescriptor socket_fd,
const void* buf,
size_t length,
- hidra2::IOErrors* err) {
+ hidra2::IOErrors* err) const {
*err = hidra2::IOErrors::kNoError;
size_t already_sent = 0;
@@ -378,7 +379,7 @@ size_t hidra2::SystemIO::Send(hidra2::FileDescriptor socket_fd,
hidra2::FileDescriptor hidra2::SystemIO::Open(const std::string& filename,
int open_flags,
- IOErrors* err) {
+ IOErrors* err) const {
*err = IOErrors::kNoError;
int flags = FileOpenModeToPosixFileOpenMode(open_flags);
@@ -390,7 +391,7 @@ hidra2::FileDescriptor hidra2::SystemIO::Open(const std::string& filename,
return fd;
}
-void hidra2::SystemIO::Close(hidra2::FileDescriptor fd, hidra2::IOErrors* err) {
+void hidra2::SystemIO::Close(hidra2::FileDescriptor fd, hidra2::IOErrors* err) const {
int status = ::close(fd);
if(!err) {
return;
@@ -400,7 +401,7 @@ void hidra2::SystemIO::Close(hidra2::FileDescriptor fd, hidra2::IOErrors* err) {
*err = IOErrorsFromErrno();
}
}
-size_t hidra2::SystemIO::Write(FileDescriptor fd, const void* buf, size_t length, IOErrors* err) {
+size_t hidra2::SystemIO::Write(FileDescriptor fd, const void* buf, size_t length, IOErrors* err) const {
*err = hidra2::IOErrors::kNoError;
size_t already_sent = 0;
@@ -420,7 +421,7 @@ size_t hidra2::SystemIO::Write(FileDescriptor fd, const void* buf, size_t length
return already_sent;
}
-void hidra2::SystemIO::CreateDirectory(const std::string& directory_name, hidra2::IOErrors* err) {
+void hidra2::SystemIO::CreateDirectory(const std::string& directory_name, hidra2::IOErrors* err) const {
*err = IOErrors::kNoError;
struct stat st = {0};
int result = ::stat(directory_name.c_str(), &st);
@@ -437,10 +438,10 @@ void hidra2::SystemIO::CreateDirectory(const std::string& directory_name, hidra2
}
hidra2::FileData hidra2::SystemIO::GetDataFromFile(const std::string& fname,
uint64_t fsize,
- hidra2::IOErrors* err) {
+ hidra2::IOErrors* err) const {
return hidra2::FileData();
}
-vector<hidra2::FileInfo> hidra2::SystemIO::FilesInFolder(const std::string& folder, hidra2::IOErrors* err) {
+vector<hidra2::FileInfo> hidra2::SystemIO::FilesInFolder(const std::string& folder, hidra2::IOErrors* err) const {
return vector<hidra2::FileInfo>();
}
diff --git a/common/cpp/unittests/MockIO.h b/common/cpp/unittests/MockIO.h
index b17c4c06d46abab5aa7ba3bbd3090ffe62792090..c556ef240402b97db2922fa19577bff0c1edcd8d 100644
--- a/common/cpp/unittests/MockIO.h
+++ b/common/cpp/unittests/MockIO.h
@@ -7,27 +7,31 @@
namespace hidra2 {
class MockIO : public IO {
- public:
- MOCK_METHOD3(GetDataFromFile, FileData(const std::string& fname, uint64_t fsize, IOErrors* err));
- MOCK_METHOD2(FilesInFolder, std::vector<FileInfo>(const std::string& folder, IOErrors* err));
- MOCK_METHOD1(NewThread, std::thread*(std::function<void()> function));
- MOCK_METHOD4(CreateSocket, FileDescriptor(AddressFamilies address_family, SocketTypes socket_type, SocketProtocols socket_protocol, IOErrors* err));
- MOCK_METHOD3(Listen, void(FileDescriptor socket_fd, int backlog, IOErrors* err));
- MOCK_METHOD4(InetBind, void(FileDescriptor socket_fd, const std::string& address, uint16_t port, IOErrors* err));
- virtual std::unique_ptr<std::tuple<std::string, FileDescriptor>> InetAccept(FileDescriptor socket_fd, IOErrors* err) {
+ public:
+ MOCK_CONST_METHOD3(GetDataFromFile, FileData(const std::string& fname, uint64_t fsize, IOErrors* err));
+ MOCK_CONST_METHOD2(FilesInFolder, std::vector<FileInfo>(const std::string& folder, IOErrors* err));
+ MOCK_CONST_METHOD1(NewThread, std::thread * (std::function<void()> function));
+ MOCK_CONST_METHOD4(CreateSocket, FileDescriptor(AddressFamilies address_family, SocketTypes socket_type,
+ SocketProtocols socket_protocol, IOErrors* err));
+ MOCK_CONST_METHOD3(Listen, void(FileDescriptor socket_fd, int backlog, IOErrors* err));
+ MOCK_CONST_METHOD4(InetBind, void(FileDescriptor socket_fd, const std::string& address, uint16_t port, IOErrors* err));
+ virtual std::unique_ptr<std::tuple<std::string, FileDescriptor>> InetAccept(FileDescriptor socket_fd,
+ IOErrors* err) const {
return std::unique_ptr<std::tuple<std::string, FileDescriptor>>(InetAccept_proxy(socket_fd, err));
}
- MOCK_METHOD2(InetAccept_proxy, std::tuple<std::string, FileDescriptor>* (FileDescriptor socket_fd, IOErrors* err));
- MOCK_METHOD3(InetConnect, void(FileDescriptor socket_fd, const std::string& address, IOErrors* err));
- MOCK_METHOD2(CreateAndConnectIPTCPSocket, FileDescriptor(const std::string& address, IOErrors* err));
- MOCK_METHOD4(Receive, size_t(FileDescriptor socket_fd, void* buf, size_t length, IOErrors* err));
- MOCK_METHOD5(ReceiveTimeout, size_t(FileDescriptor socket_fd, void* buf, size_t length, uint16_t timeout_in_sec, IOErrors* err));
- MOCK_METHOD4(Send, size_t(FileDescriptor socket_fd, const void* buf, size_t length, IOErrors* err));
- MOCK_METHOD3(Skip, void(FileDescriptor socket_fd, size_t length, IOErrors* err));
- MOCK_METHOD3(Open, FileDescriptor(const std::string& filename, int open_flags, IOErrors* err));
- MOCK_METHOD2(Close, void(FileDescriptor, IOErrors*));
- MOCK_METHOD4(Write, size_t(FileDescriptor fd, const void* buf, size_t length, IOErrors* err));
- MOCK_METHOD2(CreateDirectory, void(const std::string& directory_name, hidra2::IOErrors* err));
+ MOCK_CONST_METHOD2(InetAccept_proxy, std::tuple<std::string, FileDescriptor>* (FileDescriptor socket_fd,
+ IOErrors* err));
+ MOCK_CONST_METHOD3(InetConnect, void(FileDescriptor socket_fd, const std::string& address, IOErrors* err));
+ MOCK_CONST_METHOD2(CreateAndConnectIPTCPSocket, FileDescriptor(const std::string& address, IOErrors* err));
+ MOCK_CONST_METHOD4(Receive, size_t(FileDescriptor socket_fd, void* buf, size_t length, IOErrors* err));
+ MOCK_CONST_METHOD5(ReceiveTimeout, size_t(FileDescriptor socket_fd, void* buf, size_t length, uint16_t timeout_in_sec,
+ IOErrors* err));
+ MOCK_CONST_METHOD4(Send, size_t(FileDescriptor socket_fd, const void* buf, size_t length, IOErrors* err));
+ MOCK_CONST_METHOD3(Skip, void(FileDescriptor socket_fd, size_t length, IOErrors* err));
+ MOCK_CONST_METHOD3(Open, FileDescriptor(const std::string& filename, int open_flags, IOErrors* err));
+ MOCK_CONST_METHOD2(Close, void(FileDescriptor, IOErrors*));
+ MOCK_CONST_METHOD4(Write, size_t(FileDescriptor fd, const void* buf, size_t length, IOErrors* err));
+ MOCK_CONST_METHOD2(CreateDirectory, void(const std::string& directory_name, hidra2::IOErrors* err));
};
}
diff --git a/examples/producer/dummy-data-producer/CMakeLists.txt b/examples/producer/dummy-data-producer/CMakeLists.txt
index c137167f63cc43b4b057d533aac0329e23dbb552..4e5aa4d1b7f57024d1bcd60de52a03436ca0a5ee 100644
--- a/examples/producer/dummy-data-producer/CMakeLists.txt
+++ b/examples/producer/dummy-data-producer/CMakeLists.txt
@@ -7,3 +7,7 @@ add_executable(${TARGET_NAME} ${SOURCE_FILES} $<TARGET_OBJECTS:common>)
target_include_directories(${TARGET_NAME} PUBLIC include ${CMAKE_SOURCE_DIR}/common/cpp/include)
target_link_libraries(${TARGET_NAME} pthread producer-api)
set_target_properties(${TARGET_NAME} PROPERTIES LINKER_LANGUAGE CXX)
+
+if (CMAKE_COMPILER_IS_GNUCXX)
+ set_target_properties(${TARGET_NAME} PROPERTIES LINK_FLAGS_DEBUG "--coverage")
+endif()
diff --git a/examples/producer/dummy-data-producer/dummy_data_producer.cpp b/examples/producer/dummy-data-producer/dummy_data_producer.cpp
index ede97a0a878fe3a096911e537d38d0d8e0feffcd..5edf2c634f5ca6630adce9e126747c528ae378a2 100644
--- a/examples/producer/dummy-data-producer/dummy_data_producer.cpp
+++ b/examples/producer/dummy-data-producer/dummy_data_producer.cpp
@@ -33,7 +33,7 @@ int SendDummyData(const std::string& receiver_address, size_t number_of_byte, ui
auto buffer = std::unique_ptr<uint8_t>(new uint8_t[number_of_byte]);
for(uint64_t i = 0; i < iterations; i++) {
- std::cout << "Send file " << i+1 << "/" << iterations << std::endl;
+ std::cout << "Send file " << i + 1 << "/" << iterations << std::endl;
hidra2::ProducerError error;
error = producer->Send(i, buffer.get(), number_of_byte);
diff --git a/producer/CMakeLists.txt b/producer/CMakeLists.txt
index 0d50d291afaac3aedb56552609d99d712a59c8a1..5f35adf857e6f13c8bba2de4452a9eeeb55169fc 100644
--- a/producer/CMakeLists.txt
+++ b/producer/CMakeLists.txt
@@ -1 +1 @@
-add_subdirectory(inotify-event-detector-cpp)
+#add_subdirectory(inotify-event-detector-cpp)
diff --git a/producer/api/src/producer.cpp b/producer/api/src/producer.cpp
index dc3a0928479076efbdb118791ede8610fdbccda8..e92d9872141c6420bd746ff0de37153901b4eb53 100644
--- a/producer/api/src/producer.cpp
+++ b/producer/api/src/producer.cpp
@@ -4,4 +4,3 @@
std::unique_ptr<hidra2::Producer> hidra2::Producer::create() {
return std::unique_ptr<hidra2::Producer>(new ProducerImpl());
}
-
diff --git a/producer/api/src/producer_impl.cpp b/producer/api/src/producer_impl.cpp
index 68b0af0a3ad3c23f86b32dc6ad8bc486ac321fce..208d0bff23717d1f040897566bebb90966adee5c 100644
--- a/producer/api/src/producer_impl.cpp
+++ b/producer/api/src/producer_impl.cpp
@@ -111,4 +111,3 @@ hidra2::ProducerError hidra2::ProducerImpl::Send(uint64_t file_id, void* data, s
status_ = PRODUCER_STATUS__CONNECTED;
return ProducerError::kNoError;
}
-
diff --git a/producer/api/unittests/test_producer_impl.cpp b/producer/api/unittests/test_producer_impl.cpp
index 7cc21e33a818d74a82674c91db589a88170db5a4..4acf628c367de268b2951a360f700dd55f6d7606 100644
--- a/producer/api/unittests/test_producer_impl.cpp
+++ b/producer/api/unittests/test_producer_impl.cpp
@@ -87,12 +87,12 @@ TEST(ProducerImpl, ConnectToReceiver) {
hidra2::FileDescriptor expected_fd = 199;
EXPECT_CALL(mockIO, CreateAndConnectIPTCPSocket(expected_address, _))
- .Times(1)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<1>(hidra2::IOErrors::kNoError),
- Return(expected_fd)
- ));
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<1>(hidra2::IOErrors::kNoError),
+ Return(expected_fd)
+ ));
hidra2::ProducerError error = producer.ConnectToReceiver(expected_address);
hidra2::ProducerStatus status = producer.GetStatus();
@@ -109,9 +109,9 @@ void ConnectToReceiver_DONE(hidra2::ProducerImpl& producer, hidra2::FileDescript
.Times(1)
.WillOnce(
DoAll(
- testing::SetArgPointee<1>(hidra2::IOErrors::kNoError),
- Return(expected_fd)
- ));
+ testing::SetArgPointee<1>(hidra2::IOErrors::kNoError),
+ Return(expected_fd)
+ ));
producer.ConnectToReceiver("");
}
@@ -169,7 +169,8 @@ TEST(ProducerImpl, Send__file_too_large) {
ConnectToReceiver_DONE(producer, expected_fd);
- hidra2::ProducerError error = producer.Send(expected_file_id, nullptr, size_t(1024) * size_t(1024) * size_t(1024) * size_t(3));
+ hidra2::ProducerError error = producer.Send(expected_file_id, nullptr,
+ size_t(1024) * size_t(1024) * size_t(1024) * size_t(3));
hidra2::ProducerStatus status = producer.GetStatus();
ASSERT_THAT(error, Eq(hidra2::ProducerError::kFileTooLarge));
@@ -191,13 +192,14 @@ TEST(ProducerImpl, Send__sendDataRequest_error) {
hidra2::MockIO mockIO;
producer.__set_io(&mockIO);
- EXPECT_CALL(mockIO, Send(expected_fd, M_CheckSendDataRequest(expected_request_id, expected_file_id, expected_file_size), sizeof(hidra2::SendDataRequest), _))
- .Times(1)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<3>(hidra2::IOErrors::kBadFileNumber),
- Return(-1)
- ));
+ EXPECT_CALL(mockIO, Send(expected_fd, M_CheckSendDataRequest(expected_request_id, expected_file_id, expected_file_size),
+ sizeof(hidra2::SendDataRequest), _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::kBadFileNumber),
+ Return(-1)
+ ));
hidra2::ProducerError error = producer.Send(expected_file_id, nullptr, expected_file_size);
hidra2::ProducerStatus status = producer.GetStatus();
@@ -223,20 +225,20 @@ TEST(ProducerImpl, Send__sendData_error) {
producer.__set_io(&mockIO);
EXPECT_CALL(mockIO, Send(_, _, _, _))
- .Times(1)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
- testing::ReturnArg<2>()
- ));
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
+ testing::ReturnArg<2>()
+ ));
EXPECT_CALL(mockIO, Send(expected_fd, expected_file_pointer, expected_file_size, _))
- .Times(1)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<3>(hidra2::IOErrors::kBadFileNumber),
- Return(-1)
- ));
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::kBadFileNumber),
+ Return(-1)
+ ));
hidra2::ProducerError error = producer.Send(expected_file_id, expected_file_pointer, expected_file_size);
@@ -264,20 +266,20 @@ TEST(ProducerImpl, Send__Receive_error) {
producer.__set_io(&mockIO);
EXPECT_CALL(mockIO, Send(_, _, _, _))
- .Times(2)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
- testing::ReturnArg<2>()
- ));
+ .Times(2)
+ .WillRepeatedly(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
+ testing::ReturnArg<2>()
+ ));
EXPECT_CALL(mockIO, Receive(expected_fd, _, sizeof(hidra2::SendDataResponse), _))
- .Times(1)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<3>(hidra2::IOErrors::kBadFileNumber),
- testing::Return(-1)
- ));
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::kBadFileNumber),
+ testing::Return(-1)
+ ));
hidra2::ProducerError error = producer.Send(expected_file_id, expected_file_pointer, expected_file_size);
hidra2::ProducerStatus status = producer.GetStatus();
@@ -303,21 +305,21 @@ TEST(ProducerImpl, Send__Receive_server_error) {
producer.__set_io(&mockIO);
EXPECT_CALL(mockIO, Send(_, _, _, _))
- .Times(2)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
- testing::ReturnArg<2>()
- ));
+ .Times(2)
+ .WillRepeatedly(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
+ testing::ReturnArg<2>()
+ ));
EXPECT_CALL(mockIO, Receive(_, _, sizeof(hidra2::SendDataResponse), _))
- .Times(1)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
- A_WriteSendDataResponse(hidra2::NET_ERR__ALLOCATE_STORAGE_FAILED, expected_request_id),
- testing::ReturnArg<2>()
- ));
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
+ A_WriteSendDataResponse(hidra2::NET_ERR__ALLOCATE_STORAGE_FAILED, expected_request_id),
+ testing::ReturnArg<2>()
+ ));
hidra2::ProducerError error = producer.Send(expected_file_id, expected_file_pointer, expected_file_size);
hidra2::ProducerStatus status = producer.GetStatus();
@@ -344,21 +346,21 @@ TEST(ProducerImpl, Send) {
producer.__set_io(&mockIO);
EXPECT_CALL(mockIO, Send(_, _, _, _))
- .Times(2)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
- testing::ReturnArg<2>()
- ));
+ .Times(2)
+ .WillRepeatedly(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
+ testing::ReturnArg<2>()
+ ));
EXPECT_CALL(mockIO, Receive(_, _, sizeof(hidra2::SendDataResponse), _))
- .Times(1)
- .WillOnce(
- DoAll(
- testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
- A_WriteSendDataResponse(hidra2::NET_ERR__NO_ERROR, expected_request_id),
- testing::ReturnArg<2>()
- ));
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::kNoError),
+ A_WriteSendDataResponse(hidra2::NET_ERR__NO_ERROR, expected_request_id),
+ testing::ReturnArg<2>()
+ ));
hidra2::ProducerError error = producer.Send(expected_file_id, expected_file_pointer, expected_file_size);
hidra2::ProducerStatus status = producer.GetStatus();
diff --git a/receiver/src/network_producer_peer.cpp b/receiver/src/network_producer_peer.cpp
index 2eaf4e8a4be0ad87082313e164efd069f28ff30c..b249b76c7c5764e31d5b637dabaa18e5c85f0099 100644
--- a/receiver/src/network_producer_peer.cpp
+++ b/receiver/src/network_producer_peer.cpp
@@ -77,7 +77,7 @@ void NetworkProducerPeer::internal_receiver_thread_() {
}
}
- io->Close(socket_fd_);
+ io->Close(socket_fd_, nullptr);
std::cout << "[" << connection_id() << "] Disconnected." << std::endl;
free(generic_request);
@@ -98,7 +98,7 @@ size_t NetworkProducerPeer::handle_generic_request_(GenericNetworkRequest* reque
if(request->op_code >= OP_CODE_COUNT || request->op_code < 0) {
std::cerr << "[" << connection_id() << "] Error invalid op_code: " << request->op_code << " force disconnect." <<
std::endl;
- io->Close(socket_fd_);
+ io->Close(socket_fd_, nullptr);
return 0;
}
diff --git a/receiver/src/network_producer_peer_handlers.cpp b/receiver/src/network_producer_peer_handlers.cpp
index ad6cce952d74247d8c42f9d8750b66e72e9803f5..579542a4f0c13732cac67d167a6be1cf952b18df 100644
--- a/receiver/src/network_producer_peer_handlers.cpp
+++ b/receiver/src/network_producer_peer_handlers.cpp
@@ -37,7 +37,7 @@ void NetworkProducerPeer::handle_send_data_request_(NetworkProducerPeer* self, c
self->io->Skip(self->socket_fd_, request->file_size, &ioErr);
if(ioErr != IOErrors::kNoError) {
std::cout << "[NetworkProducerPeer] Out of sync force disconnect" << std::endl;
- self->io->Close(self->socket_fd_);
+ self->io->Close(self->socket_fd_, nullptr);
}
return;
}
diff --git a/receiver/src/receiver.cpp b/receiver/src/receiver.cpp
index def17eed4a87478df6cd2951df67baaf2f916cda..cd923cd3598da5737790bd9a260aad160f76de2c 100644
--- a/receiver/src/receiver.cpp
+++ b/receiver/src/receiver.cpp
@@ -29,7 +29,7 @@ void hidra2::Receiver::StartListener(std::string listener_address, uint16_t port
io->InetBind(listener_fd, listener_address, port, &io_error);
if(io_error != IOErrors::kNoError) {
- io->Close(listener_fd);
+ io->Close(listener_fd, nullptr);
*err = ReceiverError::FAILED_CREATING_SOCKET;
listener_running_ = false;
std::cerr << "Fail to bind socket" << std::endl;
@@ -38,7 +38,7 @@ void hidra2::Receiver::StartListener(std::string listener_address, uint16_t port
io->Listen(listener_fd, kMaxUnacceptedConnectionsBacklog, &io_error);
if(io_error != IOErrors::kNoError) {
- io->Close(listener_fd);
+ io->Close(listener_fd, nullptr);
*err = ReceiverError::FAILED_CREATING_SOCKET;
listener_running_ = false;
std::cerr << "Fail to start listen" << std::endl;
diff --git a/worker/api/cpp/unittests/test_folder_broker.cpp b/worker/api/cpp/unittests/test_folder_broker.cpp
index cc340388d59398f0b0a51d75339141f3ca8e91ca..5cc870f1ab36633714a6ad142b9c6e943b0f5c28 100644
--- a/worker/api/cpp/unittests/test_folder_broker.cpp
+++ b/worker/api/cpp/unittests/test_folder_broker.cpp
@@ -5,6 +5,7 @@
#include "system_wrappers/io.h"
#include "system_wrappers/system_io.h"
#include "../src/folder_data_broker.h"
+#include "../../../../common/cpp/unittests/MockIO.h"
using hidra2::DataBrokerFactory;
using hidra2::DataBroker;
@@ -33,7 +34,7 @@ TEST(FolderDataBroker, SetCorrectIO) {
-class FakeIO: public IO {
+class FakeIO: public hidra2::MockIO {
public:
virtual uint8_t* GetDataFromFileProxy(const std::string& fname, uint64_t fsize, IOErrors* err) const {
@@ -41,22 +42,10 @@ class FakeIO: public IO {
return nullptr;
};
- FileData GetDataFromFile(const std::string& fname, uint64_t fsize, IOErrors* err) const noexcept override {
+ FileData GetDataFromFile(const std::string& fname, uint64_t fsize, IOErrors* err) const override {
return FileData(GetDataFromFileProxy(fname, fsize, err));
};
- int open(const char* __file, int __oflag) const noexcept override {
- return 0;
- };
-
- int close(int __fd)const noexcept override {
- return 0;
- };
-
- uint64_t Read(int fd, uint8_t* array, uint64_t fsize, IOErrors* err) const noexcept override {
- return 0;
- }
-
std::vector<FileInfo> FilesInFolder(const std::string& folder, IOErrors* err) const override {
*err = IOErrors::kNoError;
std::vector<FileInfo> file_infos;