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