AudioManagerDaemon/test/routingInterface/routingInterfaceTest.cpp

   1 /**
   2  * Copyright (C) 2011, BMW AG
   3  *
   4  * GeniviAudioMananger AudioManagerDaemon
   5  *
   6  * \file routingInterfaces.cpp
   7  *
   8  * \date 20-Oct-2011 3:42:04 PM
   9  * \author Christian Mueller (christian.ei.mueller@bmw.de)
  10  *
  11  * \section License
  12  * GNU Lesser General Public License, version 2.1, with special exception (GENIVI clause)
  13  * Copyright (C) 2011, BMW AG Christian Mueller  Christian.ei.mueller@bmw.de
  14  *
  15  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
  16  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License, version 2.1, for more details.
  17  * You should have received a copy of the GNU Lesser General Public License, version 2.1, along with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
  18  * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may also be applicable to programs even in cases in which the program is not a library in the technical sense.
  19  * Linking AudioManager statically or dynamically with other modules is making a combined work based on AudioManager. You may license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to license your linked modules under the GNU Lesser General Public License, version 2.1, you may use the program under the following exception.
  20  * As a special exception, the copyright holders of AudioManager give you permission to combine AudioManager with software programs or libraries that are released under any license unless such a combination is not permitted by the license of such a software program or library. You may copy and distribute such a system following the terms of the GNU Lesser General Public License, version 2.1, including this special exception, for AudioManager and the licenses of the other code concerned.
  21  * Note that people who make modified versions of AudioManager are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, version 2.1, gives permission to release a modified version without this exception; this exception also makes it possible to release a modified version which carries forward this exception.
  22  *
  23  * THIS CODE HAS BEEN GENERATED BY ENTERPRISE ARCHITECT GENIVI MODEL. PLEASE CHANGE ONLY IN ENTERPRISE ARCHITECT AND GENERATE AGAIN
  24  */
  25
  26 #include "routingInterfaceTest.h"
  27 #include "DLTWrapper.h"
  28
  29 using namespace am;
  30 using namespace testing;
  31
  32 routingInterfaceTest::routingInterfaceTest() :
  33         plistRoutingPluginDirs(), //
  34         plistCommandPluginDirs(), //
  35         pDatabaseHandler(std::string(":memory:")), //
  36         pRoutingSender(plistRoutingPluginDirs), //
  37         pCommandSender(plistCommandPluginDirs), //
  38         pControlSender(""), //
  39         pRouter(&pDatabaseHandler, &pControlSender), //
  40         pMockInterface(), //
  41         pRoutingInterfaceBackdoor(), //
  42         pCommandInterfaceBackdoor(), //
  43         pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender, &pRouter), //
  44         pObserver(&pCommandSender, &pRoutingSender)
  45 {
  46     pDatabaseHandler.registerObserver(&pObserver);
  47     pRoutingInterfaceBackdoor.unloadPlugins(&pRoutingSender);
  48     pRoutingInterfaceBackdoor.injectInterface(&pRoutingSender, &pMockInterface, "mock");
  49     pCommandInterfaceBackdoor.unloadPlugins(&pCommandSender);
  50 }
  51
  52 routingInterfaceTest::~routingInterfaceTest()
  53 {
  54 }
  55
  56 void routingInterfaceTest::SetUp()
  57 {
  58     logInfo("RoutingSendInterface Test started ");
  59
  60 }
  61
  62 void routingInterfaceTest::TearDown()
  63 {
  64 }
  65
  66 TEST_F(routingInterfaceTest,abort)
  67 {
  68     am_Sink_s sink;
  69     am_sinkID_t sinkID;
  70     am_Domain_s domain;
  71     am_domainID_t domainID;
  72     am_Handle_s handle;
  73     am_connectionID_t connectionID;
  74     std::vector<am_Handle_s> listHandles;
  75     pCF.createSink(sink);
  76     pCF.createDomain(domain);
  77     domain.name = "mock";
  78     domain.busname = "mock";
  79     sink.sinkID = 2;
  80     sink.domainID = 1;
  81
  82     //prepare the stage
  83     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
  84     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
  85
  86     //start a connect, expect a call on the routingInterface
  87     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
  88     ASSERT_EQ(E_OK, pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
  89
  90     //check the correctness of the handle
  91     ASSERT_NE(handle.handle, 0);
  92     ASSERT_EQ(handle.handleType, H_CONNECT);
  93
  94     //the handle must be inside the handlelist
  95     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
  96     ASSERT_TRUE(listHandles[0].handle==handle.handle);
  97     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
  98
  99     //send an abort expect a call on the routing interface
 100     EXPECT_CALL(pMockInterface,asyncAbort(_)).WillOnce(Return(E_OK));
 101     ASSERT_EQ(E_OK, pControlReceiver.abortAction(handle));
 102
 103     //the reaction on the abort is specific for every function
 104
 105     //now we try to abort a handle that does not exist
 106     handle.handle = 24;
 107     ASSERT_EQ(E_NON_EXISTENT, pControlReceiver.abortAction(handle));
 108 }
 109
 110 TEST_F(routingInterfaceTest,abortNonExistent)
 111 {
 112     EXPECT_CALL(pMockInterface,asyncAbort(_)).Times(0);
 113     am_Handle_s handle;
 114     ASSERT_EQ(E_NON_EXISTENT, pControlReceiver.abortAction(handle));
 115 }
 116
 117 TEST_F(routingInterfaceTest,alreadyConnected)
 118 {
 119     am_Sink_s sink;
 120     am_sinkID_t sinkID;
 121     am_Domain_s domain;
 122     am_domainID_t domainID;
 123     pCF.createSink(sink);
 124     pCF.createDomain(domain);
 125     domain.name = "mock";
 126     domain.busname = "mock";
 127     sink.sinkID = 2;
 128     sink.domainID = 1;
 129     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 130     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 131     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
 132     am_Handle_s handle;
 133     am_connectionID_t connectionID;
 134     ASSERT_EQ(E_OK, pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 135     ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
 136     ASSERT_EQ(E_ALREADY_EXISTS, pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 137     ASSERT_NE(handle.handle, 0);
 138     ASSERT_EQ(handle.handleType, H_CONNECT);
 139 }
 140
 141 TEST_F(routingInterfaceTest,setSinkSoundPropertyNoChange)
 142 {
 143     am_Sink_s sink;
 144     am_sinkID_t sinkID;
 145     am_Domain_s domain;
 146     am_domainID_t domainID;
 147     am_Handle_s handle;
 148     am_SoundProperty_s soundProperty;
 149     soundProperty.type = SP_TREBLE;
 150     soundProperty.value = 23;
 151     std::vector<am_Handle_s> listHandles;
 152     pCF.createSink(sink);
 153     pCF.createDomain(domain);
 154     domain.name = "mock";
 155     domain.busname = "mock";
 156     sink.sinkID = 2;
 157     sink.domainID = 1;
 158     sink.listSoundProperties.push_back(soundProperty);
 159     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 160     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 161     EXPECT_CALL(pMockInterface,asyncSetSinkSoundProperty(_,sinkID,_)).Times(0);
 162     ASSERT_EQ(E_NO_CHANGE, pControlReceiver.setSinkSoundProperty(handle,sinkID,soundProperty));
 163 }
 164
 165 TEST_F(routingInterfaceTest,setSourceState)
 166 {
 167     am_Source_s source;
 168     am_sourceID_t sourceID;
 169     am_Domain_s domain;
 170     am_domainID_t domainID;
 171     am_Handle_s handle;
 172     handle.handle = 0;
 173     am_SourceState_e state = SS_PAUSED;
 174     pCF.createSource(source);
 175     pCF.createDomain(domain);
 176     domain.name = "mock";
 177     domain.busname = "mock";
 178     source.domainID = 1;
 179     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 180     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 181     EXPECT_CALL(pMockInterface,asyncSetSourceState(_,sourceID,state)).WillOnce(Return(E_OK));
 182     ASSERT_EQ(E_OK, pControlReceiver.setSourceState(handle,sourceID,state));
 183     ASSERT_NE(handle.handle, 0);
 184     ASSERT_EQ(handle.handleType, H_SETSOURCESTATE);
 185 }
 186
 187 TEST_F(routingInterfaceTest,setSourceSoundProperty)
 188 {
 189     am_Source_s source;
 190     am_sourceID_t sourceID;
 191     am_Domain_s domain;
 192     am_domainID_t domainID;
 193     am_Handle_s handle;
 194     am_SoundProperty_s soundProperty;
 195     std::vector<am_Handle_s> listHandles;
 196     pCF.createSource(source);
 197     pCF.createDomain(domain);
 198     domain.name = "mock";
 199     domain.busname = "mock";
 200     source.sourceID = 2;
 201     source.domainID = 1;
 202     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 203     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 204     EXPECT_CALL(pMockInterface,asyncSetSourceSoundProperty(_,sourceID,_)).WillOnce(Return(E_OK));
 205     ASSERT_EQ(E_OK, pControlReceiver.setSourceSoundProperty(handle,sourceID,soundProperty));
 206     ASSERT_NE(handle.handle, 0);
 207     ASSERT_EQ(handle.handleType, H_SETSOURCESOUNDPROPERTY);
 208     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 209     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 210     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 211 }
 212
 213 TEST_F(routingInterfaceTest,setSinkSoundProperty)
 214 {
 215     am_Sink_s sink;
 216     am_sinkID_t sinkID;
 217     am_Domain_s domain;
 218     am_domainID_t domainID;
 219     am_Handle_s handle;
 220     am_SoundProperty_s soundProperty;
 221     std::vector<am_Handle_s> listHandles;
 222     pCF.createSink(sink);
 223     pCF.createDomain(domain);
 224     domain.name = "mock";
 225     domain.busname = "mock";
 226     sink.sinkID = 2;
 227     sink.domainID = 1;
 228     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 229     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 230     EXPECT_CALL(pMockInterface,asyncSetSinkSoundProperty(_,sinkID,_)).WillOnce(Return(E_OK));
 231     ASSERT_EQ(E_OK, pControlReceiver.setSinkSoundProperty(handle,sinkID,soundProperty));
 232     ASSERT_NE(handle.handle, 0);
 233     ASSERT_EQ(handle.handleType, H_SETSINKSOUNDPROPERTY);
 234     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 235     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 236     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 237 }
 238
 239 TEST_F(routingInterfaceTest,setSourceVolumeNoChange)
 240 {
 241     am_Source_s source;
 242     am_sourceID_t sourceID;
 243     am_Domain_s domain;
 244     am_domainID_t domainID;
 245     am_Handle_s handle;
 246     am_volume_t volume = 34;
 247     am_RampType_e rampType = RAMP_DIRECT;
 248     am_time_t rampTime = 300;
 249     std::vector<am_Handle_s> listHandles;
 250     pCF.createSource(source);
 251     pCF.createDomain(domain);
 252     domain.name = "mock";
 253     domain.busname = "mock";
 254     source.sourceID = 2;
 255     source.domainID = 1;
 256     source.volume = volume;
 257     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 258     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 259     EXPECT_CALL(pMockInterface,asyncSetSourceVolume(_,2,volume,rampType,rampTime)).Times(0);
 260     ASSERT_EQ(E_NO_CHANGE, pControlReceiver.setSourceVolume(handle,2,volume,rampType,rampTime));
 261     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 262     ASSERT_TRUE(listHandles.empty());
 263 }
 264
 265 TEST_F(routingInterfaceTest,setSourceVolume)
 266 {
 267     am_Source_s source;
 268     am_sourceID_t sourceID;
 269     am_Domain_s domain;
 270     am_domainID_t domainID;
 271     am_Handle_s handle;
 272     am_volume_t volume = 34;
 273     am_RampType_e rampType = RAMP_DIRECT;
 274     am_time_t rampTime = 300;
 275     std::vector<am_Handle_s> listHandles;
 276     pCF.createSource(source);
 277     pCF.createDomain(domain);
 278     domain.name = "mock";
 279     domain.busname = "mock";
 280     source.sourceID = 2;
 281     source.domainID = 1;
 282     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 283     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 284     EXPECT_CALL(pMockInterface,asyncSetSourceVolume(_,2,volume,rampType,rampTime)).WillOnce(Return(E_OK));
 285     ASSERT_EQ(E_OK, pControlReceiver.setSourceVolume(handle,2,volume,rampType,rampTime));
 286     ASSERT_NE(handle.handle, 0);
 287     ASSERT_EQ(handle.handleType, H_SETSOURCEVOLUME);
 288     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 289     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 290     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 291 }
 292
 293 TEST_F(routingInterfaceTest,setSinkVolumeNoChange)
 294 {
 295     am_Sink_s sink;
 296     am_sinkID_t sinkID;
 297     am_Domain_s domain;
 298     am_domainID_t domainID;
 299     am_Handle_s handle;
 300     am_volume_t volume = 34;
 301     am_RampType_e rampType = RAMP_DIRECT;
 302     am_time_t rampTime = 300;
 303     std::vector<am_Handle_s> listHandles;
 304     pCF.createSink(sink);
 305     pCF.createDomain(domain);
 306     domain.name = "mock";
 307     domain.busname = "mock";
 308     sink.sinkID = 2;
 309     sink.domainID = 1;
 310     sink.volume = volume;
 311     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 312     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 313     EXPECT_CALL(pMockInterface,asyncSetSinkVolume(_,2,volume,rampType,rampTime)).Times(0);
 314     ASSERT_EQ(E_NO_CHANGE, pControlReceiver.setSinkVolume(handle,2,volume,rampType,rampTime));
 315     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 316     ASSERT_TRUE(listHandles.empty());
 317 }
 318
 319 TEST_F(routingInterfaceTest,setSinkVolume)
 320 {
 321     am_Sink_s sink;
 322     am_sinkID_t sinkID;
 323     am_Domain_s domain;
 324     am_domainID_t domainID;
 325     am_Handle_s handle;
 326     am_volume_t volume = 34;
 327     am_RampType_e rampType = RAMP_DIRECT;
 328     am_time_t rampTime = 300;
 329     std::vector<am_Handle_s> listHandles;
 330     pCF.createSink(sink);
 331     pCF.createDomain(domain);
 332     domain.name = "mock";
 333     domain.busname = "mock";
 334     sink.sinkID = 2;
 335     sink.domainID = 1;
 336     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 337     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 338     EXPECT_CALL(pMockInterface,asyncSetSinkVolume(_,2,volume,rampType,rampTime)).WillOnce(Return(E_OK));
 339     ASSERT_EQ(E_OK, pControlReceiver.setSinkVolume(handle,2,volume,rampType,rampTime));
 340     ASSERT_NE(handle.handle, 0);
 341     ASSERT_EQ(handle.handleType, H_SETSINKVOLUME);
 342     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 343     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 344     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 345 }
 346
 347 TEST_F(routingInterfaceTest,connect)
 348 {
 349     am_Sink_s sink;
 350     am_sinkID_t sinkID;
 351     am_Domain_s domain;
 352     am_domainID_t domainID;
 353     am_Handle_s handle;
 354     am_connectionID_t connectionID;
 355     std::vector<am_Handle_s> listHandles;
 356     pCF.createSink(sink);
 357     pCF.createDomain(domain);
 358     domain.name = "mock";
 359     domain.busname = "mock";
 360     sink.sinkID = 2;
 361     sink.domainID = 1;
 362     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 363     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 364     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
 365     ASSERT_EQ(E_OK, pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 366     ASSERT_NE(handle.handle, 0);
 367     ASSERT_EQ(handle.handleType, H_CONNECT);
 368     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 369     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 370     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 371 }
 372
 373 TEST_F(routingInterfaceTest,disconnect)
 374 {
 375     am_Sink_s sink;
 376     am_sinkID_t sinkID;
 377     am_Domain_s domain;
 378     am_domainID_t domainID;
 379     am_Handle_s handle;
 380     am_connectionID_t connectionID;
 381     std::vector<am_Handle_s> listHandles;
 382     pCF.createSink(sink);
 383     pCF.createDomain(domain);
 384     domain.name = "mock";
 385     domain.busname = "mock";
 386     sink.sinkID = 2;
 387     sink.domainID = 1;
 388     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 389     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 390     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
 391     ASSERT_EQ(E_OK, pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 392     ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
 393     EXPECT_CALL(pMockInterface,asyncDisconnect(_,connectionID)).WillOnce(Return(E_OK));
 394     ASSERT_EQ(E_OK, pControlReceiver.disconnect(handle,connectionID));
 395     ASSERT_NE(handle.handle, 0);
 396     ASSERT_EQ(handle.handleType, H_DISCONNECT);
 397     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 398     ASSERT_TRUE(listHandles[1].handle==handle.handle);
 399     ASSERT_TRUE(listHandles[1].handleType==handle.handleType);
 400 }
 401
 402 TEST_F(routingInterfaceTest,nothingTodisconnect)
 403 {
 404     am_Handle_s handle;
 405     am_connectionID_t connectionID = 4;
 406     std::vector<am_Handle_s> listHandles;
 407     ASSERT_EQ(E_NON_EXISTENT, pControlReceiver.disconnect(handle,connectionID));
 408     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 409     ASSERT_TRUE(listHandles.empty());
 410 }
 411
 412 TEST_F(routingInterfaceTest,setSourceStateNoChange)
 413 {
 414     am_Source_s source;
 415     am_sourceID_t sourceID;
 416     am_Domain_s domain;
 417     am_domainID_t domainID;
 418     am_Handle_s handle;
 419     handle.handle = 0;
 420     am_SourceState_e state = SS_PAUSED;
 421     pCF.createSource(source);
 422     pCF.createDomain(domain);
 423     domain.name = "mock";
 424     domain.busname = "mock";
 425     source.domainID = 1;
 426     source.sourceState = state;
 427     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 428     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 429     EXPECT_CALL(pMockInterface,asyncSetSourceState(_,sourceID,state)).Times(0);
 430     ASSERT_EQ(E_NO_CHANGE, pControlReceiver.setSourceState(handle,sourceID,state));
 431 }
 432
 433 int main(int argc, char **argv)
 434 {
 435     ::testing::InitGoogleTest(&argc, argv);
 436     return RUN_ALL_TESTS();
 437 }
 438