/**
 * SPDX license identifier: MPL-2.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
 * \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013
 *
 * For further information see http://www.genivi.org/.
 *
 */

#include "CAmMapHandlerTest.h"
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <ios>
#include "CAmDltWrapper.h"
#include "CAmCommandLineSingleton.h"

using namespace am;
using namespace testing;


extern bool equalMainSoundProperty(const am_MainSoundProperty_s a, const am_MainSoundProperty_s b);
extern bool equalNotificationConfiguration(const am_NotificationConfiguration_s a, const am_NotificationConfiguration_s b);
extern bool equalClassProperties(const am_ClassProperty_s a, const am_ClassProperty_s b);
extern std::string int2string(int i);

int16_t const TEST_MAX_CONNECTION_ID = 20;
int16_t const TEST_MAX_MAINCONNECTION_ID = 20;
int16_t const TEST_MAX_SINK_ID = 40;

TCLAP::SwitchArg enableNoDLTDebug ("V","logDlt","print DLT logs to stdout or dlt-daemon default off",false);


CAmMapBasicTest::CAmMapBasicTest() :
                plistRoutingPluginDirs(), //
                plistCommandPluginDirs(), //
                pSocketHandler(),//
                pDatabaseHandler(), //
                pRoutingSender(plistRoutingPluginDirs), //
                pCommandSender(plistCommandPluginDirs), //
                pRoutingInterfaceBackdoor(), //
                pCommandInterfaceBackdoor(), //
                pControlSender(), //
                pRouter(&pDatabaseHandler, &pControlSender), //
                pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender,  &pSocketHandler, &pRouter), //
				pCF()
{
}

CAmMapBasicTest::~CAmMapBasicTest()
{
}

void CAmMapBasicTest::createMainConnectionSetup(am_mainConnectionID_t & mainConnectionID, am_MainConnection_s & mainConnection)
{
    //fill the connection database
    am_Connection_s connection;
    am_Source_s source;
    am_Sink_s sink;
    std::vector<am_connectionID_t> connectionList;

    //we create 9 sources and sinks:

    for (uint16_t i = 1; 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;

        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(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
        connectionList.push_back(connectionID);
    }

    //create a mainConnection
    std::vector<am_MainConnection_s> mainConnectionList;
    mainConnection.listConnectionID = connectionList;
    mainConnection.mainConnectionID = 0;
    mainConnection.sinkID = 1;
    mainConnection.sourceID = 1;
    mainConnection.connectionState = CS_CONNECTED;
    mainConnection.delay = -1;

    //enter mainconnection in database
    ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
    ASSERT_NE(0, mainConnectionID);

    //read out the mainconnections and check if they are equal to the data written.
    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(mainConnectionList));
    std::vector<am_MainConnection_s>::iterator listIterator = mainConnectionList.begin();
    for (; listIterator < mainConnectionList.end(); ++listIterator)
    {
        if (listIterator->mainConnectionID == mainConnectionID)
        {
            ASSERT_EQ(listIterator->connectionState, mainConnection.connectionState);
            ASSERT_EQ(listIterator->sinkID, mainConnection.sinkID);
            ASSERT_EQ(listIterator->sourceID, mainConnection.sourceID);
            ASSERT_EQ(listIterator->delay, mainConnection.delay);
            ASSERT_TRUE(std::equal(listIterator->listConnectionID.begin(), listIterator->listConnectionID.end(), connectionList.begin()));
        }
    }
}

void CAmMapBasicTest::SetUp()
{
	::testing::FLAGS_gmock_verbose = "error";
}

void CAmMapBasicTest::TearDown()
{
	::testing::FLAGS_gmock_verbose = "warning";
}



CAmMapHandlerTest::CAmMapHandlerTest() :
        pMockInterface(), //
        pObserver(&pCommandSender,&pRoutingSender, &pSocketHandler)
{
    pDatabaseHandler.registerObserver(&pObserver);
    pDatabaseHandler.setConnectionIDRange(1, TEST_MAX_CONNECTION_ID);
    pDatabaseHandler.setMainConnectionIDRange(1, TEST_MAX_MAINCONNECTION_ID);
    pDatabaseHandler.setSinkIDRange(DYNAMIC_ID_BOUNDARY, DYNAMIC_ID_BOUNDARY+TEST_MAX_SINK_ID);
    pCommandInterfaceBackdoor.injectInterface(&pCommandSender, &pMockInterface);
}

CAmMapHandlerTest::~CAmMapHandlerTest()
{
}

TEST_F(CAmMapHandlerTest,getMainConnectionInfo)
{
	am_mainConnectionID_t mainConnectionID;
	am_MainConnection_s mainConnection, mainConnectionT;
	createMainConnectionSetup(mainConnectionID, mainConnection);

	ASSERT_EQ(E_OK, pDatabaseHandler.getMainConnectionInfoDB(mainConnectionID,mainConnectionT));
	ASSERT_TRUE(mainConnection.connectionState == mainConnectionT.connectionState);
	ASSERT_TRUE(mainConnection.delay == mainConnectionT.delay);
	ASSERT_TRUE(std::equal(mainConnection.listConnectionID.begin(),mainConnection.listConnectionID.end(),mainConnectionT.listConnectionID.begin()));
	ASSERT_TRUE(mainConnection.sinkID == mainConnectionT.sinkID);
	ASSERT_TRUE(mainConnection.sourceID == mainConnectionT.sourceID);
	ASSERT_TRUE(mainConnectionID == mainConnectionT.mainConnectionID);
}

TEST_F(CAmMapHandlerTest,getSinkInfo)
{
    //fill the connection database
    am_Sink_s staticSink, firstDynamicSink, secondDynamicSink;
    am_sinkID_t staticSinkID, firstDynamicSinkID, secondDynamicSinkID;
    std::vector<am_Sink_s> sinkList;

    pCF.createSink(staticSink);
    staticSink.sinkID = 4;

    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
        << "ERROR: database error";
    ASSERT_EQ(staticSink.sinkID,staticSinkID)
        << "ERROR: ID not the one given in staticSink";

    pCF.createSink(firstDynamicSink);
    firstDynamicSink.name = "firstdynamic";
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(firstDynamicSink,firstDynamicSinkID))
        << "ERROR: database error";
    ASSERT_EQ(firstDynamicSinkID,DYNAMIC_ID_BOUNDARY)
        << "ERROR: ID not the one given in firstDynamicSink";

    pCF.createSink(secondDynamicSink);
    secondDynamicSink.name = "seconddynamic";

    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(secondDynamicSink,secondDynamicSinkID))
        << "ERROR: database error";
    ASSERT_NEAR(secondDynamicSinkID,DYNAMIC_ID_BOUNDARY,10)
        << "ERROR: ID not the one given in secondDynamicSink";

    //now read back and check the returns agains the given values
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(sinkList))
        << "ERROR: database error";

    std::vector<am_Sink_s>::iterator listIterator = sinkList.begin();
    for (; listIterator < sinkList.end(); ++listIterator)
    {
        if (listIterator->sinkID == staticSinkID)
        {
            ASSERT_TRUE(pCF.compareSink(listIterator, staticSink));
        }

        if (listIterator->sinkID == firstDynamicSinkID)
        {
            ASSERT_TRUE(pCF.compareSink(listIterator, firstDynamicSink));
        }

        if (listIterator->sinkID == secondDynamicSinkID)
        {
            ASSERT_TRUE(pCF.compareSink(listIterator, secondDynamicSink));
        }
    }

    am_Sink_s sinkData;
    ASSERT_EQ(E_OK, pDatabaseHandler.getSinkInfoDB(secondDynamicSinkID,sinkData));
    ASSERT_EQ(secondDynamicSink.available.availability, sinkData.available.availability);
    ASSERT_EQ(secondDynamicSink.available.availabilityReason, sinkData.available.availabilityReason);
    ASSERT_EQ(secondDynamicSink.sinkClassID, sinkData.sinkClassID);
    ASSERT_EQ(secondDynamicSink.domainID, sinkData.domainID);
    ASSERT_EQ(secondDynamicSink.visible, sinkData.visible);
    ASSERT_EQ(0, secondDynamicSink.name.compare(sinkData.name));
    ASSERT_EQ(secondDynamicSink.volume, sinkData.volume);
    ASSERT_TRUE(std::equal(secondDynamicSink.listConnectionFormats.begin(), secondDynamicSink.listConnectionFormats.end(), sinkData.listConnectionFormats.begin()));
    ASSERT_TRUE(std::equal(secondDynamicSink.listMainSoundProperties.begin(), secondDynamicSink.listMainSoundProperties.end(), sinkData.listMainSoundProperties.begin(), equalMainSoundProperty));
    ASSERT_TRUE(std::equal(secondDynamicSink.listNotificationConfigurations.begin(), secondDynamicSink.listNotificationConfigurations.end(), sinkData.listNotificationConfigurations.begin(), equalNotificationConfiguration));
    ASSERT_TRUE(std::equal(secondDynamicSink.listMainNotificationConfigurations.begin(), secondDynamicSink.listMainNotificationConfigurations.end(), sinkData.listMainNotificationConfigurations.begin(), equalNotificationConfiguration));
}

TEST_F(CAmMapHandlerTest,getSourceInfo)
{
    //fill the connection database
    am_Source_s staticSource, firstDynamicSource, secondDynamicSource;
    am_sourceID_t staticSourceID, firstDynamicSourceID, secondDynamicSourceID;
    std::vector<am_Source_s> sourceList;

    pCF.createSource(staticSource);
    staticSource.sourceID = 4;
    staticSource.name = "Static";


    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
        << "ERROR: database error";
    ASSERT_EQ(staticSource.sourceID,staticSourceID)
        << "ERROR: ID not the one given in staticSource";

    pCF.createSource(firstDynamicSource);
    firstDynamicSource.name = "firstDynamicSource";

    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(firstDynamicSource,firstDynamicSourceID))
        << "ERROR: database error";
    ASSERT_EQ(firstDynamicSourceID,DYNAMIC_ID_BOUNDARY)
        << "ERROR: ID not the one given in firstDynamicSink";


    pCF.createSource(secondDynamicSource);
    secondDynamicSource.name = "secondDynamicSource";

    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(secondDynamicSource,secondDynamicSourceID))
        << "ERROR: database error";
    ASSERT_NEAR(secondDynamicSourceID,DYNAMIC_ID_BOUNDARY,10)
        << "ERROR: ID not the one given in secondDynamicSink";

    //now read back and check the returns agains the given values
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(sourceList))
        << "ERROR: database error";

    std::vector<am_Source_s>::iterator listIterator = sourceList.begin();
    for (; listIterator < sourceList.end(); ++listIterator)
    {
        if (listIterator->sourceID == staticSourceID)
        {
            ASSERT_TRUE(pCF.compareSource(listIterator, staticSource));
        }

        if (listIterator->sourceID == firstDynamicSourceID)
        {
            ASSERT_TRUE(pCF.compareSource(listIterator, firstDynamicSource));
        }

        if (listIterator->sourceID == secondDynamicSourceID)
        {
            ASSERT_TRUE(pCF.compareSource(listIterator, secondDynamicSource));
        }
    }

    am_Source_s sourceData;
    ASSERT_EQ(E_OK, pDatabaseHandler.getSourceInfoDB(secondDynamicSourceID,sourceData));
    ASSERT_EQ(secondDynamicSource.available.availability, sourceData.available.availability);
    ASSERT_EQ(secondDynamicSource.available.availabilityReason, sourceData.available.availabilityReason);
    ASSERT_EQ(secondDynamicSource.sourceClassID, sourceData.sourceClassID);
    ASSERT_EQ(secondDynamicSource.domainID, sourceData.domainID);
    ASSERT_EQ(secondDynamicSource.interruptState, sourceData.interruptState);
    ASSERT_EQ(secondDynamicSource.visible, sourceData.visible);
    ASSERT_EQ(0, secondDynamicSource.name.compare(sourceData.name));
    ASSERT_EQ(secondDynamicSource.volume, sourceData.volume);
    ASSERT_TRUE(std::equal(secondDynamicSource.listConnectionFormats.begin(), secondDynamicSource.listConnectionFormats.end(), sourceData.listConnectionFormats.begin()));
    ASSERT_TRUE(std::equal(secondDynamicSource.listMainSoundProperties.begin(), secondDynamicSource.listMainSoundProperties.end(), sourceData.listMainSoundProperties.begin(), equalMainSoundProperty));
    ASSERT_TRUE(std::equal(secondDynamicSource.listMainNotificationConfigurations.begin(), secondDynamicSource.listMainNotificationConfigurations.end(), sourceData.listMainNotificationConfigurations.begin(), equalNotificationConfiguration));
    ASSERT_TRUE(std::equal(secondDynamicSource.listNotificationConfigurations.begin(), secondDynamicSource.listNotificationConfigurations.end(), sourceData.listNotificationConfigurations.begin(), equalNotificationConfiguration));
}

TEST_F(CAmMapHandlerTest, peekSourceID)
{

    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
    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(CAmMapHandlerTest, peekSinkID)
{

    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
    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(CAmMapHandlerTest,crossfaders)
{
    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_UNKNOWN;

    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(DYNAMIC_ID_BOUNDARY, listCrossfaders[0].crossfaderID);
    ASSERT_EQ(crossfader.name.compare(listCrossfaders[0].name), 0);
}

TEST_F(CAmMapHandlerTest,crossfadersGetFromDomain)
{



    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_UNKNOWN;

    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(DYNAMIC_ID_BOUNDARY, listCrossfaders[0]);

}

TEST_F(CAmMapHandlerTest,sourceState)
{
    am_Source_s source;
    am_sourceID_t sourceID;
    std::vector<am_Source_s> listSources;
    pCF.createSource(source);
    source.sourceState = SS_OFF;

    //prepare the test

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));

    //change the source state
    ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceState(sourceID,SS_ON));

    //read out the changed values
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
    ASSERT_EQ(listSources[0].sourceState, SS_ON);
}

TEST_F(CAmMapHandlerTest,sinkVolumeChange)
{
    am_Sink_s sink;
    am_sinkID_t sinkID;
    std::vector<am_Sink_s> listSinks;
    pCF.createSink(sink);
    sink.volume = 23;

    //prepare the test

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));

    //change the volume and check the read out
    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkVolume(sinkID,34));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
    ASSERT_EQ(listSinks[0].volume, 34);
}

TEST_F(CAmMapHandlerTest,sourceVolumeChange)
{
    am_Source_s source;
    am_sourceID_t sourceID;
    std::vector<am_Source_s> listSources;
    pCF.createSource(source);
    source.volume = 23;

    //prepare test

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));

    //change the volume and check the read out
    ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceVolume(sourceID,34));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
    ASSERT_EQ(listSources[0].volume, 34);
}

TEST_F(CAmMapHandlerTest, peekSource)
{
    std::vector<am_SourceType_s> listSourceTypes;
    std::vector<am_Source_s> listSources;
    am_sourceID_t sourceID, source2ID, 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));

    //make sure it is not in the list
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
    ASSERT_TRUE(listSources.empty());
    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSources(listSourceTypes));
    ASSERT_TRUE(listSourceTypes.empty());
    ASSERT_EQ(sourceID, DYNAMIC_ID_BOUNDARY);

    //now enter the source with the same name and make sure it does not get a new ID
    source.name = "newsource";

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source2ID));

    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
    ASSERT_EQ(sourceID, source2ID);
    ASSERT_FALSE(listSources.empty());
    ASSERT_TRUE(listSources.at(0).sourceID==sourceID);

    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSources(listSourceTypes));
    ASSERT_FALSE(listSourceTypes.empty());
    ASSERT_TRUE(listSourceTypes.at(0).sourceID==sourceID);

    //now we peek again. This time, the source exists
    ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(source.name,source3ID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
    ASSERT_TRUE(listSources.size()==1);

    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSources(listSourceTypes));
    ASSERT_TRUE(listSourceTypes.size()==1);
    ASSERT_TRUE(listSourceTypes.at(0).sourceID==source3ID);
    ASSERT_EQ(source3ID, source2ID);
}

TEST_F(CAmMapHandlerTest, peekSourceDouble)
{
    std::vector<am_SourceType_s> listSourceTypes;
    std::vector<am_Source_s> 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, DYNAMIC_ID_BOUNDARY);
    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

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source3ID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
    ASSERT_EQ(sourceID, source3ID);
    ASSERT_TRUE(listSources.size()==1);
    ASSERT_TRUE(listSources[0].sourceID==sourceID);

    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSources(listSourceTypes));
    ASSERT_TRUE(listSourceTypes.size()==1);
    ASSERT_TRUE(listSourceTypes[0].sourceID==source3ID);
}

TEST_F(CAmMapHandlerTest, peekSink)
{
	std::vector<am_SinkType_s> listSinkTypes;
    std::vector<am_Sink_s> listSinks;
    am_sinkID_t sinkID, sink2ID, 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));

    //make sure it is not in the list
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
    ASSERT_TRUE(listSinks.empty());
    ASSERT_EQ(sinkID, DYNAMIC_ID_BOUNDARY);
    sink.name = "newsink";

    //now enter the source with the same name and make sure it does not get a new ID

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sink2ID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
    ASSERT_EQ(sinkID, sink2ID);
    ASSERT_TRUE(listSinks[0].sinkID==sinkID);

    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSinks(listSinkTypes));
    ASSERT_FALSE(listSinkTypes.empty());
    ASSERT_TRUE(listSinkTypes.at(0).sinkID==sinkID);

    //now we peek again, this time, the sink exists
    ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(sink.name,sink3ID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
    ASSERT_TRUE(listSinks.size()==1);
    ASSERT_EQ(sink3ID, sink2ID);

    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSinks(listSinkTypes));
    ASSERT_TRUE(listSinkTypes.size()==1);
    ASSERT_TRUE(listSinkTypes.at(0).sinkID==sink3ID);
}

TEST_F(CAmMapHandlerTest, peekSinkDouble)
{
	std::vector<am_SinkType_s> listSinkTypes;
    std::vector<am_Sink_s> 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, DYNAMIC_ID_BOUNDARY);
    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

    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);

    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSinks(listSinkTypes));
    ASSERT_TRUE(listSinkTypes.size()==1);
    ASSERT_TRUE(listSinkTypes[0].sinkID==sink3ID);
}

TEST_F(CAmMapHandlerTest,changeConnectionTimingInformationCheckMainConnection)
{
    am_mainConnectionID_t mainConnectionID;
    am_MainConnection_s mainConnection;
    std::vector<am_Connection_s> connectionList;
    std::vector<am_MainConnectionType_s> mainList;

    //prepare the test, it is one mainconnection, so we expect one callback
    createMainConnectionSetup(mainConnectionID, mainConnection);

    //first get all visible mainconnections and make sure, the delay is set to -1 for the first entry
    ASSERT_EQ(E_OK, pDatabaseHandler.getListVisibleMainConnections(mainList));
    ASSERT_EQ(mainList[0].delay, -1);

    //no go through all connections and set the delay time to 24 for each connection
    ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(connectionList));
    std::vector<am_Connection_s>::iterator iteratorConnectionList = connectionList.begin();
    for (; iteratorConnectionList < connectionList.end(); ++iteratorConnectionList)
    {
        ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionTimingInformation(iteratorConnectionList->connectionID,24));
    }

    //we read the result again and expect that the value is now different from -1
    ASSERT_EQ(E_OK, pDatabaseHandler.getListVisibleMainConnections(mainList));
    ASSERT_EQ(mainList[0].delay, 216);
}

TEST_F(CAmMapHandlerTest,changeConnectionTimingInformation)
{
    am_Connection_s connection;
    am_connectionID_t connectionID;
    std::vector<am_Connection_s> connectionList;
    pCF.createConnection(connection);

    //enter a connection
    ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
    ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));

    //change the timing and check it
    ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionTimingInformation(connectionID, 24));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(connectionList));
    ASSERT_TRUE(connectionList[0].delay == 24);
}

TEST_F(CAmMapHandlerTest,getSinkClassOfSink)
{
    std::vector<am_SinkClass_s> sinkClassList;
    std::vector<am_ClassProperty_s> classPropertyList;
    am_SinkClass_s sinkClass, returnClass;
    am_ClassProperty_s classProperty;
    am_sinkClass_t sinkClassID;
    am_Sink_s sink;
    am_sinkID_t sinkID;
    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
    classProperty.value = 1;
    classPropertyList.push_back(classProperty);
    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
    classProperty.value = 4;
    classPropertyList.push_back(classProperty);
    sinkClass.name = "test";
    sinkClass.sinkClassID = 4;
    sinkClass.listClassProperties = classPropertyList;
    pCF.createSink(sink);
    sink.sinkClassID = 4;

    //prepare test

    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);
    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));

    ASSERT_EQ(E_OK, pDatabaseHandler.getSinkClassInfoDB(sinkID,returnClass));
    ASSERT_EQ(sinkClassList[0].name, returnClass.name);
    ASSERT_EQ(sinkClassList[0].sinkClassID, returnClass.sinkClassID);
    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),returnClass.listClassProperties.begin(),equalClassProperties));
}

TEST_F(CAmMapHandlerTest,getSourceClassOfSource)
{
    std::vector<am_SourceClass_s> sourceClassList;
    std::vector<am_ClassProperty_s> classPropertyList;
    am_SourceClass_s sourceClass, sinkSourceClass;
    am_ClassProperty_s classProperty;
    am_sourceClass_t sourceClassID;
    am_Source_s source;
    am_sourceID_t sourceID;
    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
    classProperty.value = 1;
    classPropertyList.push_back(classProperty);
    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
    classProperty.value = 4;
    classPropertyList.push_back(classProperty);
    sourceClass.name = "test";
    sourceClass.sourceClassID = 1;
    sourceClass.listClassProperties = classPropertyList;
    pCF.createSource(source);


    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_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);
    ASSERT_EQ(sourceClassList[0].sourceClassID, sinkSourceClass.sourceClassID);
    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),sinkSourceClass.listClassProperties.begin(),equalClassProperties));
}

TEST_F(CAmMapHandlerTest,removeSourceClass)
{
    std::vector<am_SourceClass_s> sourceClassList;
    std::vector<am_ClassProperty_s> classPropertyList;
    am_SourceClass_s sourceClass;
    am_ClassProperty_s classProperty;
    am_sourceClass_t sourceClassID;
    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
    classProperty.value = 1;
    classPropertyList.push_back(classProperty);
    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
    classProperty.value = 4;
    classPropertyList.push_back(classProperty);
    sourceClass.name = "test";
    sourceClass.sourceClassID = 3;
    sourceClass.listClassProperties = classPropertyList;


    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, 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.getListSourceClasses(sourceClassList));
    ASSERT_TRUE(sourceClassList.empty());
}

TEST_F(CAmMapHandlerTest,updateSourceClass)
{
    std::vector<am_SourceClass_s> sourceClassList;
    std::vector<am_ClassProperty_s> classPropertyList, changedPropertyList;
    am_SourceClass_s sourceClass, changedClass;
    am_ClassProperty_s classProperty;
    am_sourceClass_t sourceClassID;
    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
    classProperty.value = 1;
    classPropertyList.push_back(classProperty);
    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
    classProperty.value = 4;
    classPropertyList.push_back(classProperty);
    sourceClass.name = "test";
    sourceClass.sourceClassID = 0;
    sourceClass.listClassProperties = classPropertyList;
    changedClass = sourceClass;
    changedClass.listClassProperties[1].value = 6;
    changedPropertyList = changedClass.listClassProperties;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
    changedClass.sourceClassID = sourceClassID;
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
    ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
    ASSERT_EQ(sourceClassList[0].sourceClassID, DYNAMIC_ID_BOUNDARY);
    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
    ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceClassInfoDB(changedClass));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
    ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
    ASSERT_EQ(sourceClassList[0].sourceClassID, DYNAMIC_ID_BOUNDARY);
    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),changedPropertyList.begin(),equalClassProperties));
}

TEST_F(CAmMapHandlerTest,enterSourceClass)
{
    std::vector<am_SourceClass_s> sourceClassList;
    std::vector<am_ClassProperty_s> classPropertyList;
    am_SourceClass_s sourceClass;
    am_ClassProperty_s classProperty;
    am_sourceClass_t sourceClassID;
    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
    classProperty.value = 1;
    classPropertyList.push_back(classProperty);
    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
    classProperty.value = 4;
    classPropertyList.push_back(classProperty);
    sourceClass.name = "test";
    sourceClass.sourceClassID = 0;
    sourceClass.listClassProperties = classPropertyList;


    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, DYNAMIC_ID_BOUNDARY);
    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
}

TEST_F(CAmMapHandlerTest,enterSourceClassStatic)
{
    std::vector<am_SourceClass_s> sourceClassList;
    std::vector<am_ClassProperty_s> classPropertyList;
    am_SourceClass_s sourceClass;
    am_ClassProperty_s classProperty;
    am_sourceClass_t sourceClassID;
    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
    classProperty.value = 1;
    classPropertyList.push_back(classProperty);
    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
    classProperty.value = 4;
    classPropertyList.push_back(classProperty);
    sourceClass.name = "test";
    sourceClass.sourceClassID = 3;
    sourceClass.listClassProperties = classPropertyList;


    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, 3);
    ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
}

TEST_F(CAmMapHandlerTest,removeSinkClass)
{
    std::vector<am_SinkClass_s> sinkClassList;
    std::vector<am_ClassProperty_s> classPropertyList;
    am_SinkClass_s sinkClass;
    am_ClassProperty_s classProperty;
    am_sinkClass_t sinkClassID;
    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
    classProperty.value = 1;
    classPropertyList.push_back(classProperty);
    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
    classProperty.value = 4;
    classPropertyList.push_back(classProperty);
    sinkClass.name = "test";
    sinkClass.sinkClassID = 0;
    sinkClass.listClassProperties = classPropertyList;


    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, 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.getListSinkClasses(sinkClassList));
    ASSERT_TRUE(sinkClassList.empty());
}

TEST_F(CAmMapHandlerTest,updateSinkClass)
{
    std::vector<am_SinkClass_s> sinkClassList;
    std::vector<am_ClassProperty_s> classPropertyList, changedPropertyList;
    am_SinkClass_s sinkClass, changedClass;
    am_ClassProperty_s classProperty;
    am_sinkClass_t sinkClassID;
    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
    classProperty.value = 1;
    classPropertyList.push_back(classProperty);
    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
    classProperty.value = 4;
    classPropertyList.push_back(classProperty);
    sinkClass.name = "test";
    sinkClass.sinkClassID = 0;
    sinkClass.listClassProperties = classPropertyList;
    changedClass = sinkClass;
    changedClass.listClassProperties[1].value = 6;
    changedPropertyList = changedClass.listClassProperties;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
    changedClass.sinkClassID = sinkClassID;
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
    ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
    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.changeSinkClassInfoDB(changedClass));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
    ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
    ASSERT_EQ(sinkClassList[0].sinkClassID, DYNAMIC_ID_BOUNDARY);
    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),changedPropertyList.begin(),equalClassProperties));
}

TEST_F(CAmMapHandlerTest,enterSinkClass)
{
    std::vector<am_SinkClass_s> sinkClassList;
    std::vector<am_ClassProperty_s> classPropertyList;
    am_SinkClass_s sinkClass;
    am_ClassProperty_s classProperty;
    am_sinkClass_t sinkClassID;
    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
    classProperty.value = 1;
    classPropertyList.push_back(classProperty);
    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
    classProperty.value = 4;
    classPropertyList.push_back(classProperty);
    sinkClass.name = "test";
    sinkClass.sinkClassID = 0;
    sinkClass.listClassProperties = classPropertyList;


    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, DYNAMIC_ID_BOUNDARY);
    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
}

TEST_F(CAmMapHandlerTest,enterSinkClassStatic)
{
    std::vector<am_SinkClass_s> sinkClassList;
    std::vector<am_ClassProperty_s> classPropertyList;
    am_SinkClass_s sinkClass;
    am_ClassProperty_s classProperty;
    am_sinkClass_t sinkClassID;
    classProperty.classProperty = CP_GENIVI_SINK_TYPE;
    classProperty.value = 1;
    classPropertyList.push_back(classProperty);
    classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
    classProperty.value = 4;
    classPropertyList.push_back(classProperty);
    sinkClass.name = "test";
    sinkClass.sinkClassID = 4;
    sinkClass.listClassProperties = classPropertyList;


    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);
    ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
}

TEST_F(CAmMapHandlerTest, changeSystemProperty)
{
    std::vector<am_SystemProperty_s> 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;
    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(CAmMapHandlerTest, systemProperties)
{
    std::vector<am_SystemProperty_s> listSystemProperties, listReturn;
    am_SystemProperty_s systemProperty;

    systemProperty.type = SYP_UNKNOWN;
    systemProperty.value = 33;
    listSystemProperties.push_back(systemProperty);

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSystemProperties(listSystemProperties));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSystemProperties(listReturn));
    ASSERT_EQ(listReturn[0].type, systemProperty.type);
    ASSERT_EQ(listReturn[0].value, systemProperty.value);
}

TEST_F(CAmMapHandlerTest,enterSourcesCorrect)
{
    //fill the connection database
    am_Source_s staticSource, firstDynamicSource, secondDynamicSource;
    am_sourceID_t staticSourceID, firstDynamicSourceID, secondDynamicSourceID;
    std::vector<am_Source_s> sourceList;

    pCF.createSource(staticSource);
    staticSource.sourceID = 4;
    staticSource.name = "Static";


    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
        << "ERROR: database error";
    ASSERT_EQ(staticSource.sourceID,staticSourceID)
        << "ERROR: ID not the one given in staticSource";

    pCF.createSource(firstDynamicSource);
    firstDynamicSource.name = "firstDynamicSource";

    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(firstDynamicSource,firstDynamicSourceID))
        << "ERROR: database error";
    ASSERT_EQ(firstDynamicSourceID,DYNAMIC_ID_BOUNDARY)
        << "ERROR: ID not the one given in firstDynamicSink";

    pCF.createSource(secondDynamicSource);
    secondDynamicSource.name = "secondDynamicSource";

    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(secondDynamicSource,secondDynamicSourceID))
        << "ERROR: database error";
    ASSERT_NEAR(secondDynamicSourceID,DYNAMIC_ID_BOUNDARY,10)
        << "ERROR: ID not the one given in secondDynamicSink";

    //now read back and check the returns agains the given values
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(sourceList))
        << "ERROR: database error";

    std::vector<am_Source_s>::iterator listIterator = sourceList.begin();
    for (; listIterator < sourceList.end(); ++listIterator)
    {
        if (listIterator->sourceID == staticSourceID)
        {
            ASSERT_TRUE(pCF.compareSource(listIterator, staticSource));
        }

        if (listIterator->sourceID == firstDynamicSourceID)
        {
            ASSERT_TRUE(pCF.compareSource(listIterator, firstDynamicSource));
        }

        if (listIterator->sourceID == secondDynamicSourceID)
        {
            ASSERT_TRUE(pCF.compareSource(listIterator, secondDynamicSource));
        }

    }
}

TEST_F(CAmMapHandlerTest, changeSinkMuteState)
{
    std::vector<am_Sink_s> listSinks;
    am_Sink_s sink;
    am_sinkID_t sinkID;
    pCF.createSink(sink);
    am_MuteState_e muteState = MS_MUTED;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));

    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMuteStateDB(muteState,sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
    ASSERT_EQ(muteState, listSinks[0].muteState);
}

TEST_F(CAmMapHandlerTest, changeSourceMainSoundProperty)
{
    std::vector<am_Source_s> listSources;
    am_Source_s source;
    am_sourceID_t sourceID;
    pCF.createSource(source);
    am_MainSoundProperty_s property;
    property.type = MSP_UNKNOWN;
    property.value = 33;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));

    ASSERT_EQ(E_OK, pDatabaseHandler.changeMainSourceSoundPropertyDB(property,sourceID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));

    std::vector<am_MainSoundProperty_s>::iterator listIterator = listSources[0].listMainSoundProperties.begin();
    for (; listIterator < listSources[0].listMainSoundProperties.end(); ++listIterator)
    {
        if (listIterator->type == property.type)
            ASSERT_EQ(listIterator->value, property.value);
    }
    int16_t value;
    ASSERT_EQ(E_OK, pDatabaseHandler.getMainSourceSoundPropertyValue(sourceID, property.type, value));
    ASSERT_EQ(value, property.value);

    ASSERT_EQ(E_OK, pDatabaseHandler.changeMainSourceSoundPropertyDB({property.type, 34},sourceID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getMainSourceSoundPropertyValue(sourceID, property.type, value));
    ASSERT_EQ(value, 34);
    ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.getMainSourceSoundPropertyValue(sourceID, 1000, value));
}

TEST_F(CAmMapHandlerTest, changeSinkMainSoundProperty)
{
    std::vector<am_Sink_s> listSinks;
    am_Sink_s sink;
    am_sinkID_t sinkID;
    pCF.createSink(sink);
    am_MainSoundProperty_s property;
    property.type = MSP_UNKNOWN;
    property.value = 33;


    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));

    ASSERT_EQ(E_OK, pDatabaseHandler.changeMainSinkSoundPropertyDB(property,sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
    std::vector<am_MainSoundProperty_s>::iterator listIterator = listSinks[0].listMainSoundProperties.begin();
    for (; listIterator < listSinks[0].listMainSoundProperties.end(); ++listIterator)
    {
        if (listIterator->type == property.type)
            ASSERT_EQ(listIterator->value, property.value);
    }

    int16_t value;
    ASSERT_EQ(E_OK, pDatabaseHandler.getMainSinkSoundPropertyValue(sinkID, property.type, value));
    ASSERT_EQ(value, property.value);

    ASSERT_EQ(E_OK, pDatabaseHandler.changeMainSinkSoundPropertyDB({property.type, 34},sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getMainSinkSoundPropertyValue(sinkID, property.type, value));
    ASSERT_EQ(value, 34);
    ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.getMainSinkSoundPropertyValue(sinkID, 1000, value));
}

TEST_F(CAmMapHandlerTest, changeSourceSoundProperty)
{
    std::vector<am_Source_s> listSources;
    am_Source_s source;
    am_sourceID_t sourceID;
    pCF.createSource(source);
    am_SoundProperty_s property;
    property.type = SP_GENIVI_MID;
    property.value = 33;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));

    ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceSoundPropertyDB(property,sourceID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));

    std::vector<am_SoundProperty_s>::iterator listIterator = listSources[0].listSoundProperties.begin();
    for (; listIterator < listSources[0].listSoundProperties.end(); ++listIterator)
    {
        if (listIterator->type == property.type)
            ASSERT_EQ(listIterator->value, property.value);
    }
    int16_t value;
    ASSERT_EQ(E_OK, pDatabaseHandler.getSourceSoundPropertyValue(sourceID, property.type, value));
    ASSERT_EQ(value, property.value);

    ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceSoundPropertyDB({property.type, 34},sourceID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getSourceSoundPropertyValue(sourceID, property.type, value));
    ASSERT_EQ(value, 34);
    ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.getSourceSoundPropertyValue(sourceID, 1000, value));
}

TEST_F(CAmMapHandlerTest, changeSinkSoundProperty)
{
    std::vector<am_Sink_s> listSinks;
    am_Sink_s sink;
    am_sinkID_t sinkID;
    pCF.createSink(sink);
    am_SoundProperty_s property;
    property.type = SP_GENIVI_MID;
    property.value = 33;


    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));

    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkSoundPropertyDB(property,sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
    std::vector<am_SoundProperty_s>::iterator listIterator = listSinks[0].listSoundProperties.begin();
    for (; listIterator < listSinks[0].listSoundProperties.end(); ++listIterator)
    {
        if (listIterator->type == property.type)
            ASSERT_EQ(listIterator->value, property.value);
    }

    int16_t value;
    ASSERT_EQ(E_OK, pDatabaseHandler.getSinkSoundPropertyValue(sinkID, property.type, value));
    ASSERT_EQ(value, property.value);

    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkSoundPropertyDB({property.type, 34},sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getSinkSoundPropertyValue(sinkID, property.type, value));
    ASSERT_EQ(value, 34);
    ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.getSinkSoundPropertyValue(sinkID, 1000, value));
}

TEST_F(CAmMapHandlerTest, peekDomain)
{
    std::vector<am_Domain_s> 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, DYNAMIC_ID_BOUNDARY);
    domain.name = "newdomain";
    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
    ASSERT_EQ(domainID, domain2ID);
    ASSERT_TRUE(listDomains[0].domainID==domainID);
}

TEST_F(CAmMapHandlerTest, peekDomainFirstEntered)
{
    std::vector<am_Domain_s> listDomains;
    am_Domain_s domain;
    am_domainID_t domainID;
    am_domainID_t domain2ID;
    pCF.createDomain(domain);
    domain.name = "newdomain";
    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
    ASSERT_EQ(E_OK, pDatabaseHandler.peekDomain(std::string("newdomain"),domain2ID));
    ASSERT_EQ(domainID, domain2ID);
    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
    ASSERT_TRUE(listDomains.size()==1);
}

TEST_F(CAmMapHandlerTest, changeDomainState)
{
    std::vector<am_Domain_s> listDomains;
    am_Domain_s domain;
    am_domainID_t domainID;
    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.getListDomains(listDomains));
    ASSERT_EQ(newState, listDomains[0].state);
}

TEST_F(CAmMapHandlerTest, changeMainConnectionState)
{
    am_mainConnectionID_t mainConnectionID;
    am_MainConnection_s mainConnection;
    std::vector<am_MainConnection_s> listMainConnections;
    createMainConnectionSetup(mainConnectionID, mainConnection);

    ASSERT_EQ(E_OK, pDatabaseHandler.changeMainConnectionStateDB(1,CS_DISCONNECTING));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(listMainConnections));
    ASSERT_EQ(CS_DISCONNECTING, listMainConnections[0].connectionState);
}

TEST_F(CAmMapHandlerTest, changeSinkAvailability)
{
    std::vector<am_Sink_s> 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;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
    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(CAmMapHandlerTest, changeSourceAvailability)
{
    std::vector<am_Source_s> 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;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
    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(CAmMapHandlerTest,changeMainConnectionRoute)
{
    am_mainConnectionID_t mainConnectionID;
    am_MainConnection_s mainConnection;
    std::vector<am_MainConnection_s> originalList;
    std::vector<am_MainConnection_s> newList;
    createMainConnectionSetup(mainConnectionID, mainConnection);

    //fill the connection database
    am_Connection_s connection;
    am_Source_s source;
    am_Sink_s sink;
    std::vector<am_connectionID_t> listConnectionID;

    uint16_t i = 1;
    for (; i < 10; i++)
    {
        am_sinkID_t forgetSink;
        am_sourceID_t forgetSource;
        am_connectionID_t connectionID;

        connection.sinkID = i + 20;
        connection.sourceID = i + 20;
        connection.delay = -1;
        connection.connectionFormat = CF_GENIVI_ANALOG;
        connection.connectionID = 0;

        pCF.createSink(sink);
        sink.sinkID = i + 20;
        sink.name = "sink" + int2string(i + 20);
        sink.domainID = 4;
        pCF.createSource(source);
        source.sourceID = i + 20;
        source.name = "source" + int2string(i + 30);
        source.domainID = 4;

        ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,forgetSink));
        ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,forgetSource));
        ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
        listConnectionID.push_back(connectionID);
    }

    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(originalList));
    ASSERT_EQ(E_OK, pDatabaseHandler.changeMainConnectionRouteDB(mainConnectionID,listConnectionID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(newList));
    ASSERT_FALSE(std::equal(newList[0].listConnectionID.begin(),newList[0].listConnectionID.end(),originalList[0].listConnectionID.begin()));
}

TEST_F(CAmMapHandlerTest,changeMainSinkVolume)
{
    am_Sink_s sink;
    am_sinkID_t sinkID;
    am_mainVolume_t newVol = 20;
    std::vector<am_Sink_s> listSinks;
    pCF.createSink(sink);

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMainVolumeDB(newVol,sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
    ASSERT_EQ(listSinks[0].mainVolume, newVol);
}

TEST_F(CAmMapHandlerTest,getMainSourceSoundProperties)
{
    am_Source_s source;
    am_sourceID_t sourceID;
    pCF.createSource(source);
    std::vector<am_MainSoundProperty_s> mainSoundProperties = source.listMainSoundProperties;
    std::vector<am_MainSoundProperty_s> listMainSoundProperties;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSourceSoundProperties(sourceID,listMainSoundProperties));
    ASSERT_TRUE(std::equal(mainSoundProperties.begin(),mainSoundProperties.end(),listMainSoundProperties.begin(),equalMainSoundProperty));
}

TEST_F(CAmMapHandlerTest,getMainSinkSoundProperties)
{
    am_Sink_s sink;
    am_sinkID_t sinkID;
    pCF.createSink(sink);
    std::vector<am_MainSoundProperty_s> mainSoundProperties = sink.listMainSoundProperties;
    std::vector<am_MainSoundProperty_s> listMainSoundProperties;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSinkSoundProperties(sinkID,listMainSoundProperties));
    ASSERT_TRUE(std::equal(mainSoundProperties.begin(),mainSoundProperties.end(),listMainSoundProperties.begin(),equalMainSoundProperty));
}

TEST_F(CAmMapHandlerTest,getMainSources)
{
    am_Source_s source, source1, source2;
    am_sourceID_t sourceID;
    pCF.createSource(source);
    pCF.createSource(source1);
    pCF.createSource(source2);
    source1.name = "source1";
    source2.name = "source2";
    bool equal = true;
    source1.visible = false;
    std::vector<am_SourceType_s> listMainSources;
    std::vector<am_Source_s> listSources;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
    source.sourceID = sourceID;
    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source1,sourceID));
    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source2,sourceID));
    source2.sourceID = sourceID;
    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSources(listMainSources));
    listSources.push_back(source);
    listSources.push_back(source2);
    std::vector<am_SourceType_s>::iterator listIterator = listMainSources.begin();
    for (; listIterator < listMainSources.end(); ++listIterator)
    {
        equal = equal && pCF.compareSinkMainSource(listIterator, listSources);
    }
    ASSERT_TRUE(equal);
}

TEST_F(CAmMapHandlerTest,getMainSinks)
{
	am_Sink_s sink, sink1, sink2;
    am_sinkID_t sinkID;
    pCF.createSink(sink);
    pCF.createSink(sink1);
    pCF.createSink(sink2);
    sink1.name = "sink1";
    sink2.name = "sink2";
    sink1.visible = false;
    std::vector<am_SinkType_s> listMainSinks;
    std::vector<am_Sink_s> listSinks;

    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
    sink.sinkID = sinkID;
    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink1,sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink2,sinkID));
    sink2.sinkID = sinkID;
    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSinks(listMainSinks));
    listSinks.push_back(sink);
    listSinks.push_back(sink2);

    std::vector<am_SinkType_s>::iterator listIterator = listMainSinks.begin();
    for (; listIterator < listMainSinks.end(); ++listIterator)
    {
        ASSERT_TRUE(pCF.compareSinkMainSink(listIterator, listSinks));
    }
}

TEST_F(CAmMapHandlerTest,getVisibleMainConnections)
{
    am_mainConnectionID_t mainConnectionID;
    am_MainConnection_s mainConnection;
    createMainConnectionSetup(mainConnectionID, mainConnection);

    std::vector<am_MainConnectionType_s> listVisibleMainConnections;
    std::vector<am_MainConnection_s> listMainConnections;
    ASSERT_EQ(E_OK, pDatabaseHandler.getListVisibleMainConnections(listVisibleMainConnections));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(listMainConnections));
    ASSERT_EQ(listMainConnections[0].mainConnectionID, listVisibleMainConnections[0].mainConnectionID);
    ASSERT_EQ(listMainConnections[0].connectionState, listVisibleMainConnections[0].connectionState);
    ASSERT_EQ(listMainConnections[0].delay, listVisibleMainConnections[0].delay);
    ASSERT_EQ(listMainConnections[0].sinkID, listVisibleMainConnections[0].sinkID);
    ASSERT_EQ(listMainConnections[0].sourceID, listVisibleMainConnections[0].sourceID);
}

TEST_F(CAmMapHandlerTest,getListSourcesOfDomain)
{
    am_Source_s source, source2;
    am_Domain_s domain;
    am_domainID_t domainID;
    am_sourceID_t sourceID;
    std::vector<am_sourceID_t> sourceList, sourceCheckList;
    pCF.createSource(source);
    source.sourceID = 1;
    source.name = "testSource";
    source.domainID = DYNAMIC_ID_BOUNDARY;
    pCF.createSource(source2);
    source2.sourceID = 0;
    source2.name = "testSource2";
    source2.domainID = 5;
    pCF.createDomain(domain);
    sourceCheckList.push_back(1); //sink.sinkID);

    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source2,sourceID))
        << "ERROR: database error";
    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListSourcesOfDomain(2,sourceList))
        << "ERROR: database error";ASSERT_TRUE(sourceList.empty());
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSourcesOfDomain(DYNAMIC_ID_BOUNDARY,sourceList))
        << "ERROR: database error";
    ASSERT_TRUE(std::equal(sourceList.begin(),sourceList.end(),sourceCheckList.begin()) && !sourceList.empty());
}

TEST_F(CAmMapHandlerTest,getListSinksOfDomain)
{
    am_Sink_s sink, sink2;
    am_Domain_s domain;
    am_domainID_t domainID;
    am_sinkID_t sinkID;
    std::vector<am_sinkID_t> sinkList, sinkCheckList;
    pCF.createSink(sink);
    sink.sinkID = 1;
    sink.domainID = DYNAMIC_ID_BOUNDARY;
    pCF.createSink(sink2);
    sink2.domainID = 5;
    sink2.name = "sink2";
    pCF.createDomain(domain);
    sinkCheckList.push_back(1); //sink.sinkID);

    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink2,sinkID))
        << "ERROR: database error";
    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListSinksOfDomain(DYNAMIC_ID_BOUNDARY+1,sinkList))
        << "ERROR: database error";ASSERT_TRUE(sinkList.empty());
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinksOfDomain(DYNAMIC_ID_BOUNDARY,sinkList))
        << "ERROR: database error";
    ASSERT_TRUE(std::equal(sinkList.begin(),sinkList.end(),sinkCheckList.begin()) && !sinkList.empty());
}

TEST_F(CAmMapHandlerTest,getListGatewaysOfDomain)
{
    am_Gateway_s gateway, gateway2;
    am_gatewayID_t gatewayID1, gatewayID2;
    am_domainID_t domainID;
    am_Domain_s domain;
    std::vector<am_gatewayID_t> gatewayList, gatewayCheckList;

    pCF.createDomain(domain);
    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));

    pCF.createGateway(gateway);
    gateway.gatewayID = 1;
    gateway.name = "testGateway";
    gateway.controlDomainID = domainID;
    gateway.sourceID = 1;
    gateway.sinkID = 1;
    gateway.domainSinkID = 1;
    gateway.domainSourceID = 1;
    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID1))
        << "ERROR: database error";
    ASSERT_EQ(true, gatewayID1==1);

    pCF.createGateway(gateway2);
    gateway2.gatewayID = 2;
    gateway2.name = "testGateway2";
    gateway2.controlDomainID = 4;
    gateway2.sourceID = 1;
    gateway2.sinkID = 1;
    gateway2.domainSinkID = 1;
    gateway2.domainSourceID = 1;
    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";
    ASSERT_TRUE(gatewayList.empty());
    ASSERT_EQ(E_OK,pDatabaseHandler.getListGatewaysOfDomain(domainID,gatewayList))
        << "ERROR: database error";
    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;
    am_domainID_t domainID;
    std::vector<am_Domain_s> listDomains;
    pCF.createDomain(domain);
    ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.removeDomainDB(domainID))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.getListDomains(listDomains))
        << "ERROR: database error";
    ASSERT_TRUE(listDomains.empty());
}

TEST_F(CAmMapHandlerTest,removeGateway)
{
    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))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.getListGateways(listGateways))
        << "ERROR: database error";
    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;
    am_sinkID_t sinkID;
    std::vector<am_Sink_s> listSinks;
    pCF.createSink(sink);

    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.removeSinkDB(sinkID))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
        << "ERROR: database error";
    ASSERT_TRUE(listSinks.empty());
}

TEST_F(CAmMapHandlerTest,removeSource)
{
    //fill the connection database
    am_Source_s source;
    am_sourceID_t sourceID;
    std::vector<am_Source_s> listSources;
    pCF.createSource(source);

    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.removeSourceDB(sourceID))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(listSources))
        << "ERROR: database error";
    ASSERT_TRUE(listSources.empty());
}

TEST_F(CAmMapHandlerTest, removeMainConnection)
{
    am_mainConnectionID_t mainConnectionID;
    am_MainConnection_s mainConnection;
    createMainConnectionSetup(mainConnectionID, mainConnection);

    ASSERT_EQ(E_OK,pDatabaseHandler.removeMainConnectionDB(mainConnectionID))
        << "ERROR: database error";
}

TEST_F(CAmMapHandlerTest,removeNonexistentMainConnectionFail)
{
    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeMainConnectionDB(34))
        << "ERROR: database error";
}

TEST_F(CAmMapHandlerTest,removeNonexistentSource)
{
    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeSourceDB(3))
        << "ERROR: database error";
}

TEST_F(CAmMapHandlerTest,removeNonexistentSink)
{
    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeSinkDB(2))
        << "ERROR: database error";
}

TEST_F(CAmMapHandlerTest,removeNonexistentGateway)
{
    ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeGatewayDB(12))
        << "ERROR: database error";
}

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;
    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;
    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(DYNAMIC_ID_BOUNDARY,gatewayID)
        << "ERROR: domainID zero";

    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1))
        << "ERROR: database error";
    ASSERT_EQ(gateway1.gatewayID,gatewayID1)
        << "ERROR: domainID zero";

    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2))
        << "ERROR: database error";
    ASSERT_EQ(DYNAMIC_ID_BOUNDARY+1,gatewayID2)
        << "ERROR: domainID zero";

    //now check if we read out the correct values
    ASSERT_EQ(E_OK, pDatabaseHandler.getListGateways(returnList));
    std::vector<am_Gateway_s>::iterator listIterator = returnList.begin();

    for (; listIterator < returnList.end(); ++listIterator)
    {
        if (listIterator->gatewayID == gatewayID)
        {
            ASSERT_TRUE(pCF.compareGateway(listIterator, gateway));
        }

        if (listIterator->gatewayID == gatewayID1)
        {
            ASSERT_TRUE(pCF.compareGateway(listIterator, gateway1));
        }

        if (listIterator->gatewayID == gatewayID2)
        {
            ASSERT_TRUE(pCF.compareGateway(listIterator, gateway2));
        }
    }
}

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(DYNAMIC_ID_BOUNDARY,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(DYNAMIC_ID_BOUNDARY+1,gatewayID2)
        << "ERROR: domainID zero";

    //now check if we read out the correct values
    ASSERT_EQ(E_OK, pDatabaseHandler.getListConverters(returnList));
    std::vector<am_Converter_s>::iterator listIterator = returnList.begin();

    for (; listIterator < returnList.end(); ++listIterator)
    {
        if (listIterator->converterID == gatewayID)
        {
            ASSERT_TRUE(pCF.compareConverter(listIterator, gateway));
        }

        if (listIterator->converterID == gatewayID1)
        {
            ASSERT_TRUE(pCF.compareConverter(listIterator, gateway1));
        }

        if (listIterator->converterID == gatewayID2)
        {
            ASSERT_TRUE(pCF.compareConverter(listIterator, gateway2));
        }
    }
}

TEST_F(CAmMapHandlerTest,getGatewayInfo)
{


    //initialize gateway
    std::vector<am_Gateway_s> 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;
    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(DYNAMIC_ID_BOUNDARY,gatewayID)
        << "ERROR: domainID zero";

    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1))
        << "ERROR: database error";
    ASSERT_EQ(gateway1.gatewayID,gatewayID1)
        << "ERROR: domainID zero";

    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2))
        << "ERROR: database error";
    ASSERT_EQ(DYNAMIC_ID_BOUNDARY+1,gatewayID2)
        << "ERROR: domainID zero";

    //now check if we read out the correct values
    ASSERT_EQ(E_OK, pDatabaseHandler.getListGateways(returnList));
    std::vector<am_Gateway_s>::iterator listIterator = returnList.begin();

    for (; listIterator < returnList.end(); ++listIterator)
    {
        if (listIterator->gatewayID == gatewayID)
        {
            ASSERT_TRUE(pCF.compareGateway(listIterator, gateway));
        }

        if (listIterator->gatewayID == gatewayID1)
        {
            ASSERT_TRUE(pCF.compareGateway(listIterator, gateway1));
        }

        if (listIterator->gatewayID == gatewayID2)
        {
            ASSERT_TRUE(pCF.compareGateway(listIterator, gateway2));
        }
    }

    am_Gateway_s gatewayInfo;
    ASSERT_EQ(E_OK, pDatabaseHandler.getGatewayInfoDB(20,gatewayInfo));
    ASSERT_TRUE(pCF.compareGateway1(gateway1,gatewayInfo));

}

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(DYNAMIC_ID_BOUNDARY,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(DYNAMIC_ID_BOUNDARY+1,gatewayID2)
        << "ERROR: domainID zero";

    //now check if we read out the correct values
    ASSERT_EQ(E_OK, pDatabaseHandler.getListConverters(returnList));
    std::vector<am_Converter_s>::iterator listIterator = returnList.begin();

    for (; listIterator < returnList.end(); ++listIterator)
    {
        if (listIterator->converterID == gatewayID)
        {
            ASSERT_TRUE(pCF.compareConverter(listIterator, gateway));
        }

        if (listIterator->converterID == gatewayID1)
        {
            ASSERT_TRUE(pCF.compareConverter(listIterator, gateway1));
        }

        if (listIterator->converterID == gatewayID2)
        {
            ASSERT_TRUE(pCF.compareConverter(listIterator, gateway2));
        }
    }

    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
    am_Sink_s staticSink, SecondSink;
    am_sinkID_t staticSinkID, SecondSinkID;

    pCF.createSink(staticSink);
    staticSink.sinkID = 43;
    staticSink.name = "Static";


    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
        << "ERROR: database error";
    ASSERT_EQ(staticSink.sinkID,staticSinkID)
        << "ERROR: ID not the one given in staticSink";

    pCF.createSink(SecondSink);
    SecondSink.sinkID = 43;
    SecondSink.name = "SecondSink";

    ASSERT_EQ(E_ALREADY_EXISTS,pDatabaseHandler.enterSinkDB(SecondSink,SecondSinkID))
        << "ERROR: database error";
}

TEST_F(CAmMapHandlerTest,enterSourcesThatAlreadyExistFail)
{
    //fill the connection database
    am_Source_s staticSource, SecondSource;
    am_sourceID_t staticSourceID, SecondSourceID;
    pCF.createSource(staticSource);
    staticSource.sourceID = 4;


    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
        << "ERROR: database error";
    ASSERT_EQ(staticSource.sourceID,staticSourceID)
        << "ERROR: ID not the one given in staticSource";

    pCF.createSource(SecondSource);
    SecondSource.sourceID = 4;

    ASSERT_EQ(E_ALREADY_EXISTS,pDatabaseHandler.enterSourceDB(SecondSource,SecondSourceID))
        << "ERROR: database error";
}

TEST_F(CAmMapHandlerTest,registerDomainCorrect)
{
    //initialize domain
    std::vector<am_Domain_s> returnList;
    am_Domain_s domain;
    am_domainID_t domainID = 0;
    pCF.createDomain(domain);

    ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID))
        << "ERROR: database error";
    ASSERT_NE(0,domainID)
        << "ERROR: domainID zero";

    //now check if we read out the correct values
    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(returnList));
    bool equal = true;
    std::vector<am_Domain_s>::iterator listIterator = returnList.begin();
    for (; listIterator < returnList.end(); ++listIterator)
    {
        if (listIterator->domainID == domainID)
        {
            equal = equal && (listIterator->name.compare(domain.name) == 0) && (listIterator->busname.compare(domain.busname) == 0) && (listIterator->complete == domain.complete) && (listIterator->early == domain.early) && (listIterator->state == domain.state);
        }
    }
    ASSERT_EQ(true, equal);
}

TEST_F(CAmMapHandlerTest,registerDomainPredefined)
{
    //initialize domain
    std::vector<am_Domain_s> returnList;
    am_Domain_s domain;
    am_domainID_t domainID = 10;
    pCF.createDomain(domain);

    ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID))
        << "ERROR: database error";
    ASSERT_NE(10,domainID)
        << "ERROR: domainID not predefined one";

    //now check if we read out the correct values
    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(returnList));
    std::vector<am_Domain_s>::iterator listIterator = returnList.begin();
    for (; listIterator < returnList.end(); ++listIterator)
    {
        if (listIterator->domainID == domainID)
        {
            ASSERT_EQ(0, listIterator->name.compare(domain.name));
            ASSERT_EQ(0, listIterator->busname.compare(domain.busname));
            ASSERT_EQ(domain.complete, listIterator->complete);
            ASSERT_EQ(domain.early, listIterator->early);
            ASSERT_EQ(domain.state, listIterator->state);
        }
    }
}

TEST_F(CAmMapHandlerTest,registerConnectionCorrect)
{
    am_Connection_s connection;
    am_connectionID_t connectionID;
    std::vector<am_Connection_s> returnList;
    pCF.createConnection(connection);

    ASSERT_EQ(E_OK,pDatabaseHandler.enterConnectionDB(connection,connectionID))
        << "ERROR: database error";;
    ASSERT_NE(0,connectionID)
        << "ERROR: connectionID zero";

    //now check if we read out the correct values
    ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(returnList));
    std::vector<am_Connection_s>::iterator listIterator = returnList.begin();
    for (; listIterator < returnList.end(); ++listIterator)
    {
        if (listIterator->connectionID == connectionID)
        {
            ASSERT_EQ(connection.sourceID, listIterator->sourceID);
            ASSERT_EQ(connection.sinkID, listIterator->sinkID);
            ASSERT_EQ(connection.delay, listIterator->delay);
            ASSERT_EQ(connection.connectionFormat, listIterator->connectionFormat);
        }
    }
}

TEST_F(CAmMapHandlerTest,enterMainConnectionCorrect)
{
    am_mainConnectionID_t mainConnectionID;
    am_MainConnection_s mainConnection;
    createMainConnectionSetup(mainConnectionID, mainConnection);
}

TEST_F(CAmMapHandlerTest,enterSinksCorrect)
{
    //fill the connection database
    am_Sink_s staticSink, firstDynamicSink, secondDynamicSink;
    am_sinkID_t staticSinkID, firstDynamicSinkID, secondDynamicSinkID;
    std::vector<am_Sink_s> sinkList;

    pCF.createSink(staticSink);
    staticSink.sinkID = 4;


    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
        << "ERROR: database error";
    ASSERT_EQ(staticSink.sinkID,staticSinkID)
        << "ERROR: ID not the one given in staticSink";

    pCF.createSink(firstDynamicSink);
    firstDynamicSink.name = "firstdynamic";
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(firstDynamicSink,firstDynamicSinkID))
        << "ERROR: database error";
    ASSERT_EQ(firstDynamicSinkID,DYNAMIC_ID_BOUNDARY)
        << "ERROR: ID not the one given in firstDynamicSink";

    pCF.createSink(secondDynamicSink);
    secondDynamicSink.name = "seconddynamic";

    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(secondDynamicSink,secondDynamicSinkID))
        << "ERROR: database error";
    ASSERT_NEAR(secondDynamicSinkID,DYNAMIC_ID_BOUNDARY,10)
        << "ERROR: ID not the one given in secondDynamicSink";

    //now read back and check the returns agains the given values
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(sinkList))
        << "ERROR: database error";

    std::vector<am_Sink_s>::iterator listIterator = sinkList.begin();
    for (; listIterator < sinkList.end(); ++listIterator)
    {
        if (listIterator->sinkID == staticSinkID)
        {
            ASSERT_TRUE(pCF.compareSink(listIterator, staticSink));
        }

        if (listIterator->sinkID == firstDynamicSinkID)
        {
            ASSERT_TRUE(pCF.compareSink(listIterator, firstDynamicSink));
        }

        if (listIterator->sinkID == secondDynamicSinkID)
        {
            ASSERT_TRUE(pCF.compareSink(listIterator, secondDynamicSink));
        }
    }
}

TEST_F(CAmMapHandlerTest,enterNotificationConfigurationCorrect)
{
    am_Sink_s testSinkData, readoutData;
    pCF.createSink(testSinkData);
    testSinkData.sinkID = 4;
    am_sinkID_t sinkID;
    std::vector<am_Sink_s> listSinks;

    am_NotificationConfiguration_s notify;
    notify.type=NT_UNKNOWN;
    notify.status=NS_CHANGE;
    notify.parameter=25;
    testSinkData.listNotificationConfigurations.push_back(notify);

    //enter the sink in the database
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
        << "ERROR: database error";

    //read it again
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
        << "ERROR: database error";

    ASSERT_EQ(listSinks.begin()->listNotificationConfigurations[2].parameter,notify.parameter);
    ASSERT_EQ(listSinks.begin()->listNotificationConfigurations[2].status,notify.status);
    ASSERT_EQ(listSinks.begin()->listNotificationConfigurations[2].type,notify.type);

    ASSERT_EQ(E_OK,pDatabaseHandler.getSinkInfoDB(testSinkData.sinkID,readoutData))
            << "ERROR: database error";

    ASSERT_EQ(readoutData.listNotificationConfigurations[2].parameter,notify.parameter);
    ASSERT_EQ(readoutData.listNotificationConfigurations[2].status,notify.status);
    ASSERT_EQ(readoutData.listNotificationConfigurations[2].type,notify.type);

}

TEST_F(CAmMapHandlerTest,enterMainNotificationConfigurationCorrect)
{
    am_Sink_s testSinkData;
    pCF.createSink(testSinkData);
    testSinkData.sinkID = 4;
    am_sinkID_t sinkID;
    std::vector<am_Sink_s> listSinks;

    am_NotificationConfiguration_s notify;
    notify.type=NT_UNKNOWN;
    notify.status=NS_CHANGE;
    notify.parameter=25;

    testSinkData.listMainNotificationConfigurations.push_back(notify);

    //enter the sink in the database
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
        << "ERROR: database error";

    //read it again
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
        << "ERROR: database error";

    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].parameter,notify.parameter);
    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].status,notify.status);
    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].type,notify.type);
}

TEST_F(CAmMapHandlerTest,removeNotificationsSink)
{
    am_Sink_s testSinkData;
    pCF.createSink(testSinkData);
    testSinkData.sinkID = 4;
    am_sinkID_t sinkID;
    std::vector<am_Sink_s> listSinks;

    am_NotificationConfiguration_s notify;
    notify.type=NT_UNKNOWN;
    notify.status=NS_CHANGE;
    notify.parameter=25;

    testSinkData.listMainNotificationConfigurations.push_back(notify);

    //enter the sink in the database
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
        << "ERROR: database error";

    //read it again
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
        << "ERROR: database error";

    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].parameter,notify.parameter);
    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].status,notify.status);
    ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].type,notify.type);

    //now we remove the sink
    ASSERT_EQ(E_OK,pDatabaseHandler.removeSinkDB(sinkID));
}

TEST_F(CAmMapHandlerTest,removeNotificationsSource)
{
    am_Source_s testSourceData;
    pCF.createSource(testSourceData);
    testSourceData.sourceID = 4;
    am_sourceID_t sourceID;
    std::vector<am_Source_s> listSources;

    am_NotificationConfiguration_s notify;
    notify.type=NT_UNKNOWN;
    notify.status=NS_CHANGE;
    notify.parameter=25;

    testSourceData.listMainNotificationConfigurations.push_back(notify);

    //enter the sink in the database
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
        << "ERROR: database error";

    //read it again
    ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(listSources))
        << "ERROR: database error";

    ASSERT_EQ(listSources.begin()->listMainNotificationConfigurations[2].parameter,notify.parameter);
    ASSERT_EQ(listSources.begin()->listMainNotificationConfigurations[2].status,notify.status);
    ASSERT_EQ(listSources.begin()->listMainNotificationConfigurations[2].type,notify.type);

    //now we remove the sink
    ASSERT_EQ(E_OK,pDatabaseHandler.removeSourceDB(sourceID));
}

TEST_F(CAmMapHandlerTest,getMainNotificationsSink)
{
    am_Sink_s testSinkData;
    pCF.createSink(testSinkData);
    testSinkData.sinkID = 4;
    am_sinkID_t sinkID;
    std::vector<am_Sink_s> listSinks;
    std::vector<am_NotificationConfiguration_s>returnList;

    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_UNKNOWN;
    notify1.status=NS_PERIODIC;
    notify1.parameter=5;

    testSinkData.listMainNotificationConfigurations.push_back(notify1);

    //enter the sink in the database
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
        << "ERROR: database error";

    //read it again
    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSinkNotificationConfigurations(sinkID,returnList))
        << "ERROR: database error";

    std::equal(testSinkData.listMainNotificationConfigurations.begin(),testSinkData.listMainNotificationConfigurations.end(),returnList.begin(),equalNotificationConfiguration);

}

TEST_F(CAmMapHandlerTest,getMainNotificationsSources)
{
    am_Source_s testSourceData;
    pCF.createSource(testSourceData);
    testSourceData.sourceID = 4;
    am_sourceID_t sourceID;
    std::vector<am_Source_s> listSources;
    std::vector<am_NotificationConfiguration_s>returnList;

    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_UNKNOWN;
    notify1.status=NS_PERIODIC;
    notify1.parameter=5;

    testSourceData.listMainNotificationConfigurations.push_back(notify1);

    //enter the sink in the database
    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";

    std::equal(testSourceData.listMainNotificationConfigurations.begin(),testSourceData.listMainNotificationConfigurations.end(),returnList.begin(),equalNotificationConfiguration);

}

TEST_F(CAmMapHandlerTest,changeMainNotificationsSources)
{
    am_Source_s testSourceData;
    pCF.createSource(testSourceData);
    testSourceData.sourceID = 4;
    am_sourceID_t sourceID;
    std::vector<am_Source_s> listSources;
    std::vector<am_NotificationConfiguration_s>returnList,returnList1;

    //enter the sink in the database
    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";

    ASSERT_EQ(true, std::equal(testSourceData.listMainNotificationConfigurations.begin(),
    				 testSourceData.listMainNotificationConfigurations.end(),
    				 returnList.begin(),
    				 equalNotificationConfiguration));

    //change notification which is not available
    am_NotificationConfiguration_s notify;
    notify.type=NT_UNKNOWN;
    notify.status=NS_CHANGE;
    notify.parameter=10;
    ASSERT_EQ(E_NO_CHANGE,pDatabaseHandler.changeMainSourceNotificationConfigurationDB(sourceID,notify));
    //change a setting
    notify.type=NT_TEST_2;
    ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSourceNotificationConfigurationDB(sourceID,notify));

    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSourceNotificationConfigurations(sourceID,returnList1))
        << "ERROR: database error";

    ASSERT_EQ(returnList1[1].parameter,notify.parameter);
    ASSERT_EQ(returnList1[1].status,notify.status);
    ASSERT_EQ(returnList1[1].type,notify.type);

}

TEST_F(CAmMapHandlerTest,changeMainNotificationsSink)
{
    am_Sink_s testSinkData;
    pCF.createSink(testSinkData);
    testSinkData.sinkID = 4;
    am_sinkID_t sinkID;
    std::vector<am_Sink_s> listSinks;
    std::vector<am_NotificationConfiguration_s>returnList,returnList1;

    //enter the sink in the database
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
        << "ERROR: database error";

    //read it again
    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSinkNotificationConfigurations(sinkID,returnList))
        << "ERROR: database error";

    std::equal(testSinkData.listMainNotificationConfigurations.begin(),testSinkData.listMainNotificationConfigurations.end(),returnList.begin(),equalNotificationConfiguration);

    //change notification which is not available
    am_NotificationConfiguration_s notify;
    notify.type=NT_UNKNOWN;
    notify.status=NS_CHANGE;
    notify.parameter=27;
    ASSERT_EQ(E_NO_CHANGE,pDatabaseHandler.changeMainSinkNotificationConfigurationDB(sinkID,notify))
        << "ERROR: database error";
    //change a setting
    notify.type=NT_TEST_2;
    ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSinkNotificationConfigurationDB(sinkID,notify))
        << "ERROR: database error";

    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSinkNotificationConfigurations(sinkID,returnList1))
        << "ERROR: database error";

    ASSERT_EQ(returnList1[1].parameter,notify.parameter);
    ASSERT_EQ(returnList1[1].status,notify.status);
    ASSERT_EQ(returnList1[1].type,notify.type);
}

TEST_F(CAmMapHandlerTest, peekDomain_2)
{
    std::vector<am_Domain_s> 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, DYNAMIC_ID_BOUNDARY);

    domain.name = "anotherdomain";
    ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
    ASSERT_EQ(domain2ID, DYNAMIC_ID_BOUNDARY+1);

    domain.name = "newdomain";
    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
	bool containsDomainID = std::find_if(listDomains.begin(), listDomains.end(), [&](const am_Domain_s & ref) {
		return ref.domainID==domainID;
	})!=listDomains.end();
    ASSERT_TRUE(containsDomainID);
}

TEST_F(CAmMapHandlerTest, connectionIDBoundary)
{
	am_Sink_s sink;
	am_Source_s source;
	am_Connection_s connection;
	connection.delay = -1;
	connection.connectionFormat = CF_GENIVI_ANALOG;
	connection.connectionID = 0;
	am_sinkID_t forgetSink;
	am_sourceID_t forgetSource;
	am_connectionID_t connectionID;
	for (uint16_t i = 1; i < TEST_MAX_SINK_ID; i++)
	{
		pCF.createSink(sink);
		sink.sinkID = 0;
		sink.name = "sink" + int2string(i);
		sink.domainID = 4;
		pCF.createSource(source);
		source.sourceID = 0;
		source.name = "source" + int2string(i);
		source.domainID = 4;
		ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, forgetSink));
		ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source, forgetSource));
		connection.sinkID = forgetSink;
		connection.sourceID = forgetSource;
		if( i < TEST_MAX_CONNECTION_ID )
		{
			ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
			ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
			ASSERT_EQ(i, connectionID);
		}
	}
	std::vector<am_Connection_s> connectionList;
	ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(connectionList));
	ASSERT_EQ(TEST_MAX_CONNECTION_ID-1, static_cast<int>(connectionList.size()));
	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterConnectionDB(connection,connectionID));
	logInfo("here");
	ASSERT_EQ(0, connectionID);

	ASSERT_EQ(E_OK, pDatabaseHandler.removeConnection(10));
	ASSERT_EQ(E_OK, pDatabaseHandler.removeConnection(12));

	ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
	ASSERT_EQ(10, connectionID);
	connection.sinkID = 77;
	connection.sourceID = 77;
	ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
	ASSERT_EQ(12, connectionID);
	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterConnectionDB(connection,connectionID));
	ASSERT_EQ(0, connectionID);
}

TEST_F(CAmMapHandlerTest, mainConnectionIDBoundary)
{
	am_Sink_s sink;
	am_Source_s source;
	am_Connection_s connection;
	connection.delay = -1;
	connection.connectionFormat = CF_GENIVI_ANALOG;
	connection.connectionID = 0;
	am_sinkID_t forgetSink;
	am_sourceID_t forgetSource;
	am_connectionID_t connectionID;
	std::vector<am_connectionID_t> connectionIDList;
	for (uint16_t i = 1; i < TEST_MAX_SINK_ID; i++)
	{
		pCF.createSink(sink);
		sink.sinkID = 0;
		sink.name = "sink" + int2string(i);
		sink.domainID = 4;
		pCF.createSource(source);
		source.sourceID = 0;
		source.name = "source" + int2string(i);
		source.domainID = 4;
		ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, forgetSink));
		ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source, forgetSource));
		connection.sinkID = forgetSink;
		connection.sourceID = forgetSource;
		if( i < TEST_MAX_CONNECTION_ID )
		{
			ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
			ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
			ASSERT_EQ(i, connectionID);
			connectionIDList.push_back(i);
		}
	}
	std::vector<am_Connection_s> connectionList;
	ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(connectionList));
	ASSERT_EQ(TEST_MAX_CONNECTION_ID-1, static_cast<int>(connectionList.size()));

	//create a mainConnection

	am_MainConnection_s mainConnection;
	am_mainConnectionID_t mainConnectionID;
	mainConnection.listConnectionID = connectionIDList;
	mainConnection.mainConnectionID = 0;
	mainConnection.connectionState = CS_CONNECTED;
	mainConnection.delay = -1;

	for (uint16_t i = 1; i < TEST_MAX_MAINCONNECTION_ID; i++)
	{
		mainConnection.sinkID = DYNAMIC_ID_BOUNDARY + i;
		mainConnection.sourceID = DYNAMIC_ID_BOUNDARY + i;
		ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
		ASSERT_EQ(i, mainConnectionID);
	}
	ASSERT_EQ(E_OK, pDatabaseHandler.removeMainConnectionDB(10));
	ASSERT_EQ(E_OK, pDatabaseHandler.removeMainConnectionDB(12));
	ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
	ASSERT_EQ(10, mainConnectionID);
	mainConnection.sinkID = 77;
	mainConnection.sourceID = 77;
	ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
	ASSERT_EQ(12, mainConnectionID);
	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
	ASSERT_EQ(0, mainConnectionID);
}

TEST_F(CAmMapHandlerTest, increaseID)
{
	am_Sink_s sink;
	am_sinkID_t sinkID;
	for (uint16_t i = 0; i < TEST_MAX_SINK_ID; i++)
	{
		pCF.createSink(sink);
		sink.sinkID = 0;
		sink.name = "sink" + int2string(i);
		sink.domainID = 4;
		ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink, sinkID));
		ASSERT_EQ(DYNAMIC_ID_BOUNDARY+i, sinkID);
	}
	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterSinkDB(sink, sinkID));

	ASSERT_EQ(E_OK, pDatabaseHandler.removeSinkDB(DYNAMIC_ID_BOUNDARY+10));
	ASSERT_EQ(E_OK, pDatabaseHandler.removeSinkDB(DYNAMIC_ID_BOUNDARY+12));

	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterSinkDB(sink, sinkID));
	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterSinkDB(sink, sinkID));
	ASSERT_EQ(E_UNKNOWN, pDatabaseHandler.enterSinkDB(sink, sinkID));
}


CAmMapHandlerObserverCallbacksTest::CAmMapHandlerObserverCallbacksTest() :
				mMockObserver(&pCommandSender, &pRoutingSender, &pSocketHandler)
{
	pDatabaseHandler.registerObserver(&mMockObserver);
}

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<am_Domain_s> 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, DYNAMIC_ID_BOUNDARY);

    domain.name = "anotherdomain";
    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));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
    ASSERT_EQ(domain2ID, DYNAMIC_ID_BOUNDARY+1);
    EXPECT_TRUE(Mock::VerifyAndClearExpectations(MockDatabaseObserver::getMockObserverObject()));
    domain.name = "newdomain";
    const am_Domain_s expDomain2 = {DYNAMIC_ID_BOUNDARY, 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
	bool containsDomainID = std::find_if(listDomains.begin(), listDomains.end(), [&](const am_Domain_s & ref) {
		return ref.domainID==domainID;
	})!=listDomains.end();
    ASSERT_TRUE(containsDomainID);
    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<am_Source_s> 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, DYNAMIC_ID_BOUNDARY);

    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(Field(&am_Source_s::sourceID, DYNAMIC_ID_BOUNDARY+2))).Times(1);
    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source3ID));
    ASSERT_EQ(source3ID, DYNAMIC_ID_BOUNDARY+2);

    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, DYNAMIC_ID_BOUNDARY))).Times(1);
    ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source3ID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
    ASSERT_EQ(sourceID, source3ID);
    bool containsSourceID = std::find_if(listSources.begin(), listSources.end(), [&](const am_Source_s & ref) {
    		return ref.sourceID==sourceID;
    	})!=listSources.end();
    ASSERT_TRUE(containsSourceID);

    std::vector<am_SoundProperty_s> listSoundProperties;
    std::vector<am_CustomAvailabilityReason_t> listConnectionFormats;
    std::vector<am_MainSoundProperty_s> listMainSoundProperties;
#ifndef WITH_DATABASE_CHANGE_CHECK
    //check no change
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceUpdated(sourceID, _, _, _)).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.changeSourceDB(sourceID, source.sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties))<< "ERROR: database error";
#else
    //check no change
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceUpdated(sourceID, _, _, _)).Times(0);
    ASSERT_EQ(E_OK,pDatabaseHandler.changeSourceDB(sourceID, source.sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties))<< "ERROR: database error";
    //check change of class id
    source.sourceClassID++;
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceUpdated(sourceID, source.sourceClassID, _, _)).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.changeSourceDB(sourceID, source.sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties))<< "ERROR: database error";
    //check change of main sound properties
    am_MainSoundProperty_s mainSoundProperties;
    mainSoundProperties.type = MSP_GENIVI_TREBLE;
    mainSoundProperties.value = 0;
    listMainSoundProperties.push_back(mainSoundProperties);
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceUpdated(sourceID, _, _, _)).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.changeSourceDB(sourceID, source.sourceClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties))<< "ERROR: database error";
#endif
    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<am_Sink_s> 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, DYNAMIC_ID_BOUNDARY);

    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(Field(&am_Sink_s::sinkID, DYNAMIC_ID_BOUNDARY+2))).Times(1);
    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sink3ID));
    ASSERT_EQ(sink3ID, DYNAMIC_ID_BOUNDARY+2);

    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, DYNAMIC_ID_BOUNDARY))).Times(1);
    ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sink3ID));
    ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
    ASSERT_EQ(sinkID, sink3ID);
    bool containsSourceID = std::find_if(listSinks.begin(), listSinks.end(), [&](const am_Sink_s & ref) {
			return ref.sinkID==sinkID;
	})!=listSinks.end();
	ASSERT_TRUE(containsSourceID);

    std::vector<am_SoundProperty_s> listSoundProperties;
    std::vector<am_CustomAvailabilityReason_t> listConnectionFormats;
    std::vector<am_MainSoundProperty_s> listMainSoundProperties;
#ifndef WITH_DATABASE_CHANGE_CHECK
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkUpdated(sinkID, _, _, _)).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.changeSinkDB(sinkID, sink.sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties))<< "ERROR: database error";
#else
    //check no change
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkUpdated(sinkID, _, _, _)).Times(0);
    ASSERT_EQ(E_OK,pDatabaseHandler.changeSinkDB(sinkID, sink.sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties))<< "ERROR: database error";
    //check change of class id
    sink.sinkClassID++;
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkUpdated(sinkID, sink.sinkClassID, _, _)).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.changeSinkDB(sinkID, sink.sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties))<< "ERROR: database error";
    //check change of main sound properties
    am_MainSoundProperty_s mainSoundProperties;
    mainSoundProperties.type = MSP_GENIVI_TREBLE;
    mainSoundProperties.value = 0;
    listMainSoundProperties.push_back(mainSoundProperties);
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkUpdated(sinkID, _, _, _)).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.changeSinkDB(sinkID, sink.sinkClassID, listSoundProperties, listConnectionFormats, listMainSoundProperties))<< "ERROR: database error";
#endif
    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<am_Gateway_s> 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, DYNAMIC_ID_BOUNDARY))).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))<< "ERROR: database error";
    ASSERT_EQ(DYNAMIC_ID_BOUNDARY,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, DYNAMIC_ID_BOUNDARY+1))).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2))<< "ERROR: database error";
    ASSERT_EQ(DYNAMIC_ID_BOUNDARY+1,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_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, DYNAMIC_ID_BOUNDARY))).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway,gatewayID))<< "ERROR: database error";
    ASSERT_EQ(DYNAMIC_ID_BOUNDARY,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, DYNAMIC_ID_BOUNDARY+1))).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.enterConverterDB(gateway2,gatewayID2))<< "ERROR: database error";
    ASSERT_EQ(DYNAMIC_ID_BOUNDARY+1,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;
    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, DYNAMIC_ID_BOUNDARY))).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_update_removeMainConnection)
{
    am_mainConnectionID_t mainConnectionID;
    am_MainConnection_s mainConnection;
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(9);
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(9);
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newMainConnection(Field(&am_MainConnectionType_s::mainConnectionID, 1))).Times(1);
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(1, CS_CONNECTED)).Times(1);
#ifndef WITH_DATABASE_CHANGE_CHECK
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(1, _)).Times(1);
#else
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(1, _)).Times(0);
#endif
    createMainConnectionSetup(mainConnectionID, mainConnection);

    //change delay of first connection
    am_timeSync_t delay = 20;
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(mainConnectionID, 20)).Times(1);
    ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionTimingInformation(mainConnection.listConnectionID[0], delay));
#ifdef WITH_DATABASE_CHANGE_CHECK
    ASSERT_EQ(E_NO_CHANGE, pDatabaseHandler.changeConnectionTimingInformation(mainConnection.listConnectionID[0], delay));
#endif

    //change delay of route
    delay = 40;
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), timingInformationChanged(mainConnectionID, 40)).Times(1);
    ASSERT_EQ(E_OK, pDatabaseHandler.changeDelayMainConnection(delay, mainConnectionID));
#ifdef WITH_DATABASE_CHANGE_CHECK
    ASSERT_EQ(E_NO_CHANGE, pDatabaseHandler.changeDelayMainConnection(delay, mainConnectionID));
#endif

    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), removedMainConnection(1)).Times(1);
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), mainConnectionStateChanged(1, _)).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.removeMainConnectionDB(mainConnectionID)) << "ERROR: database error";
}

TEST_F(CAmMapHandlerObserverCallbacksTest, changeSinkAvailability)
{
    std::vector<am_Sink_s> 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);

#ifdef WITH_DATABASE_CHANGE_CHECK
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkAvailabilityChanged(_, _)).Times(1);
    ASSERT_EQ(E_NO_CHANGE, pDatabaseHandler.changeSinkAvailabilityDB(availability,sinkID));
    availability.availability = A_AVAILABLE;
    availability.availabilityReason = AR_GENIVI_TEMPERATURE;
    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkAvailabilityDB(availability,sinkID));
#endif
}

TEST_F(CAmMapHandlerObserverCallbacksTest, changeSourceAvailability)
{
    std::vector<am_Source_s> 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);

#ifdef WITH_DATABASE_CHANGE_CHECK
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceAvailabilityChanged(_, _)).Times(1);
    ASSERT_EQ(E_NO_CHANGE, pDatabaseHandler.changeSourceAvailabilityDB(availability,sourceID));
    availability.availability = A_AVAILABLE;
    availability.availabilityReason = AR_GENIVI_TEMPERATURE;
    ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceAvailabilityDB(availability,sourceID));
#endif
}

TEST_F(CAmMapHandlerObserverCallbacksTest,changeMainSinkVolume)
{
    am_Sink_s sink;
    am_sinkID_t sinkID;
    am_mainVolume_t newVol = 20;
    std::vector<am_Sink_s> 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);

#ifdef WITH_DATABASE_CHANGE_CHECK
    am_mainVolume_t incVol = 21;
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), volumeChanged( sinkID, incVol)).Times(1);
    ASSERT_EQ(E_NO_CHANGE, pDatabaseHandler.changeSinkMainVolumeDB(newVol,sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMainVolumeDB(incVol,sinkID));
#endif
}

TEST_F(CAmMapHandlerObserverCallbacksTest, changeSinkMuteState)
{
    std::vector<am_Sink_s> 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);

#ifdef WITH_DATABASE_CHANGE_CHECK
    am_MuteState_e newMuteState = MS_UNMUTED;
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkMuteStateChanged(sinkID, newMuteState)).Times(1);
    ASSERT_EQ(E_NO_CHANGE, pDatabaseHandler.changeSinkMuteStateDB(muteState,sinkID));
    ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMuteStateDB(newMuteState,sinkID));
#endif
}

TEST_F(CAmMapHandlerObserverCallbacksTest, changeSystemProperty)
{
    std::vector<am_SystemProperty_s> 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);

#ifdef WITH_DATABASE_CHANGE_CHECK
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), systemPropertyChanged(_)).Times(1);
    ASSERT_EQ(E_NO_CHANGE, pDatabaseHandler.changeSystemPropertyDB(systemProperty));
    systemProperty.value = 33;
    ASSERT_EQ(E_OK, pDatabaseHandler.changeSystemPropertyDB(systemProperty));
#endif
}

TEST_F(CAmMapHandlerObserverCallbacksTest, changeMainNotificationsSink)
{
    am_Sink_s testSinkData;
    pCF.createSink(testSinkData);
    testSinkData.sinkID = 4;
    am_sinkID_t sinkID;
    std::vector<am_Sink_s> listSinks;
    std::vector<am_NotificationConfiguration_s>returnList;

    am_NotificationConfiguration_s notify;
    notify.type=NT_TEST_1;
    notify.status=NS_CHANGE;
    notify.parameter=25;

    testSinkData.listMainNotificationConfigurations.push_back(notify);

    am_NotificationConfiguration_s notify1;
    notify1.type=NT_TEST_1;
    notify1.status=NS_PERIODIC;
    notify1.parameter=5;

    testSinkData.listMainNotificationConfigurations.push_back(notify1);

    am_NotificationConfiguration_s notify2;
    notify2.type=NT_TEST_2;
    notify2.status=NS_CHANGE;
    notify2.parameter=27;

    testSinkData.listMainNotificationConfigurations.push_back(notify2);

    //enter the sink in the database
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSink(_)).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSinkNotificationConfigurations(sinkID, returnList))
        << "ERROR: database error";
    ASSERT_EQ(2, returnList.size()) << "ERROR: database error";

    //change a setting
    notify2.parameter++;
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sinkMainNotificationConfigurationChanged(sinkID, _)).Times(1);
#ifdef WITH_DATABASE_CHANGE_CHECK
    ASSERT_EQ(E_NO_CHANGE,pDatabaseHandler.changeMainSinkNotificationConfigurationDB(sinkID,notify1));
#endif
    ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSinkNotificationConfigurationDB(sinkID,notify2));
}

TEST_F(CAmMapHandlerObserverCallbacksTest, changeMainNotificationsSources)
{

    am_Source_s testSourceData;
    pCF.createSource(testSourceData);
    testSourceData.sourceID = 4;
    am_sourceID_t sourceID;
    std::vector<am_Source_s> listSources;
    std::vector<am_NotificationConfiguration_s>returnList;

    am_NotificationConfiguration_s notify;
    notify.type=NT_TEST_1;
    notify.status=NS_CHANGE;
    notify.parameter=25;

    testSourceData.listMainNotificationConfigurations.push_back(notify);

    am_NotificationConfiguration_s notify1;
    notify1.type=NT_TEST_1;
    notify1.status=NS_PERIODIC;
    notify1.parameter=5;

    testSourceData.listMainNotificationConfigurations.push_back(notify1);

    am_NotificationConfiguration_s notify2;
    notify2.type=NT_TEST_2;
    notify2.status=NS_CHANGE;
    notify2.parameter=10;

    testSourceData.listMainNotificationConfigurations.push_back(notify2);

    //enter the sink in the database
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), newSource(_)).Times(1);
    ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
        << "ERROR: database error";
    ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSourceNotificationConfigurations(sourceID,returnList))
        << "ERROR: database error";
    ASSERT_EQ(2, returnList.size()) << "ERROR: database error";

    //change a setting
    notify2.parameter++;
    EXPECT_CALL(*MockDatabaseObserver::getMockObserverObject(), sourceMainNotificationConfigurationChanged(sourceID, _)).Times(1);
#ifdef WITH_DATABASE_CHANGE_CHECK
    ASSERT_EQ(E_NO_CHANGE,pDatabaseHandler.changeMainSourceNotificationConfigurationDB(sourceID,notify1));
#endif
    ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSourceNotificationConfigurationDB(sourceID,notify2));
}

int main(int argc, char **argv)
{
	try
	{
		TCLAP::CmdLine* cmd(CAmCommandLineSingleton::instanciateOnce("The team of the AudioManager wishes you a nice day!",' ',DAEMONVERSION,true));
		cmd->add(enableNoDLTDebug);
	}
	catch (TCLAP::ArgException &e)  // catch any exceptions
	{ std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl; }
	CAmCommandLineSingleton::instance()->preparse(argc,argv);
	CAmDltWrapper::instance(enableNoDLTDebug.getValue())->registerApp("databse", "databasetest");
    logInfo("Database Test started ");
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}