Merge pull request #14 from GENIVI/Router_adaptions

after phoneconference merged
author: GENIVI Audio Manager Maintainer <genivi-maint-audiomanager@smtp1.genivi.org> 2017-03-07 10:44:54 +0100
committer: GitHub <noreply@github.com> 2017-03-07 10:44:54 +0100
commit: 71eab93f9cd67b2e0343700552adf988c420f174 (patch)
tree: 9f08492872ce7de767f66535178bd0575b72a5b7 /AudioManagerCore/test
parent: 41b1249b1fc3b211dd56333bdc01f7eb8977f674 (diff)
parent: ff7a091bd6500413853f381d14be55de2e3affa3 (diff)
download: audiomanager-71eab93f9cd67b2e0343700552adf988c420f174.tar.gz
14 files changed, 2131 insertions, 1581 deletions
diff --git a/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.cpp b/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.cpp
index 9c09deb..27ed2b6 100644
--- a/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.cpp
+++ b/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.cpp
@@ -51,7 +51,7 @@ CAmControlInterfaceTest::CAmControlInterfaceTest() :
         plistRoutingPluginDirs(), //
         pDatabaseHandler(), //
         pRoutingSender(plistRoutingPluginDirs,dynamic_cast<IAmDatabaseHandler*>( &pDatabaseHandler )), //RoutingReceiver
-        pCommandSender(plistCommandPluginDirs), //
+        pCommandSender(plistCommandPluginDirs, &pSocketHandler), //
         pMockControlInterface(), //
         pMockRoutingInterface(), //
         pRoutingInterfaceBackdoor(), //
@@ -59,11 +59,11 @@ CAmControlInterfaceTest::CAmControlInterfaceTest() :
         pControlInterfaceBackdoor(), //
         pControlSender(), //
         pRouter(&pDatabaseHandler,&pControlSender), //
-        pDatabaseObserver(&pCommandSender, &pRoutingSender, &pSocketHandler), //
         pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender, &pSocketHandler, &pRouter), //
         pRoutingReceiver(&pDatabaseHandler, &pRoutingSender, &pControlSender, &pSocketHandler)
 {
-    pDatabaseHandler.registerObserver(&pDatabaseObserver);
+    pDatabaseHandler.registerObserver(&pRoutingSender);
+    pDatabaseHandler.registerObserver(&pCommandSender);
     pControlInterfaceBackdoor.replaceController(&pControlSender, &pMockControlInterface);
     pRoutingInterfaceBackdoor.injectInterface(&pRoutingSender, &pMockRoutingInterface, "mock");
 
diff --git a/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.h b/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.h
index 3e645fb..9ebcec7 100644
--- a/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.h
+++ b/AudioManagerCore/test/AmControlInterfaceTest/CAmControlInterfaceTest.h
@@ -26,11 +26,9 @@
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
 
-//#include "CAmDatabaseHandlerSQLite.h"
 #include "CAmDatabaseHandlerMap.h"
 #include "CAmControlReceiver.h"
 #include "CAmRoutingReceiver.h"
-#include "CAmDatabaseObserver.h"
 #include "CAmControlSender.h"
 #include "CAmRoutingSender.h"
 #include "CAmRouter.h"
@@ -65,7 +63,6 @@ public:
     IAmControlBackdoor pControlInterfaceBackdoor;
     CAmControlSender pControlSender;
     CAmRouter pRouter;
-    CAmDatabaseObserver pDatabaseObserver;
     CAmControlReceiver pControlReceiver;
     CAmRoutingReceiver pRoutingReceiver;
     CAmCommonFunctions pCF;
diff --git a/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.cpp b/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
index 559764d..fe2f68a 100644
--- a/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
+++ b/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
@@ -47,18 +47,18 @@ TCLAP::SwitchArg enableDebug ("V","logDlt","print DLT logs to stdout or dlt-daem
 
 
 CAmMapBasicTest::CAmMapBasicTest() :
+                pDatabaseHandler(), //
                 plistRoutingPluginDirs(), //
                 plistCommandPluginDirs(), //
-                pSocketHandler(),//
-                pDatabaseHandler(), //
+                pSocketHandler(),//                
                 pRoutingSender(plistRoutingPluginDirs,dynamic_cast<IAmDatabaseHandler*>( &pDatabaseHandler )), //
-                pCommandSender(plistCommandPluginDirs), //
+                pCommandSender(plistCommandPluginDirs, &pSocketHandler), //
                 pRoutingInterfaceBackdoor(), //
                 pCommandInterfaceBackdoor(), //
                 pControlSender(), //
                 pRouter(&pDatabaseHandler, &pControlSender), //
                 pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender,  &pSocketHandler, &pRouter), //
-				pCF()
+		pCF()
 {
 }
 
@@ -96,7 +96,8 @@ void CAmMapBasicTest::createMainConnectionSetup(am_mainConnectionID_t & mainConn
         connection.delay = -1;
         connection.connectionFormat = CF_GENIVI_ANALOG;
         connection.connectionID = 0;
-
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
         ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,forgetSink));
         ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,forgetSource));
         ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
@@ -114,6 +115,9 @@ void CAmMapBasicTest::createMainConnectionSetup(am_mainConnectionID_t & mainConn
     mainConnection.delay = -1;
 
     //enter mainconnection in database
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newMainConnection(_)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(_, _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(_, _)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
     ASSERT_NE(0, mainConnectionID);
 
@@ -135,10 +139,8 @@ void CAmMapBasicTest::createMainConnectionSetup(am_mainConnectionID_t & mainConn
 
 void CAmMapBasicTest::SetUp()
 {
-	::testing::FLAGS_gmock_verbose = "error";
-
-	am_Domain_s domain;
-	pCF.createDomain(domain);
+    am_Domain_s domain;
+    pCF.createDomain(domain);
     am_domainID_t forgetDomain;
     am_sinkClass_t forgetSinkClassID;
     am_SinkClass_s sinkClass;
@@ -149,6 +151,9 @@ void CAmMapBasicTest::SetUp()
     sourceClass.name="TestSourceClass";
     sourceClass.sourceClassID=1;
     domain.domainID=4;
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain(_)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(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));
@@ -156,16 +161,16 @@ void CAmMapBasicTest::SetUp()
 
 void CAmMapBasicTest::TearDown()
 {
-	::testing::FLAGS_gmock_verbose = "warning";
+    Mock::VerifyAndClearExpectations(MockDatabaseObserver::getMockObserverObject());
 }
 
 
 
 CAmMapHandlerTest::CAmMapHandlerTest() :
         pMockInterface(), //
-        pObserver(&pCommandSender,&pRoutingSender, &pSocketHandler)
+        mMockObserver()
 {
-    pDatabaseHandler.registerObserver(&pObserver);
+    pDatabaseHandler.registerObserver(&mMockObserver);
     pDatabaseHandler.setConnectionIDRange(1, TEST_MAX_CONNECTION_ID);
     pDatabaseHandler.setMainConnectionIDRange(1, TEST_MAX_MAINCONNECTION_ID);
     pDatabaseHandler.setSinkIDRange(DYNAMIC_ID_BOUNDARY, DYNAMIC_ID_BOUNDARY+TEST_MAX_SINK_ID);
@@ -174,6 +179,7 @@ CAmMapHandlerTest::CAmMapHandlerTest() :
 
 CAmMapHandlerTest::~CAmMapHandlerTest()
 {
+    pDatabaseHandler.unregisterObserver(&mMockObserver);
 }
 
 TEST_F(CAmMapHandlerTest,getMainConnectionInfo)
@@ -200,7 +206,8 @@ TEST_F(CAmMapHandlerTest,getSinkInfo)
 
    pCF.createSink(staticSink);
     staticSink.sinkID = 4;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(3);
+    
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
         << "ERROR: database error";
     ASSERT_EQ(staticSink.sinkID,staticSinkID)
@@ -270,7 +277,8 @@ TEST_F(CAmMapHandlerTest,getSourceInfo)
     staticSource.sourceID = 4;
     staticSource.name = "Static";
 
-
+     EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(3);
+     
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
         << "ERROR: database error";
     ASSERT_EQ(staticSource.sourceID,staticSourceID)
@@ -344,7 +352,7 @@ TEST_F(CAmMapHandlerTest, peekSourceID)
     sourceClass.name = sourceName;
     sourceClass.sourceClassID = 0;
     sourceClass.listClassProperties.push_back(classProperty);
-
+     EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(1);
     //first we peek without an existing class
     ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.peekSourceClassID(sourceName,sourceClassID));
 
@@ -368,7 +376,7 @@ TEST_F(CAmMapHandlerTest, peekSinkID)
     sinkClass.name = sinkName;
     sinkClass.sinkClassID = 0;
     sinkClass.listClassProperties.push_back(classProperty);
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(1);
     //first we peek without an existing class
     ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.peekSinkClassID(sinkName,sinkClassID));
 
@@ -392,7 +400,9 @@ TEST_F(CAmMapHandlerTest,crossfaders)
     pCF.createSink(sinkB);
     sinkB.name = "sinkB";
     pCF.createSource(source);
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(2);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newCrossfader(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkA,sinkAID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkB,sinkBID));
@@ -419,9 +429,6 @@ TEST_F(CAmMapHandlerTest,crossfaders)
 
 TEST_F(CAmMapHandlerTest,crossfadersGetFromDomain)
 {
-
-
-
     am_Crossfader_s crossfader;
     am_crossfaderID_t crossfaderID;
     am_Sink_s sinkA, sinkB;
@@ -435,6 +442,12 @@ TEST_F(CAmMapHandlerTest,crossfadersGetFromDomain)
     pCF.createDomain(domain);
     sinkB.name = "sinkB";
     pCF.createSource(source);
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain(_)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(2);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newCrossfader(_)).Times(1);
+    
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     source.domainID = domainID;
     sinkA.domainID = domainID;
@@ -469,7 +482,7 @@ TEST_F(CAmMapHandlerTest,sourceState)
     source.sourceState = SS_OFF;
 
     //prepare the test
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
     //change the source state
@@ -489,7 +502,7 @@ TEST_F(CAmMapHandlerTest,sourceInterruptState)
     source.interruptState = IS_OFF;
 
     //prepare the test
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
     //change the source interrupt state
@@ -509,7 +522,7 @@ TEST_F(CAmMapHandlerTest,sinkVolumeChange)
     sink.volume = 23;
 
     //prepare the test
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 
     //change the volume and check the read out
@@ -527,7 +540,7 @@ TEST_F(CAmMapHandlerTest,sourceVolumeChange)
     source.volume = 23;
 
     //prepare test
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
     //change the volume and check the read out
@@ -543,9 +556,8 @@ TEST_F(CAmMapHandlerTest, peekSource)
     am_sourceID_t sourceID, source2ID, source3ID;
     am_Source_s source;
     pCF.createSource(source);
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
     //peek a source that does not exits
-
     ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(std::string("newsource"),sourceID));
 
     //make sure it is not in the list
@@ -591,7 +603,7 @@ TEST_F(CAmMapHandlerTest, peekSourceDouble)
     pCF.createSource(source);
 
     //peek a source that does not exits
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(std::string("newsource"),sourceID));
 
     //peek a second source that does not exits
@@ -626,7 +638,7 @@ TEST_F(CAmMapHandlerTest, peekSink)
     pCF.createSink(sink);
 
     //peek a sink that does not exits
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(std::string("newsink"),sinkID));
 
     //make sure it is not in the list
@@ -668,7 +680,7 @@ TEST_F(CAmMapHandlerTest, peekSinkDouble)
     pCF.createSink(sink);
 
     //peek a sink that does not exits
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(std::string("newsink"),sinkID));
 
     //peek again
@@ -712,6 +724,7 @@ TEST_F(CAmMapHandlerTest,changeConnectionTimingInformationCheckMainConnection)
     std::vector<am_Connection_s>::iterator iteratorConnectionList = connectionList.begin();
     for (; iteratorConnectionList < connectionList.end(); ++iteratorConnectionList)
     {
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(_,_)).Times(1);
         ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionTimingInformation(iteratorConnectionList->connectionID,24));
     }
 
@@ -732,7 +745,10 @@ TEST_F(CAmMapHandlerTest,changeConnectionTimingInformation)
     pCF.createConnection(connection);
     pCF.createSink(sink);
     pCF.createSource(source);
-
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
+    
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkid));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceid));
 
@@ -769,7 +785,8 @@ TEST_F(CAmMapHandlerTest,getSinkClassOfSink)
     sinkClass.listClassProperties = classPropertyList;
     pCF.createSink(sink);
     sink.sinkClassID = 4;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1);
     //prepare test
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
 
@@ -808,7 +825,9 @@ TEST_F(CAmMapHandlerTest,getSourceClassOfSource)
     sourceClass.listClassProperties = classPropertyList;
     pCF.createSource(source);
     source.sourceClassID=8;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
+    
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
@@ -838,7 +857,7 @@ TEST_F(CAmMapHandlerTest,removeSourceClass)
     sourceClass.name = "test";
     sourceClass.sourceClassID = 3;
     sourceClass.listClassProperties = classPropertyList;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(3);
 
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
@@ -870,7 +889,7 @@ TEST_F(CAmMapHandlerTest,updateSourceClass)
     changedClass = sourceClass;
     changedClass.listClassProperties[1].value = 6;
     changedPropertyList = changedClass.listClassProperties;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
     changedClass.sourceClassID = sourceClassID;
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
@@ -901,7 +920,7 @@ TEST_F(CAmMapHandlerTest,enterSourceClass)
     sourceClass.sourceClassID = 0;
     sourceClass.listClassProperties = classPropertyList;
 
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
     ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
@@ -926,7 +945,7 @@ TEST_F(CAmMapHandlerTest,enterSourceClassStatic)
     sourceClass.sourceClassID = 3;
     sourceClass.listClassProperties = classPropertyList;
 
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
     ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
@@ -950,7 +969,7 @@ TEST_F(CAmMapHandlerTest,removeSinkClass)
     sinkClass.name = "test";
     sinkClass.sinkClassID = 0;
     sinkClass.listClassProperties = classPropertyList;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(3);
 
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
@@ -982,7 +1001,7 @@ TEST_F(CAmMapHandlerTest,updateSinkClass)
     changedClass = sinkClass;
     changedClass.listClassProperties[1].value = 6;
     changedPropertyList = changedClass.listClassProperties;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
     changedClass.sinkClassID = sinkClassID;
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
@@ -1012,7 +1031,7 @@ TEST_F(CAmMapHandlerTest,enterSinkClass)
     sinkClass.name = "test";
     sinkClass.sinkClassID = 0;
     sinkClass.listClassProperties = classPropertyList;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(1);
 
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
@@ -1038,7 +1057,7 @@ TEST_F(CAmMapHandlerTest,enterSinkClassStatic)
     sinkClass.sinkClassID = 4;
     sinkClass.listClassProperties = classPropertyList;
 
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
     ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
@@ -1054,6 +1073,7 @@ TEST_F(CAmMapHandlerTest, changeSystemProperty)
     systemProperty.type = SYP_UNKNOWN;
     systemProperty.value = 33;
     listSystemProperties.push_back(systemProperty);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), systemPropertyChanged(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSystemProperties(listSystemProperties));
     systemProperty.value = 444;
     ASSERT_EQ(E_OK, pDatabaseHandler.changeSystemPropertyDB(systemProperty));
@@ -1088,7 +1108,7 @@ TEST_F(CAmMapHandlerTest,enterSourcesCorrect)
     staticSource.sourceID = 4;
     staticSource.name = "Static";
 
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(3);
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
         << "ERROR: database error";
     ASSERT_EQ(staticSource.sourceID,staticSourceID)
@@ -1142,6 +1162,8 @@ TEST_F(CAmMapHandlerTest, changeSinkMuteState)
     am_sinkID_t sinkID;
     pCF.createSink(sink);
     am_MuteState_e muteState = MS_MUTED;
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkMuteStateChanged(_, _)).Times(1);
 
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 
@@ -1159,6 +1181,8 @@ TEST_F(CAmMapHandlerTest, changeSourceMainSoundProperty)
     am_MainSoundProperty_s property;
     property.type = MSP_UNKNOWN;
     property.value = 33;
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainSourceSoundPropertyChanged(_, _)).Times(2);
 
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
@@ -1191,7 +1215,8 @@ TEST_F(CAmMapHandlerTest, changeSinkMainSoundProperty)
     property.type = MSP_UNKNOWN;
     property.value = 33;
 
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainSinkSoundPropertyChanged(_, _)).Times(2);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 
     ASSERT_EQ(E_OK, pDatabaseHandler.changeMainSinkSoundPropertyDB(property,sinkID));
@@ -1222,7 +1247,7 @@ TEST_F(CAmMapHandlerTest, changeSourceSoundProperty)
     am_SoundProperty_s property;
     property.type = SP_GENIVI_MID;
     property.value = 33;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 
     ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceSoundPropertyDB(property,sourceID));
@@ -1254,7 +1279,7 @@ TEST_F(CAmMapHandlerTest, changeSinkSoundProperty)
     property.type = SP_GENIVI_MID;
     property.value = 33;
 
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 
     ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkSoundPropertyDB(property,sinkID));
@@ -1283,6 +1308,7 @@ TEST_F(CAmMapHandlerTest, peekDomain)
     am_domainID_t domainID;
     am_domainID_t domain2ID;
     pCF.createDomain(domain);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.peekDomain(std::string("newdomain"),domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
     ASSERT_FALSE(listDomains.empty());
@@ -1302,6 +1328,7 @@ TEST_F(CAmMapHandlerTest, peekDomainFirstEntered)
     am_domainID_t domain2ID;
     pCF.createDomain(domain);
     domain.name = "newdomain";
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.peekDomain(std::string("newdomain"),domain2ID));
     ASSERT_EQ(domainID, domain2ID);
@@ -1316,6 +1343,7 @@ TEST_F(CAmMapHandlerTest, changeDomainState)
     am_domainID_t domainID;
     pCF.createDomain(domain);
     am_DomainState_e newState = DS_INDEPENDENT_STARTUP;
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain(_)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.changeDomainStateDB(newState,domainID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
@@ -1328,7 +1356,7 @@ TEST_F(CAmMapHandlerTest, changeMainConnectionState)
     am_MainConnection_s mainConnection;
     std::vector<am_MainConnection_s> listMainConnections;
     createMainConnectionSetup(mainConnectionID, mainConnection);
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(_, _)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.changeMainConnectionStateDB(1,CS_DISCONNECTING));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(listMainConnections));
     ASSERT_EQ(CS_DISCONNECTING, listMainConnections[0].connectionState);
@@ -1343,7 +1371,8 @@ TEST_F(CAmMapHandlerTest, changeSinkAvailability)
     am_Availability_s availability;
     availability.availability = A_UNKNOWN;
     availability.availabilityReason = AR_GENIVI_TEMPERATURE;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkAvailabilityChanged(_, _)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkAvailabilityDB(availability,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
@@ -1361,7 +1390,8 @@ TEST_F(CAmMapHandlerTest, changeSourceAvailability)
     availability.availability = A_UNKNOWN;
     availability.availabilityReason = AR_GENIVI_TEMPERATURE;
     source.visible = true;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceAvailabilityChanged(_, _)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceAvailabilityDB(availability,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
@@ -1376,7 +1406,7 @@ TEST_F(CAmMapHandlerTest,changeMainConnectionRoute)
     std::vector<am_MainConnection_s> originalList;
     std::vector<am_MainConnection_s> newList;
     createMainConnectionSetup(mainConnectionID, mainConnection);
-
+    
     //fill the connection database
     am_Connection_s connection;
     am_Source_s source;
@@ -1405,12 +1435,15 @@ TEST_F(CAmMapHandlerTest,changeMainConnectionRoute)
         source.name = "source" + int2string(i + 30);
         source.domainID = 4;
 
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+        
         ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,forgetSink));
         ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,forgetSource));
         ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
         listConnectionID.push_back(connectionID);
     }
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(_, _)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(originalList));
     ASSERT_EQ(E_OK, pDatabaseHandler.changeMainConnectionRouteDB(mainConnectionID,listConnectionID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(newList));
@@ -1424,7 +1457,8 @@ TEST_F(CAmMapHandlerTest,changeMainSinkVolume)
     am_mainVolume_t newVol = 20;
     std::vector<am_Sink_s> listSinks;
     pCF.createSink(sink);
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), volumeChanged(_, _)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMainVolumeDB(newVol,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
@@ -1438,7 +1472,7 @@ TEST_F(CAmMapHandlerTest,getMainSourceSoundProperties)
     pCF.createSource(source);
     std::vector<am_MainSoundProperty_s> mainSoundProperties = source.listMainSoundProperties;
     std::vector<am_MainSoundProperty_s> listMainSoundProperties;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSourceSoundProperties(sourceID,listMainSoundProperties));
     ASSERT_TRUE(std::equal(mainSoundProperties.begin(),mainSoundProperties.end(),listMainSoundProperties.begin(),equalMainSoundProperty));
@@ -1451,7 +1485,7 @@ TEST_F(CAmMapHandlerTest,getMainSinkSoundProperties)
     pCF.createSink(sink);
     std::vector<am_MainSoundProperty_s> mainSoundProperties = sink.listMainSoundProperties;
     std::vector<am_MainSoundProperty_s> listMainSoundProperties;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSinkSoundProperties(sinkID,listMainSoundProperties));
     ASSERT_TRUE(std::equal(mainSoundProperties.begin(),mainSoundProperties.end(),listMainSoundProperties.begin(),equalMainSoundProperty));
@@ -1470,7 +1504,7 @@ TEST_F(CAmMapHandlerTest,getMainSources)
     source1.visible = false;
     std::vector<am_SourceType_s> listMainSources;
     std::vector<am_Source_s> listSources;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(3);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     source.sourceID = sourceID;
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source1,sourceID));
@@ -1499,7 +1533,7 @@ TEST_F(CAmMapHandlerTest,getMainSinks)
     sink1.visible = false;
     std::vector<am_SinkType_s> listMainSinks;
     std::vector<am_Sink_s> listSinks;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(3);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     sink.sinkID = sinkID;
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink1,sinkID));
@@ -1521,7 +1555,7 @@ TEST_F(CAmMapHandlerTest,getVisibleMainConnections)
     am_mainConnectionID_t mainConnectionID;
     am_MainConnection_s mainConnection;
     createMainConnectionSetup(mainConnectionID, mainConnection);
-
+    
     std::vector<am_MainConnectionType_s> listVisibleMainConnections;
     std::vector<am_MainConnection_s> listMainConnections;
     ASSERT_EQ(E_OK, pDatabaseHandler.getListVisibleMainConnections(listVisibleMainConnections));
@@ -1552,7 +1586,8 @@ TEST_F(CAmMapHandlerTest,getListSourcesOfDomain)
     domain.domainID=0;
     domain.name="dynDomain";
     sourceCheckList.push_back(1); //sink.sinkID);
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(2);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID))
         << "ERROR: database error";
@@ -1582,6 +1617,8 @@ TEST_F(CAmMapHandlerTest,getListSinksOfDomain)
     domain.domainID=0;
     domain.name="dyndomain";
     sinkCheckList.push_back(1); //sink.sinkID);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(2);
 
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID))
@@ -1606,7 +1643,10 @@ TEST_F(CAmMapHandlerTest,getListGatewaysOfDomain)
     am_Sink_s sink;
     am_Source_s source;
     std::vector<am_gatewayID_t> gatewayList, gatewayCheckList;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(2);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(2);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newGateway( _)).Times(2);
     pCF.createDomain(domain);
     domain.domainID=0;
     domain.name="dyndomain";
@@ -1679,6 +1719,12 @@ TEST_F(CAmMapHandlerTest,getListConvertersOfDomain)
     pCF.createDomain(domain);
     domain.domainID=6;
     domain.name="sdfsd";
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(2);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(2);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newConverter( _)).Times(2);
+    
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 
     am_sinkID_t sinkID1;
@@ -1743,6 +1789,10 @@ TEST_F(CAmMapHandlerTest,removeDomain)
     am_domainID_t domainID;
     std::vector<am_Domain_s> listDomains;
     pCF.createDomain(domain);
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removeDomain( _)).Times(1);
+    
     ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID))
         << "ERROR: database error";
     ASSERT_EQ(E_OK,pDatabaseHandler.removeDomainDB(domainID))
@@ -1766,6 +1816,11 @@ TEST_F(CAmMapHandlerTest,removeGateway)
     pCF.createSource(source);
     sink.sinkID = 1;
     source.sourceID = 2;
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newGateway( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removeGateway( _)).Times(1);
 
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
@@ -1792,6 +1847,12 @@ TEST_F(CAmMapHandlerTest,removeConverter)
     pCF.createSource(source);
     sink.sinkID = 1;
     source.sourceID = 2;
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newConverter( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removeConverter( _)).Times(1);
+    
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(converter,converterID))
@@ -1810,6 +1871,9 @@ TEST_F(CAmMapHandlerTest,removeSink)
     std::vector<am_Sink_s> listSinks;
     pCF.createSink(sink);
 
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedSink(_, _)).Times(1);
+    
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID))
         << "ERROR: database error";
     ASSERT_EQ(E_OK,pDatabaseHandler.removeSinkDB(sinkID))
@@ -1826,7 +1890,10 @@ TEST_F(CAmMapHandlerTest,removeSource)
     am_sourceID_t sourceID;
     std::vector<am_Source_s> listSources;
     pCF.createSource(source);
-
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedSource(_, _)).Times(1);
+    
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID))
         << "ERROR: database error";
     ASSERT_EQ(E_OK,pDatabaseHandler.removeSourceDB(sourceID))
@@ -1841,7 +1908,8 @@ TEST_F(CAmMapHandlerTest, removeMainConnection)
     am_mainConnectionID_t mainConnectionID;
     am_MainConnection_s mainConnection;
     createMainConnectionSetup(mainConnectionID, mainConnection);
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedMainConnection(_)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(_, _)).Times(1);
     ASSERT_EQ(E_OK,pDatabaseHandler.removeMainConnectionDB(mainConnectionID))
         << "ERROR: database error";
 }
@@ -1895,6 +1963,11 @@ TEST_F(CAmMapHandlerTest,registerGatewayCorrect)
     pCF.createSource(source);
     sink.sinkID = 1;
     source.sourceID = 2;
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newGateway( _)).Times(3);
+    
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
@@ -1954,6 +2027,11 @@ TEST_F(CAmMapHandlerTest,registerConverterCorrect)
     pCF.createSource(source);
     sink.sinkID = 1;
     source.sourceID = 2;
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newConverter( _)).Times(3);
+    
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway,gatewayID))
@@ -2015,6 +2093,11 @@ TEST_F(CAmMapHandlerTest,getGatewayInfo)
     pCF.createSource(source);
     sink.sinkID = 1;
     source.sourceID = 2;
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newGateway( _)).Times(3);    
+    
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
@@ -2079,6 +2162,9 @@ TEST_F(CAmMapHandlerTest,getConverterInfo)
     pCF.createSource(source);
     sink.sinkID = 1;
     source.sourceID = 2;
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newConverter( _)).Times(3);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway,gatewayID))
@@ -2133,8 +2219,8 @@ TEST_F(CAmMapHandlerTest,enterSinkThatAlreadyExistFail)
     pCF.createSink(staticSink);
     staticSink.sinkID = 43;
     staticSink.name = "Static";
-
-
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
         << "ERROR: database error";
     ASSERT_EQ(staticSink.sinkID,staticSinkID)
@@ -2156,6 +2242,7 @@ TEST_F(CAmMapHandlerTest,enterSourcesThatAlreadyExistFail)
     pCF.createSource(staticSource);
     staticSource.sourceID = 4;
 
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
 
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
         << "ERROR: database error";
@@ -2176,6 +2263,8 @@ TEST_F(CAmMapHandlerTest,registerDomainCorrect)
     am_Domain_s domain;
     am_domainID_t domainID = 0;
     pCF.createDomain(domain);
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain( _)).Times(1);
 
     ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID))
         << "ERROR: database error";
@@ -2204,6 +2293,7 @@ TEST_F(CAmMapHandlerTest,registerDomainPredefined)
     am_domainID_t domainID = 10;
     pCF.createDomain(domain);
 
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain( _)).Times(1);
     ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID))
         << "ERROR: database error";
     ASSERT_NE(10,domainID)
@@ -2240,11 +2330,14 @@ TEST_F(CAmMapHandlerTest,registerConnectionCorrect)
     sink.sinkID=connection.sinkID;
     pCF.createSource(source);
     source.sourceID=connection.sourceID;
+    
+    
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    
     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";
     ASSERT_NE(0,connectionID)
@@ -2283,6 +2376,7 @@ TEST_F(CAmMapHandlerTest,enterSinksCorrect)
     pCF.createSink(staticSink);
     staticSink.sinkID = 4;
 
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(3);
 
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
         << "ERROR: database error";
@@ -2341,6 +2435,7 @@ TEST_F(CAmMapHandlerTest,enterNotificationConfigurationCorrect)
     notify.status=NS_CHANGE;
     notify.parameter=25;
     testSinkData.listNotificationConfigurations.push_back(notify);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
 
     //enter the sink in the database
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
@@ -2377,6 +2472,7 @@ TEST_F(CAmMapHandlerTest,enterMainNotificationConfigurationCorrect)
     notify.parameter=25;
 
     testSinkData.listMainNotificationConfigurations.push_back(notify);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
 
     //enter the sink in the database
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
@@ -2405,8 +2501,10 @@ TEST_F(CAmMapHandlerTest,removeNotificationsSink)
     notify.parameter=25;
 
     testSinkData.listMainNotificationConfigurations.push_back(notify);
-
-    //enter the sink in the database
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedSink(_, _)).Times(1);
+ 
+        //enter the sink in the database
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
         << "ERROR: database error";
 
@@ -2437,6 +2535,9 @@ TEST_F(CAmMapHandlerTest,removeNotificationsSource)
 
     testSourceData.listMainNotificationConfigurations.push_back(notify);
 
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedSource(_, _)).Times(1);
+
     //enter the sink in the database
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
         << "ERROR: database error";
@@ -2475,7 +2576,7 @@ TEST_F(CAmMapHandlerTest,getMainNotificationsSink)
     notify1.parameter=5;
 
     testSinkData.listMainNotificationConfigurations.push_back(notify1);
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
     //enter the sink in the database
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
         << "ERROR: database error";
@@ -2510,7 +2611,7 @@ TEST_F(CAmMapHandlerTest,getMainNotificationsSources)
     notify1.parameter=5;
 
     testSourceData.listMainNotificationConfigurations.push_back(notify1);
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
     //enter the sink in the database
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
         << "ERROR: database error";
@@ -2531,7 +2632,8 @@ TEST_F(CAmMapHandlerTest,changeMainNotificationsSources)
     am_sourceID_t sourceID;
     std::vector<am_Source_s> listSources;
     std::vector<am_NotificationConfiguration_s>returnList,returnList1;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceMainNotificationConfigurationChanged(_, _)).Times(1);
     //enter the sink in the database
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
         << "ERROR: database error";
@@ -2572,7 +2674,8 @@ TEST_F(CAmMapHandlerTest,changeMainNotificationsSink)
     am_sinkID_t sinkID;
     std::vector<am_Sink_s> listSinks;
     std::vector<am_NotificationConfiguration_s>returnList,returnList1;
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkMainNotificationConfigurationChanged(_, _)).Times(1);
     //enter the sink in the database
     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
         << "ERROR: database error";
@@ -2617,7 +2720,7 @@ TEST_F(CAmMapHandlerTest, peekDomain_2)
     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
     ASSERT_TRUE(listDomains.size()==1);
     ASSERT_EQ(domainID, DYNAMIC_ID_BOUNDARY);
-
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain( _)).Times(2);
     domain2.name = "anotherdomain";
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domain2ID));
     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
@@ -2654,6 +2757,8 @@ TEST_F(CAmMapHandlerTest, connectionIDBoundary)
 		source.sourceID = 0;
 		source.name = "source" + int2string(i);
 		source.domainID = 4;
+                EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+                EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
 		ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, forgetSink));
 		ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source, forgetSource));
 		connection.sinkID = forgetSink;
@@ -2683,6 +2788,8 @@ TEST_F(CAmMapHandlerTest, connectionIDBoundary)
 	sink.name="77";
 	source.sourceID=77;
 	source.name="77";
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
 	ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, forgetSink));
 	ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source, forgetSource));
 	ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
@@ -2713,16 +2820,18 @@ TEST_F(CAmMapHandlerTest, mainConnectionIDBoundary)
 		source.sourceID = 0;
 		source.name = "source" + int2string(i);
 		source.domainID = 4;
+                EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+                EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
 		ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, forgetSink));
 		ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source, forgetSource));
 		connection.sinkID = forgetSink;
 		connection.sourceID = forgetSource;
 		if( i < TEST_MAX_CONNECTION_ID )
 		{
-			ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
-			ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
-			ASSERT_EQ(i, connectionID);
-			connectionIDList.push_back(i);
+                    ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
+                    ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
+                    ASSERT_EQ(i, connectionID);
+                    connectionIDList.push_back(i);
 		}
 	}
 	std::vector<am_Connection_s> connectionList;
@@ -2744,9 +2853,16 @@ TEST_F(CAmMapHandlerTest, mainConnectionIDBoundary)
 	{
 		mainConnection.sinkID = DYNAMIC_ID_BOUNDARY + i;
 		mainConnection.sourceID = DYNAMIC_ID_BOUNDARY + i;
+                EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newMainConnection( _)).Times(1);
+                EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(_, _)).Times(1);
+                EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(_, _)).Times(1);
 		ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
 		ASSERT_EQ(i, mainConnectionID);
 	}
+	EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newMainConnection( _)).Times(1);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(_, _)).Times(1);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedMainConnection(_)).Times(2);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(_, _)).Times(3);
 	ASSERT_EQ(E_OK, pDatabaseHandler.removeMainConnectionDB(10));
 	ASSERT_EQ(E_OK, pDatabaseHandler.removeMainConnectionDB(12));
 	ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
@@ -2757,6 +2873,11 @@ TEST_F(CAmMapHandlerTest, mainConnectionIDBoundary)
 	sink.name="77";
 	source.sourceID=77;
 	source.name="77";
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource( _)).Times(1);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newMainConnection( _)).Times(1);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(_, _)).Times(1);
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(_, _)).Times(1);
 	ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, forgetSink));
 	ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source, forgetSource));
 	ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
@@ -2775,11 +2896,12 @@ TEST_F(CAmMapHandlerTest, increaseID)
 		sink.sinkID = 0;
 		sink.name = "sink" + int2string(i);
 		sink.domainID = 4;
+                EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink( _)).Times(1);
 		ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, sinkID));
 		ASSERT_EQ(DYNAMIC_ID_BOUNDARY+i, sinkID);
 	}
 	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterSinkDB(sink, sinkID));
-
+        EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedSink(_,_)).Times(2);
 	ASSERT_EQ(E_OK, pDatabaseHandler.removeSinkDB(DYNAMIC_ID_BOUNDARY+10));
 	ASSERT_EQ(E_OK, pDatabaseHandler.removeSinkDB(DYNAMIC_ID_BOUNDARY+12));
 
@@ -2788,17 +2910,6 @@ TEST_F(CAmMapHandlerTest, increaseID)
 	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterSinkDB(sink, sinkID));
 }
 
-
-CAmMapHandlerObserverCallbacksTest::CAmMapHandlerObserverCallbacksTest() :
-				mMockObserver(&pCommandSender, &pRoutingSender, &pSocketHandler)
-{
-	pDatabaseHandler.registerObserver(&mMockObserver);
-}
-
-CAmMapHandlerObserverCallbacksTest::~CAmMapHandlerObserverCallbacksTest()
-{
-}
-
 MATCHER_P(IsDomainDataEqualTo, value, "") {
 	auto lh = arg;
 	return lh.domainID == value.domainID &&
@@ -2809,7 +2920,30 @@ MATCHER_P(IsDomainDataEqualTo, value, "") {
 			lh.state == value.state;
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, peek_enter_removeDomain)
+TEST_F(CAmMapHandlerTest, dbo_addAndRemoveObservers)
+{
+	CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks observer1;
+	CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks observer2;
+	ASSERT_EQ(pDatabaseHandler.registerObserver(&observer1), true);
+	ASSERT_EQ(pDatabaseHandler.countObservers(), 2);
+	ASSERT_EQ(pDatabaseHandler.registerObserver(&observer2), true);
+	ASSERT_EQ(pDatabaseHandler.countObservers(), 3);
+
+	pDatabaseHandler.unregisterObserver(&observer1);
+	ASSERT_EQ(pDatabaseHandler.countObservers(), 2);
+	pDatabaseHandler.unregisterObserver(&observer2);
+	ASSERT_EQ(pDatabaseHandler.countObservers(), 1);
+	pDatabaseHandler.unregisterObserver(&observer2);
+	ASSERT_EQ(pDatabaseHandler.countObservers(), 1);
+
+	ASSERT_EQ(pDatabaseHandler.registerObserver(&observer2), true);
+	ASSERT_EQ(pDatabaseHandler.registerObserver(&observer2), false);
+	ASSERT_EQ(pDatabaseHandler.countObservers(), 2);
+	pDatabaseHandler.unregisterObserver(&observer2);
+	ASSERT_EQ(pDatabaseHandler.countObservers(), 1);
+}
+
+TEST_F(CAmMapHandlerTest, dbo_peek_enter_removeDomain)
 {
     std::vector<am_Domain_s> listDomains;
     am_Domain_s domain;
@@ -2844,7 +2978,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, peek_enter_removeDomain)
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(MockDatabaseObserver::getMockObserverObject()));
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, peek_enter_update_removeSource)
+TEST_F(CAmMapHandlerTest, dbo_peek_enter_update_removeSource)
 {
     std::vector<am_Source_s> listSources;
     am_sourceID_t sourceID;
@@ -2909,7 +3043,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, peek_enter_update_removeSource)
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(MockDatabaseObserver::getMockObserverObject()));
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, peek_enter_update_removeSink)
+TEST_F(CAmMapHandlerTest, dbo_peek_enter_update_removeSink)
 {
     std::vector<am_Sink_s> listSinks;
     am_sinkID_t sinkID;
@@ -2973,7 +3107,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, peek_enter_update_removeSink)
     EXPECT_TRUE(Mock::VerifyAndClearExpectations(MockDatabaseObserver::getMockObserverObject()));
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, peekSourceClassID)
+TEST_F(CAmMapHandlerTest, dbo_peekSourceClassID)
 {
     std::string sourceName("myClassID");
     am_sourceClass_t sourceClassID, peekID;
@@ -2989,7 +3123,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(13);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
 
     //first we peek without an existing class
@@ -2997,7 +3131,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, peekSourceClassID)
     ASSERT_EQ(sourceClassID, peekID);
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, peekSinkClassID)
+TEST_F(CAmMapHandlerTest, dbo_peekSinkClassID)
 {
     std::string sinkName("myClassID");
     am_sinkClass_t sinkClassID, peekID;
@@ -3013,7 +3147,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(12);
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(1);
     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
 
     //first we peek without an existing class
@@ -3021,7 +3155,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, peekSinkClassID)
     ASSERT_EQ(sinkClassID, peekID);
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeGateway)
+TEST_F(CAmMapHandlerTest, dbo_enter_removeGateway)
 {
     //initialize gateway
     std::vector<am_Gateway_s> returnList;
@@ -3056,7 +3190,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeGateway)
     ASSERT_EQ(E_OK,pDatabaseHandler.removeGatewayDB(gatewayID2))<< "ERROR: database error";
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeConverter)
+TEST_F(CAmMapHandlerTest, dbo_enter_removeConverter)
 {
     //initialize gateway
     std::vector<am_Converter_s> returnList;
@@ -3091,7 +3225,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeConverter)
     ASSERT_EQ(E_OK,pDatabaseHandler.removeConverterDB(gatewayID2))<< "ERROR: database error";
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeCrossfader)
+TEST_F(CAmMapHandlerTest, dbo_enter_removeCrossfader)
 {
     am_Crossfader_s crossfader;
     am_crossfaderID_t crossfaderID;
@@ -3125,19 +3259,11 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeCrossfader)
     ASSERT_EQ(E_OK,pDatabaseHandler.removeCrossfaderDB(crossfaderID))<< "ERROR: database error";
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, enter_update_removeMainConnection)
+TEST_F(CAmMapHandlerTest, dbo_enter_update_removeMainConnection)
 {
     am_mainConnectionID_t mainConnectionID;
     am_MainConnection_s mainConnection;
-    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(9);
-    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(9);
-    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newMainConnection(Field(&am_MainConnectionType_s::mainConnectionID, 1))).Times(1);
-    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(1, CS_CONNECTED)).Times(1);
-#ifndef WITH_DATABASE_CHANGE_CHECK
-    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(1, _)).Times(1);
-#else
-    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(1, _)).Times(0);
-#endif
+
     createMainConnectionSetup(mainConnectionID, mainConnection);
 
     //change delay of first connection
@@ -3161,7 +3287,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, enter_update_removeMainConnection)
     ASSERT_EQ(E_OK,pDatabaseHandler.removeMainConnectionDB(mainConnectionID)) << "ERROR: database error";
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, changeSinkAvailability)
+TEST_F(CAmMapHandlerTest, dbo_changeSinkAvailability)
 {
     std::vector<am_Sink_s> listSinks;
     am_Sink_s sink;
@@ -3187,7 +3313,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, changeSinkAvailability)
 #endif
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, changeSourceAvailability)
+TEST_F(CAmMapHandlerTest, dbo_changeSourceAvailability)
 {
     std::vector<am_Source_s> listSources;
     am_Source_s source;
@@ -3214,7 +3340,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, changeSourceAvailability)
 #endif
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest,changeMainSinkVolume)
+TEST_F(CAmMapHandlerTest, dbo_changeMainSinkVolume)
 {
     am_Sink_s sink;
     am_sinkID_t sinkID;
@@ -3236,7 +3362,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest,changeMainSinkVolume)
 #endif
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, changeSinkMuteState)
+TEST_F(CAmMapHandlerTest, dbo_changeSinkMuteState)
 {
     std::vector<am_Sink_s> listSinks;
     am_Sink_s sink;
@@ -3258,7 +3384,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, changeSinkMuteState)
 #endif
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, changeSystemProperty)
+TEST_F(CAmMapHandlerTest, dbo_changeSystemProperty)
 {
     std::vector<am_SystemProperty_s> listSystemProperties, listReturn;
     am_SystemProperty_s systemProperty;
@@ -3282,7 +3408,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, changeSystemProperty)
 #endif
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, changeMainNotificationsSink)
+TEST_F(CAmMapHandlerTest, dbo_changeMainNotificationsSink)
 {
     am_Sink_s testSinkData;
     pCF.createSink(testSinkData);
@@ -3329,7 +3455,7 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, changeMainNotificationsSink)
     ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSinkNotificationConfigurationDB(sinkID,notify2));
 }
 
-TEST_F(CAmMapHandlerObserverCallbacksTest, changeMainNotificationsSources)
+TEST_F(CAmMapHandlerTest, dbo_changeMainNotificationsSources)
 {
 
     am_Source_s testSourceData;
diff --git a/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.h b/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.h
index e3cc0ef..32add3d 100644
--- a/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.h
+++ b/AudioManagerCore/test/AmMapHandlerTest/CAmMapHandlerTest.h
@@ -33,16 +33,17 @@
 #include "CAmDatabaseHandlerMap.h"
 #include "CAmControlReceiver.h"
 #include "CAmControlSender.h"
-#include "CAmDatabaseObserver.h"
+#include "CAmTestDatabaseObserver.h"
 #include "CAmRoutingSender.h"
 #include "CAmRouter.h"
 #include "CAmControlSender.h"
+#include "MockDatabaseObserver.h"
 #include "../IAmControlBackdoor.h"
 #include "../IAmCommandBackdoor.h"
 #include "../CAmCommonFunctions.h"
 #include "../MockIAmControlSend.h"
 #include "../MockIAmCommandSend.h"
-#include "MockDatabaseObserver.h"
+
 
 namespace am
 {
@@ -50,15 +51,15 @@ namespace am
 class CAmMapBasicTest : public ::testing::Test
 {
 public:
-	CAmMapBasicTest();
+    CAmMapBasicTest();
     ~CAmMapBasicTest();
+    CAmSocketHandler pSocketHandler;
     std::vector<std::string> plistRoutingPluginDirs;
     std::vector<std::string> plistCommandPluginDirs;
     CAmRoutingSender pRoutingSender;
     CAmCommandSender pCommandSender;
     IAmRoutingBackdoor pRoutingInterfaceBackdoor;
     IAmCommandBackdoor pCommandInterfaceBackdoor;
-    CAmSocketHandler pSocketHandler;
     CAmDatabaseHandlerMap pDatabaseHandler;
     CAmControlSender pControlSender;
     CAmRouter pRouter;
@@ -75,18 +76,9 @@ public:
 	CAmMapHandlerTest();
 	~CAmMapHandlerTest();
     MockIAmCommandSend pMockInterface;
-    CAmDatabaseObserver pObserver;
+    CAmDatabaseObserver mMockObserver;
 };
 
-class CAmMapHandlerObserverCallbacksTest : public CAmMapBasicTest
-{
-public:
-    CAmMapHandlerObserverCallbacksTest();
-    ~CAmMapHandlerObserverCallbacksTest();
-	CAmDatabaseObserver mMockObserver;
-};
-
-
 }
 
 #endif /* MAPHANDLERTEST_H_ */
diff --git a/AudioManagerCore/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp b/AudioManagerCore/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp
index a035cee..ddf0abb 100644
--- a/AudioManagerCore/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp
+++ b/AudioManagerCore/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp
@@ -21,78 +21,75 @@
  *
  */
 
-#include "CAmDatabaseObserver.h"
+#include "CAmTestDatabaseObserver.h"
 #include "MockDatabaseObserver.h"
 
 namespace am {
 
-CAmDatabaseObserver::CAmDatabaseObserver(CAmCommandSender *iCommandSender, CAmRoutingSender *iRoutingSender, CAmSocketHandler *iSocketHandler) :
-mCommandSender(iCommandSender), //
-mRoutingSender(iRoutingSender), //
-mTelnetServer(NULL), //
-mSerializer(iSocketHandler) //
-{}
+CAmDatabaseObserver::CAmDatabaseObserver()
+{
+		dboNumberOfSinkClassesChanged = [&]()
+		{ MockDatabaseObserver::getMockObserverObject()->numberOfSinkClassesChanged(); };
+		dboNumberOfSourceClassesChanged = [&]()
+		{ MockDatabaseObserver::getMockObserverObject()->numberOfSourceClassesChanged(); };
+		dboNewSink = [&](const am_Sink_s& sink)
+		{ MockDatabaseObserver::getMockObserverObject()->newSink(sink); };
+		dboNewSource = [&](const am_Source_s& source)
+		{ MockDatabaseObserver::getMockObserverObject()->newSource(source); };
+		dboNewDomain = [&](const am_Domain_s& domain)
+		{ MockDatabaseObserver::getMockObserverObject()->newDomain(domain); };
+		dboNewGateway = [&](const am_Gateway_s& gateway)
+		{ MockDatabaseObserver::getMockObserverObject()->newGateway(gateway); };
+		dboNewConverter = [&](const am_Converter_s& coverter)
+		{ MockDatabaseObserver::getMockObserverObject()->newConverter(coverter); };
+		dboNewCrossfader = [&](const am_Crossfader_s& crossfader)
+		{ MockDatabaseObserver::getMockObserverObject()->newCrossfader(crossfader); };
+		dboNewMainConnection = [&](const am_MainConnectionType_s& mainConnection)
+		{ MockDatabaseObserver::getMockObserverObject()->newMainConnection(mainConnection); };
+		dboRemovedMainConnection = [&](const am_mainConnectionID_t mainConnection)
+		{ MockDatabaseObserver::getMockObserverObject()->removedMainConnection(mainConnection); };
+		dboRemovedSink = [&](const am_sinkID_t sinkID, const bool visible)
+		{ MockDatabaseObserver::getMockObserverObject()->removedSink(sinkID, visible); };
+		dboRemovedSource = [&](const am_sourceID_t sourceID, const bool visible)
+		{ MockDatabaseObserver::getMockObserverObject()->removedSource(sourceID, visible); };
+		dboRemoveDomain = [&](const am_domainID_t domainID)
+		{ MockDatabaseObserver::getMockObserverObject()->removeDomain(domainID); };
+		dboRemoveGateway = [&](const am_gatewayID_t gatewayID)
+		{ MockDatabaseObserver::getMockObserverObject()->removeGateway(gatewayID); };
+		dboRemoveConverter = [&](const am_converterID_t converterID)
+		{ MockDatabaseObserver::getMockObserverObject()->removeConverter(converterID); };
+		dboRemoveCrossfader = [&](const am_crossfaderID_t crossfaderID)
+		{ MockDatabaseObserver::getMockObserverObject()->removeCrossfader(crossfaderID); };
+		dboMainConnectionStateChanged = [&](const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)
+		{ MockDatabaseObserver::getMockObserverObject()->mainConnectionStateChanged(connectionID, connectionState); };
+		dboMainSinkSoundPropertyChanged = [&](const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty)
+		{ MockDatabaseObserver::getMockObserverObject()->mainSinkSoundPropertyChanged(sinkID, SoundProperty); };
+		dboMainSourceSoundPropertyChanged = [&](const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty)
+		{ MockDatabaseObserver::getMockObserverObject()->mainSourceSoundPropertyChanged(sourceID, SoundProperty); };
+		dboSinkAvailabilityChanged = [&](const am_sinkID_t sinkID, const am_Availability_s& availability)
+		{ MockDatabaseObserver::getMockObserverObject()->sinkAvailabilityChanged(sinkID, availability); };
+		dboSourceAvailabilityChanged = [&](const am_sourceID_t sourceID, const am_Availability_s& availability)
+		{ MockDatabaseObserver::getMockObserverObject()->sourceAvailabilityChanged(sourceID, availability); };
+		dboVolumeChanged = [&](const am_sinkID_t sinkID, const am_mainVolume_t volume)
+		{ MockDatabaseObserver::getMockObserverObject()->volumeChanged(sinkID, volume); };
+		dboSinkMuteStateChanged = [&](const am_sinkID_t sinkID, const am_MuteState_e muteState)
+		{ MockDatabaseObserver::getMockObserverObject()->sinkMuteStateChanged(sinkID, muteState); };
+		dboSystemPropertyChanged = [&](const am_SystemProperty_s& SystemProperty)
+		{ MockDatabaseObserver::getMockObserverObject()->systemPropertyChanged(SystemProperty); };
+		dboTimingInformationChanged = [&](const am_mainConnectionID_t mainConnection, const am_timeSync_t time)
+		{ MockDatabaseObserver::getMockObserverObject()->timingInformationChanged(mainConnection,time); };
+		dboSinkUpdated = [&](const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties, const bool visible)
+		{ MockDatabaseObserver::getMockObserverObject()->sinkUpdated(sinkID,sinkClassID,listMainSoundProperties, visible); };
+		dboSourceUpdated = [&](const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties, const bool visible)
+		{ MockDatabaseObserver::getMockObserverObject()->sourceUpdated(sourceID,sourceClassID,listMainSoundProperties, visible); };
+		dboSinkMainNotificationConfigurationChanged = [&](const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration)
+		{ MockDatabaseObserver::getMockObserverObject()->sinkMainNotificationConfigurationChanged(sinkID,mainNotificationConfiguration); };
+		dboSourceMainNotificationConfigurationChanged = [&](const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration)
+		{ MockDatabaseObserver::getMockObserverObject()->sourceMainNotificationConfigurationChanged(sourceID,mainNotificationConfiguration); };
 
-CAmDatabaseObserver::~CAmDatabaseObserver() {}
+}
 
+CAmDatabaseObserver::~CAmDatabaseObserver() {}
 
-void CAmDatabaseObserver::numberOfSinkClassesChanged()
-{ MockDatabaseObserver::getMockObserverObject()->numberOfSinkClassesChanged(); }
-void CAmDatabaseObserver::numberOfSourceClassesChanged()
-{ MockDatabaseObserver::getMockObserverObject()->numberOfSourceClassesChanged(); }
-void CAmDatabaseObserver::newSink(const am_Sink_s& sink)
-{ MockDatabaseObserver::getMockObserverObject()->newSink(sink); }
-void CAmDatabaseObserver::newSource(const am_Source_s& source)
-{ MockDatabaseObserver::getMockObserverObject()->newSource(source); }
-void CAmDatabaseObserver::newDomain(const am_Domain_s& domain)
-{ MockDatabaseObserver::getMockObserverObject()->newDomain(domain); }
-void CAmDatabaseObserver::newGateway(const am_Gateway_s& gateway)
-{ MockDatabaseObserver::getMockObserverObject()->newGateway(gateway); }
-void CAmDatabaseObserver::newConverter(const am_Converter_s& coverter)
-{ MockDatabaseObserver::getMockObserverObject()->newConverter(coverter); }
-void CAmDatabaseObserver::newCrossfader(const am_Crossfader_s& crossfader)
-{ MockDatabaseObserver::getMockObserverObject()->newCrossfader(crossfader); }
-void CAmDatabaseObserver::newMainConnection(const am_MainConnectionType_s& mainConnection)
-{ MockDatabaseObserver::getMockObserverObject()->newMainConnection(mainConnection); }
-void CAmDatabaseObserver::removedMainConnection(const am_mainConnectionID_t mainConnection)
-{ MockDatabaseObserver::getMockObserverObject()->removedMainConnection(mainConnection); }
-void CAmDatabaseObserver::removedSink(const am_sinkID_t sinkID, const bool visible)
-{ MockDatabaseObserver::getMockObserverObject()->removedSink(sinkID, visible); }
-void CAmDatabaseObserver::removedSource(const am_sourceID_t sourceID, const bool visible)
-{ MockDatabaseObserver::getMockObserverObject()->removedSource(sourceID, visible); }
-void CAmDatabaseObserver::removeDomain(const am_domainID_t domainID)
-{ MockDatabaseObserver::getMockObserverObject()->removeDomain(domainID); }
-void CAmDatabaseObserver::removeGateway(const am_gatewayID_t gatewayID)
-{ MockDatabaseObserver::getMockObserverObject()->removeGateway(gatewayID); }
-void CAmDatabaseObserver::removeConverter(const am_converterID_t converterID)
-{ MockDatabaseObserver::getMockObserverObject()->removeConverter(converterID); }
-void CAmDatabaseObserver::removeCrossfader(const am_crossfaderID_t crossfaderID)
-{ MockDatabaseObserver::getMockObserverObject()->removeCrossfader(crossfaderID); }
-void CAmDatabaseObserver::mainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)
-{ MockDatabaseObserver::getMockObserverObject()->mainConnectionStateChanged(connectionID, connectionState); }
-void CAmDatabaseObserver::mainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty)
-{ MockDatabaseObserver::getMockObserverObject()->mainSinkSoundPropertyChanged(sinkID, SoundProperty); }
-void CAmDatabaseObserver::mainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty)
-{ MockDatabaseObserver::getMockObserverObject()->mainSourceSoundPropertyChanged(sourceID, SoundProperty); }
-void CAmDatabaseObserver::sinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s& availability)
-{ MockDatabaseObserver::getMockObserverObject()->sinkAvailabilityChanged(sinkID, availability); }
-void CAmDatabaseObserver::sourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s& availability)
-{ MockDatabaseObserver::getMockObserverObject()->sourceAvailabilityChanged(sourceID, availability); }
-void CAmDatabaseObserver::volumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume)
-{ MockDatabaseObserver::getMockObserverObject()->volumeChanged(sinkID, volume); }
-void CAmDatabaseObserver::sinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState)
-{ MockDatabaseObserver::getMockObserverObject()->sinkMuteStateChanged(sinkID, muteState); }
-void CAmDatabaseObserver::systemPropertyChanged(const am_SystemProperty_s& SystemProperty)
-{ MockDatabaseObserver::getMockObserverObject()->systemPropertyChanged(SystemProperty); }
-void CAmDatabaseObserver::timingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time)
-{ MockDatabaseObserver::getMockObserverObject()->timingInformationChanged(mainConnection,time); }
-void CAmDatabaseObserver::sinkUpdated(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties, const bool visible)
-{ MockDatabaseObserver::getMockObserverObject()->sinkUpdated(sinkID,sinkClassID,listMainSoundProperties, visible); }
-void CAmDatabaseObserver::sourceUpdated(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector<am_MainSoundProperty_s>& listMainSoundProperties, const bool visible)
-{ MockDatabaseObserver::getMockObserverObject()->sourceUpdated(sourceID,sourceClassID,listMainSoundProperties, visible); }
-void CAmDatabaseObserver::sinkMainNotificationConfigurationChanged(const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration)
-{ MockDatabaseObserver::getMockObserverObject()->sinkMainNotificationConfigurationChanged(sinkID,mainNotificationConfiguration); }
-void CAmDatabaseObserver::sourceMainNotificationConfigurationChanged(const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration)
-{ MockDatabaseObserver::getMockObserverObject()->sourceMainNotificationConfigurationChanged(sourceID,mainNotificationConfiguration); }
 }
 
diff --git a/AudioManagerCore/test/AmMapHandlerTest/CAmTestDatabaseObserver.h b/AudioManagerCore/test/AmMapHandlerTest/CAmTestDatabaseObserver.h
new file mode 100644
index 0000000..12ba32e
--- /dev/null
+++ b/AudioManagerCore/test/AmMapHandlerTest/CAmTestDatabaseObserver.h
@@ -0,0 +1,53 @@
+/**
+ * SPDX license identifier: MPL-2.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
+ *
+ * \file CAmDatabaseObserver.h
+ * For further information see http://www.genivi.org/.
+ *
+ */
+
+#ifndef DATABASEOBSERVER_H_
+#define DATABASEOBSERVER_H_
+
+#include "audiomanagertypes.h"
+#include <queue>
+#include <vector>
+#include <functional>
+#include "CAmDatabaseHandlerMap.h"
+
+
+namespace am
+{
+
+
+/**
+ * This class observes the Database and notifies other classes about important events, mainly the CommandSender.
+ */
+
+class CAmDatabaseObserver: public CAmDatabaseHandlerMap::AmDatabaseObserverCallbacks
+{
+public:
+    explicit CAmDatabaseObserver();
+    ~CAmDatabaseObserver();
+
+private:
+};
+
+}
+
+#endif /* DATABASEOBSERVER_H_ */
diff --git a/AudioManagerCore/test/AmMapHandlerTest/MockDatabaseObserver.h b/AudioManagerCore/test/AmMapHandlerTest/MockDatabaseObserver.h
index da1b3b4..82e1ea4 100644
--- a/AudioManagerCore/test/AmMapHandlerTest/MockDatabaseObserver.h
+++ b/AudioManagerCore/test/AmMapHandlerTest/MockDatabaseObserver.h
@@ -27,7 +27,7 @@
 
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
-#include "CAmDatabaseObserver.h"
+#include "CAmTestDatabaseObserver.h"
 
 class CAmCommandSender;
 class CAmRoutingSender;
diff --git a/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp b/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp
index 465995f..11d8c3c 100644
--- a/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp
+++ b/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp
@@ -27,32 +27,32 @@
 #include "CAmDltWrapper.h"
 #include "CAmCommandLineSingleton.h"
 
-TCLAP::SwitchArg enableDebug ("V","logDlt","print DLT logs to stdout or dlt-daemon default off",false);
-
+TCLAP::SwitchArg enableDebug("V", "logDlt", "print DLT logs to stdout or dlt-daemon default off", false);
 
 using namespace am;
 using namespace testing;
 
 CAmRouterMapTest::CAmRouterMapTest() :
-        		plistRoutingPluginDirs(), //
-				plistCommandPluginDirs(), //
-				pSocketHandler(), //
-				pControlSender(), //
-				pDatabaseHandler(),
-				pRouter(&pDatabaseHandler, &pControlSender), //
-				pRoutingSender(plistRoutingPluginDirs,dynamic_cast<IAmDatabaseHandler*>( &pDatabaseHandler )), //
-				pCommandSender(plistCommandPluginDirs), //
-				pMockInterface(), //
-				pMockControlInterface(), //
-				pRoutingInterfaceBackdoor(), //
-				pCommandInterfaceBackdoor(), //
-				pControlInterfaceBackdoor(), //
-				pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender,&pSocketHandler, &pRouter), //
-				pObserver(&pCommandSender, &pRoutingSender, &pSocketHandler)
+        plistRoutingPluginDirs(), //
+                plistCommandPluginDirs(), //
+                pSocketHandler(), //
+                pControlSender(), //
+                pDatabaseHandler(),
+                pRouter(&pDatabaseHandler, &pControlSender), //
+                pRoutingSender(plistRoutingPluginDirs, dynamic_cast<IAmDatabaseHandler*>(&pDatabaseHandler)), //
+                pCommandSender(plistCommandPluginDirs, &pSocketHandler), //
+                pMockInterface(), //
+                pMockControlInterface(), //
+                pRoutingInterfaceBackdoor(), //
+                pCommandInterfaceBackdoor(), //
+                pControlInterfaceBackdoor(), //
+                pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender, &pSocketHandler, &pRouter)
 {
-	pDatabaseHandler.registerObserver(&pObserver);
-	pCommandInterfaceBackdoor.injectInterface(&pCommandSender, &pMockInterface);
-	pControlInterfaceBackdoor.replaceController(&pControlSender, &pMockControlInterface);
+    pDatabaseHandler.registerObserver(&pRoutingSender);
+    pDatabaseHandler.registerObserver(&pCommandSender);
+    pDatabaseHandler.registerObserver(&pRouter);
+    pCommandInterfaceBackdoor.injectInterface(&pCommandSender, &pMockInterface);
+    pControlInterfaceBackdoor.replaceController(&pControlSender, &pMockControlInterface);
 }
 
 CAmRouterMapTest::~CAmRouterMapTest()
@@ -62,22 +62,22 @@ CAmRouterMapTest::~CAmRouterMapTest()
 
 void CAmRouterMapTest::SetUp()
 {
-	logInfo("Routing Test started ");
-	am_Domain_s domain;
-	pCF.createDomain(domain);
+    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;
+    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));
+    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()
@@ -85,152 +85,146 @@ void CAmRouterMapTest::TearDown()
 }
 
 ACTION(returnConnectionFormat){
-	arg4=arg3;
+arg4=arg3;
 }
 
 void CAmRouterMapTest::enterDomainDB(const std::string & domainName, am_domainID_t & domainID)
 {
-	am_Domain_s domain1;
-	domain1.domainID = 0;
-	domain1.name = domainName;
-	domain1.busname = "domain1bus";
-	domain1.state = DS_CONTROLLED;
-	ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID));
+    am_Domain_s domain1;
+    domain1.domainID = 0;
+    domain1.name = domainName;
+    domain1.busname = "domain1bus";
+    domain1.state = DS_CONTROLLED;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID));
 }
 
-void CAmRouterMapTest::enterSourceDB(const std::string & sourceName, const am_domainID_t domainID, const std::vector<am_CustomConnectionFormat_t> & connectionFormats, am_sourceID_t & sourceID)
+void CAmRouterMapTest::enterSourceDB(const std::string & sourceName, const am_domainID_t domainID,
+        const std::vector<am_CustomConnectionFormat_t> & connectionFormats, am_sourceID_t & sourceID)
 {
-	am_Source_s source;
-	source.domainID = domainID;
-	source.name = sourceName;
-	source.sourceState = SS_ON;
-	source.sourceID = 0;
-	source.sourceClassID = 5;
-	source.listConnectionFormats = connectionFormats;
-	ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    am_Source_s source;
+    source.domainID = domainID;
+    source.name = sourceName;
+    source.sourceState = SS_ON;
+    source.sourceID = 0;
+    source.sourceClassID = 5;
+    source.listConnectionFormats = connectionFormats;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source, sourceID));
 }
 
-void CAmRouterMapTest::enterSinkDB(const std::string & sinkName, const am_domainID_t domainID, const std::vector<am_CustomConnectionFormat_t> & connectionFormats, am_sinkID_t & sinkID)
+void CAmRouterMapTest::enterSinkDB(const std::string & sinkName, const am_domainID_t domainID,
+        const std::vector<am_CustomConnectionFormat_t> & connectionFormats, am_sinkID_t & sinkID)
 {
-	am_Sink_s sink;
-	sink.domainID = domainID;
-	sink.name = sinkName;
-	sink.sinkID = 0;
-	sink.sinkClassID = 5;
-	sink.muteState = MS_MUTED;
-	sink.listConnectionFormats = connectionFormats;
-	ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    am_Sink_s sink;
+    sink.domainID = domainID;
+    sink.name = sinkName;
+    sink.sinkID = 0;
+    sink.sinkClassID = 5;
+    sink.muteState = MS_MUTED;
+    sink.listConnectionFormats = connectionFormats;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, sinkID));
 }
 
-void CAmRouterMapTest::enterGatewayDB(const std::string & gwName,
-		const am_domainID_t domainSourceID,
-		const am_domainID_t domainSinkID,
-		const std::vector<am_CustomConnectionFormat_t> & sourceConnectionFormats,
-		const std::vector<am_CustomConnectionFormat_t> & sinkConnectionFormats,
-		const std::vector<bool> & matrix,
-		const am_sourceID_t & sourceID,
-		const am_sinkID_t & sinkID,
-		am_gatewayID_t & gatewayID)
+void CAmRouterMapTest::enterGatewayDB(const std::string & gwName, const am_domainID_t domainSourceID, const am_domainID_t domainSinkID,
+        const std::vector<am_CustomConnectionFormat_t> & sourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t> & sinkConnectionFormats,
+        const std::vector<bool> & matrix, const am_sourceID_t & sourceID, const am_sinkID_t & sinkID, am_gatewayID_t & gatewayID)
 {
-	am_Gateway_s gateway;
-	gateway.controlDomainID = domainSourceID;
-	gateway.gatewayID = 0;
-	gateway.sinkID = sinkID;
-	gateway.sourceID = sourceID;
-	gateway.domainSourceID = domainSourceID;
-	gateway.domainSinkID = domainSinkID;
-	gateway.listSinkFormats = sinkConnectionFormats;
-	gateway.listSourceFormats = sourceConnectionFormats;
-	gateway.convertionMatrix = matrix;
-	gateway.name = gwName;
-	ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
+    am_Gateway_s gateway;
+    gateway.controlDomainID = domainSourceID;
+    gateway.gatewayID = 0;
+    gateway.sinkID = sinkID;
+    gateway.sourceID = sourceID;
+    gateway.domainSourceID = domainSourceID;
+    gateway.domainSinkID = domainSinkID;
+    gateway.listSinkFormats = sinkConnectionFormats;
+    gateway.listSourceFormats = sourceConnectionFormats;
+    gateway.convertionMatrix = matrix;
+    gateway.name = gwName;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
 }
 
-void CAmRouterMapTest::enterConverterDB(const std::string & gwName,
-		const am_domainID_t domainID,
-		const std::vector<am_CustomConnectionFormat_t> & sourceConnectionFormats,
-		const std::vector<am_CustomConnectionFormat_t> & sinkConnectionFormats,
-		const std::vector<bool> & matrix,
-		const am_sourceID_t & sourceID,
-		const am_sinkID_t & sinkID,
-		am_converterID_t & converterID)
+void CAmRouterMapTest::enterConverterDB(const std::string & gwName, const am_domainID_t domainID,
+        const std::vector<am_CustomConnectionFormat_t> & sourceConnectionFormats, const std::vector<am_CustomConnectionFormat_t> & sinkConnectionFormats,
+        const std::vector<bool> & matrix, const am_sourceID_t & sourceID, const am_sinkID_t & sinkID, am_converterID_t & converterID)
 {
-	am_Converter_s converter;
-	converter.converterID = 0;
-	converter.sinkID = sinkID;
-	converter.sourceID = sourceID;
-	converter.domainID = domainID;
-	converter.listSinkFormats = sinkConnectionFormats;
-	converter.listSourceFormats = sourceConnectionFormats;
-	converter.convertionMatrix = matrix;
-	converter.name = gwName;
-	ASSERT_EQ(E_OK, pDatabaseHandler.enterConverterDB(converter,converterID));
+    am_Converter_s converter;
+    converter.converterID = 0;
+    converter.sinkID = sinkID;
+    converter.sourceID = sourceID;
+    converter.domainID = domainID;
+    converter.listSinkFormats = sinkConnectionFormats;
+    converter.listSourceFormats = sourceConnectionFormats;
+    converter.convertionMatrix = matrix;
+    converter.name = gwName;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterConverterDB(converter, converterID));
 }
 
-void CAmRouterMapTest::getRoute(const bool onlyfree, const am_Source_s & aSource, const am_Sink_s & aSink, std::vector<am_Route_s> & listRoutes)
+am_Error_e CAmRouterMapTest::getRoute(const bool onlyfree, const bool shouldReload, const am_Source_s & aSource, const am_Sink_s & aSink,
+        std::vector<am_Route_s> & listRoutes, const unsigned countCycles, const unsigned pathsCount)
 {
-	std::ios_base::fmtflags oldflags = std::cout.flags();
-	std::streamsize oldprecision = std::cout.precision();
-	auto t_start = std::chrono::high_resolution_clock::now();
-	ASSERT_EQ(E_OK, pRouter.getRoute(onlyfree, aSource, aSink, listRoutes));
-	auto t_end = std::chrono::high_resolution_clock::now();
-	std::cout << std::fixed << std::setprecision(2);
-	std::cout << "getRoute did find " << listRoutes.size() <<" routes from " << aSource.sourceID << " to " << aSink.sinkID;
-	std::cout << " in " << std::chrono::duration<double, std::milli>(t_end-t_start).count() << " ms\n";
-	std::cout.flags (oldflags);
-	std::cout.precision (oldprecision);
+    return getRoute(onlyfree, shouldReload, aSource.sourceID, aSink.sinkID, listRoutes, countCycles, pathsCount);
 }
 
-void CAmRouterMapTest::getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s>& returnList)
+am_Error_e CAmRouterMapTest::getRoute(const bool onlyfree, const bool shouldReload, const am_sourceID_t sourceID, const am_sinkID_t sinkID,
+        std::vector<am_Route_s>& returnList, const unsigned countCycles, const unsigned pathsCount)
 {
-	std::ios_base::fmtflags oldflags = std::cout.flags();
-	std::streamsize oldprecision = std::cout.precision();
-	auto t_start = std::chrono::high_resolution_clock::now();
-	ASSERT_EQ(E_OK, pRouter.getRoute(onlyfree, sourceID, sinkID, returnList));
-	auto t_end = std::chrono::high_resolution_clock::now();
-	std::cout << std::fixed << std::setprecision(2);
-	std::cout << "getRoute by id did find " << returnList.size() <<" routes from " << sourceID << " to " << sinkID;
-	std::cout << " in " << std::chrono::duration<double, std::milli>(t_end-t_start).count() << " ms\n";
-	std::cout.flags (oldflags);
-	std::cout.precision (oldprecision);
+    pRouter.setMaxAllowedCycles(countCycles);
+    pRouter.setMaxPathCount(pathsCount);
+    std::ios_base::fmtflags oldflags = std::cout.flags();
+    std::streamsize oldprecision = std::cout.precision();
+    auto t_start = std::chrono::high_resolution_clock::now();
+    if (shouldReload)
+        pRouter.load();
+
+    am_Error_e error = pRouter.getRoute(onlyfree, sourceID, sinkID, returnList);
+    auto t_end = std::chrono::high_resolution_clock::now();
+    std::cout << std::fixed << std::setprecision(2);
+    std::cout << returnList.size() << " routes from " << sourceID << " to " << sinkID;
+    std::cout << " in " << std::chrono::duration<double, std::milli>(t_end - t_start).count() << " ms\n";
+    std::cout.flags(oldflags);
+    std::cout.precision(oldprecision);
+    return error;
 }
 
-void CAmRouterMapTest::getAllPaths(CAmRoutingNode & aSource,
-										 CAmRoutingNode & aSink,
-										 std::vector<am_Route_s> & resultPath,
-										 std::vector<std::vector<CAmRoutingNode*>> & resultNodesPath,
-										 const bool includeCycles)
+am_Error_e CAmRouterMapTest::getAllPaths(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & resultPath,
+        const unsigned countCycles, const unsigned pathsCount)
 {
-	std::ios_base::fmtflags oldflags = std::cout.flags();
-	std::streamsize oldprecision = std::cout.precision();
-	auto t_start = std::chrono::high_resolution_clock::now();
-	ASSERT_EQ(E_OK, pRouter.getAllPaths(aSource, aSink, resultPath, resultNodesPath, includeCycles));
-	auto t_end = std::chrono::high_resolution_clock::now();
-	std::cout << std::fixed << std::setprecision(2);
-	std::cout << "getAllPaths did find " << resultPath.size()
-			  << " routes from " << aSource.getData().data.source->sourceID
-			  << " to " << aSink.getData().data.sink->sinkID;
-	std::cout << " in " << std::chrono::duration<double, std::milli>(t_end-t_start).count() << " ms\n";
-	std::cout.flags (oldflags);
-	std::cout.precision (oldprecision);
+    std::ios_base::fmtflags oldflags = std::cout.flags();
+    std::streamsize oldprecision = std::cout.precision();
+    auto t_start = std::chrono::high_resolution_clock::now();
+    if (pRouter.getUpdateGraphNodesAction())
+        pRouter.load();
+    CAmRoutingNode* sourceNode = pRouter.sourceNodeWithID(sourceID);
+    CAmRoutingNode* sinkNode = pRouter.sinkNodeWithID(sinkID);
+
+    if (!sourceNode || !sinkNode)
+        return E_NON_EXISTENT;
+
+    am_Error_e error = pRouter.getFirstNShortestPaths(onlyfree, countCycles, pathsCount, *sourceNode, *sinkNode, resultPath);
+    auto t_end = std::chrono::high_resolution_clock::now();
+    std::cout << std::fixed << std::setprecision(2);
+    std::cout << resultPath.size() << " routes from " << sourceNode->getData().data.source->sourceID << " to " << sinkNode->getData().data.sink->sinkID;
+    std::cout << " in " << std::chrono::duration<double, std::milli>(t_end - t_start).count() << " ms\n";
+    std::cout.flags(oldflags);
+    std::cout.precision(oldprecision);
+    return error;
 }
 
 TEST_F(CAmRouterMapTest,checkInsertedDomain)
 {
-	std::vector<am_domainID_t> domains;
-	ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 22));
-	domains.push_back(22);
-	ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 22));
-	domains.push_back(22);
-	ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 22));
-	ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 50));
-	domains.push_back(30);
-	ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 30));
-	ASSERT_FALSE(CAmRouter::shouldGoInDomain(domains, 22));
-	domains.push_back(30);
-	ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 30));
-	ASSERT_FALSE(CAmRouter::shouldGoInDomain(domains, 22));
-	ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 60));
+    std::vector<am_domainID_t> domains;
+    ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 22, 0));
+    domains.push_back(22);
+    ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 22, 0));
+    domains.push_back(22);
+    ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 22, 0));
+    ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 50, 0));
+    domains.push_back(30);
+    ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 30, 0));
+    ASSERT_FALSE(CAmRouter::shouldGoInDomain(domains, 22, 0));
+    domains.push_back(30);
+    ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 30, 0));
+    ASSERT_FALSE(CAmRouter::shouldGoInDomain(domains, 22, 0));
+    ASSERT_TRUE(CAmRouter::shouldGoInDomain(domains, 60, 0));
 }
 
 //test that checks just sinks and source in a domain but connectionformats do not match
@@ -247,14 +241,14 @@ TEST_F(CAmRouterMapTest,simpleRoute2withDomainNoMatchFormats)
     domain1.busname = "domain1bus";
     domain1.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
 
     am_Source_s source;
     am_sourceID_t sourceID;
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -263,15 +257,14 @@ 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));
+    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";
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     sink.domainID = domainID1;
     sink.name = "sink1";
@@ -280,8 +273,8 @@ 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));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass, sinkclass.sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, sinkID));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -300,12 +293,12 @@ TEST_F(CAmRouterMapTest,simpleRoute2withDomainNoMatchFormats)
     compareRoute.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
-	am::am_Sink_s sinkDb;
-	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
-	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
-	listRoutes.clear();
-	getRoute(true, sourceDb, sinkDb, listRoutes);
-	ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    listRoutes.clear();
+    ASSERT_EQ(getRoute(true, false, sourceDb, sinkDb, listRoutes), E_NOT_POSSIBLE);
+    ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
 }
 
 //test that checks just sinks and source in a domain
@@ -322,14 +315,14 @@ TEST_F(CAmRouterMapTest,simpleRoute2withDomain)
     domain1.busname = "domain1bus";
     domain1.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
 
     am_Source_s source;
     am_sourceID_t sourceID;
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -338,15 +331,14 @@ 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));
+    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";
-
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     sink.domainID = domainID1;
     sink.name = "sink1";
@@ -355,8 +347,8 @@ 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));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass, sinkclass.sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, sinkID));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -375,13 +367,13 @@ TEST_F(CAmRouterMapTest,simpleRoute2withDomain)
     compareRoute.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
-	am::am_Sink_s sinkDb;
-	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
-	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
-	listRoutes.clear();
-	getRoute(true, sourceDb, sinkDb, listRoutes);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    listRoutes.clear();
+    ASSERT_EQ(getRoute(true, false, sourceDb, sinkDb, listRoutes), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
 //test that checks just 2 domains, one sink one source with only one connection format each
@@ -402,15 +394,15 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFree)
     domain2.busname = "domain2bus";
     domain2.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
 
     am_Source_s source, gwSource;
     am_sourceID_t sourceID, gwSourceID;
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -426,15 +418,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));
+    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";
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     sink.domainID = domainID2;
     sink.name = "sink1";
@@ -450,9 +442,9 @@ 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));
+    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));
 
     am_Gateway_s gateway;
     am_gatewayID_t gatewayID;
@@ -468,7 +460,7 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFree)
     gateway.convertionMatrix.push_back(true);
     gateway.name = "gateway";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -498,12 +490,11 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFree)
     pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
     pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
 
-    getRoute(true,sourceID,sinkID,listRoutes);
+    ASSERT_EQ(getRoute(true, false, sourceID, sinkID, listRoutes), E_OK);
     ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-    ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
-
 //test that checks just 2 domains, one sink one source with only one connection format each
 TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFreeNotFree)
 {
@@ -522,15 +513,15 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFreeNotFree)
     domain2.busname = "domain2bus";
     domain2.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
 
     am_Source_s source, gwSource;
     am_sourceID_t sourceID, gwSourceID;
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -546,16 +537,15 @@ 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));
+    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";
-
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     sink.domainID = domainID2;
     sink.name = "sink1";
@@ -571,9 +561,9 @@ 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));
+    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));
 
     am_Gateway_s gateway;
     am_gatewayID_t gatewayID;
@@ -589,7 +579,7 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFreeNotFree)
     gateway.convertionMatrix.push_back(true);
     gateway.name = "gateway";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -614,32 +604,32 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsOnlyFreeNotFree)
     compareRoute.sinkID = sinkID;
     compareRoute.sourceID = sourceID;
 
-    am_Connection_s connection,connection1;
-    am_connectionID_t id1,id2;
-    connection.sourceID=sourceID;
-    connection.sinkID=gwSinkID;
-    connection.connectionFormat=CF_GENIVI_ANALOG;
-    connection.connectionID=0;
-    connection1.sourceID=gwSourceID;
-    connection1.sinkID=sinkID;
-    connection1.connectionFormat=CF_GENIVI_ANALOG;
-    connection1.connectionID=0;
+    am_Connection_s connection, connection1;
+    am_connectionID_t id1, id2;
+    connection.sourceID = sourceID;
+    connection.sinkID = gwSinkID;
+    connection.connectionFormat = CF_GENIVI_ANALOG;
+    connection.connectionID = 0;
+    connection1.sourceID = gwSourceID;
+    connection1.sinkID = sinkID;
+    connection1.connectionFormat = CF_GENIVI_ANALOG;
+    connection1.connectionID = 0;
 
-    ASSERT_EQ(E_OK,pDatabaseHandler.enterConnectionDB(connection,id1));
-    ASSERT_EQ(E_OK,pDatabaseHandler.enterConnectionDB(connection1,id2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection, id1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection1, id2));
 
     am::am_Source_s sourceDb;
-	am::am_Sink_s sinkDb;
-	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
-	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
-	listRoutes.clear();
-	getRoute(true, sourceDb, sinkDb, listRoutes);
-	ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
-
-	listRoutes.clear();
-	getRoute(false, sourceDb, sinkDb, listRoutes);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    listRoutes.clear();
+    ASSERT_EQ(getRoute(true, false, sourceDb, sinkDb, listRoutes), E_NOT_POSSIBLE);
+    ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
+
+    listRoutes.clear();
+    ASSERT_EQ(getRoute(false, false, sourceDb, sinkDb, listRoutes), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
 //test that checks just 2 domains, with gateway for each direction (possible circular route)
@@ -660,15 +650,15 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsCircularGWOnlyFree)
     domain2.busname = "domain2bus";
     domain2.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
 
     am_Source_s source, gwSource, gwSource2;
     am_sourceID_t sourceID, gwSourceID, gwSourceID2;
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -691,16 +681,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));
+    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";
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     sink.domainID = domainID2;
     sink.name = "sink1";
@@ -723,10 +713,10 @@ 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));
+    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));
 
     am_Gateway_s gateway, gateway2;
     am_gatewayID_t gatewayID, gatewayID2;
@@ -753,8 +743,8 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsCircularGWOnlyFree)
     gateway2.convertionMatrix.push_back(true);
     gateway2.name = "gateway2";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway2, gatewayID2));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -780,13 +770,13 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsCircularGWOnlyFree)
     compareRoute.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
-	am::am_Sink_s sinkDb;
-	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
-	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
-	listRoutes.clear();
-	getRoute(true, sourceDb, sinkDb, listRoutes);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    listRoutes.clear();
+    ASSERT_EQ(getRoute(true, false, sourceDb, sinkDb, listRoutes), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
 //test that checks 3 domains, one sink one source, longer lists of connectionformats.
@@ -811,17 +801,16 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_2)
     domain3.busname = "domain3bus";
     domain3.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3,domainID3));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3, domainID3));
 
     am_Source_s source, gwSource, gwSource1;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1;
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
-
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -848,10 +837,10 @@ 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));
+    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;
@@ -863,8 +852,8 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_2)
     sink.muteState = MS_MUTED;
     sink.listConnectionFormats.push_back(CF_GENIVI_MONO);
     am_SinkClass_s sinkclass;
-    sinkclass.sinkClassID=5;
-    sinkclass.name="sname";
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     gwSink.domainID = domainID1;
     gwSink.name = "gwSink";
@@ -882,10 +871,10 @@ 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));
+    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));
 
     am_Gateway_s gateway, gateway1;
     am_gatewayID_t gatewayID, gatewayID1;
@@ -920,8 +909,8 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_2)
     gateway1.convertionMatrix.push_back(true);
     gateway1.name = "gateway1";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1, gatewayID1));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -954,12 +943,12 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_2)
     compareRoute.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
-	am::am_Sink_s sinkDb;
-	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
-	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
-	getRoute(false, sourceDb, sinkDb, listRoutes);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    ASSERT_EQ(getRoute(false, false, sourceDb, sinkDb, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
 //test that checks 3 domains, one sink one source, longer lists of connectionformats.
@@ -984,9 +973,9 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_1)
     domain3.busname = "domain3bus";
     domain3.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3,domainID3));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3, domainID3));
 
     am_Source_s source, gwSource, gwSource1;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1;
@@ -1000,8 +989,8 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_1)
     source.listConnectionFormats.push_back(CF_GENIVI_MONO);
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     gwSource.domainID = domainID2;
     gwSource.name = "gwsource1";
@@ -1019,16 +1008,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));
+    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";
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     sink.domainID = domainID3;
     sink.name = "sink1";
@@ -1052,10 +1041,10 @@ 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));
+    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));
 
     am_Gateway_s gateway, gateway1;
     am_gatewayID_t gatewayID, gatewayID1;
@@ -1087,8 +1076,8 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_1)
     gateway1.convertionMatrix.push_back(true);
     gateway1.name = "gateway";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1, gatewayID1));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -1121,15 +1110,14 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats_1)
     compareRoute.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
-	am::am_Sink_s sinkDb;
-	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
-	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
-	getRoute(false, sourceDb, sinkDb, listRoutes);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    ASSERT_EQ(getRoute(false, false, sourceDb, sinkDb, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
-
 //test that checks 3 domains, one sink one source, longer lists of connectionformats.
 TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats)
 {
@@ -1152,16 +1140,16 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats)
     domain3.busname = "domain3bus";
     domain3.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3,domainID3));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3, domainID3));
 
     am_Source_s source, gwSource, gwSource1;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1;
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -1185,17 +1173,17 @@ 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));
+    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";
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     sink.domainID = domainID3;
     sink.name = "sink1";
@@ -1219,10 +1207,10 @@ 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));
+    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));
 
     am_Gateway_s gateway, gateway1;
     am_gatewayID_t gatewayID, gatewayID1;
@@ -1250,8 +1238,8 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats)
     gateway1.convertionMatrix.push_back(true);
     gateway1.name = "gateway";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1, gatewayID1));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -1284,15 +1272,14 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsListConnectionFormats)
     compareRoute.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
-	am::am_Sink_s sinkDb;
-	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
-	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
-	getRoute(false, sourceDb, sinkDb, listRoutes);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    ASSERT_EQ(getRoute(false, false, sourceDb, sinkDb, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
-
 //test that checks 4 domains, one sink and one source but there are 2 routes because there are 2 gateways
 TEST_F(CAmRouterMapTest,simpleRoute4Domains2Routes)
 {
@@ -1319,17 +1306,17 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains2Routes)
     domain4.busname = "domain4bus";
     domain4.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3,domainID3));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain4,domainID4));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3, domainID3));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain4, domainID4));
 
     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;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -1366,12 +1353,12 @@ 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));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource2,gwSourceID2));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource3,gwSourceID3));
+    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));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource2, gwSourceID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource3, gwSourceID3));
 
     am_Sink_s sink, gwSink, gwSink1, gwSink2, gwSink3;
     am_sinkID_t sinkID, gwSinkID, gwSinkID1, gwSinkID2, gwSinkID3;
@@ -1411,15 +1398,15 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains2Routes)
     sink.muteState = MS_MUTED;
     sink.listConnectionFormats.push_back(CF_GENIVI_STEREO);
     am_SinkClass_s sinkclass;
-    sinkclass.sinkClassID=5;
-    sinkclass.name="sname";
+    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));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink2,gwSinkID2));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink3,gwSinkID3));
+    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));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink2, gwSinkID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink3, gwSinkID3));
 
     am_Gateway_s gateway, gateway1, gateway2, gateway3;
     am_gatewayID_t gatewayID, gatewayID1, gatewayID2, gatewayID3;
@@ -1468,10 +1455,10 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains2Routes)
     gateway3.convertionMatrix.push_back(true);
     gateway3.name = "gateway3";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway3,gatewayID3));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1, gatewayID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway2, gatewayID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway3, gatewayID3));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements, listRoutingElements1;
@@ -1531,20 +1518,22 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains2Routes)
     compareRoute1.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
-	am::am_Sink_s sinkDb;
-	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
-	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
-	getRoute(false, sourceDb, sinkDb, listRoutes);
-	ASSERT_EQ(static_cast<uint>(2), listRoutes.size());
-
-    bool containsRoute1 = std::find_if(listRoutes.begin(), listRoutes.end(), [&](const am_Route_s & ref) {
-   		return pCF.compareRoute(compareRoute, ref);
-   })!=listRoutes.end();
-   bool containsRoute2 = std::find_if(listRoutes.begin(), listRoutes.end(), [&](const am_Route_s & ref) {
-      		return pCF.compareRoute(compareRoute1, ref);
-      })!=listRoutes.end();
-
-	ASSERT_TRUE(containsRoute1);
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    ASSERT_EQ(getRoute(false, false, sourceDb, sinkDb, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(2), listRoutes.size());
+
+    bool containsRoute1 = std::find_if(listRoutes.begin(), listRoutes.end(), [&](const am_Route_s & ref)
+    {
+        return pCF.compareRoute(compareRoute, ref);
+    }) != listRoutes.end();
+    bool containsRoute2 = std::find_if(listRoutes.begin(), listRoutes.end(), [&](const am_Route_s & ref)
+    {
+        return pCF.compareRoute(compareRoute1, ref);
+    }) != listRoutes.end();
+
+    ASSERT_TRUE(containsRoute1);
     ASSERT_TRUE(containsRoute2);
 }
 
@@ -1570,9 +1559,9 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsNoConnection)
     domain3.busname = "domain3bus";
     domain3.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3,domainID3));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3, domainID3));
 
     am_Source_s source, gwSource, gwSource1;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1;
@@ -1585,8 +1574,8 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsNoConnection)
     source.listConnectionFormats.push_back(CF_GENIVI_MONO);
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     gwSource.domainID = domainID2;
     gwSource.name = "gwsource1";
@@ -1602,10 +1591,10 @@ 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));
+    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;
@@ -1617,8 +1606,8 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsNoConnection)
     sink.muteState = MS_MUTED;
     sink.listConnectionFormats.push_back(CF_GENIVI_STEREO);
     am_SinkClass_s sinkclass;
-    sinkclass.sinkClassID=5;
-    sinkclass.name="sname";
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     gwSink.domainID = domainID1;
     gwSink.name = "gwSink";
@@ -1634,10 +1623,10 @@ 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));
+    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));
 
     am_Gateway_s gateway, gateway1;
     am_gatewayID_t gatewayID, gatewayID1;
@@ -1664,8 +1653,8 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsNoConnection)
     gateway1.convertionMatrix.push_back(true);
     gateway1.name = "gateway";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1, gatewayID1));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -1698,13 +1687,14 @@ TEST_F(CAmRouterMapTest,simpleRoute3DomainsNoConnection)
     compareRoute.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
- 	am::am_Sink_s sinkDb;
- 	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
- 	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
- 	listRoutes.clear();
- 	getRoute(false, sourceDb, sinkDb, listRoutes);
- 	ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    listRoutes.clear();
+    ASSERT_EQ(getRoute(false, false, sourceDb, sinkDb, listRoutes, 0), E_NOT_POSSIBLE);
+    ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
 }
+
 //test that checks just 2 domains, one sink one source with only one connection format each
 TEST_F(CAmRouterMapTest,simpleRoute2Domains)
 {
@@ -1723,8 +1713,8 @@ TEST_F(CAmRouterMapTest,simpleRoute2Domains)
     domain2.busname = "domain2bus";
     domain2.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
 
     am_Source_s source, gwSource;
     am_sourceID_t sourceID, gwSourceID;
@@ -1737,8 +1727,8 @@ TEST_F(CAmRouterMapTest,simpleRoute2Domains)
     source.listConnectionFormats.push_back(CF_GENIVI_ANALOG);
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     gwSource.domainID = domainID2;
     gwSource.name = "gwsource1";
@@ -1747,16 +1737,15 @@ 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));
+    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";
-
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     sink.domainID = domainID2;
     sink.name = "sink1";
@@ -1772,10 +1761,9 @@ 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));
+    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));
 
     am_Gateway_s gateway;
     am_gatewayID_t gatewayID;
@@ -1791,7 +1779,7 @@ TEST_F(CAmRouterMapTest,simpleRoute2Domains)
     gateway.convertionMatrix.push_back(true);
     gateway.name = "gateway";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -1817,12 +1805,12 @@ TEST_F(CAmRouterMapTest,simpleRoute2Domains)
     compareRoute.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
- 	am::am_Sink_s sinkDb;
- 	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
- 	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
- 	getRoute(false, sourceDb, sinkDb, listRoutes);
- 	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
- 	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    ASSERT_EQ(getRoute(false, false, sourceDb, sinkDb, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
 //test that checks just 2 domains, one sink one source but the connectionformat of source
@@ -1843,8 +1831,8 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsNoMatchConnectionFormats)
     domain2.busname = "domain2bus";
     domain2.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
 
     am_Source_s source, gwSource;
     am_sourceID_t sourceID, gwSourceID;
@@ -1857,8 +1845,8 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsNoMatchConnectionFormats)
     source.listConnectionFormats.push_back(CF_GENIVI_STEREO);
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     gwSource.domainID = domainID2;
     gwSource.name = "gwsource1";
@@ -1867,15 +1855,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));
+    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";
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     sink.domainID = domainID2;
     sink.name = "sink1";
@@ -1891,9 +1879,9 @@ 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));
+    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));
 
     am_Gateway_s gateway;
     am_gatewayID_t gatewayID;
@@ -1909,17 +1897,17 @@ TEST_F(CAmRouterMapTest,simpleRoute2DomainsNoMatchConnectionFormats)
     gateway.convertionMatrix.push_back(true);
     gateway.name = "gateway";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
 
     std::vector<am_Route_s> listRoutes;
 
     am::am_Source_s sourceDb;
- 	am::am_Sink_s sinkDb;
- 	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
- 	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
- 	getRoute(false, sourceDb, sinkDb, listRoutes);
- 	ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
- }
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    ASSERT_EQ(getRoute(false, false, sourceDb, sinkDb, listRoutes, 0), E_NOT_POSSIBLE);
+    ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
+}
 
 //test that checks 3 domains, one sink one source.
 TEST_F(CAmRouterMapTest,simpleRoute3Domains)
@@ -1943,16 +1931,16 @@ TEST_F(CAmRouterMapTest,simpleRoute3Domains)
     domain3.busname = "domain3bus";
     domain3.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3,domainID3));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3, domainID3));
 
     am_Source_s source, gwSource, gwSource1;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1;
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -1975,17 +1963,16 @@ 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));
+    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";
-
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
     sink.domainID = domainID3;
     sink.name = "sink1";
@@ -2008,10 +1995,10 @@ 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));
+    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));
 
     am_Gateway_s gateway, gateway1;
     am_gatewayID_t gatewayID, gatewayID1;
@@ -2038,8 +2025,8 @@ TEST_F(CAmRouterMapTest,simpleRoute3Domains)
     gateway1.convertionMatrix.push_back(true);
     gateway1.name = "gateway";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1, gatewayID1));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -2072,13 +2059,13 @@ TEST_F(CAmRouterMapTest,simpleRoute3Domains)
     compareRoute.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
-   	am::am_Sink_s sinkDb;
-   	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
-   	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
-   	listRoutes.clear();
-   	getRoute(false, sourceDb, sinkDb, listRoutes);
-   	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-   	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    listRoutes.clear();
+    ASSERT_EQ(getRoute(false, false, sourceDb, sinkDb, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
 //test that checks 4 domains, one sink and one source.
@@ -2107,17 +2094,17 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains)
     domain4.busname = "domain4bus";
     domain4.state = DS_CONTROLLED;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1,domainID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2,domainID2));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3,domainID3));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain4,domainID4));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain1, domainID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain2, domainID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain3, domainID3));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain4, domainID4));
 
     am_Source_s source, gwSource, gwSource1, gwSource2;
     am_sourceID_t sourceID, gwSourceID, gwSourceID1, gwSourceID2;
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
     source.domainID = domainID1;
     source.name = "source1";
@@ -2147,11 +2134,11 @@ 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));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource2,gwSourceID2));
+    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));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(gwSource2, gwSourceID2));
 
     am_Sink_s sink, gwSink, gwSink1, gwSink2;
     am_sinkID_t sinkID, gwSinkID, gwSinkID1, gwSinkID2;
@@ -2184,14 +2171,14 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains)
     sink.muteState = MS_MUTED;
     sink.listConnectionFormats.push_back(CF_GENIVI_STEREO);
     am_SinkClass_s sinkclass;
-    sinkclass.sinkClassID=5;
-    sinkclass.name="sname";
+    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));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink2,gwSinkID2));
+    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));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(gwSink2, gwSinkID2));
 
     am_Gateway_s gateway, gateway1, gateway2;
     am_gatewayID_t gatewayID, gatewayID1, gatewayID2;
@@ -2229,9 +2216,9 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains)
     gateway2.convertionMatrix.push_back(true);
     gateway2.name = "gateway2";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway,gatewayID));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1));
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway, gatewayID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway1, gatewayID1));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterGatewayDB(gateway2, gatewayID2));
 
     std::vector<am_Route_s> listRoutes;
     std::vector<am_RoutingElement_s> listRoutingElements;
@@ -2271,112 +2258,112 @@ TEST_F(CAmRouterMapTest,simpleRoute4Domains)
     compareRoute.sourceID = sourceID;
 
     am::am_Source_s sourceDb;
-   	am::am_Sink_s sinkDb;
-   	pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
-   	pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
-   	listRoutes.clear();
-   	getRoute(false, sourceDb, sinkDb, listRoutes);
-   	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-   	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    am::am_Sink_s sinkDb;
+    pDatabaseHandler.getSinkInfoDB(sinkID, sinkDb);
+    pDatabaseHandler.getSourceInfoDB(sourceID, sourceDb);
+    listRoutes.clear();
+    ASSERT_EQ(getRoute(false, false, sourceDb, sinkDb, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
 TEST_F(CAmRouterMapTest,getAllowedFormatsFromConvMatrix)
 {
-	std::vector<bool> convertionMatrix;
-	convertionMatrix.push_back(1);
-	convertionMatrix.push_back(0);
-	convertionMatrix.push_back(0);
-	convertionMatrix.push_back(1);
-	convertionMatrix.push_back(1);
-	convertionMatrix.push_back(0);
-
-	std::vector<am_CustomConnectionFormat_t> listSourceFormats;
-	listSourceFormats.push_back(CF_GENIVI_ANALOG);
-	listSourceFormats.push_back(CF_GENIVI_STEREO);
-
-	std::vector<am_CustomConnectionFormat_t> listSinkFormats;
-	listSinkFormats.push_back(CF_GENIVI_MONO);
-	listSinkFormats.push_back(CF_GENIVI_AUTO);
-	listSinkFormats.push_back(CF_GENIVI_STEREO);
-
-	std::vector<am_CustomConnectionFormat_t> sourceFormats;
-	std::vector<am_CustomConnectionFormat_t> sinkFormats;
-
-	ASSERT_TRUE(CAmRouter::getAllowedFormatsFromConvMatrix(convertionMatrix, listSourceFormats, listSinkFormats, sourceFormats, sinkFormats));
-
-	ASSERT_TRUE(sourceFormats.size()==3);
-	ASSERT_TRUE(sinkFormats.size()==3);
-	ASSERT_TRUE(sourceFormats.at(0)==CF_GENIVI_ANALOG);
-	ASSERT_TRUE(sourceFormats.at(1)==CF_GENIVI_STEREO);
-	ASSERT_TRUE(sourceFormats.at(2)==CF_GENIVI_ANALOG);
-	ASSERT_TRUE(sinkFormats.at(0)==CF_GENIVI_MONO);
-	ASSERT_TRUE(sinkFormats.at(1)==CF_GENIVI_AUTO);
-	ASSERT_TRUE(sinkFormats.at(2)==CF_GENIVI_STEREO);
-
-	sinkFormats.clear();
-	sourceFormats.clear();
-	convertionMatrix.clear();
-	listSinkFormats.clear();
-	listSourceFormats.clear();
-
-	convertionMatrix.push_back(1);
-	listSinkFormats.push_back(CF_GENIVI_STEREO);
-	listSourceFormats.push_back(CF_GENIVI_STEREO);
-
-	ASSERT_TRUE(CAmRouter::getAllowedFormatsFromConvMatrix(convertionMatrix, listSourceFormats, listSinkFormats, sourceFormats, sinkFormats));
-
-	sinkFormats.clear();
-	sourceFormats.clear();
-	convertionMatrix.clear();
-	listSinkFormats.clear();
-	listSourceFormats.clear();
-
-	convertionMatrix.push_back(1);
-	convertionMatrix.push_back(0);
-	listSourceFormats.push_back(CF_GENIVI_STEREO);
-	listSinkFormats.push_back(CF_GENIVI_STEREO);
-
-	ASSERT_FALSE(CAmRouter::getAllowedFormatsFromConvMatrix(convertionMatrix, listSourceFormats, listSinkFormats, sourceFormats, sinkFormats));
-
-	sinkFormats.clear();
-	sourceFormats.clear();
-	convertionMatrix.clear();
-	listSinkFormats.clear();
-	listSourceFormats.clear();
-
-	convertionMatrix.push_back(1);
-	listSinkFormats.push_back(CF_GENIVI_STEREO);
-
-	ASSERT_FALSE(CAmRouter::getAllowedFormatsFromConvMatrix(convertionMatrix, listSourceFormats, listSinkFormats, sourceFormats, sinkFormats));
+    std::vector<bool> convertionMatrix;
+    convertionMatrix.push_back(1);
+    convertionMatrix.push_back(0);
+    convertionMatrix.push_back(0);
+    convertionMatrix.push_back(1);
+    convertionMatrix.push_back(1);
+    convertionMatrix.push_back(0);
+
+    std::vector<am_CustomConnectionFormat_t> listSourceFormats;
+    listSourceFormats.push_back(CF_GENIVI_ANALOG);
+    listSourceFormats.push_back(CF_GENIVI_STEREO);
+
+    std::vector<am_CustomConnectionFormat_t> listSinkFormats;
+    listSinkFormats.push_back(CF_GENIVI_MONO);
+    listSinkFormats.push_back(CF_GENIVI_AUTO);
+    listSinkFormats.push_back(CF_GENIVI_STEREO);
+
+    std::vector<am_CustomConnectionFormat_t> sourceFormats;
+    std::vector<am_CustomConnectionFormat_t> sinkFormats;
+
+    ASSERT_TRUE(CAmRouter::getAllowedFormatsFromConvMatrix(convertionMatrix, listSourceFormats, listSinkFormats, sourceFormats, sinkFormats));
+
+    ASSERT_TRUE(sourceFormats.size() == 3);
+    ASSERT_TRUE(sinkFormats.size() == 3);
+    ASSERT_TRUE(sourceFormats.at(0) == CF_GENIVI_ANALOG);
+    ASSERT_TRUE(sourceFormats.at(1) == CF_GENIVI_STEREO);
+    ASSERT_TRUE(sourceFormats.at(2) == CF_GENIVI_ANALOG);
+    ASSERT_TRUE(sinkFormats.at(0) == CF_GENIVI_MONO);
+    ASSERT_TRUE(sinkFormats.at(1) == CF_GENIVI_AUTO);
+    ASSERT_TRUE(sinkFormats.at(2) == CF_GENIVI_STEREO);
+
+    sinkFormats.clear();
+    sourceFormats.clear();
+    convertionMatrix.clear();
+    listSinkFormats.clear();
+    listSourceFormats.clear();
+
+    convertionMatrix.push_back(1);
+    listSinkFormats.push_back(CF_GENIVI_STEREO);
+    listSourceFormats.push_back(CF_GENIVI_STEREO);
+
+    ASSERT_TRUE(CAmRouter::getAllowedFormatsFromConvMatrix(convertionMatrix, listSourceFormats, listSinkFormats, sourceFormats, sinkFormats));
+
+    sinkFormats.clear();
+    sourceFormats.clear();
+    convertionMatrix.clear();
+    listSinkFormats.clear();
+    listSourceFormats.clear();
+
+    convertionMatrix.push_back(1);
+    convertionMatrix.push_back(0);
+    listSourceFormats.push_back(CF_GENIVI_STEREO);
+    listSinkFormats.push_back(CF_GENIVI_STEREO);
+
+    ASSERT_FALSE(CAmRouter::getAllowedFormatsFromConvMatrix(convertionMatrix, listSourceFormats, listSinkFormats, sourceFormats, sinkFormats));
+
+    sinkFormats.clear();
+    sourceFormats.clear();
+    convertionMatrix.clear();
+    listSinkFormats.clear();
+    listSourceFormats.clear();
+
+    convertionMatrix.push_back(1);
+    listSinkFormats.push_back(CF_GENIVI_STEREO);
+
+    ASSERT_FALSE(CAmRouter::getAllowedFormatsFromConvMatrix(convertionMatrix, listSourceFormats, listSinkFormats, sourceFormats, sinkFormats));
 }
 
 TEST_F(CAmRouterMapTest,route1Domain1Source1Sink)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
-	am_domainID_t domainID1;
-	enterDomainDB("domain1", domainID1);
+    am_domainID_t domainID1;
+    enterDomainDB("domain1", domainID1);
 
-	am_sourceID_t sourceID;
-	std::vector<am_CustomConnectionFormat_t> cf1;
-	cf1.push_back(CF_GENIVI_STEREO);
-	cf1.push_back(CF_GENIVI_ANALOG);
+    am_sourceID_t sourceID;
+    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);
+    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_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);
+    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;
     am::am_Sink_s sink;
@@ -2385,75 +2372,74 @@ TEST_F(CAmRouterMapTest,route1Domain1Source1Sink)
     pDatabaseHandler.getSourceInfoDB(sourceID, source);
 
     std::vector<am_Route_s> listRoutes;
-	std::vector<am_RoutingElement_s> listRoutingElements;
-	am_RoutingElement_s hopp1;
+    std::vector<am_RoutingElement_s> listRoutingElements;
+    am_RoutingElement_s hopp1;
 
-	hopp1.sourceID = sourceID;
-	hopp1.sinkID = sinkID;
-	hopp1.domainID = domainID1;
-	hopp1.connectionFormat = cf2[0];
+    hopp1.sourceID = sourceID;
+    hopp1.sinkID = sinkID;
+    hopp1.domainID = domainID1;
+    hopp1.connectionFormat = cf2[0];
 
-	listRoutingElements.push_back(hopp1);
+    listRoutingElements.push_back(hopp1);
 
-	am_Route_s compareRoute;
-	compareRoute.route = listRoutingElements;
-	compareRoute.sinkID = sinkID;
-	compareRoute.sourceID = sourceID;
+    am_Route_s compareRoute;
+    compareRoute.route = listRoutingElements;
+    compareRoute.sinkID = sinkID;
+    compareRoute.sourceID = sourceID;
 
-   	getRoute(false, source, sink, listRoutes);
-   	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-   	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    ASSERT_EQ(getRoute(false, false, source, sink, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
 TEST_F(CAmRouterMapTest,route1Domain1Source1Converter1Sink)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
-	am_domainID_t domainID1;
-	enterDomainDB("domain1", domainID1);
+    am_domainID_t domainID1;
+    enterDomainDB("domain1", domainID1);
 
-	am_sourceID_t sourceID;
-	std::vector<am_CustomConnectionFormat_t> cf1;
-	cf1.push_back(CF_GENIVI_STEREO);
-	cf1.push_back(CF_GENIVI_AUTO);
+    am_sourceID_t sourceID;
+    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;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
-	enterSourceDB("source1", domainID1, cf1, sourceID);
+    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_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";
-
+    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);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass, sinkclass.sinkClassID));
+    enterSinkDB("sink1", domainID1, cf2, sinkID1);
+    enterSinkDB("sink2", domainID1, cf2, sinkID2);
 
-	am_sourceID_t gwSourceID;
-	std::vector<am_CustomConnectionFormat_t> cf3;
-	cf3.push_back(CF_GENIVI_MONO);
-	cf3.push_back(CF_GENIVI_ANALOG);
-	enterSourceDB("gwSource1", domainID1, cf3, gwSourceID);
+    am_sourceID_t gwSourceID;
+    std::vector<am_CustomConnectionFormat_t> cf3;
+    cf3.push_back(CF_GENIVI_MONO);
+    cf3.push_back(CF_GENIVI_ANALOG);
+    enterSourceDB("gwSource1", domainID1, cf3, gwSourceID);
 
-	am_sinkID_t gwSinkID;
-	std::vector<am_CustomConnectionFormat_t> cf4;
-	cf4.push_back(CF_GENIVI_STEREO);
-	cf4.push_back(CF_GENIVI_ANALOG);
-	enterSinkDB("gwSink1", domainID1, cf4, gwSinkID);
+    am_sinkID_t gwSinkID;
+    std::vector<am_CustomConnectionFormat_t> cf4;
+    cf4.push_back(CF_GENIVI_STEREO);
+    cf4.push_back(CF_GENIVI_ANALOG);
+    enterSinkDB("gwSink1", domainID1, cf4, gwSinkID);
 
     am_converterID_t converterID;
     std::vector<bool> matrix;
     matrix.resize(4, false);
-    matrix[0]=(true);
-    matrix[1]=(true);
+    matrix[0] = (true);
+    matrix[1] = (true);
     enterConverterDB("converter", domainID1, cf3, cf4, matrix, gwSourceID, gwSinkID, converterID);
 
     am::am_Source_s source;
@@ -2463,87 +2449,86 @@ TEST_F(CAmRouterMapTest,route1Domain1Source1Converter1Sink)
     pDatabaseHandler.getSourceInfoDB(sourceID, source);
 
     std::vector<am_Route_s> listRoutes;
-	std::vector<am_RoutingElement_s> listRoutingElements;
-	am_RoutingElement_s hopp1;
-	am_RoutingElement_s hopp2;
-
-	hopp1.sourceID = sourceID;
-	hopp1.sinkID = gwSinkID;
-	hopp1.domainID = domainID1;
-	hopp1.connectionFormat = CF_GENIVI_STEREO;
-
-	hopp2.sourceID = gwSourceID;
-	hopp2.sinkID = sinkID1;
-	hopp2.domainID = domainID1;
-	hopp2.connectionFormat = CF_GENIVI_MONO;
-
-	listRoutingElements.push_back(hopp1);
-	listRoutingElements.push_back(hopp2);
-
-	am_Route_s compareRoute;
-	compareRoute.route = listRoutingElements;
-	compareRoute.sinkID = sinkID1;
-	compareRoute.sourceID = sourceID;
-
-   	getRoute(false, source, sink, listRoutes);
-   	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-   	ASSERT_TRUE(pCF.compareRoute(compareRoute,listRoutes[0]));
+    std::vector<am_RoutingElement_s> listRoutingElements;
+    am_RoutingElement_s hopp1;
+    am_RoutingElement_s hopp2;
+
+    hopp1.sourceID = sourceID;
+    hopp1.sinkID = gwSinkID;
+    hopp1.domainID = domainID1;
+    hopp1.connectionFormat = CF_GENIVI_STEREO;
+
+    hopp2.sourceID = gwSourceID;
+    hopp2.sinkID = sinkID1;
+    hopp2.domainID = domainID1;
+    hopp2.connectionFormat = CF_GENIVI_MONO;
+
+    listRoutingElements.push_back(hopp1);
+    listRoutingElements.push_back(hopp2);
+
+    am_Route_s compareRoute;
+    compareRoute.route = listRoutingElements;
+    compareRoute.sinkID = sinkID1;
+    compareRoute.sourceID = sourceID;
+
+    ASSERT_EQ(getRoute(false, false, source, sink, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute, listRoutes[0]));
 }
 
 TEST_F(CAmRouterMapTest,route1Domain1Source3Converters1Sink)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID, sourceclass));
 
     am_SinkClass_s sinkclass;
-    sinkclass.sinkClassID=5;
-    sinkclass.name="sname";
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass, sinkclass.sinkClassID));
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
-
-	am_domainID_t domainID1;
-	enterDomainDB("domain1", domainID1);
+    am_domainID_t domainID1;
+    enterDomainDB("domain1", domainID1);
 
-	std::vector<am_CustomConnectionFormat_t> cf1;
-	cf1.push_back(CF_GENIVI_STEREO);
-	std::vector<am_CustomConnectionFormat_t> cf2;
-	cf2.push_back(CF_GENIVI_MONO);
-	std::vector<am_CustomConnectionFormat_t> cf3;
-	cf3.push_back(CF_GENIVI_AUTO);
+    std::vector<am_CustomConnectionFormat_t> cf1;
+    cf1.push_back(CF_GENIVI_STEREO);
+    std::vector<am_CustomConnectionFormat_t> cf2;
+    cf2.push_back(CF_GENIVI_MONO);
+    std::vector<am_CustomConnectionFormat_t> cf3;
+    cf3.push_back(CF_GENIVI_AUTO);
 
-	am_sourceID_t sourceID;
-	enterSourceDB("source1", domainID1, cf1, sourceID);
+    am_sourceID_t sourceID;
+    enterSourceDB("source1", domainID1, cf1, sourceID);
 
-	am_sinkID_t sinkID;
-	enterSinkDB("sink1", domainID1, cf3, sinkID);
+    am_sinkID_t sinkID;
+    enterSinkDB("sink1", domainID1, cf3, sinkID);
 
-	am_sourceID_t gwSourceID;
-	enterSourceDB("gwSource1", domainID1, cf2, gwSourceID);
-	am_sinkID_t gwSinkID;
-	enterSinkDB("gwSink1", domainID1, cf1, gwSinkID);
+    am_sourceID_t gwSourceID;
+    enterSourceDB("gwSource1", domainID1, cf2, gwSourceID);
+    am_sinkID_t gwSinkID;
+    enterSinkDB("gwSink1", domainID1, cf1, gwSinkID);
     am_converterID_t converterID;
     std::vector<bool> matrix;
     matrix.push_back(true);
     enterConverterDB("converter1", domainID1, cf2, cf1, matrix, gwSourceID, gwSinkID, converterID);
 
-	am_sourceID_t gwSourceID1;
-	enterSourceDB("gwSource2", domainID1, cf2, gwSourceID1);
-	am_sinkID_t gwSinkID1;
-	enterSinkDB("gwSink2", domainID1, cf1, gwSinkID1);
+    am_sourceID_t gwSourceID1;
+    enterSourceDB("gwSource2", domainID1, cf2, gwSourceID1);
+    am_sinkID_t gwSinkID1;
+    enterSinkDB("gwSink2", domainID1, cf1, gwSinkID1);
     am_converterID_t converterID1;
     enterConverterDB("converter2", domainID1, cf2, cf1, matrix, gwSourceID1, gwSinkID1, converterID1);
 
-	am_sourceID_t gwSourceID2;
-	enterSourceDB("gwSource3", domainID1, cf3, gwSourceID2);
-	am_sinkID_t gwSinkID2;
-	enterSinkDB("gwSink3", domainID1, cf2, gwSinkID2);
+    am_sourceID_t gwSourceID2;
+    enterSourceDB("gwSource3", domainID1, cf3, gwSourceID2);
+    am_sinkID_t gwSinkID2;
+    enterSinkDB("gwSink3", domainID1, cf2, gwSinkID2);
     am_converterID_t converterID2;
     enterConverterDB("converter3", domainID1, cf3, cf2, matrix, gwSourceID2, gwSinkID2, converterID2);
 
@@ -2552,106 +2537,104 @@ TEST_F(CAmRouterMapTest,route1Domain1Source3Converters1Sink)
     pDatabaseHandler.getSinkInfoDB(sinkID, sink);
     pDatabaseHandler.getSourceInfoDB(sourceID, source);
 
-
     std::vector<am_Route_s> listRoutes;
-	std::vector<am_RoutingElement_s> listRoutingElements1;
-	std::vector<am_RoutingElement_s> listRoutingElements2;
-	am_RoutingElement_s hopp11;
-	am_RoutingElement_s hopp12;
-	am_RoutingElement_s hopp13;
-	am_RoutingElement_s hopp21;
-	am_RoutingElement_s hopp22;
-
-	hopp11.sourceID = sourceID;
-	hopp11.sinkID = gwSinkID;
-	hopp11.domainID = domainID1;
-	hopp11.connectionFormat = CF_GENIVI_STEREO;
-
-	hopp12.sourceID = gwSourceID;
-	hopp12.sinkID = gwSinkID2;
-	hopp12.domainID = domainID1;
-	hopp12.connectionFormat = CF_GENIVI_MONO;
-
-	hopp21.sourceID = sourceID;
-	hopp21.sinkID = gwSinkID1;
-	hopp21.domainID = domainID1;
-	hopp21.connectionFormat = CF_GENIVI_STEREO;
-
-	hopp22.sourceID = gwSourceID1;
-	hopp22.sinkID = gwSinkID2;
-	hopp22.domainID = domainID1;
-	hopp22.connectionFormat = CF_GENIVI_MONO;
-
-	hopp13.sourceID = gwSourceID2;
-	hopp13.sinkID = sinkID;
-	hopp13.domainID = domainID1;
-	hopp13.connectionFormat = CF_GENIVI_AUTO;
-
-	listRoutingElements1.push_back(hopp11);
-	listRoutingElements1.push_back(hopp12);
-	listRoutingElements1.push_back(hopp13);
-
-	listRoutingElements2.push_back(hopp21);
-	listRoutingElements2.push_back(hopp22);
-	listRoutingElements2.push_back(hopp13);
-
-	am_Route_s compareRoute1;
-	compareRoute1.route = listRoutingElements1;
-	compareRoute1.sinkID = sinkID;
-	compareRoute1.sourceID = sourceID;
-
-	getRoute(false, source, sink, listRoutes);
-	ASSERT_EQ(static_cast<uint>(2), listRoutes.size());
-	ASSERT_TRUE(pCF.compareRoute(compareRoute1,listRoutes[0])||pCF.compareRoute(compareRoute1,listRoutes[1]));
-
-	am_Route_s compareRoute2;
-	compareRoute2.route = listRoutingElements2;
-	compareRoute2.sinkID = sinkID;
-	compareRoute2.sourceID = sourceID;
-	ASSERT_TRUE(pCF.compareRoute(compareRoute2,listRoutes[1])||pCF.compareRoute(compareRoute2,listRoutes[0]));
+    std::vector<am_RoutingElement_s> listRoutingElements1;
+    std::vector<am_RoutingElement_s> listRoutingElements2;
+    am_RoutingElement_s hopp11;
+    am_RoutingElement_s hopp12;
+    am_RoutingElement_s hopp13;
+    am_RoutingElement_s hopp21;
+    am_RoutingElement_s hopp22;
+
+    hopp11.sourceID = sourceID;
+    hopp11.sinkID = gwSinkID;
+    hopp11.domainID = domainID1;
+    hopp11.connectionFormat = CF_GENIVI_STEREO;
+
+    hopp12.sourceID = gwSourceID;
+    hopp12.sinkID = gwSinkID2;
+    hopp12.domainID = domainID1;
+    hopp12.connectionFormat = CF_GENIVI_MONO;
+
+    hopp21.sourceID = sourceID;
+    hopp21.sinkID = gwSinkID1;
+    hopp21.domainID = domainID1;
+    hopp21.connectionFormat = CF_GENIVI_STEREO;
+
+    hopp22.sourceID = gwSourceID1;
+    hopp22.sinkID = gwSinkID2;
+    hopp22.domainID = domainID1;
+    hopp22.connectionFormat = CF_GENIVI_MONO;
+
+    hopp13.sourceID = gwSourceID2;
+    hopp13.sinkID = sinkID;
+    hopp13.domainID = domainID1;
+    hopp13.connectionFormat = CF_GENIVI_AUTO;
+
+    listRoutingElements1.push_back(hopp11);
+    listRoutingElements1.push_back(hopp12);
+    listRoutingElements1.push_back(hopp13);
+
+    listRoutingElements2.push_back(hopp21);
+    listRoutingElements2.push_back(hopp22);
+    listRoutingElements2.push_back(hopp13);
+
+    am_Route_s compareRoute1;
+    compareRoute1.route = listRoutingElements1;
+    compareRoute1.sinkID = sinkID;
+    compareRoute1.sourceID = sourceID;
+
+    ASSERT_EQ(getRoute(false, false, source, sink, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(2), listRoutes.size());
+    ASSERT_TRUE(pCF.compareRoute(compareRoute1, listRoutes[0]) || pCF.compareRoute(compareRoute1, listRoutes[1]));
+
+    am_Route_s compareRoute2;
+    compareRoute2.route = listRoutingElements2;
+    compareRoute2.sinkID = sinkID;
+    compareRoute2.sourceID = sourceID;
+    ASSERT_TRUE(pCF.compareRoute(compareRoute2, listRoutes[1]) || pCF.compareRoute(compareRoute2, listRoutes[0]));
 }
 
 TEST_F(CAmRouterMapTest,route2Domains1Source1Sink)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID, sourceclass));
 
     am_SinkClass_s sinkclass;
-    sinkclass.sinkClassID=5;
-    sinkclass.name="sname";
-
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass, sinkclass.sinkClassID));
 
-	am_domainID_t domainID1, domainID2;
-	enterDomainDB("domain1", domainID1);
-	enterDomainDB("domain2", domainID2);
+    am_domainID_t domainID1, domainID2;
+    enterDomainDB("domain1", domainID1);
+    enterDomainDB("domain2", domainID2);
 
-	am_sourceID_t sourceID;
-	std::vector<am_CustomConnectionFormat_t> cf1;
-	cf1.push_back(CF_GENIVI_STEREO);
-	enterSourceDB("source1", domainID1, cf1, sourceID);
+    am_sourceID_t sourceID;
+    std::vector<am_CustomConnectionFormat_t> cf1;
+    cf1.push_back(CF_GENIVI_STEREO);
+    enterSourceDB("source1", domainID1, cf1, sourceID);
 
-	am_sinkID_t sinkID;
-	std::vector<am_CustomConnectionFormat_t> cf2;
-	cf2.push_back(CF_GENIVI_ANALOG);
-	enterSinkDB("sink1", domainID2, cf2, sinkID);
+    am_sinkID_t sinkID;
+    std::vector<am_CustomConnectionFormat_t> cf2;
+    cf2.push_back(CF_GENIVI_ANALOG);
+    enterSinkDB("sink1", domainID2, cf2, sinkID);
 
-	am_sourceID_t gwSourceID;
-	std::vector<am_CustomConnectionFormat_t> cf3;
-	cf3.push_back(CF_GENIVI_ANALOG);
-	enterSourceDB("gwSource1", domainID2, cf3, gwSourceID);
+    am_sourceID_t gwSourceID;
+    std::vector<am_CustomConnectionFormat_t> cf3;
+    cf3.push_back(CF_GENIVI_ANALOG);
+    enterSourceDB("gwSource1", domainID2, cf3, gwSourceID);
 
-	am_sinkID_t gwSinkID;
-	std::vector<am_CustomConnectionFormat_t> cf4;
-	cf4.push_back(CF_GENIVI_STEREO);
-	enterSinkDB("gwSink1", domainID1, cf4, gwSinkID);
+    am_sinkID_t gwSinkID;
+    std::vector<am_CustomConnectionFormat_t> cf4;
+    cf4.push_back(CF_GENIVI_STEREO);
+    enterSinkDB("gwSink1", domainID1, cf4, gwSinkID);
 
     am_gatewayID_t gatewayID;
     std::vector<bool> matrix;
@@ -2665,58 +2648,59 @@ TEST_F(CAmRouterMapTest,route2Domains1Source1Sink)
     pDatabaseHandler.getSourceInfoDB(sourceID, source);
     std::vector<am_Route_s> listRoutes;
 
-	getRoute(false, source, sink, listRoutes);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_EQ(getRoute(false, false, source, sink, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
 
-	am_Route_s compareRoute1;
-	compareRoute1.sinkID = sinkID;
-	compareRoute1.sourceID = sourceID;
-	compareRoute1.route.push_back({sourceID, gwSinkID, domainID1, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gwSourceID, sinkID, domainID2, CF_GENIVI_ANALOG});
-	ASSERT_TRUE(pCF.compareRoute(compareRoute1,listRoutes[0]));
+    am_Route_s compareRoute1;
+    compareRoute1.sinkID = sinkID;
+    compareRoute1.sourceID = sourceID;
+    compareRoute1.route.push_back(
+    { sourceID, gwSinkID, domainID1, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gwSourceID, sinkID, domainID2, CF_GENIVI_ANALOG });
+    ASSERT_TRUE(pCF.compareRoute(compareRoute1, listRoutes[0]));
 }
 
 TEST_F(CAmRouterMapTest,route3Domains1Source1Sink)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID, sourceclass));
 
     am_SinkClass_s sinkclass;
-    sinkclass.sinkClassID=5;
-    sinkclass.name="sname";
-
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass, sinkclass.sinkClassID));
 
-	am_domainID_t domainID1, domainID2, domainID3;
-	enterDomainDB("domain1", domainID1);
-	enterDomainDB("domain2", domainID2);
-	enterDomainDB("domain3", domainID3);
+    am_domainID_t domainID1, domainID2, domainID3;
+    enterDomainDB("domain1", domainID1);
+    enterDomainDB("domain2", domainID2);
+    enterDomainDB("domain3", domainID3);
 
-	std::vector<am_CustomConnectionFormat_t> cfStereo;
-	cfStereo.push_back(CF_GENIVI_STEREO);
-	std::vector<am_CustomConnectionFormat_t> cfAnalog;
-	cfAnalog.push_back(CF_GENIVI_ANALOG);
-	std::vector<am_CustomConnectionFormat_t> cfMono;
-	cfMono.push_back(CF_GENIVI_MONO);
+    std::vector<am_CustomConnectionFormat_t> cfStereo;
+    cfStereo.push_back(CF_GENIVI_STEREO);
+    std::vector<am_CustomConnectionFormat_t> cfAnalog;
+    cfAnalog.push_back(CF_GENIVI_ANALOG);
+    std::vector<am_CustomConnectionFormat_t> cfMono;
+    cfMono.push_back(CF_GENIVI_MONO);
 
-	am_sourceID_t sourceID;
-	enterSourceDB("source1", domainID1, cfStereo, sourceID);
+    am_sourceID_t sourceID;
+    enterSourceDB("source1", domainID1, cfStereo, sourceID);
 
-	am_sinkID_t gwSinkID1;
-	enterSinkDB("gwSink1", domainID1, cfStereo, gwSinkID1);
+    am_sinkID_t gwSinkID1;
+    enterSinkDB("gwSink1", domainID1, cfStereo, gwSinkID1);
 
-	am_sourceID_t gwSourceID1;
-	enterSourceDB("gwSource1", domainID2, cfMono, gwSourceID1);
+    am_sourceID_t gwSourceID1;
+    enterSourceDB("gwSource1", domainID2, cfMono, gwSourceID1);
 
-	std::vector<bool> matrix;
-	matrix.push_back(true);
+    std::vector<bool> matrix;
+    matrix.push_back(true);
 
     am_gatewayID_t gatewayID;
     enterGatewayDB("gateway", domainID2, domainID1, cfMono, cfStereo, matrix, gwSourceID1, gwSinkID1, gatewayID);
@@ -2727,8 +2711,8 @@ TEST_F(CAmRouterMapTest,route3Domains1Source1Sink)
     am_sinkID_t gwSinkID2;
     enterSinkDB("gwSink2", domainID2, cfMono, gwSinkID2);
 
-	am_sinkID_t sinkID;
-	enterSinkDB("sink1", domainID3, cfStereo, sinkID);
+    am_sinkID_t sinkID;
+    enterSinkDB("sink1", domainID3, cfStereo, sinkID);
 
     am_gatewayID_t gatewayID1;
     enterGatewayDB("gateway", domainID3, domainID2, cfStereo, cfMono, matrix, gwSourceID2, gwSinkID2, gatewayID1);
@@ -2741,65 +2725,67 @@ TEST_F(CAmRouterMapTest,route3Domains1Source1Sink)
 
     std::vector<am_Route_s> listRoutes;
 
-	getRoute(false, source, sink, listRoutes);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_EQ(getRoute(false, false, source, sink, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
 
-	am_Route_s compareRoute1;
-	compareRoute1.sinkID = sinkID;
-	compareRoute1.sourceID = sourceID;
-	compareRoute1.route.push_back({sourceID, gwSinkID1, domainID1, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gwSourceID1, gwSinkID2, domainID2, CF_GENIVI_MONO});
-	compareRoute1.route.push_back({gwSourceID2, sinkID, domainID3, CF_GENIVI_STEREO});
-	ASSERT_TRUE(pCF.compareRoute(compareRoute1,listRoutes[0]));
+    am_Route_s compareRoute1;
+    compareRoute1.sinkID = sinkID;
+    compareRoute1.sourceID = sourceID;
+    compareRoute1.route.push_back(
+    { sourceID, gwSinkID1, domainID1, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gwSourceID1, gwSinkID2, domainID2, CF_GENIVI_MONO });
+    compareRoute1.route.push_back(
+    { gwSourceID2, sinkID, domainID3, CF_GENIVI_STEREO });
+    ASSERT_TRUE(pCF.compareRoute(compareRoute1, listRoutes[0]));
 }
 
 TEST_F(CAmRouterMapTest,routeSource1Sink2PathThroughConv1Gate1)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID, sourceclass));
 
     am_SinkClass_s sinkclass;
-    sinkclass.sinkClassID=5;
-    sinkclass.name="sname";
-
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass, sinkclass.sinkClassID));
 
-	std::vector<bool> matrix;
-	matrix.push_back(true);
-	am_domainID_t domainID1, domainID2;
-	enterDomainDB("domain1", domainID1);
-	enterDomainDB("domain2", domainID2);
-
-	std::vector<am_CustomConnectionFormat_t> cfStereo;
-	cfStereo.push_back(CF_GENIVI_STEREO);
-	std::vector<am_CustomConnectionFormat_t> cfAnalog;
-	cfAnalog.push_back(CF_GENIVI_ANALOG);
-	std::vector<am_CustomConnectionFormat_t> cfMono;
-	cfMono.push_back(CF_GENIVI_MONO);
-	std::vector<am_CustomConnectionFormat_t> cfAuto;
-	cfAuto.push_back(CF_GENIVI_AUTO);
+    std::vector<bool> matrix;
+    matrix.push_back(true);
+    am_domainID_t domainID1, domainID2;
+    enterDomainDB("domain1", domainID1);
+    enterDomainDB("domain2", domainID2);
+
+    std::vector<am_CustomConnectionFormat_t> cfStereo;
+    cfStereo.push_back(CF_GENIVI_STEREO);
+    std::vector<am_CustomConnectionFormat_t> cfAnalog;
+    cfAnalog.push_back(CF_GENIVI_ANALOG);
+    std::vector<am_CustomConnectionFormat_t> cfMono;
+    cfMono.push_back(CF_GENIVI_MONO);
+    std::vector<am_CustomConnectionFormat_t> cfAuto;
+    cfAuto.push_back(CF_GENIVI_AUTO);
 
-	am_sourceID_t sourceID;
-	enterSourceDB("source1", domainID1, cfStereo, sourceID);
+    am_sourceID_t sourceID;
+    enterSourceDB("source1", domainID1, cfStereo, sourceID);
 
-	am_sinkID_t gwSinkID1;
-	enterSinkDB("gwSink1", domainID1, cfMono, gwSinkID1);
+    am_sinkID_t gwSinkID1;
+    enterSinkDB("gwSink1", domainID1, cfMono, gwSinkID1);
 
-	am_sinkID_t coSinkID21;
+    am_sinkID_t coSinkID21;
     enterSinkDB("coSink21", domainID1, cfStereo, coSinkID21);
 
-	am_sourceID_t coSourceID21;
-	enterSourceDB("coSource21", domainID1, cfMono, coSourceID21);
+    am_sourceID_t coSourceID21;
+    enterSourceDB("coSource21", domainID1, cfMono, coSourceID21);
 
-	am_converterID_t converterID1;
-	enterConverterDB("converter1", domainID1, cfMono, cfStereo, matrix, coSourceID21, coSinkID21, converterID1);
+    am_converterID_t converterID1;
+    enterConverterDB("converter1", domainID1, cfMono, cfStereo, matrix, coSourceID21, coSinkID21, converterID1);
 
     am_sourceID_t gwSourceID1;
     enterSourceDB("gwSource21", domainID2, cfAuto, gwSourceID1);
@@ -2807,11 +2793,11 @@ TEST_F(CAmRouterMapTest,routeSource1Sink2PathThroughConv1Gate1)
     am_gatewayID_t gatewayID;
     enterGatewayDB("gateway1", domainID2, domainID1, cfAuto, cfMono, matrix, gwSourceID1, gwSinkID1, gatewayID);
 
-	am_sinkID_t sinkID1;
-	enterSinkDB("sink1", domainID2, cfAuto, sinkID1);
+    am_sinkID_t sinkID1;
+    enterSinkDB("sink1", domainID2, cfAuto, sinkID1);
 
-	am_sinkID_t sinkID2;
-	enterSinkDB("sink2", domainID1, cfAuto, sinkID2);
+    am_sinkID_t sinkID2;
+    enterSinkDB("sink2", domainID1, cfAuto, sinkID2);
 
     am::am_Source_s source;
     am::am_Sink_s sink1;
@@ -2822,76 +2808,78 @@ TEST_F(CAmRouterMapTest,routeSource1Sink2PathThroughConv1Gate1)
 
     std::vector<am_Route_s> listRoutes;
 
-	getRoute(false, source, sink1, listRoutes);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-
- 	am_Route_s compareRoute1;
-	compareRoute1.sinkID = sinkID1;
-	compareRoute1.sourceID = sourceID;
-	compareRoute1.route.push_back({sourceID, coSinkID21, domainID1, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({coSourceID21, gwSinkID1, domainID1, CF_GENIVI_MONO});
-	compareRoute1.route.push_back({gwSourceID1, sinkID1, domainID2, CF_GENIVI_AUTO});
-	ASSERT_TRUE(pCF.compareRoute(compareRoute1,listRoutes[0]));
+    ASSERT_EQ(getRoute(false, false, source, sink1, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
 
-	listRoutes.clear();
-	getRoute(false, source, sink2, listRoutes);
-	ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
+    am_Route_s compareRoute1;
+    compareRoute1.sinkID = sinkID1;
+    compareRoute1.sourceID = sourceID;
+    compareRoute1.route.push_back(
+    { sourceID, coSinkID21, domainID1, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { coSourceID21, gwSinkID1, domainID1, CF_GENIVI_MONO });
+    compareRoute1.route.push_back(
+    { gwSourceID1, sinkID1, domainID2, CF_GENIVI_AUTO });
+    ASSERT_TRUE(pCF.compareRoute(compareRoute1, listRoutes[0]));
+
+    listRoutes.clear();
+    ASSERT_EQ(getRoute(false, false, source, sink2, listRoutes, 0), E_NOT_POSSIBLE);
+    ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
 }
 
 TEST_F(CAmRouterMapTest, routeSource1Sink1PathThroughDomain2)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID, sourceclass));
 
     am_SinkClass_s sinkclass;
-    sinkclass.sinkClassID=5;
-    sinkclass.name="sname";
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass, sinkclass.sinkClassID));
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass,sinkclass.sinkClassID));
-
-	std::vector<bool> matrix;
-	matrix.push_back(true);
-	am_domainID_t domainID1, domainID2;
-	enterDomainDB("domain1", domainID1);
-	enterDomainDB("domain2", domainID2);
-
-	std::vector<am_CustomConnectionFormat_t> cfStereo;
-	cfStereo.push_back(CF_GENIVI_STEREO);
-	std::vector<am_CustomConnectionFormat_t> cfAnalog;
-	cfAnalog.push_back(CF_GENIVI_ANALOG);
-	std::vector<am_CustomConnectionFormat_t> cfMono;
-	cfMono.push_back(CF_GENIVI_MONO);
-	std::vector<am_CustomConnectionFormat_t> cfAuto;
-	cfAuto.push_back(CF_GENIVI_AUTO);
+    std::vector<bool> matrix;
+    matrix.push_back(true);
+    am_domainID_t domainID1, domainID2;
+    enterDomainDB("domain1", domainID1);
+    enterDomainDB("domain2", domainID2);
+
+    std::vector<am_CustomConnectionFormat_t> cfStereo;
+    cfStereo.push_back(CF_GENIVI_STEREO);
+    std::vector<am_CustomConnectionFormat_t> cfAnalog;
+    cfAnalog.push_back(CF_GENIVI_ANALOG);
+    std::vector<am_CustomConnectionFormat_t> cfMono;
+    cfMono.push_back(CF_GENIVI_MONO);
+    std::vector<am_CustomConnectionFormat_t> cfAuto;
+    cfAuto.push_back(CF_GENIVI_AUTO);
 
-	am_sourceID_t sourceID;
-	enterSourceDB("source1", domainID1, cfStereo, sourceID);
+    am_sourceID_t sourceID;
+    enterSourceDB("source1", domainID1, cfStereo, sourceID);
 
-	am_sinkID_t gwSinkID11;
+    am_sinkID_t gwSinkID11;
     enterSinkDB("gwSink11", domainID1, cfStereo, gwSinkID11);
-	am_sourceID_t gwSourceID11;
-	enterSourceDB("gwSource11", domainID2, cfAnalog, gwSourceID11);
-	am_converterID_t gatewayID1;
-	enterGatewayDB("gateway1", domainID2, domainID1, cfAnalog, cfStereo, matrix, gwSourceID11, gwSinkID11, gatewayID1);
+    am_sourceID_t gwSourceID11;
+    enterSourceDB("gwSource11", domainID2, cfAnalog, gwSourceID11);
+    am_converterID_t gatewayID1;
+    enterGatewayDB("gateway1", domainID2, domainID1, cfAnalog, cfStereo, matrix, gwSourceID11, gwSinkID11, gatewayID1);
 
-	am_sinkID_t gwSinkID21;
+    am_sinkID_t gwSinkID21;
     enterSinkDB("gwSink21", domainID2, cfAnalog, gwSinkID21);
     am_sourceID_t gwSourceID12;
     enterSourceDB("gwSource12", domainID1, cfAuto, gwSourceID12);
     am_gatewayID_t gatewayID2;
     enterGatewayDB("gateway2", domainID1, domainID2, cfAuto, cfAnalog, matrix, gwSourceID12, gwSinkID21, gatewayID2);
 
-	am_sinkID_t sink1ID;
-	enterSinkDB("sink1", domainID1, cfAuto, sink1ID);
-	am_sinkID_t sink2ID;
-	enterSinkDB("sink2", domainID2, cfAnalog, sink2ID);
+    am_sinkID_t sink1ID;
+    enterSinkDB("sink1", domainID1, cfAuto, sink1ID);
+    am_sinkID_t sink2ID;
+    enterSinkDB("sink2", domainID2, cfAnalog, sink2ID);
 
     std::vector<am_Route_s> listRoutes;
 
@@ -2900,90 +2888,91 @@ TEST_F(CAmRouterMapTest, routeSource1Sink1PathThroughDomain2)
     pDatabaseHandler.getSinkInfoDB(sink1ID, sink1);
     pDatabaseHandler.getSourceInfoDB(sourceID, source);
 
-	getRoute(false, source, sink1, listRoutes);
-	ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
+    ASSERT_EQ(getRoute(false, false, source, sink1, listRoutes, 0), E_NOT_POSSIBLE);
+    ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
 
     am::am_Sink_s sink2;
     pDatabaseHandler.getSinkInfoDB(sink2ID, sink2);
 
-	getRoute(false, source, sink2, listRoutes);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    ASSERT_EQ(getRoute(false, false, source, sink2, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
 
- 	am_Route_s compareRoute1;
-	compareRoute1.sinkID = sink2ID;
-	compareRoute1.sourceID = sourceID;
-	compareRoute1.route.push_back({sourceID, gwSinkID11, domainID1, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gwSourceID11, sink2ID, domainID2, CF_GENIVI_ANALOG});
-	ASSERT_TRUE(pCF.compareRoute(compareRoute1,listRoutes[0]));
+    am_Route_s compareRoute1;
+    compareRoute1.sinkID = sink2ID;
+    compareRoute1.sourceID = sourceID;
+    compareRoute1.route.push_back(
+    { sourceID, gwSinkID11, domainID1, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gwSourceID11, sink2ID, domainID2, CF_GENIVI_ANALOG });
+    ASSERT_TRUE(pCF.compareRoute(compareRoute1, listRoutes[0]));
 }
 
 TEST_F(CAmRouterMapTest, routeSource1Sink1PathThroughGate1Conv2Gate2)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+    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));
+    sinkclass.sinkClassID = 5;
+    sinkclass.name = "sname";
 
-	std::vector<bool> matrix;
-	matrix.push_back(true);
-	am_domainID_t domainID1, domainID2;
-	enterDomainDB("domain1", domainID1);
-	enterDomainDB("domain2", domainID2);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkclass, sinkclass.sinkClassID));
 
-	std::vector<am_CustomConnectionFormat_t> cfStereo;
-	cfStereo.push_back(CF_GENIVI_STEREO);
-	std::vector<am_CustomConnectionFormat_t> cfAnalog;
-	cfAnalog.push_back(CF_GENIVI_ANALOG);
-	std::vector<am_CustomConnectionFormat_t> cfMono;
-	cfMono.push_back(CF_GENIVI_MONO);
-	std::vector<am_CustomConnectionFormat_t> cfAuto;
-	cfAuto.push_back(CF_GENIVI_AUTO);
+    std::vector<bool> matrix;
+    matrix.push_back(true);
+    am_domainID_t domainID1, domainID2;
+    enterDomainDB("domain1", domainID1);
+    enterDomainDB("domain2", domainID2);
+
+    std::vector<am_CustomConnectionFormat_t> cfStereo;
+    cfStereo.push_back(CF_GENIVI_STEREO);
+    std::vector<am_CustomConnectionFormat_t> cfAnalog;
+    cfAnalog.push_back(CF_GENIVI_ANALOG);
+    std::vector<am_CustomConnectionFormat_t> cfMono;
+    cfMono.push_back(CF_GENIVI_MONO);
+    std::vector<am_CustomConnectionFormat_t> cfAuto;
+    cfAuto.push_back(CF_GENIVI_AUTO);
 
-	am_sourceID_t sourceID;
-	enterSourceDB("source1", domainID1, cfStereo, sourceID);
+    am_sourceID_t sourceID;
+    enterSourceDB("source1", domainID1, cfStereo, sourceID);
 
-	am_sinkID_t gwSinkID11;
+    am_sinkID_t gwSinkID11;
     enterSinkDB("gwSink11", domainID1, cfStereo, gwSinkID11);
 
-	am_sourceID_t gwSourceID21;
-	enterSourceDB("gwSource21", domainID2, cfAnalog, gwSourceID21);
+    am_sourceID_t gwSourceID21;
+    enterSourceDB("gwSource21", domainID2, cfAnalog, gwSourceID21);
 
-	am_converterID_t gatewayID1;
-	enterGatewayDB("gateway1", domainID2, domainID1, cfAnalog, cfStereo, matrix, gwSourceID21, gwSinkID11, gatewayID1);
+    am_converterID_t gatewayID1;
+    enterGatewayDB("gateway1", domainID2, domainID1, cfAnalog, cfStereo, matrix, gwSourceID21, gwSinkID11, gatewayID1);
 
-	am_sinkID_t gwSinkID21;
+    am_sinkID_t gwSinkID21;
     enterSinkDB("gwSink21", domainID2, cfStereo, gwSinkID21);
 
     am_sourceID_t gwSourceID12;
     enterSourceDB("gwSource12", domainID1, cfAuto, gwSourceID12);
 
     am_sinkID_t coSinkID21;
-	enterSinkDB("coSink21", domainID2, cfAnalog, coSinkID21);
+    enterSinkDB("coSink21", domainID2, cfAnalog, coSinkID21);
 
-	am_sourceID_t coSourceID21;
-	enterSourceDB("coSource21", domainID2, cfStereo, coSourceID21);
+    am_sourceID_t coSourceID21;
+    enterSourceDB("coSource21", domainID2, cfStereo, coSourceID21);
 
-	am_converterID_t converterID2;
-	enterConverterDB("converter2", domainID2, cfStereo, cfAnalog, matrix, coSourceID21, coSinkID21, converterID2);
+    am_converterID_t converterID2;
+    enterConverterDB("converter2", domainID2, cfStereo, cfAnalog, matrix, coSourceID21, coSinkID21, converterID2);
 
     am_gatewayID_t gatewayID2;
     enterGatewayDB("gateway2", domainID1, domainID2, cfAuto, cfStereo, matrix, gwSourceID12, gwSinkID21, gatewayID2);
 
-	am_sinkID_t sink1ID;
-	enterSinkDB("sink1", domainID1, cfAuto, sink1ID);
-	am_sinkID_t sink2ID;
-	enterSinkDB("sink2", domainID2, cfStereo, sink2ID);
+    am_sinkID_t sink1ID;
+    enterSinkDB("sink1", domainID1, cfAuto, sink1ID);
+    am_sinkID_t sink2ID;
+    enterSinkDB("sink2", domainID2, cfStereo, sink2ID);
 
     am::am_Source_s source;
     am::am_Sink_s sink;
@@ -2993,112 +2982,113 @@ TEST_F(CAmRouterMapTest, routeSource1Sink1PathThroughGate1Conv2Gate2)
 
     std::vector<am_Route_s> listRoutes;
 
-	getRoute(false, source, sink, listRoutes);
-	ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
+    ASSERT_EQ(getRoute(false, false, source, sink, listRoutes, 0), E_NOT_POSSIBLE);
+    ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
 
     am::am_Sink_s sink1;
     pDatabaseHandler.getSinkInfoDB(sink2ID, sink1);
-	getRoute(false, source, sink1, listRoutes);
-
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
- 	am_Route_s compareRoute1;
-	compareRoute1.sinkID = sink2ID;
-	compareRoute1.sourceID = sourceID;
-	compareRoute1.route.push_back({sourceID, gwSinkID11, domainID1, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gwSourceID21, coSinkID21, domainID2, CF_GENIVI_ANALOG});
-	compareRoute1.route.push_back({coSourceID21, sink2ID, domainID2, CF_GENIVI_STEREO});
-	ASSERT_TRUE(pCF.compareRoute(compareRoute1,listRoutes[0]));
+    ASSERT_EQ(getRoute(false, false, source, sink1, listRoutes, 0), E_OK);
+
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    am_Route_s compareRoute1;
+    compareRoute1.sinkID = sink2ID;
+    compareRoute1.sourceID = sourceID;
+    compareRoute1.route.push_back(
+    { sourceID, gwSinkID11, domainID1, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gwSourceID21, coSinkID21, domainID2, CF_GENIVI_ANALOG });
+    compareRoute1.route.push_back(
+    { coSourceID21, sink2ID, domainID2, CF_GENIVI_STEREO });
+    ASSERT_TRUE(pCF.compareRoute(compareRoute1, listRoutes[0]));
 }
 
 TEST_F(CAmRouterMapTest, routeSource1Sink1PathThroughConv1Gate1Conv2Gate2)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+    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;
-	enterDomainDB("domain1", domainID1);
-	enterDomainDB("domain2", domainID2);
-
-	std::vector<am_CustomConnectionFormat_t> cfStereo;
-	cfStereo.push_back(CF_GENIVI_STEREO);
-	std::vector<am_CustomConnectionFormat_t> cfAnalog;
-	cfAnalog.push_back(CF_GENIVI_ANALOG);
-	std::vector<am_CustomConnectionFormat_t> cfMono;
-	cfMono.push_back(CF_GENIVI_MONO);
-	std::vector<am_CustomConnectionFormat_t> cfAuto;
-	cfAuto.push_back(CF_GENIVI_AUTO);
-	std::vector<am_CustomConnectionFormat_t> cfFuture1;
-	cfFuture1.push_back(5);
-	std::vector<am_CustomConnectionFormat_t> cfFuture2;
-	cfFuture2.push_back(6);
-
-	am_sourceID_t sourceID;
-	enterSourceDB("source1", domainID1, cfStereo, sourceID);
-
-	am_sinkID_t coSinkID11;
+    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;
+    enterDomainDB("domain1", domainID1);
+    enterDomainDB("domain2", domainID2);
+
+    std::vector<am_CustomConnectionFormat_t> cfStereo;
+    cfStereo.push_back(CF_GENIVI_STEREO);
+    std::vector<am_CustomConnectionFormat_t> cfAnalog;
+    cfAnalog.push_back(CF_GENIVI_ANALOG);
+    std::vector<am_CustomConnectionFormat_t> cfMono;
+    cfMono.push_back(CF_GENIVI_MONO);
+    std::vector<am_CustomConnectionFormat_t> cfAuto;
+    cfAuto.push_back(CF_GENIVI_AUTO);
+    std::vector<am_CustomConnectionFormat_t> cfFuture1;
+    cfFuture1.push_back(5);
+    std::vector<am_CustomConnectionFormat_t> cfFuture2;
+    cfFuture2.push_back(6);
+
+    am_sourceID_t sourceID;
+    enterSourceDB("source1", domainID1, cfStereo, sourceID);
+
+    am_sinkID_t coSinkID11;
     enterSinkDB("coSink11", domainID1, cfStereo, coSinkID11);
-	am_sourceID_t coSourceID11;
-	enterSourceDB("coSource11", domainID1, cfFuture1, coSourceID11);
-	am_converterID_t converterID11;
-	enterConverterDB("converter11", domainID1, cfFuture1, cfStereo, matrix, coSourceID11, coSinkID11, converterID11);
+    am_sourceID_t coSourceID11;
+    enterSourceDB("coSource11", domainID1, cfFuture1, coSourceID11);
+    am_converterID_t converterID11;
+    enterConverterDB("converter11", domainID1, cfFuture1, cfStereo, matrix, coSourceID11, coSinkID11, converterID11);
 
-	am_sinkID_t coSinkID12;
+    am_sinkID_t coSinkID12;
     enterSinkDB("coSink12", domainID1, cfStereo, coSinkID12);
-	am_sourceID_t coSourceID12;
-	enterSourceDB("coSource12", domainID1, cfFuture2, coSourceID12);
-	am_converterID_t converterID12;
-	enterConverterDB("converter12", domainID1, cfFuture2, cfStereo, matrix, coSourceID12, coSinkID12, converterID12);
+    am_sourceID_t coSourceID12;
+    enterSourceDB("coSource12", domainID1, cfFuture2, coSourceID12);
+    am_converterID_t converterID12;
+    enterConverterDB("converter12", domainID1, cfFuture2, cfStereo, matrix, coSourceID12, coSinkID12, converterID12);
 
-	am_sinkID_t coSinkID13;
+    am_sinkID_t coSinkID13;
     enterSinkDB("coSink13", domainID1, cfFuture2, coSinkID13);
-	am_sourceID_t coSourceID13;
-	enterSourceDB("coSource13", domainID1, cfFuture1, coSourceID13);
-	am_converterID_t converterID13;
-	enterConverterDB("converter13", domainID1, cfFuture1, cfFuture2, matrix, coSourceID13, coSinkID13, converterID13);
+    am_sourceID_t coSourceID13;
+    enterSourceDB("coSource13", domainID1, cfFuture1, coSourceID13);
+    am_converterID_t converterID13;
+    enterConverterDB("converter13", domainID1, cfFuture1, cfFuture2, matrix, coSourceID13, coSinkID13, converterID13);
 
-	am_sinkID_t gwSinkID11;
+    am_sinkID_t gwSinkID11;
     enterSinkDB("gwSink11", domainID1, cfFuture1, gwSinkID11);
-	am_sourceID_t gwSourceID21;
-	enterSourceDB("gwSource21", domainID2, cfAnalog, gwSourceID21);
-	am_converterID_t gatewayID1;
-	enterGatewayDB("gateway1", domainID2, domainID1, cfAnalog, cfFuture1, matrix, gwSourceID21, gwSinkID11, gatewayID1);
+    am_sourceID_t gwSourceID21;
+    enterSourceDB("gwSource21", domainID2, cfAnalog, gwSourceID21);
+    am_converterID_t gatewayID1;
+    enterGatewayDB("gateway1", domainID2, domainID1, cfAnalog, cfFuture1, matrix, gwSourceID21, gwSinkID11, gatewayID1);
 
-	am_sinkID_t gwSinkID21;
+    am_sinkID_t gwSinkID21;
     enterSinkDB("gwSink21", domainID2, cfStereo, gwSinkID21);
 
     am_sourceID_t gwSourceID12;
     enterSourceDB("gwSource12", domainID1, cfAuto, gwSourceID12);
 
     am_sinkID_t coSinkID21;
-	enterSinkDB("coSink21", domainID2, cfAnalog, coSinkID21);
-
-	am_sourceID_t coSourceID21;
-	enterSourceDB("coSource21", domainID2, cfStereo, coSourceID21);
+    enterSinkDB("coSink21", domainID2, cfAnalog, coSinkID21);
 
-	am_converterID_t converterID2;
-	enterConverterDB("converter2", domainID2, cfStereo, cfAnalog, matrix, coSourceID21, coSinkID21, converterID2);
+    am_sourceID_t coSourceID21;
+    enterSourceDB("coSource21", domainID2, cfStereo, coSourceID21);
 
+    am_converterID_t converterID2;
+    enterConverterDB("converter2", domainID2, cfStereo, cfAnalog, matrix, coSourceID21, coSinkID21, converterID2);
 
     am_gatewayID_t gatewayID2;
     enterGatewayDB("gateway2", domainID1, domainID2, cfAuto, cfStereo, matrix, gwSourceID12, gwSinkID21, gatewayID2);
 
-	am_sinkID_t sinkID;
-	enterSinkDB("sink1", domainID1, cfAuto, sinkID);
+    am_sinkID_t sinkID;
+    enterSinkDB("sink1", domainID1, cfAuto, sinkID);
 
     am::am_Source_s source;
     am::am_Sink_s sink;
@@ -3107,121 +3097,382 @@ TEST_F(CAmRouterMapTest, routeSource1Sink1PathThroughConv1Gate1Conv2Gate2)
 
     std::vector<am_Route_s> listRoutes;
 
-	getRoute(false, source, sink, listRoutes);
-	ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
+    ASSERT_EQ(getRoute(false, false, source, sink, listRoutes, 0), E_NOT_POSSIBLE);
+    ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
 
     am::am_Sink_s sink2;
     pDatabaseHandler.getSinkInfoDB(coSinkID21, sink2);
-	pRouter.getRoute(false, source, sink2, listRoutes);
-	ASSERT_EQ(static_cast<uint>(2), listRoutes.size());
-
- 	am_Route_s compareRoute1;
-	compareRoute1.sinkID = coSinkID21;
-	compareRoute1.sourceID = sourceID;
-	compareRoute1.route.push_back({sourceID, coSinkID11, domainID1, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({coSourceID11, gwSinkID11, domainID1, 5});
-	compareRoute1.route.push_back({gwSourceID21, coSinkID21, domainID2, CF_GENIVI_ANALOG});
-
- 	am_Route_s compareRoute2;
-	compareRoute2.sinkID = coSinkID21;
-	compareRoute2.sourceID = sourceID;
-	compareRoute2.route.push_back({sourceID, coSinkID12, domainID1, CF_GENIVI_STEREO});
-	compareRoute2.route.push_back({coSourceID12, coSinkID13, domainID1, 6});
-	compareRoute2.route.push_back({coSourceID13, gwSinkID11, domainID1, 5});
-	compareRoute2.route.push_back({gwSourceID21, coSinkID21, domainID2, CF_GENIVI_ANALOG});
-
-	ASSERT_TRUE(pCF.compareRoute(compareRoute1,listRoutes[1])||pCF.compareRoute(compareRoute1,listRoutes[0]));
-	ASSERT_TRUE(pCF.compareRoute(compareRoute2,listRoutes[0])||pCF.compareRoute(compareRoute2,listRoutes[1]));
+    ASSERT_EQ(getRoute(false, false, source, sink2, listRoutes, 0), E_OK);
+    ASSERT_EQ(static_cast<uint>(2), listRoutes.size());
+
+    am_Route_s compareRoute1;
+    compareRoute1.sinkID = coSinkID21;
+    compareRoute1.sourceID = sourceID;
+    compareRoute1.route.push_back(
+    { sourceID, coSinkID11, domainID1, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { coSourceID11, gwSinkID11, domainID1, 5 });
+    compareRoute1.route.push_back(
+    { gwSourceID21, coSinkID21, domainID2, CF_GENIVI_ANALOG });
+
+    am_Route_s compareRoute2;
+    compareRoute2.sinkID = coSinkID21;
+    compareRoute2.sourceID = sourceID;
+    compareRoute2.route.push_back(
+    { sourceID, coSinkID12, domainID1, CF_GENIVI_STEREO });
+    compareRoute2.route.push_back(
+    { coSourceID12, coSinkID13, domainID1, 6 });
+    compareRoute2.route.push_back(
+    { coSourceID13, gwSinkID11, domainID1, 5 });
+    compareRoute2.route.push_back(
+    { gwSourceID21, coSinkID21, domainID2, CF_GENIVI_ANALOG });
+
+    ASSERT_TRUE(pCF.compareRoute(compareRoute1, listRoutes[1]) || pCF.compareRoute(compareRoute1, listRoutes[0]));
+    ASSERT_TRUE(pCF.compareRoute(compareRoute2, listRoutes[0]) || pCF.compareRoute(compareRoute2, listRoutes[1]));
 }
 
 TEST_F(CAmRouterMapTest,route3Domains1Source1SinkGwCycles)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    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);
+    enterDomainDB("domain3", domain3ID);
+
+    //just make so many cycles as possible
+    std::vector<am_CustomConnectionFormat_t> cfStereo;
+    cfStereo.push_back(CF_GENIVI_STEREO);
+    std::vector<am_CustomConnectionFormat_t> cfAnalog = cfStereo;
+    std::vector<am_CustomConnectionFormat_t> cfMono = cfStereo;
+    std::vector<am_CustomConnectionFormat_t> cfAuto;
+    cfAuto.push_back(CF_GENIVI_AUTO);
+
+    am_sourceID_t source1ID;
+    enterSourceDB("source1", domain1ID, cfStereo, source1ID);
+    am_sinkID_t gw1SinkID;
+    enterSinkDB("gw1Sink", domain1ID, cfStereo, gw1SinkID);
+    am_sinkID_t gw2SinkID;
+    enterSinkDB("gw2Sink", domain1ID, cfStereo, gw2SinkID);
+    am_sourceID_t gw3SourceID;
+    enterSourceDB("gw3Source", domain1ID, cfAnalog, gw3SourceID);
+    am_sourceID_t gw4SourceID;
+    enterSourceDB("gw4Source", domain1ID, cfAnalog, gw4SourceID);
+    am_sinkID_t gw5SinkID;
+    enterSinkDB("gw5Sink", domain1ID, cfAnalog, gw5SinkID);
+
+    am_sourceID_t gw1SourceID;
+    enterSourceDB("gw1Source", domain2ID, cfMono, gw1SourceID);
+    am_sourceID_t gw2SourceID;
+    enterSourceDB("gw2Source", domain2ID, cfMono, gw2SourceID);
+    am_sinkID_t gw3SinkID;
+    enterSinkDB("gw3Sink", domain2ID, cfMono, gw3SinkID);
+    am_sinkID_t gw4SinkID;
+    enterSinkDB("gw4Sink", domain2ID, cfMono, gw4SinkID);
+
+    am_sourceID_t gw5SourceID;
+    enterSourceDB("gw5Source", domain3ID, cfStereo, gw5SourceID);
+    am_sinkID_t sink1ID;
+    enterSinkDB("sink1", domain3ID, cfStereo, sink1ID);
+
+    std::vector<bool> matrixT;
+    matrixT.push_back(true);
+    std::vector<bool> matrixF;
+    matrixF.push_back(false);
+
+    am_gatewayID_t gateway1ID;
+    enterGatewayDB("gateway1", domain2ID, domain1ID, cfMono, cfStereo, matrixT, gw1SourceID, gw1SinkID, gateway1ID);
+    am_gatewayID_t gateway2ID;
+    enterGatewayDB("gateway2", domain2ID, domain1ID, cfMono, cfStereo, matrixT, gw2SourceID, gw2SinkID, gateway2ID);
+    am_gatewayID_t gateway3ID;
+    enterGatewayDB("gateway3", domain1ID, domain2ID, cfAnalog, cfMono, matrixT, gw3SourceID, gw3SinkID, gateway3ID);
+    am_gatewayID_t gateway4ID;
+    enterGatewayDB("gateway4", domain1ID, domain2ID, cfAnalog, cfMono, matrixT, gw4SourceID, gw4SinkID, gateway4ID);
+    am_gatewayID_t gateway5ID;
+    enterGatewayDB("gateway5", domain3ID, domain1ID, cfStereo, cfAnalog, matrixT, gw5SourceID, gw5SinkID, gateway5ID);
+
+    std::vector<am_Route_s> listRoutes;
+
+    am_Route_s compareRoute1;
+    compareRoute1.sinkID = sink1ID;
+    compareRoute1.sourceID = source1ID;
+
+#define DO_ASSERT()	 \
+		{\
+	bool didMatch = false; \
+	for(auto it = listRoutes.begin(); it!=listRoutes.end(); it++) \
+	didMatch|=pCF.compareRoute(compareRoute1,*it); \
+	ASSERT_TRUE(didMatch); \
+		}
+
+    ASSERT_EQ(getAllPaths(false, source1ID, sink1ID, listRoutes, UINT_MAX, 10), E_OK);
+    ASSERT_EQ(static_cast<uint>(9), listRoutes.size());
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw2SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw2SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw1SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw1SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw2SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw2SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw1SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw1SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw2SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw2SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw4SourceID, gw1SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw1SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw2SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw2SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw3SourceID, gw1SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw1SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw1SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw1SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw3SourceID, gw2SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw2SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw1SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw1SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw4SourceID, gw2SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw2SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    listRoutes.clear();
+
+    ASSERT_EQ(getAllPaths(false, source1ID, sink1ID, listRoutes, 1, 10), E_OK);
+    ASSERT_EQ(static_cast<uint>(5), listRoutes.size());
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw2SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw2SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw1SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw1SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw2SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw2SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw1SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw1SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO });
+    DO_ASSERT()
+
+    listRoutes.clear();
+
+    ASSERT_EQ(getAllPaths(false, source1ID, sink1ID, listRoutes), E_OK);
+    ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
+    DO_ASSERT()
+}
+
+TEST_F(CAmRouterMapTest,route3Domains1Source1SinkGwCycles2)
+{
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+    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);
-	enterDomainDB("domain3", domain3ID);
-
-	//just make so many cycles as possible
-	std::vector<am_CustomConnectionFormat_t> cfStereo;
-	cfStereo.push_back(CF_GENIVI_STEREO);
-	std::vector<am_CustomConnectionFormat_t> cfAnalog = cfStereo;
-	std::vector<am_CustomConnectionFormat_t> cfMono = cfStereo;
-	std::vector<am_CustomConnectionFormat_t> cfAuto;
-	cfAuto.push_back(CF_GENIVI_AUTO);
-
-	am_sourceID_t source1ID;
-	enterSourceDB("source1", domain1ID, cfStereo, source1ID);
-	am_sinkID_t gw1SinkID;
-	enterSinkDB("gw1Sink", domain1ID, cfStereo, gw1SinkID);
-	am_sinkID_t gw2SinkID;
-	enterSinkDB("gw2Sink", domain1ID, cfStereo, gw2SinkID);
-	am_sourceID_t gw3SourceID;
-	enterSourceDB("gw3Source", domain1ID, cfAnalog, gw3SourceID);
-	am_sourceID_t gw4SourceID;
-	enterSourceDB("gw4Source", domain1ID, cfAnalog, gw4SourceID);
-	am_sinkID_t gw5SinkID;
-	enterSinkDB("gw5Sink", domain1ID, cfAnalog, gw5SinkID);
-
-	am_sourceID_t gw1SourceID;
-	enterSourceDB("gw1Source", domain2ID, cfMono, gw1SourceID);
-	am_sourceID_t gw2SourceID;
-	enterSourceDB("gw2Source", domain2ID, cfMono, gw2SourceID);
-	am_sinkID_t gw3SinkID;
-	enterSinkDB("gw3Sink", domain2ID, cfMono, gw3SinkID);
-	am_sinkID_t gw4SinkID;
-	enterSinkDB("gw4Sink", domain2ID, cfMono, gw4SinkID);
-
-	am_sourceID_t gw5SourceID;
-	enterSourceDB("gw5Source", domain3ID, cfStereo, gw5SourceID);
-	am_sinkID_t sink1ID;
-	enterSinkDB("sink1", domain3ID, cfStereo, sink1ID);
-
-	std::vector<bool> matrixT;
-	matrixT.push_back(true);
-	std::vector<bool> matrixF;
-	matrixF.push_back(false);
-
-	am_gatewayID_t gateway1ID;
-	enterGatewayDB("gateway1", domain2ID, domain1ID, cfMono, cfStereo, matrixT, gw1SourceID, gw1SinkID, gateway1ID);
-	am_gatewayID_t gateway2ID;
-	enterGatewayDB("gateway2", domain2ID, domain1ID, cfMono, cfStereo, matrixT, gw2SourceID, gw2SinkID, gateway2ID);
-	am_gatewayID_t gateway3ID;
-	enterGatewayDB("gateway3", domain1ID, domain2ID, cfAnalog, cfMono, matrixT, gw3SourceID, gw3SinkID, gateway3ID);
-	am_gatewayID_t gateway4ID;
-	enterGatewayDB("gateway4", domain1ID, domain2ID, cfAnalog, cfMono, matrixT, gw4SourceID, gw4SinkID, gateway4ID);
-	am_gatewayID_t gateway5ID;
-	enterGatewayDB("gateway5", domain3ID, domain1ID, cfStereo, cfAnalog, matrixT, gw5SourceID, gw5SinkID, gateway5ID);
-
-	pRouter.load(false);
-
-	CAmRoutingNode* sourceNode = pRouter.sourceNodeWithID(source1ID);
-	CAmRoutingNode* sinkNode = pRouter.sinkNodeWithID(sink1ID);
-
-	ASSERT_TRUE(sourceNode);
-	ASSERT_TRUE(sinkNode);
-
-	std::vector<am_Route_s> listRoutes;
-	std::vector<std::vector<CAmRoutingNode*>> resultNodesPath;
-
-	am_Route_s compareRoute1;
-	compareRoute1.sinkID = sink1ID;
-	compareRoute1.sourceID = source1ID;
+    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);
+    enterDomainDB("domain3", domain3ID);
+
+    //just make so many cycles as possible
+    std::vector<am_CustomConnectionFormat_t> cfStereo;
+    cfStereo.push_back(CF_GENIVI_STEREO);
+    std::vector<am_CustomConnectionFormat_t> cfOther;
+    cfOther.push_back(CF_GENIVI_AUTO);
+    std::vector<am_CustomConnectionFormat_t> cfMono;
+    cfMono.push_back(CF_GENIVI_MONO);
+
+    am_sourceID_t source1ID;
+    enterSourceDB("source1", domain1ID, cfMono, source1ID);
+    am_sinkID_t gw1SinkID;
+    enterSinkDB("gw1Sink", domain1ID, cfStereo, gw1SinkID);
+    am_sinkID_t gw2SinkID;
+    enterSinkDB("gw2Sink", domain1ID, cfMono, gw2SinkID);
+    am_sourceID_t gw3SourceID;
+    enterSourceDB("gw3Source", domain1ID, cfStereo, gw3SourceID);
+    am_sourceID_t gw4SourceID;
+    enterSourceDB("gw4Source", domain1ID, cfStereo, gw4SourceID);
+    am_sinkID_t gw5SinkID;
+    enterSinkDB("gw5Sink", domain1ID, cfStereo, gw5SinkID);
+
+    am_sourceID_t gw1SourceID;
+    enterSourceDB("gw1Source", domain2ID, cfStereo, gw1SourceID);
+    am_sourceID_t gw2SourceID;
+    enterSourceDB("gw2Source", domain2ID, cfStereo, gw2SourceID);
+    am_sinkID_t gw3SinkID;
+    enterSinkDB("gw3Sink", domain2ID, cfStereo, gw3SinkID);
+    am_sinkID_t gw4SinkID;
+    enterSinkDB("gw4Sink", domain2ID, cfStereo, gw4SinkID);
+
+    am_sourceID_t gw5SourceID;
+    enterSourceDB("gw5Source", domain3ID, cfOther, gw5SourceID);
+    am_sinkID_t sink1ID;
+    enterSinkDB("sink1", domain3ID, cfOther, sink1ID);
+
+    std::vector<bool> matrixT;
+    matrixT.push_back(true);
+    std::vector<bool> matrixF;
+    matrixF.push_back(false);
+
+    am_gatewayID_t gateway1ID;
+    enterGatewayDB("gateway1", domain2ID, domain1ID, cfStereo, cfStereo, matrixT, gw1SourceID, gw1SinkID, gateway1ID);
+    am_gatewayID_t gateway2ID;
+    enterGatewayDB("gateway2", domain2ID, domain1ID, cfStereo, cfMono, matrixT, gw2SourceID, gw2SinkID, gateway2ID);
+    am_gatewayID_t gateway3ID;
+    enterGatewayDB("gateway3", domain1ID, domain2ID, cfStereo, cfStereo, matrixT, gw3SourceID, gw3SinkID, gateway3ID);
+    am_gatewayID_t gateway4ID;
+    enterGatewayDB("gateway4", domain1ID, domain2ID, cfStereo, cfStereo, matrixT, gw4SourceID, gw4SinkID, gateway4ID);
+    am_gatewayID_t gateway5ID;
+    enterGatewayDB("gateway5", domain3ID, domain1ID, cfOther, cfStereo, matrixT, gw5SourceID, gw5SinkID, gateway5ID);
+
+    std::vector<am_Route_s> listRoutes;
+
+    am_Route_s compareRoute1;
+    compareRoute1.sinkID = sink1ID;
+    compareRoute1.sourceID = source1ID;
 
 #define DO_ASSERT()	 \
 		{\
@@ -3231,132 +3482,75 @@ TEST_F(CAmRouterMapTest,route3Domains1Source1SinkGwCycles)
 	ASSERT_TRUE(didMatch); \
 		}
 
-#ifdef ROUTING_BUILD_CONNECTIONS
-	getAllPaths(*sourceNode, *sinkNode, listRoutes, resultNodesPath, true);
-	ASSERT_EQ(static_cast<uint>(9), listRoutes.size());
-
-	compareRoute1.route.clear();
-	compareRoute1.route.push_back({source1ID, gw2SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw2SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO});
-	DO_ASSERT()
-
-	compareRoute1.route.clear();
-	compareRoute1.route.push_back({source1ID, gw1SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw1SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO});
-	DO_ASSERT()
-
-	compareRoute1.route.clear();
-	compareRoute1.route.push_back({source1ID, gw2SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw2SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO});
-	DO_ASSERT()
-
-	compareRoute1.route.clear();
-	compareRoute1.route.push_back({source1ID, gw1SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw1SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO});
-	DO_ASSERT()
-
-	compareRoute1.route.clear();
-	compareRoute1.route.push_back({source1ID, gw2SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw2SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw4SourceID, gw1SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw1SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO});
-	DO_ASSERT()
-
-	compareRoute1.route.clear();
-	compareRoute1.route.push_back({source1ID, gw2SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw2SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw3SourceID, gw1SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw1SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO});
-	DO_ASSERT()
-
-	compareRoute1.route.clear();
-	compareRoute1.route.push_back({source1ID, gw1SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw1SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw3SourceID, gw2SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw2SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO});
-	DO_ASSERT()
-
-	compareRoute1.route.clear();
-	compareRoute1.route.push_back({source1ID, gw1SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw1SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw4SourceID, gw2SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw2SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO});
-	DO_ASSERT()
-
-	compareRoute1.route.clear();
-	compareRoute1.route.push_back({source1ID, gw5SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO});
-	DO_ASSERT()
-#else
-	compareRoute1.route.clear();
-	compareRoute1.route.push_back({source1ID, gw5SinkID, domain1ID, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gw5SourceID, sink1ID, domain3ID, CF_GENIVI_STEREO});
-#endif
-
-	listRoutes.clear();
-	resultNodesPath.clear();
-	getAllPaths(*sourceNode, *sinkNode, listRoutes, resultNodesPath, false);
-	ASSERT_EQ(static_cast<uint>(1), listRoutes.size());
-	DO_ASSERT()
+    ASSERT_EQ(getRoute(false, false, source1ID, sink1ID, listRoutes, 0, 10), E_NOT_POSSIBLE);
+    ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
+
+    ASSERT_EQ(getRoute(false, false, source1ID, sink1ID, listRoutes, 1, 10), E_OK);
+    ASSERT_EQ(static_cast<uint>(2), listRoutes.size());
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw2SinkID, domain1ID, CF_GENIVI_MONO });
+    compareRoute1.route.push_back(
+    { gw2SourceID, gw4SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw4SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_AUTO });
+    DO_ASSERT()
+
+    compareRoute1.route.clear();
+    compareRoute1.route.push_back(
+    { source1ID, gw2SinkID, domain1ID, CF_GENIVI_MONO });
+    compareRoute1.route.push_back(
+    { gw2SourceID, gw3SinkID, domain2ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw3SourceID, gw5SinkID, domain1ID, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gw5SourceID, sink1ID, domain3ID, CF_GENIVI_AUTO });
+    DO_ASSERT()
 }
 
 TEST_F(CAmRouterMapTest,route3Domains1Source3Gateways3Convertres1Sink)
 {
-	EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
+    EXPECT_CALL(pMockControlInterface,getConnectionFormatChoice(_,_,_,_,_)).WillRepeatedly(DoAll(returnConnectionFormat(), Return(E_OK)));
 
     am_SourceClass_s sourceclass;
 
-    sourceclass.name="sClass";
-    sourceclass.sourceClassID=5;
+    sourceclass.name = "sClass";
+    sourceclass.sourceClassID = 5;
 
-    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceclass.sourceClassID,sourceclass));
+    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);
-	enterDomainDB("domain3", domainID3);
-
-	std::vector<am_CustomConnectionFormat_t> cfStereo;
-	cfStereo.push_back(CF_GENIVI_STEREO);
-	std::vector<am_CustomConnectionFormat_t> cfAnalog;
-	cfAnalog.push_back(CF_GENIVI_ANALOG);
-	std::vector<am_CustomConnectionFormat_t> cfMono;
-	cfMono.push_back(CF_GENIVI_MONO);
-	std::vector<am_CustomConnectionFormat_t> cfAuto;
-	cfAuto.push_back(CF_GENIVI_AUTO);
-
-	am_sourceID_t sourceID;
-	enterSourceDB("source1", domainID1, cfStereo, sourceID);
-	am_sinkID_t gwSinkID1;
-	enterSinkDB("gwSink1", domainID1, cfStereo, gwSinkID1);
+    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);
+    enterDomainDB("domain3", domainID3);
+
+    std::vector<am_CustomConnectionFormat_t> cfStereo;
+    cfStereo.push_back(CF_GENIVI_STEREO);
+    std::vector<am_CustomConnectionFormat_t> cfAnalog;
+    cfAnalog.push_back(CF_GENIVI_ANALOG);
+    std::vector<am_CustomConnectionFormat_t> cfMono;
+    cfMono.push_back(CF_GENIVI_MONO);
+    std::vector<am_CustomConnectionFormat_t> cfAuto;
+    cfAuto.push_back(CF_GENIVI_AUTO);
+
+    am_sourceID_t sourceID;
+    enterSourceDB("source1", domainID1, cfStereo, sourceID);
+    am_sinkID_t gwSinkID1;
+    enterSinkDB("gwSink1", domainID1, cfStereo, gwSinkID1);
     am_sinkID_t gwSinkID21;
     enterSinkDB("gwSink21", domainID1, cfStereo, gwSinkID21);
 
-	am_sourceID_t gwSourceID1;
-	enterSourceDB("gwSource1", domainID2, cfMono, gwSourceID1);
+    am_sourceID_t gwSourceID1;
+    enterSourceDB("gwSource1", domainID2, cfMono, gwSourceID1);
     am_sinkID_t gwSinkID22;
     enterSinkDB("gwSink22", domainID2, cfMono, gwSinkID22);
 
@@ -3365,35 +3559,35 @@ TEST_F(CAmRouterMapTest,route3Domains1Source3Gateways3Convertres1Sink)
 
     am_sourceID_t gwSourceID22;
     enterSourceDB("gwSource22", domainID3, cfAuto, gwSourceID22);
-	am_sourceID_t gwSourceID5;
-	enterSourceDB("gwSource5", domainID3, cfStereo, gwSourceID5);
-	am_sinkID_t gwSinkID5;
-	enterSinkDB("gwSink5", domainID3, cfAnalog, gwSinkID5);
-    am_sourceID_t gwSourceID3;
-	enterSourceDB("gwSource3", domainID3, cfAnalog, gwSourceID3);
-	am_sinkID_t gwSinkID3;
-	enterSinkDB("gwSink3", domainID3, cfAuto, gwSinkID3);
-	am_sourceID_t gwSourceID4;
-	enterSourceDB("gwSource4", domainID3, cfStereo, gwSourceID4);
-	am_sinkID_t gwSinkID4;
-	enterSinkDB("gwSink4", domainID3, cfAnalog, gwSinkID4);
-	am_sinkID_t sinkID;
-	enterSinkDB("sink1", domainID3, cfStereo, sinkID);
-
-	std::vector<bool> matrix;
-	matrix.push_back(true);
+    am_sourceID_t cSourceID5;
+    enterSourceDB("cSource5", domainID3, cfStereo, cSourceID5);
+    am_sinkID_t cSinkID5;
+    enterSinkDB("cSink5", domainID3, cfAnalog, cSinkID5);
+    am_sourceID_t cSourceID3;
+    enterSourceDB("cSource3", domainID3, cfAnalog, cSourceID3);
+    am_sinkID_t cSinkID3;
+    enterSinkDB("cSinkID3", domainID3, cfAuto, cSinkID3);
+    am_sourceID_t cSourceID4;
+    enterSourceDB("cSource4", domainID3, cfStereo, cSourceID4);
+    am_sinkID_t cSinkID4;
+    enterSinkDB("cSink4", domainID3, cfAnalog, cSinkID4);
+    am_sinkID_t sinkID;
+    enterSinkDB("sink1", domainID3, cfStereo, sinkID);
+
+    std::vector<bool> matrix;
+    matrix.push_back(true);
     am_gatewayID_t gatewayID;
     enterGatewayDB("gateway1", domainID2, domainID1, cfMono, cfStereo, matrix, gwSourceID1, gwSinkID1, gatewayID);
     am_gatewayID_t gatewayID22;
     enterGatewayDB("gateway22", domainID3, domainID2, cfAuto, cfMono, matrix, gwSourceID22, gwSinkID22, gatewayID22);
     am_gatewayID_t gatewayID21;
     enterGatewayDB("gateway21", domainID3, domainID1, cfAuto, cfStereo, matrix, gwSourceID21, gwSinkID21, gatewayID21);
-	am_converterID_t converterID1;
-	enterConverterDB("converter1", domainID3, cfAnalog, cfAuto, matrix, gwSourceID3, gwSinkID3, converterID1);
-	am_converterID_t converterID2;
-	enterConverterDB("converter2", domainID3, cfStereo, cfAnalog, matrix, gwSourceID4, gwSinkID4, converterID2);
-	am_converterID_t converterID3;
-	enterConverterDB("converter3", domainID3, cfStereo, cfAnalog, matrix, gwSourceID5, gwSinkID5, converterID3);
+    am_converterID_t converterID1;
+    enterConverterDB("converter1", domainID3, cfAnalog, cfAuto, matrix, cSourceID3, cSinkID3, converterID1);
+    am_converterID_t converterID2;
+    enterConverterDB("converter2", domainID3, cfStereo, cfAnalog, matrix, cSourceID4, cSinkID4, converterID2);
+    am_converterID_t converterID3;
+    enterConverterDB("converter3", domainID3, cfStereo, cfAnalog, matrix, cSourceID5, cSinkID5, converterID3);
 
     am::am_Source_s source;
     am::am_Sink_s sink;
@@ -3403,77 +3597,186 @@ TEST_F(CAmRouterMapTest,route3Domains1Source3Gateways3Convertres1Sink)
 
     std::vector<am_Route_s> listRoutes;
 
-	getRoute(false, source, sink, listRoutes);
-	ASSERT_EQ(static_cast<uint>(4), listRoutes.size());
-
- 	am_Route_s compareRoute1;
-	compareRoute1.sinkID = sinkID;
-	compareRoute1.sourceID = sourceID;
-	compareRoute1.route.push_back({sourceID, gwSinkID1, domainID1, CF_GENIVI_STEREO});
-	compareRoute1.route.push_back({gwSourceID1, gwSinkID22, domainID2, CF_GENIVI_MONO});
-	compareRoute1.route.push_back({gwSourceID22, gwSinkID3, domainID3, CF_GENIVI_AUTO});
-	compareRoute1.route.push_back({gwSourceID3, gwSinkID4, domainID3, CF_GENIVI_ANALOG});
-	compareRoute1.route.push_back({gwSourceID4, sinkID, domainID3, CF_GENIVI_STEREO});
-
- 	am_Route_s compareRoute2;
-	compareRoute2.sinkID = sinkID;
-	compareRoute2.sourceID = sourceID;
-	compareRoute2.route.push_back({sourceID, gwSinkID1, domainID1, CF_GENIVI_STEREO});
-	compareRoute2.route.push_back({gwSourceID1, gwSinkID22, domainID2, CF_GENIVI_MONO});
-	compareRoute2.route.push_back({gwSourceID22, gwSinkID3, domainID3, CF_GENIVI_AUTO});
-	compareRoute2.route.push_back({gwSourceID3, gwSinkID5, domainID3, CF_GENIVI_ANALOG});
-	compareRoute2.route.push_back({gwSourceID5, sinkID, domainID3, CF_GENIVI_STEREO});
-
- 	am_Route_s compareRoute3;
-	compareRoute3.sinkID = sinkID;
-	compareRoute3.sourceID = sourceID;
-	compareRoute3.route.push_back({sourceID, gwSinkID21, domainID1, CF_GENIVI_STEREO});
-	compareRoute3.route.push_back({gwSourceID21, gwSinkID3, domainID3, CF_GENIVI_AUTO});
-	compareRoute3.route.push_back({gwSourceID3, gwSinkID4, domainID3, CF_GENIVI_ANALOG});
-	compareRoute3.route.push_back({gwSourceID4, sinkID, domainID3, CF_GENIVI_STEREO});
-
- 	am_Route_s compareRoute4;
-	compareRoute4.sinkID = sinkID;
-	compareRoute4.sourceID = sourceID;
-	compareRoute4.route.push_back({sourceID, gwSinkID21, domainID1, CF_GENIVI_STEREO});
-	compareRoute4.route.push_back({gwSourceID21, gwSinkID3, domainID3, CF_GENIVI_AUTO});
-	compareRoute4.route.push_back({gwSourceID3, gwSinkID5, domainID3, CF_GENIVI_ANALOG});
-	compareRoute4.route.push_back({gwSourceID5, sinkID, domainID3, CF_GENIVI_STEREO});
-
-	ASSERT_TRUE(pCF.compareRoute(compareRoute1,listRoutes[0])||
-				pCF.compareRoute(compareRoute1,listRoutes[1])||
-				pCF.compareRoute(compareRoute1,listRoutes[2])||
-				pCF.compareRoute(compareRoute1,listRoutes[3]));
-
-	ASSERT_TRUE(pCF.compareRoute(compareRoute2,listRoutes[0])||
-				pCF.compareRoute(compareRoute2,listRoutes[1])||
-				pCF.compareRoute(compareRoute2,listRoutes[2])||
-				pCF.compareRoute(compareRoute2,listRoutes[3]));
-
-	ASSERT_TRUE(pCF.compareRoute(compareRoute3,listRoutes[0])||
-				pCF.compareRoute(compareRoute3,listRoutes[1])||
-				pCF.compareRoute(compareRoute3,listRoutes[2])||
-				pCF.compareRoute(compareRoute3,listRoutes[3]));
-
-	ASSERT_TRUE(pCF.compareRoute(compareRoute4,listRoutes[0])||
-				pCF.compareRoute(compareRoute4,listRoutes[1])||
-				pCF.compareRoute(compareRoute4,listRoutes[2])||
-				pCF.compareRoute(compareRoute4,listRoutes[3]));
+    ASSERT_EQ(getRoute(false, false, source, sink, listRoutes), E_OK);
+    ASSERT_EQ(static_cast<uint>(4), listRoutes.size());
+
+    am_Route_s compareRoute1;
+    compareRoute1.sinkID = sinkID;
+    compareRoute1.sourceID = sourceID;
+    compareRoute1.route.push_back(
+    { sourceID, gwSinkID1, domainID1, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gwSourceID1, gwSinkID22, domainID2, CF_GENIVI_MONO });
+    compareRoute1.route.push_back(
+    { gwSourceID22, cSinkID3, domainID3, CF_GENIVI_AUTO });
+    compareRoute1.route.push_back(
+    { cSourceID3, cSinkID4, domainID3, CF_GENIVI_ANALOG });
+    compareRoute1.route.push_back(
+    { cSourceID4, sinkID, domainID3, CF_GENIVI_STEREO });
+
+    am_Route_s compareRoute2;
+    compareRoute2.sinkID = sinkID;
+    compareRoute2.sourceID = sourceID;
+    compareRoute2.route.push_back(
+    { sourceID, gwSinkID1, domainID1, CF_GENIVI_STEREO });
+    compareRoute2.route.push_back(
+    { gwSourceID1, gwSinkID22, domainID2, CF_GENIVI_MONO });
+    compareRoute2.route.push_back(
+    { gwSourceID22, cSinkID3, domainID3, CF_GENIVI_AUTO });
+    compareRoute2.route.push_back(
+    { cSourceID3, cSinkID5, domainID3, CF_GENIVI_ANALOG });
+    compareRoute2.route.push_back(
+    { cSourceID5, sinkID, domainID3, CF_GENIVI_STEREO });
+
+    am_Route_s compareRoute3;
+    compareRoute3.sinkID = sinkID;
+    compareRoute3.sourceID = sourceID;
+    compareRoute3.route.push_back(
+    { sourceID, gwSinkID21, domainID1, CF_GENIVI_STEREO });
+    compareRoute3.route.push_back(
+    { gwSourceID21, cSinkID3, domainID3, CF_GENIVI_AUTO });
+    compareRoute3.route.push_back(
+    { cSourceID3, cSinkID4, domainID3, CF_GENIVI_ANALOG });
+    compareRoute3.route.push_back(
+    { cSourceID4, sinkID, domainID3, CF_GENIVI_STEREO });
+
+    am_Route_s compareRoute4;
+    compareRoute4.sinkID = sinkID;
+    compareRoute4.sourceID = sourceID;
+    compareRoute4.route.push_back(
+    { sourceID, gwSinkID21, domainID1, CF_GENIVI_STEREO });
+    compareRoute4.route.push_back(
+    { gwSourceID21, cSinkID3, domainID3, CF_GENIVI_AUTO });
+    compareRoute4.route.push_back(
+    { cSourceID3, cSinkID5, domainID3, CF_GENIVI_ANALOG });
+    compareRoute4.route.push_back(
+    { cSourceID5, sinkID, domainID3, CF_GENIVI_STEREO });
+
+    ASSERT_TRUE(
+            pCF.compareRoute(compareRoute1, listRoutes[0]) || pCF.compareRoute(compareRoute1, listRoutes[1]) || pCF.compareRoute(compareRoute1, listRoutes[2])
+                    || pCF.compareRoute(compareRoute1, listRoutes[3]));
+
+    ASSERT_TRUE(
+            pCF.compareRoute(compareRoute2, listRoutes[0]) || pCF.compareRoute(compareRoute2, listRoutes[1]) || pCF.compareRoute(compareRoute2, listRoutes[2])
+                    || pCF.compareRoute(compareRoute2, listRoutes[3]));
+
+    ASSERT_TRUE(
+            pCF.compareRoute(compareRoute3, listRoutes[0]) || pCF.compareRoute(compareRoute3, listRoutes[1]) || pCF.compareRoute(compareRoute3, listRoutes[2])
+                    || pCF.compareRoute(compareRoute3, listRoutes[3]));
+
+    ASSERT_TRUE(
+            pCF.compareRoute(compareRoute4, listRoutes[0]) || pCF.compareRoute(compareRoute4, listRoutes[1]) || pCF.compareRoute(compareRoute4, listRoutes[2])
+                    || pCF.compareRoute(compareRoute4, listRoutes[3]));
+}
+
+TEST_F(CAmRouterMapTest, routeTunerHeadphonePathThroughGWPlus2OtherSinks)
+{
+    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);
+    matrix.push_back(false);
+    matrix.push_back(false);
+    matrix.push_back(true);
+
+    am_domainID_t domainID1, domainID2;
+    enterDomainDB("domain1", domainID1);
+    enterDomainDB("domain2", domainID2);
+
+    std::vector<am_CustomConnectionFormat_t> cfStereo;
+    cfStereo.push_back(CF_GENIVI_STEREO);
+
+    std::vector<am_CustomConnectionFormat_t> cfMulti;
+    cfMulti.push_back(CF_GENIVI_STEREO);
+    cfMulti.push_back(CF_GENIVI_ANALOG);
+
+    am_sourceID_t tunerID;
+    enterSourceDB("Tuner", domainID1, cfStereo, tunerID);
+
+    am_sinkID_t gwSinkID1;
+    enterSinkDB("gwSink1", domainID1, cfStereo, gwSinkID1);
+    am_sourceID_t gwSourceID1;
+    enterSourceDB("gwSource1", domainID2, cfMulti, gwSourceID1);
+    am_converterID_t gatewayID1;
+    enterGatewayDB("gateway1", domainID2, domainID1, cfMulti, cfMulti, matrix, gwSourceID1, gwSinkID1, gatewayID1);
+
+    am_sinkID_t rseLeftID;
+    enterSinkDB("RSE Left", domainID2, cfMulti, rseLeftID);
+    am_sinkID_t rseRightID;
+    enterSinkDB("RSE Right", domainID2, cfMulti, rseRightID);
+    am_sinkID_t rseHeadphoneID;
+    enterSinkDB("Headphone", domainID2, cfMulti, rseHeadphoneID);
+
+    am::am_Source_s source;
+    am::am_Sink_s sink;
+    pDatabaseHandler.getSinkInfoDB(rseLeftID, sink);
+    pDatabaseHandler.getSourceInfoDB(tunerID, source);
+
+    std::vector<am_Route_s> listRoutes;
+    ASSERT_EQ(getRoute(false, false, source, sink, listRoutes), E_OK);
+    ASSERT_EQ(listRoutes.size(), static_cast<uint>(1));
+
+    am_Route_s compareRoute1;
+    compareRoute1.sinkID = rseLeftID;
+    compareRoute1.sourceID = tunerID;
+    compareRoute1.route.push_back(
+    { tunerID, gwSinkID1, domainID1, CF_GENIVI_STEREO });
+    compareRoute1.route.push_back(
+    { gwSourceID1, rseLeftID, domainID2, CF_GENIVI_STEREO });
+
+    ASSERT_TRUE(pCF.compareRoute(compareRoute1, listRoutes[0]));
+
+    listRoutes.clear();
+
+    am::am_Source_s gwSource;
+    am::am_Sink_s sink2;
+    pDatabaseHandler.getSinkInfoDB(rseHeadphoneID, sink2);
+    pDatabaseHandler.getSourceInfoDB(gwSourceID1, gwSource);
+    ASSERT_EQ(getRoute(false, false, gwSource, sink2, listRoutes), E_OK);
+    ASSERT_GT(listRoutes.size(), static_cast<uint>(0));
+
+    am_Route_s compareRoute2;
+    compareRoute2.sinkID = rseHeadphoneID;
+    compareRoute2.sourceID = gwSourceID1;
+    compareRoute2.route.push_back(
+    { gwSourceID1, rseHeadphoneID, domainID2, CF_GENIVI_STEREO });
+    am_Route_s compareRoute3;
+    compareRoute3.sinkID = rseHeadphoneID;
+    compareRoute3.sourceID = gwSourceID1;
+    compareRoute3.route.push_back(
+    { gwSourceID1, rseHeadphoneID, domainID2, CF_GENIVI_ANALOG });
+
+    ASSERT_TRUE(pCF.compareRoute(compareRoute2, listRoutes[0]) || pCF.compareRoute(compareRoute2, listRoutes[1]));
+    ASSERT_TRUE(pCF.compareRoute(compareRoute3, listRoutes[0]) || pCF.compareRoute(compareRoute3, listRoutes[1]));
 }
 
 int main(int argc, char **argv)
 {
-	try
-	{
-		TCLAP::CmdLine* cmd(CAmCommandLineSingleton::instanciateOnce("The team of the AudioManager wishes you a nice day!",' ',DAEMONVERSION,true));
-		cmd->add(enableDebug);
-	}
-	catch (TCLAP::ArgException &e)  // catch any exceptions
-	{ std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl; }
-	CAmCommandLineSingleton::instance()->preparse(argc,argv);
-	CAmDltWrapper::instanctiateOnce("rTEST","RouterMap Test",enableDebug.getValue(),CAmDltWrapper::logDestination::DAEMON);
-	logInfo("Routing Test started ");
-	::testing::InitGoogleTest(&argc, argv);
-	return RUN_ALL_TESTS();
+    try
+    {
+        TCLAP::CmdLine* cmd(CAmCommandLineSingleton::instanciateOnce("The team of the AudioManager wishes you a nice day!", ' ', DAEMONVERSION, true));
+        cmd->add(enableDebug);
+    } catch (TCLAP::ArgException &e)  // catch any exceptions
+    {
+        std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl;
+    }
+    CAmCommandLineSingleton::instance()->preparse(argc, argv);
+    CAmDltWrapper::instanctiateOnce("rTEST", "RouterMap Test", enableDebug.getValue(), CAmDltWrapper::logDestination::DAEMON);
+    logInfo("Routing Test started ");
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
 }
 
diff --git a/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.h b/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.h
index 65ff97b..6ecaeaa 100644
--- a/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.h
+++ b/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.h
@@ -14,7 +14,7 @@
  * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  *
  *
-* \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013, 2014
+ * \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013, 2014
  *
  * For further information see http://www.genivi.org/.
  *
@@ -34,7 +34,6 @@
 #include "CAmDatabaseHandlerMap.h"
 #include "CAmControlReceiver.h"
 #include "CAmControlSender.h"
-#include "CAmDatabaseObserver.h"
 #include "CAmRoutingSender.h"
 #include "CAmRouter.h"
 #include "CAmSocketHandler.h"
@@ -44,64 +43,54 @@
 #include "../MockIAmControlSend.h"
 #include "../MockIAmCommandSend.h"
 
-
 namespace am
 {
 
-class CAmRouterMapTest: public ::testing::Test
-{
-public:
-	CAmRouterMapTest();
-    ~CAmRouterMapTest();
-    std::vector<std::string> plistRoutingPluginDirs;
-    std::vector<std::string> plistCommandPluginDirs;
-    CAmSocketHandler pSocketHandler;
-    CAmControlSender pControlSender;
-    CAmDatabaseHandlerMap pDatabaseHandler;
-    CAmRouter pRouter;
-    CAmRoutingSender pRoutingSender;
-    CAmCommandSender pCommandSender;
-    MockIAmCommandSend pMockInterface;
-    MockIAmControlSend pMockControlInterface;
-    IAmRoutingBackdoor pRoutingInterfaceBackdoor;
-    IAmCommandBackdoor pCommandInterfaceBackdoor;
-    IAmControlBackdoor pControlInterfaceBackdoor;
-    CAmControlReceiver pControlReceiver;
-    CAmDatabaseObserver pObserver;
-    CAmCommonFunctions pCF;
-    void SetUp();
-    void TearDown();
+    class CAmRouterMapTest: public ::testing::Test
+    {
+    public:
+        CAmRouterMapTest();
+        ~CAmRouterMapTest();
+        std::vector<std::string> plistRoutingPluginDirs;
+        std::vector<std::string> plistCommandPluginDirs;
+        CAmSocketHandler pSocketHandler;
+        CAmControlSender pControlSender;
+        CAmDatabaseHandlerMap pDatabaseHandler;
+        CAmRouter pRouter;
+        CAmRoutingSender pRoutingSender;
+        CAmCommandSender pCommandSender;
+        MockIAmCommandSend pMockInterface;
+        MockIAmControlSend pMockControlInterface;
+        IAmRoutingBackdoor pRoutingInterfaceBackdoor;
+        IAmCommandBackdoor pCommandInterfaceBackdoor;
+        IAmControlBackdoor pControlInterfaceBackdoor;
+        CAmControlReceiver pControlReceiver;
+        CAmCommonFunctions pCF;
+        void SetUp();
+        void TearDown();
 
-    void createMainConnectionSetup();
+        void createMainConnectionSetup();
 
-    void enterDomainDB(const std::string & domainName, am_domainID_t & domainID);
-    void enterSourceDB(const std::string & sourceName, const am_domainID_t domainID, const std::vector<am_CustomConnectionFormat_t> & connectionFormats, am_sourceID_t & sourceID);
-    void enterSinkDB(const std::string & sinkName, const am_domainID_t domainID, const std::vector<am_CustomConnectionFormat_t> & connectionFormats, am_sinkID_t & sinkID);
-    void enterGatewayDB(const std::string & gwName,
-							const am_domainID_t domainSourceID,
-							const am_domainID_t domainSinkID,
-							const std::vector<am_CustomConnectionFormat_t> & sourceConnectionFormats,
-							const std::vector<am_CustomConnectionFormat_t> & sinkConnectionFormats,
-							const std::vector<bool> & matrix,
-							const am_sourceID_t & sourceID,
-							const am_sinkID_t & sinkID,
-							am_gatewayID_t & gatewayID);
-    void enterConverterDB(const std::string & gwName,
-							  const am_domainID_t domainID,
-							  const std::vector<am_CustomConnectionFormat_t> & sourceConnectionFormats,
-							  const std::vector<am_CustomConnectionFormat_t> & sinkConnectionFormats,
-							  const std::vector<bool> & matrix,
-							  const am_sourceID_t & sourceID,
-							  const am_sinkID_t & sinkID,
-							  am_converterID_t & converterID);
-	void getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s>& returnList);
-	void getRoute(const bool onlyfree, const am_Source_s & aSource, const am_Sink_s & aSink, std::vector<am_Route_s> & listRoutes);
-	void getAllPaths(CAmRoutingNode & aSource,
-					 CAmRoutingNode & aSink,
-					 std::vector<am_Route_s> & resultPath,
-					 std::vector<std::vector<CAmRoutingNode*>> & resultNodesPath,
-					 const bool includeCycles);
-};
+        void enterDomainDB(const std::string & domainName, am_domainID_t & domainID);
+        void enterSourceDB(const std::string & sourceName, const am_domainID_t domainID, const std::vector<am_CustomConnectionFormat_t> & connectionFormats,
+                am_sourceID_t & sourceID);
+        void enterSinkDB(const std::string & sinkName, const am_domainID_t domainID, const std::vector<am_CustomConnectionFormat_t> & connectionFormats,
+                am_sinkID_t & sinkID);
+        void enterGatewayDB(const std::string & gwName, const am_domainID_t domainSourceID, const am_domainID_t domainSinkID,
+                const std::vector<am_CustomConnectionFormat_t> & sourceConnectionFormats,
+                const std::vector<am_CustomConnectionFormat_t> & sinkConnectionFormats, const std::vector<bool> & matrix, const am_sourceID_t & sourceID,
+                const am_sinkID_t & sinkID, am_gatewayID_t & gatewayID);
+        void enterConverterDB(const std::string & gwName, const am_domainID_t domainID,
+                const std::vector<am_CustomConnectionFormat_t> & sourceConnectionFormats,
+                const std::vector<am_CustomConnectionFormat_t> & sinkConnectionFormats, const std::vector<bool> & matrix, const am_sourceID_t & sourceID,
+                const am_sinkID_t & sinkID, am_converterID_t & converterID);
+        am_Error_e getRoute(const bool onlyfree, const bool shouldReload, const am_sourceID_t sourceID, const am_sinkID_t sinkID,
+                std::vector<am_Route_s>& returnList, const unsigned countCycles = 0, const unsigned pathsCount = MAX_ROUTING_PATHS);
+        am_Error_e getRoute(const bool onlyfree, const bool shouldReload, const am_Source_s & aSource, const am_Sink_s & aSink,
+                std::vector<am_Route_s> & listRoutes, const unsigned countCycles = 0, const unsigned pathsCount = MAX_ROUTING_PATHS);
+        am_Error_e getAllPaths(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s> & resultPath,
+                const unsigned countCycles = 0, const unsigned pathsCount = MAX_ROUTING_PATHS);
+    };
 
 }
 
diff --git a/AudioManagerCore/test/AmRouterTest/CAmRouterTest.cpp b/AudioManagerCore/test/AmRouterTest/CAmRouterTest.cpp
index e1acd65..ea1f452 100644
--- a/AudioManagerCore/test/AmRouterTest/CAmRouterTest.cpp
+++ b/AudioManagerCore/test/AmRouterTest/CAmRouterTest.cpp
@@ -38,16 +38,16 @@ CAmRouterTest::CAmRouterTest() :
 		pDatabaseHandler(),
         pRouter(&pDatabaseHandler, &pControlSender), //
         pRoutingSender(plistRoutingPluginDirs,dynamic_cast<IAmDatabaseHandler*>( &pDatabaseHandler )), //
-        pCommandSender(plistCommandPluginDirs), //
+        pCommandSender(plistCommandPluginDirs, &pSocketHandler), //
         pMockInterface(), //
         pMockControlInterface(), //
         pRoutingInterfaceBackdoor(), //
         pCommandInterfaceBackdoor(), //
         pControlInterfaceBackdoor(), //
-        pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender,&pSocketHandler, &pRouter), //
-        pObserver(&pCommandSender, &pRoutingSender, &pSocketHandler)
+        pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender,&pSocketHandler, &pRouter)
 {
-    pDatabaseHandler.registerObserver(&pObserver);
+    pDatabaseHandler.registerObserver(&pRoutingSender);
+    pDatabaseHandler.registerObserver(&pCommandSender);
     pCommandInterfaceBackdoor.injectInterface(&pCommandSender, &pMockInterface);
     pControlInterfaceBackdoor.replaceController(&pControlSender, &pMockControlInterface);
 }
@@ -143,7 +143,7 @@ TEST_F(CAmRouterTest,simpleRoute2withDomainNoMatchFormats)
     compareRoute.sinkID = sinkID;
     compareRoute.sourceID = sourceID;
 
-    ASSERT_EQ(E_OK, pRouter.getRoute(true,sourceID,sinkID,listRoutes));
+    ASSERT_EQ(E_NOT_POSSIBLE, pRouter.getRoute(true,sourceID,sinkID,listRoutes));
     ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
 
 }
@@ -435,7 +435,7 @@ TEST_F(CAmRouterTest,simpleRoute2DomainsOnlyFreeNotFree)
     ASSERT_EQ(E_OK,pDatabaseHandler.enterConnectionDB(connection,id1));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterConnectionDB(connection1,id2));
 
-    ASSERT_EQ(E_OK, pRouter.getRoute(true,sourceID,sinkID,listRoutes));
+    ASSERT_EQ(E_NOT_POSSIBLE, pRouter.getRoute(true,sourceID,sinkID,listRoutes));
     ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
 
     ASSERT_EQ(E_OK, pRouter.getRoute(false,sourceID,sinkID,listRoutes));
@@ -1416,7 +1416,7 @@ TEST_F(CAmRouterTest,simpleRoute3DomainsNoConnection)
     compareRoute.sinkID = sinkID;
     compareRoute.sourceID = sourceID;
 
-    ASSERT_EQ(E_OK, pRouter.getRoute(false,sourceID,sinkID,listRoutes));
+    ASSERT_EQ(E_NOT_POSSIBLE, pRouter.getRoute(false,sourceID,sinkID,listRoutes));
     ASSERT_EQ(static_cast<uint>(0), listRoutes.size());
 }
 //test that checks just 2 domains, one sink one source with only one connection format each
@@ -1629,7 +1629,7 @@ TEST_F(CAmRouterTest,simpleRoute2DomainsNoMatchConnectionFormats)
     compareRoute.sinkID = sinkID;
     compareRoute.sourceID = sourceID;
 
-    ASSERT_EQ(E_OK, pRouter.getRoute(false,sourceID,sinkID,listRoutes));
+    ASSERT_EQ(E_NOT_POSSIBLE, pRouter.getRoute(false,sourceID,sinkID,listRoutes));
     ASSERT_EQ(static_cast<uint>(0),  listRoutes.size());
 }
 
diff --git a/AudioManagerCore/test/AmRouterTest/CAmRouterTest.h b/AudioManagerCore/test/AmRouterTest/CAmRouterTest.h
index 4a4e35b..ad3ed68 100644
--- a/AudioManagerCore/test/AmRouterTest/CAmRouterTest.h
+++ b/AudioManagerCore/test/AmRouterTest/CAmRouterTest.h
@@ -35,7 +35,6 @@
 #include "CAmDatabaseHandlerMap.h"
 #include "CAmControlReceiver.h"
 #include "CAmControlSender.h"
-#include "CAmDatabaseObserver.h"
 #include "CAmRoutingSender.h"
 #include "CAmRouter.h"
 #include "CAmSocketHandler.h"
@@ -68,7 +67,6 @@ public:
     IAmCommandBackdoor pCommandInterfaceBackdoor;
     IAmControlBackdoor pControlInterfaceBackdoor;
     CAmControlReceiver pControlReceiver;
-    CAmDatabaseObserver pObserver;
     CAmCommonFunctions pCF;
     void SetUp();
     void TearDown();
diff --git a/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.cpp b/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.cpp
index 2a166cf..3a576e6 100644
--- a/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.cpp
+++ b/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.cpp
@@ -35,17 +35,17 @@ CAmRoutingInterfaceTest::CAmRoutingInterfaceTest() :
         pSocketHandler(), //
         pDatabaseHandler(), //
         pRoutingSender(plistRoutingPluginDirs,dynamic_cast<IAmDatabaseHandler*>( &pDatabaseHandler )), //
-        pCommandSender(plistCommandPluginDirs), //
+        pCommandSender(plistCommandPluginDirs, &pSocketHandler), //
         pControlSender(), //
         pRouter(&pDatabaseHandler, &pControlSender), //
         pMockInterface(), //
         pRoutingInterfaceBackdoor(), //
         pCommandInterfaceBackdoor(), //
         pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender, &pSocketHandler, &pRouter), //
-        pObserver(&pCommandSender, &pRoutingSender, &pSocketHandler), //
         pRoutingReceiver(&pDatabaseHandler,  &pRoutingSender, &pControlSender, &pSocketHandler)
 {
-    pDatabaseHandler.registerObserver(&pObserver);
+    pDatabaseHandler.registerObserver(&pRoutingSender);
+    pDatabaseHandler.registerObserver(&pCommandSender);
     pRoutingInterfaceBackdoor.unloadPlugins(&pRoutingSender);
     pRoutingInterfaceBackdoor.injectInterface(&pRoutingSender, &pMockInterface, "mock");
     pControlInterfaceBackdoor.replaceController(&pControlSender, &pMockControlInterface);
@@ -546,6 +546,103 @@ TEST_F(CAmRoutingInterfaceTest,nothingTodisconnect)
     ASSERT_TRUE(listHandles.empty());
 }
 
+TEST_F(CAmRoutingInterfaceTest,handleOverflow)
+{
+    am_Handle_s handle,handleOverflow1,handleOverflow2,handleOverflowCheck1,handleOverflowCheck2;	
+    am_sinkID_t sinkID;
+    am_Sink_s sink;
+    am_Domain_s domain;
+    am_domainID_t domainID;
+   
+    pCF.createSink(sink);
+    pCF.createDomain(domain);
+    domain.name = "mock";
+    domain.busname = "mock";
+    sink.sinkID = 2;
+    sink.domainID = DYNAMIC_ID_BOUNDARY;
+    am_SoundProperty_s soundProperty;
+    soundProperty.type = SP_GENIVI_TREBLE;
+    soundProperty.value = 23;
+
+    sink.listSoundProperties.push_back(soundProperty);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+
+
+    
+    EXPECT_CALL(pMockInterface,asyncSetSinkSoundProperty(_,sinkID,_)).WillRepeatedly(Return(E_OK));
+    
+    //open handles till 50
+    for(int i=0;i<50;i++) 
+    {
+		handle.handle=0;
+		soundProperty.value = i;
+		ASSERT_EQ(E_OK, pControlReceiver.setSinkSoundProperty(handle,sinkID,soundProperty));
+	}
+	//now we ack 2 handles
+	EXPECT_CALL(pMockControlInterface,cbAckSetSinkSoundProperty(_,E_OK));
+	ASSERT_EQ(E_OK, pControlReceiver.setSinkSoundProperty(handleOverflow1,sinkID,soundProperty));
+	pRoutingReceiver.ackSetSinkSoundProperty(handleOverflow1,E_OK);
+	
+	EXPECT_CALL(pMockControlInterface,cbAckSetSinkSoundProperty(_,E_OK));
+	ASSERT_EQ(E_OK, pControlReceiver.setSinkSoundProperty(handleOverflow2,sinkID,soundProperty));
+	pRoutingReceiver.ackSetSinkSoundProperty(handleOverflow2,E_OK);
+	    
+	for(int i=52;i<1023;i++) //now we get into the overflow areay
+    {
+		handle.handle=0;
+		soundProperty.value = i;
+		ASSERT_EQ(E_OK, pControlReceiver.setSinkSoundProperty(handle,sinkID,soundProperty));
+	}
+	
+	//the next two handles must be the one we already acked
+	ASSERT_EQ(E_OK, pControlReceiver.setSinkSoundProperty(handleOverflowCheck1,sinkID,soundProperty));
+	ASSERT_EQ(handleOverflow1.handle,handleOverflowCheck1.handle);
+	
+	ASSERT_EQ(E_OK, pControlReceiver.setSinkSoundProperty(handleOverflowCheck2,sinkID,soundProperty));
+	ASSERT_EQ(handleOverflow2.handle,handleOverflowCheck2.handle);
+	
+}
+
+TEST_F(CAmRoutingInterfaceTest,handleOverflowAbsolute)
+{
+    am_Handle_s handle,handleOverflow1,handleOverflow2,handleOverflowCheck1,handleOverflowCheck2;	
+    am_sinkID_t sinkID;
+    am_Sink_s sink;
+    am_Domain_s domain;
+    am_domainID_t domainID;
+   
+    pCF.createSink(sink);
+    pCF.createDomain(domain);
+    domain.name = "mock";
+    domain.busname = "mock";
+    sink.sinkID = 2;
+    sink.domainID = DYNAMIC_ID_BOUNDARY;
+    am_SoundProperty_s soundProperty;
+    soundProperty.type = SP_GENIVI_TREBLE;
+    soundProperty.value = 23;
+
+    sink.listSoundProperties.push_back(soundProperty);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+
+
+    
+    EXPECT_CALL(pMockInterface,asyncSetSinkSoundProperty(_,sinkID,_)).WillRepeatedly(Return(E_OK));
+    
+    
+	for(int i=0;i<1023;i++) //we fill up the handles
+    {
+		handle.handle=0;
+		soundProperty.value = i;
+		ASSERT_EQ(E_OK, pControlReceiver.setSinkSoundProperty(handle,sinkID,soundProperty));
+	}
+	
+	//the next handle must return 0!
+	ASSERT_EQ(E_OK, pControlReceiver.setSinkSoundProperty(handleOverflowCheck1,sinkID,soundProperty));
+	ASSERT_EQ(handleOverflowCheck1.handle,0);	
+}
+
 
 
 int main(int argc, char **argv)
diff --git a/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.h b/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.h
index 6233c17..78497ca 100644
--- a/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.h
+++ b/AudioManagerCore/test/AmRoutingInterfaceTest/CAmRoutingInterfaceTest.h
@@ -33,7 +33,6 @@
 #include "CAmControlReceiver.h"
 #include "CAmRoutingReceiver.h"
 #include "CAmControlSender.h"
-#include "CAmDatabaseObserver.h"
 #include "CAmRouter.h"
 #include "../IAmRoutingBackdoor.h"
 #include "../IAmCommandBackdoor.h"
@@ -66,7 +65,6 @@ public:
     IAmCommandBackdoor pCommandInterfaceBackdoor;
     IAmControlBackdoor pControlInterfaceBackdoor;
     CAmControlReceiver pControlReceiver;
-    CAmDatabaseObserver pObserver;
     CAmCommonFunctions pCF;
     void SetUp();
     void TearDown();
diff --git a/AudioManagerCore/test/CMakeLists.txt b/AudioManagerCore/test/CMakeLists.txt
index 47658b4..4459e14 100644
--- a/AudioManagerCore/test/CMakeLists.txt
+++ b/AudioManagerCore/test/CMakeLists.txt
@@ -21,7 +21,7 @@ cmake_minimum_required(VERSION 3.0)
 set(EXECUTABLE_OUTPUT_PATH ${TEST_EXECUTABLE_OUTPUT_PATH})
 
 #make aunt google stop complaining
-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUNIT_TEST=1 -DDLT_CONTEXT=AudioManager -Wno-unused-local-typedefs -lz -ldl")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUNIT_TEST=1 -DDLT_CONTEXT=AudioManager -Wno-unused-local-typedefs -lz -ldl -g -O0")
 
 add_subdirectory (AmControlInterfaceTest)
 add_subdirectory (AmMapHandlerTest)
author	GENIVI Audio Manager Maintainer <genivi-maint-audiomanager@smtp1.genivi.org>	2017-03-07 10:44:54 +0100
committer	GitHub <noreply@github.com>	2017-03-07 10:44:54 +0100
commit	71eab93f9cd67b2e0343700552adf988c420f174 (patch)
tree	9f08492872ce7de767f66535178bd0575b72a5b7 /AudioManagerCore/test
parent	41b1249b1fc3b211dd56333bdc01f7eb8977f674 (diff)
parent	ff7a091bd6500413853f381d14be55de2e3affa3 (diff)
download	audiomanager-71eab93f9cd67b2e0343700552adf988c420f174.tar.gz