* 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)

7 files changed, 990 insertions, 1 deletions

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