From 1b85f2410d1d644ff00284e78b1eeff6cfad2fc4 Mon Sep 17 00:00:00 2001 From: christian mueller Date: Mon, 5 Mar 2012 13:55:09 +0100 Subject: * 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) --- .../test/CAmControlReceiverShadowTest.cpp | 123 ++++++++++++++++ .../test/CAmControlReceiverShadowTest.h | 36 +++++ PluginControlInterface/test/CMakeLists.txt | 56 ++++++++ .../test/MockIAmControlReceive.h | 158 +++++++++++++++++++++ 4 files changed, 373 insertions(+) create mode 100644 PluginControlInterface/test/CAmControlReceiverShadowTest.cpp create mode 100644 PluginControlInterface/test/CAmControlReceiverShadowTest.h create mode 100644 PluginControlInterface/test/CMakeLists.txt create mode 100644 PluginControlInterface/test/MockIAmControlReceive.h (limited to 'PluginControlInterface/test') 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::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(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 route_; + std::vector 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 +#include +#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 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& 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& 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& 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& listSystemProperties)); + MOCK_METHOD2(changeMainConnectionRouteDB, + am_Error_e(const am_mainConnectionID_t mainconnectionID, const std::vector& 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& listSinkID)); + MOCK_CONST_METHOD2(getListSourcesOfDomain, + am_Error_e(const am_domainID_t domainID, std::vector& listSourceID)); + MOCK_CONST_METHOD2(getListCrossfadersOfDomain, + am_Error_e(const am_domainID_t domainID, std::vector& listCrossfadersID)); + MOCK_CONST_METHOD2(getListGatewaysOfDomain, + am_Error_e(const am_domainID_t domainID, std::vector& listGatewaysID)); + MOCK_CONST_METHOD1(getListMainConnections, + am_Error_e(std::vector& listMainConnections)); + MOCK_CONST_METHOD1(getListDomains, + am_Error_e(std::vector& listDomains)); + MOCK_CONST_METHOD1(getListConnections, + am_Error_e(std::vector& listConnections)); + MOCK_CONST_METHOD1(getListSinks, + am_Error_e(std::vector& listSinks)); + MOCK_CONST_METHOD1(getListSources, + am_Error_e(std::vector& listSources)); + MOCK_CONST_METHOD1(getListSourceClasses, + am_Error_e(std::vector& listSourceClasses)); + MOCK_CONST_METHOD1(getListHandles, + am_Error_e(std::vector& listHandles)); + MOCK_CONST_METHOD1(getListCrossfaders, + am_Error_e(std::vector& listCrossfaders)); + MOCK_CONST_METHOD1(getListGateways, + am_Error_e(std::vector& listGateways)); + MOCK_CONST_METHOD1(getListSinkClasses, + am_Error_e(std::vector& listSinkClasses)); + MOCK_CONST_METHOD1(getListSystemProperties, + am_Error_e(std::vector& 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 -- cgit v1.2.1