[RDS] Applied code style

receiver/src/receiver_data_server/receiver_data_server_request_handler.cpp

@@ -23,7 +23,7 @@ Error ReceiverDataServerRequestHandler::SendResponse(const ReceiverDataServerReq
 }
 
 Error ReceiverDataServerRequestHandler::SendResponseAndSlotData(const ReceiverDataServerRequest* request,
-                                                                CacheMeta* meta) {
+        CacheMeta* meta) {
     GenericNetworkResponse response{};
     response.op_code = kOpcodeGetBufferData;
     response.error_code = kNetErrorNoError;

receiver/src/receiver_data_server/tcp_server.h

@@ -16,7 +16,7 @@ class TcpServer : public NetServer {
     GenericRequests GetNewRequests(Error* err) const noexcept override ;
     Error SendResponse(uint64_t source_id, GenericNetworkResponse* response) const noexcept override;
     Error SendResponseAndSlotData(uint64_t source_id, GenericNetworkResponse* response,
-                                          GenericRequestHeader* request, CacheMeta* cache_slot) const noexcept override;
+                                  GenericRequestHeader* request, CacheMeta* cache_slot) const noexcept override;
     void HandleAfterError(uint64_t source_id) const noexcept override;
     std::unique_ptr<IO> io__;
     const AbstractLogger* log__;

receiver/unittests/receiver_data_server/receiver_dataserver_mocking.h

@@ -37,7 +37,7 @@ class MockNetServer : public NetServer {
         return  Error{SendResponseAndSlotData_t(source_id, response, request, cache_slot)};
     };
     MOCK_CONST_METHOD4(SendResponseAndSlotData_t, ErrorInterface * (uint64_t source_id, GenericNetworkResponse* response,
-            GenericRequestHeader* request, CacheMeta* cache_slot));
+                       GenericRequestHeader* request, CacheMeta* cache_slot));
 
     void  HandleAfterError(uint64_t source_id) const noexcept override {
         HandleAfterError_t(source_id);

receiver/unittests/receiver_data_server/test_request_handler.cpp

@@ -32,9 +32,9 @@ using asapo::ReceiverDataServerRequestHandler;
 namespace {
 
 MATCHER_P3(M_CheckResponse, op_code, error_code, message,
-    "Checks if a valid GenericNetworkResponse was used") {
+           "Checks if a valid GenericNetworkResponse was used") {
     return ((asapo::GenericNetworkResponse*)arg)->op_code == op_code
-            && ((asapo::GenericNetworkResponse*)arg)->error_code == uint64_t(error_code);
+           && ((asapo::GenericNetworkResponse*)arg)->error_code == uint64_t(error_code);
 }
 
 TEST(RequestHandlerTest, Constructor) {
@@ -77,9 +77,9 @@ class RequestHandlerTests : public Test {
 
 void RequestHandlerTests::MockGetSlotAndUnlockIt(bool return_without_error) {
     EXPECT_CALL(mock_cache, GetSlotToReadAndLock(expected_buf_id, expected_data_size, _)).WillOnce(DoAll(
-        SetArgPointee<2>(return_without_error ? &expected_meta : nullptr),
-        Return(return_without_error ? &tmp : nullptr)
-    ));
+                SetArgPointee<2>(return_without_error ? &expected_meta : nullptr),
+                Return(return_without_error ? &tmp : nullptr)
+            ));
     if (return_without_error) {
         EXPECT_CALL(mock_cache, UnlockSlot(_));
     }
@@ -87,23 +87,23 @@ void RequestHandlerTests::MockGetSlotAndUnlockIt(bool return_without_error) {
 
 void RequestHandlerTests::MockSendResponse(asapo::NetworkErrorCode expected_response_code, bool return_without_error) {
     EXPECT_CALL(mock_net, SendResponse_t(
-            expected_source_id,
-            M_CheckResponse(asapo::kOpcodeGetBufferData, expected_response_code, "")
-    )).WillOnce(
-            Return(return_without_error ? nullptr : asapo::IOErrorTemplates::kUnknownIOError.Generate().release())
-    );
+                    expected_source_id,
+                    M_CheckResponse(asapo::kOpcodeGetBufferData, expected_response_code, "")
+                )).WillOnce(
+                    Return(return_without_error ? nullptr : asapo::IOErrorTemplates::kUnknownIOError.Generate().release())
+                );
 }
 
 void RequestHandlerTests::MockSendResponseAndSlotData(asapo::NetworkErrorCode expected_response_code,
-                                                      bool return_without_error) {
+        bool return_without_error) {
     EXPECT_CALL(mock_net, SendResponseAndSlotData_t(
-            expected_source_id,
-            M_CheckResponse(asapo::kOpcodeGetBufferData, expected_response_code, ""),
-            &request.header,
-            &expected_meta
-    )).WillOnce(
-            Return(return_without_error ? nullptr : asapo::IOErrorTemplates::kUnknownIOError.Generate().release())
-    );
+                    expected_source_id,
+                    M_CheckResponse(asapo::kOpcodeGetBufferData, expected_response_code, ""),
+                    &request.header,
+                    &expected_meta
+                )).WillOnce(
+                    Return(return_without_error ? nullptr : asapo::IOErrorTemplates::kUnknownIOError.Generate().release())
+                );
 }
 
 TEST_F(RequestHandlerTests, RequestAlwaysReady) {

receiver/unittests/receiver_data_server/test_tcp_server.cpp

@@ -238,11 +238,11 @@ TEST_F(TCPServerTests, SendResponse) {
     asapo::GenericNetworkResponse tmp {};
 
     EXPECT_CALL(mock_io, Send_t(1, &tmp, sizeof(asapo::GenericNetworkResponse), _))
-            .WillOnce(
-                    DoAll(
-                            testing::SetArgPointee<3>(asapo::IOErrorTemplates::kUnknownIOError.Generate().release()),
-                            Return(1)
-                    ));
+    .WillOnce(
+        DoAll(
+            testing::SetArgPointee<3>(asapo::IOErrorTemplates::kUnknownIOError.Generate().release()),
+            Return(1)
+        ));
 
     EXPECT_CALL(mock_logger, Error(HasSubstr("cannot send")));
 
@@ -263,10 +263,10 @@ TEST_F(TCPServerTests, SendResponseAndSlotData_SendResponseError) {
     expectedMeta.lock = 123;
 
     EXPECT_CALL(mock_io, Send_t(1, &tmp, sizeof(asapo::GenericNetworkResponse), _))
-            .WillOnce(DoAll(
-                    testing::SetArgPointee<3>(asapo::IOErrorTemplates::kUnknownIOError.Generate().release()),
-                    Return(0)
-            ));
+    .WillOnce(DoAll(
+                  testing::SetArgPointee<3>(asapo::IOErrorTemplates::kUnknownIOError.Generate().release()),
+                  Return(0)
+              ));
     EXPECT_CALL(mock_logger, Error(HasSubstr("cannot send")));
 
     auto err = tcp_server.SendResponseAndSlotData(1, &tmp, &expectedRequest, &expectedMeta);
@@ -286,13 +286,13 @@ TEST_F(TCPServerTests, SendResponseAndSlotData_SendDataError) {
     expectedMeta.lock = 123;
 
     EXPECT_CALL(mock_io, Send_t(1, &tmp, sizeof(asapo::GenericNetworkResponse), _))
-            .WillOnce(Return(1));
+    .WillOnce(Return(1));
     EXPECT_CALL(mock_io, Send_t(1, expectedMeta.addr, expectedMeta.size, _))
-            .WillOnce(
-                    DoAll(
-                            testing::SetArgPointee<3>(asapo::IOErrorTemplates::kUnknownIOError.Generate().release()),
-                            Return(0)
-                    ));
+    .WillOnce(
+        DoAll(
+            testing::SetArgPointee<3>(asapo::IOErrorTemplates::kUnknownIOError.Generate().release()),
+            Return(0)
+        ));
 
     EXPECT_CALL(mock_logger, Error(HasSubstr("cannot send")));
 
@@ -313,9 +313,9 @@ TEST_F(TCPServerTests, SendResponseAndSlotData_Ok) {
     expectedMeta.lock = 123;
 
     EXPECT_CALL(mock_io, Send_t(1, &tmp, sizeof(asapo::GenericNetworkResponse), _))
-            .WillOnce(Return(1));
+    .WillOnce(Return(1));
     EXPECT_CALL(mock_io, Send_t(1, expectedMeta.addr, expectedMeta.size, _))
-            .WillOnce(Return(expectedMeta.size));
+    .WillOnce(Return(expectedMeta.size));
 
     auto err = tcp_server.SendResponseAndSlotData(1, &tmp, &expectedRequest, &expectedMeta);