AudioManagerDaemon/test/AmDatabaseHandlerTest/CAmDatabaseHandlerTest.cpp

   1 /**
   2  * Copyright (C) 2012, BMW AG
   3  *
   4  * This file is part of GENIVI Project AudioManager.
   5  *
   6  * Contributions are licensed to the GENIVI Alliance under one or more
   7  * Contribution License Agreements.
   8  *
   9  * \copyright
  10  * This Source Code Form is subject to the terms of the
  11  * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
  12  * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  13  *
  14  *
  15  * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
  16  *
  17  * For further information see http://www.genivi.org/.
  18  *
  19  */
  20
  21 #include "CAmDatabaseHandlerTest.h"
  22 #include <algorithm>
  23 #include <string>
  24 #include <vector>
  25 #include <set>
  26 #include "shared/CAmDltWrapper.h"
  27
  28 using namespace am;
  29 using namespace testing;
  30
  31 //extern int GetRandomNumber(int nLow, int nHigh);
  32 //extern bool equalSoundProperty (const am_SoundProperty_s a, const am_SoundProperty_s b);
  33 extern bool equalMainSoundProperty(const am_MainSoundProperty_s a, const am_MainSoundProperty_s b);
  34 extern bool equalNotificationConfiguration(const am_NotificationConfiguration_s a, const am_NotificationConfiguration_s b);
  35 //extern bool equalRoutingElement(const am_RoutingElement_s a, const am_RoutingElement_s b);
  36 extern bool equalClassProperties(const am_ClassProperty_s a, const am_ClassProperty_s b);
  37 extern std::string int2string(int i);
  38
  39 CAmDatabaseHandlerTest::CAmDatabaseHandlerTest() :
  40         plistRoutingPluginDirs(), //
  41         plistCommandPluginDirs(), //
  42         pSocketHandler(),//
  43         pDatabaseHandler(std::string(":memory:")), //
  44         pRoutingSender(plistRoutingPluginDirs), //
  45         pCommandSender(plistCommandPluginDirs), //
  46         pMockInterface(), //
  47         pRoutingInterfaceBackdoor(), //
  48         pCommandInterfaceBackdoor(), //
  49         pControlSender(), //
  50         pRouter(&pDatabaseHandler, &pControlSender), //
  51         pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender,  &pSocketHandler, &pRouter), //
  52         pObserver(&pCommandSender,&pRoutingSender, &pSocketHandler)
  53 {
  54     pDatabaseHandler.registerObserver(&pObserver);
  55     pCommandInterfaceBackdoor.injectInterface(&pCommandSender, &pMockInterface);
  56 }
  57
  58 CAmDatabaseHandlerTest::~CAmDatabaseHandlerTest()
  59 {
  60 }
  61
  62 void CAmDatabaseHandlerTest::createMainConnectionSetup()
  63 {
  64     //fill the connection database
  65     am_Connection_s connection;
  66     am_Source_s source;
  67     am_Sink_s sink;
  68     std::vector<am_connectionID_t> connectionList;
  69
  70     //we create 9 sources and sinks:
  71
  72
  73
  74     for (uint16_t i = 1; i < 10; i++)
  75     {
  76         am_sinkID_t forgetSink;
  77         am_sourceID_t forgetSource;
  78         am_connectionID_t connectionID;
  79
  80         pCF.createSink(sink);
  81         sink.sinkID = i;
  82         sink.name = "sink" + int2string(i);
  83         sink.domainID = 4;
  84         pCF.createSource(source);
  85         source.sourceID = i;
  86         source.name = "source" + int2string(i);
  87         source.domainID = 4;
  88
  89         connection.sinkID = i;
  90         connection.sourceID = i;
  91         connection.delay = -1;
  92         connection.connectionFormat = CF_GENIVI_ANALOG;
  93         connection.connectionID = 0;
  94
  95         ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,forgetSink));
  96         ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,forgetSource));
  97         ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
  98         ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
  99         connectionList.push_back(connectionID);
 100
 101     }
 102
 103     //create a mainConnection
 104     am_MainConnection_s mainConnection;
 105     am_mainConnectionID_t mainConnectionID;
 106     std::vector<am_MainConnection_s> mainConnectionList;
 107     mainConnection.listConnectionID = connectionList;
 108     mainConnection.mainConnectionID = 0;
 109     mainConnection.sinkID = 1;
 110     mainConnection.sourceID = 1;
 111     mainConnection.connectionState = CS_CONNECTED;
 112     mainConnection.delay = -1;
 113
 114     //enter mainconnection in database
 115
 116
 117     ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
 118     ASSERT_NE(0, mainConnectionID);
 119
 120     //read out the mainconnections and check if they are equal to the data written.
 121     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(mainConnectionList));
 122     bool equal = true;
 123     std::vector<am_MainConnection_s>::iterator listIterator = mainConnectionList.begin();
 124     for (; listIterator < mainConnectionList.end(); ++listIterator)
 125     {
 126         if (listIterator->mainConnectionID == mainConnectionID)
 127         {
 128             equal = equal && (listIterator->connectionState == mainConnection.connectionState) && (listIterator->sinkID == mainConnection.sinkID) && (listIterator->sourceID == mainConnection.sourceID) && (listIterator->delay == mainConnection.delay) && (std::equal(listIterator->listConnectionID.begin(), listIterator->listConnectionID.end(), connectionList.begin()));
 129         }
 130     }
 131     ASSERT_EQ(true, equal);
 132 }
 133
 134 void CAmDatabaseHandlerTest::SetUp()
 135 {
 136 }
 137
 138 void CAmDatabaseHandlerTest::TearDown()
 139 {
 140 }
 141
 142 TEST_F(CAmDatabaseHandlerTest,getMainConnectionInfo)
 143 {
 144     //fill the connection database
 145     am_Connection_s connection;
 146     am_Source_s source;
 147     am_Sink_s sink;
 148     std::vector<am_connectionID_t> connectionList;
 149
 150     //we create 9 sources and sinks:
 151
 152
 153
 154     for (uint16_t i = 1; i < 10; i++)
 155     {
 156         am_sinkID_t forgetSink;
 157         am_sourceID_t forgetSource;
 158         am_connectionID_t connectionID;
 159
 160         pCF.createSink(sink);
 161         sink.sinkID = i;
 162         sink.name = "sink" + int2string(i);
 163         sink.domainID = 4;
 164         pCF.createSource(source);
 165         source.sourceID = i;
 166         source.name = "source" + int2string(i);
 167         source.domainID = 4;
 168
 169         connection.sinkID = i;
 170         connection.sourceID = i;
 171         connection.delay = -1;
 172         connection.connectionFormat = CF_GENIVI_ANALOG;
 173         connection.connectionID = 0;
 174
 175         ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,forgetSink));
 176         ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,forgetSource));
 177         ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
 178         ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
 179         connectionList.push_back(connectionID);
 180
 181     }
 182
 183     //create a mainConnection
 184     am_MainConnection_s mainConnection;
 185     am_mainConnectionID_t mainConnectionID;
 186     std::vector<am_MainConnection_s> mainConnectionList;
 187     mainConnection.listConnectionID = connectionList;
 188     mainConnection.mainConnectionID = 0;
 189     mainConnection.sinkID = 1;
 190     mainConnection.sourceID = 1;
 191     mainConnection.connectionState = CS_CONNECTED;
 192     mainConnection.delay = -1;
 193
 194     //enter mainconnection in database
 195
 196
 197     ASSERT_EQ(E_OK, pDatabaseHandler.enterMainConnectionDB(mainConnection,mainConnectionID));
 198     ASSERT_NE(0, mainConnectionID);
 199
 200     //read out the mainconnections and check if they are equal to the data written.
 201     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(mainConnectionList));
 202     bool equal = true;
 203     std::vector<am_MainConnection_s>::iterator listIterator = mainConnectionList.begin();
 204     for (; listIterator < mainConnectionList.end(); ++listIterator)
 205     {
 206         if (listIterator->mainConnectionID == mainConnectionID)
 207         {
 208             equal = equal && (listIterator->connectionState == mainConnection.connectionState) && (listIterator->sinkID == mainConnection.sinkID) && (listIterator->sourceID == mainConnection.sourceID) && (listIterator->delay == mainConnection.delay) && (std::equal(listIterator->listConnectionID.begin(), listIterator->listConnectionID.end(), connectionList.begin()));
 209         }
 210     }ASSERT_EQ(true, equal);
 211
 212     am_MainConnection_s mainConnectionT;
 213     ASSERT_EQ(E_OK, pDatabaseHandler.getMainConnectionInfoDB(mainConnectionID,mainConnectionT));
 214     ASSERT_TRUE( (mainConnection.connectionState==mainConnectionT.connectionState) && (mainConnection.delay==mainConnectionT.delay) && (std::equal(mainConnection.listConnectionID.begin(),mainConnection.listConnectionID.end(),mainConnectionT.listConnectionID.begin())) && (mainConnection.sinkID==mainConnectionT.sinkID) && (mainConnection.sourceID==mainConnectionT.sourceID) && (mainConnectionID==mainConnectionT.mainConnectionID));
 215
 216 }
 217
 218 TEST_F(CAmDatabaseHandlerTest,getSinkInfo)
 219 {
 220     //fill the connection database
 221     am_Sink_s staticSink, firstDynamicSink, secondDynamicSink;
 222     am_sinkID_t staticSinkID, firstDynamicSinkID, secondDynamicSinkID;
 223     std::vector<am_Sink_s> sinkList;
 224
 225     pCF.createSink(staticSink);
 226     staticSink.sinkID = 4;
 227
 228
 229     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
 230         << "ERROR: database error";
 231     ASSERT_EQ(staticSink.sinkID,staticSinkID)
 232         << "ERROR: ID not the one given in staticSink";
 233
 234     pCF.createSink(firstDynamicSink);
 235     firstDynamicSink.name = "firstdynamic";
 236     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(firstDynamicSink,firstDynamicSinkID))
 237         << "ERROR: database error";
 238     ASSERT_EQ(firstDynamicSinkID,DYNAMIC_ID_BOUNDARY)
 239         << "ERROR: ID not the one given in firstDynamicSink";
 240
 241     pCF.createSink(secondDynamicSink);
 242     secondDynamicSink.name = "seconddynamic";
 243
 244     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(secondDynamicSink,secondDynamicSinkID))
 245         << "ERROR: database error";
 246     ASSERT_NEAR(secondDynamicSinkID,DYNAMIC_ID_BOUNDARY,10)
 247         << "ERROR: ID not the one given in secondDynamicSink";
 248
 249     //now read back and check the returns agains the given values
 250     ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(sinkList))
 251         << "ERROR: database error";
 252     bool equal = true;
 253
 254     std::vector<am_Sink_s>::iterator listIterator = sinkList.begin();
 255     for (; listIterator < sinkList.end(); ++listIterator)
 256     {
 257         if (listIterator->sinkID == staticSinkID)
 258         {
 259             equal = equal && pCF.compareSink(listIterator, staticSink);
 260         }
 261
 262         if (listIterator->sinkID == firstDynamicSinkID)
 263         {
 264             equal = equal && pCF.compareSink(listIterator, firstDynamicSink);
 265         }
 266
 267         if (listIterator->sinkID == secondDynamicSinkID)
 268         {
 269             equal = equal && pCF.compareSink(listIterator, secondDynamicSink);
 270         }
 271     }ASSERT_EQ(true, equal);
 272
 273     am_Sink_s sinkData;
 274     ASSERT_EQ(E_OK, pDatabaseHandler.getSinkInfoDB(secondDynamicSinkID,sinkData));
 275     ASSERT_TRUE( (secondDynamicSink.available.availability == sinkData.available.availability) && //
 276             (secondDynamicSink.available.availabilityReason == sinkData.available.availabilityReason) && //
 277             (secondDynamicSink.sinkClassID == sinkData.sinkClassID) && //
 278             (secondDynamicSink.domainID == sinkData.domainID) && //
 279             (secondDynamicSink.visible == sinkData.visible) && //
 280             (secondDynamicSink.name.compare(sinkData.name) == 0) && //
 281             (secondDynamicSink.volume == sinkData.volume) && //
 282             std::equal(secondDynamicSink.listConnectionFormats.begin(), secondDynamicSink.listConnectionFormats.end(), sinkData.listConnectionFormats.begin()) && //
 283             std::equal(secondDynamicSink.listMainSoundProperties.begin(), secondDynamicSink.listMainSoundProperties.end(), sinkData.listMainSoundProperties.begin(), equalMainSoundProperty) && //
 284             std::equal(secondDynamicSink.listNotificationConfigurations.begin(), secondDynamicSink.listNotificationConfigurations.end(), sinkData.listNotificationConfigurations.begin(), equalNotificationConfiguration) && //
 285             std::equal(secondDynamicSink.listMainNotificationConfigurations.begin(), secondDynamicSink.listMainNotificationConfigurations.end(), sinkData.listMainNotificationConfigurations.begin(), equalNotificationConfiguration) //
 286             );
 287
 288 }
 289
 290 TEST_F(CAmDatabaseHandlerTest,getSourceInfo)
 291 {
 292     //fill the connection database
 293     am_Source_s staticSource, firstDynamicSource, secondDynamicSource;
 294     am_sourceID_t staticSourceID, firstDynamicSourceID, secondDynamicSourceID;
 295     std::vector<am_Source_s> sourceList;
 296
 297     pCF.createSource(staticSource);
 298     staticSource.sourceID = 4;
 299     staticSource.name = "Static";
 300
 301
 302     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
 303         << "ERROR: database error";
 304     ASSERT_EQ(staticSource.sourceID,staticSourceID)
 305         << "ERROR: ID not the one given in staticSource";
 306
 307     pCF.createSource(firstDynamicSource);
 308     firstDynamicSource.name = "firstDynamicSource";
 309
 310     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(firstDynamicSource,firstDynamicSourceID))
 311         << "ERROR: database error";
 312     ASSERT_EQ(firstDynamicSourceID,DYNAMIC_ID_BOUNDARY)
 313         << "ERROR: ID not the one given in firstDynamicSink";
 314
 315     pCF.createSource(secondDynamicSource);
 316     secondDynamicSource.name = "secondDynamicSource";
 317
 318     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(secondDynamicSource,secondDynamicSourceID))
 319         << "ERROR: database error";
 320     ASSERT_NEAR(secondDynamicSourceID,DYNAMIC_ID_BOUNDARY,10)
 321         << "ERROR: ID not the one given in secondDynamicSink";
 322
 323     //now read back and check the returns agains the given values
 324     ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(sourceList))
 325         << "ERROR: database error";
 326     bool equal = true;
 327
 328     std::vector<am_Source_s>::iterator listIterator = sourceList.begin();
 329     for (; listIterator < sourceList.end(); ++listIterator)
 330     {
 331         if (listIterator->sourceID == staticSourceID)
 332         {
 333             equal = equal && pCF.compareSource(listIterator, staticSource);
 334         }
 335
 336         if (listIterator->sourceID == firstDynamicSourceID)
 337         {
 338             equal = equal && pCF.compareSource(listIterator, firstDynamicSource);
 339         }
 340
 341         if (listIterator->sourceID == secondDynamicSourceID)
 342         {
 343             equal = equal && pCF.compareSource(listIterator, secondDynamicSource);
 344         }
 345
 346     }ASSERT_EQ(true, equal);
 347
 348     am_Source_s sourceData;
 349     ASSERT_EQ(E_OK, pDatabaseHandler.getSourceInfoDB(secondDynamicSourceID,sourceData));
 350     ASSERT_TRUE((secondDynamicSource.available.availability == sourceData.available.availability) && //
 351             (secondDynamicSource.available.availabilityReason == sourceData.available.availabilityReason) && //
 352             (secondDynamicSource.sourceClassID == sourceData.sourceClassID) && (secondDynamicSource.domainID == sourceData.domainID) && //
 353             (secondDynamicSource.interruptState == sourceData.interruptState) && (secondDynamicSource.visible == sourceData.visible) && //
 354             (secondDynamicSource.name.compare(sourceData.name) == 0) && (secondDynamicSource.volume == sourceData.volume) && //
 355             std::equal(secondDynamicSource.listConnectionFormats.begin(), secondDynamicSource.listConnectionFormats.end(), sourceData.listConnectionFormats.begin()) && //
 356             std::equal(secondDynamicSource.listMainSoundProperties.begin(), secondDynamicSource.listMainSoundProperties.end(), sourceData.listMainSoundProperties.begin(), equalMainSoundProperty) && //
 357             std::equal(secondDynamicSource.listMainNotificationConfigurations.begin(), secondDynamicSource.listMainNotificationConfigurations.end(), sourceData.listMainNotificationConfigurations.begin(), equalNotificationConfiguration) && //
 358             std::equal(secondDynamicSource.listNotificationConfigurations.begin(), secondDynamicSource.listNotificationConfigurations.end(), sourceData.listNotificationConfigurations.begin(), equalNotificationConfiguration) //
 359     );
 360
 361 }
 362
 363 TEST_F(CAmDatabaseHandlerTest, peekSourceID)
 364 {
 365
 366     std::string sourceName("myClassID");
 367     am_sourceClass_t sourceClassID, peekID;
 368     am_SourceClass_s sourceClass;
 369     am_ClassProperty_s classProperty;
 370     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 371     classProperty.value = 13;
 372     sourceClass.name = sourceName;
 373     sourceClass.sourceClassID = 0;
 374     sourceClass.listClassProperties.push_back(classProperty);
 375
 376     //first we peek without an existing class
 377     ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.peekSourceClassID(sourceName,sourceClassID));
 378
 379     //now we enter the class into the database
 380     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
 381
 382     //first we peek without an existing class
 383     ASSERT_EQ(E_OK, pDatabaseHandler.peekSourceClassID(sourceName,peekID));
 384     ASSERT_EQ(sourceClassID, peekID);
 385 }
 386
 387 TEST_F(CAmDatabaseHandlerTest, peekSinkID)
 388 {
 389
 390     std::string sinkName("myClassID");
 391     am_sinkClass_t sinkClassID, peekID;
 392     am_SinkClass_s sinkClass;
 393     am_ClassProperty_s classProperty;
 394     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 395     classProperty.value = 13;
 396     sinkClass.name = sinkName;
 397     sinkClass.sinkClassID = 0;
 398     sinkClass.listClassProperties.push_back(classProperty);
 399
 400     //first we peek without an existing class
 401     ASSERT_EQ(E_NON_EXISTENT, pDatabaseHandler.peekSinkClassID(sinkName,sinkClassID));
 402
 403     //now we enter the class into the database
 404     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
 405
 406     //first we peek without an existing class
 407     ASSERT_EQ(E_OK, pDatabaseHandler.peekSinkClassID(sinkName,peekID));
 408     ASSERT_EQ(sinkClassID, peekID);
 409 }
 410
 411 TEST_F(CAmDatabaseHandlerTest,crossfaders)
 412 {
 413
 414
 415
 416     am_Crossfader_s crossfader;
 417     am_crossfaderID_t crossfaderID;
 418     am_Sink_s sinkA, sinkB;
 419     am_Source_s source;
 420     am_sourceID_t sourceID;
 421     am_sinkID_t sinkAID, sinkBID;
 422     pCF.createSink(sinkA);
 423     pCF.createSink(sinkB);
 424     sinkB.name = "sinkB";
 425     pCF.createSource(source);
 426
 427     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 428     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkA,sinkAID));
 429     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkB,sinkBID));
 430
 431     crossfader.crossfaderID = 0;
 432     crossfader.hotSink = HS_SINKA;
 433     crossfader.sinkID_A = sinkAID;
 434     crossfader.sinkID_B = sinkBID;
 435     crossfader.sourceID = sourceID;
 436     crossfader.name = "Crossfader";
 437     crossfader.hotSink = HS_UNKNOWN;
 438
 439     std::vector<am_Crossfader_s> listCrossfaders;
 440
 441     ASSERT_EQ(E_OK, pDatabaseHandler.enterCrossfaderDB(crossfader,crossfaderID));
 442     ASSERT_EQ(E_OK, pDatabaseHandler.getListCrossfaders(listCrossfaders));
 443     ASSERT_EQ(crossfader.sinkID_A, listCrossfaders[0].sinkID_A);
 444     ASSERT_EQ(crossfader.sinkID_B, listCrossfaders[0].sinkID_B);
 445     ASSERT_EQ(crossfader.sourceID, listCrossfaders[0].sourceID);
 446     ASSERT_EQ(crossfader.hotSink, listCrossfaders[0].hotSink);
 447     ASSERT_EQ(100, listCrossfaders[0].crossfaderID);
 448     ASSERT_EQ(crossfader.name.compare(listCrossfaders[0].name), 0);
 449 }
 450
 451 TEST_F(CAmDatabaseHandlerTest,crossfadersGetFromDomain)
 452 {
 453
 454
 455
 456     am_Crossfader_s crossfader;
 457     am_crossfaderID_t crossfaderID;
 458     am_Sink_s sinkA, sinkB;
 459     am_Source_s source;
 460     am_sourceID_t sourceID;
 461     am_sinkID_t sinkAID, sinkBID;
 462     am_domainID_t domainID;
 463     am_Domain_s domain;
 464     pCF.createSink(sinkA);
 465     pCF.createSink(sinkB);
 466     pCF.createDomain(domain);
 467     sinkB.name = "sinkB";
 468     pCF.createSource(source);
 469     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 470     source.domainID = domainID;
 471     sinkA.domainID = domainID;
 472     sinkB.domainID = domainID;
 473
 474     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 475     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkA,sinkAID));
 476     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sinkB,sinkBID));
 477
 478     crossfader.crossfaderID = 0;
 479     crossfader.hotSink = HS_SINKA;
 480     crossfader.sinkID_A = sinkAID;
 481     crossfader.sinkID_B = sinkBID;
 482     crossfader.sourceID = sourceID;
 483     crossfader.name = "Crossfader";
 484     crossfader.hotSink = HS_UNKNOWN;
 485
 486     std::vector<am_crossfaderID_t> listCrossfaders;
 487
 488     ASSERT_EQ(E_OK, pDatabaseHandler.enterCrossfaderDB(crossfader,crossfaderID));
 489     ASSERT_EQ(E_OK, pDatabaseHandler.getListCrossfadersOfDomain(source.domainID,listCrossfaders));
 490     ASSERT_EQ(100, listCrossfaders[0]);
 491
 492 }
 493
 494 TEST_F(CAmDatabaseHandlerTest,sourceState)
 495 {
 496     am_Source_s source;
 497     am_sourceID_t sourceID;
 498     std::vector<am_Source_s> listSources;
 499     pCF.createSource(source);
 500     source.sourceState = SS_OFF;
 501
 502     //prepare the test
 503
 504     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 505
 506     //change the source state
 507     ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceState(sourceID,SS_ON));
 508
 509     //read out the changed values
 510     ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
 511     ASSERT_EQ(listSources[0].sourceState, SS_ON);
 512 }
 513
 514 TEST_F(CAmDatabaseHandlerTest,sinkVolumeChange)
 515 {
 516     am_Sink_s sink;
 517     am_sinkID_t sinkID;
 518     std::vector<am_Sink_s> listSinks;
 519     pCF.createSink(sink);
 520     sink.volume = 23;
 521
 522     //prepare the test
 523
 524     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 525
 526     //change the volume and check the read out
 527     ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkVolume(sinkID,34));
 528     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
 529     ASSERT_EQ(listSinks[0].volume, 34);
 530 }
 531
 532 TEST_F(CAmDatabaseHandlerTest,sourceVolumeChange)
 533 {
 534     am_Source_s source;
 535     am_sourceID_t sourceID;
 536     std::vector<am_Source_s> listSources;
 537     pCF.createSource(source);
 538     source.volume = 23;
 539
 540     //prepare test
 541
 542     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 543
 544     //change the volume and check the read out
 545     ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceVolume(sourceID,34));
 546     ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
 547     ASSERT_EQ(listSources[0].volume, 34);
 548 }
 549
 550 TEST_F(CAmDatabaseHandlerTest, peekSource)
 551 {
 552     std::vector<am_Source_s> listSources;
 553     am_sourceID_t sourceID, source2ID, source3ID;
 554     am_Source_s source;
 555     pCF.createSource(source);
 556
 557     //peek a source that does not exits
 558
 559     ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(std::string("newsource"),sourceID));
 560
 561     //make sure it is not in the list
 562     ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
 563     ASSERT_TRUE(listSources.empty());
 564     ASSERT_EQ(sourceID, 100);
 565
 566     //now enter the source with the same name and make sure it does not get a new ID
 567     source.name = "newsource";
 568
 569     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source2ID));
 570     ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
 571     ASSERT_EQ(sourceID, source2ID);
 572     ASSERT_TRUE(listSources[0].sourceID==sourceID);
 573
 574     //now we peek again. This time, the source exists
 575     ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(source.name,source3ID));
 576     ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
 577     ASSERT_TRUE(listSources.size()==1);
 578     ASSERT_EQ(source3ID, source2ID);
 579 }
 580
 581 TEST_F(CAmDatabaseHandlerTest, peekSourceDouble)
 582 {
 583     std::vector<am_Source_s> listSources;
 584     am_sourceID_t sourceID;
 585     am_sourceID_t source2ID;
 586     am_sourceID_t source3ID;
 587     am_Source_s source;
 588     pCF.createSource(source);
 589
 590     //peek a source that does not exits
 591
 592     ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(std::string("newsource"),sourceID));
 593
 594     //peek a second source that does not exits
 595
 596     ASSERT_EQ(E_OK, pDatabaseHandler.peekSource(std::string("newsource2"),source2ID));
 597
 598     //make sure they are is not in the list
 599     ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
 600     ASSERT_TRUE(listSources.empty());
 601     ASSERT_EQ(sourceID, 100);
 602     source.name = "newsource";
 603
 604     //now enter the source with the same name than the first peek and make sure it does not get a new ID
 605
 606     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,source3ID));
 607     ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
 608     ASSERT_EQ(sourceID, source3ID);
 609     ASSERT_TRUE(listSources[0].sourceID==sourceID);
 610 }
 611
 612 TEST_F(CAmDatabaseHandlerTest, peekSink)
 613 {
 614     std::vector<am_Sink_s> listSinks;
 615     am_sinkID_t sinkID, sink2ID, sink3ID;
 616     am_Sink_s sink;
 617     pCF.createSink(sink);
 618
 619     //peek a sink that does not exits
 620
 621     ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(std::string("newsink"),sinkID));
 622
 623     //make sure it is not in the list
 624     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
 625     ASSERT_TRUE(listSinks.empty());
 626     ASSERT_EQ(sinkID, 100);
 627     sink.name = "newsink";
 628
 629     //now enter the source with the same name and make sure it does not get a new ID
 630
 631     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sink2ID));
 632     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
 633     ASSERT_EQ(sinkID, sink2ID);
 634     ASSERT_TRUE(listSinks[0].sinkID==sinkID);
 635
 636     //now we peek again, this time, the sink exists
 637     ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(sink.name,sink3ID));
 638     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
 639     ASSERT_TRUE(listSinks.size()==1);
 640     ASSERT_EQ(sink3ID, sink2ID);
 641 }
 642
 643 TEST_F(CAmDatabaseHandlerTest, peekSinkDouble)
 644 {
 645     std::vector<am_Sink_s> listSinks;
 646     am_sinkID_t sinkID;
 647     am_sinkID_t sink2ID;
 648     am_sinkID_t sink3ID;
 649     am_Sink_s sink;
 650     pCF.createSink(sink);
 651
 652     //peek a sink that does not exits
 653
 654     ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(std::string("newsink"),sinkID));
 655
 656     //peek again
 657
 658     ASSERT_EQ(E_OK, pDatabaseHandler.peekSink(std::string("nextsink"),sink2ID));
 659
 660     //make sure they are is not in the list
 661     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
 662     ASSERT_TRUE(listSinks.empty());
 663     ASSERT_EQ(sinkID, 100);
 664     sink.name = "newsink";
 665
 666     //now enter the sink with the same name than the first peek and make sure it does not get a new ID
 667
 668     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sink3ID));
 669     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
 670     ASSERT_EQ(sinkID, sink3ID);
 671     ASSERT_TRUE(listSinks[0].sinkID==sinkID);
 672 }
 673
 674 TEST_F(CAmDatabaseHandlerTest,changeConnectionTimingInformationCheckMainConnection)
 675 {
 676     std::vector<am_Connection_s> connectionList;
 677     std::vector<am_MainConnectionType_s> mainList;
 678
 679     //prepare the test, it is one mainconnection, so we expect one callback
 680     createMainConnectionSetup();
 681
 682     //first get all visible mainconnections and make sure, the delay is set to -1 for the first entry
 683     ASSERT_EQ(E_OK, pDatabaseHandler.getListVisibleMainConnections(mainList));
 684     ASSERT_EQ(mainList[0].delay, -1);
 685
 686     //no go through all connections and set the delay time to 24 for each connection
 687     ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(connectionList));
 688     std::vector<am_Connection_s>::iterator iteratorConnectionList = connectionList.begin();
 689     for (; iteratorConnectionList < connectionList.end(); ++iteratorConnectionList)
 690     {
 691         ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionTimingInformation(iteratorConnectionList->sinkID,24));
 692     }
 693
 694     //we read the result again and expect that the value is now different from -1
 695     ASSERT_EQ(E_OK, pDatabaseHandler.getListVisibleMainConnections(mainList));
 696     ASSERT_EQ(mainList[0].delay, 216);
 697 }
 698
 699 TEST_F(CAmDatabaseHandlerTest,changeConnectionTimingInformation)
 700 {
 701     am_Connection_s connection;
 702     am_connectionID_t connectionID;
 703     std::vector<am_Connection_s> connectionList;
 704     pCF.createConnection(connection);
 705
 706     //enter a connection
 707     ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
 708     ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
 709
 710     //change the timing and check it
 711     ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionTimingInformation(connectionID,24));
 712     ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(connectionList));
 713     ASSERT_TRUE(connectionList[0].delay==24);
 714 }
 715
 716 TEST_F(CAmDatabaseHandlerTest,getSinkClassOfSink)
 717 {
 718     std::vector<am_SinkClass_s> sinkClassList;
 719     std::vector<am_ClassProperty_s> classPropertyList;
 720     am_SinkClass_s sinkClass, returnClass;
 721     am_ClassProperty_s classProperty;
 722     am_sinkClass_t sinkClassID;
 723     am_Sink_s sink;
 724     am_sinkID_t sinkID;
 725     classProperty.classProperty = CP_GENIVI_SINK_TYPE;
 726     classProperty.value = 1;
 727     classPropertyList.push_back(classProperty);
 728     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 729     classProperty.value = 4;
 730     classPropertyList.push_back(classProperty);
 731     sinkClass.name = "test";
 732     sinkClass.sinkClassID = 4;
 733     sinkClass.listClassProperties = classPropertyList;
 734     pCF.createSink(sink);
 735     sink.sinkClassID = 4;
 736
 737     //prepare test
 738
 739     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 740
 741     //enter a new sinkclass, read out again and check
 742
 743     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
 744     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
 745     ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
 746     ASSERT_EQ(sinkClassList[0].sinkClassID, 4);
 747     ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
 748     ASSERT_EQ(E_OK, pDatabaseHandler.getSinkClassInfoDB(sinkID,returnClass));
 749     ASSERT_EQ(sinkClassList[0].name, returnClass.name);
 750     ASSERT_EQ(sinkClassList[0].sinkClassID, returnClass.sinkClassID);
 751     ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),returnClass.listClassProperties.begin(),equalClassProperties));
 752 }
 753
 754 TEST_F(CAmDatabaseHandlerTest,getSourceClassOfSource)
 755 {
 756     std::vector<am_SourceClass_s> sourceClassList;
 757     std::vector<am_ClassProperty_s> classPropertyList;
 758     am_SourceClass_s sourceClass, sinkSourceClass;
 759     am_ClassProperty_s classProperty;
 760     am_sourceClass_t sourceClassID;
 761     am_Source_s source;
 762     am_sourceID_t sourceID;
 763     classProperty.classProperty = CP_GENIVI_SINK_TYPE;
 764     classProperty.value = 1;
 765     classPropertyList.push_back(classProperty);
 766     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 767     classProperty.value = 4;
 768     classPropertyList.push_back(classProperty);
 769     sourceClass.name = "test";
 770     sourceClass.sourceClassID = 1;
 771     sourceClass.listClassProperties = classPropertyList;
 772     pCF.createSource(source);
 773
 774
 775     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 776
 777     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
 778     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
 779     ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
 780     ASSERT_EQ(sourceClassList[0].sourceClassID, 1);
 781     ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
 782     ASSERT_EQ(E_OK, pDatabaseHandler.getSourceClassInfoDB(sourceID,sinkSourceClass));
 783     ASSERT_EQ(sourceClassList[0].name, sinkSourceClass.name);
 784     ASSERT_EQ(sourceClassList[0].sourceClassID, sinkSourceClass.sourceClassID);
 785     ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),sinkSourceClass.listClassProperties.begin(),equalClassProperties));
 786 }
 787
 788 TEST_F(CAmDatabaseHandlerTest,removeSourceClass)
 789 {
 790     std::vector<am_SourceClass_s> sourceClassList;
 791     std::vector<am_ClassProperty_s> classPropertyList;
 792     am_SourceClass_s sourceClass;
 793     am_ClassProperty_s classProperty;
 794     am_sourceClass_t sourceClassID;
 795     classProperty.classProperty = CP_GENIVI_SINK_TYPE;
 796     classProperty.value = 1;
 797     classPropertyList.push_back(classProperty);
 798     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 799     classProperty.value = 4;
 800     classPropertyList.push_back(classProperty);
 801     sourceClass.name = "test";
 802     sourceClass.sourceClassID = 3;
 803     sourceClass.listClassProperties = classPropertyList;
 804
 805
 806     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
 807     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
 808     ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
 809     ASSERT_EQ(sourceClassList[0].sourceClassID, 3);
 810     ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
 811     ASSERT_EQ(E_OK, pDatabaseHandler.removeSourceClassDB(3));
 812     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
 813     ASSERT_TRUE(sourceClassList.empty());
 814 }
 815
 816 TEST_F(CAmDatabaseHandlerTest,updateSourceClass)
 817 {
 818     std::vector<am_SourceClass_s> sourceClassList;
 819     std::vector<am_ClassProperty_s> classPropertyList, changedPropertyList;
 820     am_SourceClass_s sourceClass, changedClass;
 821     am_ClassProperty_s classProperty;
 822     am_sourceClass_t sourceClassID;
 823     classProperty.classProperty = CP_GENIVI_SINK_TYPE;
 824     classProperty.value = 1;
 825     classPropertyList.push_back(classProperty);
 826     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 827     classProperty.value = 4;
 828     classPropertyList.push_back(classProperty);
 829     sourceClass.name = "test";
 830     sourceClass.sourceClassID = 0;
 831     sourceClass.listClassProperties = classPropertyList;
 832     changedClass = sourceClass;
 833     changedClass.listClassProperties[1].value = 6;
 834     changedPropertyList = changedClass.listClassProperties;
 835
 836     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
 837     changedClass.sourceClassID = sourceClassID;
 838     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
 839     ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
 840     ASSERT_EQ(sourceClassList[0].sourceClassID, 100);
 841     ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
 842     ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceClassInfoDB(changedClass));
 843     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
 844     ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
 845     ASSERT_EQ(sourceClassList[0].sourceClassID, 100);
 846     ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),changedPropertyList.begin(),equalClassProperties));
 847 }
 848
 849 TEST_F(CAmDatabaseHandlerTest,enterSourceClass)
 850 {
 851     std::vector<am_SourceClass_s> sourceClassList;
 852     std::vector<am_ClassProperty_s> classPropertyList;
 853     am_SourceClass_s sourceClass;
 854     am_ClassProperty_s classProperty;
 855     am_sourceClass_t sourceClassID;
 856     classProperty.classProperty = CP_GENIVI_SINK_TYPE;
 857     classProperty.value = 1;
 858     classPropertyList.push_back(classProperty);
 859     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 860     classProperty.value = 4;
 861     classPropertyList.push_back(classProperty);
 862     sourceClass.name = "test";
 863     sourceClass.sourceClassID = 0;
 864     sourceClass.listClassProperties = classPropertyList;
 865
 866
 867     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
 868     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
 869     ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
 870     ASSERT_EQ(sourceClassList[0].sourceClassID, 100);
 871     ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
 872 }
 873
 874 TEST_F(CAmDatabaseHandlerTest,enterSourceClassStatic)
 875 {
 876     std::vector<am_SourceClass_s> sourceClassList;
 877     std::vector<am_ClassProperty_s> classPropertyList;
 878     am_SourceClass_s sourceClass;
 879     am_ClassProperty_s classProperty;
 880     am_sourceClass_t sourceClassID;
 881     classProperty.classProperty = CP_GENIVI_SINK_TYPE;
 882     classProperty.value = 1;
 883     classPropertyList.push_back(classProperty);
 884     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 885     classProperty.value = 4;
 886     classPropertyList.push_back(classProperty);
 887     sourceClass.name = "test";
 888     sourceClass.sourceClassID = 3;
 889     sourceClass.listClassProperties = classPropertyList;
 890
 891
 892     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceClassDB(sourceClassID,sourceClass));
 893     ASSERT_EQ(E_OK, pDatabaseHandler.getListSourceClasses(sourceClassList));
 894     ASSERT_EQ(sourceClassList[0].name, sourceClass.name);
 895     ASSERT_EQ(sourceClassList[0].sourceClassID, 3);
 896     ASSERT_TRUE(std::equal(sourceClassList[0].listClassProperties.begin(),sourceClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
 897 }
 898
 899 TEST_F(CAmDatabaseHandlerTest,removeSinkClass)
 900 {
 901     std::vector<am_SinkClass_s> sinkClassList;
 902     std::vector<am_ClassProperty_s> classPropertyList;
 903     am_SinkClass_s sinkClass;
 904     am_ClassProperty_s classProperty;
 905     am_sinkClass_t sinkClassID;
 906     classProperty.classProperty = CP_GENIVI_SINK_TYPE;
 907     classProperty.value = 1;
 908     classPropertyList.push_back(classProperty);
 909     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 910     classProperty.value = 4;
 911     classPropertyList.push_back(classProperty);
 912     sinkClass.name = "test";
 913     sinkClass.sinkClassID = 0;
 914     sinkClass.listClassProperties = classPropertyList;
 915
 916
 917     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
 918     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
 919     ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
 920     ASSERT_EQ(sinkClassList[0].sinkClassID, 100);
 921     ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
 922     ASSERT_EQ(E_OK, pDatabaseHandler.removeSinkClassDB(sinkClassID));
 923     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
 924     ASSERT_TRUE(sinkClassList.empty());
 925 }
 926
 927 TEST_F(CAmDatabaseHandlerTest,updateSinkClass)
 928 {
 929     std::vector<am_SinkClass_s> sinkClassList;
 930     std::vector<am_ClassProperty_s> classPropertyList, changedPropertyList;
 931     am_SinkClass_s sinkClass, changedClass;
 932     am_ClassProperty_s classProperty;
 933     am_sinkClass_t sinkClassID;
 934     classProperty.classProperty = CP_GENIVI_SINK_TYPE;
 935     classProperty.value = 1;
 936     classPropertyList.push_back(classProperty);
 937     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 938     classProperty.value = 4;
 939     classPropertyList.push_back(classProperty);
 940     sinkClass.name = "test";
 941     sinkClass.sinkClassID = 0;
 942     sinkClass.listClassProperties = classPropertyList;
 943     changedClass = sinkClass;
 944     changedClass.listClassProperties[1].value = 6;
 945     changedPropertyList = changedClass.listClassProperties;
 946
 947     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
 948     changedClass.sinkClassID = sinkClassID;
 949     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
 950     ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
 951     ASSERT_EQ(sinkClassList[0].sinkClassID, 100);
 952     ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
 953     ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkClassInfoDB(changedClass));
 954     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
 955     ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
 956     ASSERT_EQ(sinkClassList[0].sinkClassID, 100);
 957     ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),changedPropertyList.begin(),equalClassProperties));
 958 }
 959
 960 TEST_F(CAmDatabaseHandlerTest,enterSinkClass)
 961 {
 962     std::vector<am_SinkClass_s> sinkClassList;
 963     std::vector<am_ClassProperty_s> classPropertyList;
 964     am_SinkClass_s sinkClass;
 965     am_ClassProperty_s classProperty;
 966     am_sinkClass_t sinkClassID;
 967     classProperty.classProperty = CP_GENIVI_SINK_TYPE;
 968     classProperty.value = 1;
 969     classPropertyList.push_back(classProperty);
 970     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 971     classProperty.value = 4;
 972     classPropertyList.push_back(classProperty);
 973     sinkClass.name = "test";
 974     sinkClass.sinkClassID = 0;
 975     sinkClass.listClassProperties = classPropertyList;
 976
 977
 978     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
 979     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
 980     ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
 981     ASSERT_EQ(sinkClassList[0].sinkClassID, 100);
 982     ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
 983 }
 984
 985 TEST_F(CAmDatabaseHandlerTest,enterSinkClassStatic)
 986 {
 987     std::vector<am_SinkClass_s> sinkClassList;
 988     std::vector<am_ClassProperty_s> classPropertyList;
 989     am_SinkClass_s sinkClass;
 990     am_ClassProperty_s classProperty;
 991     am_sinkClass_t sinkClassID;
 992     classProperty.classProperty = CP_GENIVI_SINK_TYPE;
 993     classProperty.value = 1;
 994     classPropertyList.push_back(classProperty);
 995     classProperty.classProperty = CP_GENIVI_SOURCE_TYPE;
 996     classProperty.value = 4;
 997     classPropertyList.push_back(classProperty);
 998     sinkClass.name = "test";
 999     sinkClass.sinkClassID = 4;
1000     sinkClass.listClassProperties = classPropertyList;
1001
1002
1003     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkClassDB(sinkClass,sinkClassID));
1004     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinkClasses(sinkClassList));
1005     ASSERT_EQ(sinkClassList[0].name, sinkClass.name);
1006     ASSERT_EQ(sinkClassList[0].sinkClassID, 4);
1007     ASSERT_TRUE(std::equal(sinkClassList[0].listClassProperties.begin(),sinkClassList[0].listClassProperties.end(),classPropertyList.begin(),equalClassProperties));
1008 }
1009
1010 TEST_F(CAmDatabaseHandlerTest, changeSystemProperty)
1011 {
1012     std::vector<am_SystemProperty_s> listSystemProperties, listReturn;
1013     am_SystemProperty_s systemProperty;
1014
1015     systemProperty.type = SYP_UNKNOWN;
1016     systemProperty.value = 33;
1017     listSystemProperties.push_back(systemProperty);
1018     ASSERT_EQ(E_OK, pDatabaseHandler.enterSystemProperties(listSystemProperties));
1019     systemProperty.value = 444;
1020     ASSERT_EQ(E_OK, pDatabaseHandler.changeSystemPropertyDB(systemProperty));
1021     ASSERT_EQ(E_OK, pDatabaseHandler.getListSystemProperties(listReturn));
1022     ASSERT_EQ(listReturn[0].type, systemProperty.type);
1023     ASSERT_EQ(listReturn[0].value, systemProperty.value);
1024 }
1025
1026 TEST_F(CAmDatabaseHandlerTest, systemProperties)
1027 {
1028     std::vector<am_SystemProperty_s> listSystemProperties, listReturn;
1029     am_SystemProperty_s systemProperty;
1030
1031     systemProperty.type = SYP_UNKNOWN;
1032     systemProperty.value = 33;
1033     listSystemProperties.push_back(systemProperty);
1034
1035     ASSERT_EQ(E_OK, pDatabaseHandler.enterSystemProperties(listSystemProperties));
1036     ASSERT_EQ(E_OK, pDatabaseHandler.getListSystemProperties(listReturn));
1037     ASSERT_EQ(listReturn[0].type, systemProperty.type);
1038     ASSERT_EQ(listReturn[0].value, systemProperty.value);
1039 }
1040
1041 TEST_F(CAmDatabaseHandlerTest,enterSourcesCorrect)
1042 {
1043     //fill the connection database
1044     am_Source_s staticSource, firstDynamicSource, secondDynamicSource;
1045     am_sourceID_t staticSourceID, firstDynamicSourceID, secondDynamicSourceID;
1046     std::vector<am_Source_s> sourceList;
1047
1048     pCF.createSource(staticSource);
1049     staticSource.sourceID = 4;
1050     staticSource.name = "Static";
1051
1052
1053     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
1054         << "ERROR: database error";
1055     ASSERT_EQ(staticSource.sourceID,staticSourceID)
1056         << "ERROR: ID not the one given in staticSource";
1057
1058     pCF.createSource(firstDynamicSource);
1059     firstDynamicSource.name = "firstDynamicSource";
1060
1061     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(firstDynamicSource,firstDynamicSourceID))
1062         << "ERROR: database error";
1063     ASSERT_EQ(firstDynamicSourceID,DYNAMIC_ID_BOUNDARY)
1064         << "ERROR: ID not the one given in firstDynamicSink";
1065
1066     pCF.createSource(secondDynamicSource);
1067     secondDynamicSource.name = "secondDynamicSource";
1068
1069     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(secondDynamicSource,secondDynamicSourceID))
1070         << "ERROR: database error";
1071     ASSERT_NEAR(secondDynamicSourceID,DYNAMIC_ID_BOUNDARY,10)
1072         << "ERROR: ID not the one given in secondDynamicSink";
1073
1074     //now read back and check the returns agains the given values
1075     ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(sourceList))
1076         << "ERROR: database error";
1077     bool equal = true;
1078
1079     std::vector<am_Source_s>::iterator listIterator = sourceList.begin();
1080     for (; listIterator < sourceList.end(); ++listIterator)
1081     {
1082         if (listIterator->sourceID == staticSourceID)
1083         {
1084             equal = equal && pCF.compareSource(listIterator, staticSource);
1085         }
1086
1087         if (listIterator->sourceID == firstDynamicSourceID)
1088         {
1089             equal = equal && pCF.compareSource(listIterator, firstDynamicSource);
1090         }
1091
1092         if (listIterator->sourceID == secondDynamicSourceID)
1093         {
1094             equal = equal && pCF.compareSource(listIterator, secondDynamicSource);
1095         }
1096
1097     }
1098     ASSERT_EQ(true, equal);
1099 }
1100
1101 TEST_F(CAmDatabaseHandlerTest, changeSourceMainSoundProperty)
1102 {
1103     std::vector<am_Source_s> listSources;
1104     am_Source_s source;
1105     am_sourceID_t sourceID;
1106     pCF.createSource(source);
1107     am_MainSoundProperty_s property;
1108     property.type = MSP_UNKNOWN;
1109     property.value = 33;
1110
1111     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
1112
1113     ASSERT_EQ(E_OK, pDatabaseHandler.changeMainSourceSoundPropertyDB(property,sourceID));
1114     ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
1115     std::vector<am_MainSoundProperty_s>::iterator listIterator = listSources[0].listMainSoundProperties.begin();
1116     for (; listIterator < listSources[0].listMainSoundProperties.end(); ++listIterator)
1117     {
1118         if (listIterator->type == property.type)
1119         {
1120             ASSERT_EQ(listIterator->value, property.value);
1121         }
1122     }
1123 }
1124
1125 TEST_F(CAmDatabaseHandlerTest, changeSinkMuteState)
1126 {
1127     std::vector<am_Sink_s> listSinks;
1128     am_Sink_s sink;
1129     am_sinkID_t sinkID;
1130     pCF.createSink(sink);
1131     am_MuteState_e muteState = MS_MUTED;
1132
1133     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
1134
1135     ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMuteStateDB(muteState,sinkID));
1136     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
1137     ASSERT_EQ(muteState, listSinks[0].muteState);
1138 }
1139
1140 TEST_F(CAmDatabaseHandlerTest, changeSinkMainSoundProperty)
1141 {
1142     std::vector<am_Sink_s> listSinks;
1143     am_Sink_s sink;
1144     am_sinkID_t sinkID;
1145     pCF.createSink(sink);
1146     am_MainSoundProperty_s property;
1147     property.type = MSP_UNKNOWN;
1148     property.value = 33;
1149
1150
1151     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
1152
1153     ASSERT_EQ(E_OK, pDatabaseHandler.changeMainSinkSoundPropertyDB(property,sinkID));
1154     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
1155     std::vector<am_MainSoundProperty_s>::iterator listIterator = listSinks[0].listMainSoundProperties.begin();
1156     for (; listIterator < listSinks[0].listMainSoundProperties.end(); ++listIterator)
1157     {
1158         if (listIterator->type == property.type)
1159         {
1160             ASSERT_EQ(listIterator->value, property.value);
1161         }
1162     }
1163 }
1164
1165 TEST_F(CAmDatabaseHandlerTest, peekDomain)
1166 {
1167     std::vector<am_Domain_s> listDomains;
1168     am_Domain_s domain;
1169     am_domainID_t domainID;
1170     am_domainID_t domain2ID;
1171     pCF.createDomain(domain);
1172     ASSERT_EQ(E_OK, pDatabaseHandler.peekDomain(std::string("newdomain"),domainID));
1173     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
1174     ASSERT_TRUE(listDomains.empty());
1175     ASSERT_EQ(domainID, 1);
1176     domain.name = "newdomain";
1177     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
1178     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
1179     ASSERT_EQ(domainID, domain2ID);
1180     ASSERT_TRUE(listDomains[0].domainID==domainID);
1181 }
1182
1183 TEST_F(CAmDatabaseHandlerTest, peekDomainFirstEntered)
1184 {
1185     std::vector<am_Domain_s> listDomains;
1186     am_Domain_s domain;
1187     am_domainID_t domainID;
1188     am_domainID_t domain2ID;
1189     pCF.createDomain(domain);
1190     domain.name = "newdomain";
1191     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
1192     ASSERT_EQ(E_OK, pDatabaseHandler.peekDomain(std::string("newdomain"),domain2ID));
1193     ASSERT_EQ(domainID, domain2ID);
1194     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
1195     ASSERT_TRUE(listDomains.size()==1);
1196 }
1197
1198 TEST_F(CAmDatabaseHandlerTest, changeDomainState)
1199 {
1200     std::vector<am_Domain_s> listDomains;
1201     am_Domain_s domain;
1202     am_domainID_t domainID;
1203     pCF.createDomain(domain);
1204     am_DomainState_e newState = DS_INDEPENDENT_STARTUP;
1205     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
1206     ASSERT_EQ(E_OK, pDatabaseHandler.changDomainStateDB(newState,domainID));
1207     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
1208     ASSERT_EQ(newState, listDomains[0].state);
1209 }
1210
1211 TEST_F(CAmDatabaseHandlerTest, changeMainConnectionState)
1212 {
1213     std::vector<am_MainConnection_s> listMainConnections;
1214     createMainConnectionSetup();
1215
1216     ASSERT_EQ(E_OK, pDatabaseHandler.changeMainConnectionStateDB(1,CS_DISCONNECTING));
1217     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(listMainConnections));
1218     ASSERT_EQ(CS_DISCONNECTING, listMainConnections[0].connectionState);
1219 }
1220
1221 TEST_F(CAmDatabaseHandlerTest, changeSinkAvailability)
1222 {
1223     std::vector<am_Sink_s> listSinks;
1224     am_Sink_s sink;
1225     am_sinkID_t sinkID;
1226     pCF.createSink(sink);
1227     am_Availability_s availability;
1228     availability.availability = A_UNKNOWN;
1229     availability.availabilityReason = AR_GENIVI_TEMPERATURE;
1230
1231
1232     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
1233     ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkAvailabilityDB(availability,sinkID));
1234     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
1235     ASSERT_EQ(availability.availability, listSinks[0].available.availability);
1236     ASSERT_EQ(availability.availabilityReason, listSinks[0].available.availabilityReason);
1237 }
1238
1239 TEST_F(CAmDatabaseHandlerTest, changeSourceAvailability)
1240 {
1241     std::vector<am_Source_s> listSources;
1242     am_Source_s source;
1243     am_sourceID_t sourceID;
1244     pCF.createSource(source);
1245     am_Availability_s availability;
1246     availability.availability = A_UNKNOWN;
1247     availability.availabilityReason = AR_GENIVI_TEMPERATURE;
1248     source.visible = true;
1249
1250
1251     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
1252     ASSERT_EQ(E_OK, pDatabaseHandler.changeSourceAvailabilityDB(availability,sourceID));
1253     ASSERT_EQ(E_OK, pDatabaseHandler.getListSources(listSources));
1254     ASSERT_EQ(availability.availability, listSources[0].available.availability);
1255     ASSERT_EQ(availability.availabilityReason, listSources[0].available.availabilityReason);
1256 }
1257
1258 TEST_F(CAmDatabaseHandlerTest,changeMainConnectionRoute)
1259 {
1260     std::vector<am_MainConnection_s> originalList;
1261     std::vector<am_MainConnection_s> newList;
1262     createMainConnectionSetup();
1263     //fill the connection database
1264     am_Connection_s connection;
1265     am_Source_s source;
1266     am_Sink_s sink;
1267     std::vector<am_connectionID_t> listConnectionID;
1268
1269
1270
1271     for (uint16_t i = 1; i < 10; i++)
1272     {
1273         am_sinkID_t forgetSink;
1274         am_sourceID_t forgetSource;
1275         am_connectionID_t connectionID;
1276
1277         connection.sinkID = i + 20;
1278         connection.sourceID = i + 20;
1279         connection.delay = -1;
1280         connection.connectionFormat = CF_GENIVI_ANALOG;
1281         connection.connectionID = 0;
1282
1283         pCF.createSink(sink);
1284         sink.sinkID = i + 20;
1285         sink.name = "sink" + int2string(i + 20);
1286         sink.domainID = 4;
1287         pCF.createSource(source);
1288         source.sourceID = i + 20;
1289         source.name = "source" + int2string(i + 30);
1290         source.domainID = 4;
1291
1292         ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,forgetSink));
1293         ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,forgetSource));
1294         ASSERT_EQ(E_OK, pDatabaseHandler.enterConnectionDB(connection,connectionID));
1295         listConnectionID.push_back(connectionID);
1296         ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(originalList));
1297
1298     }
1299
1300     ASSERT_EQ(E_OK, pDatabaseHandler.changeMainConnectionRouteDB(1,listConnectionID));
1301     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(newList));
1302     ASSERT_FALSE(std::equal(newList[0].listConnectionID.begin(),newList[0].listConnectionID.end(),originalList[0].listConnectionID.begin()));
1303 }
1304
1305 TEST_F(CAmDatabaseHandlerTest,changeMainSinkVolume)
1306 {
1307     am_Sink_s sink;
1308     am_sinkID_t sinkID;
1309     am_mainVolume_t newVol = 20;
1310     std::vector<am_Sink_s> listSinks;
1311     pCF.createSink(sink);
1312
1313
1314     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
1315
1316     ASSERT_EQ(E_OK, pDatabaseHandler.changeSinkMainVolumeDB(newVol,sinkID));
1317     ASSERT_EQ(E_OK, pDatabaseHandler.getListSinks(listSinks));
1318     ASSERT_EQ(listSinks[0].mainVolume, newVol);
1319 }
1320
1321 TEST_F(CAmDatabaseHandlerTest,getMainSourceSoundProperties)
1322 {
1323     am_Source_s source;
1324     am_sourceID_t sourceID;
1325     pCF.createSource(source);
1326     std::vector<am_MainSoundProperty_s> mainSoundProperties = source.listMainSoundProperties;
1327     std::vector<am_MainSoundProperty_s> listMainSoundProperties;
1328
1329
1330     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
1331     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSourceSoundProperties(sourceID,listMainSoundProperties));
1332     ASSERT_TRUE(std::equal(mainSoundProperties.begin(),mainSoundProperties.end(),listMainSoundProperties.begin(),equalMainSoundProperty));
1333 }
1334
1335 TEST_F(CAmDatabaseHandlerTest,getMainSinkSoundProperties)
1336 {
1337     am_Sink_s sink;
1338     am_sinkID_t sinkID;
1339     pCF.createSink(sink);
1340     std::vector<am_MainSoundProperty_s> mainSoundProperties = sink.listMainSoundProperties;
1341     std::vector<am_MainSoundProperty_s> listMainSoundProperties;
1342
1343
1344     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
1345     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSinkSoundProperties(sinkID,listMainSoundProperties));
1346     ASSERT_TRUE(std::equal(mainSoundProperties.begin(),mainSoundProperties.end(),listMainSoundProperties.begin(),equalMainSoundProperty));
1347 }
1348
1349 TEST_F(CAmDatabaseHandlerTest,getMainSources)
1350 {
1351     am_Source_s source, source1, source2;
1352     am_sourceID_t sourceID;
1353     pCF.createSource(source);
1354     pCF.createSource(source1);
1355     pCF.createSource(source2);
1356     source1.name = "source1";
1357     source2.name = "source2";
1358     bool equal = true;
1359     source1.visible = false;
1360     std::vector<am_SourceType_s> listMainSources;
1361     std::vector<am_Source_s> listSources;
1362
1363
1364
1365     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
1366     source.sourceID = sourceID;
1367     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source1,sourceID));
1368     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source2,sourceID));
1369     source2.sourceID = sourceID;
1370     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSources(listMainSources));
1371     listSources.push_back(source);
1372     listSources.push_back(source2);
1373     std::vector<am_SourceType_s>::iterator listIterator = listMainSources.begin();
1374     for (; listIterator < listMainSources.end(); ++listIterator)
1375     {
1376         equal = equal && pCF.compareSinkMainSource(listIterator, listSources);
1377     }
1378     ASSERT_TRUE(equal);
1379 }
1380
1381 TEST_F(CAmDatabaseHandlerTest,getMainSinks)
1382 {
1383     am_Sink_s sink, sink1, sink2;
1384     am_sinkID_t sinkID;
1385     pCF.createSink(sink);
1386     pCF.createSink(sink1);
1387     pCF.createSink(sink2);
1388     sink1.name = "sink1";
1389     sink2.name = "sink2";
1390     bool equal = true;
1391     sink1.visible = false;
1392     std::vector<am_SinkType_s> listMainSinks;
1393     std::vector<am_Sink_s> listSinks;
1394
1395
1396     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
1397     sink.sinkID = sinkID;
1398     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink1,sinkID));
1399     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink2,sinkID));
1400     sink2.sinkID = sinkID;
1401     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainSinks(listMainSinks));
1402     listSinks.push_back(sink);
1403     listSinks.push_back(sink2);
1404     std::vector<am_SinkType_s>::iterator listIterator = listMainSinks.begin();
1405     for (; listIterator < listMainSinks.end(); ++listIterator)
1406     {
1407         equal = equal && pCF.compareSinkMainSink(listIterator, listSinks);
1408     }
1409     ASSERT_TRUE(equal);
1410 }
1411
1412 TEST_F(CAmDatabaseHandlerTest,getVisibleMainConnections)
1413 {
1414     createMainConnectionSetup();
1415     std::vector<am_MainConnectionType_s> listVisibleMainConnections;
1416     std::vector<am_MainConnection_s> listMainConnections;
1417     ASSERT_EQ(E_OK, pDatabaseHandler.getListVisibleMainConnections(listVisibleMainConnections));
1418     ASSERT_EQ(E_OK, pDatabaseHandler.getListMainConnections(listMainConnections));
1419     ASSERT_EQ(listMainConnections[0].mainConnectionID, listVisibleMainConnections[0].mainConnectionID);
1420     ASSERT_EQ(listMainConnections[0].connectionState, listVisibleMainConnections[0].connectionState);
1421     ASSERT_EQ(listMainConnections[0].delay, listVisibleMainConnections[0].delay);
1422     ASSERT_EQ(listMainConnections[0].sinkID, listVisibleMainConnections[0].sinkID);
1423     ASSERT_EQ(listMainConnections[0].sourceID, listVisibleMainConnections[0].sourceID);
1424 }
1425
1426 TEST_F(CAmDatabaseHandlerTest,getListSourcesOfDomain)
1427 {
1428     am_Source_s source, source2;
1429     am_Domain_s domain;
1430     am_domainID_t domainID;
1431     am_sourceID_t sourceID;
1432     std::vector<am_sourceID_t> sourceList, sourceCheckList;
1433     pCF.createSource(source);
1434     source.sourceID = 1;
1435     source.name = "testSource";
1436     source.domainID = 1;
1437     pCF.createSource(source2);
1438     source2.sourceID = 0;
1439     source2.name = "testSource2";
1440     source2.domainID = 5;
1441     pCF.createDomain(domain);
1442     sourceCheckList.push_back(1); //sink.sinkID);
1443
1444
1445     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
1446     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID))
1447         << "ERROR: database error";
1448     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source2,sourceID))
1449         << "ERROR: database error";
1450     ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListSourcesOfDomain(2,sourceList))
1451         << "ERROR: database error";ASSERT_TRUE(sourceList.empty());
1452     ASSERT_EQ(E_OK,pDatabaseHandler.getListSourcesOfDomain(1,sourceList))
1453         << "ERROR: database error";
1454     ASSERT_TRUE(std::equal(sourceList.begin(),sourceList.end(),sourceCheckList.begin()) && !sourceList.empty());
1455 }
1456
1457 TEST_F(CAmDatabaseHandlerTest,getListSinksOfDomain)
1458 {
1459     am_Sink_s sink, sink2;
1460     am_Domain_s domain;
1461     am_domainID_t domainID;
1462     am_sinkID_t sinkID;
1463     std::vector<am_sinkID_t> sinkList, sinkCheckList;
1464     pCF.createSink(sink);
1465     sink.sinkID = 1;
1466     sink.domainID = 1;
1467     pCF.createSink(sink2);
1468     sink2.domainID = 5;
1469     sink2.name = "sink2";
1470     pCF.createDomain(domain);
1471     sinkCheckList.push_back(1); //sink.sinkID);
1472
1473
1474     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
1475     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID))
1476         << "ERROR: database error";
1477     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink2,sinkID))
1478         << "ERROR: database error";
1479     ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListSinksOfDomain(2,sinkList))
1480         << "ERROR: database error";ASSERT_TRUE(sinkList.empty());
1481     ASSERT_EQ(E_OK,pDatabaseHandler.getListSinksOfDomain(1,sinkList))
1482         << "ERROR: database error";
1483     ASSERT_TRUE(std::equal(sinkList.begin(),sinkList.end(),sinkCheckList.begin()) && !sinkList.empty());
1484 }
1485
1486 TEST_F(CAmDatabaseHandlerTest,getListGatewaysOfDomain)
1487 {
1488
1489
1490     am_Gateway_s gateway, gateway2;
1491     am_gatewayID_t gatewayID;
1492     am_domainID_t domainID;
1493     am_Domain_s domain;
1494     std::vector<am_gatewayID_t> gatewayList, gatewayCheckList;
1495     pCF.createGateway(gateway);
1496     gateway.gatewayID = 1;
1497     gateway.name = "testGateway";
1498     gateway.controlDomainID = 1;
1499     gateway.sourceID = 1;
1500     gateway.sinkID = 1;
1501     gateway.domainSinkID = 1;
1502     gateway.domainSourceID = 1;
1503     pCF.createGateway(gateway2);
1504     gateway2.gatewayID = 2;
1505     gateway2.name = "testGateway2";
1506     gateway2.controlDomainID = 4;
1507     gateway2.sourceID = 1;
1508     gateway2.sinkID = 1;
1509     gateway2.domainSinkID = 1;
1510     gateway2.domainSourceID = 1;
1511     pCF.createDomain(domain);
1512     gatewayCheckList.push_back(gateway.gatewayID);
1513     am_Sink_s sink;
1514     am_Source_s source;
1515     am_sinkID_t sinkID;
1516     am_sourceID_t sourceID;
1517     pCF.createSink(sink);
1518     pCF.createSource(source);
1519     sink.sinkID = 1;
1520     source.sourceID = 1;
1521     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
1522     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
1523     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
1524     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
1525         << "ERROR: database error";
1526     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID))
1527         << "ERROR: database error";
1528     ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.getListGatewaysOfDomain(2,gatewayList))
1529         << "ERROR: database error";ASSERT_TRUE(gatewayList.empty());
1530     ASSERT_EQ(E_OK,pDatabaseHandler.getListGatewaysOfDomain(1,gatewayList))
1531         << "ERROR: database error";
1532     ASSERT_TRUE(std::equal(gatewayList.begin(),gatewayList.end(),gatewayCheckList.begin()) && !gatewayList.empty());
1533 }
1534
1535 TEST_F(CAmDatabaseHandlerTest,removeDomain)
1536 {
1537     am_Domain_s domain;
1538     am_domainID_t domainID;
1539     std::vector<am_Domain_s> listDomains;
1540     pCF.createDomain(domain);
1541     ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID))
1542         << "ERROR: database error";
1543     ASSERT_EQ(E_OK,pDatabaseHandler.removeDomainDB(domainID))
1544         << "ERROR: database error";
1545     ASSERT_EQ(E_OK,pDatabaseHandler.getListDomains(listDomains))
1546         << "ERROR: database error";
1547     ASSERT_TRUE(listDomains.empty());
1548 }
1549
1550 TEST_F(CAmDatabaseHandlerTest,removeGateway)
1551 {
1552
1553
1554     am_Gateway_s gateway;
1555     am_gatewayID_t gatewayID;
1556     std::vector<am_Gateway_s> listGateways;
1557     pCF.createGateway(gateway);
1558     am_Sink_s sink;
1559     am_Source_s source;
1560     am_sinkID_t sinkID;
1561     am_sourceID_t sourceID;
1562     pCF.createSink(sink);
1563     pCF.createSource(source);
1564     sink.sinkID = 1;
1565     source.sourceID = 2;
1566     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
1567     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
1568     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
1569         << "ERROR: database error";
1570     ASSERT_EQ(E_OK,pDatabaseHandler.removeGatewayDB(gatewayID))
1571         << "ERROR: database error";
1572     ASSERT_EQ(E_OK,pDatabaseHandler.getListGateways(listGateways))
1573         << "ERROR: database error";
1574     ASSERT_TRUE(listGateways.empty());
1575 }
1576
1577 TEST_F(CAmDatabaseHandlerTest,removeSink)
1578 {
1579     am_Sink_s sink;
1580     am_sinkID_t sinkID;
1581     std::vector<am_Sink_s> listSinks;
1582     pCF.createSink(sink);
1583
1584     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID))
1585         << "ERROR: database error";
1586     ASSERT_EQ(E_OK,pDatabaseHandler.removeSinkDB(sinkID))
1587         << "ERROR: database error";
1588     ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
1589         << "ERROR: database error";
1590     ASSERT_TRUE(listSinks.empty());
1591 }
1592
1593 TEST_F(CAmDatabaseHandlerTest,removeSource)
1594 {
1595     //fill the connection database
1596     am_Source_s source;
1597     am_sourceID_t sourceID;
1598     std::vector<am_Source_s> listSources;
1599     pCF.createSource(source);
1600
1601
1602     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID))
1603         << "ERROR: database error";
1604     ASSERT_EQ(E_OK,pDatabaseHandler.removeSourceDB(sourceID))
1605         << "ERROR: database error";
1606     ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(listSources))
1607         << "ERROR: database error";
1608     ASSERT_TRUE(listSources.empty());
1609 }
1610
1611 TEST_F(CAmDatabaseHandlerTest, removeMainConnection)
1612 {
1613     createMainConnectionSetup();
1614
1615
1616     ASSERT_EQ(E_OK,pDatabaseHandler.removeMainConnectionDB(1))
1617         << "ERROR: database error";
1618 }
1619
1620 TEST_F(CAmDatabaseHandlerTest,removeNonexistentMainConnectionFail)
1621 {
1622     ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeMainConnectionDB(34))
1623         << "ERROR: database error";
1624 }
1625
1626 TEST_F(CAmDatabaseHandlerTest,removeNonexistentSource)
1627 {
1628     ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeSourceDB(3))
1629         << "ERROR: database error";
1630 }
1631
1632 TEST_F(CAmDatabaseHandlerTest,removeNonexistentSink)
1633 {
1634     ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeSinkDB(2))
1635         << "ERROR: database error";
1636 }
1637
1638 TEST_F(CAmDatabaseHandlerTest,removeNonexistentGateway)
1639 {
1640     ASSERT_EQ(E_NON_EXISTENT,pDatabaseHandler.removeGatewayDB(12))
1641         << "ERROR: database error";
1642 }
1643
1644 TEST_F(CAmDatabaseHandlerTest,registerGatewayCorrect)
1645 {
1646
1647
1648     //initialize gateway
1649     std::vector<am_Gateway_s> returnList;
1650     am_Gateway_s gateway, gateway1, gateway2;
1651     am_gatewayID_t gatewayID = 0, gatewayID1 = 0, gatewayID2 = 0;
1652
1653     pCF.createGateway(gateway);
1654     pCF.createGateway(gateway1);
1655     gateway1.gatewayID = 20;
1656     pCF.createGateway(gateway2);
1657     am_Sink_s sink;
1658     am_Source_s source;
1659     am_sinkID_t sinkID;
1660     am_sourceID_t sourceID;
1661     pCF.createSink(sink);
1662     pCF.createSource(source);
1663     sink.sinkID = 1;
1664     source.sourceID = 2;
1665     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
1666     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
1667     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
1668         << "ERROR: database error";
1669     ASSERT_EQ(100,gatewayID)
1670         << "ERROR: domainID zero";
1671
1672     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1))
1673         << "ERROR: database error";
1674     ASSERT_EQ(gateway1.gatewayID,gatewayID1)
1675         << "ERROR: domainID zero";
1676
1677     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2))
1678         << "ERROR: database error";
1679     ASSERT_EQ(101,gatewayID2)
1680         << "ERROR: domainID zero";
1681
1682     //now check if we read out the correct values
1683     ASSERT_EQ(E_OK, pDatabaseHandler.getListGateways(returnList));
1684     bool equal = true;
1685     std::vector<am_Gateway_s>::iterator listIterator = returnList.begin();
1686
1687     for (; listIterator < returnList.end(); ++listIterator)
1688     {
1689         if (listIterator->gatewayID == gatewayID)
1690         {
1691             equal = equal && pCF.compareGateway(listIterator, gateway);
1692         }
1693
1694         if (listIterator->gatewayID == gatewayID1)
1695         {
1696             equal = equal && pCF.compareGateway(listIterator, gateway1);
1697         }
1698
1699         if (listIterator->gatewayID == gatewayID2)
1700         {
1701             equal = equal && pCF.compareGateway(listIterator, gateway2);
1702         }
1703     }
1704
1705     ASSERT_EQ(true, equal);
1706 }
1707
1708 TEST_F(CAmDatabaseHandlerTest,getGatewayInfo)
1709 {
1710
1711
1712     //initialize gateway
1713     std::vector<am_Gateway_s> returnList;
1714     am_Gateway_s gateway, gateway1, gateway2;
1715     am_gatewayID_t gatewayID = 0, gatewayID1 = 0, gatewayID2 = 0;
1716
1717     pCF.createGateway(gateway);
1718     pCF.createGateway(gateway1);
1719     gateway1.gatewayID = 20;
1720     pCF.createGateway(gateway2);
1721     am_Sink_s sink;
1722     am_Source_s source;
1723     am_sinkID_t sinkID;
1724     am_sourceID_t sourceID;
1725     pCF.createSink(sink);
1726     pCF.createSource(source);
1727     sink.sinkID = 1;
1728     source.sourceID = 2;
1729     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
1730     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
1731     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway,gatewayID))
1732         << "ERROR: database error";
1733     ASSERT_EQ(100,gatewayID)
1734         << "ERROR: domainID zero";
1735
1736     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway1,gatewayID1))
1737         << "ERROR: database error";
1738     ASSERT_EQ(gateway1.gatewayID,gatewayID1)
1739         << "ERROR: domainID zero";
1740
1741     ASSERT_EQ(E_OK,pDatabaseHandler.enterGatewayDB(gateway2,gatewayID2))
1742         << "ERROR: database error";
1743     ASSERT_EQ(101,gatewayID2)
1744         << "ERROR: domainID zero";
1745
1746     //now check if we read out the correct values
1747     ASSERT_EQ(E_OK, pDatabaseHandler.getListGateways(returnList));
1748     bool equal = true;
1749     std::vector<am_Gateway_s>::iterator listIterator = returnList.begin();
1750
1751     for (; listIterator < returnList.end(); ++listIterator)
1752     {
1753         if (listIterator->gatewayID == gatewayID)
1754         {
1755             equal = equal && pCF.compareGateway(listIterator, gateway);
1756         }
1757
1758         if (listIterator->gatewayID == gatewayID1)
1759         {
1760             equal = equal && pCF.compareGateway(listIterator, gateway1);
1761         }
1762
1763         if (listIterator->gatewayID == gatewayID2)
1764         {
1765             equal = equal && pCF.compareGateway(listIterator, gateway2);
1766         }
1767     }
1768
1769     ASSERT_EQ(true, equal);
1770
1771     am_Gateway_s gatewayInfo;
1772     ASSERT_EQ(E_OK, pDatabaseHandler.getGatewayInfoDB(20,gatewayInfo));
1773     ASSERT_TRUE(pCF.compareGateway1(gateway1,gatewayInfo));
1774
1775 }
1776
1777 TEST_F(CAmDatabaseHandlerTest,enterSinkThatAlreadyExistFail)
1778 {
1779     //fill the connection database
1780     am_Sink_s staticSink, SecondSink;
1781     am_sinkID_t staticSinkID, SecondSinkID;
1782
1783     pCF.createSink(staticSink);
1784     staticSink.sinkID = 43;
1785     staticSink.name = "Static";
1786
1787
1788     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
1789         << "ERROR: database error";
1790     ASSERT_EQ(staticSink.sinkID,staticSinkID)
1791         << "ERROR: ID not the one given in staticSink";
1792
1793     pCF.createSink(SecondSink);
1794     SecondSink.sinkID = 43;
1795     SecondSink.name = "SecondSink";
1796
1797     ASSERT_EQ(E_ALREADY_EXISTS,pDatabaseHandler.enterSinkDB(SecondSink,SecondSinkID))
1798         << "ERROR: database error";
1799 }
1800
1801 TEST_F(CAmDatabaseHandlerTest,enterSourcesThatAlreadyExistFail)
1802 {
1803     //fill the connection database
1804     am_Source_s staticSource, SecondSource;
1805     am_sourceID_t staticSourceID, SecondSourceID;
1806     pCF.createSource(staticSource);
1807     staticSource.sourceID = 4;
1808
1809
1810     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(staticSource,staticSourceID))
1811         << "ERROR: database error";
1812     ASSERT_EQ(staticSource.sourceID,staticSourceID)
1813         << "ERROR: ID not the one given in staticSource";
1814
1815     pCF.createSource(SecondSource);
1816     SecondSource.sourceID = 4;
1817
1818     ASSERT_EQ(E_ALREADY_EXISTS,pDatabaseHandler.enterSourceDB(SecondSource,SecondSourceID))
1819         << "ERROR: database error";
1820 }
1821
1822 TEST_F(CAmDatabaseHandlerTest,registerDomainCorrect)
1823 {
1824     //initialize domain
1825     std::vector<am_Domain_s> returnList;
1826     am_Domain_s domain;
1827     am_domainID_t domainID = 0;
1828     pCF.createDomain(domain);
1829
1830     ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID))
1831         << "ERROR: database error";
1832     ASSERT_NE(0,domainID)
1833         << "ERROR: domainID zero";
1834
1835     //now check if we read out the correct values
1836     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(returnList));
1837     bool equal = true;
1838     std::vector<am_Domain_s>::iterator listIterator = returnList.begin();
1839     for (; listIterator < returnList.end(); ++listIterator)
1840     {
1841         if (listIterator->domainID == domainID)
1842         {
1843             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);
1844         }
1845     }
1846     ASSERT_EQ(true, equal);
1847 }
1848
1849 TEST_F(CAmDatabaseHandlerTest,registerConnectionCorrect)
1850 {
1851     am_Connection_s connection;
1852     am_connectionID_t connectionID;
1853     std::vector<am_Connection_s> returnList;
1854     pCF.createConnection(connection);
1855
1856     ASSERT_EQ(E_OK,pDatabaseHandler.enterConnectionDB(connection,connectionID))
1857         << "ERROR: database error";;
1858     ASSERT_NE(0,connectionID)
1859         << "ERROR: connectionID zero";
1860
1861     //now check if we read out the correct values
1862     ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
1863     ASSERT_EQ(E_OK, pDatabaseHandler.getListConnections(returnList));
1864     bool equal = false;
1865     std::vector<am_Connection_s>::iterator listIterator = returnList.begin();
1866     for (; listIterator < returnList.end(); ++listIterator)
1867     {
1868         if (listIterator->connectionID == connectionID)
1869         {
1870             equal = (listIterator->sourceID == connection.sourceID) && (listIterator->sinkID == connection.sinkID) && (listIterator->delay == connection.delay) && (listIterator->connectionFormat = connection.connectionFormat);
1871         }
1872     }
1873     ASSERT_EQ(true, equal);
1874 }
1875
1876 TEST_F(CAmDatabaseHandlerTest,enterMainConnectionCorrect)
1877 {
1878     createMainConnectionSetup();
1879 }
1880
1881 TEST_F(CAmDatabaseHandlerTest,enterSinksCorrect)
1882 {
1883     //fill the connection database
1884     am_Sink_s staticSink, firstDynamicSink, secondDynamicSink;
1885     am_sinkID_t staticSinkID, firstDynamicSinkID, secondDynamicSinkID;
1886     std::vector<am_Sink_s> sinkList;
1887
1888     pCF.createSink(staticSink);
1889     staticSink.sinkID = 4;
1890
1891
1892     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(staticSink,staticSinkID))
1893         << "ERROR: database error";
1894     ASSERT_EQ(staticSink.sinkID,staticSinkID)
1895         << "ERROR: ID not the one given in staticSink";
1896
1897     pCF.createSink(firstDynamicSink);
1898     firstDynamicSink.name = "firstdynamic";
1899     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(firstDynamicSink,firstDynamicSinkID))
1900         << "ERROR: database error";
1901     ASSERT_EQ(firstDynamicSinkID,DYNAMIC_ID_BOUNDARY)
1902         << "ERROR: ID not the one given in firstDynamicSink";
1903
1904     pCF.createSink(secondDynamicSink);
1905     secondDynamicSink.name = "seconddynamic";
1906
1907     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(secondDynamicSink,secondDynamicSinkID))
1908         << "ERROR: database error";
1909     ASSERT_NEAR(secondDynamicSinkID,DYNAMIC_ID_BOUNDARY,10)
1910         << "ERROR: ID not the one given in secondDynamicSink";
1911
1912     //now read back and check the returns agains the given values
1913     ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(sinkList))
1914         << "ERROR: database error";
1915     bool equal = true;
1916
1917     std::vector<am_Sink_s>::iterator listIterator = sinkList.begin();
1918     for (; listIterator < sinkList.end(); ++listIterator)
1919     {
1920         if (listIterator->sinkID == staticSinkID)
1921         {
1922             equal = equal && pCF.compareSink(listIterator, staticSink);
1923         }
1924
1925         if (listIterator->sinkID == firstDynamicSinkID)
1926         {
1927             equal = equal && pCF.compareSink(listIterator, firstDynamicSink);
1928         }
1929
1930         if (listIterator->sinkID == secondDynamicSinkID)
1931         {
1932             equal = equal && pCF.compareSink(listIterator, secondDynamicSink);
1933         }
1934     }
1935     ASSERT_EQ(true, equal);
1936 }
1937
1938 TEST_F(CAmDatabaseHandlerTest,enterNotificationConfigurationCorrect)
1939 {
1940     am_Sink_s testSinkData, readoutData;
1941     pCF.createSink(testSinkData);
1942     testSinkData.sinkID = 4;
1943     am_sinkID_t sinkID;
1944     std::vector<am_Sink_s> listSinks;
1945
1946     am_NotificationConfiguration_s notify;
1947     notify.type=NT_UNKNOWN;
1948     notify.status=NS_CHANGE;
1949     notify.parameter=25;
1950     testSinkData.listNotificationConfigurations.push_back(notify);
1951
1952     //enter the sink in the database
1953     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
1954         << "ERROR: database error";
1955
1956     //read it again
1957     ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
1958         << "ERROR: database error";
1959
1960     ASSERT_EQ(listSinks.begin()->listNotificationConfigurations[2].parameter,notify.parameter);
1961     ASSERT_EQ(listSinks.begin()->listNotificationConfigurations[2].status,notify.status);
1962     ASSERT_EQ(listSinks.begin()->listNotificationConfigurations[2].type,notify.type);
1963
1964     ASSERT_EQ(E_OK,pDatabaseHandler.getSinkInfoDB(testSinkData.sinkID,readoutData))
1965             << "ERROR: database error";
1966
1967     ASSERT_EQ(readoutData.listNotificationConfigurations[2].parameter,notify.parameter);
1968     ASSERT_EQ(readoutData.listNotificationConfigurations[2].status,notify.status);
1969     ASSERT_EQ(readoutData.listNotificationConfigurations[2].type,notify.type);
1970
1971 }
1972
1973 TEST_F(CAmDatabaseHandlerTest,enterMainNotificationConfigurationCorrect)
1974 {
1975     am_Sink_s testSinkData;
1976     pCF.createSink(testSinkData);
1977     testSinkData.sinkID = 4;
1978     am_sinkID_t sinkID;
1979     std::vector<am_Sink_s> listSinks;
1980
1981     am_NotificationConfiguration_s notify;
1982     notify.type=NT_UNKNOWN;
1983     notify.status=NS_CHANGE;
1984     notify.parameter=25;
1985
1986     testSinkData.listMainNotificationConfigurations.push_back(notify);
1987
1988     //enter the sink in the database
1989     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
1990         << "ERROR: database error";
1991
1992     //read it again
1993     ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
1994         << "ERROR: database error";
1995
1996     ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].parameter,notify.parameter);
1997     ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].status,notify.status);
1998     ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].type,notify.type);
1999 }
2000
2001 TEST_F(CAmDatabaseHandlerTest,removeNotificationsSink)
2002 {
2003     am_Sink_s testSinkData;
2004     pCF.createSink(testSinkData);
2005     testSinkData.sinkID = 4;
2006     am_sinkID_t sinkID;
2007     std::vector<am_Sink_s> listSinks;
2008
2009     am_NotificationConfiguration_s notify;
2010     notify.type=NT_UNKNOWN;
2011     notify.status=NS_CHANGE;
2012     notify.parameter=25;
2013
2014     testSinkData.listMainNotificationConfigurations.push_back(notify);
2015
2016     //enter the sink in the database
2017     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
2018         << "ERROR: database error";
2019
2020     //read it again
2021     ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks))
2022         << "ERROR: database error";
2023
2024     ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].parameter,notify.parameter);
2025     ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].status,notify.status);
2026     ASSERT_EQ(listSinks.begin()->listMainNotificationConfigurations[2].type,notify.type);
2027
2028     //now we remove the sink
2029     ASSERT_EQ(E_OK,pDatabaseHandler.removeSinkDB(sinkID));
2030 }
2031
2032 TEST_F(CAmDatabaseHandlerTest,removeNotificationsSource)
2033 {
2034     am_Source_s testSourceData;
2035     pCF.createSource(testSourceData);
2036     testSourceData.sourceID = 4;
2037     am_sourceID_t sourceID;
2038     std::vector<am_Source_s> listSources;
2039
2040     am_NotificationConfiguration_s notify;
2041     notify.type=NT_UNKNOWN;
2042     notify.status=NS_CHANGE;
2043     notify.parameter=25;
2044
2045     testSourceData.listMainNotificationConfigurations.push_back(notify);
2046
2047     //enter the sink in the database
2048     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
2049         << "ERROR: database error";
2050
2051     //read it again
2052     ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(listSources))
2053         << "ERROR: database error";
2054
2055     ASSERT_EQ(listSources.begin()->listMainNotificationConfigurations[2].parameter,notify.parameter);
2056     ASSERT_EQ(listSources.begin()->listMainNotificationConfigurations[2].status,notify.status);
2057     ASSERT_EQ(listSources.begin()->listMainNotificationConfigurations[2].type,notify.type);
2058
2059     //now we remove the sink
2060     ASSERT_EQ(E_OK,pDatabaseHandler.removeSourceDB(sourceID));
2061 }
2062
2063 TEST_F(CAmDatabaseHandlerTest,getMainNotificationsSink)
2064 {
2065     am_Sink_s testSinkData;
2066     pCF.createSink(testSinkData);
2067     testSinkData.sinkID = 4;
2068     am_sinkID_t sinkID;
2069     std::vector<am_Sink_s> listSinks;
2070     std::vector<am_NotificationConfiguration_s>returnList;
2071
2072     am_NotificationConfiguration_s notify;
2073     notify.type=NT_UNKNOWN;
2074     notify.status=NS_CHANGE;
2075     notify.parameter=25;
2076
2077     testSinkData.listMainNotificationConfigurations.push_back(notify);
2078
2079     am_NotificationConfiguration_s notify1;
2080     notify1.type=NT_MAX;
2081     notify1.status=NS_PERIODIC;
2082     notify1.parameter=5;
2083
2084     testSinkData.listMainNotificationConfigurations.push_back(notify1);
2085
2086     //enter the sink in the database
2087     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
2088         << "ERROR: database error";
2089
2090     //read it again
2091     ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSinkNotificationConfigurations(sinkID,returnList))
2092         << "ERROR: database error";
2093
2094     std::equal(testSinkData.listMainNotificationConfigurations.begin(),testSinkData.listMainNotificationConfigurations.end(),returnList.begin(),equalNotificationConfiguration);
2095
2096 }
2097
2098 TEST_F(CAmDatabaseHandlerTest,getMainNotificationsSources)
2099 {
2100     am_Source_s testSourceData;
2101     pCF.createSource(testSourceData);
2102     testSourceData.sourceID = 4;
2103     am_sourceID_t sourceID;
2104     std::vector<am_Source_s> listSources;
2105     std::vector<am_NotificationConfiguration_s>returnList;
2106
2107     am_NotificationConfiguration_s notify;
2108     notify.type=NT_UNKNOWN;
2109     notify.status=NS_CHANGE;
2110     notify.parameter=25;
2111
2112     testSourceData.listMainNotificationConfigurations.push_back(notify);
2113
2114     am_NotificationConfiguration_s notify1;
2115     notify1.type=NT_MAX;
2116     notify1.status=NS_PERIODIC;
2117     notify1.parameter=5;
2118
2119     testSourceData.listMainNotificationConfigurations.push_back(notify1);
2120
2121     //enter the sink in the database
2122     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
2123         << "ERROR: database error";
2124
2125     //read it again
2126     ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSourceNotificationConfigurations(sourceID,returnList))
2127         << "ERROR: database error";
2128
2129     std::equal(testSourceData.listMainNotificationConfigurations.begin(),testSourceData.listMainNotificationConfigurations.end(),returnList.begin(),equalNotificationConfiguration);
2130
2131 }
2132
2133 TEST_F(CAmDatabaseHandlerTest,changeMainNotificationsSources)
2134 {
2135     am_Source_s testSourceData;
2136     pCF.createSource(testSourceData);
2137     testSourceData.sourceID = 4;
2138     am_sourceID_t sourceID;
2139     std::vector<am_Source_s> listSources;
2140     std::vector<am_NotificationConfiguration_s>returnList,returnList1;
2141
2142     am_NotificationConfiguration_s notify;
2143     notify.type=NT_UNKNOWN;
2144     notify.status=NS_CHANGE;
2145     notify.parameter=25;
2146
2147     testSourceData.listMainNotificationConfigurations.push_back(notify);
2148
2149     am_NotificationConfiguration_s notify1;
2150     notify1.type=NT_MAX;
2151     notify1.status=NS_PERIODIC;
2152     notify1.parameter=5;
2153
2154     am_NotificationConfiguration_s notify2;
2155     notify2.type=NT_MAX;
2156     notify2.status=NS_CHANGE;
2157     notify2.parameter=10;
2158
2159     testSourceData.listMainNotificationConfigurations.push_back(notify1);
2160
2161     //enter the sink in the database
2162     ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(testSourceData,sourceID))
2163         << "ERROR: database error";
2164
2165     //read it again
2166     ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSourceNotificationConfigurations(sourceID,returnList))
2167         << "ERROR: database error";
2168
2169     std::equal(testSourceData.listMainNotificationConfigurations.begin(),testSourceData.listMainNotificationConfigurations.end(),returnList.begin(),equalNotificationConfiguration);
2170
2171     //change a setting
2172     ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSourceNotificationConfigurationDB(sourceID,notify2));
2173
2174     ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSourceNotificationConfigurations(sourceID,returnList1))
2175         << "ERROR: database error";
2176
2177     ASSERT_EQ(returnList1[3].parameter,notify2.parameter);
2178     ASSERT_EQ(returnList1[3].status,notify2.status);
2179     ASSERT_EQ(returnList1[3].type,notify2.type);
2180
2181 }
2182
2183 TEST_F(CAmDatabaseHandlerTest,changeMainNotificationsSink)
2184 {
2185     am_Sink_s testSinkData;
2186     pCF.createSink(testSinkData);
2187     testSinkData.sinkID = 4;
2188     am_sinkID_t sinkID;
2189     std::vector<am_Sink_s> listSinks;
2190     std::vector<am_NotificationConfiguration_s>returnList,returnList1;
2191
2192     am_NotificationConfiguration_s notify;
2193     notify.type=NT_UNKNOWN;
2194     notify.status=NS_CHANGE;
2195     notify.parameter=25;
2196
2197     testSinkData.listMainNotificationConfigurations.push_back(notify);
2198
2199     am_NotificationConfiguration_s notify1;
2200     notify1.type=NT_MAX;
2201     notify1.status=NS_PERIODIC;
2202     notify1.parameter=5;
2203
2204     am_NotificationConfiguration_s notify2;
2205     notify2.type=NT_MAX;
2206     notify2.status=NS_CHANGE;
2207     notify2.parameter=27;
2208
2209     testSinkData.listMainNotificationConfigurations.push_back(notify1);
2210
2211     //enter the sink in the database
2212     ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(testSinkData,sinkID))
2213         << "ERROR: database error";
2214
2215     //read it again
2216     ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSinkNotificationConfigurations(sinkID,returnList))
2217         << "ERROR: database error";
2218
2219     std::equal(testSinkData.listMainNotificationConfigurations.begin(),testSinkData.listMainNotificationConfigurations.end(),returnList.begin(),equalNotificationConfiguration);
2220
2221     ASSERT_EQ(E_OK,pDatabaseHandler.changeMainSinkNotificationConfigurationDB(sinkID,notify2))
2222         << "ERROR: database error";
2223
2224     ASSERT_EQ(E_OK,pDatabaseHandler.getListMainSinkNotificationConfigurations(sinkID,returnList1))
2225         << "ERROR: database error";
2226
2227     ASSERT_EQ(returnList1[3].parameter,notify2.parameter);
2228     ASSERT_EQ(returnList1[3].status,notify2.status);
2229     ASSERT_EQ(returnList1[3].type,notify2.type);
2230 }
2231
2232 TEST_F(CAmDatabaseHandlerTest, peekDomain_2)
2233 {
2234     std::vector<am_Domain_s> listDomains;
2235     am_Domain_s domain;
2236     am_domainID_t domainID;
2237     am_domainID_t domain2ID;
2238     pCF.createDomain(domain);
2239     ASSERT_EQ(E_OK,pDatabaseHandler.peekDomain(std::string("newdomain"),domainID));
2240     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
2241     ASSERT_TRUE(listDomains.empty());
2242     ASSERT_EQ(domainID, 1);
2243
2244     domain.name = "anotherdomain";
2245     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
2246     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
2247     ASSERT_EQ(domain2ID, 2);
2248
2249     domain.name = "newdomain";
2250     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domain2ID));
2251     ASSERT_EQ(E_OK, pDatabaseHandler.getListDomains(listDomains));
2252     ASSERT_EQ(domainID, domain2ID);               // FAILS, ID is 2 instead of 1
2253     ASSERT_TRUE(listDomains[0].domainID==domainID);
2254 }
2255
2256 //Commented out - gives always a warning..
2257 //TEST_F(databaseTest,registerDomainFailonID0)
2258 //{
2259 //      am_Domain_s domain;
2260 //      am_domainID_t domainID=5;
2261 //      pCF.createDomain(domain);
2262 //      domain.domainID=1;
2263 //      ASSERT_DEATH(pDatabaseHandler.enterDomainDB(domain,domainID),"Assertion `domainData.domainID==0'");
2264 //}
2265
2266 int main(int argc, char **argv)
2267 {
2268     CAmDltWrapper::instance()->registerApp("databse", "databasetest");
2269     logInfo("Database Test started ");
2270     ::testing::InitGoogleTest(&argc, argv);
2271     return RUN_ALL_TESTS();
2272 }
2273