* Converter Implementation .6.2

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

3 files changed, 255 insertions, 4 deletions

diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp b/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
index 29dc8ce..13de48b 100644
--- a/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
+++ b/AudioManagerDaemon/test/AmMapHandlerTest/CAmMapHandlerTest.cpp
@@ -1547,6 +1547,58 @@ TEST_F(CAmMapHandlerTest,getListGatewaysOfDomain)
     ASSERT_TRUE(std::equal(gatewayList.begin(),gatewayList.end(),gatewayCheckList.begin()) && !gatewayList.empty());
 }
 
+TEST_F(CAmMapHandlerTest,getListConvertersOfDomain)
+{
+    am_Converter_s converter, converter2;
+    am_converterID_t converterID1, converterID2;
+    am_domainID_t domainID;
+    am_Domain_s domain;
+    std::vector<am_converterID_t> converterList, converterCheckList;
+
+    pCF.createDomain(domain);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+
+    pCF.createConverter(converter);
+    converter.converterID = 1;
+    converter.name = "testGateway";
+    converter.sourceID = 1;
+    converter.sinkID = 1;
+    converter.domainID = domainID;
+    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;
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(converter2,converterID2))
+        << "ERROR: database error";
+    ASSERT_EQ(true, converterID2==2);
+    converterCheckList.push_back(converterID1);
+
+    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.getListConvertersOfDomain(4,converterList))
+        << "ERROR: database error";
+    ASSERT_TRUE(converterList.empty());
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListConvertersOfDomain(domainID,converterList))
+        << "ERROR: database error";
+    ASSERT_TRUE(std::equal(converterList.begin(),converterList.end(),converterCheckList.begin()) && !converterList.empty());
+}
+
 TEST_F(CAmMapHandlerTest,removeDomain)
 {
     am_Domain_s domain;
@@ -1564,8 +1616,6 @@ TEST_F(CAmMapHandlerTest,removeDomain)
 
 TEST_F(CAmMapHandlerTest,removeGateway)
 {
-
-
     am_Gateway_s gateway;
     am_gatewayID_t gatewayID;
     std::vector<am_Gateway_s> listGateways;
@@ -1589,6 +1639,31 @@ TEST_F(CAmMapHandlerTest,removeGateway)
     ASSERT_TRUE(listGateways.empty());
 }
 
+TEST_F(CAmMapHandlerTest,removeConverter)
+{
+    am_Converter_s converter;
+    am_converterID_t converterID;
+    std::vector<am_Converter_s> listConverters;
+    pCF.createConverter(converter);
+    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;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(converter,converterID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.removeConverterDB(converterID))
+        << "ERROR: database error";
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListConverters(listConverters))
+        << "ERROR: database error";
+    ASSERT_TRUE(listConverters.empty());
+}
+
 TEST_F(CAmMapHandlerTest,removeSink)
 {
     am_Sink_s sink;
@@ -1656,10 +1731,14 @@ TEST_F(CAmMapHandlerTest,removeNonexistentGateway)
         << "ERROR: database error";
 }
 
-TEST_F(CAmMapHandlerTest,registerGatewayCorrect)
+TEST_F(CAmMapHandlerTest,removeNonexistentConverter)
 {
+    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeConverterDB(12))
+        << "ERROR: database error";
+}
 
-
+TEST_F(CAmMapHandlerTest,registerGatewayCorrect)
+{
     //initialize gateway
     std::vector<am_Gateway_s> returnList;
     am_Gateway_s gateway, gateway1, gateway2;
@@ -1720,6 +1799,68 @@ TEST_F(CAmMapHandlerTest,registerGatewayCorrect)
     ASSERT_EQ(true, equal);
 }
 
+TEST_F(CAmMapHandlerTest,registerConverterCorrect)
+{
+    //initialize gateway
+    std::vector<am_Converter_s> returnList;
+    am_Converter_s gateway, gateway1, gateway2;
+    am_converterID_t gatewayID = 0, gatewayID1 = 0, gatewayID2 = 0;
+
+    pCF.createConverter(gateway);
+    pCF.createConverter(gateway1);
+    gateway1.converterID = 20;
+    pCF.createConverter(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;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway,gatewayID))
+        << "ERROR: database error";
+    ASSERT_EQ(100,gatewayID)
+        << "ERROR: domainID zero";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway1,gatewayID1))
+        << "ERROR: database error";
+    ASSERT_EQ(gateway1.converterID,gatewayID1)
+        << "ERROR: domainID zero";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway2,gatewayID2))
+        << "ERROR: database error";
+    ASSERT_EQ(101,gatewayID2)
+        << "ERROR: domainID zero";
+
+    //now check if we read out the correct values
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListConverters(returnList));
+    bool equal = true;
+    std::vector<am_Converter_s>::iterator listIterator = returnList.begin();
+
+    for (; listIterator < returnList.end(); ++listIterator)
+    {
+        if (listIterator->converterID == gatewayID)
+        {
+            equal = equal && pCF.compareConverter(listIterator, gateway);
+        }
+
+        if (listIterator->converterID == gatewayID1)
+        {
+            equal = equal && pCF.compareConverter(listIterator, gateway1);
+        }
+
+        if (listIterator->converterID == gatewayID2)
+        {
+            equal = equal && pCF.compareConverter(listIterator, gateway2);
+        }
+    }
+
+    ASSERT_EQ(true, equal);
+}
+
 TEST_F(CAmMapHandlerTest,getGatewayInfo)
 {
 
@@ -1789,6 +1930,73 @@ TEST_F(CAmMapHandlerTest,getGatewayInfo)
 
 }
 
+TEST_F(CAmMapHandlerTest,getConverterInfo)
+{
+    //initialize gateway
+    std::vector<am_Converter_s> returnList;
+    am_Converter_s gateway, gateway1, gateway2;
+    am_converterID_t gatewayID = 0, gatewayID1 = 0, gatewayID2 = 0;
+
+    pCF.createConverter(gateway);
+    pCF.createConverter(gateway1);
+    gateway1.converterID = 20;
+    pCF.createConverter(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;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway,gatewayID))
+        << "ERROR: database error";
+    ASSERT_EQ(100,gatewayID)
+        << "ERROR: domainID zero";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway1,gatewayID1))
+        << "ERROR: database error";
+    ASSERT_EQ(gateway1.converterID,gatewayID1)
+        << "ERROR: domainID zero";
+
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway2,gatewayID2))
+        << "ERROR: database error";
+    ASSERT_EQ(101,gatewayID2)
+        << "ERROR: domainID zero";
+
+    //now check if we read out the correct values
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListConverters(returnList));
+    bool equal = true;
+    std::vector<am_Converter_s>::iterator listIterator = returnList.begin();
+
+    for (; listIterator < returnList.end(); ++listIterator)
+    {
+        if (listIterator->converterID == gatewayID)
+        {
+            equal = equal && pCF.compareConverter(listIterator, gateway);
+        }
+
+        if (listIterator->converterID == gatewayID1)
+        {
+            equal = equal && pCF.compareConverter(listIterator, gateway1);
+        }
+
+        if (listIterator->converterID == gatewayID2)
+        {
+            equal = equal && pCF.compareConverter(listIterator, gateway2);
+        }
+    }
+
+    ASSERT_EQ(true, equal);
+
+    am_Converter_s gatewayInfo;
+    ASSERT_EQ(E_OK, pDatabaseHandler.getConverterInfoDB(20,gatewayInfo));
+    ASSERT_TRUE(pCF.compareConverter1(gateway1,gatewayInfo));
+
+}
+
 TEST_F(CAmMapHandlerTest,enterSinkThatAlreadyExistFail)
 {
     //fill the connection database
@@ -2665,6 +2873,41 @@ TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeGateway)
     ASSERT_EQ(E_OK,pDatabaseHandler.removeGatewayDB(gatewayID2))<< "ERROR: database error";
 }
 
+TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeConverter)
+{
+    //initialize gateway
+    std::vector<am_Converter_s> returnList;
+    am_Converter_s gateway, gateway1, gateway2;
+    am_converterID_t gatewayID = 0, gatewayID1 = 0, gatewayID2 = 0;
+    pCF.createConverter(gateway);
+    pCF.createConverter(gateway1);
+    gateway1.converterID = 20;
+    pCF.createConverter(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(), newConverter(Field(&am_Converter_s::converterID, 100))).Times(1);
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway,gatewayID))<< "ERROR: database error";
+    ASSERT_EQ(100,gatewayID)<< "ERROR: domainID zero";
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newConverter(Field(&am_Converter_s::converterID, 20))).Times(1);
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway1,gatewayID1))<< "ERROR: database error";
+    ASSERT_EQ(gateway1.converterID,gatewayID1)<< "ERROR: domainID zero";
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newConverter(Field(&am_Converter_s::converterID, 101))).Times(1);
+    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway2,gatewayID2))<< "ERROR: database error";
+    ASSERT_EQ(101,gatewayID2)<< "ERROR: domainID zero";
+    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removeConverter(gatewayID2)).Times(1);
+    ASSERT_EQ(E_OK,pDatabaseHandler.removeConverterDB(gatewayID2))<< "ERROR: database error";
+}
+
 TEST_F(CAmMapHandlerObserverCallbacksTest, enter_removeCrossfader)
 {
     am_Crossfader_s crossfader;
diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp b/AudioManagerDaemon/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp
index 87942c5..fecf214 100644
--- a/AudioManagerDaemon/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp
+++ b/AudioManagerDaemon/test/AmMapHandlerTest/CAmTestDatabaseObserver.cpp
@@ -46,6 +46,8 @@ void CAmDatabaseObserver::newDomain(const am_Domain_s& domain)
 { MockDatabaseObserver::getMockObserverObject()->newDomain(domain); }
 void CAmDatabaseObserver::newGateway(const am_Gateway_s& gateway)
 { MockDatabaseObserver::getMockObserverObject()->newGateway(gateway); }
+void CAmDatabaseObserver::newConverter(const am_Converter_s& coverter)
+{ MockDatabaseObserver::getMockObserverObject()->newConverter(coverter); }
 void CAmDatabaseObserver::newCrossfader(const am_Crossfader_s& crossfader)
 { MockDatabaseObserver::getMockObserverObject()->newCrossfader(crossfader); }
 void CAmDatabaseObserver::newMainConnection(const am_MainConnectionType_s& mainConnection)
@@ -60,6 +62,8 @@ void CAmDatabaseObserver::removeDomain(const am_domainID_t domainID)
 { MockDatabaseObserver::getMockObserverObject()->removeDomain(domainID); }
 void CAmDatabaseObserver::removeGateway(const am_gatewayID_t gatewayID)
 { MockDatabaseObserver::getMockObserverObject()->removeGateway(gatewayID); }
+void CAmDatabaseObserver::removeConverter(const am_converterID_t converterID)
+{ MockDatabaseObserver::getMockObserverObject()->removeConverter(converterID); }
 void CAmDatabaseObserver::removeCrossfader(const am_crossfaderID_t crossfaderID)
 { MockDatabaseObserver::getMockObserverObject()->removeCrossfader(crossfaderID); }
 void CAmDatabaseObserver::mainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)
diff --git a/AudioManagerDaemon/test/AmMapHandlerTest/MockDatabaseObserver.h b/AudioManagerDaemon/test/AmMapHandlerTest/MockDatabaseObserver.h
index 52f2599..34de3cd 100644
--- a/AudioManagerDaemon/test/AmMapHandlerTest/MockDatabaseObserver.h
+++ b/AudioManagerDaemon/test/AmMapHandlerTest/MockDatabaseObserver.h
@@ -47,6 +47,7 @@ public:
     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 newConverter(const am_Converter_s& coverter) = 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;
@@ -54,6 +55,7 @@ public:
     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 removeConverter(const am_converterID_t converterID) = 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;
@@ -79,6 +81,7 @@ class MockDatabaseObserver : public IAmDatabaseObserver{
 	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(newConverter, void(const am_Converter_s& converter));
 	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));
@@ -86,6 +89,7 @@ class MockDatabaseObserver : public IAmDatabaseObserver{
 	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(removeConverter, void(const am_converterID_t converterID));
 	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));