From 17c439ae25beec19fba090faa360d6ef04336a4c Mon Sep 17 00:00:00 2001 From: Christian Linke Date: Wed, 18 Jan 2017 05:00:44 -0800 Subject: Return all routes with all possible connection formats Removed obsolete sqlite interface handling Signed-off-by: Christian Linke Change-Id: I380f6d4ce1dab2efa47620164e72a30fa144afdd --- AudioManagerCore/include/CAmRouter.h | 28 ++-- AudioManagerCore/src/CAmRouter.cpp | 139 +++++++++---------- .../test/AmRouterMapTest/CAmRouterMapTest.cpp | 151 +++++++++++++++++---- 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 #include +#include #include #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> mNodeListGateways; //!< map with pointers to nodes with gateways, used for quick access std::map> mNodeListConverters;//!< map with pointers to nodes with converters, used for quick access - am_Error_e determineConnectionFormatsForPath(am_Route_s & routeObjects, std::vector & nodes); + am_Error_e determineConnectionFormatsForPath(am_Route_s & routeObjects, std::vector & nodes, std::vector & result); am_Error_e doConnectionFormatsForPath(am_Route_s & routeObjects, - std::vector & route, - std::vector::iterator routingElementIterator, - std::vector::iterator routeIterator); + std::vector & route, + std::vector::iterator routingElementIterator, + std::vector::iterator routeIterator, + std::vector & result); /** @@ -270,7 +270,7 @@ public: const std::vector & listSinkFormats, const am_CustomConnectionFormat_t connectionFormat, std::vector & listFormats); - static void getSourceSinkPossibleConnectionFormats(std::vector::iterator iteratorSource, + static am_Error_e getSourceSinkPossibleConnectionFormats(std::vector::iterator iteratorSource, std::vector::iterator iteratorSink, std::vector & 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*> & 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* refVertex){ am::CAmNode* 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 listSources; - std::deque listSinks; - std::deque listGateways; - std::deque 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 & nodes) +am_Error_e CAmRouter::determineConnectionFormatsForPath(am_Route_s & routeObjects, std::vector & nodes, std::vector & result) { std::vector::iterator routingElementIterator = routeObjects.route.begin(); std::vector::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 & nodes, std::vector::iterator routingElementIterator, - std::vector::iterator nodeIterator) + std::vector::iterator nodeIterator, + std::vector & result) { am_Error_e returnError = E_NOT_POSSIBLE; std::vector listConnectionFormats; @@ -520,7 +499,8 @@ am_Error_e CAmRouter::doConnectionFormatsForPath(am_Route_s & routeObjects, std::vector listConnectionFormats; std::vector::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 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::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 & 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 &)path); - if(err!=E_OK) + std::vector result; + am_Error_e err = determineConnectionFormatsForPath(nextRoute, (std::vector &)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:"<" - <" + < & convertionM } -void CAmRouter::getSourceSinkPossibleConnectionFormats(std::vector::iterator iteratorSource, +am_Error_e CAmRouter::getSourceSinkPossibleConnectionFormats(std::vector::iterator iteratorSource, std::vector::iterator iteratorSink, std::vector & 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(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(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(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 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 cfStereo; + cfStereo.push_back(CF_GENIVI_STEREO); + + std::vector 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 listRoutes; + getRoute(false, source, sink, listRoutes); + ASSERT_EQ(listRoutes.size(), static_cast(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(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 -- cgit v1.2.1