* fixing CAmSerializer.h - smaller changes and copy past stuff

* adding new class in Controler plugin to use CAmSerializer to build up a shadow
* added test to test the new class (unfinished)

4 files changed, 373 insertions, 0 deletions

diff --git a/PluginControlInterface/test/CAmControlReceiverShadowTest.cpp b/PluginControlInterface/test/CAmControlReceiverShadowTest.cpp
new file mode 100644
index 0000000..3452868
--- /dev/null
+++ b/PluginControlInterface/test/CAmControlReceiverShadowTest.cpp
@@ -0,0 +1,123 @@
+/*
+ * CAmControlReceiverShadowTest.cpp
+ *
+ *  Created on: Mar 2, 2012
+ *      Author: christian
+ */
+
+#include "CAmControlReceiverShadowTest.h"
+
+using namespace testing;
+using namespace am;
+
+CAmControlReceiverShadowTest::CAmControlReceiverShadowTest() :
+        psocketHandler(), //
+        pMockReceive(), //
+        pShadow(&pMockReceive, &psocketHandler), //
+        ptimerCallback(this, &CAmControlReceiverShadowTest::timerCallback)
+{
+    DefaultValue<am_Error_e>::Set(E_OK); // Sets the default value to be returned.
+}
+
+CAmControlReceiverShadowTest::~CAmControlReceiverShadowTest()
+{
+}
+
+void CAmControlReceiverShadowTest::SetUp()
+{
+    timespec t;
+    t.tv_nsec = 10000;
+    t.tv_sec = 0;
+
+    sh_timerHandle_t handle;
+
+    CAmShTimerCallBack *buf = &ptimerCallback;
+    //lets use a timeout so the test will finish
+    psocketHandler.addTimer(t, buf, handle, (void*) NULL);
+}
+
+void CAmControlReceiverShadowTest::timerCallback(sh_timerHandle_t handle, void* userData)
+{
+    (void)handle;
+    (void)userData;
+    psocketHandler.stop_listening();
+}
+
+void CAmControlReceiverShadowTest::TearDown()
+{
+}
+
+void* run_the_loop(void* socketHandlerPtr)
+{
+    CAmSocketHandler* socketHandler = static_cast<CAmSocketHandler*>(socketHandlerPtr);
+    socketHandler->start_listenting();
+    return (NULL);
+}
+
+TEST_F(CAmControlReceiverShadowTest,getRoute)
+{
+    pthread_t ptestThread;
+    bool onlyfree(true);
+    am_sourceID_t sourceID(1);
+    am_sinkID_t sinkID(2);
+    am_Route_s route;
+    am_RoutingElement_s routingElement;
+    std::vector<am_RoutingElement_s> route_;
+    std::vector<am_Route_s> returnList, List;
+    routingElement.sinkID = 1;
+    routingElement.sourceID = 2;
+    routingElement.domainID = 3;
+    routingElement.connectionFormat = CF_GENIVI_ANALOG;
+    route_.push_back(routingElement);
+    route.sinkID = 1;
+    route.sourceID = 2;
+    route.route = route_;
+    returnList.push_back(route);
+    EXPECT_CALL(pMockReceive,getRoute(onlyfree,sourceID,sinkID,_)).WillOnce(DoAll(SetArgReferee<3>(returnList),Return(E_OK)));
+    pthread_create(&ptestThread, NULL, run_the_loop, (void*) &psocketHandler);
+    ASSERT_EQ(E_OK, pShadow.getRoute(onlyfree, sourceID, sinkID, List));
+    pthread_join(ptestThread, NULL);
+}
+
+TEST_F(CAmControlReceiverShadowTest,connect)
+{
+    pthread_t ptestThread;
+    am_Handle_s handle, handleReturn;
+    handle.handle = 1;
+    handle.handleType = H_CONNECT;
+    am_connectionID_t connectionID(3), connectionIDReturn;
+    am_ConnectionFormat_e connectionFormat(CF_GENIVI_ANALOG);
+    am_sourceID_t sourceID(1);
+    am_sinkID_t sinkID(2);
+
+    EXPECT_CALL(pMockReceive, connect(_,_, connectionFormat, sourceID, sinkID)).WillOnce(DoAll(SetArgReferee<0>(handle),SetArgReferee<1>(connectionID),Return(E_OK)));
+    pthread_create(&ptestThread, NULL, run_the_loop, (void*) &psocketHandler);
+    ASSERT_EQ(E_OK,pShadow.connect(handleReturn,connectionIDReturn, connectionFormat, sourceID, sinkID));
+    ASSERT_EQ(handleReturn.handle,handle.handle);
+    ASSERT_EQ(handleReturn.handleType,handle.handleType);
+    ASSERT_EQ(connectionIDReturn,connectionID);
+    pthread_join(ptestThread, NULL);
+}
+
+TEST_F(CAmControlReceiverShadowTest,disconnect)
+{
+    pthread_t ptestThread;
+    am_Handle_s handle, handleReturn;
+    handle.handle = 1;
+    handle.handleType = H_CONNECT;
+    am_connectionID_t connectionID(3);
+
+    EXPECT_CALL(pMockReceive, disconnect(_,connectionID)).WillOnce(DoAll(SetArgReferee<0>(handle),Return(E_OK)));
+    pthread_create(&ptestThread, NULL, run_the_loop, (void*) &psocketHandler);
+    ASSERT_EQ(E_OK,pShadow.disconnect(handleReturn,connectionID));
+    ASSERT_EQ(handleReturn.handle,handle.handle);
+    ASSERT_EQ(handleReturn.handleType,handle.handleType);
+    pthread_join(ptestThread, NULL);
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+
diff --git a/PluginControlInterface/test/CAmControlReceiverShadowTest.h b/PluginControlInterface/test/CAmControlReceiverShadowTest.h
new file mode 100644
index 0000000..42cec0d
--- /dev/null
+++ b/PluginControlInterface/test/CAmControlReceiverShadowTest.h
@@ -0,0 +1,36 @@
+/*
+ * CAmControlReceiverShadowTest.h
+ *
+ *  Created on: Mar 2, 2012
+ *      Author: christian
+ */
+
+#ifndef CAMCONTROLRECEIVERSHADOWTEST_H_
+#define CAMCONTROLRECEIVERSHADOWTEST_H_
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "MockIAmControlReceive.h"
+#include "shared/CAmSocketHandler.h"
+#include "shared/CAmSerializer.h"
+#include "../include/IAmControlReceiverShadow.h"
+
+namespace am
+{
+
+class CAmControlReceiverShadowTest: public ::testing::Test
+{
+public:
+    CAmSocketHandler psocketHandler;
+    MockIAmControlReceive pMockReceive;
+    IAmControlReceiverShadow pShadow;
+    void timerCallback(sh_timerHandle_t handle, void* userData);
+    TAmShTimerCallBack<CAmControlReceiverShadowTest> ptimerCallback;
+    CAmControlReceiverShadowTest();
+    ~CAmControlReceiverShadowTest();
+    void SetUp();
+    void TearDown();
+};
+
+} /* namespace am */
+#endif /* CAMCONTROLRECEIVERSHADOWTEST_H_ */
diff --git a/PluginControlInterface/test/CMakeLists.txt b/PluginControlInterface/test/CMakeLists.txt
new file mode 100644
index 0000000..0cc914a
--- /dev/null
+++ b/PluginControlInterface/test/CMakeLists.txt
@@ -0,0 +1,56 @@
+cmake_minimum_required(VERSION 2.6)
+
+PROJECT(AmControlReceiverShadowTest)
+
+set(EXECUTABLE_OUTPUT_PATH ${TEST_EXECUTABLE_OUTPUT_PATH})
+FIND_PACKAGE(GTest REQUIRED) 
+
+find_package (Threads)
+FIND_PACKAGE(PkgConfig)
+pkg_check_modules(DLT REQUIRED automotive-dlt)
+
+INCLUDE_DIRECTORIES(   
+    ${STD_INCLUDE_DIRS}
+    ${CMAKE_SOURCE_DIR} 
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${AUDIO_include_FOLDER}
+    ${CMAKE_SOURCE_DIR} 
+    ${DLT_INCLUDE_DIRS}
+    ${include_FOLDER}
+    ${GTEST_INCLUDE_DIR}
+    ${DBUS_INCLUDE_DIR}
+    ${DBUS_ARCH_INCLUDE_DIR}
+    "../../AudioManagerDaemon/include"
+    "../include"
+)
+   
+file(GLOB CONTROL_RECEIVER_PLUGIN_INTERFACE_SRCS_CXX 
+     "../../AudioManagerDaemon/src/CAmSocketHandler.cpp"
+     "../../AudioManagerDaemon/src/CAmDltWrapper.cpp"     
+     "../src/IAmControlReceiverShadow.cpp"  
+     "CAmControlReceiverShadowTest.cpp" 
+)
+
+
+ADD_EXECUTABLE(AmControlReceiverShadowTest ${CONTROL_RECEIVER_PLUGIN_INTERFACE_SRCS_CXX})
+
+
+TARGET_LINK_LIBRARIES(AmControlReceiverShadowTest 
+    ${DLT_LIBRARIES}
+    ${CMAKE_DL_LIBS}
+    ${CMAKE_THREAD_LIBS_INIT}
+    ${GTEST_LIBRARIES}
+    ${DBUS_LIBRARY}
+    ${SQLITE_LIBRARIES}
+    gmock
+)
+
+INSTALL(TARGETS AmControlReceiverShadowTest 
+        DESTINATION "~/AudioManagerTest/"
+        PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ
+        COMPONENT tests
+)
+
+SET(ADD_DEPEND "audiomanager-bin" "dlt" "libdbus-1-3(>=1.2.16)" "libgtest-dev(>=1.6.0-1)" "google-mock" "libpthread-stubs0")
+set_property(GLOBAL APPEND PROPERTY tests_prop "${ADD_DEPEND}")
+
diff --git a/PluginControlInterface/test/MockIAmControlReceive.h b/PluginControlInterface/test/MockIAmControlReceive.h
new file mode 100644
index 0000000..a04889d
--- /dev/null
+++ b/PluginControlInterface/test/MockIAmControlReceive.h
@@ -0,0 +1,158 @@
+#ifndef MOCKCONTROLINTERFACE_H_
+#define MOCKCONTROLINTERFACE_H_
+
+#include "control/IAmControlReceive.h"
+
+
+namespace am {
+
+class MockIAmControlReceive : public IAmControlReceive {
+ public:
+  MOCK_METHOD4(getRoute,
+      am_Error_e(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s>& returnList));
+  MOCK_METHOD5(connect,
+      am_Error_e(am_Handle_s& handle, am_connectionID_t& connectionID, const am_ConnectionFormat_e format, const am_sourceID_t sourceID, const am_sinkID_t sinkID));
+  MOCK_METHOD2(disconnect,
+      am_Error_e(am_Handle_s& handle, const am_connectionID_t connectionID));
+  MOCK_METHOD5(crossfade,
+      am_Error_e(am_Handle_s& handle, const am_HotSink_e hotSource, const am_crossfaderID_t crossfaderID, const am_RampType_e rampType, const am_time_t rampTime));
+  MOCK_METHOD1(abortAction,
+      am_Error_e(const am_Handle_s handle));
+  MOCK_METHOD3(setSourceState,
+      am_Error_e(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SourceState_e state));
+  MOCK_METHOD5(setSinkVolume,
+      am_Error_e(am_Handle_s& handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time));
+  MOCK_METHOD5(setSourceVolume,
+      am_Error_e(am_Handle_s& handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e rampType, const am_time_t time));
+  MOCK_METHOD3(setSinkSoundProperties,
+      am_Error_e(am_Handle_s& handle, const am_sinkID_t sinkID, const std::vector<am_SoundProperty_s>& soundProperty));
+  MOCK_METHOD3(setSinkSoundProperty,
+      am_Error_e(am_Handle_s& handle, const am_sinkID_t sinkID, const am_SoundProperty_s& soundProperty));
+  MOCK_METHOD3(setSourceSoundProperties,
+      am_Error_e(am_Handle_s& handle, const am_sourceID_t sourceID, const std::vector<am_SoundProperty_s>& soundProperty));
+  MOCK_METHOD3(setSourceSoundProperty,
+      am_Error_e(am_Handle_s& handle, const am_sourceID_t sourceID, const am_SoundProperty_s& soundProperty));
+  MOCK_METHOD2(setDomainState,
+      am_Error_e(const am_domainID_t domainID, const am_DomainState_e domainState));
+  MOCK_METHOD2(enterDomainDB,
+      am_Error_e(const am_Domain_s& domainData, am_domainID_t& domainID));
+  MOCK_METHOD2(enterMainConnectionDB,
+      am_Error_e(const am_MainConnection_s& mainConnectionData, am_mainConnectionID_t& connectionID));
+  MOCK_METHOD2(enterSinkDB,
+      am_Error_e(const am_Sink_s& sinkData, am_sinkID_t& sinkID));
+  MOCK_METHOD2(enterCrossfaderDB,
+      am_Error_e(const am_Crossfader_s& crossfaderData, am_crossfaderID_t& crossfaderID));
+  MOCK_METHOD2(enterGatewayDB,
+      am_Error_e(const am_Gateway_s& gatewayData, am_gatewayID_t& gatewayID));
+  MOCK_METHOD2(enterSourceDB,
+      am_Error_e(const am_Source_s& sourceData, am_sourceID_t& sourceID));
+  MOCK_METHOD2(enterSinkClassDB,
+      am_Error_e(const am_SinkClass_s& sinkClass, am_sinkClass_t& sinkClassID));
+  MOCK_METHOD2(enterSourceClassDB,
+      am_Error_e(am_sourceClass_t& sourceClassID, const am_SourceClass_s& sourceClass));
+  MOCK_METHOD1(changeSinkClassInfoDB,
+      am_Error_e(const am_SinkClass_s& sinkClass));
+  MOCK_METHOD1(changeSourceClassInfoDB,
+      am_Error_e(const am_SourceClass_s& sourceClass));
+  MOCK_METHOD1(enterSystemPropertiesListDB,
+      am_Error_e(const std::vector<am_SystemProperty_s>& listSystemProperties));
+  MOCK_METHOD2(changeMainConnectionRouteDB,
+      am_Error_e(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID));
+  MOCK_METHOD2(changeMainConnectionStateDB,
+      am_Error_e(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState));
+  MOCK_METHOD2(changeSinkMainVolumeDB,
+      am_Error_e(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID));
+  MOCK_METHOD2(changeSinkAvailabilityDB,
+      am_Error_e(const am_Availability_s& availability, const am_sinkID_t sinkID));
+  MOCK_METHOD2(changDomainStateDB,
+      am_Error_e(const am_DomainState_e domainState, const am_domainID_t domainID));
+  MOCK_METHOD2(changeSinkMuteStateDB,
+      am_Error_e(const am_MuteState_e muteState, const am_sinkID_t sinkID));
+  MOCK_METHOD2(changeMainSinkSoundPropertyDB,
+      am_Error_e(const am_MainSoundProperty_s& soundProperty, const am_sinkID_t sinkID));
+  MOCK_METHOD2(changeMainSourceSoundPropertyDB,
+      am_Error_e(const am_MainSoundProperty_s& soundProperty, const am_sourceID_t sourceID));
+  MOCK_METHOD2(changeSourceAvailabilityDB,
+      am_Error_e(const am_Availability_s& availability, const am_sourceID_t sourceID));
+  MOCK_METHOD1(changeSystemPropertyDB,
+      am_Error_e(const am_SystemProperty_s& property));
+  MOCK_METHOD1(removeMainConnectionDB,
+      am_Error_e(const am_mainConnectionID_t mainConnectionID));
+  MOCK_METHOD1(removeSinkDB,
+      am_Error_e(const am_sinkID_t sinkID));
+  MOCK_METHOD1(removeSourceDB,
+      am_Error_e(const am_sourceID_t sourceID));
+  MOCK_METHOD1(removeGatewayDB,
+      am_Error_e(const am_gatewayID_t gatewayID));
+  MOCK_METHOD1(removeCrossfaderDB,
+      am_Error_e(const am_crossfaderID_t crossfaderID));
+  MOCK_METHOD1(removeDomainDB,
+      am_Error_e(const am_domainID_t domainID));
+  MOCK_METHOD1(removeSinkClassDB,
+      am_Error_e(const am_sinkClass_t sinkClassID));
+  MOCK_METHOD1(removeSourceClassDB,
+      am_Error_e(const am_sourceClass_t sourceClassID));
+  MOCK_CONST_METHOD2(getSourceClassInfoDB,
+      am_Error_e(const am_sourceID_t sourceID, am_SourceClass_s& classInfo));
+  MOCK_CONST_METHOD2(getSinkClassInfoDB,
+      am_Error_e(const am_sinkID_t sinkID, am_SinkClass_s& sinkClass));
+  MOCK_CONST_METHOD2(getSinkInfoDB,
+      am_Error_e(const am_sinkID_t sinkID, am_Sink_s& sinkData));
+  MOCK_CONST_METHOD2(getSourceInfoDB,
+      am_Error_e(const am_sourceID_t sourceID, am_Source_s& sourceData));
+  MOCK_CONST_METHOD2(getGatewayInfoDB,
+      am_Error_e(const am_gatewayID_t gatewayID, am_Gateway_s& gatewayData));
+  MOCK_CONST_METHOD2(getCrossfaderInfoDB,
+      am_Error_e(const am_crossfaderID_t crossfaderID, am_Crossfader_s& crossfaderData));
+  MOCK_CONST_METHOD2(getMainConnectionInfoDB,
+      am_Error_e(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s& mainConnectionData));
+  MOCK_CONST_METHOD2(getListSinksOfDomain,
+      am_Error_e(const am_domainID_t domainID, std::vector<am_sinkID_t>& listSinkID));
+  MOCK_CONST_METHOD2(getListSourcesOfDomain,
+      am_Error_e(const am_domainID_t domainID, std::vector<am_sourceID_t>& listSourceID));
+  MOCK_CONST_METHOD2(getListCrossfadersOfDomain,
+      am_Error_e(const am_domainID_t domainID, std::vector<am_crossfaderID_t>& listCrossfadersID));
+  MOCK_CONST_METHOD2(getListGatewaysOfDomain,
+      am_Error_e(const am_domainID_t domainID, std::vector<am_gatewayID_t>& listGatewaysID));
+  MOCK_CONST_METHOD1(getListMainConnections,
+      am_Error_e(std::vector<am_MainConnection_s>& listMainConnections));
+  MOCK_CONST_METHOD1(getListDomains,
+      am_Error_e(std::vector<am_Domain_s>& listDomains));
+  MOCK_CONST_METHOD1(getListConnections,
+      am_Error_e(std::vector<am_Connection_s>& listConnections));
+  MOCK_CONST_METHOD1(getListSinks,
+      am_Error_e(std::vector<am_Sink_s>& listSinks));
+  MOCK_CONST_METHOD1(getListSources,
+      am_Error_e(std::vector<am_Source_s>& listSources));
+  MOCK_CONST_METHOD1(getListSourceClasses,
+      am_Error_e(std::vector<am_SourceClass_s>& listSourceClasses));
+  MOCK_CONST_METHOD1(getListHandles,
+      am_Error_e(std::vector<am_Handle_s>& listHandles));
+  MOCK_CONST_METHOD1(getListCrossfaders,
+      am_Error_e(std::vector<am_Crossfader_s>& listCrossfaders));
+  MOCK_CONST_METHOD1(getListGateways,
+      am_Error_e(std::vector<am_Gateway_s>& listGateways));
+  MOCK_CONST_METHOD1(getListSinkClasses,
+      am_Error_e(std::vector<am_SinkClass_s>& listSinkClasses));
+  MOCK_CONST_METHOD1(getListSystemProperties,
+      am_Error_e(std::vector<am_SystemProperty_s>& listSystemProperties));
+  MOCK_METHOD0(setCommandReady,
+      void());
+  MOCK_METHOD0(setCommandRundown,
+      void());
+  MOCK_METHOD0(setRoutingReady,
+      void());
+  MOCK_METHOD0(setRoutingRundown,
+      void());
+  MOCK_METHOD0(confirmControllerReady,
+      void());
+  MOCK_METHOD0(confirmControllerRundown,
+      void());
+  MOCK_METHOD1(getSocketHandler,
+      am_Error_e(CAmSocketHandler*& socketHandler));
+  MOCK_CONST_METHOD1(getInterfaceVersion,
+      void(std::string& version));
+};
+
+} // namespace am
+#endif