* add an out of memory handler

7 files changed, 367 insertions, 35 deletions

diff --git a/AudioManagerDaemon/include/DatabaseHandler.h b/AudioManagerDaemon/include/DatabaseHandler.h
index b182195..1337c3d 100644
--- a/AudioManagerDaemon/include/DatabaseHandler.h
+++ b/AudioManagerDaemon/include/DatabaseHandler.h
@@ -45,7 +45,6 @@ class RoutingTreeItem;
 //todo: exchange last_insert_row id to be more safe
 //todo: create test to ensure uniqueness of names throughout the database
 //todo: enforce the uniqueness of names
-//todo: set isUsed flag for gateways!
 
 /**
  * This class handles and abstracts the database
@@ -268,6 +267,7 @@ private:
     bool mFirstStaticGateway;
     bool mFirstStaticSinkClass;
     bool mFirstStaticSourceClass;
+    bool mFirstStaticCrossfader;
     typedef std::map<am_gatewayID_t, std::vector<bool> > ListConnectionFormat; //!< type for list of connection formats
     ListConnectionFormat mListConnectionFormat; //!< list of connection formats
 };
diff --git a/AudioManagerDaemon/src/DatabaseHandler.cpp b/AudioManagerDaemon/src/DatabaseHandler.cpp
index a8bc443..d9f81a6 100644
--- a/AudioManagerDaemon/src/DatabaseHandler.cpp
+++ b/AudioManagerDaemon/src/DatabaseHandler.cpp
@@ -81,6 +81,7 @@ DatabaseHandler::DatabaseHandler(std::string databasePath) :
         mFirstStaticGateway(true), //
         mFirstStaticSinkClass(true), //
         mFirstStaticSourceClass(true), //
+        mFirstStaticCrossfader(true), //
         mListConnectionFormat()
 {
 
@@ -455,10 +456,89 @@ am_Error_e DatabaseHandler::enterSinkDB(const am_Sink_s & sinkData, am_sinkID_t
 
 am_Error_e DatabaseHandler::enterCrossfaderDB(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 {
-    //todo: implement crossfader
-    (void) crossfaderData;
-    (void) crossfaderID;
-    return E_UNKNOWN;
+    assert(crossfaderData.crossfaderID<DYNAMIC_ID_BOUNDARY);
+    assert(crossfaderData.hotSink>=HS_MIN && crossfaderData.hotSink<=HS_MAX);
+    assert(!crossfaderData.name.empty());
+    assert(existSink(crossfaderData.sinkID_A));
+    assert(existSink(crossfaderData.sinkID_B));
+    assert(existSource(crossfaderData.sourceID));
+
+    sqlite3_stmt* query = NULL;
+    int eCode = 0;
+    std::string command;
+
+    //if gatewayData is zero and the first Static Sink was already entered, the ID is created
+    if (crossfaderData.crossfaderID == 0 && !mFirstStaticCrossfader)
+    {
+        command = "INSERT INTO " + std::string(CROSSFADER_TABLE) + "(name, sinkID_A, sinkID_B, sourceID, hotSink) VALUES (?,?,?,?,?)";
+    }
+    else
+    {
+        //check if the ID already exists
+        if (existcrossFader(crossfaderData.crossfaderID))
+            return E_ALREADY_EXISTS;
+        command = "INSERT INTO " + std::string(CROSSFADER_TABLE) + "(name, sinkID_A, sinkID_B, sourceID, hotSink, crossfaderID) VALUES (?,?,?,?,?,?)";
+    }
+
+    sqlite3_prepare_v2(mDatabase, command.c_str(), -1, &query, NULL);
+
+    sqlite3_bind_text(query, 1, crossfaderData.name.c_str(), crossfaderData.name.size(), SQLITE_STATIC);
+    sqlite3_bind_int(query, 2, crossfaderData.sinkID_A);
+    sqlite3_bind_int(query, 3, crossfaderData.sinkID_B);
+    sqlite3_bind_int(query, 4, crossfaderData.sourceID);
+    sqlite3_bind_int(query, 5, crossfaderData.hotSink);
+
+    //if the ID is not created, we add it to the query
+    if (crossfaderData.crossfaderID != 0)
+    {
+        sqlite3_bind_int(query, 6, crossfaderData.crossfaderID);
+    }
+
+    //if the first static sink is entered, we need to set it onto the boundary
+    else if (mFirstStaticCrossfader)
+    {
+        sqlite3_bind_int(query, 6, DYNAMIC_ID_BOUNDARY);
+        mFirstStaticCrossfader = false;
+    }
+
+    if ((eCode = sqlite3_step(query)) != SQLITE_DONE)
+    {
+        logError("DatabaseHandler::enterCrossfaderDB SQLITE Step error code:", eCode);
+        sqlite3_finalize(query);
+        return E_DATABASE_ERROR;
+    }
+
+    if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
+    {
+        logError("DatabaseHandler::enterCrossfaderDB SQLITE Finalize error code:", eCode);
+        sqlite3_finalize(query);
+        return E_DATABASE_ERROR;
+    }
+
+    //now read back the crossfaderID
+    command = "SELECT crossfaderID FROM " + std::string(CROSSFADER_TABLE) + " WHERE name=?";
+    sqlite3_prepare_v2(mDatabase, command.c_str(), -1, &query, NULL);
+    sqlite3_bind_text(query, 1, crossfaderData.name.c_str(), crossfaderData.name.size(), SQLITE_STATIC);
+    if ((eCode = sqlite3_step(query)) == SQLITE_ROW)
+    {
+        crossfaderID = sqlite3_column_int(query, 0);
+    }
+    else
+    {
+        crossfaderID = 0;
+        logError("DatabaseHandler::enterCrossfaderDB database error!:", eCode);
+        sqlite3_finalize(query);
+        return E_DATABASE_ERROR;
+    }
+    sqlite3_finalize(query);
+
+    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 (mDatabaseObserver)
+        mDatabaseObserver->newCrossfader(crossfader);
+    return E_OK;
 }
 
 am_Error_e DatabaseHandler::enterGatewayDB(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
@@ -473,12 +553,14 @@ am_Error_e DatabaseHandler::enterGatewayDB(const am_Gateway_s & gatewayData, am_
     assert(!gatewayData.convertionMatrix.empty());
     assert(!gatewayData.listSinkFormats.empty());
     assert(!gatewayData.listSourceFormats.empty());
+    assert(existSink(gatewayData.sinkID));
+    assert(existSource(gatewayData.sourceID));
 
     sqlite3_stmt* query = NULL;
     int eCode = 0;
     std::string command;
 
-    //if sinkID is zero and the first Static Sink was already entered, the ID is created
+    //if gatewayData is zero and the first Static Sink was already entered, the ID is created
     if (gatewayData.gatewayID == 0 && !mFirstStaticGateway)
     {
         command = "INSERT INTO " + std::string(GATEWAY_TABLE) + "(name, sinkID, sourceID, domainSinkID, domainSourceID, controlDomainID) VALUES (?,?,?,?,?,?)";
@@ -1232,9 +1314,19 @@ am_Error_e DatabaseHandler::removeGatewayDB(const am_gatewayID_t gatewayID)
 
 am_Error_e DatabaseHandler::removeCrossfaderDB(const am_crossfaderID_t crossfaderID)
 {
-    //todo: implement crossdfader
-    (void) crossfaderID;
-    return E_UNKNOWN;
+    assert(crossfaderID!=0);
+
+    if (!existcrossFader(crossfaderID))
+    {
+        return E_NON_EXISTENT;
+    }
+    std::string command = "DELETE from " + std::string(CROSSFADER_TABLE) + " WHERE crossfaderID=" + i2s(crossfaderID);
+    if (!sqQuery(command))
+        return E_DATABASE_ERROR;
+    logInfo("DatabaseHandler::removeDomainDB removed:", crossfaderID);
+    if (mDatabaseObserver)
+        mDatabaseObserver->removeCrossfader(crossfaderID);
+    return E_OK;
 }
 
 am_Error_e DatabaseHandler::removeDomainDB(const am_domainID_t domainID)
@@ -1619,10 +1711,39 @@ am_Error_e DatabaseHandler::getGatewayInfoDB(const am_gatewayID_t gatewayID, am_
 
 am_Error_e DatabaseHandler::getCrossfaderInfoDB(const am_crossfaderID_t crossfaderID, am_Crossfader_s & crossfaderData) const
 {
-    //todo: implement crossfader
-    (void) crossfaderID;
-    (void) crossfaderData;
-    return E_UNKNOWN;
+    assert(crossfaderID!=0);
+    if (!existcrossFader(crossfaderID))
+    {
+        return E_NON_EXISTENT;
+    }
+    sqlite3_stmt* query = NULL;
+    int eCode = 0;
+    std::string command = "SELECT name, sinkID_A, sinkID_B, sourceID, hotSink,crossfaderID FROM " + std::string(CROSSFADER_TABLE) + " WHERE crossfaderID=" + i2s(crossfaderID);
+    sqlite3_prepare_v2(mDatabase, command.c_str(), -1, &query, NULL);
+
+    while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
+    {
+        crossfaderData.name = std::string((const char*) sqlite3_column_text(query, 0));
+        crossfaderData.sinkID_A = sqlite3_column_int(query, 1);
+        crossfaderData.sinkID_B = sqlite3_column_int(query, 2);
+        crossfaderData.sourceID = sqlite3_column_int(query, 3);
+        crossfaderData.hotSink = static_cast<am_HotSink_e>(sqlite3_column_int(query, 4));
+        crossfaderData.crossfaderID = sqlite3_column_int(query, 5);
+    }
+
+    if (eCode != SQLITE_DONE)
+    {
+        logError("DatabaseHandler::getCrossfaderInfoDB SQLITE error code:", eCode);
+        return E_DATABASE_ERROR;
+    }
+
+    if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
+    {
+        logError("DatabaseHandler::getCrossfaderInfoDB SQLITE Finalize error code:", eCode);
+        return E_DATABASE_ERROR;
+    }
+
+    return E_OK;
 }
 
 am_Error_e DatabaseHandler::getListSinksOfDomain(const am_domainID_t domainID, std::vector<am_sinkID_t> & listSinkID) const
@@ -1696,12 +1817,40 @@ am_Error_e DatabaseHandler::getListSourcesOfDomain(const am_domainID_t domainID,
     return E_OK;
 }
 
-am_Error_e DatabaseHandler::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listGatewaysID) const
+am_Error_e DatabaseHandler::getListCrossfadersOfDomain(const am_domainID_t domainID, std::vector<am_crossfaderID_t> & listCrossfader) const
 {
-    //todo: implement crossfader
-    (void) listGatewaysID;
-    (void) domainID;
-    return E_UNKNOWN;
+    assert(domainID!=0);
+    listCrossfader.clear();
+    if (!existDomain(domainID))
+    {
+        return E_NON_EXISTENT;
+    }
+    sqlite3_stmt* query = NULL;
+    int eCode = 0;
+    am_crossfaderID_t temp;
+
+    std::string command = "SELECT c.crossfaderID FROM " + std::string(CROSSFADER_TABLE) + " c," + std::string(SOURCE_TABLE) + " s WHERE c.sourceID=s.sourceID AND s.domainID=" + i2s(domainID);
+    sqlite3_prepare_v2(mDatabase, command.c_str(), -1, &query, NULL);
+
+    while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
+    {
+        temp = sqlite3_column_int(query, 0);
+        listCrossfader.push_back(temp);
+    }
+
+    if (eCode != SQLITE_DONE)
+    {
+        logError("DatabaseHandler::getListCrossfadersOfDomain SQLITE error code:", eCode);
+        return E_DATABASE_ERROR;
+    }
+
+    if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
+    {
+        logError("DatabaseHandler::getListCrossfadersOfDomain SQLITE Finalize error code:", eCode);
+        return E_DATABASE_ERROR;
+    }
+
+    return E_OK;
 
 }
 
@@ -2126,9 +2275,37 @@ am_Error_e DatabaseHandler::getListSourceClasses(std::vector<am_SourceClass_s> &
 
 am_Error_e DatabaseHandler::getListCrossfaders(std::vector<am_Crossfader_s> & listCrossfaders) const
 {
-    //todo: implement crossfaders
-    (void) listCrossfaders;
-    return E_UNKNOWN;
+    listCrossfaders.clear();
+    sqlite3_stmt* query = NULL;
+    int eCode = 0;
+    am_Crossfader_s tempData;
+    std::string command = "SELECT name, sinkID_A, sinkID_B, sourceID, hotSink,crossfaderID FROM " + std::string(CROSSFADER_TABLE);
+    sqlite3_prepare_v2(mDatabase, command.c_str(), -1, &query, NULL);
+
+    while ((eCode = sqlite3_step(query)) == SQLITE_ROW)
+    {
+        tempData.name = std::string((const char*) sqlite3_column_text(query, 0));
+        tempData.sinkID_A = sqlite3_column_int(query, 1);
+        tempData.sinkID_B = sqlite3_column_int(query, 2);
+        tempData.sourceID = sqlite3_column_int(query, 3);
+        tempData.hotSink = static_cast<am_HotSink_e>(sqlite3_column_int(query, 4));
+        tempData.crossfaderID = sqlite3_column_int(query, 5);
+        listCrossfaders.push_back(tempData);
+    }
+
+    if (eCode != SQLITE_DONE)
+    {
+        logError("DatabaseHandler::getListCrossfaders SQLITE error code:", eCode);
+        return E_DATABASE_ERROR;
+    }
+
+    if ((eCode = sqlite3_finalize(query)) != SQLITE_OK)
+    {
+        logError("DatabaseHandler::getListCrossfaders SQLITE Finalize error code:", eCode);
+        return E_DATABASE_ERROR;
+    }
+
+    return E_OK;
 }
 
 am_Error_e DatabaseHandler::getListGateways(std::vector<am_Gateway_s> & listGateways) const
diff --git a/AudioManagerDaemon/src/main.cpp b/AudioManagerDaemon/src/main.cpp
index faaafdb..c4f4d0d 100644
--- a/AudioManagerDaemon/src/main.cpp
+++ b/AudioManagerDaemon/src/main.cpp
@@ -59,6 +59,7 @@
 #include <csignal>
 #include <cstring>
 #include <cstdio>
+#include <new>
 
 DLT_DECLARE_CONTEXT(AudioManager)
 
@@ -87,6 +88,13 @@ unsigned int telnetport = DEFAULT_TELNETPORT;
 unsigned int maxConnections = MAX_TELNETCONNECTIONS;
 int fd0, fd1, fd2;
 
+void OutOfMemoryHandler ()
+{
+    logError("No more memory - bye");
+    //todo: add gracefull dead here. Do what can be done persistence wise
+    exit (1);
+}
+
 void daemonize()
 {
     umask(0);
@@ -242,6 +250,9 @@ int main(int argc, char *argv[])
     signalChildAction.sa_flags = SA_NOCLDWAIT;
     sigaction(SIGCHLD, &signalChildAction, NULL);
 
+    //register new out of memory handler
+    std::set_new_handler(&OutOfMemoryHandler);
+
     //Instantiate all classes. Keep in same order !
 #ifdef WITH_SOCKETHANDLER_LOOP
     SocketHandler iSocketHandler;
diff --git a/AudioManagerDaemon/test/database/databaseTest.cpp b/AudioManagerDaemon/test/database/databaseTest.cpp
index a44804b..9fa5a3e 100644
--- a/AudioManagerDaemon/test/database/databaseTest.cpp
+++ b/AudioManagerDaemon/test/database/databaseTest.cpp
@@ -203,7 +203,85 @@ TEST_F(routingTest, peekSinkID)
 
 TEST_F(routingTest,crossfaders)
 {
-    //todo:implement crossfader tests
+
+    EXPECT_CALL(pMockInterface,cbNumberOfSinksChanged()).Times(2);
+    EXPECT_CALL(pMockInterface,cbNumberOfSourcesChanged()).Times(1);
+    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);
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkA,sinkAID));
+    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_MIN;
+
+    std::vector<am_Crossfader_s> listCrossfaders;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterCrossfaderDB(crossfader,crossfaderID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.getListCrossfaders(listCrossfaders));
+    ASSERT_EQ(crossfader.sinkID_A, listCrossfaders[0].sinkID_A);
+    ASSERT_EQ(crossfader.sinkID_B, listCrossfaders[0].sinkID_B);
+    ASSERT_EQ(crossfader.sourceID, listCrossfaders[0].sourceID);
+    ASSERT_EQ(crossfader.hotSink, listCrossfaders[0].hotSink);
+    ASSERT_EQ(100, listCrossfaders[0].crossfaderID);
+    ASSERT_EQ(crossfader.name.compare(listCrossfaders[0].name), 0);
+}
+
+TEST_F(routingTest,crossfadersGetFromDomain)
+{
+
+    EXPECT_CALL(pMockInterface,cbNumberOfSinksChanged()).Times(2);
+    EXPECT_CALL(pMockInterface,cbNumberOfSourcesChanged()).Times(1);
+    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;
+    am_domainID_t domainID;
+    am_Domain_s domain;
+    pCF.createSink(sinkA);
+    pCF.createSink(sinkB);
+    pCF.createDomain(domain);
+    sinkB.name = "sinkB";
+    pCF.createSource(source);
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
+    source.domainID=domainID;
+    sinkA.domainID=domainID;
+    sinkB.domainID=domainID;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkA,sinkAID));
+    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_MIN;
+
+    std::vector<am_crossfaderID_t> listCrossfaders;
+
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterCrossfaderDB(crossfader,crossfaderID));
+    ASSERT_EQ(E_OK,pDatabaseHandler.getListCrossfadersOfDomain(source.domainID,listCrossfaders));
+    ASSERT_EQ(100, listCrossfaders[0]);
+
 }
 
 TEST_F(routingTest,sourceState)
@@ -1223,6 +1301,8 @@ TEST_F(routingTest,getListSinksOfDomain)
 
 TEST_F(routingTest,getListGatewaysOfDomain)
 {
+    EXPECT_CALL(pMockInterface,cbNumberOfSinksChanged()).Times(1);
+    EXPECT_CALL(pMockInterface,cbNumberOfSourcesChanged()).Times(1);
     am_Gateway_s gateway, gateway2;
     am_gatewayID_t gatewayID;
     am_domainID_t domainID;
@@ -1246,6 +1326,16 @@ TEST_F(routingTest,getListGatewaysOfDomain)
     gateway2.domainSourceID = 1;
     pCF.createDomain(domain);
     gatewayCheckList.push_back(gateway.gatewayID);
+    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 = 1;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
         << "ERROR: database error";
@@ -1275,10 +1365,22 @@ TEST_F(routingTest,removeDomain)
 
 TEST_F(routingTest,removeGateway)
 {
+    EXPECT_CALL(pMockInterface,cbNumberOfSinksChanged()).Times(1);
+    EXPECT_CALL(pMockInterface,cbNumberOfSourcesChanged()).Times(1);
     am_Gateway_s gateway;
     am_gatewayID_t gatewayID;
     std::vector<am_Gateway_s> listGateways;
     pCF.createGateway(gateway);
+    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.enterGatewayDB(gateway,gatewayID))
         << "ERROR: database error";
     ASSERT_EQ(E_OK,pDatabaseHandler.removeGatewayDB(gatewayID))
@@ -1357,6 +1459,8 @@ TEST_F(routingTest,removeNonexistentGateway)
 
 TEST_F(routingTest,registerGatewayCorrect)
 {
+    EXPECT_CALL(pMockInterface,cbNumberOfSinksChanged()).Times(1);
+    EXPECT_CALL(pMockInterface,cbNumberOfSourcesChanged()).Times(1);
     //initialize gateway
     std::vector<am_Gateway_s> returnList;
     am_Gateway_s gateway, gateway1, gateway2;
@@ -1366,7 +1470,16 @@ TEST_F(routingTest,registerGatewayCorrect)
     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;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
         << "ERROR: database error";
     ASSERT_EQ(100,gatewayID)
@@ -1410,6 +1523,8 @@ TEST_F(routingTest,registerGatewayCorrect)
 
 TEST_F(routingTest,getGatewayInfo)
 {
+    EXPECT_CALL(pMockInterface,cbNumberOfSinksChanged()).Times(1);
+    EXPECT_CALL(pMockInterface,cbNumberOfSourcesChanged()).Times(1);
     //initialize gateway
     std::vector<am_Gateway_s> returnList;
     am_Gateway_s gateway, gateway1, gateway2;
@@ -1419,7 +1534,16 @@ TEST_F(routingTest,getGatewayInfo)
     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;
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
+    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
         << "ERROR: database error";
     ASSERT_EQ(100,gatewayID)
diff --git a/CHANGELOG b/CHANGELOG
index 2f156c0..cee400e 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,3 +1,23 @@
+commit af25985a8ccf00bb7fb080aaac33a47614f5f222
+Author: christian mueller <christian.ei.mueller@bmw.de>
+
+    * add an out of memory handler
+
+commit 9f4c15a8e89d798077ca3edf7f786dbc740aa176
+Author: christian mueller <christian.ei.mueller@bmw.de>
+
+    * implemented peeksinkclassIDs and peeksourceclassIDs
+    * changed interface of both from const to non-const
+    * corrected include headers to c++ style, eg. <cassert>
+    * corrected sendChangedData return type to void
+    * implemented tests for sinkclass and sourceclass peeking
+    * fixed bug in sockethandler (FD could not be removed) thanks to Frank
+
+commit 52a769615e476860f3e4c0196fdf7e5159a7a7c1
+Author: christian mueller <christian.ei.mueller@bmw.de>
+
+    * still the weired error but now really ok.
+
 commit 0538d699f441beb81ab64b7f59cb87329667287a
 Merge: 1b65963 bef6b6f
 Author: christian mueller <christian.ei.mueller@bmw.de>
diff --git a/PluginRoutingInterfaceAsync/test/CMakeLists.txt b/PluginRoutingInterfaceAsync/test/CMakeLists.txt
index c060a71..e80d80b 100644
--- a/PluginRoutingInterfaceAsync/test/CMakeLists.txt
+++ b/PluginRoutingInterfaceAsync/test/CMakeLists.txt
@@ -67,7 +67,7 @@ file(GLOB ASYNC_PLUGIN_INTERFACE_INTERRUPT_SRCS_CXX
 )
 
 ADD_EXECUTABLE(asyncRoutingInterfaceTest ${ASYNC_PLUGIN_INTERFACE_SRCS_CXX})
-ADD_EXECUTABLE(asyncRoutingInterfaceInterruptTest ${ASYNC_PLUGIN_INTERFACE_INTERRUPT_SRCS_CXX})
+#ADD_EXECUTABLE(asyncRoutingInterfaceInterruptTest ${ASYNC_PLUGIN_INTERFACE_INTERRUPT_SRCS_CXX})
 
 
 TARGET_LINK_LIBRARIES(asyncRoutingInterfaceTest 
@@ -79,16 +79,16 @@ TARGET_LINK_LIBRARIES(asyncRoutingInterfaceTest
     gmock
 )
 
-TARGET_LINK_LIBRARIES(asyncRoutingInterfaceInterruptTest 
-    ${DLT_LIBRARIES}
-    ${CMAKE_DL_LIBS}
-    ${CMAKE_THREAD_LIBS_INIT}
-    ${GTEST_LIBRARIES}
-    ${DBUS_LIBRARY}
-    gmock
-)
+#TARGET_LINK_LIBRARIES(asyncRoutingInterfaceInterruptTest 
+#    ${DLT_LIBRARIES}
+#    ${CMAKE_DL_LIBS}
+#    ${CMAKE_THREAD_LIBS_INIT}
+#    ${GTEST_LIBRARIES}
+#    ${DBUS_LIBRARY}
+#    gmock
+#)
 
-INSTALL(TARGETS asyncRoutingInterfaceInterruptTest 
+INSTALL(TARGETS asyncRoutingInterfaceTest 
         DESTINATION "~/AudioManagerTest/"
         PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ
         COMPONENT tests
diff --git a/includes/config.h b/includes/config.h
index ece351a..b83c8d3 100644
--- a/includes/config.h
+++ b/includes/config.h
@@ -1,7 +1,7 @@
 #ifndef _CONFIG_H
 #define _CONFIG_H
 
-#define DAEMONVERSION "ver-0.0.1-20-g0538d69"
+#define DAEMONVERSION "ver-0.0.1-23-gaf25985"
 
 #define WITH_DBUS_WRAPPER
 #define WITH_SOCKETHANDLER_LOOP