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