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 +++++ .../include/IAmRoutingReceiverShadow.h | 2 - .../src/IAmRoutingReceiverShadow.cpp | 1 + .../test/CAmRoutingReceiverAsync.cpp | 1 + .../test/CAmRoutingReceiverAsync.h | 1 - PluginRoutingInterfaceAsync/test/CMakeLists.txt | 2 - include/shared/CAmSerializer.h | 671 ++++++++++++++------- 13 files changed, 1459 insertions(+), 210 deletions(-) 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 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 diff --git a/PluginRoutingInterfaceAsync/include/IAmRoutingReceiverShadow.h b/PluginRoutingInterfaceAsync/include/IAmRoutingReceiverShadow.h index af4685c..cfce5a1 100644 --- a/PluginRoutingInterfaceAsync/include/IAmRoutingReceiverShadow.h +++ b/PluginRoutingInterfaceAsync/include/IAmRoutingReceiverShadow.h @@ -26,8 +26,6 @@ #define ROUTINGRECEIVERASYNCSHADOW_H_ #include "routing/IAmRoutingReceive.h" -#include -#include #include "shared/CAmSerializer.h" #include "shared/CAmSocketHandler.h" diff --git a/PluginRoutingInterfaceAsync/src/IAmRoutingReceiverShadow.cpp b/PluginRoutingInterfaceAsync/src/IAmRoutingReceiverShadow.cpp index b8733db..c894954 100644 --- a/PluginRoutingInterfaceAsync/src/IAmRoutingReceiverShadow.cpp +++ b/PluginRoutingInterfaceAsync/src/IAmRoutingReceiverShadow.cpp @@ -33,6 +33,7 @@ #include #include #include "shared/CAmDltWrapper.h" +#include "shared/CAmSerializer.h" using namespace am; diff --git a/PluginRoutingInterfaceAsync/test/CAmRoutingReceiverAsync.cpp b/PluginRoutingInterfaceAsync/test/CAmRoutingReceiverAsync.cpp index 2d3cbca..1c2c7a9 100644 --- a/PluginRoutingInterfaceAsync/test/CAmRoutingReceiverAsync.cpp +++ b/PluginRoutingInterfaceAsync/test/CAmRoutingReceiverAsync.cpp @@ -28,6 +28,7 @@ #include "TAmPluginTemplate.h" #include "MockIAmRoutingReceive.h" #include "shared/CAmDltWrapper.h" +#include "routing/IAmRoutingSend.h" using namespace am; using namespace testing; diff --git a/PluginRoutingInterfaceAsync/test/CAmRoutingReceiverAsync.h b/PluginRoutingInterfaceAsync/test/CAmRoutingReceiverAsync.h index ec33c9f..e8aab64 100644 --- a/PluginRoutingInterfaceAsync/test/CAmRoutingReceiverAsync.h +++ b/PluginRoutingInterfaceAsync/test/CAmRoutingReceiverAsync.h @@ -31,7 +31,6 @@ #include "MockIAmRoutingReceive.h" #include "shared/CAmSocketHandler.h" #include "shared/CAmSerializer.h" -#include "../../AudioManagerDaemon/include/CAmRoutingSender.h" #define UNIT_TEST 1 diff --git a/PluginRoutingInterfaceAsync/test/CMakeLists.txt b/PluginRoutingInterfaceAsync/test/CMakeLists.txt index 59c50dc..cf537bd 100644 --- a/PluginRoutingInterfaceAsync/test/CMakeLists.txt +++ b/PluginRoutingInterfaceAsync/test/CMakeLists.txt @@ -25,8 +25,6 @@ cmake_minimum_required(VERSION 2.6) PROJECT(AmRoutingReceiverAsync) -set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -DUNIT_TEST=1 -DDLT_CONTEXT=AudioManager") - set(EXECUTABLE_OUTPUT_PATH ${TEST_EXECUTABLE_OUTPUT_PATH}) FIND_PACKAGE(GTest REQUIRED) diff --git a/include/shared/CAmSerializer.h b/include/shared/CAmSerializer.h index a27edaf..3cb8f5a 100644 --- a/include/shared/CAmSerializer.h +++ b/include/shared/CAmSerializer.h @@ -47,7 +47,8 @@ private: class CAmDelegate { public: - virtual ~CAmDelegate(){}; + virtual ~CAmDelegate() + {}; virtual bool call(int* pipe)=0; }; @@ -64,13 +65,14 @@ private: void (TClass::*mFunction)(); public: - CAmNoArgDelegate(TClass* instance, void(TClass::*function)()) : + CAmNoArgDelegate(TClass* instance, void (TClass::*function)()) : mInstance(instance), // - mFunction(function){}; + mFunction(function) + {}; bool call(int* pipe) { - (void)pipe; + (void) pipe; (*mInstance.*mFunction)(); return true; }; @@ -87,14 +89,15 @@ private: Targ mArgument; public: - CAmOneArgDelegate(TClass* instance, void(TClass::*function)(Targ), Targ argument) : + CAmOneArgDelegate(TClass* instance, void (TClass::*function)(Targ), Targ argument) : mInstance(instance), // mFunction(function), // - mArgument(argument) { }; + mArgument(argument) + {}; bool call(int* pipe) { - (void)pipe; + (void) pipe; (*mInstance.*mFunction)(mArgument); return true; }; @@ -107,21 +110,22 @@ private: { private: TClass* mInstance; - void (TClass::*mFunction)(Targ argument,Targ1 argument1); + void (TClass::*mFunction)(Targ argument, Targ1 argument1); Targ mArgument; Targ1 mArgument1; public: - CAmTwoArgDelegate(TClass* instance, void(TClass::*function)(Targ argument,Targ1 argument1), Targ argument, Targ1 argument1) : + CAmTwoArgDelegate(TClass* instance, void (TClass::*function)(Targ argument, Targ1 argument1), Targ argument, Targ1 argument1) : mInstance(instance), // mFunction(function), // mArgument(argument), // - mArgument1(argument1){}; + mArgument1(argument1) + {}; bool call(int* pipe) { - (void)pipe; - (*mInstance.*mFunction)(mArgument,mArgument1); + (void) pipe; + (*mInstance.*mFunction)(mArgument, mArgument1); return true; }; }; @@ -133,25 +137,29 @@ private: { private: TClass* mInstance; - void (TClass::*mFunction)(Targ argument,Targ1 argument1,Targ2 argument2); + void (TClass::*mFunction)(Targ argument, Targ1 argument1, Targ2 argument2); Targ mArgument; Targ1 mArgument1; Targ2 mArgument2; public: - CAmThreeArgDelegate(TClass* instance, void(TClass::*function)(Targ argument,Targ1 argument1,Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2) : + CAmThreeArgDelegate(TClass* instance, void (TClass::*function)(Targ argument, Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2) : mInstance(instance), // mFunction(function), // mArgument(argument), // mArgument1(argument1), // - mArgument2(argument2){}; + mArgument2(argument2) + { + } + ; bool call(int* pipe) { - (void)pipe; - (*mInstance.*mFunction)(mArgument,mArgument1,mArgument2); + (void) pipe; + (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2); return true; - }; + } + ; }; /** @@ -168,20 +176,24 @@ private: Targ3 mArgument3; public: - CAmFourArgDelegate(TClass* instance, void(TClass::*function)(Targ argument,Targ1 argument1,Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3) : + CAmFourArgDelegate(TClass* instance, void (TClass::*function)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3) : mInstance(instance), // mFunction(function), // mArgument(argument), // mArgument1(argument1), // mArgument2(argument2), // - mArgument3(argument3){}; + mArgument3(argument3) + { + } + ; bool call(int* pipe) { - (void)pipe; - (*mInstance.*mFunction)(mArgument,mArgument1,mArgument2,mArgument3); + (void) pipe; + (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2, mArgument3); return true; - }; + } + ; }; /** @@ -190,61 +202,103 @@ private: template class CAmSyncNoArgDelegate: public CAmDelegate { private: - TClass* mInstance; - TretVal (TClass::*mFunction)(); - TretVal mRetval; + TClass* mInstance; + TretVal (TClass::*mFunction)(); + TretVal mRetval; public: - friend class CAmSerializer; - CAmSyncNoArgDelegate(TClass* instance, TretVal(TClass::*function)()) : - mInstance(instance), // - mFunction(function), // - mRetval(){}; - - bool call(int* pipe) - { - mRetval = (*mInstance.*mFunction)(); - write(pipe[1], this, sizeof(this)); - return false; - }; - - TretVal returnResults() - { - return mRetval; - } + friend class CAmSerializer; + CAmSyncNoArgDelegate(TClass* instance, TretVal (TClass::*function)()) : + mInstance(instance), // + mFunction(function), // + mRetval() + { + } + ; + + bool call(int* pipe) + { + mRetval = (*mInstance.*mFunction)(); + write(pipe[1], this, sizeof(this)); + return false; + } + ; + + TretVal returnResults() + { + return mRetval; + } }; /** * template for synchronous calls with one argument */ - template class CAmSyncOneArgDelegate: public CAmDelegate + template class CAmSyncOneArgDelegate: public CAmDelegate + { + private: + TClass* mInstance; + TretVal (TClass::*mFunction)(TargCall argument); + Targ mArgument; + TretVal mRetval; + + public: + friend class CAmSerializer; + CAmSyncOneArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCall argument), Targ argument) : + mInstance(instance), // + mFunction(function), // + mArgument(argument), // + mRetval() + { + } + ; + + bool call(int* pipe) + { + mRetval = (*mInstance.*mFunction)(mArgument); + write(pipe[1], this, sizeof(this)); + return false; + } + ; + + TretVal returnResults(Targ& argument) + { + argument = mArgument; + return mRetval; + } + }; + + template class CAmSyncOneArgConstDelegate: public CAmDelegate { private: - TClass* mInstance; - TretVal (TClass::*mFunction)(Targ argument); - Targ mArgument; - TretVal mRetval; + TClass* mInstance; + TretVal (TClass::*mFunction)(TargCall argument) const; + Targ mArgument; + TretVal mRetval; public: - friend class CAmSerializer; - CAmSyncOneArgDelegate(TClass* instance, TretVal(TClass::*function)(Targ argument), Targ argument) : - mInstance(instance), // - mFunction(function), // - mArgument(argument), // - mRetval(){}; - - bool call(int* pipe) - { - mRetval = (*mInstance.*mFunction)(mArgument); - write(pipe[1], this, sizeof(this)); - return false; - }; - - TretVal returnResults(Targ& argument) - { - argument=mArgument; - return mRetval; - } + friend class CAmSerializer; + CAmSyncOneArgConstDelegate(TClass* instance, TretVal (TClass::*function)(TargCall argument) const, Targ argument) : + mInstance(instance), // + mFunction(function), // + mArgument(argument), // + mRetval() + { + } + ; + + bool call(int* pipe) + { + mRetval = (*mInstance.*mFunction)(mArgument); + write(pipe[1], this, sizeof(this)); + return false; + } + ; + + TretVal returnResults(Targ& argument) + { + argument = mArgument; + return mRetval; + } }; /** @@ -253,112 +307,253 @@ private: template class CAmSyncTwoArgDelegate: public CAmDelegate { private: - TClass* mInstance; - TretVal (TClass::*mFunction)(TargCall,TargCall1); - Targ mArgument; - Targ1 mArgument1; - TretVal mRetval; + TClass* mInstance; + TretVal (TClass::*mFunction)(TargCall, TargCall1); + Targ mArgument; + Targ1 mArgument1; + TretVal mRetval; public: - friend class CAmSerializer; - CAmSyncTwoArgDelegate(TClass* instance, TretVal(TClass::*function)(TargCall, TargCall1), Targ& argument, Targ1& argument1) : - mInstance(instance), // - mFunction(function), // - mArgument(argument), // - mArgument1(argument1), // - mRetval(){}; - - bool call(int* pipe) - { - mRetval = (*mInstance.*mFunction)(mArgument, mArgument1); - write(pipe[1], this, sizeof(this)); - return false; - }; - - TretVal returnResults(Targ& argument, Targ1& argument1) - { - argument=mArgument; - argument1=mArgument1; - return mRetval; - } + friend class CAmSerializer; + CAmSyncTwoArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCall, TargCall1), Targ& argument, Targ1& argument1) : + mInstance(instance), // + mFunction(function), // + mArgument(argument), // + mArgument1(argument1), // + mRetval() + { + } + ; + + bool call(int* pipe) + { + mRetval = (*mInstance.*mFunction)(mArgument, mArgument1); + write(pipe[1], this, sizeof(this)); + return false; + } + ; + + TretVal returnResults(Targ& argument, Targ1& argument1) + { + argument = mArgument; + argument1 = mArgument1; + return mRetval; + } + }; + + template class CAmSyncTwoArgConstDelegate: public CAmDelegate + { + private: + TClass* mInstance; + TretVal (TClass::*mFunction)(TargCall, TargCall1) const; + Targ mArgument; + Targ1 mArgument1; + TretVal mRetval; + + public: + friend class CAmSerializer; + CAmSyncTwoArgConstDelegate(TClass* instance, TretVal (TClass::*function)(TargCall, TargCall1) const, Targ& argument, Targ1& argument1) : + mInstance(instance), // + mFunction(function), // + mArgument(argument), // + mArgument1(argument1), // + mRetval() + { + } + ; + + bool call(int* pipe) + { + mRetval = (*mInstance.*mFunction)(mArgument, mArgument1); + write(pipe[1], this, sizeof(this)); + return false; + } + ; + + TretVal returnResults(Targ& argument, Targ1& argument1) + { + argument = mArgument; + argument1 = mArgument1; + return mRetval; + } }; /** * template for synchronous calls with three arguments */ - template class CAmSyncThreeArgDelegate: public CAmDelegate + template class CAmSyncThreeArgDelegate: public CAmDelegate { private: - TClass* mInstance; - TretVal (TClass::*mFunction)(Targ argument, Targ1 argument1, Targ2 argument2); - Targ mArgument; - Targ1 mArgument1; - Targ2 mArgument2; - TretVal mRetval; + TClass* mInstance; + TretVal (TClass::*mFunction)(TargCall argument, TargCall1 argument1, TargCall2 argument2); + Targ mArgument; + Targ1 mArgument1; + Targ2 mArgument2; + TretVal mRetval; public: - CAmSyncThreeArgDelegate(TClass* instance, TretVal(TClass::*function)(Targ argument, Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1,Targ2 argument2) : - mInstance(instance), // - mFunction(function), // - mArgument(argument), // - mArgument1(argument1), // - mArgument2(argument2), // - mRetval(){}; - - bool call(int* pipe) - { - mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2); - write(pipe[1], this, sizeof(this)); - return false; - }; - - TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2) - { - argument=mArgument; - argument1=mArgument1; - argument2=mArgument2; - return mRetval; - } + CAmSyncThreeArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCall argument, TargCall1 argument1, TargCall2 argument2), Targ argument, Targ1 argument1, Targ2 argument2) : + mInstance(instance), // + mFunction(function), // + mArgument(argument), // + mArgument1(argument1), // + mArgument2(argument2), // + mRetval() + { + } + ; + + bool call(int* pipe) + { + mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2); + write(pipe[1], this, sizeof(this)); + return false; + } + ; + + TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2) + { + argument = mArgument; + argument1 = mArgument1; + argument2 = mArgument2; + return mRetval; + } }; /** * template for synchronous calls with four arguments */ - template class CAmSyncFourArgDelegate: public CAmDelegate + template class CAmSyncFourArgDelegate: public CAmDelegate + { + private: + TClass* mInstance; + TretVal (TClass::*mFunction)(TargCAll argument, TargCall1 argument1, TargCall2 argument2, TargCall3 argument3); + Targ mArgument; + Targ1 mArgument1; + Targ2 mArgument2; + Targ3 mArgument3; + TretVal mRetval; + public: + CAmSyncFourArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCAll argument, TargCall1 argument1, TargCall2 argument2, TargCall3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3) : + mInstance(instance), // + mFunction(function), // + mArgument(argument), // + mArgument1(argument1), // + mArgument2(argument2), // + mArgument3(argument3), // + mRetval() + { + } + ; + + bool call(int* pipe) + { + mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2, mArgument3); + write(pipe[1], this, sizeof(this)); + return false; + } + ; + + TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3) + { + argument = mArgument; + argument1 = mArgument1; + argument2 = mArgument2; + argument3 = mArgument3; + return mRetval; + } + }; + + template class CAmSyncFiveArgDelegate: public CAmDelegate { private: - TClass* mInstance; - TretVal (TClass::*mFunction)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3); - Targ mArgument; - Targ1 mArgument1; - Targ2 mArgument2; - Targ3 mArgument3; - TretVal mRetval; - - CAmSyncFourArgDelegate(TClass* instance, TretVal(TClass::*function)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3) : - mInstance(instance), // - mFunction(function), // - mArgument(argument), // - mArgument1(argument1), // - mArgument2(argument2), // - mArgument3(argument3), // - mRetval(){}; - - bool call(int* pipe) - { - mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2, mArgument3); - write(pipe[1], this, sizeof(this)); - return false; - }; - - TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3) - { - argument=mArgument; - argument1=mArgument1; - argument2=mArgument2; - argument3=mArgument3; - return mRetval; - } + TClass* mInstance; + TretVal (TClass::*mFunction)(TargCAll argument, TargCall1 argument1, TargCall2 argument2, TargCall3 argument3, TargCall4); + Targ mArgument; + Targ1 mArgument1; + Targ2 mArgument2; + Targ3 mArgument3; + Targ4 mArgument4; + TretVal mRetval; + public: + + CAmSyncFiveArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCAll argument, TargCall1 argument1, TargCall2 argument2, TargCall3 argument3, TargCall4 argument4), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3, Targ4 argument4) : + mInstance(instance), // + mFunction(function), // + mArgument(argument), // + mArgument1(argument1), // + mArgument2(argument2), // + mArgument3(argument3), // + mArgument4(argument4), // + mRetval() + { + } + ; + + bool call(int* pipe) + { + mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2, mArgument3, mArgument4); + write(pipe[1], this, sizeof(this)); + return false; + } + ; + + TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3, Targ4& argument4) + { + argument = mArgument; + argument1 = mArgument1; + argument2 = mArgument2; + argument3 = mArgument3; + argument4 = mArgument4; + return mRetval; + } + }; + + template class CAmSyncSixArgDelegate: public CAmDelegate + { + private: + TClass* mInstance; + TretVal (TClass::*mFunction)(TargCAll argument, TargCall1 argument1, TargCall2 argument2, TargCall3 argument3, TargCall4, TargCall5); + Targ mArgument; + Targ1 mArgument1; + Targ2 mArgument2; + Targ3 mArgument3; + Targ4 mArgument4; + Targ5 mArgument5; + TretVal mRetval; + + CAmSyncSixArgDelegate(TClass* instance, TretVal (TClass::*function)(TargCAll, TargCall1, TargCall2, TargCall3, TargCall4, TargCall5), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3, Targ4 argument4, Targ5 argument5) : + mInstance(instance), // + mFunction(function), // + mArgument(argument), // + mArgument1(argument1), // + mArgument2(argument2), // + mArgument3(argument3), // + mArgument4(argument4), // + mArgument5(argument5), // + mRetval() + { + } + ; + + bool call(int* pipe) + { + mRetval = (*mInstance.*mFunction)(mArgument, mArgument1, mArgument2, mArgument3, mArgument4, mArgument5); + write(pipe[1], this, sizeof(this)); + return false; + } + ; + + TretVal returnResults(Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3, Targ4& argument4, Targ5& argument5) + { + argument = mArgument; + argument1 = mArgument1; + argument2 = mArgument2; + argument3 = mArgument3; + argument4 = mArgument4; + argument5 = mArgument5; + return mRetval; + } }; /** @@ -395,7 +590,7 @@ public: * @endcode */ template - void asyncCall(TClass* instance, void(TClass::*function)()) + void asyncCall(TClass* instance, void (TClass::*function)()) { CAmDelegagePtr p(new CAmNoArgDelegate(instance, function)); send(p); @@ -418,7 +613,7 @@ public: * @endcode */ template - void asyncCall(TClass1* instance, void(TClass1::*function)(Targ), Targ argument) + void asyncCall(TClass1* instance, void (TClass1::*function)(Targ), Targ argument) { CAmDelegagePtr p(new CAmOneArgDelegate(instance, function, argument)); send(p); @@ -432,9 +627,9 @@ public: * @param argument1 */ template - void asyncCall(TClass1* instance, void(TClass1::*function)(Targ argument,Targ1 argument1), Targ argument, Targ1 argument1) + void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1), Targ argument, Targ1 argument1) { - CAmDelegagePtr p(new CAmTwoArgDelegate(instance, function, argument,argument1)); + CAmDelegagePtr p(new CAmTwoArgDelegate(instance, function, argument, argument1)); send(p); } @@ -444,26 +639,26 @@ public: * @param function * @param argument * @param argument1 template - void syncCall(TClass1* instance, TretVal(TClass1::*function)(Targ,Targ1), TretVal& retVal, Targ& argument, Targ1& argument1) - { - CAmSyncTwoArgDelegate* p(new CAmSyncTwoArgDelegate(instance, function, argument, argument1)); - send(static_cast(p)); - int numReads; - CAmDelegagePtr ptr; - if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1) - { - logError("CAmSerializer::receiverCallback could not read pipe!"); - throw std::runtime_error("CAmSerializer Could not read pipe!"); - } - //working with friend class here is not the finest of all programming stiles but it works... - retVal=p->returnResults(argument,argument1); - } + void syncCall(TClass1* instance, TretVal(TClass1::*function)(Targ,Targ1), TretVal& retVal, Targ& argument, Targ1& argument1) + { + CAmSyncTwoArgDelegate* p(new CAmSyncTwoArgDelegate(instance, function, argument, argument1)); + send(static_cast(p)); + int numReads; + CAmDelegagePtr ptr; + if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1) + { + logError("CAmSerializer::receiverCallback could not read pipe!"); + throw std::runtime_error("CAmSerializer Could not read pipe!"); + } + //working with friend class here is not the finest of all programming stiles but it works... + retVal=p->returnResults(argument,argument1); + } * @param argument2 */ template - void asyncCall(TClass1* instance, void(TClass1::*function)(Targ argument,Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2) + void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1, Targ2 argument2), Targ argument, Targ1 argument1, Targ2 argument2) { - CAmDelegagePtr p(new CAmThreeArgDelegate(instance, function, argument,argument1, argument2)); + CAmDelegagePtr p(new CAmThreeArgDelegate(instance, function, argument, argument1, argument2)); send(p); } @@ -477,9 +672,9 @@ public: * @param argument3 */ template - void asyncCall(TClass1* instance, void(TClass1::*function)(Targ argument,Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3) + void asyncCall(TClass1* instance, void (TClass1::*function)(Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3), Targ argument, Targ1 argument1, Targ2 argument2, Targ3 argument3) { - CAmDelegagePtr p(new CAmFourArgDelegate(instance, function, argument,argument1, argument2, argument3)); + CAmDelegagePtr p(new CAmFourArgDelegate(instance, function, argument, argument1, argument2, argument3)); send(p); } @@ -503,19 +698,19 @@ public: * */ template - void syncCall(TClass1* instance, TretVal(TClass1::*function)(), TretVal& retVal) + void syncCall(TClass1* instance, TretVal (TClass1::*function)(), TretVal& retVal) { CAmSyncNoArgDelegate* p(new CAmSyncNoArgDelegate(instance, function)); send(static_cast(p)); int numReads; CAmDelegagePtr ptr; - if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1) + if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1) { logError("CAmSerializer::receiverCallback could not read pipe!"); throw std::runtime_error("CAmSerializer Could not read pipe!"); } //working with friend class here is not the finest of all programming stiles but it works... - retVal=p->returnResults(); + retVal = p->returnResults(); delete p; } @@ -538,20 +733,37 @@ public: * @endcode * All arguments given to synchronous functions must be non-const since the results of the operations will be written back to the arguments. */ - template - void syncCall(TClass1* instance, TretVal(TClass1::*function)(Targ), TretVal& retVal,Targ& argument) + template + void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall), TretVal& retVal, Targ& argument) { - CAmSyncOneArgDelegate* p(new CAmSyncOneArgDelegate(instance, function, argument)); + CAmSyncOneArgDelegate* p(new CAmSyncOneArgDelegate(instance, function, argument)); send(static_cast(p)); int numReads; CAmDelegagePtr ptr; - if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1) + if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1) { logError("CAmSerializer::receiverCallback could not read pipe!"); throw std::runtime_error("CAmSerializer Could not read pipe!"); } //working with friend class here is not the finest of all programming stiles but it works... - retVal=p->returnResults(argument); + retVal = p->returnResults(argument); + delete p; + } + + template + void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall) const, TretVal& retVal, Targ& argument) + { + CAmSyncOneArgConstDelegate* p(new CAmSyncOneArgConstDelegate(instance, function, argument)); + send(static_cast(p)); + int numReads; + CAmDelegagePtr ptr; + if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1) + { + logError("CAmSerializer::receiverCallback could not read pipe!"); + throw std::runtime_error("CAmSerializer Could not read pipe!"); + } + //working with friend class here is not the finest of all programming stiles but it works... + retVal = p->returnResults(argument); delete p; } @@ -563,19 +775,35 @@ public: * @param argument * @param argument1 */ - template - void syncCall(TClass1* instance, TretVal(TClass1::*function)(TargCall,Targ1Call), TretVal& retVal, Targ& argument, Targ1& argument1) + template + void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, Targ1Call), TretVal& retVal, Targ& argument, Targ1& argument1) { - CAmSyncTwoArgDelegate* p(new CAmSyncTwoArgDelegate(instance, function, argument, argument1)); + CAmSyncTwoArgDelegate* p(new CAmSyncTwoArgDelegate(instance, function, argument, argument1)); send(dynamic_cast(p)); CAmDelegagePtr ptr; - if (read(mReturnPipe[0],&ptr, sizeof(ptr)) == -1) + if (read(mReturnPipe[0], &ptr, sizeof(ptr)) == -1) { logError("CAmSerializer::receiverCallback could not read pipe!"); throw std::runtime_error("CAmSerializer Could not read pipe!"); } - retVal=p->returnResults(argument,argument1); + retVal = p->returnResults(argument, argument1); + delete p; + } + + template + void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, Targ1Call) const, TretVal& retVal, Targ& argument, Targ1& argument1) + { + CAmSyncTwoArgConstDelegate* p(new CAmSyncTwoArgConstDelegate(instance, function, argument, argument1)); + send(dynamic_cast(p)); + + CAmDelegagePtr ptr; + if (read(mReturnPipe[0], &ptr, sizeof(ptr)) == -1) + { + logError("CAmSerializer::receiverCallback could not read pipe!"); + throw std::runtime_error("CAmSerializer Could not read pipe!"); + } + retVal = p->returnResults(argument, argument1); delete p; } @@ -588,20 +816,20 @@ public: * @param argument1 * @param argument2 */ - template - void syncCall(TClass1* instance, TretVal(TClass1::*function)(Targ,Targ1,Targ2), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2) + template + void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2) { - CAmSyncThreeArgDelegate* p(new CAmSyncThreeArgDelegate(instance, function, argument, argument1, argument2)); + CAmSyncThreeArgDelegate* p(new CAmSyncThreeArgDelegate(instance, function, argument, argument1, argument2)); send(static_cast(p)); int numReads; CAmDelegagePtr ptr; - if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1) + if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1) { logError("CAmSerializer::receiverCallback could not read pipe!"); throw std::runtime_error("CAmSerializer Could not read pipe!"); } //working with friend class here is not the finest of all programming stiles but it works... - retVal=p->returnResults(argument, argument1, argument2); + retVal = p->returnResults(argument, argument1, argument2); delete p; } @@ -615,23 +843,56 @@ public: * @param argument2 * @param argument3 */ - template - void syncCall(TClass1* instance, TretVal(TClass1::*function)(Targ,Targ1,Targ2,Targ3), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3) + template + void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3) + { + CAmSyncFourArgDelegate* p(new CAmSyncFourArgDelegate(instance, function, argument, argument1, argument2, argument3)); + send(static_cast(p)); + int numReads; + CAmDelegagePtr ptr; + if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1) + { + logError("CAmSerializer::receiverCallback could not read pipe!"); + throw std::runtime_error("CAmSerializer Could not read pipe!"); + } + //working with friend class here is not the finest of all programming stiles but it works... + retVal = p->returnResults(argument, argument1, argument2, argument3); + delete p; + } + + template + void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3, TargCall4), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3, Targ4& argument4) { - CAmSyncFourArgDelegate* p(new CAmSyncFourArgDelegate(instance, function, argument, argument1, argument2, argument3)); + CAmSyncFiveArgDelegate* p(new CAmSyncFiveArgDelegate(instance, function, argument, argument1, argument2, argument3, argument4)); send(static_cast(p)); int numReads; CAmDelegagePtr ptr; - if ((numReads=read(mReturnPipe[0],&ptr, sizeof(ptr))) == -1) + if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1) { logError("CAmSerializer::receiverCallback could not read pipe!"); throw std::runtime_error("CAmSerializer Could not read pipe!"); } //working with friend class here is not the finest of all programming stiles but it works... - retVal=p->returnResults(argument, argument1, argument2, argument3); + retVal = p->returnResults(argument, argument1, argument2, argument3, argument4); delete p; } + template + void syncCall(TClass1* instance, TretVal (TClass1::*function)(TargCall, TargCall1, TargCall2, TargCall3, TargCall4, TargCall5), TretVal& retVal, Targ& argument, Targ1& argument1, Targ2& argument2, Targ3& argument3, Targ4& argument4, Targ5& argument5) + { + CAmSyncSixArgDelegate* p(new CAmSyncSixArgDelegate(instance, function, argument, argument1, argument2, argument3, argument4, argument5)); + send(static_cast(p)); + int numReads; + CAmDelegagePtr ptr; + if ((numReads = read(mReturnPipe[0], &ptr, sizeof(ptr))) == -1) + { + logError("CAmSerializer::receiverCallback could not read pipe!"); + throw std::runtime_error("CAmSerializer Could not read pipe!"); + } + //working with friend class here is not the finest of all programming stiles but it works... + retVal = p->returnResults(argument, argument1, argument2, argument3, argument4, argument5); + delete p; + } void receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void* userData) { @@ -639,12 +900,12 @@ public: (void) userData; int numReads; CAmDelegagePtr listPointers[3]; - if ((numReads=read(pollfd.fd,&listPointers, sizeof(listPointers))) == -1) + if ((numReads = read(pollfd.fd, &listPointers, sizeof(listPointers))) == -1) { logError("CAmSerializer::receiverCallback could not read pipe!"); throw std::runtime_error("CAmSerializer Could not read pipe!"); } - mListDelegatePoiters.assign(listPointers, listPointers+(numReads/sizeof(CAmDelegagePtr))); + mListDelegatePoiters.assign(listPointers, listPointers + (numReads / sizeof(CAmDelegagePtr))); } bool checkerCallback(const sh_pollHandle_t handle, void* userData) @@ -662,7 +923,7 @@ public: (void) userData; CAmDelegagePtr delegatePoiter = mListDelegatePoiters.front(); mListDelegatePoiters.pop_front(); - if(delegatePoiter->call(mReturnPipe)) + if (delegatePoiter->call(mReturnPipe)) delete delegatePoiter; if (mListDelegatePoiters.empty()) return false; @@ -702,7 +963,9 @@ public: iSocketHandler->addFDPoll(mPipe[0], event, NULL, &receiverCallbackT, NULL, &dispatcherCallbackT, NULL, handle); } - ~CAmSerializer(){} + ~CAmSerializer() + { + } }; } /* namespace am */ #endif /* CAMSERIALIZER_H_ */ -- cgit v1.2.1