From 67b6d070bdea90463aab419d516186f498ebc6d6 Mon Sep 17 00:00:00 2001 From: Aleksandar Donchev Date: Tue, 3 Sep 2013 18:09:49 +0200 Subject: * AmMapHanlderTest - added tests for the callbacks in CAmDatabaseObserver. * An object ID added to the response whenever E_ALREADY_EXISTS is returned in CAmDatabasehandlerMap Signed-off-by: Christian Linke --- .gitignore | 2 + AudioManagerDaemon/include/CAmDatabaseHandlerMap.h | 2 + AudioManagerDaemon/src/CAmDatabaseHandlerMap.cpp | 150 +++--- .../test/AmMapHandlerTest/CAmMapHandlerTest.cpp | 511 ++++++++++++++++++++- .../test/AmMapHandlerTest/CAmMapHandlerTest.h | 21 + .../AmMapHandlerTest/CAmTestDatabaseObserver.cpp | 92 ++++ .../test/AmMapHandlerTest/CMakeLists.txt | 12 +- .../test/AmMapHandlerTest/MockDatabaseObserver.h | 114 +++++ 8 files changed, 825 insertions(+), 79 deletions(-) create mode 100644 AudioManagerDaemon/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp create mode 100644 AudioManagerDaemon/test/AmMapHandlerTest/MockDatabaseObserver.h diff --git a/.gitignore b/.gitignore index fbff9e6..e08a5bd 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,5 @@ packages/ /patch ProjectSpecific/ +/AudioManagerDaemon/fidls/AudioManager_dbus.conf +/AudioManagerDaemon/fidls/AudioManager_dbus.conf.in diff --git a/AudioManagerDaemon/include/CAmDatabaseHandlerMap.h b/AudioManagerDaemon/include/CAmDatabaseHandlerMap.h index 28ec7e6..9e292f0 100644 --- a/AudioManagerDaemon/include/CAmDatabaseHandlerMap.h +++ b/AudioManagerDaemon/include/CAmDatabaseHandlerMap.h @@ -353,6 +353,8 @@ public: bool insertSourceDB(const am_Source_s & sourceData, am_sourceID_t & sourceID); bool insertSinkClassDB(const am_SinkClass_s & sinkClass, am_sinkClass_t & sinkClassID); bool insertSourceClassDB(am_sourceClass_t & sourceClassID, const am_SourceClass_s & sourceClass); + const am_Sink_Database_s * sinkWithNameOrID(const am_sinkID_t sinkID, const std::string & name) const; + const am_Source_Database_s * sourceWithNameOrID(const am_sourceID_t sourceID, const std::string & name) const; CAmDatabaseObserver *mpDatabaseObserver; //!< pointer to the Observer ListConnectionFormat mListConnectionFormat; //!< list of connection formats diff --git a/AudioManagerDaemon/src/CAmDatabaseHandlerMap.cpp b/AudioManagerDaemon/src/CAmDatabaseHandlerMap.cpp index 3e83cc5..505aa96 100644 --- a/AudioManagerDaemon/src/CAmDatabaseHandlerMap.cpp +++ b/AudioManagerDaemon/src/CAmDatabaseHandlerMap.cpp @@ -94,6 +94,27 @@ struct CAmComparatorFlag } }; +/** + * \brief Returns an object matching predicate. + * + * Convenient method for searching in a given map. + * + * @param map Map reference. + * @param comparator Search predicate. + * @return NULL or pointer to the found object. + */ +template const TReturn * objectMatchingPredicate(const std::unordered_map & map, + std::function & comparator) +{ + typename std::unordered_map::const_iterator elementIterator = map.begin(); + for (;elementIterator != map.end(); ++elementIterator) + { + if( comparator(elementIterator->second) ) + return &elementIterator->second; + } + return NULL; +} + /** * \brief Returns the first object matching criteria. * @@ -111,17 +132,10 @@ TMapObjectType const * findFirstObjectMatchingCriteria(const std::unordered_map< TComparator & aComparator, void *context = NULL) { - typename std::unordered_map::const_iterator it = aMap.begin(); - TMapObjectType const * result = NULL; - for (; it != aMap.end(); ++it) - { - if (aComparator(it->second, aComparisonArgument, context)) - { - result = &it->second; - break; - } - } - return result; + std::function comparator = [&](const TMapObjectType & object)->bool{ + return aComparator(object, aComparisonArgument, context); + }; + return objectMatchingPredicate(aMap, comparator); } /* Domain */ @@ -425,12 +439,12 @@ am_Error_e CAmDatabaseHandlerMap::enterDomainDB(const am_Domain_s & domainData, assert(!domainData.name.empty()); assert(!domainData.busname.empty()); assert(domainData.state>=DS_UNKNOWN && domainData.state<=DS_MAX); - //first check for a reserved domain CAmComparator comparator; am_Domain_s const *reservedDomain = findFirstObjectMatchingCriteria(mMappedData.mDomainMap, domainData.name, comparator); int16_t nextID = 0; + if( NULL != reservedDomain ) { nextID = reservedDomain->domainID; @@ -438,9 +452,7 @@ am_Error_e CAmDatabaseHandlerMap::enterDomainDB(const am_Domain_s & domainData, mMappedData.mDomainMap[nextID] = domainData; mMappedData.mDomainMap[nextID].domainID = nextID; mMappedData.mDomainMap[nextID].reserved = 0; - logInfo("DatabaseHandler::enterDomainDB entered reserved domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "reserved ID:", domainID); - if (mpDatabaseObserver) mpDatabaseObserver->newDomain(mMappedData.mDomainMap[nextID]); return (E_OK); @@ -452,9 +464,7 @@ am_Error_e CAmDatabaseHandlerMap::enterDomainDB(const am_Domain_s & domainData, domainID = nextID; mMappedData.mDomainMap[nextID] = domainData; mMappedData.mDomainMap[nextID].domainID = nextID; - logInfo("DatabaseHandler::enterDomainDB entered new domain with name=", domainData.name, "busname=", domainData.busname, "nodename=", domainData.nodename, "assigned ID:", domainID); - if (mpDatabaseObserver) mpDatabaseObserver->newDomain(mMappedData.mDomainMap[nextID]); return (E_OK); @@ -512,21 +522,17 @@ am_Error_e CAmDatabaseHandlerMap::enterMainConnectionDB(const am_MainConnection_ //now check the connectionTable for all connections in the route. IF connectionID exist delay = calculateDelayForRoute(mainConnectionData.listConnectionID); - + mMappedData.mMainConnectionMap[nextID].delay = delay; logInfo("DatabaseHandler::enterMainConnectionDB entered new mainConnection with sourceID", mainConnectionData.sourceID, "sinkID:", mainConnectionData.sinkID, "delay:", delay, "assigned ID:", connectionID); if (mpDatabaseObserver) { am_MainConnectionType_s mainConnection; - mainConnection.mainConnectionID = connectionID; - mainConnection.connectionState = mainConnectionData.connectionState; - mainConnection.delay = delay; - mainConnection.sinkID = mainConnectionData.sinkID; - mainConnection.sourceID = mainConnectionData.sourceID; + mMappedData.mMainConnectionMap[nextID].getMainConnectionType(mainConnection); mpDatabaseObserver->newMainConnection(mainConnection); - mpDatabaseObserver->mainConnectionStateChanged(connectionID, mainConnectionData.connectionState); + mpDatabaseObserver->mainConnectionStateChanged(connectionID, mMappedData.mMainConnectionMap[nextID].connectionState); } - mMappedData.mMainConnectionMap[nextID].delay = delay; + //finally, we update the delay value for the maintable if (delay == 0) delay = -1; @@ -586,7 +592,10 @@ am_Error_e CAmDatabaseHandlerMap::enterSinkDB(const am_Sink_s & sinkData, am_sin { //check if the ID already exists if (existSinkNameOrID(sinkData.sinkID, sinkData.name)) + { + sinkID = sinkData.sinkID; return (E_ALREADY_EXISTS); + } } result = insertSinkDB(sinkData, temp_SinkID); if( false == result ) @@ -601,7 +610,7 @@ am_Error_e CAmDatabaseHandlerMap::enterSinkDB(const am_Sink_s & sinkData, am_sin mMappedData.mSinkMap[temp_SinkIndex].sinkID = temp_SinkID; sinkID = temp_SinkID; - am_Sink_s sink = mMappedData.mSinkMap[temp_SinkID]; + am_Sink_s & sink = mMappedData.mSinkMap[temp_SinkID]; logInfo("DatabaseHandler::enterSinkDB entered new sink with name", sink.name, "domainID:", sink.domainID, "classID:", sink.sinkClassID, "volume:", sink.volume, "assigned ID:", sink.sinkID); if (mpDatabaseObserver != NULL) @@ -646,7 +655,10 @@ am_Error_e CAmDatabaseHandlerMap::enterCrossfaderDB(const am_Crossfader_s & cros { //check if the ID already exists if (existcrossFader(crossfaderData.crossfaderID)) + { + crossfaderID = crossfaderData.crossfaderID; return (E_ALREADY_EXISTS); + } } result = insertCrossfaderDB(crossfaderData, temp_CrossfaderID); if( false == result ) @@ -659,14 +671,12 @@ am_Error_e CAmDatabaseHandlerMap::enterCrossfaderDB(const am_Crossfader_s & cros mFirstStaticCrossfader = false; } - mMappedData.mCrossfaderMap[temp_CrossfaderIndex].crossfaderID = temp_CrossfaderID; + mMappedData.mCrossfaderMap[temp_CrossfaderIndex].crossfaderID = temp_CrossfaderID; crossfaderID = temp_CrossfaderID; logInfo("DatabaseHandler::enterCrossfaderDB entered new crossfader with name=", crossfaderData.name, "sinkA= ", crossfaderData.sinkID_A, "sinkB=", crossfaderData.sinkID_B, "source=", crossfaderData.sourceID, "assigned ID:", crossfaderID); - am_Crossfader_s crossfader(crossfaderData); - crossfader.crossfaderID = crossfaderID; if (mpDatabaseObserver) - mpDatabaseObserver->newCrossfader(crossfader); + mpDatabaseObserver->newCrossfader(mMappedData.mCrossfaderMap[temp_CrossfaderIndex]); return (E_OK); } @@ -713,7 +723,10 @@ am_Error_e CAmDatabaseHandlerMap::enterGatewayDB(const am_Gateway_s & gatewayDat { //check if the ID already exists if (existGateway(gatewayData.gatewayID)) + { + gatewayID = gatewayData.gatewayID; return (E_ALREADY_EXISTS); + } } result = insertGatewayDB(gatewayData, temp_GatewayID); if( false == result ) @@ -729,10 +742,8 @@ am_Error_e CAmDatabaseHandlerMap::enterGatewayDB(const am_Gateway_s & gatewayDat gatewayID = temp_GatewayID; logInfo("DatabaseHandler::enterGatewayDB entered new gateway with name", gatewayData.name, "sourceID:", gatewayData.sourceID, "sinkID:", gatewayData.sinkID, "assigned ID:", gatewayID); - am_Gateway_s gateway = gatewayData; - gateway.gatewayID = gatewayID; if (mpDatabaseObserver) - mpDatabaseObserver->newGateway(gateway); + mpDatabaseObserver->newGateway(mMappedData.mGatewayMap[temp_GatewayIndex]); return (E_OK); } @@ -804,7 +815,10 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s & sourceData, { //check if the ID already exists if (existSourceNameOrID(sourceData.sourceID, sourceData.name)) + { + sourceID = sourceData.sourceID; return (E_ALREADY_EXISTS); + } } result = insertSourceDB(sourceData, temp_SourceID); if( false == result ) @@ -822,10 +836,8 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceDB(const am_Source_s & sourceData, logInfo("DatabaseHandler::enterSourceDB entered new source with name", sourceData.name, "domainID:", sourceData.domainID, "classID:", sourceData.sourceClassID, "visible:", sourceData.visible, "assigned ID:", sourceID); - am_Source_s source = sourceData; - source.sourceID = sourceID; if (mpDatabaseObserver) - mpDatabaseObserver->newSource(source); + mpDatabaseObserver->newSource(mMappedData.mSourceMap[temp_SourceIndex]); return (E_OK); } @@ -884,7 +896,10 @@ am_Error_e CAmDatabaseHandlerMap::enterSinkClassDB(const am_SinkClass_s & sinkCl { //check if the ID already exists if (existSinkClass(sinkClass.sinkClassID)) + { + sinkClassID = sinkClass.sinkClassID; return (E_ALREADY_EXISTS); + } } result = insertSinkClassDB(sinkClass, temp_SinkClassID); if( false == result ) @@ -937,7 +952,10 @@ am_Error_e CAmDatabaseHandlerMap::enterSourceClassDB(am_sourceClass_t & sourceCl { //check if the ID already exists if (existSourceClass(sourceClass.sourceClassID)) + { + sourceClassID = sourceClass.sourceClassID; return (E_ALREADY_EXISTS); + } } result = insertSourceClassDB(temp_SourceClassID, sourceClass); if( false == result ) @@ -1042,7 +1060,7 @@ am_Error_e CAmDatabaseHandlerMap::changeSinkAvailabilityDB(const am_Availability logInfo("DatabaseHandler::changeSinkAvailabilityDB changed sinkAvailability of sink:", sinkID, "to:", availability.availability, "Reason:", availability.availabilityReason); - if (mpDatabaseObserver && sourceVisible(sinkID)) + if (mpDatabaseObserver && sinkVisible(sinkID)) mpDatabaseObserver->sinkAvailabilityChanged(sinkID, availability); return (E_OK); } @@ -1789,7 +1807,8 @@ am_Error_e CAmDatabaseHandlerMap::changeDelayMainConnection(const am_timeSync_t if (!existMainConnection(connectionID)) return (E_NON_EXISTENT); mMappedData.mMainConnectionMap[connectionID].delay = delay; - + if (mpDatabaseObserver) + mpDatabaseObserver->timingInformationChanged(connectionID, delay); return (E_OK); } @@ -1825,18 +1844,7 @@ bool CAmDatabaseHandlerMap::existSource(const am_sourceID_t sourceID) const */ bool CAmDatabaseHandlerMap::existSourceNameOrID(const am_sourceID_t sourceID, const std::string & name) const { - bool returnVal = false; - CAmMapSource::const_iterator elementIterator = mMappedData.mSourceMap.begin(); - for (;elementIterator != mMappedData.mSourceMap.end(); ++elementIterator) - { - if( 0==elementIterator->second.reserved && - (sourceID==elementIterator->second.sourceID || name.compare(elementIterator->second.name)==0)) - { - returnVal = true; - break; - } - } - return (returnVal); + return sourceWithNameOrID(sourceID, name); } /** @@ -1870,6 +1878,36 @@ bool CAmDatabaseHandlerMap::existSink(const am_sinkID_t sinkID) const return (returnVal); } +/** + * returns source with given ID or the name if exists + * @param sourceID the ID + * @param name the name + * @return source structure if exists. + */ +const CAmDatabaseHandlerMap::am_Source_Database_s * CAmDatabaseHandlerMap::sourceWithNameOrID(const am_sourceID_t sourceID, const std::string & name) const +{ + std::function comparator = [&](const CAmDatabaseHandlerMap::am_Source_Database_s & source)->bool{ + return ( 0==source.reserved && + (sourceID==source.sourceID || name.compare(source.name)==0)); + }; + return objectMatchingPredicate(mMappedData.mSourceMap, comparator); +} + +/** + * returns sink with given ID or the name if exists + * @param sinkID the ID + * @param name the name + * @return sink structure if exists. + */ +const CAmDatabaseHandlerMap::am_Sink_Database_s * CAmDatabaseHandlerMap::sinkWithNameOrID(const am_sinkID_t sinkID, const std::string & name) const +{ + std::function comparator = [&](const CAmDatabaseHandlerMap::am_Sink_Database_s & sink)->bool{ + return ( 0==sink.reserved && + (sinkID==sink.sinkID || name.compare(sink.name)==0)); + }; + return objectMatchingPredicate(mMappedData.mSinkMap, comparator); +} + /** * checks if a sink with the ID or the name exists * @param sinkID the ID @@ -1878,19 +1916,7 @@ bool CAmDatabaseHandlerMap::existSink(const am_sinkID_t sinkID) const */ bool CAmDatabaseHandlerMap::existSinkNameOrID(const am_sinkID_t sinkID, const std::string & name) const { - bool returnVal = false; - CAmMapSink::const_iterator elementIterator = mMappedData.mSinkMap.begin(); - for (;elementIterator != mMappedData.mSinkMap.end(); ++elementIterator) - { - if( 0==elementIterator->second.reserved && - (sinkID==elementIterator->second.sinkID || name.compare(elementIterator->second.name)==0)) - { - returnVal = true; - break; - } - } - - return (returnVal); + return sinkWithNameOrID( sinkID, name)!=NULL; } /** diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp b/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp index d034b54..f52dda8 100644 --- a/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp +++ b/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp @@ -13,6 +13,7 @@ * * * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012 + * \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013 * * For further information see http://www.genivi.org/. * @@ -136,10 +137,12 @@ void CAmMapHandlerTest::createMainConnectionSetup() void CAmMapHandlerTest::SetUp() { + ::testing::FLAGS_gmock_verbose = "error"; } void CAmMapHandlerTest::TearDown() { + ::testing::FLAGS_gmock_verbose = "warning"; } TEST_F(CAmMapHandlerTest,getMainConnectionInfo) @@ -413,9 +416,6 @@ TEST_F(CAmMapHandlerTest, peekSinkID) TEST_F(CAmMapHandlerTest,crossfaders) { - - - am_Crossfader_s crossfader; am_crossfaderID_t crossfaderID; am_Sink_s sinkA, sinkB; @@ -2268,15 +2268,502 @@ TEST_F(CAmMapHandlerTest, peekDomain_2) ASSERT_TRUE(listDomains[0].domainID==domainID); } -//Commented out - gives always a warning.. -//TEST_F(databaseTest,registerDomainFailonID0) -//{ -// am_Domain_s domain; -// am_domainID_t domainID=5; -// pCF.createDomain(domain); -// domain.domainID=1; -// ASSERT_DEATH(pDatabaseHandler.enterDomainDB(domain,domainID),"Assertion `domainData.domainID==0'"); -//} +CAmMapHandlerObserverCallbacksTest::CAmMapHandlerObserverCallbacksTest() : + plistRoutingPluginDirs(), + plistCommandPluginDirs(), + pSocketHandler(), + pRoutingSender(plistRoutingPluginDirs), + pCommandSender(plistCommandPluginDirs), + pControlSender(), + mMockObserver(&pCommandSender, &pRoutingSender, &pSocketHandler), + pDatabaseHandler(), + pRouter(&pDatabaseHandler, &pControlSender), + pCF() +{ + pDatabaseHandler.registerObserver(&mMockObserver); +} + +void CAmMapHandlerObserverCallbacksTest::SetUp() +{ + +} + +void CAmMapHandlerObserverCallbacksTest::TearDown() +{ + +} + +CAmMapHandlerObserverCallbacksTest::~CAmMapHandlerObserverCallbacksTest() +{ + +} + +MATCHER_P(IsDomainDataEqualTo, value, "") { + auto lh = arg; + return lh.domainID == value.domainID && + lh.name == value.name && + lh.nodename == value.nodename && + lh.early == value.early && + lh.complete == value.complete && + lh.state == value.state; +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, peek_enter_removeDomain) +{ + std::vector listDomains; + am_Domain_s domain; + am_domainID_t domainID; + am_domainID_t domain2ID; + 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_EQ(domainID, 1); + + domain.name = "anotherdomain"; + const am_Domain_s expDomain1 = {2, 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)); + ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains)); + ASSERT_EQ(domain2ID, 2); + EXPECT_TRUE(Mock::VerifyAndClearExpectations(MockDatabaseObserver::getMockObserverObject())); + domain.name = "newdomain"; + const am_Domain_s expDomain2 = {1, domain.name, domain.busname, domain.nodename, domain.early, domain.complete, domain.state}; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newDomain(IsDomainDataEqualTo(expDomain2))).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID)); + ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains)); + ASSERT_EQ(domainID, domain2ID); // FAILS, ID is 2 instead of 1 + ASSERT_TRUE(listDomains[0].domainID==domainID); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removeDomain(domainID)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.removeDomainDB(domainID))<< "ERROR: database error"; + EXPECT_TRUE(Mock::VerifyAndClearExpectations(MockDatabaseObserver::getMockObserverObject())); +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, peek_enter_update_removeSource) +{ + std::vector listSources; + am_sourceID_t sourceID; + am_sourceID_t source2ID; + am_sourceID_t source3ID; + am_Source_s source; + pCF.createSource(source); + + //peek a source that does not exits + + ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(std::string("newsource"),sourceID)); + + //peek a second source that does not exits + + ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(std::string("newsource2"),source2ID)); + + //make sure they are is not in the list + ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources)); + ASSERT_TRUE(listSources.empty()); + ASSERT_EQ(sourceID, 100); + + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(Field(&am_Source_s::sourceID, 102))).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source3ID)); + ASSERT_EQ(source3ID, 102); + + source.name = "newsource"; + //now enter the source with the same name than the first peek and make sure it does not get a new ID + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(Field(&am_Source_s::sourceID, 100))).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source3ID)); + ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources)); + ASSERT_EQ(sourceID, source3ID); + ASSERT_TRUE(listSources[0].sourceID==sourceID); + std::vector listSoundProperties; + std::vector listConnectionFormats; + std::vector listMainSoundProperties; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceUpdated(sourceID, _, _, _)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.changeSourceDB(sourceID, 1, listSoundProperties, listConnectionFormats, listMainSoundProperties))<< "ERROR: database error"; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedSource(sourceID, _)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.removeSourceDB(sourceID))<< "ERROR: database error"; + EXPECT_TRUE(Mock::VerifyAndClearExpectations(MockDatabaseObserver::getMockObserverObject())); +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, peek_enter_update_removeSink) +{ + std::vector listSinks; + am_sinkID_t sinkID; + am_sinkID_t sink2ID; + am_sinkID_t sink3ID; + am_Sink_s sink; + pCF.createSink(sink); + + //peek a sink that does not exits + + ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(std::string("newsink"),sinkID)); + + //peek again + + ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(std::string("nextsink"),sink2ID)); + + //make sure they are is not in the list + ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks)); + ASSERT_TRUE(listSinks.empty()); + ASSERT_EQ(sinkID, 100); + + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(Field(&am_Sink_s::sinkID, 102))).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sink3ID)); + ASSERT_EQ(sink3ID, 102); + + sink.name = "newsink"; + //now enter the sink with the same name than the first peek and make sure it does not get a new ID + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(Field(&am_Sink_s::sinkID, 100))).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sink3ID)); + ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks)); + ASSERT_EQ(sinkID, sink3ID); + ASSERT_TRUE(listSinks[0].sinkID==sinkID); + std::vector listSoundProperties; + std::vector listConnectionFormats; + std::vector listMainSoundProperties; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkUpdated(sinkID, _, _, _)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.changeSinkDB(sinkID, 1, listSoundProperties, listConnectionFormats, listMainSoundProperties))<< "ERROR: database error"; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedSink(sinkID, _)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.removeSinkDB(sinkID))<< "ERROR: database error"; + EXPECT_TRUE(Mock::VerifyAndClearExpectations(MockDatabaseObserver::getMockObserverObject())); +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, peekSourceClassID) +{ + std::string sourceName("myClassID"); + am_sourceClass_t sourceClassID, peekID; + am_SourceClass_s sourceClass; + am_ClassProperty_s classProperty; + classProperty.classProperty = CP_GENIVI_SOURCE_TYPE; + classProperty.value = 13; + sourceClass.name = sourceName; + sourceClass.sourceClassID = 0; + sourceClass.listClassProperties.push_back(classProperty); + + //first we peek without an existing class + ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.peekSourceClassID(sourceName,sourceClassID)); + + //now we enter the class into the database + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSourceClassesChanged()).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass)); + + //first we peek without an existing class + ASSERT_EQ(E_OK, pDatabaseHandler.peekSourceClassID(sourceName,peekID)); + ASSERT_EQ(sourceClassID, peekID); +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, peekSinkClassID) +{ + std::string sinkName("myClassID"); + am_sinkClass_t sinkClassID, peekID; + am_SinkClass_s sinkClass; + am_ClassProperty_s classProperty; + classProperty.classProperty = CP_GENIVI_SOURCE_TYPE; + classProperty.value = 13; + sinkClass.name = sinkName; + sinkClass.sinkClassID = 0; + sinkClass.listClassProperties.push_back(classProperty); + + //first we peek without an existing class + ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.peekSinkClassID(sinkName,sinkClassID)); + + //now we enter the class into the database + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), numberOfSinkClassesChanged()).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID)); + + //first we peek without an existing class + ASSERT_EQ(E_OK, pDatabaseHandler.peekSinkClassID(sinkName,peekID)); + ASSERT_EQ(sinkClassID, peekID); +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeGateway) +{ + //initialize gateway + std::vector returnList; + am_Gateway_s gateway, gateway1, gateway2; + am_gatewayID_t gatewayID = 0, gatewayID1 = 0, gatewayID2 = 0; + pCF.createGateway(gateway); + pCF.createGateway(gateway1); + gateway1.gatewayID = 20; + pCF.createGateway(gateway2); + am_Sink_s sink; + am_Source_s source; + am_sinkID_t sinkID; + am_sourceID_t sourceID; + pCF.createSink(sink); + pCF.createSource(source); + sink.sinkID = 1; + source.sourceID = 2; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID)); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID)); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newGateway(Field(&am_Gateway_s::gatewayID, 100))).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))<< "ERROR: database error"; + ASSERT_EQ(100,gatewayID)<< "ERROR: domainID zero"; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newGateway(Field(&am_Gateway_s::gatewayID, 20))).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1))<< "ERROR: database error"; + ASSERT_EQ(gateway1.gatewayID,gatewayID1)<< "ERROR: domainID zero"; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newGateway(Field(&am_Gateway_s::gatewayID, 101))).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2))<< "ERROR: database error"; + ASSERT_EQ(101,gatewayID2)<< "ERROR: domainID zero"; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removeGateway(gatewayID2)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.removeGatewayDB(gatewayID2))<< "ERROR: database error"; +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeCrossfader) +{ + am_Crossfader_s crossfader; + am_crossfaderID_t crossfaderID; + am_Sink_s sinkA, sinkB; + am_Source_s source; + am_sourceID_t sourceID; + am_sinkID_t sinkAID, sinkBID; + pCF.createSink(sinkA); + pCF.createSink(sinkB); + sinkB.name = "sinkB"; + pCF.createSource(source); + + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID)); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkA,sinkAID)); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkB,sinkBID)); + + crossfader.crossfaderID = 0; + crossfader.hotSink = HS_SINKA; + crossfader.sinkID_A = sinkAID; + crossfader.sinkID_B = sinkBID; + crossfader.sourceID = sourceID; + crossfader.name = "Crossfader"; + crossfader.hotSink = HS_UNKNOWN; + + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newCrossfader(Field(&am_Crossfader_s::crossfaderID, 100))).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterCrossfaderDB(crossfader,crossfaderID)); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removeCrossfader(crossfaderID)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.removeCrossfaderDB(crossfaderID))<< "ERROR: database error"; +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeMainConnection) +{ + //fill the connection database + am_Connection_s connection; + am_Source_s source; + am_Sink_s sink; + std::vector connectionList; + + //we create 9 sources and sinks: + uint16_t i = 1; + for (; i < 10; i++) + { + am_sinkID_t forgetSink; + am_sourceID_t forgetSource; + am_connectionID_t connectionID; + + 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; + connection.delay = -1; + connection.connectionFormat = CF_GENIVI_ANALOG; + connection.connectionID = 0; + + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,forgetSink)); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,forgetSource)); + ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID)); + ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID)); + connectionList.push_back(connectionID); + } + //create a mainConnection + am_MainConnection_s mainConnection; + am_mainConnectionID_t mainConnectionID; + std::vector mainConnectionList; + mainConnection.listConnectionID = connectionList; + mainConnection.mainConnectionID = 0; + mainConnection.sinkID = 1; + mainConnection.sourceID = 1; + mainConnection.connectionState = CS_CONNECTED; + mainConnection.delay = -1; + + //enter mainconnection in database + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newMainConnection(Field(&am_MainConnectionType_s::mainConnectionID, 1))).Times(1); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(1, CS_CONNECTED)).Times(1); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(1, _)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID)); + ASSERT_NE(0, mainConnectionID); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedMainConnection(1)).Times(1); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(1, _)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.removeMainConnectionDB(1)) << "ERROR: database error"; +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, changeSinkAvailability) +{ + std::vector listSinks; + am_Sink_s sink; + am_sinkID_t sinkID; + pCF.createSink(sink); + am_Availability_s availability; + availability.availability = A_UNKNOWN; + availability.availabilityReason = AR_GENIVI_TEMPERATURE; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID)); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkAvailabilityChanged(_, _)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkAvailabilityDB(availability,sinkID)); + ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks)); + ASSERT_EQ(availability.availability, listSinks[0].available.availability); + ASSERT_EQ(availability.availabilityReason, listSinks[0].available.availabilityReason); +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, changeSourceAvailability) +{ + std::vector listSources; + am_Source_s source; + am_sourceID_t sourceID; + pCF.createSource(source); + am_Availability_s availability; + availability.availability = A_UNKNOWN; + availability.availabilityReason = AR_GENIVI_TEMPERATURE; + source.visible = true; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID)); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceAvailabilityChanged(_, _)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceAvailabilityDB(availability,sourceID)); + ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources)); + ASSERT_EQ(availability.availability, listSources[0].available.availability); + ASSERT_EQ(availability.availabilityReason, listSources[0].available.availabilityReason); +} + +TEST_F(CAmMapHandlerObserverCallbacksTest,changeMainSinkVolume) +{ + am_Sink_s sink; + am_sinkID_t sinkID; + am_mainVolume_t newVol = 20; + std::vector listSinks; + pCF.createSink(sink); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID)); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), volumeChanged(sinkID, newVol)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMainVolumeDB(newVol,sinkID)); + ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks)); + ASSERT_EQ(listSinks[0].mainVolume, newVol); +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, changeSinkMuteState) +{ + std::vector listSinks; + am_Sink_s sink; + am_sinkID_t sinkID; + pCF.createSink(sink); + am_MuteState_e muteState = MS_MUTED; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID)); + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkMuteStateChanged(sinkID, muteState)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMuteStateDB(muteState,sinkID)); + ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks)); + ASSERT_EQ(muteState, listSinks[0].muteState); +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, changeSystemProperty) +{ + std::vector listSystemProperties, listReturn; + am_SystemProperty_s systemProperty; + + systemProperty.type = SYP_UNKNOWN; + systemProperty.value = 33; + listSystemProperties.push_back(systemProperty); + ASSERT_EQ(E_OK, pDatabaseHandler.enterSystemProperties(listSystemProperties)); + systemProperty.value = 444; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), systemPropertyChanged(_)).Times(1); + ASSERT_EQ(E_OK, pDatabaseHandler.changeSystemPropertyDB(systemProperty)); + ASSERT_EQ(E_OK, pDatabaseHandler.getListSystemProperties(listReturn)); + ASSERT_EQ(listReturn[0].type, systemProperty.type); + ASSERT_EQ(listReturn[0].value, systemProperty.value); +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, changeMainNotificationsSink) +{ + am_Sink_s testSinkData; + pCF.createSink(testSinkData); + testSinkData.sinkID = 4; + am_sinkID_t sinkID; + std::vector listSinks; + std::vectorreturnList,returnList1; + + am_NotificationConfiguration_s notify; + notify.type=NT_UNKNOWN; + notify.status=NS_CHANGE; + notify.parameter=25; + + testSinkData.listMainNotificationConfigurations.push_back(notify); + + am_NotificationConfiguration_s notify1; + notify1.type=NT_MAX; + notify1.status=NS_PERIODIC; + notify1.parameter=5; + + am_NotificationConfiguration_s notify2; + notify2.type=NT_MAX; + notify2.status=NS_CHANGE; + notify2.parameter=27; + + testSinkData.listMainNotificationConfigurations.push_back(notify1); + + //enter the sink in the database + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID)) + << "ERROR: database error"; + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkMainNotificationConfigurationChanged(sinkID, _)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSinkNotificationConfigurationDB(sinkID,notify2)) + << "ERROR: database error"; +} + +TEST_F(CAmMapHandlerObserverCallbacksTest, changeMainNotificationsSources) +{ + + am_Source_s testSourceData; + pCF.createSource(testSourceData); + testSourceData.sourceID = 4; + am_sourceID_t sourceID; + std::vector listSources; + std::vectorreturnList,returnList1; + + am_NotificationConfiguration_s notify; + notify.type=NT_UNKNOWN; + notify.status=NS_CHANGE; + notify.parameter=25; + + testSourceData.listMainNotificationConfigurations.push_back(notify); + + am_NotificationConfiguration_s notify1; + notify1.type=NT_MAX; + notify1.status=NS_PERIODIC; + notify1.parameter=5; + + am_NotificationConfiguration_s notify2; + notify2.type=NT_MAX; + notify2.status=NS_CHANGE; + notify2.parameter=10; + + testSourceData.listMainNotificationConfigurations.push_back(notify1); + + //enter the sink in the database + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID)) + << "ERROR: database error"; + //read it again + ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSourceNotificationConfigurations(sourceID,returnList)) + << "ERROR: database error"; + //change a setting + EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceMainNotificationConfigurationChanged(sourceID, _)).Times(1); + ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSourceNotificationConfigurationDB(sourceID,notify2)); +} int main(int argc, char **argv) { diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.h b/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.h index f4cb0cf..2f5552d 100644 --- a/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.h +++ b/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.h @@ -13,6 +13,7 @@ * * * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012 + * \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013 * * For further information see http://www.genivi.org/. * @@ -39,6 +40,7 @@ #include "../MockIAmControlSend.h" #include "../MockIAmCommandSend.h" #include "shared/CAmSocketHandler.h" +#include "MockDatabaseObserver.h" namespace am { @@ -68,6 +70,25 @@ public: void createMainConnectionSetup(); }; +class CAmMapHandlerObserverCallbacksTest: public ::testing::Test +{ +public: + std::vector plistRoutingPluginDirs; + std::vector plistCommandPluginDirs; + CAmSocketHandler pSocketHandler; + CAmRoutingSender pRoutingSender; + CAmCommandSender pCommandSender; + CAmControlSender pControlSender; + CAmDatabaseObserver mMockObserver; + CAmDatabaseHandlerMap pDatabaseHandler; + CAmRouter pRouter; + CAmCommonFunctions pCF; + CAmMapHandlerObserverCallbacksTest(); + ~CAmMapHandlerObserverCallbacksTest(); + void SetUp(); + void TearDown(); +}; + } #endif /* MAPHANDLERTEST_H_ */ diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp b/AudioManagerDaemon/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp new file mode 100644 index 0000000..87942c5 --- /dev/null +++ b/AudioManagerDaemon/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp @@ -0,0 +1,92 @@ +/** + * 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 Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013 + * + * \file CAmTestDatabaseObserver.cpp + * For further information see http://www.genivi.org/. + * + */ + +#include "CAmDatabaseObserver.h" +#include "MockDatabaseObserver.h" + +namespace am { + +CAmDatabaseObserver::CAmDatabaseObserver(CAmCommandSender *iCommandSender, CAmRoutingSender *iRoutingSender, CAmSocketHandler *iSocketHandler) : +mCommandSender(iCommandSender), // +mRoutingSender(iRoutingSender), // +mTelnetServer(NULL), // +mSerializer(iSocketHandler) // +{} + +CAmDatabaseObserver::~CAmDatabaseObserver() {} + + +void CAmDatabaseObserver::numberOfSinkClassesChanged() +{ MockDatabaseObserver::getMockObserverObject()->numberOfSinkClassesChanged(); } +void CAmDatabaseObserver::numberOfSourceClassesChanged() +{ MockDatabaseObserver::getMockObserverObject()->numberOfSourceClassesChanged(); } +void CAmDatabaseObserver::newSink(const am_Sink_s& sink) +{ MockDatabaseObserver::getMockObserverObject()->newSink(sink); } +void CAmDatabaseObserver::newSource(const am_Source_s& source) +{ MockDatabaseObserver::getMockObserverObject()->newSource(source); } +void CAmDatabaseObserver::newDomain(const am_Domain_s& domain) +{ MockDatabaseObserver::getMockObserverObject()->newDomain(domain); } +void CAmDatabaseObserver::newGateway(const am_Gateway_s& gateway) +{ MockDatabaseObserver::getMockObserverObject()->newGateway(gateway); } +void CAmDatabaseObserver::newCrossfader(const am_Crossfader_s& crossfader) +{ MockDatabaseObserver::getMockObserverObject()->newCrossfader(crossfader); } +void CAmDatabaseObserver::newMainConnection(const am_MainConnectionType_s& mainConnection) +{ MockDatabaseObserver::getMockObserverObject()->newMainConnection(mainConnection); } +void CAmDatabaseObserver::removedMainConnection(const am_mainConnectionID_t mainConnection) +{ MockDatabaseObserver::getMockObserverObject()->removedMainConnection(mainConnection); } +void CAmDatabaseObserver::removedSink(const am_sinkID_t sinkID, const bool visible) +{ MockDatabaseObserver::getMockObserverObject()->removedSink(sinkID, visible); } +void CAmDatabaseObserver::removedSource(const am_sourceID_t sourceID, const bool visible) +{ MockDatabaseObserver::getMockObserverObject()->removedSource(sourceID, visible); } +void CAmDatabaseObserver::removeDomain(const am_domainID_t domainID) +{ MockDatabaseObserver::getMockObserverObject()->removeDomain(domainID); } +void CAmDatabaseObserver::removeGateway(const am_gatewayID_t gatewayID) +{ MockDatabaseObserver::getMockObserverObject()->removeGateway(gatewayID); } +void CAmDatabaseObserver::removeCrossfader(const am_crossfaderID_t crossfaderID) +{ MockDatabaseObserver::getMockObserverObject()->removeCrossfader(crossfaderID); } +void CAmDatabaseObserver::mainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState) +{ MockDatabaseObserver::getMockObserverObject()->mainConnectionStateChanged(connectionID, connectionState); } +void CAmDatabaseObserver::mainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty) +{ MockDatabaseObserver::getMockObserverObject()->mainSinkSoundPropertyChanged(sinkID, SoundProperty); } +void CAmDatabaseObserver::mainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty) +{ MockDatabaseObserver::getMockObserverObject()->mainSourceSoundPropertyChanged(sourceID, SoundProperty); } +void CAmDatabaseObserver::sinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s& availability) +{ MockDatabaseObserver::getMockObserverObject()->sinkAvailabilityChanged(sinkID, availability); } +void CAmDatabaseObserver::sourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s& availability) +{ MockDatabaseObserver::getMockObserverObject()->sourceAvailabilityChanged(sourceID, availability); } +void CAmDatabaseObserver::volumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume) +{ MockDatabaseObserver::getMockObserverObject()->volumeChanged(sinkID, volume); } +void CAmDatabaseObserver::sinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState) +{ MockDatabaseObserver::getMockObserverObject()->sinkMuteStateChanged(sinkID, muteState); } +void CAmDatabaseObserver::systemPropertyChanged(const am_SystemProperty_s& SystemProperty) +{ MockDatabaseObserver::getMockObserverObject()->systemPropertyChanged(SystemProperty); } +void CAmDatabaseObserver::timingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time) +{ MockDatabaseObserver::getMockObserverObject()->timingInformationChanged(mainConnection,time); } +void CAmDatabaseObserver::sinkUpdated(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector& listMainSoundProperties, const bool visible) +{ MockDatabaseObserver::getMockObserverObject()->sinkUpdated(sinkID,sinkClassID,listMainSoundProperties, visible); } +void CAmDatabaseObserver::sourceUpdated(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector& listMainSoundProperties, const bool visible) +{ MockDatabaseObserver::getMockObserverObject()->sourceUpdated(sourceID,sourceClassID,listMainSoundProperties, visible); } +void CAmDatabaseObserver::sinkMainNotificationConfigurationChanged(const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration) +{ MockDatabaseObserver::getMockObserverObject()->sinkMainNotificationConfigurationChanged(sinkID,mainNotificationConfiguration); } +void CAmDatabaseObserver::sourceMainNotificationConfigurationChanged(const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration) +{ MockDatabaseObserver::getMockObserverObject()->sourceMainNotificationConfigurationChanged(sourceID,mainNotificationConfiguration); } +} + diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/CMakeLists.txt b/AudioManagerDaemon/test/AmMapHandlerTest/CMakeLists.txt index 493de6a..0381966 100644 --- a/AudioManagerDaemon/test/AmMapHandlerTest/CMakeLists.txt +++ b/AudioManagerDaemon/test/AmMapHandlerTest/CMakeLists.txt @@ -45,8 +45,7 @@ INCLUDE_DIRECTORIES( file(GLOB DATABASE_SRCS_CXX "../../src/CAmDatabaseHandlerMap.cpp" - "../../src/CAmDatabaseObserver.cpp" - "../../src/CAmCommandSender.cpp" + "../../src/CAmCommandSender.cpp" "../../src/CAmRoutingSender.cpp" "../../src/CAmControlReceiver.cpp" "../../src/CAmControlSender.cpp" @@ -57,13 +56,16 @@ file(GLOB DATABASE_SRCS_CXX "../../src/CAmRoutingReceiver.cpp" "../../src/CAmDbusWrapper.cpp" "../CAmCommonFunctions.cpp" + "CAmTestDatabaseObserver.cpp" "*.cpp" ) IF(WITH_NSM) - SET (DATABASE_SRCS_CXX - ${DATABASE_SRCS_CXX} - "../../src/CAmNodeStateCommunicatorDBus.cpp") + IF(WITH_DBUS_WRAPPER) + SET (DATABASE_SRCS_CXX + ${DATABASE_SRCS_CXX} + "../../src/CAmNodeStateCommunicatorDBus.cpp") + ENDIF() ENDIF(WITH_NSM) ADD_EXECUTABLE( AmMapHandlerTest ${DATABASE_SRCS_CXX}) diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/MockDatabaseObserver.h b/AudioManagerDaemon/test/AmMapHandlerTest/MockDatabaseObserver.h new file mode 100644 index 0000000..52f2599 --- /dev/null +++ b/AudioManagerDaemon/test/AmMapHandlerTest/MockDatabaseObserver.h @@ -0,0 +1,114 @@ +/** + * 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 Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013 + * + * \file MockDatabaseObserver.h + * For further information see http://www.genivi.org/. + * + */ + + +#ifndef MOCKDATABASEOBSERVER_H_ +#define MOCKDATABASEOBSERVER_H_ + +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include "CAmDatabaseObserver.h" + +class CAmCommandSender; +class CAmRoutingSender; +class CAmSocketHandler; +class CAmTelnetServer; + +namespace am { +using namespace testing; + +class IAmDatabaseObserver +{ +public: + IAmDatabaseObserver() {}; + virtual ~IAmDatabaseObserver() {}; + + virtual void numberOfSinkClassesChanged() = 0; + virtual void numberOfSourceClassesChanged() = 0; + virtual void newSink(const am_Sink_s& sink) = 0; + virtual void newSource(const am_Source_s& source) = 0; + virtual void newDomain(const am_Domain_s& domain) = 0; + virtual void newGateway(const am_Gateway_s& gateway) = 0; + virtual void newCrossfader(const am_Crossfader_s& crossfader) = 0; + virtual void newMainConnection(const am_MainConnectionType_s& mainConnection) = 0; + virtual void removedMainConnection(const am_mainConnectionID_t mainConnection) = 0; + virtual void removedSink(const am_sinkID_t sinkID, const bool visible) = 0; + virtual void removedSource(const am_sourceID_t sourceID, const bool visible) = 0; + virtual void removeDomain(const am_domainID_t domainID) = 0; + virtual void removeGateway(const am_gatewayID_t gatewayID) = 0; + virtual void removeCrossfader(const am_crossfaderID_t crossfaderID) = 0; + virtual void mainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState) = 0; + virtual void mainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty) = 0; + virtual void mainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty) = 0; + virtual void sinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s& availability) = 0; + virtual void sourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s& availability) = 0; + virtual void volumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume) = 0; + virtual void sinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState) = 0; + virtual void systemPropertyChanged(const am_SystemProperty_s& SystemProperty) = 0; + virtual void timingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time) = 0; + virtual void sinkUpdated(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector& listMainSoundProperties, const bool visible) = 0; + virtual void sourceUpdated(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector& listMainSoundProperties, const bool visible) = 0; + virtual void sinkMainNotificationConfigurationChanged(const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration) = 0; + virtual void sourceMainNotificationConfigurationChanged(const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration) = 0; + +}; + +class MockDatabaseObserver : public IAmDatabaseObserver{ + public: + MOCK_METHOD0(numberOfSinkClassesChanged, void()); + MOCK_METHOD0(numberOfSourceClassesChanged, void()); + MOCK_METHOD1(newSink, void(const am_Sink_s& sink)); + MOCK_METHOD1(newSource, void(const am_Source_s& source)); + MOCK_METHOD1(newDomain, void(const am_Domain_s& domain)); + MOCK_METHOD1(newGateway, void(const am_Gateway_s& gateway)); + MOCK_METHOD1(newCrossfader, void(const am_Crossfader_s& crossfader)); + MOCK_METHOD1(newMainConnection, void(const am_MainConnectionType_s & mainConnection)); + MOCK_METHOD1(removedMainConnection, void(const am_mainConnectionID_t mainConnection)); + MOCK_METHOD2(removedSink, void(const am_sinkID_t sinkID, const bool visible)); + MOCK_METHOD2(removedSource, void(const am_sourceID_t sourceID, const bool visible)); + MOCK_METHOD1(removeDomain, void(const am_domainID_t domainID)); + MOCK_METHOD1(removeGateway, void(const am_gatewayID_t gatewayID)); + MOCK_METHOD1(removeCrossfader, void(const am_crossfaderID_t crossfaderID)); + MOCK_METHOD2(mainConnectionStateChanged, void(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)); + MOCK_METHOD2(mainSinkSoundPropertyChanged, void(const am_sinkID_t sinkID, const am_MainSoundProperty_s& SoundProperty)); + MOCK_METHOD2(mainSourceSoundPropertyChanged, void(const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty)); + MOCK_METHOD2(sinkAvailabilityChanged, void(const am_sinkID_t sinkID, const am_Availability_s& availability)); + MOCK_METHOD2(sourceAvailabilityChanged, void(const am_sourceID_t sourceID, const am_Availability_s& availability)); + MOCK_METHOD2(volumeChanged, void(const am_sinkID_t sinkID, const am_mainVolume_t volume)); + MOCK_METHOD2(sinkMuteStateChanged, void(const am_sinkID_t sinkID, const am_MuteState_e muteState)); + MOCK_METHOD1(systemPropertyChanged, void(const am_SystemProperty_s& SystemProperty)); + MOCK_METHOD2(timingInformationChanged, void(const am_mainConnectionID_t mainConnection, const am_timeSync_t time)); + MOCK_METHOD4(sinkUpdated, void(const am_sinkID_t sinkID, const am_sinkClass_t sinkClassID, const std::vector& listMainSoundProperties, const bool visible)); + MOCK_METHOD4(sourceUpdated, void(const am_sourceID_t sourceID, const am_sourceClass_t sourceClassID, const std::vector& listMainSoundProperties, const bool visible)); + MOCK_METHOD2(sinkMainNotificationConfigurationChanged, void(const am_sinkID_t sinkID, const am_NotificationConfiguration_s mainNotificationConfiguration)); + MOCK_METHOD2(sourceMainNotificationConfigurationChanged, void(const am_sourceID_t sourceID, const am_NotificationConfiguration_s mainNotificationConfiguration)); + + static MockDatabaseObserver *getMockObserverObject() + { + static MockDatabaseObserver glMockObserverObject; + return &glMockObserverObject; + } +}; + + + +} // namespace am +#endif /* MOCKDATABASEOBSERVER_H_ */ -- cgit v1.2.1