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) --- PluginControlInterface/CMakeLists.txt | 2 +- .../include/IAmControlReceiverShadow.h | 105 +++++ .../src/IAmControlReceiverShadow.cpp | 511 +++++++++++++++++++++ .../test/CAmControlReceiverShadowTest.cpp | 123 +++++ .../test/CAmControlReceiverShadowTest.h | 36 ++ PluginControlInterface/test/CMakeLists.txt | 56 +++ .../test/MockIAmControlReceive.h | 158 +++++++ 7 files changed, 990 insertions(+), 1 deletion(-) create mode 100644 PluginControlInterface/include/IAmControlReceiverShadow.h create mode 100644 PluginControlInterface/src/IAmControlReceiverShadow.cpp 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') diff --git a/PluginControlInterface/CMakeLists.txt b/PluginControlInterface/CMakeLists.txt index 7701364..9111c84 100644 --- a/PluginControlInterface/CMakeLists.txt +++ b/PluginControlInterface/CMakeLists.txt @@ -32,7 +32,7 @@ TARGET_LINK_LIBRARIES(PluginControlInterface ${DLT_LIBRARIES}) IF(WITH_TESTS) -# add_subdirectory (test) + add_subdirectory (test) ENDIF(WITH_TESTS) #IF(WITH_DOCUMENTATION) diff --git a/PluginControlInterface/include/IAmControlReceiverShadow.h b/PluginControlInterface/include/IAmControlReceiverShadow.h new file mode 100644 index 0000000..bf5580b --- /dev/null +++ b/PluginControlInterface/include/IAmControlReceiverShadow.h @@ -0,0 +1,105 @@ +/* + * IAmControlReceiverShadow.h + * + * Created on: Mar 2, 2012 + * Author: christian + */ + +#ifndef IAMCONTROLRECEIVERSHADOW_H_ +#define IAMCONTROLRECEIVERSHADOW_H_ + +#include "audiomanagertypes.h" +#include "shared/CAmSerializer.h" + +namespace am +{ +class IAmControlReceive; +class CAmSocketHandler; + +/** + * shadow class that used CAmSerializer to make threadsafe calls to the IAmControlReceive interface. + */ +class IAmControlReceiverShadow +{ +public: + IAmControlReceiverShadow(IAmControlReceive* iReceiveInterface, CAmSocketHandler* iSocketHandler); + ~IAmControlReceiverShadow(); + am_Error_e getRoute(bool onlyfree, am_sourceID_t sourceID, am_sinkID_t sinkID, std::vector& returnList); + am_Error_e connect(am_Handle_s& handle, am_connectionID_t& connectionID, am_ConnectionFormat_e format, am_sourceID_t sourceID, am_sinkID_t sinkID); + am_Error_e disconnect(am_Handle_s& handle, am_connectionID_t connectionID); + am_Error_e crossfade(am_Handle_s& handle, am_HotSink_e hotSource, am_crossfaderID_t crossfaderID, am_RampType_e rampType, am_time_t rampTime); + am_Error_e abortAction(am_Handle_s handle); + am_Error_e setSourceState(am_Handle_s& handle, am_sourceID_t sourceID, am_SourceState_e state); + am_Error_e setSinkVolume(am_Handle_s& handle, am_sinkID_t sinkID, am_volume_t volume, am_RampType_e ramp, am_time_t time); + am_Error_e setSourceVolume(am_Handle_s& handle, am_sourceID_t sourceID, am_volume_t volume, am_RampType_e rampType, am_time_t time); + am_Error_e setSinkSoundProperties(am_Handle_s& handle, am_sinkID_t sinkID, std::vector& soundProperty); + am_Error_e setSinkSoundProperty(am_Handle_s& handle, am_sinkID_t sinkID, am_SoundProperty_s& soundProperty); + am_Error_e setSourceSoundProperties(am_Handle_s& handle, am_sourceID_t sourceID, std::vector& soundProperty); + am_Error_e setSourceSoundProperty(am_Handle_s& handle, am_sourceID_t sourceID, am_SoundProperty_s& soundProperty); + am_Error_e setDomainState(am_domainID_t domainID, am_DomainState_e domainState); + am_Error_e enterDomainDB(am_Domain_s& domainData, am_domainID_t& domainID); + am_Error_e enterMainConnectionDB(am_MainConnection_s& mainConnectionData, am_mainConnectionID_t& connectionID); + am_Error_e enterSinkDB(am_Sink_s& sinkData, am_sinkID_t& sinkID); + am_Error_e enterCrossfaderDB(am_Crossfader_s& crossfaderData, am_crossfaderID_t& crossfaderID); + am_Error_e enterGatewayDB(am_Gateway_s& gatewayData, am_gatewayID_t& gatewayID); + am_Error_e enterSourceDB(am_Source_s& sourceData, am_sourceID_t& sourceID); + am_Error_e enterSinkClassDB(am_SinkClass_s& sinkClass, am_sinkClass_t& sinkClassID); + am_Error_e enterSourceClassDB(am_sourceClass_t& sourceClassID, am_SourceClass_s& sourceClass); + am_Error_e changeSinkClassInfoDB(am_SinkClass_s& sinkClass); + am_Error_e changeSourceClassInfoDB(am_SourceClass_s& sourceClass); + am_Error_e enterSystemPropertiesListDB(std::vector& listSystemProperties); + am_Error_e changeMainConnectionRouteDB(am_mainConnectionID_t mainconnectionID, std::vector& listConnectionID); + am_Error_e changeMainConnectionStateDB(am_mainConnectionID_t mainconnectionID, am_ConnectionState_e connectionState); + am_Error_e changeSinkMainVolumeDB(am_mainVolume_t mainVolume, am_sinkID_t sinkID); + am_Error_e changeSinkAvailabilityDB(am_Availability_s& availability, am_sinkID_t sinkID); + am_Error_e changDomainStateDB(am_DomainState_e domainState, am_domainID_t domainID); + am_Error_e changeSinkMuteStateDB(am_MuteState_e muteState, am_sinkID_t sinkID); + am_Error_e changeMainSinkSoundPropertyDB(am_MainSoundProperty_s& soundProperty, am_sinkID_t sinkID); + am_Error_e changeMainSourceSoundPropertyDB(am_MainSoundProperty_s& soundProperty, am_sourceID_t sourceID); + am_Error_e changeSourceAvailabilityDB(am_Availability_s& availability, am_sourceID_t sourceID); + am_Error_e changeSystemPropertyDB(am_SystemProperty_s& property); + am_Error_e removeMainConnectionDB(am_mainConnectionID_t mainConnectionID); + am_Error_e removeSinkDB(am_sinkID_t sinkID); + am_Error_e removeSourceDB(am_sourceID_t sourceID); + am_Error_e removeGatewayDB(am_gatewayID_t gatewayID); + am_Error_e removeCrossfaderDB(am_crossfaderID_t crossfaderID); + am_Error_e removeDomainDB(am_domainID_t domainID); + am_Error_e removeSinkClassDB(am_sinkClass_t sinkClassID); + am_Error_e removeSourceClassDB(am_sourceClass_t sourceClassID); + am_Error_e getSourceClassInfoDB(am_sourceID_t sourceID, am_SourceClass_s& classInfo); + am_Error_e getSinkClassInfoDB(am_sinkID_t sinkID, am_SinkClass_s& sinkClass); + am_Error_e getSinkInfoDB(am_sinkID_t sinkID, am_Sink_s& sinkData); + am_Error_e getSourceInfoDB(am_sourceID_t sourceID, am_Source_s& sourceData); + am_Error_e getGatewayInfoDB(am_gatewayID_t gatewayID, am_Gateway_s& gatewayData); + am_Error_e getCrossfaderInfoDB(am_crossfaderID_t crossfaderID, am_Crossfader_s& crossfaderData); + am_Error_e getMainConnectionInfoDB(am_mainConnectionID_t mainConnectionID, am_MainConnection_s& mainConnectionData); + am_Error_e getListSinksOfDomain(am_domainID_t domainID, std::vector& listSinkID); + am_Error_e getListSourcesOfDomain(am_domainID_t domainID, std::vector& listSourceID); + am_Error_e getListCrossfadersOfDomain(am_domainID_t domainID, std::vector& listCrossfadersID); + am_Error_e getListGatewaysOfDomain(am_domainID_t domainID, std::vector& listGatewaysID); + am_Error_e getListMainConnections(std::vector& listMainConnections); + am_Error_e getListDomains(std::vector& listDomains); + am_Error_e getListConnections(std::vector& listConnections); + am_Error_e getListSinks(std::vector& listSinks); + am_Error_e getListSources(std::vector& listSources); + am_Error_e getListSourceClasses(std::vector& listSourceClasses); + am_Error_e getListHandles(std::vector& listHandles); + am_Error_e getListCrossfaders(std::vector& listCrossfaders); + am_Error_e getListGateways(std::vector& listGateways); + am_Error_e getListSinkClasses(std::vector& listSinkClasses); + am_Error_e getListSystemProperties(std::vector& listSystemProperties); + void setCommandReady(); + void setCommandRundown(); + void setRoutingReady(); + void setRoutingRundown(); + void confirmControllerReady(); + void confirmControllerRundown(); + am_Error_e getSocketHandler(CAmSocketHandler*& socketHandler); +private: + IAmControlReceive *mpIAmControlReceiver; + CAmSerializer mCAmSerializer; + +}; + +} /* namespace am */ +#endif /* IAMCONTROLRECEIVERSHADOW_H_ */ diff --git a/PluginControlInterface/src/IAmControlReceiverShadow.cpp b/PluginControlInterface/src/IAmControlReceiverShadow.cpp new file mode 100644 index 0000000..e7572ff --- /dev/null +++ b/PluginControlInterface/src/IAmControlReceiverShadow.cpp @@ -0,0 +1,511 @@ +/* + * IAmControlReceiverShadow.cpp + * + * Created on: Mar 2, 2012 + * Author: christian + */ + +#include "IAmControlReceiverShadow.h" +#include "control/IAmControlReceive.h" + +namespace am +{ + +IAmControlReceiverShadow::IAmControlReceiverShadow(IAmControlReceive *iReceiveInterface, CAmSocketHandler *iSocketHandler) : + mpIAmControlReceiver(iReceiveInterface), // + mCAmSerializer(iSocketHandler) +{ +} + +IAmControlReceiverShadow::~IAmControlReceiverShadow() +{ + +} + +am_Error_e IAmControlReceiverShadow::getRoute(bool onlyfree, am_sourceID_t sourceID, am_sinkID_t sinkID, std::vector & returnList) +{ + am_Error_e error; + mCAmSerializer.syncCall &, bool, am_sourceID_t, am_sinkID_t, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getRoute, error, onlyfree, sourceID, sinkID, returnList); + return (error); +} + +am_Error_e IAmControlReceiverShadow::connect(am_Handle_s & handle, am_connectionID_t & connectionID, am_ConnectionFormat_e format, am_sourceID_t sourceID, am_sinkID_t sinkID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::connect, error, handle, connectionID, format, sourceID, sinkID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::disconnect(am_Handle_s & handle, am_connectionID_t connectionID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::disconnect, error, handle, connectionID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::crossfade(am_Handle_s & handle, am_HotSink_e hotSource, am_crossfaderID_t crossfaderID, am_RampType_e rampType, am_time_t rampTime) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::crossfade, error, handle, hotSource, crossfaderID, rampType, rampTime); + return (error); +} + +am_Error_e IAmControlReceiverShadow::abortAction(am_Handle_s handle) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::abortAction, error, handle); + return (error); +} + +am_Error_e IAmControlReceiverShadow::setSourceState(am_Handle_s & handle, am_sourceID_t sourceID, am_SourceState_e state) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::setSourceState, error, handle, sourceID, state); + return (error); + +} + +am_Error_e IAmControlReceiverShadow::setSinkVolume(am_Handle_s & handle, am_sinkID_t sinkID, am_volume_t volume, am_RampType_e ramp, am_time_t time) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::setSinkVolume, error, handle, sinkID, volume, ramp, time); + return (error); +} + +am_Error_e IAmControlReceiverShadow::setSourceVolume(am_Handle_s & handle, am_sourceID_t sourceID, am_volume_t volume, am_RampType_e rampType, am_time_t time) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::setSourceVolume, error, handle, sourceID, volume, rampType, time); + return (error); +} + +am_Error_e IAmControlReceiverShadow::setSinkSoundProperties(am_Handle_s & handle, am_sinkID_t sinkID, std::vector & soundProperty) +{ + am_Error_e error; + mCAmSerializer.syncCall &, am_Handle_s, am_sinkID_t, std::vector >(mpIAmControlReceiver, &IAmControlReceive::setSinkSoundProperties, error, handle, sinkID, soundProperty); + return (error); +} + +am_Error_e IAmControlReceiverShadow::setSinkSoundProperty(am_Handle_s & handle, am_sinkID_t sinkID, am_SoundProperty_s & soundProperty) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::setSinkSoundProperty, error, handle, sinkID, soundProperty); + return (error); +} + +am_Error_e IAmControlReceiverShadow::setSourceSoundProperties(am_Handle_s & handle, am_sourceID_t sourceID, std::vector & soundProperty) +{ + am_Error_e error; + mCAmSerializer.syncCall &, am_Handle_s, am_sourceID_t, std::vector >(mpIAmControlReceiver, &IAmControlReceive::setSourceSoundProperties, error, handle, sourceID, soundProperty); + return (error); +} + +am_Error_e IAmControlReceiverShadow::setSourceSoundProperty(am_Handle_s & handle, am_sourceID_t sourceID, am_SoundProperty_s & soundProperty) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::setSourceSoundProperty, error, handle, sourceID, soundProperty); + return (error); +} + +am_Error_e IAmControlReceiverShadow::setDomainState(am_domainID_t domainID, am_DomainState_e domainState) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::setDomainState, error, domainID, domainState); + return (error); +} + +am_Error_e IAmControlReceiverShadow::enterDomainDB(am_Domain_s & domainData, am_domainID_t & domainID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::enterDomainDB, error, domainData, domainID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::enterMainConnectionDB(am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::enterMainConnectionDB, error, mainConnectionData, connectionID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::enterSinkDB(am_Sink_s & sinkData, am_sinkID_t & sinkID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::enterSinkDB, error, sinkData, sinkID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::enterCrossfaderDB(am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::enterCrossfaderDB, error, crossfaderData, crossfaderID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::enterGatewayDB(am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::enterGatewayDB, error, gatewayData, gatewayID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::enterSourceDB(am_Source_s & sourceData, am_sourceID_t & sourceID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::enterSourceDB, error, sourceData, sourceID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::enterSinkClassDB(am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::enterSinkClassDB, error, sinkClass, sinkClassID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::enterSourceClassDB(am_sourceClass_t & sourceClassID, am_SourceClass_s & sourceClass) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::enterSourceClassDB, error, sourceClassID, sourceClass); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeSinkClassInfoDB(am_SinkClass_s & sinkClass) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changeSinkClassInfoDB, error, sinkClass); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeSourceClassInfoDB(am_SourceClass_s & sourceClass) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changeSourceClassInfoDB, error, sourceClass); + return (error); +} + +am_Error_e IAmControlReceiverShadow::enterSystemPropertiesListDB(std::vector & listSystemProperties) +{ + am_Error_e error; + mCAmSerializer.syncCall &, std::vector >(mpIAmControlReceiver, &IAmControlReceive::enterSystemPropertiesListDB, error, listSystemProperties); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeMainConnectionRouteDB(am_mainConnectionID_t mainconnectionID, std::vector & listConnectionID) +{ + am_Error_e error; + mCAmSerializer.syncCall &, am_mainConnectionID_t, std::vector >(mpIAmControlReceiver, &IAmControlReceive::changeMainConnectionRouteDB, error, mainconnectionID, listConnectionID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeMainConnectionStateDB(am_mainConnectionID_t mainconnectionID, am_ConnectionState_e connectionState) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changeMainConnectionStateDB, error, mainconnectionID, connectionState); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeSinkMainVolumeDB(am_mainVolume_t mainVolume, am_sinkID_t sinkID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changeSinkMainVolumeDB, error, mainVolume, sinkID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListMainConnections(std::vector & listMainConnections) +{ + am_Error_e error; + mCAmSerializer.syncCall &, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListMainConnections, error, listMainConnections); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListDomains(std::vector & listDomains) +{ + am_Error_e error; + mCAmSerializer.syncCall &, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListDomains, error, listDomains); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListConnections(std::vector & listConnections) +{ + am_Error_e error; + mCAmSerializer.syncCall&, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListConnections, error, listConnections); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListSinks(std::vector & listSinks) +{ + am_Error_e error; + mCAmSerializer.syncCall &, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListSinks, error, listSinks); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListSources(std::vector & listSources) +{ + am_Error_e error; + mCAmSerializer.syncCall &, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListSources, error, listSources); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListSourceClasses(std::vector & listSourceClasses) +{ + am_Error_e error; + mCAmSerializer.syncCall &, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListSourceClasses, error, listSourceClasses); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListHandles(std::vector & listHandles) +{ + am_Error_e error; + mCAmSerializer.syncCall &, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListHandles, error, listHandles); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListCrossfaders(std::vector & listCrossfaders) +{ + am_Error_e error; + mCAmSerializer.syncCall &, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListCrossfaders, error, listCrossfaders); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListGateways(std::vector & listGateways) +{ + am_Error_e error; + mCAmSerializer.syncCall&, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListGateways, error, listGateways); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListSinkClasses(std::vector & listSinkClasses) +{ + am_Error_e error; + mCAmSerializer.syncCall &, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListSinkClasses, error, listSinkClasses); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListSystemProperties(std::vector & listSystemProperties) +{ + am_Error_e error; + mCAmSerializer.syncCall &, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListSystemProperties, error, listSystemProperties); + return (error); +} + +void IAmControlReceiverShadow::setCommandReady() +{ + mCAmSerializer.asyncCall(mpIAmControlReceiver, &IAmControlReceive::setCommandReady); +} + +void IAmControlReceiverShadow::setCommandRundown() +{ + mCAmSerializer.asyncCall(mpIAmControlReceiver, &IAmControlReceive::setCommandRundown); +} + +void IAmControlReceiverShadow::setRoutingReady() +{ + mCAmSerializer.asyncCall(mpIAmControlReceiver, &IAmControlReceive::setRoutingReady); +} + +void IAmControlReceiverShadow::setRoutingRundown() +{ + mCAmSerializer.asyncCall(mpIAmControlReceiver, &IAmControlReceive::setRoutingRundown); +} + +void IAmControlReceiverShadow::confirmControllerReady() +{ + mCAmSerializer.asyncCall(mpIAmControlReceiver, &IAmControlReceive::confirmControllerReady); +} + +void IAmControlReceiverShadow::confirmControllerRundown() +{ + mCAmSerializer.asyncCall(mpIAmControlReceiver, &IAmControlReceive::confirmControllerRundown); +} + +am_Error_e IAmControlReceiverShadow::getSocketHandler(CAmSocketHandler *& socketHandler) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::getSocketHandler, error, socketHandler); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeSinkAvailabilityDB(am_Availability_s& availability, am_sinkID_t sinkID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changeSinkAvailabilityDB, error, availability, sinkID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changDomainStateDB(am_DomainState_e domainState, am_domainID_t domainID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changDomainStateDB, error, domainState, domainID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeSinkMuteStateDB(am_MuteState_e muteState, am_sinkID_t sinkID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changeSinkMuteStateDB, error, muteState, sinkID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeMainSinkSoundPropertyDB(am_MainSoundProperty_s& soundProperty, am_sinkID_t sinkID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changeMainSinkSoundPropertyDB, error, soundProperty, sinkID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeMainSourceSoundPropertyDB(am_MainSoundProperty_s& soundProperty, am_sourceID_t sourceID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changeMainSourceSoundPropertyDB, error, soundProperty, sourceID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeSourceAvailabilityDB(am_Availability_s& availability, am_sourceID_t sourceID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changeSourceAvailabilityDB, error, availability, sourceID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::changeSystemPropertyDB(am_SystemProperty_s& property) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::changeSystemPropertyDB, error, property); + return (error); +} + +am_Error_e IAmControlReceiverShadow::removeMainConnectionDB(am_mainConnectionID_t mainConnectionID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::removeMainConnectionDB, error, mainConnectionID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::removeSinkDB(am_sinkID_t sinkID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::removeSinkDB, error, sinkID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::removeSourceDB(am_sourceID_t sourceID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::removeSourceDB, error, sourceID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::removeGatewayDB(am_gatewayID_t gatewayID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::removeGatewayDB, error, gatewayID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::removeCrossfaderDB(am_crossfaderID_t crossfaderID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::removeCrossfaderDB, error, crossfaderID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::removeDomainDB(am_domainID_t domainID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::removeDomainDB, error, domainID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::removeSinkClassDB(am_sinkClass_t sinkClassID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::removeSinkClassDB, error, sinkClassID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::removeSourceClassDB(am_sourceClass_t sourceClassID) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::removeSourceClassDB, error, sourceClassID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getSourceClassInfoDB(am_sourceID_t sourceID, am_SourceClass_s& classInfo) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::getSourceClassInfoDB, error, sourceID, classInfo); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getSinkClassInfoDB(am_sinkID_t sinkID, am_SinkClass_s& sinkClass) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::getSinkClassInfoDB, error, sinkID, sinkClass); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getSinkInfoDB(am_sinkID_t sinkID, am_Sink_s& sinkData) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::getSinkInfoDB, error, sinkID, sinkData); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getSourceInfoDB(am_sourceID_t sourceID, am_Source_s& sourceData) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::getSourceInfoDB, error, sourceID, sourceData); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getGatewayInfoDB(am_gatewayID_t gatewayID, am_Gateway_s& gatewayData) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::getGatewayInfoDB, error, gatewayID, gatewayData); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getCrossfaderInfoDB(am_crossfaderID_t crossfaderID, am_Crossfader_s& crossfaderData) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::getCrossfaderInfoDB, error, crossfaderID, crossfaderData); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getMainConnectionInfoDB(am_mainConnectionID_t mainConnectionID, am_MainConnection_s& mainConnectionData) +{ + am_Error_e error; + mCAmSerializer.syncCall(mpIAmControlReceiver, &IAmControlReceive::getMainConnectionInfoDB, error, mainConnectionID, mainConnectionData); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListSinksOfDomain(am_domainID_t domainID, std::vector& listSinkID) +{ + am_Error_e error; + mCAmSerializer.syncCall&, am_domainID_t, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListSinksOfDomain, error, domainID, listSinkID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListSourcesOfDomain(am_domainID_t domainID, std::vector& listSourceID) +{ + am_Error_e error; + mCAmSerializer.syncCall&, am_domainID_t, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListSourcesOfDomain, error, domainID, listSourceID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListCrossfadersOfDomain(am_domainID_t domainID, std::vector& listCrossfadersID) +{ + am_Error_e error; + mCAmSerializer.syncCall&, am_domainID_t, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListCrossfadersOfDomain, error, domainID, listCrossfadersID); + return (error); +} + +am_Error_e IAmControlReceiverShadow::getListGatewaysOfDomain(am_domainID_t domainID, std::vector& listGatewaysID) +{ + am_Error_e error; + mCAmSerializer.syncCall&, am_domainID_t, std::vector >(mpIAmControlReceiver, &IAmControlReceive::getListGatewaysOfDomain, error, domainID, listGatewaysID); + return (error); +} + +} /* namespace am */ 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