Remove assert from database and replace by error handling

Signed-off-by: Christian Linke <Christian.Linke@bmw.de>

13 files changed, 1000 insertions, 293 deletions

diff --git a/AudioManagerCore/include/CAmDatabaseHandlerMap.h b/AudioManagerCore/include/CAmDatabaseHandlerMap.h
index cf319f7..49e77f6 100644
--- a/AudioManagerCore/include/CAmDatabaseHandlerMap.h
+++ b/AudioManagerCore/include/CAmDatabaseHandlerMap.h
@@ -89,7 +89,7 @@ public:
     am_Error_e changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState);
     am_Error_e changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID);
     am_Error_e changeSinkAvailabilityDB(const am_Availability_s& availability, const am_sinkID_t sinkID);
-    am_Error_e changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID);
+    am_Error_e changeDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID);
     am_Error_e changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID);
     am_Error_e changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s& soundProperty, const am_sinkID_t sinkID);
     am_Error_e changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s& soundProperty, const am_sourceID_t sourceID);
diff --git a/AudioManagerCore/include/CAmRouter.h b/AudioManagerCore/include/CAmRouter.h
index fe41049..e7c0746 100644
--- a/AudioManagerCore/include/CAmRouter.h
+++ b/AudioManagerCore/include/CAmRouter.h
@@ -35,6 +35,8 @@
 
 namespace am
 {
+#define TRACE_GRAPH 1
+#define ROUTING_BUILD_CONNECTIONS 1
 /**
  * Optimal path search between a source and a sink is implemented with a graph which contains nodes - sinks, sources, gateways, converters.
  * The nodes are identified by sinkID, sourceID, gatewayID, converterID.
diff --git a/AudioManagerCore/include/IAmDatabaseHandler.h b/AudioManagerCore/include/IAmDatabaseHandler.h
index 30c1aaf..7284d4b 100644
--- a/AudioManagerCore/include/IAmDatabaseHandler.h
+++ b/AudioManagerCore/include/IAmDatabaseHandler.h
@@ -76,7 +76,7 @@ public:
     virtual am_Error_e changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState) = 0;
     virtual am_Error_e changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID) = 0;
     virtual am_Error_e changeSinkAvailabilityDB(const am_Availability_s& availability, const am_sinkID_t sinkID) = 0;
-    virtual am_Error_e changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID) = 0;
+    virtual am_Error_e changeDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID) = 0;
     virtual am_Error_e changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID) = 0;
     virtual am_Error_e changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s& soundProperty, const am_sinkID_t sinkID) = 0;
     virtual am_Error_e changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s& soundProperty, const am_sourceID_t sourceID) = 0;
diff --git a/AudioManagerCore/src/CAmControlReceiver.cpp b/AudioManagerCore/src/CAmControlReceiver.cpp
index c1c161e..662de85 100644
--- a/AudioManagerCore/src/CAmControlReceiver.cpp
+++ b/AudioManagerCore/src/CAmControlReceiver.cpp
@@ -70,7 +70,9 @@ am_Error_e CAmControlReceiver::connect(am_Handle_s & handle, am_connectionID_t &
     tempConnection.connectionID = 0;
     tempConnection.delay=-1;
 
-    mDatabaseHandler->enterConnectionDB(tempConnection, connectionID);
+    am_Error_e connError(mDatabaseHandler->enterConnectionDB(tempConnection, connectionID));
+    if (connError)
+    	return(connError);
     am_Error_e syncError(mRoutingSender->asyncConnect(handle, connectionID, sourceID, sinkID, format));
 	if (syncError)
 	{
@@ -217,7 +219,7 @@ am_Error_e CAmControlReceiver::changeSinkAvailabilityDB(const am_Availability_s
 
 am_Error_e CAmControlReceiver::changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
 {
-    return (mDatabaseHandler->changDomainStateDB(domainState, domainID));
+    return (mDatabaseHandler->changeDomainStateDB(domainState, domainID));
 }
 
 am_Error_e CAmControlReceiver::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
diff --git a/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp b/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp
index 929c8d5..bc35623 100644
--- a/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp
+++ b/AudioManagerCore/src/CAmDatabaseHandlerMap.cpp
@@ -424,9 +424,21 @@ CAmDatabaseHandlerMap::~CAmDatabaseHandlerMap()
 
 am_Error_e CAmDatabaseHandlerMap::enterDomainDB(const am_Domain_s & domainData, am_domainID_t & domainID)
 {
-    assert(!domainData.name.empty());
-    assert(!domainData.busname.empty());
-    assert(domainData.state>=DS_UNKNOWN && domainData.state<=DS_MAX);
+    if(domainData.name.empty())
+    {
+    	logError(__PRETTY_FUNCTION__,"DomainName must not be emtpy!");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(domainData.busname.empty())
+    {
+    	logError(__PRETTY_FUNCTION__,"Busname must not be emtpy!");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!(domainData.state>=DS_UNKNOWN && domainData.state<=DS_MAX))
+    {
+    	logError(__PRETTY_FUNCTION__,"State must not be valid!");
+    	return (E_NOT_POSSIBLE);
+    }
     //first check for a reserved domain
     am_Domain_s const *reservedDomain = objectMatchingPredicate<CAmDomain, am_domainID_t>(mMappedData.mDomainMap, [&](const CAmDomain & obj){
     	return domainData.name.compare(obj.name)==0;
@@ -489,10 +501,26 @@ int16_t CAmDatabaseHandlerMap::calculateDelayForRoute(const std::vector<am_conne
 
 am_Error_e CAmDatabaseHandlerMap::enterMainConnectionDB(const am_MainConnection_s & mainConnectionData, am_mainConnectionID_t & connectionID)
 {
-    assert(mainConnectionData.mainConnectionID==0);
-    assert(mainConnectionData.connectionState>=CS_UNKNOWN && mainConnectionData.connectionState<=CS_MAX);
-    assert(mainConnectionData.sinkID!=0);
-    assert(mainConnectionData.sourceID!=0);
+    if(mainConnectionData.mainConnectionID!=0)
+    {
+    	logError(__PRETTY_FUNCTION__,"mainConnectionID must be 0!");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!(mainConnectionData.connectionState>=CS_UNKNOWN && mainConnectionData.connectionState<=CS_MAX))
+    {
+    	logError(__PRETTY_FUNCTION__,"connectionState must be valid!");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!existSink(mainConnectionData.sinkID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID must be valid!");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!existSink(mainConnectionData.sourceID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must be valid!");
+    	return (E_NOT_POSSIBLE);
+    }
 
     int16_t delay = 0;
     int16_t nextID = 0;
@@ -555,11 +583,32 @@ bool CAmDatabaseHandlerMap::insertSinkDB(const am_Sink_s & sinkData, am_sinkID_t
 
 am_Error_e CAmDatabaseHandlerMap::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 {
-    assert(sinkData.sinkID<DYNAMIC_ID_BOUNDARY);
-    assert(sinkData.domainID!=0);
-    assert(!sinkData.name.empty());
-    assert(sinkData.sinkClassID!=0);
-    assert(sinkData.muteState>=MS_UNKNOWN && sinkData.muteState<=MS_MAX);
+    if(sinkData.sinkID>DYNAMIC_ID_BOUNDARY)
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID must be below:",DYNAMIC_ID_BOUNDARY);
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!existDomain(sinkData.domainID))
+    {
+    	logError(__PRETTY_FUNCTION__,"domainID must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(sinkData.name.empty())
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkName must not be zero");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!existSinkClass(sinkData.sinkClassID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkClass must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!(sinkData.muteState>=MS_UNKNOWN && sinkData.muteState<=MS_MAX))
+    {
+    	logError(__PRETTY_FUNCTION__,"muteState must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
 
     am_sinkID_t temp_SinkID = 0;
     am_sinkID_t temp_SinkIndex = 0;
@@ -631,12 +680,38 @@ bool CAmDatabaseHandlerMap::insertCrossfaderDB(const am_Crossfader_s & crossfade
 
 am_Error_e CAmDatabaseHandlerMap::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 {
-    assert(crossfaderData.crossfaderID<DYNAMIC_ID_BOUNDARY);
-    assert(crossfaderData.hotSink>=HS_UNKNOWN && crossfaderData.hotSink<=HS_MAX);
-    assert(!crossfaderData.name.empty());
-    assert(existSink(crossfaderData.sinkID_A));
-    assert(existSink(crossfaderData.sinkID_B));
-    assert(existSource(crossfaderData.sourceID));
+    if(crossfaderData.crossfaderID>DYNAMIC_ID_BOUNDARY)
+    {
+    	logError(__PRETTY_FUNCTION__,"crossfaderID must be below:",DYNAMIC_ID_BOUNDARY);
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!(crossfaderData.hotSink>=HS_UNKNOWN && crossfaderData.hotSink<=HS_MAX))
+    {
+    	logError(__PRETTY_FUNCTION__,"hotSink must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(crossfaderData.name.empty())
+    {
+    	logError(__PRETTY_FUNCTION__,"crossfaderName must not be zero");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!existSink(crossfaderData.sinkID_A))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID_A must exist");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!existSink(crossfaderData.sinkID_B))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID_B must exist");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!existSource(crossfaderData.sourceID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exist");
+    	return (E_NOT_POSSIBLE);
+    }
 
     am_crossfaderID_t temp_CrossfaderID = 0;
     am_crossfaderID_t temp_CrossfaderIndex = 0;
@@ -692,13 +767,48 @@ bool CAmDatabaseHandlerMap::insertGatewayDB(const am_Gateway_s & gatewayData, am
 
 am_Error_e CAmDatabaseHandlerMap::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 {
-    assert(gatewayData.gatewayID<DYNAMIC_ID_BOUNDARY);
-    assert(gatewayData.sinkID!=0);
-    assert(gatewayData.sourceID!=0);
-    assert(gatewayData.controlDomainID!=0);
-    assert(gatewayData.domainSinkID!=0);
-    assert(gatewayData.domainSourceID!=0);
-    assert(!gatewayData.name.empty());
+
+    if(gatewayData.gatewayID>DYNAMIC_ID_BOUNDARY)
+    {
+    	logError(__PRETTY_FUNCTION__,"gatewayID must be below:",DYNAMIC_ID_BOUNDARY);
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!existSink(gatewayData.sinkID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID must be exist");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!existSource(gatewayData.sourceID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must be exist");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!existDomain(gatewayData.controlDomainID))
+    {
+    	logError(__PRETTY_FUNCTION__,"controlDomainID must be exist");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!existDomain(gatewayData.domainSinkID))
+    {
+    	logError(__PRETTY_FUNCTION__,"domainSinkID must be exist");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!existDomain(gatewayData.domainSourceID))
+    {
+    	logError(__PRETTY_FUNCTION__,"domainSourceID must be exist");
+    	return (E_NOT_POSSIBLE);
+    }
+
+
+    if(gatewayData.name.empty())
+    {
+    	logError(__PRETTY_FUNCTION__,"gatewayName must not be empty");
+    	return (E_NOT_POSSIBLE);
+    }
 
     //might be that the sinks and sources are not there during registration time
     //assert(existSink(gatewayData.sinkID));
@@ -756,11 +866,35 @@ bool CAmDatabaseHandlerMap::insertConverterDB(const am_Converter_s & converteDat
 
 am_Error_e CAmDatabaseHandlerMap::enterConverterDB(const am_Converter_s & converterData, am_converterID_t & converterID)
 {
-    assert(converterData.converterID<DYNAMIC_ID_BOUNDARY);
-    assert(converterData.sinkID!=0);
-    assert(converterData.sourceID!=0);
-    assert(converterData.domainID!=0);
-    assert(!converterData.name.empty());
+    if(converterData.converterID>DYNAMIC_ID_BOUNDARY)
+    {
+    	logError(__PRETTY_FUNCTION__,"converterID must be below:",DYNAMIC_ID_BOUNDARY);
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!existSink(converterData.sinkID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exists");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!existSource(converterData.sourceID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exists");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!existDomain(converterData.domainID))
+    {
+    	logError(__PRETTY_FUNCTION__,"domainID must exists");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(converterData.name.empty())
+    {
+    	logError(__PRETTY_FUNCTION__,"converterName must not be empty");
+    	return (E_NOT_POSSIBLE);
+    }
 
     //might be that the sinks and sources are not there during registration time
     //assert(existSink(gatewayData.sinkID));
@@ -839,11 +973,32 @@ bool CAmDatabaseHandlerMap::insertSourceDB(const am_Source_s & sourceData, am_so
 
 am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 {
-    assert(sourceData.sourceID<DYNAMIC_ID_BOUNDARY);
-    assert(sourceData.domainID!=0);
-    assert(!sourceData.name.empty());
-    assert(sourceData.sourceClassID!=0);
-    assert(sourceData.sourceState>=SS_UNKNNOWN && sourceData.sourceState<=SS_MAX);
+    if(sourceData.sourceID>DYNAMIC_ID_BOUNDARY)
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must be below:",DYNAMIC_ID_BOUNDARY);
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!existDomain(sourceData.domainID))
+    {
+    	logError(__PRETTY_FUNCTION__,"domainID must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(sourceData.name.empty())
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceName must not be zero");
+    	return (E_NOT_POSSIBLE);
+    }
+    if(!existSourceClass(sourceData.sourceClassID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceClassID must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!(sourceData.sourceState>=SS_UNKNNOWN && sourceData.sourceState<=SS_MAX))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceState must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
 
     bool isFirstStatic = sourceData.sourceID == 0 && mFirstStaticSource;
     am_sourceID_t temp_SourceID = 0;
@@ -894,9 +1049,23 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s & sourceData,
 
 am_Error_e CAmDatabaseHandlerMap::enterConnectionDB(const am_Connection_s& connection, am_connectionID_t& connectionID)
 {
-    assert(connection.connectionID==0);
-    assert(connection.sinkID!=0);
-    assert(connection.sourceID!=0);
+    if(connection.connectionID!=0)
+    {
+    	logError(__PRETTY_FUNCTION__,"connectionID must be 0!");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!existSink(connection.sinkID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exist!");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!existSource(connection.sourceID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exist!");
+    	return (E_NOT_POSSIBLE);
+    }
     //connection format is not checked, because it's project specific
     int16_t nextID = 0;
     if(mMappedData.increaseConnectionID(nextID))
@@ -937,8 +1106,17 @@ bool CAmDatabaseHandlerMap::insertSinkClassDB(const am_SinkClass_s & sinkClass,
 
 am_Error_e CAmDatabaseHandlerMap::enterSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID)
 {
-    assert(sinkClass.sinkClassID<DYNAMIC_ID_BOUNDARY);
-    assert(!sinkClass.name.empty());
+    if(sinkClass.sinkClassID>DYNAMIC_ID_BOUNDARY)
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkClassID must be <",DYNAMIC_ID_BOUNDARY);
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(sinkClass.name.empty())
+    {
+    	logError(__PRETTY_FUNCTION__,"name must not be empty");
+    	return (E_NOT_POSSIBLE);
+    }
 
     am_sinkClass_t temp_SinkClassID = 0;
     am_sinkClass_t temp_SinkClassIndex = 0;
@@ -993,8 +1171,18 @@ bool CAmDatabaseHandlerMap::insertSourceClassDB(am_sourceClass_t & sourceClassID
 
 am_Error_e CAmDatabaseHandlerMap::enterSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass)
 {
-    assert(sourceClass.sourceClassID<DYNAMIC_ID_BOUNDARY);
-    assert(!sourceClass.name.empty());
+    if(sourceClass.sourceClassID>DYNAMIC_ID_BOUNDARY)
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceClassID must be <",DYNAMIC_ID_BOUNDARY);
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(sourceClass.name.empty())
+    {
+    	logError(__PRETTY_FUNCTION__,"name must not be empty");
+    	return (E_NOT_POSSIBLE);
+    }
+
 
     am_sourceClass_t temp_SourceClassID = 0;
     am_sourceClass_t temp_SourceClassIndex = 0;
@@ -1033,7 +1221,11 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceClassDB(am_sourceClass_t & sourceCl
 
 am_Error_e CAmDatabaseHandlerMap::enterSystemProperties(const std::vector<am_SystemProperty_s> & listSystemProperties)
 {
-    assert(!listSystemProperties.empty());
+    if(listSystemProperties.empty())
+	{
+    	logError(__PRETTY_FUNCTION__,"listSystemProperties must not be empty");
+    	return (E_NOT_POSSIBLE);
+	}
 
     mMappedData.mSystemProperties = listSystemProperties;
 
@@ -1043,9 +1235,15 @@ am_Error_e CAmDatabaseHandlerMap::enterSystemProperties(const std::vector<am_Sys
 
 am_Error_e CAmDatabaseHandlerMap::changeMainConnectionRouteDB(const am_mainConnectionID_t mainconnectionID, const std::vector<am_connectionID_t>& listConnectionID)
 {
-    assert(mainconnectionID!=0);
+    if(mainconnectionID==0)
+    {
+    	logError(__PRETTY_FUNCTION__,"mainconnectionID must not be 0");
+    	return (E_NOT_POSSIBLE);
+    }
+
     if (!existMainConnection(mainconnectionID))
     {
+    	logError(__PRETTY_FUNCTION__,"existMainConnection must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1063,11 +1261,21 @@ am_Error_e CAmDatabaseHandlerMap::changeMainConnectionRouteDB(const am_mainConne
 
 am_Error_e CAmDatabaseHandlerMap::changeMainConnectionStateDB(const am_mainConnectionID_t mainconnectionID, const am_ConnectionState_e connectionState)
 {
-    assert(mainconnectionID!=0);
-    assert(connectionState>=CS_UNKNOWN && connectionState<=CS_MAX);
+    if(mainconnectionID==0)
+    {
+    	logError(__PRETTY_FUNCTION__,"mainconnectionID must not be 0");
+    	return (E_NOT_POSSIBLE);
+    }
+
+    if(!(connectionState>=CS_UNKNOWN && connectionState<=CS_MAX))
+    {
+    	logError(__PRETTY_FUNCTION__,"connectionState must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
 
     if (!existMainConnection(mainconnectionID))
     {
+    	logError(__PRETTY_FUNCTION__,"existMainConnection must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1081,10 +1289,9 @@ am_Error_e CAmDatabaseHandlerMap::changeMainConnectionStateDB(const am_mainConne
 
 am_Error_e CAmDatabaseHandlerMap::changeSinkMainVolumeDB(const am_mainVolume_t mainVolume, const am_sinkID_t sinkID)
 {
-    assert(sinkID!=0);
-
     if (!existSink(sinkID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1100,11 +1307,15 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkMainVolumeDB(const am_mainVolume_t m
 
 am_Error_e CAmDatabaseHandlerMap::changeSinkAvailabilityDB(const am_Availability_s & availability, const am_sinkID_t sinkID)
 {
-    assert(sinkID!=0);
-    assert(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX);
+    if (!(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX))
+    {
+    	logError(__PRETTY_FUNCTION__,"availability must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
 
     if (!existSink(sinkID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1117,13 +1328,18 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkAvailabilityDB(const am_Availability
     return (E_OK);
 }
 
-am_Error_e CAmDatabaseHandlerMap::changDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
+am_Error_e CAmDatabaseHandlerMap::changeDomainStateDB(const am_DomainState_e domainState, const am_domainID_t domainID)
 {
-    assert(domainID!=0);
-    assert(domainState>=DS_UNKNOWN && domainState<=DS_MAX);
+
+    if(!(domainState>=DS_UNKNOWN && domainState<=DS_MAX))
+    {
+    	logError(__PRETTY_FUNCTION__,"domainState must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
 
     if (!existDomain(domainID))
     {
+    	logError(__PRETTY_FUNCTION__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1135,11 +1351,16 @@ am_Error_e CAmDatabaseHandlerMap::changDomainStateDB(const am_DomainState_e doma
 
 am_Error_e CAmDatabaseHandlerMap::changeSinkMuteStateDB(const am_MuteState_e muteState, const am_sinkID_t sinkID)
 {
-    assert(sinkID!=0);
-    assert(muteState>=MS_UNKNOWN && muteState<=MS_MAX);
+
+    if(!(muteState>=MS_UNKNOWN && muteState<=MS_MAX))
+    {
+    	logError(__PRETTY_FUNCTION__,"muteState must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
 
     if (!existSink(sinkID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1155,10 +1376,10 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkMuteStateDB(const am_MuteState_e mut
 
 am_Error_e CAmDatabaseHandlerMap::changeMainSinkSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sinkID_t sinkID)
 {
-    assert(sinkID!=0);
 
     if (!existSink(sinkID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
     am_Sink_Database_s & sink = mMappedData.mSinkMap[sinkID];
@@ -1182,10 +1403,10 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSinkSoundPropertyDB(const am_MainSou
 
 am_Error_e CAmDatabaseHandlerMap::changeMainSourceSoundPropertyDB(const am_MainSoundProperty_s & soundProperty, const am_sourceID_t sourceID)
 {
-    assert(sourceID!=0);
 
     if (!existSource(sourceID))
     {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exist");
         return (E_NON_EXISTENT);
     }
     am_Source_Database_s & source = mMappedData.mSourceMap.at(sourceID);
@@ -1210,11 +1431,15 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSourceSoundPropertyDB(const am_MainS
 
 am_Error_e CAmDatabaseHandlerMap::changeSourceAvailabilityDB(const am_Availability_s & availability, const am_sourceID_t sourceID)
 {
-    assert(sourceID!=0);
-    assert(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX);
+    if(!(availability.availability>=A_UNKNOWN && availability.availability<=A_MAX))
+    {
+    	logError(__PRETTY_FUNCTION__,"availability must be valid");
+    	return (E_NOT_POSSIBLE);
+    }
 
     if (!existSource(sourceID))
     {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1246,10 +1471,10 @@ am_Error_e CAmDatabaseHandlerMap::changeSystemPropertyDB(const am_SystemProperty
 
 am_Error_e CAmDatabaseHandlerMap::removeMainConnectionDB(const am_mainConnectionID_t mainConnectionID)
 {
-    assert(mainConnectionID!=0);
 
     if (!existMainConnection(mainConnectionID))
     {
+    	logError(__PRETTY_FUNCTION__,"mainConnectionID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1266,10 +1491,10 @@ am_Error_e CAmDatabaseHandlerMap::removeMainConnectionDB(const am_mainConnection
 
 am_Error_e CAmDatabaseHandlerMap::removeSinkDB(const am_sinkID_t sinkID)
 {
-    assert(sinkID!=0);
 
     if (!existSink(sinkID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1288,10 +1513,10 @@ am_Error_e CAmDatabaseHandlerMap::removeSinkDB(const am_sinkID_t sinkID)
 
 am_Error_e CAmDatabaseHandlerMap::removeSourceDB(const am_sourceID_t sourceID)
 {
-    assert(sourceID!=0);
 
     if (!existSource(sourceID))
     {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1310,10 +1535,10 @@ am_Error_e CAmDatabaseHandlerMap::removeSourceDB(const am_sourceID_t sourceID)
 
 am_Error_e CAmDatabaseHandlerMap::removeGatewayDB(const am_gatewayID_t gatewayID)
 {
-    assert(gatewayID!=0);
 
     if (!existGateway(gatewayID))
     {
+    	logError(__PRETTY_FUNCTION__,"gatewayID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1327,10 +1552,10 @@ am_Error_e CAmDatabaseHandlerMap::removeGatewayDB(const am_gatewayID_t gatewayID
 
 am_Error_e CAmDatabaseHandlerMap::removeConverterDB(const am_converterID_t converterID)
 {
-    assert(converterID!=0);
 
     if (!existConverter(converterID))
     {
+    	logError(__PRETTY_FUNCTION__,"converterID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1344,10 +1569,10 @@ am_Error_e CAmDatabaseHandlerMap::removeConverterDB(const am_converterID_t conve
 
 am_Error_e CAmDatabaseHandlerMap::removeCrossfaderDB(const am_crossfaderID_t crossfaderID)
 {
-    assert(crossfaderID!=0);
 
     if (!existCrossFader(crossfaderID))
     {
+    	logError(__PRETTY_FUNCTION__,"crossfaderID must exist");
         return (E_NON_EXISTENT);
     }
     mMappedData.mCrossfaderMap.erase(crossfaderID);
@@ -1360,10 +1585,10 @@ am_Error_e CAmDatabaseHandlerMap::removeCrossfaderDB(const am_crossfaderID_t cro
 
 am_Error_e CAmDatabaseHandlerMap::removeDomainDB(const am_domainID_t domainID)
 {
-    assert(domainID!=0);
 
     if (!existDomain(domainID))
     {
+    	logError(__PRETTY_FUNCTION__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
     mMappedData.mDomainMap.erase(domainID);
@@ -1376,10 +1601,10 @@ am_Error_e CAmDatabaseHandlerMap::removeDomainDB(const am_domainID_t domainID)
 
 am_Error_e CAmDatabaseHandlerMap::removeSinkClassDB(const am_sinkClass_t sinkClassID)
 {
-    assert(sinkClassID!=0);
 
     if (!existSinkClass(sinkClassID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkClassID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1394,10 +1619,10 @@ am_Error_e CAmDatabaseHandlerMap::removeSinkClassDB(const am_sinkClass_t sinkCla
 
 am_Error_e CAmDatabaseHandlerMap::removeSourceClassDB(const am_sourceClass_t sourceClassID)
 {
-    assert(sourceClassID!=0);
 
     if (!existSourceClass(sourceClassID))
     {
+    	logError(__PRETTY_FUNCTION__,"sourceClassID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1410,7 +1635,11 @@ am_Error_e CAmDatabaseHandlerMap::removeSourceClassDB(const am_sourceClass_t sou
 
 am_Error_e CAmDatabaseHandlerMap::removeConnection(const am_connectionID_t connectionID)
 {
-    assert(connectionID!=0);
+    if (!existConnectionID(connectionID))
+    {
+    	logError(__PRETTY_FUNCTION__,"connectionID must exist");
+        return (E_NON_EXISTENT);
+    }
 
     mMappedData.mConnectionMap.erase(connectionID);
 
@@ -1420,10 +1649,10 @@ am_Error_e CAmDatabaseHandlerMap::removeConnection(const am_connectionID_t conne
 
 am_Error_e CAmDatabaseHandlerMap::getSourceClassInfoDB(const am_sourceID_t sourceID, am_SourceClass_s & classInfo) const
 {
-    assert(sourceID!=0);
 
     if (!existSource(sourceID))
     {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exist");
         return (E_NON_EXISTENT);
     }
     am_Source_Database_s source = mMappedData.mSourceMap.at(sourceID);
@@ -1441,10 +1670,12 @@ am_Error_e CAmDatabaseHandlerMap::getSourceClassInfoDB(const am_sourceID_t sourc
 
 am_Error_e CAmDatabaseHandlerMap::getSinkInfoDB(const am_sinkID_t sinkID, am_Sink_s & sinkData) const
 {
-    assert(sinkID!=0);
 
     if (!existSink(sinkID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exist");
         return (E_NON_EXISTENT);
+    }
 
     am_Sink_Database_s mappedSink = mMappedData.mSinkMap.at(sinkID);
     if( true == mappedSink.reserved )
@@ -1456,10 +1687,12 @@ am_Error_e CAmDatabaseHandlerMap::getSinkInfoDB(const am_sinkID_t sinkID, am_Sin
 
 am_Error_e CAmDatabaseHandlerMap::getSourceInfoDB(const am_sourceID_t sourceID, am_Source_s & sourceData) const
 {
-    assert(sourceID!=0);
 
     if (!existSource(sourceID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exist");
         return (E_NON_EXISTENT);
+    }
 
     am_Source_Database_s mappedSource = mMappedData.mSourceMap.at(sourceID);
     if( true == mappedSource.reserved )
@@ -1472,9 +1705,9 @@ am_Error_e CAmDatabaseHandlerMap::getSourceInfoDB(const am_sourceID_t sourceID,
 
 am_Error_e am::CAmDatabaseHandlerMap::getMainConnectionInfoDB(const am_mainConnectionID_t mainConnectionID, am_MainConnection_s & mainConnectionData) const
 {
-    assert(mainConnectionID!=0);
     if (!existMainConnection(mainConnectionID))
     {
+    	logError(__PRETTY_FUNCTION__,"mainConnectionID must exist");
         return (E_NON_EXISTENT);
     }
     am_MainConnection_s temp = mMappedData.mMainConnectionMap.at(mainConnectionID);
@@ -1485,12 +1718,18 @@ am_Error_e am::CAmDatabaseHandlerMap::getMainConnectionInfoDB(const am_mainConne
 
 am_Error_e CAmDatabaseHandlerMap::changeSinkClassInfoDB(const am_SinkClass_s& sinkClass)
 {
-    assert(sinkClass.sinkClassID!=0);
-    assert(!sinkClass.listClassProperties.empty());
+    if(sinkClass.listClassProperties.empty())
+    {
+    	logError(__PRETTY_FUNCTION__,"listClassProperties must not be empty");
+    	return (E_NOT_POSSIBLE);
+    }
 
     //check if the ID already exists
     if (!existSinkClass(sinkClass.sinkClassID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkClassID must exist");
         return (E_NON_EXISTENT);
+    }
 
     DB_COND_UPDATE_RIE(mMappedData.mSinkClassesMap[sinkClass.sinkClassID].listClassProperties, sinkClass.listClassProperties);
 
@@ -1500,12 +1739,18 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkClassInfoDB(const am_SinkClass_s& si
 
 am_Error_e CAmDatabaseHandlerMap::changeSourceClassInfoDB(const am_SourceClass_s& sourceClass)
 {
-    assert(sourceClass.sourceClassID!=0);
-    assert(!sourceClass.listClassProperties.empty());
+    if(sourceClass.listClassProperties.empty())
+    {
+		logError(__PRETTY_FUNCTION__,"listClassProperties must not be empty");
+		return (E_NOT_POSSIBLE);
+    }
 
     //check if the ID already exists
     if (!existSourceClass(sourceClass.sourceClassID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceClassID must exist");
         return (E_NON_EXISTENT);
+    }
 
     DB_COND_UPDATE_RIE(mMappedData.mSourceClassesMap[sourceClass.sourceClassID].listClassProperties, sourceClass.listClassProperties);
 
@@ -1515,10 +1760,10 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceClassInfoDB(const am_SourceClass_s
 
 am_Error_e CAmDatabaseHandlerMap::getSinkClassInfoDB(const am_sinkID_t sinkID, am_SinkClass_s & sinkClass) const
 {
-    assert(sinkID!=0);
 
     if (!existSink(sinkID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exist");
         return (E_NON_EXISTENT);
     }
     am_Sink_Database_s sink = mMappedData.mSinkMap.at(sinkID);
@@ -1526,6 +1771,7 @@ am_Error_e CAmDatabaseHandlerMap::getSinkClassInfoDB(const am_sinkID_t sinkID, a
 
     if (!existSinkClass(sinkClass.sinkClassID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkClassID must exist");
         return (E_NON_EXISTENT);
     }
     am_SinkClass_s tmpSinkClass = mMappedData.mSinkClassesMap.at(sinkClass.sinkClassID);
@@ -1536,9 +1782,9 @@ am_Error_e CAmDatabaseHandlerMap::getSinkClassInfoDB(const am_sinkID_t sinkID, a
 
 am_Error_e CAmDatabaseHandlerMap::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_Gateway_s & gatewayData) const
 {
-    assert(gatewayID!=0);
     if (!existGateway(gatewayID))
     {
+    	logError(__PRETTY_FUNCTION__,"gatewayID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1550,9 +1796,9 @@ am_Error_e CAmDatabaseHandlerMap::getGatewayInfoDB(const am_gatewayID_t gatewayI
 
 am_Error_e CAmDatabaseHandlerMap::getConverterInfoDB(const am_converterID_t converterID, am_Converter_s& converterData) const
 {
-    assert(converterID!=0);
     if (!existConverter(converterID))
     {
+    	logError(__PRETTY_FUNCTION__,"converterID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1564,9 +1810,9 @@ am_Error_e CAmDatabaseHandlerMap::getConverterInfoDB(const am_converterID_t conv
 
 am_Error_e CAmDatabaseHandlerMap::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
 {
-    assert(crossfaderID!=0);
     if (!existCrossFader(crossfaderID))
     {
+    	logError(__PRETTY_FUNCTION__,"crossfaderID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1577,10 +1823,10 @@ am_Error_e CAmDatabaseHandlerMap::getCrossfaderInfoDB(const am_crossfaderID_t cr
 
 am_Error_e CAmDatabaseHandlerMap::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
 {
-    assert(domainID!=0);
     listSinkID.clear();
     if (!existDomain(domainID))
     {
+    	logError(__PRETTY_FUNCTION__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1595,10 +1841,10 @@ am_Error_e CAmDatabaseHandlerMap::getListSinksOfDomain(const am_domainID_t domai
 
 am_Error_e CAmDatabaseHandlerMap::getListSourcesOfDomain(const am_domainID_t domainID, std::vector<am_sourceID_t> & listSourceID) const
 {
-    assert(domainID!=0);
     listSourceID.clear();
     if (!existDomain(domainID))
     {
+    	logError(__PRETTY_FUNCTION__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
      CAmMapSource::const_iterator elementIterator = mMappedData.mSourceMap.begin();
@@ -1613,10 +1859,10 @@ am_Error_e CAmDatabaseHandlerMap::getListSourcesOfDomain(const am_domainID_t dom
 
 am_Error_e CAmDatabaseHandlerMap::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listCrossfader) const
 {
-    assert(domainID!=0);
     listCrossfader.clear();
     if (!existDomain(domainID))
     {
+    	logError(__PRETTY_FUNCTION__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1640,10 +1886,10 @@ am_Error_e CAmDatabaseHandlerMap::getListCrossfadersOfDomain(const am_domainID_t
 
 am_Error_e CAmDatabaseHandlerMap::getListGatewaysOfDomain(const am_domainID_t domainID, std::vector<am_gatewayID_t> & listGatewaysID) const
 {
-    assert(domainID!=0);
     listGatewaysID.clear();
     if (!existDomain(domainID))
     {
+    	logError(__PRETTY_FUNCTION__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1658,10 +1904,10 @@ am_Error_e CAmDatabaseHandlerMap::getListGatewaysOfDomain(const am_domainID_t do
 
 am_Error_e CAmDatabaseHandlerMap::getListConvertersOfDomain(const am_domainID_t domainID, std::vector<am_converterID_t>& listConvertersID) const
 {
-    assert(domainID!=0);
     listConvertersID.clear();
     if (!existDomain(domainID))
     {
+    	logError(__PRETTY_FUNCTION__,"domainID must exist");
         return (E_NON_EXISTENT);
     }
 
@@ -1836,9 +2082,11 @@ am_Error_e CAmDatabaseHandlerMap::getListMainSources(std::vector<am_SourceType_s
 
 am_Error_e CAmDatabaseHandlerMap::getListMainSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_MainSoundProperty_s> & listSoundProperties) const
 {
-    assert(sinkID!=0);
     if (!existSink(sinkID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exist");
     	return E_NON_EXISTENT;
+    }
 
     const am_Sink_s & sink = mMappedData.mSinkMap.at(sinkID);
     listSoundProperties = sink.listMainSoundProperties;
@@ -1848,10 +2096,11 @@ am_Error_e CAmDatabaseHandlerMap::getListMainSinkSoundProperties(const am_sinkID
 
 am_Error_e CAmDatabaseHandlerMap::getListMainSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_MainSoundProperty_s> & listSourceProperties) const
 {
-    assert(sourceID!=0);
     if (!existSource(sourceID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exist");
     	return E_NON_EXISTENT;
-
+    }
     const am_Source_s & source = mMappedData.mSourceMap.at(sourceID);
     listSourceProperties = source.listMainSoundProperties;
 
@@ -1860,9 +2109,11 @@ am_Error_e CAmDatabaseHandlerMap::getListMainSourceSoundProperties(const am_sour
 
 am_Error_e CAmDatabaseHandlerMap::getListSinkSoundProperties(const am_sinkID_t sinkID, std::vector<am_SoundProperty_s>& listSoundproperties) const
 {
-    assert(sinkID!=0);
     if (!existSink(sinkID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID must exist");
     	return E_NON_EXISTENT;
+    }
 
     const am_Sink_Database_s & sink = mMappedData.mSinkMap.at(sinkID);
     listSoundproperties = sink.listSoundProperties;
@@ -1872,9 +2123,11 @@ am_Error_e CAmDatabaseHandlerMap::getListSinkSoundProperties(const am_sinkID_t s
 
 am_Error_e CAmDatabaseHandlerMap::getListSourceSoundProperties(const am_sourceID_t sourceID, std::vector<am_SoundProperty_s>& listSoundproperties) const
 {
-	assert(sourceID!=0);
 	if (!existSource(sourceID))
-		return E_NON_EXISTENT;
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exist");
+    	return E_NON_EXISTENT;
+    }
 
 	const am_Source_Database_s & source = mMappedData.mSourceMap.at(sourceID);
 	listSoundproperties = source.listSoundProperties;
@@ -1891,7 +2144,10 @@ am_Error_e CAmDatabaseHandlerMap::getListSystemProperties(std::vector<am_SystemP
 am_Error_e am::CAmDatabaseHandlerMap::getListSinkConnectionFormats(const am_sinkID_t sinkID, std::vector<am_CustomConnectionFormat_t> & listConnectionFormats) const
 {
    if (!existSink(sinkID))
-	   return E_NON_EXISTENT;
+   {
+		logError(__PRETTY_FUNCTION__,"sinkID must exist");
+		return E_NON_EXISTENT;
+   }
 	const am_Sink_s & sink = mMappedData.mSinkMap.at(sinkID);
 	listConnectionFormats = sink.listConnectionFormats;
 
@@ -1901,7 +2157,10 @@ am_Error_e am::CAmDatabaseHandlerMap::getListSinkConnectionFormats(const am_sink
 am_Error_e am::CAmDatabaseHandlerMap::getListSourceConnectionFormats(const am_sourceID_t sourceID, std::vector<am_CustomConnectionFormat_t> & listConnectionFormats) const
 {
    if (!existSource(sourceID))
-	   return E_NON_EXISTENT;
+   {
+		logError(__PRETTY_FUNCTION__,"sourceID must exist");
+		return E_NON_EXISTENT;
+   }
     const am_Source_s & source = mMappedData.mSourceMap.at(sourceID);
     listConnectionFormats = source.listConnectionFormats;
 
@@ -1910,6 +2169,11 @@ am_Error_e am::CAmDatabaseHandlerMap::getListSourceConnectionFormats(const am_so
 
 am_Error_e am::CAmDatabaseHandlerMap::getListGatewayConnectionFormats(const am_gatewayID_t gatewayID, std::vector<bool> & listConnectionFormat) const
 {
+   if (!existGateway(gatewayID))
+   {
+		logError(__PRETTY_FUNCTION__,"gatewayID must exist");
+		return E_NON_EXISTENT;
+   }
     ListConnectionFormat::const_iterator iter = mListConnectionFormat.begin();
     iter = mListConnectionFormat.find(gatewayID);
     if (iter == mListConnectionFormat.end())
@@ -1925,9 +2189,11 @@ am_Error_e am::CAmDatabaseHandlerMap::getListGatewayConnectionFormats(const am_g
 
 am_Error_e CAmDatabaseHandlerMap::getTimingInformation(const am_mainConnectionID_t mainConnectionID, am_timeSync_t & delay) const
 {
-    assert(mainConnectionID!=0);
     if (!existMainConnection(mainConnectionID))
-    	return E_NON_EXISTENT;
+    {
+ 		logError(__PRETTY_FUNCTION__,"mainConnectionID must exist");
+ 		return E_NON_EXISTENT;
+    }
     delay = -1;
 
     const am_MainConnection_s & mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID);
@@ -1941,9 +2207,11 @@ am_Error_e CAmDatabaseHandlerMap::getTimingInformation(const am_mainConnectionID
 
 am_Error_e CAmDatabaseHandlerMap::changeDelayMainConnection(const am_timeSync_t & delay, const am_mainConnectionID_t & connectionID)
 {
-    assert(connectionID!=0);
     if (!existMainConnection(connectionID))
- 		return (E_NON_EXISTENT);
+    {
+ 		logError(__PRETTY_FUNCTION__,"connectionID must exist");
+ 		return E_NON_EXISTENT;
+    }
     DB_COND_UPDATE_RIE(mMappedData.mMainConnectionMap[connectionID].delay, delay);
     if (mpDatabaseObserver)
         mpDatabaseObserver->timingInformationChanged(connectionID, delay);
@@ -2098,7 +2366,6 @@ bool CAmDatabaseHandlerMap::existConverter(const am_converterID_t converterID) c
 
 am_Error_e CAmDatabaseHandlerMap::getDomainOfSource(const am_sourceID_t sourceID, am_domainID_t & domainID) const
 {
-    assert(sourceID!=0);
     domainID=0;
 
     am_Source_Database_s const * source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
@@ -2112,7 +2379,6 @@ am_Error_e CAmDatabaseHandlerMap::getDomainOfSource(const am_sourceID_t sourceID
 
 am_Error_e am::CAmDatabaseHandlerMap::getDomainOfSink(const am_sinkID_t sinkID, am_domainID_t & domainID) const
 {
-    assert(sinkID!=0);
     domainID=0;
 
     am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
@@ -2126,7 +2392,6 @@ am_Error_e am::CAmDatabaseHandlerMap::getDomainOfSink(const am_sinkID_t sinkID,
 
 am_Error_e am::CAmDatabaseHandlerMap::getDomainOfCrossfader(const am_converterID_t crossfader, am_domainID_t & domainID) const
 {
-    assert(crossfader!=0);
     domainID=0;
 
     am_Crossfader_Database_s const * cross = objectForKeyIfExistsInMap(crossfader, mMappedData.mCrossfaderMap);
@@ -2160,9 +2425,11 @@ bool CAmDatabaseHandlerMap::existSourceClass(const am_sourceClass_t sourceClassI
 
 am_Error_e CAmDatabaseHandlerMap::changeConnectionTimingInformation(const am_connectionID_t connectionID, const am_timeSync_t delay)
 {
-    assert(connectionID!=0);
-    if(!existConnectionID(connectionID))
-    	return E_NON_EXISTENT;
+     if(!existConnectionID(connectionID))
+     {
+     	logError(__PRETTY_FUNCTION__,"connectionID must exist");
+         return (E_NON_EXISTENT);
+     }
 
     mMappedData.mConnectionMap[connectionID].delay = delay;
 
@@ -2186,19 +2453,18 @@ am_Error_e CAmDatabaseHandlerMap::changeConnectionTimingInformation(const am_con
 
 am_Error_e CAmDatabaseHandlerMap::changeConnectionFinal(const am_connectionID_t connectionID)
 {
-    assert(connectionID!=0);
     am_Connection_Database_s const * connection = objectForKeyIfExistsInMap(connectionID, mMappedData.mConnectionMap);
     if( NULL!=connection )
     {
     	mMappedData.mConnectionMap.at(connectionID).reserved = false;
     	return E_OK;
     }
+	logError(__PRETTY_FUNCTION__,"connectionID must exist");
     return (E_NON_EXISTENT);
 }
 
 am_timeSync_t CAmDatabaseHandlerMap::calculateMainConnectionDelay(const am_mainConnectionID_t mainConnectionID) const
 {
-    assert(mainConnectionID!=0);
     if (!existMainConnection(mainConnectionID))
   		return -1;
     const am_MainConnection_s & mainConnection = mMappedData.mMainConnectionMap.at(mainConnectionID);
@@ -2232,9 +2498,11 @@ void CAmDatabaseHandlerMap::registerObserver(CAmDatabaseObserver *iObserver)
  */
 bool CAmDatabaseHandlerMap::sourceVisible(const am_sourceID_t sourceID) const
 {
-    assert(sourceID!=0);
     if (!existSource(sourceID))
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must exist");
     	return false;
+    }
     am_Source_Database_s source = mMappedData.mSourceMap.at(sourceID);
     return source.visible;
 }
@@ -2314,18 +2582,23 @@ am_Error_e CAmDatabaseHandlerMap::getSoureState(const am_sourceID_t sourceID, am
 
 am_Error_e CAmDatabaseHandlerMap::changeSourceState(const am_sourceID_t sourceID, const am_SourceState_e sourceState)
 {
-    assert(sourceID!=0);
-    assert(sourceState>=SS_UNKNNOWN && sourceState<=SS_MAX);
+    if(!(sourceState>=SS_UNKNNOWN && sourceState<=SS_MAX))
+	{
+		logError(__PRETTY_FUNCTION__,"sourceState must be valid");
+		return (E_NOT_POSSIBLE);
+	}
+
     if(existSource(sourceID))
     {
     	mMappedData.mSourceMap.at(sourceID).sourceState = sourceState;
 		return (E_OK);
 	}
+    logError(__PRETTY_FUNCTION__,"sourceID must exist");
 	return (E_NON_EXISTENT);
 }
 
 am_Error_e CAmDatabaseHandlerMap::getSinkMainVolume(const am_sinkID_t sinkID, am_mainVolume_t& mainVolume) const {
-    assert(sinkID!=0);
+
 
 	am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
 	if( NULL!=source )
@@ -2334,12 +2607,12 @@ am_Error_e CAmDatabaseHandlerMap::getSinkMainVolume(const am_sinkID_t sinkID, am
 		return (E_OK);
 	}
 	mainVolume = -1;
+	logError(__PRETTY_FUNCTION__,"sinkID must be valid");
 	return (E_NON_EXISTENT);
 }
 
 am_Error_e CAmDatabaseHandlerMap::getSinkVolume(const am_sinkID_t sinkID, am_volume_t & volume) const
 {
-    assert(sinkID!=0);
 
 	am_Sink_Database_s const * source = objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
 	if( NULL!=source )
@@ -2348,12 +2621,12 @@ am_Error_e CAmDatabaseHandlerMap::getSinkVolume(const am_sinkID_t sinkID, am_vol
 		return (E_OK);
 	}
 	volume = -1;
+	logError(__PRETTY_FUNCTION__,"sinkID must be valid");
 	return (E_NON_EXISTENT);
 }
 
 am_Error_e CAmDatabaseHandlerMap::getSourceVolume(const am_sourceID_t sourceID, am_volume_t & volume) const
 {
-    assert(sourceID!=0);
 	am_Source_Database_s const * source = objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
 	if( NULL!=source )
 	{
@@ -2361,12 +2634,12 @@ am_Error_e CAmDatabaseHandlerMap::getSourceVolume(const am_sourceID_t sourceID,
 		return (E_OK);
 	}
 	volume = -1;
+	logError(__PRETTY_FUNCTION__,"sourceID must be valid");
 	return (E_NON_EXISTENT);
 }
 
 am_Error_e CAmDatabaseHandlerMap::getSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomSoundPropertyType_t propertyType, int16_t & value) const
 {
-    assert(sinkID!=0);
 
 	am_Sink_Database_s * pObject = (am_Sink_Database_s *)objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
 	if( NULL!=pObject )
@@ -2385,13 +2658,12 @@ am_Error_e CAmDatabaseHandlerMap::getSinkSoundPropertyValue(const am_sinkID_t si
 		}
 	}
 	value = -1;
+	logError(__PRETTY_FUNCTION__,"sinkID must be valid");
 	return (E_NON_EXISTENT);
 }
 
 am_Error_e CAmDatabaseHandlerMap::getSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomSoundPropertyType_t propertyType, int16_t & value) const
 {
-    assert(sourceID!=0);
-
 	am_Source_Database_s * pObject = (am_Source_Database_s *)objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
 	if( NULL!=pObject )
 	{
@@ -2409,13 +2681,12 @@ am_Error_e CAmDatabaseHandlerMap::getSourceSoundPropertyValue(const am_sourceID_
 		}
 	}
 	value = -1;
+	logError(__PRETTY_FUNCTION__,"sourceID must be valid");
 	return (E_NON_EXISTENT);
 }
 
 am_Error_e CAmDatabaseHandlerMap::getMainSinkSoundPropertyValue(const am_sinkID_t sinkID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const
 {
-    assert(sinkID!=0);
-
 	am_Sink_Database_s * pObject = (am_Sink_Database_s *)objectForKeyIfExistsInMap(sinkID, mMappedData.mSinkMap);
 	if( NULL!=pObject )
 	{
@@ -2433,12 +2704,12 @@ am_Error_e CAmDatabaseHandlerMap::getMainSinkSoundPropertyValue(const am_sinkID_
 		}
 	}
 	value = -1;
+	logError(__PRETTY_FUNCTION__,"sinkID must be valid");
 	return (E_NON_EXISTENT);
 }
 
 am_Error_e CAmDatabaseHandlerMap::getMainSourceSoundPropertyValue(const am_sourceID_t sourceID, const am_CustomMainSoundPropertyType_t propertyType, int16_t& value) const
 {
-    assert(sourceID!=0);
 
 	am_Source_Database_s * pObject = (am_Source_Database_s *)objectForKeyIfExistsInMap(sourceID, mMappedData.mSourceMap);
 	if( NULL!=pObject )
@@ -2458,12 +2729,12 @@ am_Error_e CAmDatabaseHandlerMap::getMainSourceSoundPropertyValue(const am_sourc
 	}
 
 	value = -1;
+	logError(__PRETTY_FUNCTION__,"sourceID must be valid");
 	return (E_NON_EXISTENT);
 }
 
 am_Error_e CAmDatabaseHandlerMap::getDomainState(const am_domainID_t domainID, am_DomainState_e& state) const
 {
-    assert(domainID!=0);
 
     am_Domain_Database_s const * source = objectForKeyIfExistsInMap(domainID, mMappedData.mDomainMap);
 	if( NULL!=source )
@@ -2472,6 +2743,7 @@ am_Error_e CAmDatabaseHandlerMap::getDomainState(const am_domainID_t domainID, a
 		return (E_OK);
 	}
 	state = DS_UNKNOWN;
+	logError(__PRETTY_FUNCTION__,"domainID must be valid");
 	return (E_NON_EXISTENT);
 }
 
@@ -2573,10 +2845,9 @@ am_Error_e CAmDatabaseHandlerMap::peekSource(const std::string & name, am_source
 
 am_Error_e CAmDatabaseHandlerMap::changeSinkVolume(const am_sinkID_t sinkID, const am_volume_t volume)
 {
-    assert(sinkID!=0);
-
     if (!existSink(sinkID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -2586,9 +2857,9 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkVolume(const am_sinkID_t sinkID, con
 
 am_Error_e CAmDatabaseHandlerMap::changeSourceVolume(const am_sourceID_t sourceID, const am_volume_t volume)
 {
-    assert(sourceID!=0);
     if (!existSource(sourceID))
     {
+    	logError(__PRETTY_FUNCTION__,"sourceID must be valid");
         return (E_NON_EXISTENT);
     }
     mMappedData.mSourceMap[sourceID].volume = volume;
@@ -2598,10 +2869,9 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceVolume(const am_sourceID_t sourceI
 
 am_Error_e CAmDatabaseHandlerMap::changeSourceSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sourceID_t sourceID)
 {
-    assert(sourceID!=0);
-
     if (!existSource(sourceID))
     {
+    	logError(__PRETTY_FUNCTION__,"sourceID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -2617,15 +2887,16 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceSoundPropertyDB(const am_SoundProp
 			return (E_OK);
 		}
 	}
+	logError(__PRETTY_FUNCTION__,"sourceID must be valid");
 	return (E_NON_EXISTENT);
 }
 
 am_Error_e CAmDatabaseHandlerMap::changeSinkSoundPropertyDB(const am_SoundProperty_s & soundProperty, const am_sinkID_t sinkID)
 {
-    assert(sinkID!=0);
 
     if (!existSink(sinkID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkID must be valid");
         return (E_NON_EXISTENT);
     }
     am_Sink_Database_s & sink = mMappedData.mSinkMap[sinkID];
@@ -2640,16 +2911,16 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkSoundPropertyDB(const am_SoundProper
  			return (E_OK);
  		}
  	}
+	logError(__PRETTY_FUNCTION__,"sinkID must be valid");
  	return (E_NON_EXISTENT);
 }
 
 am_Error_e CAmDatabaseHandlerMap::changeCrossFaderHotSink(const am_crossfaderID_t crossfaderID, const am_HotSink_e hotsink)
 {
-    assert(crossfaderID!=0);
-    assert(hotsink!=HS_UNKNOWN);
 
     if (!existCrossFader(crossfaderID))
     {
+    	logError(__PRETTY_FUNCTION__,"crossfaderID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -2702,10 +2973,10 @@ am_Error_e am::CAmDatabaseHandlerMap::peekSourceClassID(const std::string & name
 
 am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
 {
-    assert(sourceID!=0);
 
     if (!existSource(sourceID))
     {
+    	logError(__PRETTY_FUNCTION__,"sourceID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -2774,7 +3045,6 @@ am_Error_e CAmDatabaseHandlerMap::changeSourceDB(const am_sourceID_t sourceID, c
 
 am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_SoundProperty_s>& listSoundProperties, const std::vector<am_CustomConnectionFormat_t>& listConnectionFormats, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties)
 {
-    assert(sinkID!=0);
 
     DB_COND_UPDATE_INIT;
     am_sinkClass_t sinkClassOut(sinkClassID);
@@ -2782,6 +3052,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const a
 
     if (!existSink(sinkID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -2844,9 +3115,12 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkDB(const am_sinkID_t sinkID, const a
 
 am_Error_e CAmDatabaseHandlerMap::getListMainSinkNotificationConfigurations(const am_sinkID_t sinkID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations)
 {
-    assert(sinkID!=0);
+
     if (!existSink(sinkID))
-        return (E_DATABASE_ERROR); // todo: here we could change to non existen, but not shown in sequences
+    {
+    	logError(__PRETTY_FUNCTION__,"sinkID must be valid");
+        return (E_DATABASE_ERROR);
+    }
     listMainNotificationConfigurations.clear();
 
     listMainNotificationConfigurations = mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations;
@@ -2856,9 +3130,12 @@ am_Error_e CAmDatabaseHandlerMap::getListMainSinkNotificationConfigurations(cons
 
 am_Error_e CAmDatabaseHandlerMap::getListMainSourceNotificationConfigurations(const am_sourceID_t sourceID, std::vector<am_NotificationConfiguration_s>& listMainNotificationConfigurations)
 {
-    assert(sourceID!=0);
+
     if (!existSource(sourceID))
-        return (E_DATABASE_ERROR); // todo: here we could change to non existen, but not shown in sequences
+    {
+    	logError(__PRETTY_FUNCTION__,"sourceID must be valid");
+        return (E_DATABASE_ERROR);
+    }
 
     listMainNotificationConfigurations = mMappedData.mSourceMap.at(sourceID).listMainNotificationConfigurations;
 
@@ -2886,10 +3163,10 @@ bool changeMainNotificationConfiguration(std::vector<am_NotificationConfiguratio
 
 am_Error_e CAmDatabaseHandlerMap::changeMainSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration)
 {
-    assert(sinkID!=0);
 
     if (!existSink(sinkID))
     {
+    	logError(__PRETTY_FUNCTION__,"sinkID must be valid");
         return (E_NON_EXISTENT);
     }
     if(!changeMainNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listMainNotificationConfigurations, mainNotificationConfiguration))
@@ -2904,10 +3181,10 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSinkNotificationConfigurationDB(cons
 
 am_Error_e CAmDatabaseHandlerMap::changeMainSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration)
 {
-    assert(sourceID!=0);
 
     if (!existSource(sourceID))
     {
+    	logError(__PRETTY_FUNCTION__,"sourceID must be valid");
         return (E_NON_EXISTENT);
     }
 
@@ -2923,10 +3200,10 @@ am_Error_e CAmDatabaseHandlerMap::changeMainSourceNotificationConfigurationDB(co
 
 am_Error_e CAmDatabaseHandlerMap::changeGatewayDB(const am_gatewayID_t gatewayID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFormats, const std::vector<bool>& convertionMatrix)
 {
-    assert(gatewayID!=0);
 
    if (!existGateway(gatewayID))
    {
+	   logError(__PRETTY_FUNCTION__,"gatewayID must be valid");
        return (E_NON_EXISTENT);
    }
 
@@ -2954,10 +3231,10 @@ am_Error_e CAmDatabaseHandlerMap::changeGatewayDB(const am_gatewayID_t gatewayID
 
 am_Error_e CAmDatabaseHandlerMap::changeConverterDB(const am_converterID_t converterID, const std::vector<am_CustomConnectionFormat_t>& listSourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t>& listSinkConnectionFormats, const std::vector<bool>& convertionMatrix)
 {
-    assert(converterID!=0);
 
    if (!existConverter(converterID))
    {
+	   logError(__PRETTY_FUNCTION__,"converterID must be valid");
        return (E_NON_EXISTENT);
    }
 
@@ -3001,10 +3278,10 @@ bool changeNotificationConfiguration(std::vector<am_NotificationConfiguration_s>
 
 am_Error_e CAmDatabaseHandlerMap::changeSinkNotificationConfigurationDB(const am_sinkID_t sinkID, const am_NotificationConfiguration_s notificationConfiguration)
 {
-    assert(sinkID!=0);
 
     if (!existSink(sinkID))
     {
+ 	   logError(__PRETTY_FUNCTION__,"sinkID must be valid");
         return (E_NON_EXISTENT);
     }
     if(!changeNotificationConfiguration(mMappedData.mSinkMap.at(sinkID).listNotificationConfigurations, notificationConfiguration))
@@ -3018,10 +3295,10 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkNotificationConfigurationDB(const am
 
 am_Error_e CAmDatabaseHandlerMap::changeSourceNotificationConfigurationDB(const am_sourceID_t sourceID, const am_NotificationConfiguration_s notificationConfiguration)
 {
-    assert(sourceID!=0);
 
     if (!existSource(sourceID))
     {
+  	   logError(__PRETTY_FUNCTION__,"sourceID must be valid");
         return (E_NON_EXISTENT);
     }
 
diff --git a/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.cpp b/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.cpp
index 0836229..be2203a 100644
--- a/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.cpp
+++ b/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.cpp
@@ -77,6 +77,24 @@ CAmControlInterfaceTest::~CAmControlInterfaceTest()
 void CAmControlInterfaceTest::SetUp()
 {
 
+	::testing::FLAGS_gmock_verbose = "error";
+
+	am_Domain_s domain;
+	pCF.createDomain(domain);
+    am_domainID_t forgetDomain;
+    am_sinkClass_t forgetSinkClassID;
+    am_SinkClass_s sinkClass;
+    sinkClass.name="TestSinkClass";
+    sinkClass.sinkClassID=1;
+    am_sourceClass_t forgetSourceClassID;
+    am_SourceClass_s sourceClass;
+    sourceClass.name="TestSourceClass";
+    sourceClass.sourceClassID=1;
+    domain.domainID=4;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,forgetDomain));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkClassDB(sinkClass,forgetSinkClassID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceClassDB(forgetSourceClassID,sourceClass));
+
 }
 
 void CAmControlInterfaceTest::TearDown()
@@ -173,6 +191,8 @@ TEST_F(CAmControlInterfaceTest,ackConnect)
     am_connectionID_t connectionID;
     am_Sink_s sink;
     am_sinkID_t sinkID;
+    am_Source_s source;
+    am_sourceID_t sourceID;
     am_Domain_s domain;
     am_domainID_t domainID;
     std::vector<am_Connection_s> connectionList;
@@ -180,14 +200,16 @@ TEST_F(CAmControlInterfaceTest,ackConnect)
     am_Handle_s handle;
     pCF.createSink(sink);
     pCF.createDomain(domain);
+    pCF.createSource(source);
     domain.name = "mock";
     domain.busname = "mock";
     sink.sinkID = 2;
-    sink.domainID = DYNAMIC_ID_BOUNDARY;
+    source.sourceID=2;
 
     //prepare the stage
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
     //when asyncConnect is called, we expect a call on the routingInterface
     EXPECT_CALL(pMockRoutingInterface,asyncConnect(_,1,2,2,CF_GENIVI_STEREO)).WillOnce(Return(E_OK));
@@ -231,19 +253,25 @@ TEST_F(CAmControlInterfaceTest,ackDisconnect)
     am_sinkID_t sinkID;
     am_Domain_s domain;
     am_domainID_t domainID;
+    am_Source_s source;
+    am_sourceID_t sourceID;
     std::vector<am_Connection_s> connectionList;
     std::vector<am_Handle_s> handlesList;
     am_Handle_s handle;
     pCF.createSink(sink);
     pCF.createDomain(domain);
+    pCF.createSource(source);
+    domain.domainID=0;
     domain.name = "mock";
     domain.busname = "mock";
     sink.sinkID = 2;
     sink.domainID = DYNAMIC_ID_BOUNDARY;
+    source.sourceID=2;
 
     //prepare the stage
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
     //now we first need to connect, we expect a call on the routing interface
     EXPECT_CALL(pMockRoutingInterface,asyncConnect(_,1,2,2,CF_GENIVI_STEREO)).WillOnce(Return(E_OK));
@@ -285,19 +313,25 @@ TEST_F(CAmControlInterfaceTest,ackDisconnectFailAndRetry)
     am_sinkID_t sinkID;
     am_Domain_s domain;
     am_domainID_t domainID;
+    am_Source_s source;
+    am_sourceID_t sourceID;
     std::vector<am_Connection_s> connectionList;
     std::vector<am_Handle_s> handlesList;
     am_Handle_s handle;
     pCF.createSink(sink);
     pCF.createDomain(domain);
+    pCF.createSource(source);
     domain.name = "mock";
     domain.busname = "mock";
+    domain.domainID=0;
     sink.sinkID = 2;
     sink.domainID = DYNAMIC_ID_BOUNDARY;
+    source.sourceID=2;
 
     //prepare the stage
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
     //now we first need to connect, we expect a call on the routing interface
     EXPECT_CALL(pMockRoutingInterface,asyncConnect(_,1,2,2,CF_GENIVI_STEREO)).WillOnce(Return(E_OK));
@@ -349,6 +383,7 @@ TEST_F(CAmControlInterfaceTest,setSourceState)
     pCF.createDomain(domain);
     domain.name = "mock";
     domain.busname = "mock";
+    domain.domainID=0;
     source.sourceID = 2;
     source.domainID = DYNAMIC_ID_BOUNDARY;
 
@@ -399,6 +434,7 @@ TEST_F(CAmControlInterfaceTest,SetSinkVolumeChange)
     pCF.createDomain(domain);
     domain.name = "mock";
     domain.busname = "mock";
+    domain.domainID=0;
     sink.sinkID = 2;
     sink.domainID = DYNAMIC_ID_BOUNDARY;
     sink.volume = 10;
@@ -450,6 +486,7 @@ TEST_F(CAmControlInterfaceTest,ackSetSourceVolumeChange)
     pCF.createDomain(domain);
     domain.name = "mock";
     domain.busname = "mock";
+    domain.domainID=0;
     source.sourceID = 2;
     source.domainID = DYNAMIC_ID_BOUNDARY;
     source.volume = 12;
@@ -502,6 +539,7 @@ TEST_F(CAmControlInterfaceTest,ackSetSinkSoundProperty)
     pCF.createDomain(domain);
     domain.name = "mock";
     domain.busname = "mock";
+    domain.domainID=0;
     sink.sinkID = 2;
     sink.domainID = DYNAMIC_ID_BOUNDARY;
     soundProperty.type = SP_GENIVI_BASS;
@@ -555,6 +593,7 @@ TEST_F(CAmControlInterfaceTest,ackSetSourceSoundProperty)
     pCF.createDomain(domain);
     domain.name = "mock";
     domain.busname = "mock";
+    domain.domainID=0;
     source.sourceID = 2;
     source.domainID = DYNAMIC_ID_BOUNDARY;
     soundProperty.type = SP_GENIVI_BASS;
@@ -626,19 +665,26 @@ TEST_F(CAmControlInterfaceTest,ackConnectNotPossible)
     am_sinkID_t sinkID;
     am_Domain_s domain;
     am_domainID_t domainID;
+    am_Source_s source;
+    am_sourceClass_t sourceID;
     std::vector<am_Connection_s> connectionList;
     std::vector<am_Handle_s> handlesList;
     am_Handle_s handle;
     pCF.createSink(sink);
     pCF.createDomain(domain);
+    pCF.createSource(source);
+
     domain.name = "mock";
     domain.busname = "mock";
+    domain.domainID=0;
     sink.sinkID = 2;
     sink.domainID = DYNAMIC_ID_BOUNDARY;
+    source.sourceID=2;
 
     //prepare the stage
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
     //when asyncConnect is called, we expect a call on the routingInterface
     EXPECT_CALL(pMockRoutingInterface,asyncConnect(_,1,2,2,CF_GENIVI_STEREO)).WillOnce(Return(E_COMMUNICATION));
diff --git a/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.cpp b/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
index dd61b7c..9557b6f 100644
--- a/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
+++ b/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
@@ -72,6 +72,7 @@ void CAmMapBasicTest::createMainConnectionSetup(am_mainConnectionID_t & mainConn
     am_Connection_s connection;
     am_Source_s source;
     am_Sink_s sink;
+    am_Domain_s domain;
     std::vector<am_connectionID_t> connectionList;
 
     //we create 9 sources and sinks:
@@ -85,11 +86,10 @@ void CAmMapBasicTest::createMainConnectionSetup(am_mainConnectionID_t & mainConn
         pCF.createSink(sink);
         sink.sinkID = i;
         sink.name = "sink" + int2string(i);
-        sink.domainID = 4;
         pCF.createSource(source);
         source.sourceID = i;
         source.name = "source" + int2string(i);
-        source.domainID = 4;
+
 
         connection.sinkID = i;
         connection.sourceID = i;
@@ -136,6 +136,22 @@ void CAmMapBasicTest::createMainConnectionSetup(am_mainConnectionID_t & mainConn
 void CAmMapBasicTest::SetUp()
 {
 	::testing::FLAGS_gmock_verbose = "error";
+
+	am_Domain_s domain;
+	pCF.createDomain(domain);
+    am_domainID_t forgetDomain;
+    am_sinkClass_t forgetSinkClassID;
+    am_SinkClass_s sinkClass;
+    sinkClass.name="TestSinkClass";
+    sinkClass.sinkClassID=1;
+    am_sourceClass_t forgetSourceClassID;
+    am_SourceClass_s sourceClass;
+    sourceClass.name="TestSourceClass";
+    sourceClass.sourceClassID=1;
+    domain.domainID=4;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,forgetDomain));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkClassDB(sinkClass,forgetSinkClassID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceClassDB(forgetSourceClassID,sourceClass));
 }
 
 void CAmMapBasicTest::TearDown()
@@ -182,7 +198,7 @@ TEST_F(CAmMapHandlerTest,getSinkInfo)
     am_sinkID_t staticSinkID, firstDynamicSinkID, secondDynamicSinkID;
     std::vector<am_Sink_s> sinkList;
 
-    pCF.createSink(staticSink);
+   pCF.createSink(staticSink);
     staticSink.sinkID = 4;
 
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
@@ -688,8 +704,20 @@ TEST_F(CAmMapHandlerTest,changeConnectionTimingInformation)
 {
     am_Connection_s connection;
     am_connectionID_t connectionID;
+    am_Source_s source;
+    am_Sink_s sink;
+    am_sourceID_t sourceid;
+    am_sinkID_t sinkid;
     std::vector<am_Connection_s> connectionList;
     pCF.createConnection(connection);
+    pCF.createSink(sink);
+    pCF.createSource(source);
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkid));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceid));
+
+    connection.sinkID=sinkid;
+    connection.sourceID=sourceid;
 
     //enter a connection
     ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
@@ -723,12 +751,12 @@ TEST_F(CAmMapHandlerTest,getSinkClassOfSink)
     sink.sinkClassID = 4;
 
     //prepare test
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
 
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 
     //enter a new sinkclass, read out again and check
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
     ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
     ASSERT_EQ(sinkClassList[0].sinkClassID, 4);
@@ -756,17 +784,17 @@ TEST_F(CAmMapHandlerTest,getSourceClassOfSource)
     classProperty.value = 4;
     classPropertyList.push_back(classProperty);
     sourceClass.name = "test";
-    sourceClass.sourceClassID = 1;
+    sourceClass.sourceClassID = 8;
     sourceClass.listClassProperties = classPropertyList;
     pCF.createSource(source);
+    source.sourceClassID=8;
 
-
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
     ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
-    ASSERT_EQ(sourceClassList[0].sourceClassID, 1);
+    ASSERT_EQ(sourceClassList[0].sourceClassID, source.sourceClassID);
     ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
     ASSERT_EQ(E_OK, pDatabaseHandler.getSourceClassInfoDB(sourceID,sinkSourceClass));
     ASSERT_EQ(sourceClassList[0].name, sinkSourceClass.name);
@@ -798,6 +826,7 @@ TEST_F(CAmMapHandlerTest,removeSourceClass)
     ASSERT_EQ(sourceClassList[0].sourceClassID, 3);
     ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
     ASSERT_EQ(E_OK, pDatabaseHandler.removeSourceClassDB(3));
+    ASSERT_EQ(E_OK, pDatabaseHandler.removeSourceClassDB(1));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
     ASSERT_TRUE(sourceClassList.empty());
 }
@@ -909,6 +938,7 @@ TEST_F(CAmMapHandlerTest,removeSinkClass)
     ASSERT_EQ(sinkClassList[0].sinkClassID, DYNAMIC_ID_BOUNDARY);
     ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
     ASSERT_EQ(E_OK, pDatabaseHandler.removeSinkClassDB(sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.removeSinkClassDB(1));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
     ASSERT_TRUE(sinkClassList.empty());
 }
@@ -1235,7 +1265,7 @@ TEST_F(CAmMapHandlerTest, peekDomain)
     pCF.createDomain(domain);
     ASSERT_EQ(E_OK, pDatabaseHandler.peekDomain(std::string("newdomain"),domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
-    ASSERT_TRUE(listDomains.empty());
+    ASSERT_FALSE(listDomains.empty());
     ASSERT_EQ(domainID, DYNAMIC_ID_BOUNDARY);
     domain.name = "newdomain";
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
@@ -1267,7 +1297,7 @@ TEST_F(CAmMapHandlerTest, changeDomainState)
     pCF.createDomain(domain);
     am_DomainState_e newState = DS_INDEPENDENT_STARTUP;
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
-    ASSERT_EQ(E_OK, pDatabaseHandler.changDomainStateDB(newState,domainID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.changeDomainStateDB(newState,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
     ASSERT_EQ(newState, listDomains[0].state);
 }
@@ -1486,7 +1516,7 @@ TEST_F(CAmMapHandlerTest,getVisibleMainConnections)
 TEST_F(CAmMapHandlerTest,getListSourcesOfDomain)
 {
     am_Source_s source, source2;
-    am_Domain_s domain;
+    am_Domain_s domain,domain1;
     am_domainID_t domainID;
     am_sourceID_t sourceID;
     std::vector<am_sourceID_t> sourceList, sourceCheckList;
@@ -1497,8 +1527,10 @@ TEST_F(CAmMapHandlerTest,getListSourcesOfDomain)
     pCF.createSource(source2);
     source2.sourceID = 0;
     source2.name = "testSource2";
-    source2.domainID = 5;
+    source2.domainID = 4;
     pCF.createDomain(domain);
+    domain.domainID=0;
+    domain.name="dynDomain";
     sourceCheckList.push_back(1); //sink.sinkID);
 
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
@@ -1524,9 +1556,11 @@ TEST_F(CAmMapHandlerTest,getListSinksOfDomain)
     sink.sinkID = 1;
     sink.domainID = DYNAMIC_ID_BOUNDARY;
     pCF.createSink(sink2);
-    sink2.domainID = 5;
+    sink2.domainID = 4;
     sink2.name = "sink2";
     pCF.createDomain(domain);
+    domain.domainID=0;
+    domain.name="dyndomain";
     sinkCheckList.push_back(1); //sink.sinkID);
 
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
@@ -1546,20 +1580,48 @@ TEST_F(CAmMapHandlerTest,getListGatewaysOfDomain)
     am_Gateway_s gateway, gateway2;
     am_gatewayID_t gatewayID1, gatewayID2;
     am_domainID_t domainID;
+    am_sinkID_t sinkID;
+    am_sourceID_t sourceID;
     am_Domain_s domain;
+    am_Sink_s sink;
+    am_Source_s source;
     std::vector<am_gatewayID_t> gatewayList, gatewayCheckList;
 
     pCF.createDomain(domain);
+    domain.domainID=0;
+    domain.name="dyndomain";
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+    pCF.createSink(sink);
+    pCF.createSource(source);
+    source.sourceID=20;
+    sink.sinkID=30;
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
+
+    am_Sink_s sink1;
+    am_Source_s source1;
+    am_sinkID_t sinkID1;
+    am_sourceID_t sourceID1;
+    pCF.createSink(sink1);
+    sink1.sinkID=32;
+    sink1.name="bla";
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink1,sinkID1));
+    sink.sinkID = sinkID1;
+
+    pCF.createSource(source1);
+    source1.name="blubb";
+    source1.sourceID=56;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source1,sourceID1));
+    source.sourceID = sourceID1;
 
     pCF.createGateway(gateway);
     gateway.gatewayID = 1;
     gateway.name = "testGateway";
     gateway.controlDomainID = domainID;
-    gateway.sourceID = 1;
-    gateway.sinkID = 1;
-    gateway.domainSinkID = 1;
-    gateway.domainSourceID = 1;
+    gateway.sourceID = source.sourceID;
+    gateway.sinkID = sink.sinkID;
+    gateway.domainSinkID = 4;
+    gateway.domainSourceID = 4;
     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID1))
         << "ERROR: database error";
     ASSERT_EQ(true, gatewayID1==1);
@@ -1568,26 +1630,15 @@ TEST_F(CAmMapHandlerTest,getListGatewaysOfDomain)
     gateway2.gatewayID = 2;
     gateway2.name = "testGateway2";
     gateway2.controlDomainID = 4;
-    gateway2.sourceID = 1;
-    gateway2.sinkID = 1;
-    gateway2.domainSinkID = 1;
-    gateway2.domainSourceID = 1;
+    gateway2.sourceID = source1.sourceID;
+    gateway2.sinkID = sink1.sinkID;
+    gateway2.domainSinkID = 4;
+    gateway2.domainSourceID = 4;
     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2))
         << "ERROR: database error";
     ASSERT_EQ(true, gatewayID2==2);
     gatewayCheckList.push_back(gatewayID1);
 
-    am_Sink_s sink;
-    am_Source_s source;
-    am_sinkID_t sinkID;
-    am_sourceID_t sourceID;
-    pCF.createSink(sink);
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
-    sink.sinkID = sinkID;
-
-    pCF.createSource(source);
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
-    source.sourceID = sourceID;
 
     ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListGatewaysOfDomain(2,gatewayList))
         << "ERROR: database error";
@@ -1606,24 +1657,37 @@ TEST_F(CAmMapHandlerTest,getListConvertersOfDomain)
     std::vector<am_converterID_t> converterList, converterCheckList;
 
     pCF.createDomain(domain);
+    domain.domainID=6;
+    domain.name="sdfsd";
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 
+    am_sinkID_t sinkID1;
+    am_sourceID_t sourceID1;
+    am_Sink_s sink1;
+    am_Source_s source1;
+    pCF.createSink(sink1);
+    pCF.createSource(source1);
+    source1.sourceID=20;
+    sink1.sinkID=30;
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink1,sinkID1));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source1,sourceID1));
+
     pCF.createConverter(converter);
     converter.converterID = 1;
-    converter.name = "testGateway";
-    converter.sourceID = 1;
-    converter.sinkID = 1;
-    converter.domainID = domainID;
+    converter.name = "testConverter";
+    converter.sourceID = 20;
+    converter.sinkID = 30;
+    converter.domainID = 4;
     ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(converter,converterID1))
         << "ERROR: database error";
     ASSERT_EQ(true, converterID1==1);
 
     pCF.createConverter(converter2);
     converter2.converterID = 2;
-    converter2.name = "testGateway2";
-    converter2.domainID = 4;
-    converter2.sourceID = 1;
-    converter2.sinkID = 1;
+    converter2.name = "testConverter2";
+    converter2.domainID = 6;
+    converter2.sourceID = 20;
+    converter2.sinkID = 30;
     ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(converter2,converterID2))
         << "ERROR: database error";
     ASSERT_EQ(true, converterID2==2);
@@ -1634,17 +1698,21 @@ TEST_F(CAmMapHandlerTest,getListConvertersOfDomain)
     am_sinkID_t sinkID;
     am_sourceID_t sourceID;
     pCF.createSink(sink);
+    sink.sinkID=4;
+    sink.name="ere";
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     sink.sinkID = sinkID;
 
     pCF.createSource(source);
+    source.sourceID=2;
+    source.name="ere2";
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     source.sourceID = sourceID;
 
-    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListConvertersOfDomain(4,converterList))
+    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListConvertersOfDomain(8,converterList))
         << "ERROR: database error";
     ASSERT_TRUE(converterList.empty());
-    ASSERT_EQ(E_OK,pDatabaseHandler.getListConvertersOfDomain(domainID,converterList))
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListConvertersOfDomain(4,converterList))
         << "ERROR: database error";
     ASSERT_TRUE(std::equal(converterList.begin(),converterList.end(),converterCheckList.begin()) && !converterList.empty());
 }
@@ -1678,6 +1746,7 @@ TEST_F(CAmMapHandlerTest,removeGateway)
     pCF.createSource(source);
     sink.sinkID = 1;
     source.sourceID = 2;
+
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
@@ -2143,8 +2212,21 @@ TEST_F(CAmMapHandlerTest,registerConnectionCorrect)
     std::vector<am_Connection_s> returnList;
     pCF.createConnection(connection);
 
+    am_Sink_s sink;
+    am_Source_s source;
+    am_sinkID_t sinkID;
+    am_sourceID_t sourceID;
+    pCF.createSink(sink);
+    sink.sinkID=connection.sinkID;
+    pCF.createSource(source);
+    source.sourceID=connection.sourceID;
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
+
+
+
     ASSERT_EQ(E_OK,pDatabaseHandler.enterConnectionDB(connection,connectionID))
-        << "ERROR: database error";;
+        << "ERROR: database error";
     ASSERT_NE(0,connectionID)
         << "ERROR: connectionID zero";
 
@@ -2508,13 +2590,16 @@ TEST_F(CAmMapHandlerTest, peekDomain_2)
     am_domainID_t domainID;
     am_domainID_t domain2ID;
     pCF.createDomain(domain);
+    am_Domain_s domain2;
+    pCF.createDomain(domain2);
+    domain2.domainID=0;
     ASSERT_EQ(E_OK,pDatabaseHandler.peekDomain(std::string("newdomain"),domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
-    ASSERT_TRUE(listDomains.empty());
+    ASSERT_TRUE(listDomains.size()==1);
     ASSERT_EQ(domainID, DYNAMIC_ID_BOUNDARY);
 
-    domain.name = "anotherdomain";
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
+    domain2.name = "anotherdomain";
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domain2ID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
     ASSERT_EQ(domain2ID, DYNAMIC_ID_BOUNDARY+1);
 
@@ -2574,6 +2659,12 @@ TEST_F(CAmMapHandlerTest, connectionIDBoundary)
 	ASSERT_EQ(10, connectionID);
 	connection.sinkID = 77;
 	connection.sourceID = 77;
+	sink.sinkID=77;
+	sink.name="77";
+	source.sourceID=77;
+	source.name="77";
+	ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, forgetSink));
+	ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source, forgetSource));
 	ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
 	ASSERT_EQ(12, connectionID);
 	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterConnectionDB(connection,connectionID));
@@ -2626,6 +2717,8 @@ TEST_F(CAmMapHandlerTest, mainConnectionIDBoundary)
 	mainConnection.mainConnectionID = 0;
 	mainConnection.connectionState = CS_CONNECTED;
 	mainConnection.delay = -1;
+	mainConnection.sinkID=2;
+	mainConnection.sourceID=1;
 
 	for (uint16_t i = 1; i < TEST_MAX_MAINCONNECTION_ID; i++)
 	{
@@ -2640,6 +2733,12 @@ TEST_F(CAmMapHandlerTest, mainConnectionIDBoundary)
 	ASSERT_EQ(10, mainConnectionID);
 	mainConnection.sinkID = 77;
 	mainConnection.sourceID = 77;
+	sink.sinkID=77;
+	sink.name="77";
+	source.sourceID=77;
+	source.name="77";
+	ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, forgetSink));
+	ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source, forgetSource));
 	ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
 	ASSERT_EQ(12, mainConnectionID);
 	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
@@ -2699,10 +2798,11 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, peek_enter_removeDomain)
     pCF.createDomain(domain);
     ASSERT_EQ(E_OK,pDatabaseHandler.peekDomain(std::string("newdomain"), domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
-    ASSERT_TRUE(listDomains.empty());
+    ASSERT_TRUE(listDomains.size()==1);
     ASSERT_EQ(domainID, DYNAMIC_ID_BOUNDARY);
 
     domain.name = "anotherdomain";
+    domain.domainID=0;
     const am_Domain_s expDomain1 = {DYNAMIC_ID_BOUNDARY+1, domain.name, domain.busname, domain.nodename, domain.early, domain.complete, domain.state};
     EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain(IsDomainDataEqualTo(expDomain1))).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
@@ -2869,7 +2969,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, peekSourceClassID)
     ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.peekSourceClassID(sourceName,sourceClassID));
 
     //now we enter the class into the database
-    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(13);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
 
     //first we peek without an existing class
@@ -2893,7 +2993,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, peekSinkClassID)
     ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.peekSinkClassID(sinkName,sinkClassID));
 
     //now we enter the class into the database
-    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(12);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
 
     //first we peek without an existing class
diff --git a/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp b/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp
index 46b2d41..a99f7d8 100644
--- a/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp
+++ b/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp
@@ -63,6 +63,21 @@ CAmRouterMapTest::~CAmRouterMapTest()
 void CAmRouterMapTest::SetUp()
 {
 	logInfo("Routing Test started ");
+	am_Domain_s domain;
+	pCF.createDomain(domain);
+    am_domainID_t forgetDomain;
+    am_sinkClass_t forgetSinkClassID;
+    am_SinkClass_s sinkClass;
+    sinkClass.name="TestSinkClass";
+    sinkClass.sinkClassID=1;
+    am_sourceClass_t forgetSourceClassID;
+    am_SourceClass_s sourceClass;
+    sourceClass.name="TestSourceClass";
+    sourceClass.sourceClassID=1;
+    domain.domainID=4;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,forgetDomain));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkClassDB(sinkClass,forgetSinkClassID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceClassDB(forgetSourceClassID,sourceClass));
 }
 
 void CAmRouterMapTest::TearDown()
@@ -236,6 +251,10 @@ TEST_F(CAmRouterMapTest,simpleRoute2withDomainNoMatchFormats)
 
     am_Source_s source;
     am_sourceID_t sourceID;
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -244,10 +263,15 @@ TEST_F(CAmRouterMapTest,simpleRoute2withDomainNoMatchFormats)
     source.sourceClassID = 5;
     source.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
     am_Sink_s sink;
     am_sinkID_t sinkID;
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
 
     sink.domainID = domainID1;
     sink.name = "sink1";
@@ -256,6 +280,7 @@ TEST_F(CAmRouterMapTest,simpleRoute2withDomainNoMatchFormats)
     sink.muteState = MS_MUTED;
     sink.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 
     std::vector<am_Route_s> listRoutes;
@@ -301,6 +326,10 @@ TEST_F(CAmRouterMapTest,simpleRoute2withDomain)
 
     am_Source_s source;
     am_sourceID_t sourceID;
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -309,10 +338,15 @@ TEST_F(CAmRouterMapTest,simpleRoute2withDomain)
     source.sourceClassID = 5;
     source.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
     am_Sink_s sink;
     am_sinkID_t sinkID;
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
 
     sink.domainID = domainID1;
     sink.name = "sink1";
@@ -321,6 +355,7 @@ TEST_F(CAmRouterMapTest,simpleRoute2withDomain)
     sink.muteState = MS_MUTED;
     sink.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 
     std::vector<am_Route_s> listRoutes;
@@ -372,6 +407,10 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFree)
 
     am_Source_s source, gwSource;
     am_sourceID_t sourceID, gwSourceID;
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -387,11 +426,15 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFree)
     gwSource.sourceClassID = 5;
     gwSource.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
 
     am_Sink_s sink, gwSink;
     am_sinkID_t sinkID, gwSinkID;
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
 
     sink.domainID = domainID2;
     sink.name = "sink1";
@@ -407,6 +450,7 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFree)
     gwSink.muteState = MS_MUTED;
     gwSink.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
 
@@ -483,6 +527,10 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFreeNotFree)
 
     am_Source_s source, gwSource;
     am_sourceID_t sourceID, gwSourceID;
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -498,11 +546,16 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFreeNotFree)
     gwSource.sourceClassID = 5;
     gwSource.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
 
     am_Sink_s sink, gwSink;
     am_sinkID_t sinkID, gwSinkID;
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
 
     sink.domainID = domainID2;
     sink.name = "sink1";
@@ -518,6 +571,7 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFreeNotFree)
     gwSink.muteState = MS_MUTED;
     gwSink.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
 
@@ -611,6 +665,10 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsCircularGWOnlyFree)
 
     am_Source_s source, gwSource, gwSource2;
     am_sourceID_t sourceID, gwSourceID, gwSourceID2;
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -633,12 +691,16 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsCircularGWOnlyFree)
     gwSource2.sourceClassID = 5;
     gwSource2.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource2,gwSourceID2));
 
     am_Sink_s sink, gwSink, gwSink2;
     am_sinkID_t sinkID, gwSinkID, gwSinkID2;
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
 
     sink.domainID = domainID2;
     sink.name = "sink1";
@@ -661,6 +723,7 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsCircularGWOnlyFree)
     gwSink2.muteState = MS_MUTED;
     gwSink2.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink2,gwSinkID2));
@@ -754,6 +817,11 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_2)
 
     am_Source_s source, gwSource, gwSource1;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1;
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -780,6 +848,7 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_2)
     gwSource1.listConnectionFormats.push_back(CF_GENIVI_STEREO);
     gwSource1.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource1,gwSourceID1));
@@ -793,6 +862,9 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_2)
     sink.sinkClassID = 5;
     sink.muteState = MS_MUTED;
     sink.listConnectionFormats.push_back(CF_GENIVI_MONO);
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
 
     gwSink.domainID = domainID1;
     gwSink.name = "gwSink";
@@ -810,6 +882,7 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_2)
     gwSink1.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
     gwSink1.listConnectionFormats.push_back(CF_GENIVI_STEREO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink1,gwSinkID1));
@@ -925,6 +998,10 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_1)
     source.sourceClassID = 5;
     source.listConnectionFormats.push_back(CF_GENIVI_STEREO);
     source.listConnectionFormats.push_back(CF_GENIVI_MONO);
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     gwSource.domainID = domainID2;
     gwSource.name = "gwsource1";
@@ -942,12 +1019,16 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_1)
     gwSource1.sourceClassID = 5;
     gwSource1.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource1,gwSourceID1));
 
     am_Sink_s sink, gwSink, gwSink1;
     am_sinkID_t sinkID, gwSinkID, gwSinkID1;
+    am_SinkClass_s sinkclass;
+	sinkclass.sinkClassID=5;
+	sinkclass.name="sname";
 
     sink.domainID = domainID3;
     sink.name = "sink1";
@@ -971,6 +1052,7 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_1)
     gwSink1.muteState = MS_MUTED;
     gwSink1.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink1,gwSinkID1));
@@ -1076,6 +1158,10 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats)
 
     am_Source_s source, gwSource, gwSource1;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1;
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -1099,6 +1185,7 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats)
     gwSource1.sourceClassID = 5;
     gwSource1.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource1,gwSourceID1));
@@ -1106,6 +1193,10 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats)
     am_Sink_s sink, gwSink, gwSink1;
     am_sinkID_t sinkID, gwSinkID, gwSinkID1;
 
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
     sink.domainID = domainID3;
     sink.name = "sink1";
     sink.sinkID = 0;
@@ -1128,6 +1219,7 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats)
     gwSink1.muteState = MS_MUTED;
     gwSink1.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink1,gwSinkID1));
@@ -1234,6 +1326,10 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains2Routes)
 
     am_Source_s source, gwSource, gwSource1, gwSource2, gwSource3;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1, gwSourceID2, gwSourceID3;
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -1270,6 +1366,7 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains2Routes)
     gwSource3.sourceClassID = 5;
     gwSource3.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource1,gwSourceID1));
@@ -1313,7 +1410,11 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains2Routes)
     sink.sinkClassID = 5;
     sink.muteState = MS_MUTED;
     sink.listConnectionFormats.push_back(CF_GENIVI_STEREO);
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink1,gwSinkID1));
@@ -1482,6 +1583,10 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsNoConnection)
     source.sourceID = 0;
     source.sourceClassID = 5;
     source.listConnectionFormats.push_back(CF_GENIVI_MONO);
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     gwSource.domainID = domainID2;
     gwSource.name = "gwsource1";
@@ -1497,6 +1602,7 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsNoConnection)
     gwSource1.sourceClassID = 5;
     gwSource1.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource1,gwSourceID1));
@@ -1510,6 +1616,9 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsNoConnection)
     sink.sinkClassID = 5;
     sink.muteState = MS_MUTED;
     sink.listConnectionFormats.push_back(CF_GENIVI_STEREO);
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
 
     gwSink.domainID = domainID1;
     gwSink.name = "gwSink";
@@ -1525,6 +1634,7 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsNoConnection)
     gwSink1.muteState = MS_MUTED;
     gwSink1.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink1,gwSinkID1));
@@ -1625,6 +1735,10 @@ TEST_F(CAmRouterMapTest,simpleRoute2Domains)
     source.sourceID = 0;
     source.sourceClassID = 5;
     source.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     gwSource.domainID = domainID2;
     gwSource.name = "gwsource1";
@@ -1633,11 +1747,16 @@ TEST_F(CAmRouterMapTest,simpleRoute2Domains)
     gwSource.sourceClassID = 5;
     gwSource.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
 
     am_Sink_s sink, gwSink;
     am_sinkID_t sinkID, gwSinkID;
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
 
     sink.domainID = domainID2;
     sink.name = "sink1";
@@ -1653,6 +1772,8 @@ TEST_F(CAmRouterMapTest,simpleRoute2Domains)
     gwSink.muteState = MS_MUTED;
     gwSink.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
 
@@ -1734,6 +1855,10 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsNoMatchConnectionFormats)
     source.sourceID = 0;
     source.sourceClassID = 5;
     source.listConnectionFormats.push_back(CF_GENIVI_STEREO);
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     gwSource.domainID = domainID2;
     gwSource.name = "gwsource1";
@@ -1742,11 +1867,15 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsNoMatchConnectionFormats)
     gwSource.sourceClassID = 5;
     gwSource.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
 
     am_Sink_s sink, gwSink;
     am_sinkID_t sinkID, gwSinkID;
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
 
     sink.domainID = domainID2;
     sink.name = "sink1";
@@ -1762,6 +1891,7 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsNoMatchConnectionFormats)
     gwSink.muteState = MS_MUTED;
     gwSink.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
 
@@ -1819,6 +1949,10 @@ TEST_F(CAmRouterMapTest,simpleRoute3Domains)
 
     am_Source_s source, gwSource, gwSource1;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1;
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -1841,12 +1975,17 @@ TEST_F(CAmRouterMapTest,simpleRoute3Domains)
     gwSource1.sourceClassID = 5;
     gwSource1.listConnectionFormats.push_back(CF_GENIVI_MONO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource1,gwSourceID1));
 
     am_Sink_s sink, gwSink, gwSink1;
     am_sinkID_t sinkID, gwSinkID, gwSinkID1;
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
 
     sink.domainID = domainID3;
     sink.name = "sink1";
@@ -1869,6 +2008,7 @@ TEST_F(CAmRouterMapTest,simpleRoute3Domains)
     gwSink1.muteState = MS_MUTED;
     gwSink1.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink1,gwSinkID1));
@@ -1974,6 +2114,10 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains)
 
     am_Source_s source, gwSource, gwSource1, gwSource2;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1, gwSourceID2;
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -2003,6 +2147,7 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains)
     gwSource2.sourceClassID = 5;
     gwSource2.listConnectionFormats.push_back(CF_GENIVI_STEREO);
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(source.sourceClassID,sourceclass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource,gwSourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource1,gwSourceID1));
@@ -2038,7 +2183,11 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains)
     sink.sinkClassID = 5;
     sink.muteState = MS_MUTED;
     sink.listConnectionFormats.push_back(CF_GENIVI_STEREO);
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink,gwSinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink1,gwSinkID1));
@@ -2212,12 +2361,21 @@ TEST_F(CAmRouterMapTest,route1Domain1Source1Sink)
 	std::vector<am_CustomConnectionFormat_t> cf1;
 	cf1.push_back(CF_GENIVI_STEREO);
 	cf1.push_back(CF_GENIVI_ANALOG);
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
 	enterSourceDB("source1", domainID1, cf1, sourceID);
 
 	am_sinkID_t sinkID;
 	std::vector<am_CustomConnectionFormat_t> cf2;
 	cf2.push_back(CF_GENIVI_ANALOG);
 	cf2.push_back(CF_GENIVI_MONO);
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
 	enterSinkDB("sink1", domainID1, cf2, sinkID);
 
     am::am_Source_s source;
@@ -2258,12 +2416,24 @@ TEST_F(CAmRouterMapTest,route1Domain1Source1Converter1Sink)
 	std::vector<am_CustomConnectionFormat_t> cf1;
 	cf1.push_back(CF_GENIVI_STEREO);
 	cf1.push_back(CF_GENIVI_AUTO);
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
 	enterSourceDB("source1", domainID1, cf1, sourceID);
 
 	am_sinkID_t sinkID1, sinkID2;
 	std::vector<am_CustomConnectionFormat_t> cf2;
 	cf2.push_back(CF_GENIVI_MONO);
 	cf2.push_back(CF_GENIVI_ANALOG);
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
 	enterSinkDB("sink1", domainID1, cf2, sinkID1);
 	enterSinkDB("sink2", domainID1, cf2, sinkID2);
 
@@ -2324,6 +2494,20 @@ TEST_F(CAmRouterMapTest,route1Domain1Source3Converters1Sink)
 {
 	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+
 	am_domainID_t domainID1;
 	enterDomainDB("domain1", domainID1);
 
@@ -2431,6 +2615,20 @@ TEST_F(CAmRouterMapTest,route2Domains1Source1Sink)
 {
 	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+
 	am_domainID_t domainID1, domainID2;
 	enterDomainDB("domain1", domainID1);
 	enterDomainDB("domain2", domainID2);
@@ -2482,6 +2680,20 @@ TEST_F(CAmRouterMapTest,route3Domains1Source1Sink)
 {
 	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+
 	am_domainID_t domainID1, domainID2, domainID3;
 	enterDomainDB("domain1", domainID1);
 	enterDomainDB("domain2", domainID2);
@@ -2545,6 +2757,20 @@ TEST_F(CAmRouterMapTest,routeSource1Sink2PathThroughConv1Gate1)
 {
 	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+
 	std::vector<bool> matrix;
 	matrix.push_back(true);
 	am_domainID_t domainID1, domainID2;
@@ -2616,6 +2842,20 @@ TEST_F(CAmRouterMapTest, routeSource1Sink1PathThroughDomain2)
 {
 	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+
 	std::vector<bool> matrix;
 	matrix.push_back(true);
 	am_domainID_t domainID1, domainID2;
@@ -2681,6 +2921,20 @@ TEST_F(CAmRouterMapTest, routeSource1Sink1PathThroughGate1Conv2Gate2)
 {
 	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+
 	std::vector<bool> matrix;
 	matrix.push_back(true);
 	am_domainID_t domainID1, domainID2;
@@ -2760,6 +3014,20 @@ TEST_F(CAmRouterMapTest, routeSource1Sink1PathThroughConv1Gate1Conv2Gate2)
 {
 	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+
 	std::vector<bool> matrix;
 	matrix.push_back(true);
 	am_domainID_t domainID1, domainID2;
@@ -2870,6 +3138,20 @@ TEST_F(CAmRouterMapTest,route3Domains1Source1SinkGwCycles)
 {
 	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+
 	am_domainID_t domain1ID, domain2ID, domain3ID;
 	enterDomainDB("domain1", domain1ID);
 	enterDomainDB("domain2", domain2ID);
@@ -3038,6 +3320,20 @@ TEST_F(CAmRouterMapTest,route3Domains1Source3Gateways3Convertres1Sink)
 {
 	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+
 	am_domainID_t domainID1, domainID2, domainID3;
 	enterDomainDB("domain1", domainID1);
 	enterDomainDB("domain2", domainID2);
diff --git a/AudioManagerCore/test/AmRouterMapTest/CMakeLists.txt~ b/AudioManagerCore/test/AmRouterMapTest/CMakeLists.txt~
deleted file mode 100644
index ec79082..0000000
--- a/AudioManagerCore/test/AmRouterMapTest/CMakeLists.txt~
+++ /dev/null
@@ -1,47 +0,0 @@
-# Copyright (C) 2012, BMW AG
-#
-# This file is part of GENIVI Project AudioManager.
-# 
-# Contributions are licensed to the GENIVI Alliance under one or more
-# Contribution License Agreements.
-# 
-# copyright
-# This Source Code Form is subject to the terms of the
-# Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
-# this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# 
-# author Christian Linke, christian.linke@bmw.de BMW 2011,2012
-#
-# For further information see http://www.genivi.org/.
-#
-
-cmake_minimum_required(VERSION 3.0)
-
-project (AmRouterMapTest LANGUAGES CXX VERSION ${DAEMONVERSION})
-
-INCLUDE_DIRECTORIES(   
-    ${AUDIOMANAGER_CORE_INCLUDE} 
-    ${GMOCK_INCLUDE_DIR}
-    ${GTEST_INCLUDE_DIRS})
-
-file(GLOB ROUTINGMAP_SRCS_CXX 
-     "../CAmCommonFunctions.cpp" 
-    "*.cpp"
-    )
-    
-ADD_EXECUTABLE( AmRouterMapTest ${ROUTINGMAP_SRCS_CXX})
-
-TARGET_LINK_LIBRARIES(AmRouterMapTest 
-        ${GTEST_LIBRARIES}
-	${GMOCK_LIBRARIES}
-    	AudioManagerCore
-)
-
-ADD_DEPENDENCIES(AmRouterMapTest AudioManagerCore)
-
-INSTALL(TARGETS AmRouterMapTest 
-        DESTINATION ${TEST_EXECUTABLE_INSTALL_PATH}
-        PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ
-        COMPONENT tests
-)
-
diff --git a/AudioManagerCore/test/AmRouterTest/CAmRouterTest.cpp b/AudioManagerCore/test/AmRouterTest/CAmRouterTest.cpp
index 5f59777..28a5a72 100644
--- a/AudioManagerCore/test/AmRouterTest/CAmRouterTest.cpp
+++ b/AudioManagerCore/test/AmRouterTest/CAmRouterTest.cpp
@@ -60,6 +60,21 @@ CAmRouterTest::~CAmRouterTest()
 void CAmRouterTest::SetUp()
 {
     logInfo("Routing Test started ");
+	am_Domain_s domain;
+	pCF.createDomain(domain);
+    am_domainID_t forgetDomain;
+    am_sinkClass_t forgetSinkClassID;
+    am_SinkClass_s sinkClass;
+    sinkClass.name="TestSinkClass";
+    sinkClass.sinkClassID=5;
+    am_sourceClass_t forgetSourceClassID;
+    am_SourceClass_s sourceClass;
+    sourceClass.name="TestSourceClass";
+    sourceClass.sourceClassID=5;
+    domain.domainID=4;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,forgetDomain));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkClassDB(sinkClass,forgetSinkClassID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceClassDB(forgetSourceClassID,sourceClass));
 }
 
 void CAmRouterTest::TearDown()
diff --git a/AudioManagerCore/test/AmRouterTest/CMakeLists.txt~ b/AudioManagerCore/test/AmRouterTest/CMakeLists.txt~
deleted file mode 100644
index 32e1206..0000000
--- a/AudioManagerCore/test/AmRouterTest/CMakeLists.txt~
+++ /dev/null
@@ -1,47 +0,0 @@
-# Copyright (C) 2012, BMW AG
-#
-# This file is part of GENIVI Project AudioManager.
-# 
-# Contributions are licensed to the GENIVI Alliance under one or more
-# Contribution License Agreements.
-# 
-# copyright
-# This Source Code Form is subject to the terms of the
-# Mozilla Public License, v. 2.0. if a  copy of the MPL was not distributed with
-# this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-# 
-# author Christian Linke, christian.linke@bmw.de BMW 2011,2012
-#
-# For further information see http://www.genivi.org/.
-#
-
-cmake_minimum_required(VERSION 3.0)
-
-project(AmRouterTest LANGUAGES CXX VERSION ${DAEMONVERSION})
-
-INCLUDE_DIRECTORIES(   
-    ${AUDIOMANAGER_CORE_INCLUDE} 
-    ${GMOCK_INCLUDE_DIR})
-
-
-file(GLOB ROUTING_SRCS_CXX 
-    "../CAmCommonFunctions.cpp" 
-    "*.cpp"
-    )
-    
-ADD_EXECUTABLE( AmRouterTest ${ROUTING_SRCS_CXX})
-
-TARGET_LINK_LIBRARIES(AmRouterTest 
-        ${GTEST_LIBRARIES}
-	${GMOCK_LIBRARIES}
-    	AudioManagerCore
-)
-
-ADD_DEPENDENCIES(AmRouterTest AudioManagerCore)
-
-INSTALL(TARGETS AmRouterTest 
-        DESTINATION ${TEST_EXECUTABLE_INSTALL_PATH}
-        PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ
-        COMPONENT tests
-)
-
diff --git a/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.cpp b/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.cpp
index 916ff77..69cf90a 100644
--- a/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.cpp
+++ b/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.cpp
@@ -57,6 +57,24 @@ CAmRoutingInterfaceTest::~CAmRoutingInterfaceTest()
 void CAmRoutingInterfaceTest::SetUp()
 {
     logInfo("RoutingSendInterface Test started ");
+	am_Domain_s domain;
+	pCF.createDomain(domain);
+	domain.domainID=0;
+	domain.busname="mock";
+    am_domainID_t forgetDomain;
+    am_sinkClass_t forgetSinkClassID;
+    am_SinkClass_s sinkClass;
+    sinkClass.name="TestSinkClass";
+    sinkClass.sinkClassID=1;
+    am_sourceClass_t forgetSourceClassID;
+    am_SourceClass_s sourceClass;
+    sourceClass.name="TestSourceClass";
+    sourceClass.sourceClassID=1;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,forgetDomain));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkClassDB(sinkClass,forgetSinkClassID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceClassDB(forgetSourceClassID,sourceClass));
+    ASSERT_EQ(E_OK,pRoutingSender.addDomainLookup(domain));
+
 
 }
 
@@ -73,16 +91,26 @@ TEST_F(CAmRoutingInterfaceTest,abort)
     am_Handle_s handle;
     am_connectionID_t connectionID;
     std::vector<am_Handle_s> listHandles;
+    am_Source_s source;
+    pCF.createSource(source);
+    source.sourceID=1;
+    source.domainID=DYNAMIC_ID_BOUNDARY;
+    source.name="sds";
+
+
+
     pCF.createSink(sink);
     pCF.createDomain(domain);
     domain.name = "mock";
     domain.busname = "mock";
+    domain.domainID=0;
     sink.sinkID = 2;
     sink.domainID = DYNAMIC_ID_BOUNDARY;
 
     //prepare the stage
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source.sourceID));
 
     //start a connect, expect a call on the routingInterface
     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_GENIVI_ANALOG)).WillOnce(Return(E_OK));
@@ -127,8 +155,28 @@ TEST_F(CAmRoutingInterfaceTest,alreadyConnected)
     domain.busname = "mock";
     sink.sinkID = 2;
     sink.domainID = DYNAMIC_ID_BOUNDARY;
+
+
+    am_SourceClass_s sourceclass;
+
+    sourceclass.name="sClass";
+    sourceclass.sourceClassID=5;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+
+    am_SinkClass_s sinkclass;
+    sinkclass.sinkClassID=5;
+    sinkclass.name="sname";
+
+    am_Source_s source;
+    pCF.createSource(source);
+    source.sourceID=1;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source.sourceID));
     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_GENIVI_ANALOG)).WillOnce(Return(E_OK));
     am_Handle_s handle;
     am_connectionID_t connectionID;
@@ -314,8 +362,15 @@ TEST_F(CAmRoutingInterfaceTest,connect)
     domain.busname = "mock";
     sink.sinkID = 2;
     sink.domainID = DYNAMIC_ID_BOUNDARY;
+
+    am_Source_s source;
+    pCF.createSource(source);
+    source.sourceID=1;
+    source.domainID=DYNAMIC_ID_BOUNDARY;
+
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source.sourceID));
     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_GENIVI_ANALOG)).WillOnce(Return(E_OK));
     ASSERT_EQ(E_OK, pControlReceiver.connect(handle,connectionID,CF_GENIVI_ANALOG,1,2));
     ASSERT_NE(handle.handle, 0);
@@ -340,8 +395,16 @@ TEST_F(CAmRoutingInterfaceTest,disconnect)
     domain.busname = "mock";
     sink.sinkID = 2;
     sink.domainID = DYNAMIC_ID_BOUNDARY;
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+
+    am_Source_s source;
+     pCF.createSource(source);
+     source.sourceID=1;
+     source.domainID=DYNAMIC_ID_BOUNDARY;
+
+     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source.sourceID));
+
     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_GENIVI_ANALOG)).WillOnce(Return(E_OK));
     ASSERT_EQ(E_OK, pControlReceiver.connect(handle,connectionID,CF_GENIVI_ANALOG,1,2));
     ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
diff --git a/AudioManagerCore/test/CAmCommonFunctions.cpp b/AudioManagerCore/test/CAmCommonFunctions.cpp
index 22331d4..d1f0594 100644
--- a/AudioManagerCore/test/CAmCommonFunctions.cpp
+++ b/AudioManagerCore/test/CAmCommonFunctions.cpp
@@ -292,7 +292,7 @@ void CAmCommonFunctions::createSource(am_Source_s& source) const
 void CAmCommonFunctions::createDomain(am_Domain_s & domain) const
 {
 
-    domain.domainID = 0;
+    domain.domainID = 4;
     domain.name = "AnyDomain";
     domain.nodename = "AnyNode";
     domain.busname = "AnyBusname";
@@ -306,8 +306,8 @@ void CAmCommonFunctions::createGateway(am_Gateway_s & gateway)
     gateway.name = "AnyGateway";
     gateway.sinkID = 1;
     gateway.sourceID = 2;
-    gateway.controlDomainID = 1;
-    gateway.domainSinkID = 3;
+    gateway.controlDomainID = 4;
+    gateway.domainSinkID = 4;
     gateway.domainSourceID = 4;
     gateway.convertionMatrix = getStandardConvertionMatrix();
     gateway.listSourceFormats = getStandardConnectionFormatList();
@@ -321,7 +321,7 @@ void CAmCommonFunctions::createConverter(am_Converter_s & converter) const
 	converter.name = "AnyConverter";
 	converter.sinkID = 1;
 	converter.sourceID = 2;
-	converter.domainID = 1;
+	converter.domainID = 4;
 	converter.convertionMatrix = getStandardConvertionMatrix();
 	converter.listSourceFormats = getStandardConnectionFormatList();
 	converter.listSinkFormats = getStandardConnectionFormatList();