CAmSerializer interface extended to support std::function.

Signed-off-by: Christian Linke <christian.linke@bmw.de>

Change-Id: I8b4c2c436ac9fbc37c76a21145c731f327cab0e4

6 files changed, 421 insertions, 111 deletions

diff --git a/AudioManagerUtilities/test/AmSerializerTest/CAmSerializerTest.cpp b/AudioManagerUtilities/test/AmSerializerTest/CAmSerializerTest.cpp
new file mode 100644
index 0000000..06488ea
--- /dev/null
+++ b/AudioManagerUtilities/test/AmSerializerTest/CAmSerializerTest.cpp
@@ -0,0 +1,158 @@
+/**
+ * SPDX license identifier: MPL-2.0
+ *
+ * Copyright (C) 2012, BMW AG
+ *
+ * This file is part of GENIVI Project AudioManager.
+ *
+ * Contributions are licensed to the GENIVI Alliance under one or more
+ * Contribution License Agreements.
+ *
+ * \copyright
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
+ * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ *
+ * \author Christian Linke, christian.linke@bmw.de BMW 2011,2012
+ *
+ * For further information see http://www.genivi.org/.
+ *
+ */
+
+#include <cstdio>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <sys/ioctl.h>
+#include <string.h>
+#include <netdb.h>
+#include <fcntl.h>
+#include <sys/un.h>
+#include <sys/poll.h>
+
+#include "CAmSocketHandler.h"
+#include "CAmSerializer.h"
+#include "CAmSerializerTest.h"
+
+using namespace testing;
+using namespace am;
+
+CAmTimerSockethandlerController::CAmTimerSockethandlerController(CAmSocketHandler *myHandler, const timespec &timeout) :
+        MockIAmTimerCb(), mpSocketHandler(myHandler), mUpdateTimeout(timeout), pTimerCallback(this, &CAmTimerSockethandlerController::timerCallback)
+{
+}
+
+am::CAmTimerSockethandlerController::~CAmTimerSockethandlerController()
+{
+}
+
+void am::CAmTimerSockethandlerController::timerCallback(sh_timerHandle_t handle, void* userData)
+{
+    MockIAmTimerCb::timerCallback(handle, userData);
+    mpSocketHandler->stop_listening();
+}
+
+CAmSerializerTest::CAmSerializerTest()
+{
+}
+
+CAmSerializerTest::~CAmSerializerTest()
+{
+}
+
+void CAmSerializerTest::SetUp()
+{
+
+}
+
+void CAmSerializerTest::TearDown()
+{
+}
+
+struct SerializerData
+{
+
+    std::string testStr;
+    int result;
+    MockIAmSerializerCb *pSerCb;
+    CAmSocketHandler *pSocketHandler;
+    CAmSerializer *pSerializer;
+};
+
+void* ptSerializer(void* data)
+{
+    SerializerData *pData = (SerializerData*) data;
+    std::string testStr(pData->testStr);
+    bool result = false;
+    int r = 0;
+    const uint32_t ten = 10;
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+    pData->pSerializer->syncCall(pData->pSerCb, &MockIAmSerializerCb::check);
+    pData->pSerializer->syncCall(pData->pSerCb, &MockIAmSerializerCb::checkInt, pData->result);
+    pData->pSerializer->syncCall(pData->pSerCb, &MockIAmSerializerCb::dispatchData, result, ten, pData->testStr);
+
+    for (uint32_t i = 0; i < 5; i++)
+        pData->pSerializer->asyncCall(pData->pSerCb, &MockIAmSerializerCb::dispatchData, i, testStr);
+
+    pData->pSerializer->asyncInvocation(std::bind([]()->bool
+    {   return 1;}));
+    pData->pSerializer->asyncInvocation(std::bind([](const int i, int & result)
+    {   result = i*10;}, 1, std::ref(r)));
+
+    pData->pSerializer->asyncCall(pData->pSerCb, &MockIAmSerializerCb::check);
+    pData->pSerializer->asyncCall(pData->pSerCb, &MockIAmSerializerCb::check);
+
+    pData->pSerializer->asyncCall(pData->pSerCb, &MockIAmSerializerCb::checkInt);
+#pragma GCC diagnostic pop
+    return (NULL);
+}
+
+ACTION(ActionDispatchData){
+arg1="DispatchData";
+}
+
+TEST(CAmSerializerTest, serializerTest)
+{
+    pthread_t serThread;
+
+    MockIAmSerializerCb serCb;
+    CAmSocketHandler myHandler;
+    std::string testStr("testStr");
+    CAmSerializer serializer(&myHandler);
+    sh_timerHandle_t handle;
+    timespec timeout4;
+    timeout4.tv_nsec = 0;
+    timeout4.tv_sec = 3;
+    CAmTimerSockethandlerController testCallback4(&myHandler, timeout4);
+    myHandler.addTimer(timeout4, &testCallback4.pTimerCallback, handle, NULL);
+    EXPECT_CALL(testCallback4,timerCallback(handle,NULL)).Times(1);
+
+    SerializerData serializerData;
+    serializerData.result = 0;
+    serializerData.testStr = testStr;
+    serializerData.pSerCb = &serCb;
+    serializerData.pSocketHandler = &myHandler;
+    serializerData.pSerializer = &serializer;
+    pthread_create(&serThread, NULL, ptSerializer, &serializerData);
+
+    EXPECT_CALL(serCb,check()).Times(3);
+    EXPECT_CALL(serCb,checkInt()).Times(2).WillRepeatedly(Return(100));
+
+    EXPECT_CALL(serCb,dispatchData(10,testStr)).WillOnce(DoAll(ActionDispatchData(), Return(true)));
+    for (int i = 0; i < 5; i++)
+        EXPECT_CALL(serCb,dispatchData(i,testStr)).WillOnce(DoAll(ActionDispatchData(), Return(true)));
+    myHandler.start_listenting();
+
+    pthread_join(serThread, NULL);
+    ASSERT_TRUE(serializerData.testStr == "DispatchData");
+    ASSERT_TRUE(serializerData.result == 100);
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+
diff --git a/AudioManagerUtilities/test/AmSerializerTest/CAmSerializerTest.h b/AudioManagerUtilities/test/AmSerializerTest/CAmSerializerTest.h
new file mode 100644
index 0000000..8ae3737
--- /dev/null
+++ b/AudioManagerUtilities/test/AmSerializerTest/CAmSerializerTest.h
@@ -0,0 +1,99 @@
+/**
+ * SPDX license identifier: MPL-2.0
+ *
+ * Copyright (C) 2012, BMW AG
+ *
+ * This file is part of GENIVI Project AudioManager.
+ *
+ * Contributions are licensed to the GENIVI Alliance under one or more
+ * Contribution License Agreements.
+ *
+ * \copyright
+ * This Source Code Form is subject to the terms of the
+ * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
+ * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ *
+ * \author Christian Linke, christian.linke@bmw.de BMW 2011,2012
+ *
+ * For further information see http://www.genivi.org/.
+ *
+ */
+
+#ifndef SERIALIZERTEST_H_
+#define SERIALIZERTEST_H_
+
+#define WITH_DLT
+
+#include <ctime>
+#include <chrono>
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+#include <queue>
+#include "CAmSocketHandler.h"
+
+namespace am
+{
+
+    class IAmSerializerCb
+    {
+    public:
+        virtual ~IAmSerializerCb()
+        {
+        }
+        virtual bool dispatchData(const uint32_t handle, std::string & outString)=0;
+        virtual void check()=0;
+        virtual int checkInt()=0;
+    };
+
+    class IAmTimerCb
+    {
+    public:
+        virtual ~IAmTimerCb()
+        {
+        }
+        virtual void timerCallback(sh_timerHandle_t handle, void * userData)=0;
+    };
+
+    class MockIAmTimerCb: public IAmTimerCb
+    {
+    public:
+        MOCK_CONST_METHOD2(timerCallback,
+                void(sh_timerHandle_t handle, void *userData));
+    };
+
+    class CAmTimerSockethandlerController: public MockIAmTimerCb
+    {
+        CAmSocketHandler *mpSocketHandler;
+        timespec mUpdateTimeout;
+    public:
+        explicit CAmTimerSockethandlerController(CAmSocketHandler *SocketHandler, const timespec &timeout);
+        virtual ~CAmTimerSockethandlerController();
+
+        void timerCallback(sh_timerHandle_t handle, void * userData);
+
+        TAmShTimerCallBack<CAmTimerSockethandlerController> pTimerCallback;
+    };
+
+    class MockIAmSerializerCb: public IAmSerializerCb
+    {
+    public:
+        MOCK_METHOD2(dispatchData,
+                bool(const uint32_t handle, std::string & outString));
+        MOCK_METHOD0(check,
+                void());
+        MOCK_METHOD0(checkInt,
+                int());
+    };
+
+    class CAmSerializerTest: public ::testing::Test
+    {
+    public:
+        CAmSerializerTest();
+        ~CAmSerializerTest();
+        void SetUp();
+        void TearDown();
+    };
+
+} /* namespace am */
+#endif /* SOCKETHANDLERTEST_H_ */
diff --git a/AudioManagerUtilities/test/AmSerializerTest/CMakeLists.txt b/AudioManagerUtilities/test/AmSerializerTest/CMakeLists.txt
new file mode 100644
index 0000000..3e89267
--- /dev/null
+++ b/AudioManagerUtilities/test/AmSerializerTest/CMakeLists.txt
@@ -0,0 +1,47 @@
+# Copyright (C) 2012, BMW AG
+#
+# This file is part of GENIVI Project AudioManager.
+# 
+# Contributions are licensed to the GENIVI Alliance under one or more
+# Contribution License Agreements.
+# 
+# copyright
+# This Source Code Form is subject to the terms of the
+# Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
+# this file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# 
+# author Christian Linke, christian.linke@bmw.de BMW 2011,2012
+#
+# For further information see http://www.genivi.org/.
+#
+
+cmake_minimum_required(VERSION 3.0)
+
+project(AmSerializerTest LANGUAGES CXX VERSION ${DAEMONVERSION})
+
+INCLUDE_DIRECTORIES(   
+    ${AUDIOMANAGER_UTILITIES_INCLUDE}
+    ${GMOCK_INCLUDE_DIRS}
+    ${GTEST_INCLUDE_DIRS})
+
+file(GLOB Socket_SRCS_CXX
+    "*.cpp"    
+)
+
+ADD_EXECUTABLE(AmSerializerTest ${Socket_SRCS_CXX})
+
+TARGET_LINK_LIBRARIES(AmSerializerTest 
+    ${GTEST_LIBRARIES}
+    ${GMOCK_LIBRARIES}
+    AudioManagerUtilities
+)
+
+ADD_DEPENDENCIES(AmSerializerTest AudioManagerUtilities)
+
+INSTALL(TARGETS AmSerializerTest 
+        DESTINATION ${TEST_EXECUTABLE_INSTALL_PATH}
+        PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ
+        COMPONENT tests
+)
+
+
diff --git a/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.cpp b/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.cpp
index 6f4f184..d443c89 100644
--- a/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.cpp
+++ b/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.cpp
@@ -120,7 +120,7 @@ void am::CAmTimerMeasurment::timerCallback(sh_timerHandle_t handle, void* userDa
 {
     MockIAmTimerCb::timerCallback(handle, userData);
 
-    std::chrono::time_point < std::chrono::high_resolution_clock > t_end = std::chrono::high_resolution_clock::now();
+    std::chrono::time_point<std::chrono::high_resolution_clock> t_end = std::chrono::high_resolution_clock::now();
     if (TP_ZERO != mLastInvocationTime)
     {
         auto durationLast = t_end - mLastInvocationTime;
@@ -133,8 +133,10 @@ void am::CAmTimerMeasurment::timerCallback(sh_timerHandle_t handle, void* userDa
         ", diff:" << diff << "ms ] " <<
         std::endl;
 #endif
-        EXPECT_LT(diff, TIMERS_CB_TOLERANCE) << mDebugText << " [ expected:" << std::chrono::duration<double, std::milli>(mExpected).count() << "ms, current:" << std::chrono::duration<double, std::milli>(durationLast).count() << "ms ]";
-        EXPECT_GT(diff, -TIMERS_CB_TOLERANCE) << mDebugText << " [ expected:" << std::chrono::duration<double, std::milli>(mExpected).count() << "ms, current:" << std::chrono::duration<double, std::milli>(durationLast).count() << "ms ]";
+        if (diff > TIMERS_CB_TOLERANCE)
+            std::cout << mDebugText << " Warning [ expected:" << std::chrono::duration<double, std::milli>(mExpected).count() << "ms, current:" << std::chrono::duration<double, std::milli>(durationLast).count() << "ms ]" << std::endl;
+        if (diff < -TIMERS_CB_TOLERANCE)
+            std::cout << mDebugText << " Warning [ expected:" << std::chrono::duration<double, std::milli>(mExpected).count() << "ms, current:" << std::chrono::duration<double, std::milli>(durationLast).count() << "ms ]" << std::endl;
 
         mLastInvocationTime = t_end;
         if (--mRepeats > 0)
diff --git a/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.h b/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.h
index b7d2a09..63f79cf 100644
--- a/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.h
+++ b/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.h
@@ -34,122 +34,128 @@
 
 #undef ENABLED_SOCKETHANDLER_TEST_OUTPUT
 #undef ENABLED_TIMERS_TEST_OUTPUT
-#define TIMERS_CB_TOLERANCE 10.f
+#define TIMERS_CB_TOLERANCE 8.f
 
 namespace am
 {
-  class IAmTimerCb
-  {
-  public:
-    virtual void timerCallback(sh_timerHandle_t handle, void * userData)=0;
-  };
-  
-  class IAmSocketHandlerCb
-  {
-  public:
-    virtual void receiveData(const pollfd pollfd, const sh_pollHandle_t handle, void* userData)=0;
-    virtual bool dispatchData(const sh_pollHandle_t handle, void* userData)=0;
-    virtual bool check(const sh_pollHandle_t handle, void* userData)=0;
-  };
-
-  class MockIAmTimerCb : public IAmTimerCb 
-  {
-    public:    
+    class IAmTimerCb
+    {
+    public:
+        virtual ~IAmTimerCb()
+        {
+        }
+        virtual void timerCallback(sh_timerHandle_t handle, void * userData)=0;
+    };
+
+    class IAmSocketHandlerCb
+    {
+    public:
+        virtual ~IAmSocketHandlerCb()
+        {
+        }
+        virtual void receiveData(const pollfd pollfd, const sh_pollHandle_t handle, void* userData)=0;
+        virtual bool dispatchData(const sh_pollHandle_t handle, void* userData)=0;
+        virtual bool check(const sh_pollHandle_t handle, void* userData)=0;
+    };
+
+    class MockIAmTimerCb: public IAmTimerCb
+    {
+    public:
         MOCK_CONST_METHOD2(timerCallback,
-            void(sh_timerHandle_t handle, void *userData));
-  };
-  
-  class MockSocketHandlerCb : public IAmSocketHandlerCb 
-  {
-    public:    
+                void(sh_timerHandle_t handle, void *userData));
+    };
+
+    class MockSocketHandlerCb: public IAmSocketHandlerCb
+    {
+    public:
         MOCK_CONST_METHOD3(receiveData,
-            void(const pollfd pollfd, const sh_pollHandle_t handle, void* userData));
+                void(const pollfd pollfd, const sh_pollHandle_t handle, void* userData));
         MOCK_CONST_METHOD2(dispatchData,
-            void(const sh_pollHandle_t handle, void* userData));
+                void(const sh_pollHandle_t handle, void* userData));
         MOCK_CONST_METHOD2(check,
-            void(const sh_pollHandle_t handle, void* userData));
+                void(const sh_pollHandle_t handle, void* userData));
     };
-    
-class CAmSamplePlugin : public MockSocketHandlerCb
-{
-public:
-    enum sockType_e
+
+    class CAmSamplePlugin: public MockSocketHandlerCb
     {
-        UNIX, INET
+    public:
+        enum sockType_e
+        {
+            UNIX, INET
+        };
+        CAmSamplePlugin(CAmSocketHandler *mySocketHandler, sockType_e socketType);
+        ~CAmSamplePlugin()
+        {
+        }
+        ;
+        void connectSocket(const pollfd pollfd, const sh_pollHandle_t handle, void* userData);
+        void receiveData(const pollfd pollfd, const sh_pollHandle_t handle, void* userData);
+        bool dispatchData(const sh_pollHandle_t handle, void* userData);
+        bool check(const sh_pollHandle_t handle, void* userData);
+        TAmShPollFired<CAmSamplePlugin> connectFiredCB;
+        TAmShPollFired<CAmSamplePlugin> receiveFiredCB;
+        TAmShPollDispatch<CAmSamplePlugin> sampleDispatchCB;
+        TAmShPollCheck<CAmSamplePlugin> sampleCheckCB;
+
+    private:
+        CAmSocketHandler *mSocketHandler;
+        sh_pollHandle_t mConnecthandle, mReceiveHandle;
+        std::queue<std::string> msgList;
     };
-    CAmSamplePlugin(CAmSocketHandler *mySocketHandler, sockType_e socketType);
-    ~CAmSamplePlugin()
+
+    class CAmTimerSockethandlerController: public MockIAmTimerCb
     {
-    }
-    ;
-    void connectSocket(const pollfd pollfd, const sh_pollHandle_t handle, void* userData);
-    void receiveData(const pollfd pollfd, const sh_pollHandle_t handle, void* userData);
-    bool dispatchData(const sh_pollHandle_t handle, void* userData);
-    bool check(const sh_pollHandle_t handle, void* userData);
-    TAmShPollFired<CAmSamplePlugin> connectFiredCB;
-    TAmShPollFired<CAmSamplePlugin> receiveFiredCB;
-    TAmShPollDispatch<CAmSamplePlugin> sampleDispatchCB;
-    TAmShPollCheck<CAmSamplePlugin> sampleCheckCB;
-
-private:
-    CAmSocketHandler *mSocketHandler;
-    sh_pollHandle_t mConnecthandle, mReceiveHandle;
-    std::queue<std::string> msgList;
-};
-
-class CAmTimerSockethandlerController: public MockIAmTimerCb
-{
-    CAmSocketHandler *mpSocketHandler;
-    timespec mUpdateTimeout;
-public:
-    explicit CAmTimerSockethandlerController(CAmSocketHandler *SocketHandler, const timespec &timeout);
-    virtual ~CAmTimerSockethandlerController();
-
-    void timerCallback(sh_timerHandle_t handle, void * userData);
-    
-    TAmShTimerCallBack<CAmTimerSockethandlerController> pTimerCallback;
-};
-
-class CAmTimer: public MockIAmTimerCb
-{
-    CAmSocketHandler *mpSocketHandler;
-    timespec mUpdateTimeout;
-    int32_t mRepeats;
-public:
-    explicit CAmTimer(CAmSocketHandler *SocketHandler, const timespec &timeout, const int32_t repeats = 0u);
-    virtual ~CAmTimer();
-
-    void timerCallback(sh_timerHandle_t handle, void * userData);
-    
-    TAmShTimerCallBack<CAmTimer> pTimerCallback;
-};
-
-class CAmTimerMeasurment: public MockIAmTimerCb
-{
-    CAmSocketHandler *mSocketHandler;
-    timespec mUpdateTimeout;
-    std::chrono::time_point<std::chrono::high_resolution_clock>  mUpdateTimePoint;
-    std::chrono::time_point<std::chrono::high_resolution_clock> mLastInvocationTime;
-    std::chrono::duration<long, std::ratio<1l, 1000000000l>> mExpected;
-    int32_t mRepeats;
-    void * mpUserData; 
-    std::string mDebugText;
-public:
-    explicit CAmTimerMeasurment(CAmSocketHandler *SocketHandler, const timespec &timeout, const std::string & label, const int32_t repeats = 0u, void * userData = NULL);
-    virtual ~CAmTimerMeasurment();
-
-    void timerCallback(sh_timerHandle_t handle, void * userData);
-    TAmShTimerCallBack<CAmTimerMeasurment> pTimerCallback;
-};
-
-class CAmSocketHandlerTest: public ::testing::Test
-{
-public:
-    CAmSocketHandlerTest();
-    ~CAmSocketHandlerTest();
-    void SetUp();
-    void TearDown();
-};
+        CAmSocketHandler *mpSocketHandler;
+        timespec mUpdateTimeout;
+    public:
+        explicit CAmTimerSockethandlerController(CAmSocketHandler *SocketHandler, const timespec &timeout);
+        virtual ~CAmTimerSockethandlerController();
+
+        void timerCallback(sh_timerHandle_t handle, void * userData);
+
+        TAmShTimerCallBack<CAmTimerSockethandlerController> pTimerCallback;
+    };
+
+    class CAmTimer: public MockIAmTimerCb
+    {
+        CAmSocketHandler *mpSocketHandler;
+        timespec mUpdateTimeout;
+        int32_t mRepeats;
+    public:
+        explicit CAmTimer(CAmSocketHandler *SocketHandler, const timespec &timeout, const int32_t repeats = 0u);
+        virtual ~CAmTimer();
+
+        void timerCallback(sh_timerHandle_t handle, void * userData);
+
+        TAmShTimerCallBack<CAmTimer> pTimerCallback;
+    };
+
+    class CAmTimerMeasurment: public MockIAmTimerCb
+    {
+        CAmSocketHandler *mSocketHandler;
+        timespec mUpdateTimeout;
+        std::chrono::time_point<std::chrono::high_resolution_clock> mUpdateTimePoint;
+        std::chrono::time_point<std::chrono::high_resolution_clock> mLastInvocationTime;
+        std::chrono::duration<long, std::ratio<1l, 1000000000l>> mExpected;
+        int32_t mRepeats;
+        void * mpUserData;
+        std::string mDebugText;
+    public:
+        explicit CAmTimerMeasurment(CAmSocketHandler *SocketHandler, const timespec &timeout, const std::string & label, const int32_t repeats = 0u, void * userData = NULL);
+        virtual ~CAmTimerMeasurment();
+
+        void timerCallback(sh_timerHandle_t handle, void * userData);
+        TAmShTimerCallBack<CAmTimerMeasurment> pTimerCallback;
+    };
+
+    class CAmSocketHandlerTest: public ::testing::Test
+    {
+    public:
+        CAmSocketHandlerTest();
+        ~CAmSocketHandlerTest();
+        void SetUp();
+        void TearDown();
+    };
 
 } /* namespace am */
 #endif /* SOCKETHANDLERTEST_H_ */
diff --git a/AudioManagerUtilities/test/CMakeLists.txt b/AudioManagerUtilities/test/CMakeLists.txt
index fb55831..414e199 100644
--- a/AudioManagerUtilities/test/CMakeLists.txt
+++ b/AudioManagerUtilities/test/CMakeLists.txt
@@ -1,4 +1,2 @@
 add_subdirectory (AmSocketHandlerTest)
-
-
-
+add_subdirectory (AmSerializerTest)