diff --git a/CMakeIncludes/language_settings.cmake b/CMakeIncludes/language_settings.cmake
index 8f418ae9a7753327dca295105a72b7ac0c88aa0f..29d287bbbebd1b7e0cafd28d3607440e0792e983 100644
--- a/CMakeIncludes/language_settings.cmake
+++ b/CMakeIncludes/language_settings.cmake
@@ -37,6 +37,5 @@ if (CMAKE_BUILD_TYPE STREQUAL "Debug")
endif (CMAKE_BUILD_TYPE STREQUAL "Debug")
if (APPLE)
- include_directories("/usr/local/include")
link_directories("/usr/local/lib")
endif()
\ No newline at end of file
diff --git a/common/cpp/include/asapo/common/networking.h b/common/cpp/include/asapo/common/networking.h
index bfce369d63d4535cdb276c49be20286c7e217cc7..d814a88df4db17d0f9181f46ae5cb0ec6f133da3 100644
--- a/common/cpp/include/asapo/common/networking.h
+++ b/common/cpp/include/asapo/common/networking.h
@@ -13,82 +13,63 @@ namespace asapo {
typedef uint64_t NetworkRequestId;
enum class NetworkConnectionType : uint32_t {
- kUndefined,
- kAsapoTcp, // ASAPOs TCP (Multiple connections for parallel data transfers)
- kFabric, // Fabric connection (Primarily used for InfiniBand verbs)
+ kUndefined,
+ kAsapoTcp, // ASAPOs TCP (Multiple connections for parallel data transfers)
+ kFabric, // Fabric connection (Primarily used for InfiniBand verbs)
};
// do not forget to add new codes to the end!
enum Opcode : uint8_t {
- kOpcodeUnknownOp = 1,
- kOpcodeTransferData,
- kOpcodeTransferDatasetData,
- kOpcodeStreamInfo,
- kOpcodeLastStream,
- kOpcodeGetBufferData,
- kOpcodeAuthorize,
- kOpcodeTransferMetaData,
- kOpcodeDeleteStream,
- kOpcodeGetMeta,
- kOpcodeCount,
+ kOpcodeUnknownOp = 1,
+ kOpcodeTransferData,
+ kOpcodeTransferDatasetData,
+ kOpcodeStreamInfo,
+ kOpcodeLastStream,
+ kOpcodeGetBufferData,
+ kOpcodeAuthorize,
+ kOpcodeTransferMetaData,
+ kOpcodeDeleteStream,
+ kOpcodeGetMeta,
+ kOpcodeCount,
};
inline std::string OpcodeToString(uint8_t code) {
switch (code) {
- case kOpcodeTransferData:
- return "transfer data";
- case kOpcodeTransferDatasetData:
- return "transfer dataset data";
- case kOpcodeStreamInfo:
- return "stream info";
- case kOpcodeLastStream:
- return "last stream";
- case kOpcodeGetBufferData:
- return "get buffer data";
- case kOpcodeAuthorize:
- return "authorize";
- case kOpcodeTransferMetaData:
- return "transfer metadata";
- case kOpcodeDeleteStream:
- return "delete stream";
- case kOpcodeGetMeta:
- return "get meta";
- default:
- return "unknown op";
+ case kOpcodeTransferData:return "transfer data";
+ case kOpcodeTransferDatasetData:return "transfer dataset data";
+ case kOpcodeStreamInfo:return "stream info";
+ case kOpcodeLastStream:return "last stream";
+ case kOpcodeGetBufferData:return "get buffer data";
+ case kOpcodeAuthorize:return "authorize";
+ case kOpcodeTransferMetaData:return "transfer metadata";
+ case kOpcodeDeleteStream:return "delete stream";
+ case kOpcodeGetMeta:return "get meta";
+ default:return "unknown op";
}
}
enum NetworkErrorCode : uint16_t {
- kNetErrorNoError,
- kNetErrorReauthorize,
- kNetErrorWarning,
- kNetErrorWrongRequest,
- kNetErrorNotSupported,
- kNetErrorNoData,
- kNetAuthorizationError,
- kNetErrorInternalServerError = 65535,
+ kNetErrorNoError,
+ kNetErrorReauthorize,
+ kNetErrorWarning,
+ kNetErrorWrongRequest,
+ kNetErrorNotSupported,
+ kNetErrorNoData,
+ kNetAuthorizationError,
+ kNetErrorInternalServerError = 65535,
};
inline std::string NetworkErrorCodeToString(uint16_t code) {
switch (code) {
- case kNetErrorNoError:
- return "success";
- case kNetErrorReauthorize:
- return "reauthorize";
- case kNetErrorWarning:
- return "warning";
- case kNetErrorWrongRequest:
- return "wrong request";
- case kNetErrorNotSupported:
- return "not suported";
- case kNetErrorNoData:
- return "no data";
- case kNetAuthorizationError:
- return "authorization error";
- case kNetErrorInternalServerError:
- return "internal server error";
- default:
- return "unknown code";
+ case kNetErrorNoError:return "success";
+ case kNetErrorReauthorize:return "reauthorize";
+ case kNetErrorWarning:return "warning";
+ case kNetErrorWrongRequest:return "wrong request";
+ case kNetErrorNotSupported:return "not suported";
+ case kNetErrorNoData:return "no data";
+ case kNetAuthorizationError:return "authorization error";
+ case kNetErrorInternalServerError:return "internal server error";
+ default:return "unknown code";
}
}
@@ -105,46 +86,49 @@ const std::size_t kPosMetaIngestMode = 1;
const std::size_t kPosDataSetSize = 2;
struct GenericRequestHeader {
- GenericRequestHeader(const GenericRequestHeader& header) {
- op_code = header.op_code, data_id = header.data_id, data_size = header.data_size, meta_size = header.meta_size,
- memcpy(custom_data, header.custom_data, kNCustomParams * sizeof(uint64_t)),
- memcpy(message, header.message, kMaxMessageSize);
- strncpy(stream, header.stream, kMaxMessageSize);
- strncpy(api_version, header.api_version, kMaxVersionSize);
- }
-
- /* Keep in mind that the message here is just strncpy'ed, you can change the message later */
- GenericRequestHeader(Opcode i_op_code = kOpcodeUnknownOp, uint64_t i_data_id = 0,
- uint64_t i_data_size = 0, uint64_t i_meta_size = 0, const std::string& i_message = "",
- const std::string& i_stream = "") :
- op_code{i_op_code}, data_id{i_data_id}, data_size{i_data_size}, meta_size{i_meta_size} {
- strncpy(message, i_message.c_str(), kMaxMessageSize);
- strncpy(stream, i_stream.c_str(), kMaxMessageSize);
- strncpy(api_version, "v0.0", kMaxVersionSize);
- }
-
- Opcode op_code;
- uint64_t data_id;
- uint64_t data_size;
- uint64_t meta_size;
- CustomRequestData custom_data;
- char message[kMaxMessageSize]; /* Can also be a binary message (e.g. MemoryRegionDetails) */
- char stream[kMaxMessageSize]; /* Must be a string (strcpy is used) */
- char api_version[kMaxVersionSize]; /* Must be a string (strcpy is used) */
- std::string Json() {
- std::string s = "{\"id\":" + std::to_string(data_id) + ","
- "\"buffer\":\"" + std::string(message) + "\"" + ","
- "\"stream\":\""
- + std::string(stream) + "\""
- + "}";
- return s;
- };
+ GenericRequestHeader(const GenericRequestHeader &header) {
+ operator=(header);
+ }
+ GenericRequestHeader &operator=(const GenericRequestHeader &header) {
+ op_code = header.op_code, data_id = header.data_id, data_size = header.data_size, meta_size = header.meta_size,
+ memcpy(custom_data, header.custom_data, kNCustomParams * sizeof(uint64_t)),
+ memcpy(message, header.message, kMaxMessageSize);
+ strncpy(stream, header.stream, kMaxMessageSize);
+ strncpy(api_version, header.api_version, kMaxVersionSize);
+ return *this;
+ };
+ /* Keep in mind that the message here is just strncpy'ed, you can change the message later */
+ GenericRequestHeader(Opcode i_op_code = kOpcodeUnknownOp, uint64_t i_data_id = 0,
+ uint64_t i_data_size = 0, uint64_t i_meta_size = 0, const std::string &i_message = "",
+ const std::string &i_stream = "") :
+ op_code{i_op_code}, data_id{i_data_id}, data_size{i_data_size}, meta_size{i_meta_size} {
+ strncpy(message, i_message.c_str(), kMaxMessageSize);
+ strncpy(stream, i_stream.c_str(), kMaxMessageSize);
+ strncpy(api_version, "v0.0", kMaxVersionSize);
+ }
+
+ Opcode op_code;
+ uint64_t data_id;
+ uint64_t data_size;
+ uint64_t meta_size;
+ CustomRequestData custom_data;
+ char message[kMaxMessageSize]; /* Can also be a binary message (e.g. MemoryRegionDetails) */
+ char stream[kMaxMessageSize]; /* Must be a string (strcpy is used) */
+ char api_version[kMaxVersionSize]; /* Must be a string (strcpy is used) */
+ std::string Json() {
+ std::string s = "{\"id\":" + std::to_string(data_id) + ","
+ "\"buffer\":\"" + std::string(message) + "\"" + ","
+ "\"stream\":\""
+ + std::string(stream) + "\""
+ + "}";
+ return s;
+ };
};
struct GenericNetworkResponse {
- Opcode op_code;
- NetworkErrorCode error_code;
- char message[kMaxMessageSize];
+ Opcode op_code;
+ NetworkErrorCode error_code;
+ char message[kMaxMessageSize];
};
struct SendResponse : GenericNetworkResponse {
diff --git a/common/cpp/include/asapo/unittests/MockDatabase.h b/common/cpp/include/asapo/unittests/MockDatabase.h
index b8f94b260fb13f4554ea86e71f59166a9b32b4bd..887653507910802a51fe56d66037dd4ec99db07e 100644
--- a/common/cpp/include/asapo/unittests/MockDatabase.h
+++ b/common/cpp/include/asapo/unittests/MockDatabase.h
@@ -25,25 +25,23 @@ class MockDatabase : public Database {
return Error{InsertAsDatasetMessage_t(collection, file, dataset_size, ignore_duplicates)};
}
- MOCK_METHOD2(Connect_t, ErrorInterface * (const std::string&, const std::string&));
- MOCK_CONST_METHOD4(Insert_t, ErrorInterface * (const std::string&, const MessageMeta&, bool, uint64_t*));
+ MOCK_METHOD(ErrorInterface *, Connect_t, (const std::string&, const std::string&), ());
+ MOCK_METHOD(ErrorInterface *, Insert_t, (const std::string&, const MessageMeta&, bool, uint64_t*), (const));
- MOCK_CONST_METHOD4(InsertAsDatasetMessage_t,
- ErrorInterface * (const std::string&, const MessageMeta&, uint64_t, bool));
+ MOCK_METHOD(ErrorInterface *, InsertAsDatasetMessage_t, (const std::string&, const MessageMeta&, uint64_t, bool), (const));
Error InsertMeta(const std::string& collection, const std::string& id, const uint8_t* data, uint64_t size,
MetaIngestMode mode) const override {
return Error{InsertMeta_t(collection, id, data, size, mode)};
}
- MOCK_CONST_METHOD5(InsertMeta_t, ErrorInterface * (const std::string&, const std::string& id, const uint8_t* data,
- uint64_t size, MetaIngestMode mode));
+ MOCK_METHOD(ErrorInterface *, InsertMeta_t, (const std::string&, const std::string& id, const uint8_t* data, uint64_t size, MetaIngestMode mode), (const));
Error GetById(const std::string& collection, uint64_t id, MessageMeta* file) const override {
return Error{GetById_t(collection, id, file)};
}
- MOCK_CONST_METHOD3(GetById_t, ErrorInterface * (const std::string&, uint64_t id, MessageMeta*));
+ MOCK_METHOD(ErrorInterface *, GetById_t, (const std::string&, uint64_t id, MessageMeta*), (const));
Error GetDataSetById(const std::string& collection, uint64_t set_id, uint64_t id, MessageMeta* file) const override {
return Error{GetSetById_t(collection, set_id, id, file)};
@@ -52,31 +50,31 @@ class MockDatabase : public Database {
Error GetMetaFromDb(const std::string& collection, const std::string& id, std::string* res) const override {
return Error{GetMetaFromDb_t(collection, id, res)};
}
- MOCK_CONST_METHOD3(GetMetaFromDb_t, ErrorInterface * (const std::string&, const std::string&, std::string* res));
+ MOCK_METHOD(ErrorInterface *, GetMetaFromDb_t, (const std::string&, const std::string&, std::string* res), (const));
- MOCK_CONST_METHOD4(GetSetById_t, ErrorInterface * (const std::string&, uint64_t set_id, uint64_t id, MessageMeta*));
+ MOCK_METHOD(ErrorInterface *, GetSetById_t, (const std::string&, uint64_t set_id, uint64_t id, MessageMeta*), (const));
Error GetStreamInfo(const std::string& collection, StreamInfo* info) const override {
return Error{GetStreamInfo_t(collection, info)};
}
- MOCK_CONST_METHOD2(GetStreamInfo_t, ErrorInterface * (const std::string&, StreamInfo*));
+ MOCK_METHOD(ErrorInterface *, GetStreamInfo_t, (const std::string&, StreamInfo*), (const));
Error GetLastStream(StreamInfo* info) const override {
return Error{GetLastStream_t(info)};
}
- MOCK_CONST_METHOD1(DeleteStream_t, ErrorInterface * (const std::string&));
+ MOCK_METHOD(ErrorInterface *, DeleteStream_t, (const std::string&), (const));
Error DeleteStream(const std::string& stream) const override {
return Error{DeleteStream_t(stream)};
}
- MOCK_CONST_METHOD1(GetLastStream_t, ErrorInterface * (StreamInfo*));
+ MOCK_METHOD(ErrorInterface *, GetLastStream_t, (StreamInfo*), (const));
// stuff to test db destructor is called and avoid "uninteresting call" messages
- MOCK_METHOD0(Die, void());
+ MOCK_METHOD(void, Die, (), ());
virtual ~MockDatabase() override {
if (check_destructor)
Die();
diff --git a/common/cpp/include/asapo/unittests/MockFabric.h b/common/cpp/include/asapo/unittests/MockFabric.h
index 2ce3823c0dcde6cac675053eb0369a66ed615aa0..c08596b908d5bd7537796a352f5050b2c66b132b 100644
--- a/common/cpp/include/asapo/unittests/MockFabric.h
+++ b/common/cpp/include/asapo/unittests/MockFabric.h
@@ -13,13 +13,13 @@ class MockFabricMemoryRegion : public FabricMemoryRegion {
~MockFabricMemoryRegion() override {
Destructor();
}
- MOCK_METHOD0(Destructor, void());
- MOCK_CONST_METHOD0(GetDetails, const MemoryRegionDetails * ());
+ MOCK_METHOD(void, Destructor, (), ());
+ MOCK_METHOD(const MemoryRegionDetails *, GetDetails, (), (const, override));
};
class MockFabricContext : public FabricContext {
public:
- MOCK_CONST_METHOD0(GetAddress, std::string());
+ MOCK_METHOD(std::string, GetAddress, (), (const, override));
std::unique_ptr<FabricMemoryRegion> ShareMemoryRegion(void* src, size_t size, Error* error) override {
ErrorInterface* err = nullptr;
@@ -27,7 +27,7 @@ class MockFabricContext : public FabricContext {
error->reset(err);
return std::unique_ptr<FabricMemoryRegion> {data};
}
- MOCK_METHOD3(ShareMemoryRegion_t, FabricMemoryRegion * (void* src, size_t size, ErrorInterface** err));
+ MOCK_METHOD(FabricMemoryRegion *, ShareMemoryRegion_t, (void* src, size_t size, ErrorInterface** err), ());
void Send(FabricAddress dstAddress, FabricMessageId messageId,
const void* src, size_t size, Error* error) override {
@@ -35,8 +35,7 @@ class MockFabricContext : public FabricContext {
Send_t(dstAddress, messageId, src, size, &err);
error->reset(err);
}
- MOCK_METHOD5(Send_t, void(FabricAddress dstAddress, FabricMessageId messageId,
- const void* src, size_t size, ErrorInterface** err));
+ MOCK_METHOD(void, Send_t, (FabricAddress dstAddress, FabricMessageId messageId, const void* src, size_t size, ErrorInterface** err), ());
void Recv(FabricAddress srcAddress, FabricMessageId messageId,
void* dst, size_t size, Error* error) override {
@@ -44,8 +43,7 @@ class MockFabricContext : public FabricContext {
Recv_t(srcAddress, messageId, dst, size, &err);
error->reset(err);
}
- MOCK_METHOD5(Recv_t, void(FabricAddress dstAddress, FabricMessageId messageId,
- const void* src, size_t size, ErrorInterface** err));
+ MOCK_METHOD(void, Recv_t, (FabricAddress dstAddress, FabricMessageId messageId, const void* src, size_t size, ErrorInterface** err), ());
void RdmaWrite(FabricAddress dstAddress,
const MemoryRegionDetails* details, const void* buffer, size_t size,
@@ -54,8 +52,7 @@ class MockFabricContext : public FabricContext {
RdmaWrite_t(dstAddress, details, buffer, size, &err);
error->reset(err);
}
- MOCK_METHOD5(RdmaWrite_t, void(FabricAddress dstAddress, const MemoryRegionDetails* details, const void* buffer,
- size_t size, ErrorInterface** error));
+ MOCK_METHOD(void, RdmaWrite_t, (FabricAddress dstAddress, const MemoryRegionDetails* details, const void* buffer, size_t size, ErrorInterface** error), ());
};
class MockFabricClient : public MockFabricContext, public FabricClient {
@@ -66,7 +63,7 @@ class MockFabricClient : public MockFabricContext, public FabricClient {
error->reset(err);
return data;
}
- MOCK_METHOD2(AddServerAddress_t, FabricAddress (const std::string& serverAddress, ErrorInterface** err));
+ MOCK_METHOD(FabricAddress, AddServerAddress_t, (const std::string& serverAddress, ErrorInterface** err), ());
public: // Link to FabricContext
std::string GetAddress() const override {
return MockFabricContext::GetAddress();
@@ -100,8 +97,7 @@ class MockFabricServer : public MockFabricContext, public FabricServer {
RecvAny_t(srcAddress, messageId, dst, size, &err);
error->reset(err);
}
- MOCK_METHOD5(RecvAny_t, void(FabricAddress* srcAddress, FabricMessageId* messageId,
- void* dst, size_t size, ErrorInterface** err));
+ MOCK_METHOD(void, RecvAny_t, (FabricAddress* srcAddress, FabricMessageId* messageId, void* dst, size_t size, ErrorInterface** err), ());
public: // Link to FabricContext
std::string GetAddress() const override {
return MockFabricContext::GetAddress();
@@ -138,9 +134,7 @@ class MockFabricFactory : public FabricFactory {
error->reset(err);
return std::unique_ptr<FabricServer> {data};
}
- MOCK_CONST_METHOD4(CreateAndBindServer_t,
- FabricServer * (const AbstractLogger* logger, const std::string& host,
- uint16_t port, ErrorInterface** err));
+ MOCK_METHOD(FabricServer *, CreateAndBindServer_t, (const AbstractLogger* logger, const std::string& host, uint16_t port, ErrorInterface** err), (const));
std::unique_ptr<FabricClient> CreateClient(Error* error) const override {
ErrorInterface* err = nullptr;
@@ -148,8 +142,7 @@ class MockFabricFactory : public FabricFactory {
error->reset(err);
return std::unique_ptr<FabricClient> {data};
}
- MOCK_CONST_METHOD1(CreateClient_t,
- FabricClient * (ErrorInterface** err));
+ MOCK_METHOD(FabricClient *, CreateClient_t, (ErrorInterface** err), (const));
};
}
}
diff --git a/common/cpp/include/asapo/unittests/MockHttpClient.h b/common/cpp/include/asapo/unittests/MockHttpClient.h
index d5d318ed8890ecc2d245a9d8e76e934788337dc0..92d31d9c007698627154208f167d6324f4738e67 100644
--- a/common/cpp/include/asapo/unittests/MockHttpClient.h
+++ b/common/cpp/include/asapo/unittests/MockHttpClient.h
@@ -41,17 +41,12 @@ class MockHttpClient : public HttpClient {
return UrlEscape_t(uri);
}
- MOCK_CONST_METHOD1(UrlEscape_t, std::string(const std::string& uri));
+ MOCK_METHOD(std::string, UrlEscape_t, (const std::string& uri), (const));
- MOCK_CONST_METHOD3(Get_t,
- std::string(const std::string& uri, HttpCode* code, ErrorInterface** err));
- MOCK_CONST_METHOD5(Post_t,
- std::string(const std::string& uri, const std::string& cookie, const std::string& data, HttpCode* code,
- ErrorInterface** err));
- MOCK_CONST_METHOD6(PostReturnArray_t,
- ErrorInterface * (const std::string& uri, const std::string& cookie, const std::string& input_data,
- MessageData* ouput_data, uint64_t output_data_size, HttpCode* code));
+ MOCK_METHOD(std::string, Get_t, (const std::string& uri, HttpCode* code, ErrorInterface** err), (const));
+ MOCK_METHOD(std::string, Post_t, (const std::string& uri, const std::string& cookie, const std::string& data, HttpCode* code, ErrorInterface** err), (const));
+ MOCK_METHOD(ErrorInterface *, PostReturnArray_t, (const std::string& uri, const std::string& cookie, const std::string& input_data, MessageData* ouput_data, uint64_t output_data_size, HttpCode* code), (const));
};
diff --git a/common/cpp/include/asapo/unittests/MockIO.h b/common/cpp/include/asapo/unittests/MockIO.h
index 14118f7b3323e65e27cb4a9a6261e578ff54b9ec..7e3c29fd534338a3baff0170da934327d6354331 100644
--- a/common/cpp/include/asapo/unittests/MockIO.h
+++ b/common/cpp/include/asapo/unittests/MockIO.h
@@ -16,25 +16,25 @@ class MockIO : public IO {
return res;
}
- MOCK_CONST_METHOD1(GetHostName_t, std::string(ErrorInterface** err));
+ MOCK_METHOD(std::string, GetHostName_t, (ErrorInterface** err), (const));
std::string AddressFromSocket(SocketDescriptor socket) const noexcept override {
return AddressFromSocket_t(socket);
}
- MOCK_CONST_METHOD1(AddressFromSocket_t, std::string (SocketDescriptor socket));
+ MOCK_METHOD(std::string, AddressFromSocket_t, (SocketDescriptor socket), (const));
std::unique_ptr<std::thread> NewThread(const std::string&, std::function<void()> function) const override {
return std::unique_ptr<std::thread>(NewThread_t(function));
}
- MOCK_CONST_METHOD1(NewThread_t, std::thread * (std::function<void()> function));
+ MOCK_METHOD(std::thread *, NewThread_t, (std::function<void()> function), (const));
std::unique_ptr<std::thread> NewThread(const std::string&, std::function<void(uint64_t index)> function,
uint64_t index) const override {
return std::unique_ptr<std::thread>(NewThread_t(function, index));
}
- MOCK_CONST_METHOD2(NewThread_t, std::thread * (std::function<void(uint64_t)> function, uint64_t index));
+ MOCK_METHOD(std::thread *, NewThread_t, (std::function<void(uint64_t)> function, uint64_t index), (const));
ListSocketDescriptors WaitSocketsActivity(SocketDescriptor master_socket, ListSocketDescriptors* sockets_to_listen,
@@ -45,9 +45,7 @@ class MockIO : public IO {
return data;
}
- MOCK_CONST_METHOD4(WaitSocketsActivity_t, ListSocketDescriptors(SocketDescriptor master_socket,
- ListSocketDescriptors* sockets_to_listen,
- std::vector<std::string>* connections, ErrorInterface** err));
+ MOCK_METHOD(ListSocketDescriptors, WaitSocketsActivity_t, (SocketDescriptor master_socket, ListSocketDescriptors* sockets_to_listen, std::vector<std::string>* connections, ErrorInterface** err), (const));
SocketDescriptor CreateSocket(AddressFamilies address_family, SocketTypes socket_type, SocketProtocols socket_protocol,
@@ -57,15 +55,14 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD4(CreateSocket_t, SocketDescriptor(AddressFamilies address_family, SocketTypes socket_type,
- SocketProtocols socket_protocol, ErrorInterface** err));
+ MOCK_METHOD(SocketDescriptor, CreateSocket_t, (AddressFamilies address_family, SocketTypes socket_type, SocketProtocols socket_protocol, ErrorInterface** err), (const));
void Listen(SocketDescriptor socket_fd, int backlog, Error* err) const override {
ErrorInterface* error = nullptr;
Listen_t(socket_fd, backlog, &error);
err->reset(error);
}
- MOCK_CONST_METHOD3(Listen_t, void(SocketDescriptor socket_fd, int backlog, ErrorInterface** err));
+ MOCK_METHOD(void, Listen_t, (SocketDescriptor socket_fd, int backlog, ErrorInterface** err), (const));
void InetBind(SocketDescriptor socket_fd, const std::string& address, Error* err) const override {
@@ -73,7 +70,7 @@ class MockIO : public IO {
InetBind_t(socket_fd, address, &error);
err->reset(error);
}
- MOCK_CONST_METHOD3(InetBind_t, void(SocketDescriptor socket_fd, const std::string& address, ErrorInterface** err));
+ MOCK_METHOD(void, InetBind_t, (SocketDescriptor socket_fd, const std::string& address, ErrorInterface** err), (const));
SocketDescriptor CreateAndBindIPTCPSocketListener(const std::string& address, int backlog, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -81,8 +78,7 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD3(CreateAndBindIPTCPSocketListener_t, SocketDescriptor(const std::string& address, int backlog,
- ErrorInterface** err));
+ MOCK_METHOD(SocketDescriptor, CreateAndBindIPTCPSocketListener_t, (const std::string& address, int backlog, ErrorInterface** err), (const));
std::unique_ptr<std::tuple<std::string, SocketDescriptor>> InetAcceptConnection(SocketDescriptor socket_fd,
@@ -92,8 +88,7 @@ class MockIO : public IO {
err->reset(error);
return std::unique_ptr<std::tuple<std::string, SocketDescriptor>>(data);
}
- MOCK_CONST_METHOD2(InetAcceptConnection_t, std::tuple<std::string, SocketDescriptor>* (SocketDescriptor socket_fd,
- ErrorInterface** err));
+ MOCK_METHOD((std::tuple<std::string, SocketDescriptor>*), InetAcceptConnection_t, (SocketDescriptor socket_fd, ErrorInterface** err), (const));
std::string ResolveHostnameToIp(const std::string& hostname, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -101,14 +96,14 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD2(ResolveHostnameToIp_t, std::string(const std::string& hostname, ErrorInterface** err));
+ MOCK_METHOD(std::string, ResolveHostnameToIp_t, (const std::string& hostname, ErrorInterface** err), (const));
void InetConnect(SocketDescriptor socket_fd, const std::string& address, Error* err) const override {
ErrorInterface* error = nullptr;
InetConnect_t(socket_fd, address, &error);
err->reset(error);
}
- MOCK_CONST_METHOD3(InetConnect_t, void(SocketDescriptor socket_fd, const std::string& address, ErrorInterface** err));
+ MOCK_METHOD(void, InetConnect_t, (SocketDescriptor socket_fd, const std::string& address, ErrorInterface** err), (const));
SocketDescriptor CreateAndConnectIPTCPSocket(const std::string& address, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -116,7 +111,7 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD2(CreateAndConnectIPTCPSocket_t, SocketDescriptor(const std::string& address, ErrorInterface** err));
+ MOCK_METHOD(SocketDescriptor, CreateAndConnectIPTCPSocket_t, (const std::string& address, ErrorInterface** err), (const));
size_t Receive(SocketDescriptor socket_fd, void* buf, size_t length, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -124,7 +119,7 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD4(Receive_t, size_t(SocketDescriptor socket_fd, void* buf, size_t length, ErrorInterface** err));
+ MOCK_METHOD(size_t, Receive_t, (SocketDescriptor socket_fd, void* buf, size_t length, ErrorInterface** err), (const));
size_t ReceiveWithTimeout(SocketDescriptor socket_fd, void* buf, size_t length, long timeout_in_usec,
Error* err) const override {
@@ -133,9 +128,7 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD5(ReceiveWithTimeout_t, size_t(SocketDescriptor socket_fd, void* buf, size_t length,
- long timeout_in_usec,
- ErrorInterface** err));
+ MOCK_METHOD(size_t, ReceiveWithTimeout_t, (SocketDescriptor socket_fd, void* buf, size_t length, long timeout_in_usec, ErrorInterface** err), (const));
size_t Send(SocketDescriptor socket_fd, const void* buf, size_t length, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -143,20 +136,20 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD4(Send_t, size_t(SocketDescriptor socket_fd, const void* buf, size_t length, ErrorInterface** err));
+ MOCK_METHOD(size_t, Send_t, (SocketDescriptor socket_fd, const void* buf, size_t length, ErrorInterface** err), (const));
std::unique_ptr<std::tuple<std::string, uint16_t>> SplitAddressToHostnameAndPort(const std::string& address) const
override {
return std::unique_ptr<std::tuple<std::string, uint16_t>>(SplitAddressToHostnameAndPort_t(address));
}
- MOCK_CONST_METHOD1(SplitAddressToHostnameAndPort_t, std::tuple<std::string, uint16_t>* (const std::string& address));
+ MOCK_METHOD((std::tuple<std::string, uint16_t>*), SplitAddressToHostnameAndPort_t, (const std::string& address), (const));
void Skip(SocketDescriptor socket_fd, size_t length, Error* err) const override {
ErrorInterface* error = nullptr;
Skip_t(socket_fd, length, &error);
err->reset(error);
}
- MOCK_CONST_METHOD3(Skip_t, void(SocketDescriptor socket_fd, size_t length, ErrorInterface** err));
+ MOCK_METHOD(void, Skip_t, (SocketDescriptor socket_fd, size_t length, ErrorInterface** err), (const));
void CloseSocket(SocketDescriptor socket_fd, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -165,7 +158,7 @@ class MockIO : public IO {
err->reset(error);
}
}
- MOCK_CONST_METHOD2(CloseSocket_t, void(SocketDescriptor socket_fd, ErrorInterface** err));
+ MOCK_METHOD(void, CloseSocket_t, (SocketDescriptor socket_fd, ErrorInterface** err), (const));
FileDescriptor Open(const std::string& filename, int open_flags, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -173,7 +166,7 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD3(Open_t, FileDescriptor(const std::string& filename, int open_flags, ErrorInterface** err));
+ MOCK_METHOD(FileDescriptor, Open_t, (const std::string& filename, int open_flags, ErrorInterface** err), (const));
void Close(FileDescriptor fd, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -182,7 +175,7 @@ class MockIO : public IO {
err->reset(error);
}
}
- MOCK_CONST_METHOD2(Close_t, void(FileDescriptor fd, ErrorInterface** err));
+ MOCK_METHOD(void, Close_t, (FileDescriptor fd, ErrorInterface** err), (const));
size_t Read(FileDescriptor fd, void* buf, size_t length, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -190,7 +183,7 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD4(Read_t, size_t(FileDescriptor fd, void* buf, size_t length, ErrorInterface** err));
+ MOCK_METHOD(size_t, Read_t, (FileDescriptor fd, void* buf, size_t length, ErrorInterface** err), (const));
size_t Write(FileDescriptor fd, const void* buf, size_t length, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -198,14 +191,14 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD4(Write_t, size_t(FileDescriptor fd, const void* buf, size_t length, ErrorInterface** err));
+ MOCK_METHOD(size_t, Write_t, (FileDescriptor fd, const void* buf, size_t length, ErrorInterface** err), (const));
void CreateNewDirectory(const std::string& directory_name, asapo::Error* err) const override {
ErrorInterface* error = nullptr;
CreateNewDirectory_t(directory_name, &error);
err->reset(error);
}
- MOCK_CONST_METHOD2(CreateNewDirectory_t, void(const std::string& directory_name, ErrorInterface** err));
+ MOCK_METHOD(void, CreateNewDirectory_t, (const std::string& directory_name, ErrorInterface** err), (const));
MessageData GetDataFromFile(const std::string& fname, uint64_t* fsize, Error* err) const override {
std::function<ErrorInterface*()> error;
@@ -218,20 +211,19 @@ class MockIO : public IO {
return MessageData(data);
}
- MOCK_CONST_METHOD3(GetDataFromFile_t, uint8_t* (const std::string& fname, uint64_t* fsize,
- std::function<ErrorInterface*()>* err_gen));
+ MOCK_METHOD(uint8_t*, GetDataFromFile_t, (const std::string& fname, uint64_t* fsize, std::function<ErrorInterface*()>* err_gen), (const));
Error GetLastError() const override {
return Error{GetLastError_t()};
}
- MOCK_CONST_METHOD0(GetLastError_t, ErrorInterface * ());
+ MOCK_METHOD(ErrorInterface *, GetLastError_t, (), (const));
Error SendFile(SocketDescriptor socket_fd, const std::string& fname, size_t length) const override {
return Error{SendFile_t(socket_fd, fname, length)};
}
- MOCK_CONST_METHOD3(SendFile_t, ErrorInterface * (SocketDescriptor socket_fd, const std::string& fname, size_t length));
+ MOCK_METHOD(ErrorInterface *, SendFile_t, (SocketDescriptor socket_fd, const std::string& fname, size_t length), (const));
Error WriteDataToFile(const std::string& root_folder, const std::string& fname, const MessageData& data,
size_t length, bool create_directories, bool allow_ovewrite) const override {
@@ -239,7 +231,7 @@ class MockIO : public IO {
}
- MOCK_CONST_METHOD1(RemoveFile_t, ErrorInterface * (const std::string& fname));
+ MOCK_METHOD(ErrorInterface *, RemoveFile_t, (const std::string& fname), (const));
Error WriteDataToFile(const std::string& root_folder, const std::string& fname, const uint8_t* data,
size_t length, bool create_directories, bool allow_ovewrite) const override {
@@ -252,8 +244,7 @@ class MockIO : public IO {
}
- MOCK_CONST_METHOD6(ReceiveDataToFile_t, ErrorInterface * (SocketDescriptor socket, const std::string& root_folder,
- const std::string& fname, size_t fsize, bool create_directories, bool allow_ovewrite));
+ MOCK_METHOD(ErrorInterface *, ReceiveDataToFile_t, (SocketDescriptor socket, const std::string& root_folder, const std::string& fname, size_t fsize, bool create_directories, bool allow_ovewrite), (const));
Error ReceiveDataToFile(SocketDescriptor socket, const std::string& root_folder, const std::string& fname,
size_t length, bool create_directories, bool allow_ovewrite) const override {
@@ -261,8 +252,7 @@ class MockIO : public IO {
}
- MOCK_CONST_METHOD6(WriteDataToFile_t, ErrorInterface * (const std::string& root_folder, const std::string& fname,
- const uint8_t* data, size_t fsize, bool create_directories, bool allow_ovewrite));
+ MOCK_METHOD(ErrorInterface *, WriteDataToFile_t, (const std::string& root_folder, const std::string& fname, const uint8_t* data, size_t fsize, bool create_directories, bool allow_ovewrite), (const));
MessageMeta GetMessageMeta(const std::string& name, Error* err) const override {
@@ -273,7 +263,7 @@ class MockIO : public IO {
}
- MOCK_CONST_METHOD2(GetMessageMeta_t, MessageMeta (const std::string& name, ErrorInterface** err));
+ MOCK_METHOD(MessageMeta, GetMessageMeta_t, (const std::string& name, ErrorInterface** err), (const));
std::vector<MessageMeta> FilesInFolder(const std::string& folder, Error* err) const override {
ErrorInterface* error = nullptr;
@@ -281,7 +271,7 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD2(FilesInFolder_t, std::vector<MessageMeta>(const std::string& folder, ErrorInterface** err));
+ MOCK_METHOD(std::vector<MessageMeta>, FilesInFolder_t, (const std::string& folder, ErrorInterface** err), (const));
SubDirList GetSubDirectories(const std::string& path, Error* err) const override {
@@ -291,7 +281,7 @@ class MockIO : public IO {
return data;
};
- MOCK_CONST_METHOD2(GetSubDirectories_t, SubDirList(const std::string& path, ErrorInterface** err));
+ MOCK_METHOD(SubDirList, GetSubDirectories_t, (const std::string& path, ErrorInterface** err), (const));
std::string ReadFileToString(const std::string& fname, Error* err) const override {
@@ -300,7 +290,7 @@ class MockIO : public IO {
err->reset(error);
return data;
}
- MOCK_CONST_METHOD2(ReadFileToString_t, std::string(const std::string& fname, ErrorInterface** err));
+ MOCK_METHOD(std::string, ReadFileToString_t, (const std::string& fname, ErrorInterface** err), (const));
diff --git a/common/cpp/include/asapo/unittests/MockLogger.h b/common/cpp/include/asapo/unittests/MockLogger.h
index 06b30a59d3fb15142490cd529934a69a55cd2969..be3518fcf570bac6816cbe3b75cbb3d8c0090b90 100644
--- a/common/cpp/include/asapo/unittests/MockLogger.h
+++ b/common/cpp/include/asapo/unittests/MockLogger.h
@@ -23,10 +23,10 @@ class MockLogger : public AbstractLogger {
Warning(msg->ExplainInJSON());
};
- MOCK_CONST_METHOD1(Info, void(const std::string&));
- MOCK_CONST_METHOD1(Error, void(const std::string& ));
- MOCK_CONST_METHOD1(Debug, void(const std::string& ));
- MOCK_CONST_METHOD1(Warning, void(const std::string& ));
+ MOCK_METHOD(void, Info, (const std::string&), (const, override));
+ MOCK_METHOD(void, Error, (const std::string&), (const, override));
+ MOCK_METHOD(void, Debug, (const std::string&), (const, override));
+ MOCK_METHOD(void, Warning, (const std::string&), (const, override));
void Info(const LogMessageWithFields& msg) const override {
Info(msg.LogString());
};
@@ -40,9 +40,9 @@ class MockLogger : public AbstractLogger {
Warning(msg.LogString());
};
- MOCK_METHOD1(SetLogLevel, void(LogLevel));
- MOCK_METHOD1(EnableLocalLog, void(bool));
- MOCK_METHOD1(EnableRemoteLog, void(bool));
+ MOCK_METHOD(void, SetLogLevel, (LogLevel), (override));
+ MOCK_METHOD(void, EnableLocalLog, (bool), (override));
+ MOCK_METHOD(void, EnableRemoteLog, (bool), (override));
};
}
diff --git a/common/cpp/include/asapo/unittests/replace_mocks.py b/common/cpp/include/asapo/unittests/replace_mocks.py
new file mode 100755
index 0000000000000000000000000000000000000000..f91b901bac087b47b3bd7917450fad14ab51e1e5
--- /dev/null
+++ b/common/cpp/include/asapo/unittests/replace_mocks.py
@@ -0,0 +1,53 @@
+#!/usr/bin/python
+
+import sys
+import re
+
+fname = sys.argv[1]
+fnameo = sys.argv[2]
+
+with open(fname) as f:
+ lines = f.readlines()
+
+pattern = '.*(MOCK_.*?)\((.*?), (.*?)\((.*)\)\)'
+
+f = open(fnameo, "w")
+
+fulline = ""
+in_mock = False
+for line in lines:
+ if not in_mock and re.match(r".*MOCK_.*", line):
+ in_mock = True
+ if in_mock:
+ if fulline:
+ fulline = fulline.rstrip() + " " + line.lstrip()
+ else:
+ fulline = line
+ if not line.strip().endswith(";"):
+ continue
+ else:
+ f.write(line)
+ continue
+ result = re.search(pattern, fulline)
+ if result:
+ result = result.groups()
+ in_mock = False
+ else:
+ f.write(line)
+ continue
+ specifiers = ""
+ if not result[1].endswith("_t"):
+ specifiers = "override"
+ if "CONST" in result[0]:
+ if specifiers:
+ specifiers = "const, " + specifiers
+ else:
+ specifiers = "const"
+ ret = result[2].strip()
+ if "," in ret:
+ ret = "("+ret+")"
+ s="MOCK_METHOD"+"("+ret+", "+result[1].strip()+", ("+result[3].strip()+"), ("+specifiers+"));"
+ f.write(re.sub('MOCK_.*;', s , fulline))
+ print (re.sub('MOCK_.*;', s , fulline))
+ fulline = ""
+f.close()
\ No newline at end of file
diff --git a/common/cpp/scripts/replace_mocks.py b/common/cpp/scripts/replace_mocks.py
new file mode 100755
index 0000000000000000000000000000000000000000..f91b901bac087b47b3bd7917450fad14ab51e1e5
--- /dev/null
+++ b/common/cpp/scripts/replace_mocks.py
@@ -0,0 +1,53 @@
+#!/usr/bin/python
+
+import sys
+import re
+
+fname = sys.argv[1]
+fnameo = sys.argv[2]
+
+with open(fname) as f:
+ lines = f.readlines()
+
+pattern = '.*(MOCK_.*?)\((.*?), (.*?)\((.*)\)\)'
+
+f = open(fnameo, "w")
+
+fulline = ""
+in_mock = False
+for line in lines:
+ if not in_mock and re.match(r".*MOCK_.*", line):
+ in_mock = True
+ if in_mock:
+ if fulline:
+ fulline = fulline.rstrip() + " " + line.lstrip()
+ else:
+ fulline = line
+ if not line.strip().endswith(";"):
+ continue
+ else:
+ f.write(line)
+ continue
+ result = re.search(pattern, fulline)
+ if result:
+ result = result.groups()
+ in_mock = False
+ else:
+ f.write(line)
+ continue
+ specifiers = ""
+ if not result[1].endswith("_t"):
+ specifiers = "override"
+ if "CONST" in result[0]:
+ if specifiers:
+ specifiers = "const, " + specifiers
+ else:
+ specifiers = "const"
+ ret = result[2].strip()
+ if "," in ret:
+ ret = "("+ret+")"
+ s="MOCK_METHOD"+"("+ret+", "+result[1].strip()+", ("+result[3].strip()+"), ("+specifiers+"));"
+ f.write(re.sub('MOCK_.*;', s , fulline))
+ print (re.sub('MOCK_.*;', s , fulline))
+ fulline = ""
+f.close()
\ No newline at end of file
diff --git a/common/cpp/scripts/test.h b/common/cpp/scripts/test.h
new file mode 100644
index 0000000000000000000000000000000000000000..610917b7e3b7824996deae9c0406fbda9959bcea
--- /dev/null
+++ b/common/cpp/scripts/test.h
@@ -0,0 +1,20 @@
+ #MOCK_CONST_METHOD0(GetFileName, std::string());
+ MOCK_CONST_METHOD0(GetOriginUri_t,
+ const std::string & ());
+MOCK_CONST_METHOD0(GetOriginHost, const std::string & ());
+MOCK_CONST_METHOD0(GetDataSize, uint64_t());
+MOCK_CONST_METHOD0(GetDataID, uint64_t());
+MOCK_CONST_METHOD0(GetSlotId, uint64_t());
+MOCK_CONST_METHOD0(GetData, void* ());
+MOCK_CONST_METHOD0(GetBeamtimeId, const std::string & ());
+MOCK_CONST_METHOD0(GetDataSource, const std::string & ());
+MOCK_METHOD0(SetAlreadyProcessedFlag, void());
+MOCK_METHOD2(SetResponseMessage, void(std::string, ResponseMessageType));
+MOCK_CONST_METHOD0(GetResponseMessage, const std::string & ());
+MOCK_CONST_METHOD1(NewThread_t, std::thread * (std::function<void()> function));
+MOCK_CONST_METHOD2(InetAcceptConnection_t, std::tuple<std::string, SocketDescriptor>* (SocketDescriptor socket_fd,
+ ErrorInterface** err));
+ dfgd
+ gds
+ gdfsg
+
diff --git a/receiver/unittests/receiver_mocking.h b/receiver/unittests/receiver_mocking.h
index 40ce1ad8892398d6db88555ed4dd1320a3ff50cf..a12551c7e3a3c5574522f118dcf0aaea7b57f942 100644
--- a/receiver/unittests/receiver_mocking.h
+++ b/receiver/unittests/receiver_mocking.h
@@ -33,13 +33,11 @@ class MockStatistics : public asapo::ReceiverStatistics {
StopTimer_t();
}
- MOCK_METHOD1(SendIfNeeded_t, void(bool send_always));
- MOCK_METHOD0(IncreaseRequestCounter_t, void());
- MOCK_METHOD0(StopTimer_t, void());
- MOCK_METHOD1(IncreaseRequestDataVolume_t, void (uint64_t
- transferred_data_volume));
- MOCK_METHOD1(StartTimer_t, void(
- const asapo::StatisticEntity& entity));
+ MOCK_METHOD(void, SendIfNeeded_t, (bool send_always), ());
+ MOCK_METHOD(void, IncreaseRequestCounter_t, (), ());
+ MOCK_METHOD(void, StopTimer_t, (), ());
+ MOCK_METHOD(void, IncreaseRequestDataVolume_t, (uint64_t transferred_data_volume), ());
+ MOCK_METHOD(void, StartTimer_t, (const asapo::StatisticEntity& entity), ());
};
@@ -55,7 +53,7 @@ class MockHandlerDbCheckRequest : public asapo::RequestHandlerDbCheckRequest {
return StatisticEntity::kDatabase;
}
- MOCK_CONST_METHOD1(ProcessRequest_t, ErrorInterface * (const Request& request));
+ MOCK_METHOD(ErrorInterface *, ProcessRequest_t, (const Request& request), (const));
};
@@ -66,47 +64,47 @@ class MockRequest: public Request {
const RequestHandlerDbCheckRequest* db_check_handler ):
Request(request_header, socket_fd, std::move(origin_uri), nullptr, db_check_handler) {};
-// MOCK_METHOD(std::string, GetFileName, (), (const,override));
- MOCK_CONST_METHOD0(GetFileName, std::string());
- MOCK_CONST_METHOD0(GetStream, std::string());
- MOCK_CONST_METHOD0(GetApiVersion, std::string());
- MOCK_CONST_METHOD0(GetOriginUri, const std::string & ());
- MOCK_CONST_METHOD0(GetOriginHost, const std::string & ());
- MOCK_CONST_METHOD0(GetDataSize, uint64_t());
- MOCK_CONST_METHOD0(GetDataID, uint64_t());
- MOCK_CONST_METHOD0(GetSlotId, uint64_t());
- MOCK_CONST_METHOD0(GetData, void* ());
- MOCK_CONST_METHOD0(GetBeamtimeId, const std::string & ());
- MOCK_CONST_METHOD0(GetDataSource, const std::string & ());
- MOCK_CONST_METHOD0(GetMetaData, const std::string & ());
- MOCK_CONST_METHOD0(GetBeamline, const std::string & ());
- MOCK_CONST_METHOD0(GetOpCode, asapo::Opcode ());
- MOCK_CONST_METHOD0(GetSocket, asapo::SocketDescriptor ());
-
- MOCK_CONST_METHOD0(GetOnlinePath, const std::string & ());
- MOCK_CONST_METHOD0(GetOfflinePath, const std::string & ());
+// MOCK_METHOD(, ), (const,override), (override));
+ MOCK_METHOD(std::string, GetFileName, (), (const, override));
+ MOCK_METHOD(std::string, GetStream, (), (const, override));
+ MOCK_METHOD(std::string, GetApiVersion, (), (const, override));
+ MOCK_METHOD(const std::string &, GetOriginUri, (), (const, override));
+ MOCK_METHOD(const std::string &, GetOriginHost, (), (const, override));
+ MOCK_METHOD(uint64_t, GetDataSize, (), (const, override));
+ MOCK_METHOD(uint64_t, GetDataID, (), (const, override));
+ MOCK_METHOD(uint64_t, GetSlotId, (), (const, override));
+ MOCK_METHOD(void*, GetData, (), (const, override));
+ MOCK_METHOD(const std::string &, GetBeamtimeId, (), (const, override));
+ MOCK_METHOD(const std::string &, GetDataSource, (), (const, override));
+ MOCK_METHOD(const std::string &, GetMetaData, (), (const, override));
+ MOCK_METHOD(const std::string &, GetBeamline, (), (const, override));
+ MOCK_METHOD(asapo::Opcode, GetOpCode, (), (const, override));
+ MOCK_METHOD(asapo::SocketDescriptor, GetSocket, (), (const, override));
+
+ MOCK_METHOD(const std::string &, GetOnlinePath, (), (const, override));
+ MOCK_METHOD(const std::string &, GetOfflinePath, (), (const, override));
// not nice casting, but mocking GetCustomData directly does not compile on Windows.
const CustomRequestData& GetCustomData() const override {
return (CustomRequestData&) * GetCustomData_t();
};
- MOCK_CONST_METHOD0(GetCustomData_t, const uint64_t* ());
- MOCK_CONST_METHOD0(GetMessage, const char* ());
- MOCK_METHOD1(SetBeamtimeId, void (std::string));
- MOCK_METHOD1(SetDataSource, void (std::string));
- MOCK_METHOD1(SetBeamline, void (std::string));
- MOCK_METHOD1(SetOnlinePath, void (std::string));
- MOCK_METHOD1(SetOfflinePath, void (std::string));
+ MOCK_METHOD(const uint64_t*, GetCustomData_t, (), (const));
+ MOCK_METHOD(const char*, GetMessage, (), (const, override));
+ MOCK_METHOD(void, SetBeamtimeId, (std::string), (override));
+ MOCK_METHOD(void, SetDataSource, (std::string), (override));
+ MOCK_METHOD(void, SetBeamline, (std::string), (override));
+ MOCK_METHOD(void, SetOnlinePath, (std::string), (override));
+ MOCK_METHOD(void, SetOfflinePath, (std::string), (override));
- MOCK_METHOD1(SetSourceType, void (SourceType));
- MOCK_CONST_METHOD0(GetSourceType, SourceType ());
+ MOCK_METHOD(void, SetSourceType, (SourceType), (override));
+ MOCK_METHOD(SourceType, GetSourceType, (), (const, override));
- MOCK_CONST_METHOD0(WasAlreadyProcessed, bool());
- MOCK_METHOD0(SetAlreadyProcessedFlag, void());
- MOCK_METHOD2(SetResponseMessage, void(std::string, ResponseMessageType));
- MOCK_CONST_METHOD0(GetResponseMessage, const std::string & ());
- MOCK_CONST_METHOD0(GetResponseMessageType_t, ResponseMessageType ());
+ MOCK_METHOD(bool, WasAlreadyProcessed, (), (const, override));
+ MOCK_METHOD(void, SetAlreadyProcessedFlag, (), (override));
+ MOCK_METHOD(void, SetResponseMessage, (std::string, ResponseMessageType), (override));
+ MOCK_METHOD(const std::string &, GetResponseMessage, (), (const, override));
+ MOCK_METHOD(ResponseMessageType, GetResponseMessageType_t, (), (const));
ResponseMessageType GetResponseMessageType() const override {
return GetResponseMessageType_t();
@@ -116,18 +114,16 @@ class MockRequest: public Request {
return Error{CheckForDuplicates_t()};
}
- MOCK_METHOD0(CheckForDuplicates_t, ErrorInterface * ());
+ MOCK_METHOD(ErrorInterface *, CheckForDuplicates_t, (), ());
};
class MockDataCache: public DataCache {
public:
MockDataCache(): DataCache(0, 0) {};
- MOCK_METHOD2(GetFreeSlotAndLock, void* (uint64_t
- size, CacheMeta** meta));
- MOCK_METHOD1(UnlockSlot, bool(CacheMeta* meta));
- MOCK_METHOD3(GetSlotToReadAndLock, void* (uint64_t
- id, uint64_t data_size, CacheMeta** meta));
+ MOCK_METHOD(void*, GetFreeSlotAndLock, (uint64_t size, CacheMeta** meta), (override));
+ MOCK_METHOD(bool, UnlockSlot, (CacheMeta* meta), (override));
+ MOCK_METHOD(void*, GetSlotToReadAndLock, (uint64_t id, uint64_t data_size, CacheMeta** meta), (override));
};
@@ -137,7 +133,7 @@ class MockStatisticsSender: public StatisticsSender {
void SendStatistics(const StatisticsToSend& statistics) const noexcept override {
SendStatistics_t(statistics);
}
- MOCK_CONST_METHOD1(SendStatistics_t, void (const StatisticsToSend&));
+ MOCK_METHOD(void, SendStatistics_t, (const StatisticsToSend&), (const));
};
@@ -147,7 +143,7 @@ class MockFileProcessor: public FileProcessor {
return Error{ProcessFile_t(request, overwrite)};
}
- MOCK_CONST_METHOD2(ProcessFile_t, ErrorInterface * (const Request*, bool));
+ MOCK_METHOD(ErrorInterface *, ProcessFile_t, (const Request*, bool), (const));
};
@@ -156,15 +152,15 @@ class MockAuthorizationClient: public AuthorizationClient {
Error Authorize(const Request* request, AuthorizationData* data) const override {
return Error{Authorize_t(request, data)};
}
- MOCK_CONST_METHOD2(Authorize_t, ErrorInterface * (const Request*, AuthorizationData* ));
+ MOCK_METHOD(ErrorInterface *, Authorize_t, (const Request*, AuthorizationData*), (const));
};
inline void SetDefaultRequestCalls(MockRequest* mock_request,const std::string& bt) {
- ON_CALL(*mock_request, GetBeamtimeId()).WillByDefault(::testing::ReturnRef(bt));
- ON_CALL(*mock_request, GetBeamline()).WillByDefault(::testing::ReturnRef(""));
- ON_CALL(*mock_request, GetDataSource()).WillByDefault(::testing::ReturnRef(""));
- ON_CALL(*mock_request, GetStream()).WillByDefault(::testing::Return(""));
- ON_CALL(*mock_request, GetOriginHost()).WillByDefault(::testing::ReturnRef(""));
+ ON_CALL(*mock_request, GetBeamtimeId()).WillByDefault(::testing::ReturnRefOfCopy(bt));
+ ON_CALL(*mock_request, GetBeamline()).WillByDefault(::testing::ReturnRefOfCopy(std::string("")));
+ ON_CALL(*mock_request, GetDataSource()).WillByDefault(::testing::ReturnRefOfCopy(std::string("")));
+ ON_CALL(*mock_request, GetStream()).WillByDefault(::testing::Return(std::string("")));
+ ON_CALL(*mock_request, GetOriginHost()).WillByDefault(::testing::ReturnRefOfCopy(std::string("")));
ON_CALL(*mock_request, GetOpCode()).WillByDefault(::testing::Return(Opcode::kOpcodeTransferData));
}