1 files changed, 153 insertions, 47 deletions
diff --git a/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.h b/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.h
index 95e5446..ba2bf51 100644
--- a/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.h
+++ b/AudioManagerUtilities/test/AmSocketHandlerTest/CAmSocketHandlerTest.h
@@ -25,63 +25,169 @@
 
 #define WITH_DLT
 
+#include <ctime>
+#include <chrono>
 #include "gtest/gtest.h"
+#include "gmock/gmock.h"
 #include <queue>
 #include "CAmSocketHandler.h"
 
+#undef ENABLED_SOCKETHANDLER_TEST_OUTPUT
+#undef ENABLED_TIMERS_TEST_OUTPUT
+#define TIMERS_CB_TOLERANCE 8.f
+
 namespace am
 {
+    class IAmTimerCb
+    {
+    public:
+        virtual ~IAmTimerCb()
+        {
+        }
+        virtual void timerCallback(sh_timerHandle_t handle, void * userData)=0;
+    };
 
-class CAmSamplePlugin
-{
-public:
-    enum sockType_e
+    class IAmSignalHandler
     {
-        UNIX, INET
+    public:
+        virtual ~IAmSignalHandler()
+        {
+        }
+        virtual void signalHandlerAction(const sh_pollHandle_t handle, const unsigned sig, void* userData)=0;
+        virtual void signalHandler(int sig, siginfo_t *siginfo, void *context)=0;
     };
-    CAmSamplePlugin(CAmSocketHandler *mySocketHandler, sockType_e socketType);
-    ~CAmSamplePlugin()
+
+    class IAmSocketHandlerCb
     {
-    }
-    ;
-    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 CAmTimerCb
-{
-public:
-    CAmTimerCb(CAmSocketHandler *SocketHandler);
-    virtual ~CAmTimerCb();
-    void timer1Callback(sh_timerHandle_t handle, void * userData);
-    void timer2Callback(sh_timerHandle_t handle, void * userData);
-    void timer3Callback(sh_timerHandle_t handle, void * userData);
-    void timer4Callback(sh_timerHandle_t handle, void * userData);
-    TAmShTimerCallBack<CAmTimerCb> pTimer1Callback;
-    TAmShTimerCallBack<CAmTimerCb> pTimer2Callback;
-    TAmShTimerCallBack<CAmTimerCb> pTimer3Callback;
-    TAmShTimerCallBack<CAmTimerCb> pTimer4Callback;
-    CAmSocketHandler *mSocketHandler;
-};
-
-class CAmSocketHandlerTest: public ::testing::Test
-{
-public:
-    CAmSocketHandlerTest();
-    ~CAmSocketHandlerTest();
-    void SetUp();
-    void TearDown();
-};
+    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 MockIAmSignalHandler: public IAmSignalHandler
+    {
+    public:
+        MOCK_METHOD3(signalHandlerAction, void (const sh_pollHandle_t handle, const unsigned sig, void* userData));
+        MOCK_METHOD3(signalHandler, void(int sig, siginfo_t *siginfo, void *context));
+    };
+
+    class MockSocketHandlerCb: public IAmSocketHandlerCb
+    {
+    public:
+        MOCK_CONST_METHOD3(receiveData,
+                void(const pollfd pollfd, const sh_pollHandle_t handle, void* userData));
+        MOCK_CONST_METHOD2(dispatchData,
+                void(const sh_pollHandle_t handle, void* userData));
+        MOCK_CONST_METHOD2(check,
+                void(const sh_pollHandle_t handle, void* userData));
+    };
+
+    class CAmSamplePlugin: public MockSocketHandlerCb
+    {
+    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;
+    };
+
+    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 CAmTimerSignalHandler: public MockIAmTimerCb
+    {
+        unsigned mIndex;
+        std::set<unsigned> mSignals;
+        CAmSocketHandler *mpSocketHandler;
+        timespec mUpdateTimeout;
+    public:
+        explicit CAmTimerSignalHandler(CAmSocketHandler *SocketHandler, const timespec &timeout, const std::set<unsigned> & signals);
+        virtual ~CAmTimerSignalHandler();
+
+        void timerCallback(sh_timerHandle_t handle, void * userData);
+
+        TAmShTimerCallBack<CAmTimerSignalHandler> 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_ */