* adds test for bug63 to the database tests
[profile/ivi/genivi/genivi-audio-manager.git] / 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