Return all routes with all possible connection formats

Removed obsolete sqlite interface handling

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

Change-Id: I380f6d4ce1dab2efa47620164e72a30fa144afdd

3 files changed, 200 insertions, 118 deletions

diff --git a/AudioManagerCore/include/CAmRouter.h b/AudioManagerCore/include/CAmRouter.h
index 7e52b7c..705fb4a 100644
--- a/AudioManagerCore/include/CAmRouter.h
+++ b/AudioManagerCore/include/CAmRouter.h
@@ -27,6 +27,7 @@
 
 #include <assert.h>
 #include <vector>
+#include <iomanip>
 #include <functional>
 #include "audiomanagertypes.h"
 #include "CAmGraph.h"
@@ -35,7 +36,6 @@
 
 namespace am
 {
-#define ROUTING_BUILD_CONNECTIONS 1
 
 /**
  * Optimal path search between a source and a sink is implemented with a graph which contains nodes - sinks, sources, gateways, converters.
@@ -105,20 +105,19 @@ struct am_RoutingNodeData_s
 					};
 
 #ifdef TRACE_GRAPH
+#define COUT_NODE(HEAD, NAME, ID) \
+	std::cout << HEAD << "(" << std::setfill('0') << std::setw(4) << ID << " " << NAME << ")";
+
 	void trace() const
 	{
 		if(type==SINK)
-			std::cout << "[SINK:" << data.sink->sinkID << ":" << data.sink->name << "(" << data.sink->domainID << ")"
-			<< "]";
+			COUT_NODE("SI", data.sink->name, data.sink->sinkID )
 		else if(type==SOURCE)
-			std::cout << "[SOUR:" << data.source->sourceID << ":" << data.source->name << "(" << data.source->domainID << ")"
-			<< "]";
+			COUT_NODE("SO", data.source->name, data.source->sourceID )
 		else if(type==GATEWAY)
-			std::cout << "[GATE:" << data.gateway->gatewayID << ":" << data.gateway->name << "(" << data.gateway->controlDomainID << ")"
-			<< "]";
+			COUT_NODE("GA", data.gateway->name, data.gateway->gatewayID )
 		else if(type==CONVERTER)
-			std::cout << "[CONV:" << data.converter->converterID << ":" << data.converter->name << "(" << data.converter->domainID << ")"
-			<< "]";
+			COUT_NODE("CO", data.converter->name, data.converter->converterID )
 	};
 #endif
 
@@ -160,11 +159,12 @@ class CAmRouter
 	std::map<am_domainID_t,std::vector<CAmRoutingNode*>> mNodeListGateways;	//!< map with pointers to nodes with gateways, used for quick access
 	std::map<am_domainID_t,std::vector<CAmRoutingNode*>> mNodeListConverters;//!< map with pointers to nodes with converters, used for quick access
 
-	am_Error_e determineConnectionFormatsForPath(am_Route_s & routeObjects, std::vector<CAmRoutingNode*> & nodes);
+	am_Error_e determineConnectionFormatsForPath(am_Route_s & routeObjects, std::vector<CAmRoutingNode*> & nodes, std::vector<am_Route_s> & result);
 	am_Error_e doConnectionFormatsForPath(am_Route_s & routeObjects,
-			std::vector<CAmRoutingNode*> & route,
-			std::vector<am_RoutingElement_s>::iterator routingElementIterator,
-			std::vector<CAmRoutingNode*>::iterator routeIterator);
+											std::vector<CAmRoutingNode*> & route,
+											std::vector<am_RoutingElement_s>::iterator routingElementIterator,
+											std::vector<CAmRoutingNode*>::iterator routeIterator,
+											std::vector<am_Route_s> & result);
 
 
 	/**
@@ -270,7 +270,7 @@ public:
 			const std::vector<am_CustomConnectionFormat_t> & listSinkFormats,
 			const am_CustomConnectionFormat_t connectionFormat,
 			std::vector<am_CustomConnectionFormat_t> & listFormats);
-	static void getSourceSinkPossibleConnectionFormats(std::vector<CAmRoutingNode*>::iterator iteratorSource,
+	static am_Error_e getSourceSinkPossibleConnectionFormats(std::vector<CAmRoutingNode*>::iterator iteratorSource,
 			std::vector<CAmRoutingNode*>::iterator iteratorSink,
 			std::vector<am_CustomConnectionFormat_t> & outConnectionFormats);
 
diff --git a/AudioManagerCore/src/CAmRouter.cpp b/AudioManagerCore/src/CAmRouter.cpp
index f98bf11..f59af24 100644
--- a/AudioManagerCore/src/CAmRouter.cpp
+++ b/AudioManagerCore/src/CAmRouter.cpp
@@ -108,15 +108,19 @@ am_Error_e CAmRouter::getRoute(const bool onlyfree, const am_Source_s & aSource,
 
 #ifdef TRACE_GRAPH
 	mRoutingGraph.trace([&](const CAmRoutingNode & node, const std::vector<CAmVertex<am_RoutingNodeData_s,uint16_t>*> & list) {
-				std::cout << "Node " << node.getIndex() << " :";
+				std::cout << "Node " << node.getIndex() << ":";
 				((CAmRoutingNode &)node).getData().trace();
-				std::cout << "-->";
+				std::cout << "-->[";
+				int count = 0;
 				std::for_each(list.begin(), list.end(), [&](const CAmVertex<am_RoutingNodeData_s,uint16_t>* refVertex){
 					am::CAmNode<am::am_RoutingNodeData_s>* data = refVertex->getNode();
-					std::cout << "Node " << data->getIndex() << " :";
+					if(count>0)
+						std::cout << ", ";
+					std::cout << "Node " << data->getIndex() << ":";
 					data->getData().trace();
+					count++;
 				});
-				std::cout << std::endl;
+				std::cout << "]" << std::endl;
 			});
 #endif
 
@@ -130,54 +134,28 @@ void CAmRouter::load(const bool onlyFree)
 	clear();
 	mOnlyFreeConversionNodes = onlyFree;
 
-#if defined (WITH_DATABASE_STORAGE)
-	std::deque<am_Source_s> listSources;
-	std::deque<am_Sink_s> listSinks;
-	std::deque<am_Gateway_s> listGateways;
-	std::deque<am_Converter_s> listConverters;
-#endif
 	am_RoutingNodeData_s nodeDataSrc;
 	nodeDataSrc.type = CAmNodeDataType::SOURCE;
 	mpDatabaseHandler->enumerateSources([&](const am_Source_s & obj){
-#if defined (WITH_DATABASE_STORAGE)
-		listSources.push_back(obj);
-		nodeDataSrc.data.source = &listSources.back();
-#else
 		nodeDataSrc.data.source = (am_Source_s*)&obj;
-#endif
 		mNodeListSources[nodeDataSrc.data.source->domainID].push_back(&mRoutingGraph.addNode(nodeDataSrc));
-	});
+		});
 	am_RoutingNodeData_s nodeDataSink;
 	nodeDataSink.type = CAmNodeDataType::SINK;
 	mpDatabaseHandler->enumerateSinks([&](const am_Sink_s & obj){
-#if defined (WITH_DATABASE_STORAGE)
-		listSinks.push_back(obj);
-		nodeDataSrc.data.sink = &listSinks.back();
-#else
 		nodeDataSink.data.sink = (am_Sink_s*)&obj;
-#endif
 		mNodeListSinks[nodeDataSink.data.sink->domainID].push_back(&mRoutingGraph.addNode(nodeDataSink));
-	});
+		});
 	am_RoutingNodeData_s nodeDataGateway;
 	nodeDataGateway.type = CAmNodeDataType::GATEWAY;
 	mpDatabaseHandler->enumerateGateways([&](const am_Gateway_s & obj){
-#if defined (WITH_DATABASE_STORAGE)
-		listGateways.push_back(obj);
-		nodeDataSrc.data.gateway = &listGateways.back();
-#else
 		nodeDataGateway.data.gateway = (am_Gateway_s*)&obj;
-#endif
 		mNodeListGateways[nodeDataGateway.data.gateway->controlDomainID].push_back(&mRoutingGraph.addNode(nodeDataGateway));
 	});
 	am_RoutingNodeData_s nodeDataConverter;
 	nodeDataConverter.type = CAmNodeDataType::CONVERTER;
 	mpDatabaseHandler->enumerateConverters([&](const am_Converter_s & obj){
-#if defined (WITH_DATABASE_STORAGE)
-		listConverters.push_back(obj);
-		nodeDataSrc.data.converter = &listConverters.back();
-#else
 		nodeDataConverter.data.converter = (am_Converter_s*)&obj;
-#endif
 		mNodeListConverters[nodeDataConverter.data.converter->domainID].push_back(&mRoutingGraph.addNode(nodeDataConverter));
 	});
 
@@ -494,19 +472,20 @@ void CAmRouter::getVerticesForNode(
 
 #endif
 
-am_Error_e CAmRouter::determineConnectionFormatsForPath(am_Route_s & routeObjects, std::vector<CAmRoutingNode*> & nodes)
+am_Error_e CAmRouter::determineConnectionFormatsForPath(am_Route_s & routeObjects, std::vector<CAmRoutingNode*> & nodes, std::vector<am_Route_s> & result)
 {
 	std::vector<am_RoutingElement_s>::iterator routingElementIterator = routeObjects.route.begin();
 	std::vector<CAmRoutingNode*>::iterator nodeIterator = nodes.begin();
 	if( routingElementIterator!= routeObjects.route.end() && nodeIterator!=nodes.end() )
-		return doConnectionFormatsForPath(routeObjects, nodes, routingElementIterator, nodeIterator);
+		return doConnectionFormatsForPath(routeObjects, nodes, routingElementIterator, nodeIterator, result);
 	return E_OK;
 }
 
 am_Error_e CAmRouter::doConnectionFormatsForPath(am_Route_s & routeObjects,
 													 std::vector<CAmRoutingNode*> & nodes,
 													 std::vector<am_RoutingElement_s>::iterator routingElementIterator,
-													 std::vector<CAmRoutingNode*>::iterator nodeIterator)
+													 std::vector<CAmRoutingNode*>::iterator nodeIterator,
+													 std::vector<am_Route_s> & result)
 {
     am_Error_e returnError = E_NOT_POSSIBLE;
     std::vector<am_CustomConnectionFormat_t> listConnectionFormats;
@@ -520,7 +499,8 @@ am_Error_e CAmRouter::doConnectionFormatsForPath(am_Route_s & routeObjects,
     	std::vector<am_CustomConnectionFormat_t> listConnectionFormats;
     	std::vector<am_RoutingElement_s>::iterator tempIterator = (currentRoutingElementIterator-1);
       	CAmRoutingNode * currentNode = *currentNodeIterator;
-      	getSourceSinkPossibleConnectionFormats(currentNodeIterator+1, currentNodeIterator+2, listConnectionFormats);
+      	if((returnError = getSourceSinkPossibleConnectionFormats(currentNodeIterator+1, currentNodeIterator+2, listConnectionFormats))!=E_OK)
+      		return returnError;
 
 		if(currentNode->getData().type==CAmNodeDataType::GATEWAY)
 		{
@@ -532,29 +512,34 @@ am_Error_e CAmRouter::doConnectionFormatsForPath(am_Route_s & routeObjects,
 			am_Converter_s *converter = currentNode->getData().data.converter;
 			getMergeConnectionFormats(converter, tempIterator->connectionFormat, listConnectionFormats, listMergeConnectionFormats);
 		}
+		else
+			return (E_UNKNOWN);
 		currentNodeIterator+=3;
     }
     else
     {
     	CAmRoutingNode * currentNode = *currentNodeIterator;
-    	assert(currentNode->getData().type==CAmNodeDataType::SOURCE);
-
+    	if(currentNode->getData().type!=CAmNodeDataType::SOURCE)
+    		return (E_UNKNOWN);
     	currentNodeIterator++;
-		assert(currentNodeIterator!=nodes.end());
+
+    	if(currentNodeIterator==nodes.end())
+			return (E_UNKNOWN);
 
 		CAmRoutingNode * nodeSink = *currentNodeIterator;
-		assert(nodeSink->getData().type==CAmNodeDataType::SINK);
+		if(nodeSink->getData().type!=CAmNodeDataType::SINK)
+			return (E_UNKNOWN);
 
 		am_Source_s *source = currentNode->getData().data.source;
 		am_Sink_s *sink = nodeSink->getData().data.sink;
 		listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, listMergeConnectionFormats);
 		currentNodeIterator+=1; //now we are on the next converter/gateway
     }
-
     //let the controller decide:
     std::vector<am_CustomConnectionFormat_t> listPriorityConnectionFormats;
-    mpControlSender->getConnectionFormatChoice(currentRoutingElementIterator->sourceID, currentRoutingElementIterator->sinkID, routeObjects,
-    										  listMergeConnectionFormats, listPriorityConnectionFormats);
+    if((returnError = mpControlSender->getConnectionFormatChoice(currentRoutingElementIterator->sourceID, currentRoutingElementIterator->sinkID, routeObjects,
+    										  listMergeConnectionFormats, listPriorityConnectionFormats))!= E_OK)
+    	return (returnError);
 
     //we have the list sorted after priors - now we try one after the other with the next part of the route
 	std::vector<am_CustomConnectionFormat_t>::iterator connectionFormatIterator = listPriorityConnectionFormats.begin();
@@ -564,22 +549,25 @@ am_Error_e CAmRouter::doConnectionFormatsForPath(am_Route_s & routeObjects,
 	{
 		if (!listPriorityConnectionFormats.empty())
 		{
-			currentRoutingElementIterator->connectionFormat = listPriorityConnectionFormats.front();
+			for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator)
+			{
+				currentRoutingElementIterator->connectionFormat = *connectionFormatIterator;
+				result.push_back(routeObjects);
+			}
 			return (E_OK);
 		}
 		else
 			return (E_NOT_POSSIBLE);
 	}
-
-	for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator)
+	else
 	{
-		currentRoutingElementIterator->connectionFormat = *connectionFormatIterator;
-		if ((returnError = doConnectionFormatsForPath(routeObjects, nodes, nextIterator, currentNodeIterator)) == E_OK)
+		for (; connectionFormatIterator != listPriorityConnectionFormats.end(); ++connectionFormatIterator)
 		{
-			break;
+			currentRoutingElementIterator->connectionFormat = *connectionFormatIterator;
+			doConnectionFormatsForPath(routeObjects, nodes, nextIterator, currentNodeIterator, result);
 		}
+		return (E_OK);
 	}
-    return (returnError);
 }
 
 #ifdef ROUTING_BUILD_CONNECTIONS
@@ -642,8 +630,7 @@ am_Error_e CAmRouter::getAllPaths(CAmRoutingNode & aSource,
 	uint8_t errorsCount = 0, successCount = 0;
 	generateAllPaths(aSource, aSink, cycles, [&](const std::vector<CAmRoutingNode*> & path) {
 		resultNodesPath.push_back(path);
-		resultPath.emplace_back();
-		am_Route_s & nextRoute = resultPath.back();
+		am_Route_s nextRoute;
 		nextRoute.sinkID = aSink.getData().data.sink->sinkID;
 		nextRoute.sourceID = aSource.getData().data.source->sourceID;
 		am_RoutingElement_s * element;
@@ -665,35 +652,37 @@ am_Error_e CAmRouter::getAllPaths(CAmRoutingNode & aSource,
 				element->connectionFormat = CF_UNKNOWN;
 			}
 		}
-
-		am_Error_e err = determineConnectionFormatsForPath(nextRoute, (std::vector<CAmRoutingNode*> &)path);
-		if(err!=E_OK)
+		std::vector<am_Route_s> result;
+		am_Error_e err = determineConnectionFormatsForPath(nextRoute, (std::vector<CAmRoutingNode*> &)path, result);
+		if(err==E_UNKNOWN)
 		{
 			errorsCount++;
-			auto last = resultPath.end()-1;
-			resultPath.erase(last);
 #ifdef TRACE_GRAPH
 			std::cout<<"Error by determining connection formats for path from source:"<<nextRoute.sourceID<<" to sink:"<<nextRoute.sinkID<<"\n";
 #endif
 		}
 		else
 		{
+			resultPath.insert(resultPath.end(), result.begin(), result.end());
 #ifdef TRACE_GRAPH
-			std::cout<<"\nSuccessfully determined connection formats for path from source:"<<nextRoute.sourceID<<" to sink:"<<nextRoute.sinkID<<"\n";
-			for(auto it = nextRoute.route.begin(); it!=nextRoute.route.end(); it++)
+			std::cout<<"Successfully determined connection formats for path from source:"<<nextRoute.sourceID<<" to sink:"<<nextRoute.sinkID<<"\n";
+			for(auto routeConnectionFormats: result)
 			{
-				am_RoutingElement_s & routingElement =  *it;
-				std::cout<<"["
-						 <<routingElement.sourceID
-						 <<"->"
-						 <<routingElement.sinkID
-						 <<" cf:"
-						 <<routingElement.connectionFormat
-						 <<" d:"
-						 <<routingElement.domainID
-						 <<"]";
+				for(auto it = routeConnectionFormats.route.begin(); it!=routeConnectionFormats.route.end(); it++)
+				{
+					am_RoutingElement_s & routingElement =  *it;
+					std::cout<<"["
+							 <<routingElement.sourceID
+							 <<"->"
+							 <<routingElement.sinkID
+							 <<" CF:"
+							 <<routingElement.connectionFormat
+							 <<" D:"
+							 <<routingElement.domainID
+							 <<"]";
+				}
+				std::cout<<"\n";
 			}
-			std::cout<<"\n";
 #endif
 			successCount++;
 		}
@@ -865,20 +854,22 @@ bool CAmRouter::getRestrictedOutputFormats(const std::vector<bool> & convertionM
 }
 
 
-void CAmRouter::getSourceSinkPossibleConnectionFormats(std::vector<CAmRoutingNode*>::iterator iteratorSource,
+am_Error_e CAmRouter::getSourceSinkPossibleConnectionFormats(std::vector<CAmRoutingNode*>::iterator iteratorSource,
 		 	 	 	 	 	 	 	 	 	 std::vector<CAmRoutingNode*>::iterator iteratorSink,
 		 	 	 	 	 	 	 	 	 	 std::vector<am_CustomConnectionFormat_t> & outConnectionFormats)
 {
 	CAmRoutingNode * nodeSink = *iteratorSink;
-	assert(nodeSink->getData().type==CAmNodeDataType::SINK);
+	if(nodeSink->getData().type!=CAmNodeDataType::SINK)
+		return (E_UNKNOWN);
 
 	CAmRoutingNode * nodeSource = *iteratorSource;
-	assert(nodeSource->getData().type==CAmNodeDataType::SOURCE);
+	if(nodeSource->getData().type!=CAmNodeDataType::SOURCE)
+		return (E_UNKNOWN);
 
 	am_Source_s *source = nodeSource->getData().data.source;
 	am_Sink_s *sink = nodeSink->getData().data.sink;
 	listPossibleConnectionFormats(source->listConnectionFormats, sink->listConnectionFormats, outConnectionFormats);
+	return (E_OK);
 }
 
-
 }
diff --git a/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp b/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp
index 465995f..9dd23af 100644
--- a/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp
+++ b/AudioManagerCore/test/AmRouterMapTest/CAmRouterMapTest.cpp
@@ -175,7 +175,7 @@ void CAmRouterMapTest::getRoute(const bool onlyfree, const am_Source_s & aSource
 	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 << 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);
@@ -189,7 +189,7 @@ void CAmRouterMapTest::getRoute(const bool onlyfree, const am_sourceID_t sourceI
 	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 << 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);
@@ -207,7 +207,7 @@ void CAmRouterMapTest::getAllPaths(CAmRoutingNode & aSource,
 	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()
+	std::cout << 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";
@@ -3365,18 +3365,18 @@ 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_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);
 
@@ -3389,11 +3389,11 @@ TEST_F(CAmRouterMapTest,route3Domains1Source3Gateways3Convertres1Sink)
     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);
+	enterConverterDB("converter1", domainID3, cfAnalog, cfAuto, matrix, cSourceID3, cSinkID3, converterID1);
 	am_converterID_t converterID2;
-	enterConverterDB("converter2", domainID3, cfStereo, cfAnalog, matrix, gwSourceID4, gwSinkID4, converterID2);
+	enterConverterDB("converter2", domainID3, cfStereo, cfAnalog, matrix, cSourceID4, cSinkID4, converterID2);
 	am_converterID_t converterID3;
-	enterConverterDB("converter3", domainID3, cfStereo, cfAnalog, matrix, gwSourceID5, gwSinkID5, converterID3);
+	enterConverterDB("converter3", domainID3, cfStereo, cfAnalog, matrix, cSourceID5, cSinkID5, converterID3);
 
     am::am_Source_s source;
     am::am_Sink_s sink;
@@ -3411,34 +3411,34 @@ TEST_F(CAmRouterMapTest,route3Domains1Source3Gateways3Convertres1Sink)
 	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});
+	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, 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});
+	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, 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});
+	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, 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});
+	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])||
@@ -3461,6 +3461,97 @@ TEST_F(CAmRouterMapTest,route3Domains1Source3Gateways3Convertres1Sink)
 				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;
+	getRoute(false, source, sink, listRoutes);
+	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);
+	getRoute(false, gwSource, sink2, listRoutes);
+	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