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
  28 using namespace am;
  29 using namespace testing;
  30
  31 DLT_DECLARE_CONTEXT(DLT_CONTEXT);
  32
  33 routingInterfaceTest::routingInterfaceTest() :
  34         plistRoutingPluginDirs(), //
  35         plistCommandPluginDirs(), //
  36         pDatabaseHandler(std::string(":memory:")), //
  37         pRoutingSender(plistRoutingPluginDirs), //
  38         pCommandSender(plistCommandPluginDirs), //
  39         pMockInterface(), //
  40         pRoutingInterfaceBackdoor(), //
  41         pCommandInterfaceBackdoor(), //
  42         pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender), //
  43         pObserver(&pCommandSender, &pRoutingSender)
  44 {
  45     pDatabaseHandler.registerObserver(&pObserver);
  46     pRoutingInterfaceBackdoor.unloadPlugins(&pRoutingSender);
  47     pRoutingInterfaceBackdoor.injectInterface(&pRoutingSender, &pMockInterface, "mock");
  48     pCommandInterfaceBackdoor.unloadPlugins(&pCommandSender);
  49 }
  50
  51 routingInterfaceTest::~routingInterfaceTest()
  52 {
  53 }
  54
  55 void routingInterfaceTest::SetUp()
  56 {
  57     DLT_REGISTER_APP("Rtest", "RoutingInterfacetest");
  58     DLT_REGISTER_CONTEXT(DLT_CONTEXT, "Main", "Main Context");
  59     DLT_LOG(DLT_CONTEXT, DLT_LOG_INFO, DLT_STRING("RoutingSendInterface Test started "));
  60
  61 }
  62
  63 void routingInterfaceTest::TearDown()
  64 {
  65     DLT_UNREGISTER_CONTEXT(DLT_CONTEXT);
  66 }
  67
  68 TEST_F(routingInterfaceTest,abort)
  69 {
  70     am_Sink_s sink;
  71     am_sinkID_t sinkID;
  72     am_Domain_s domain;
  73     am_domainID_t domainID;
  74     am_Handle_s handle;
  75     am_connectionID_t connectionID;
  76     std::vector<am_Handle_s> listHandles;
  77     pCF.createSink(sink);
  78     pCF.createDomain(domain);
  79     domain.name = "mock";
  80     domain.busname = "mock";
  81     sink.sinkID = 2;
  82     sink.domainID = 1;
  83
  84     //prepare the stage
  85     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
  86     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
  87
  88     //start a connect, expect a call on the routingInterface
  89     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
  90     ASSERT_EQ(E_OK, pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
  91
  92     //check the correctness of the handle
  93     ASSERT_NE(handle.handle, 0);
  94     ASSERT_EQ(handle.handleType, H_CONNECT);
  95
  96     //the handle must be inside the handlelist
  97     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
  98     ASSERT_TRUE(listHandles[0].handle==handle.handle);
  99     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 100
 101     //send an abort expect a call on the routing interface
 102     EXPECT_CALL(pMockInterface,asyncAbort(_)).WillOnce(Return(E_OK));
 103     ASSERT_EQ(E_OK, pControlReceiver.abortAction(handle));
 104
 105     //the reaction on the abort is specific for every function
 106
 107     //now we try to abort a handle that does not exist
 108     handle.handle = 24;
 109     ASSERT_EQ(E_NON_EXISTENT, pControlReceiver.abortAction(handle));
 110 }
 111
 112 TEST_F(routingInterfaceTest,abortNonExistent)
 113 {
 114     EXPECT_CALL(pMockInterface,asyncAbort(_)).Times(0);
 115     am_Handle_s handle;
 116     ASSERT_EQ(E_NON_EXISTENT, pControlReceiver.abortAction(handle));
 117 }
 118
 119 TEST_F(routingInterfaceTest,alreadyConnected)
 120 {
 121     am_Sink_s sink;
 122     am_sinkID_t sinkID;
 123     am_Domain_s domain;
 124     am_domainID_t domainID;
 125     pCF.createSink(sink);
 126     pCF.createDomain(domain);
 127     domain.name = "mock";
 128     domain.busname = "mock";
 129     sink.sinkID = 2;
 130     sink.domainID = 1;
 131     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 132     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 133     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
 134     am_Handle_s handle;
 135     am_connectionID_t connectionID;
 136     ASSERT_EQ(E_OK, pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 137     ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
 138     ASSERT_EQ(E_ALREADY_EXISTS, pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 139     ASSERT_NE(handle.handle, 0);
 140     ASSERT_EQ(handle.handleType, H_CONNECT);
 141 }
 142
 143 TEST_F(routingInterfaceTest,setSinkSoundPropertyNoChange)
 144 {
 145     am_Sink_s sink;
 146     am_sinkID_t sinkID;
 147     am_Domain_s domain;
 148     am_domainID_t domainID;
 149     am_Handle_s handle;
 150     am_SoundProperty_s soundProperty;
 151     soundProperty.type = SP_TREBLE;
 152     soundProperty.value = 23;
 153     std::vector<am_Handle_s> listHandles;
 154     pCF.createSink(sink);
 155     pCF.createDomain(domain);
 156     domain.name = "mock";
 157     domain.busname = "mock";
 158     sink.sinkID = 2;
 159     sink.domainID = 1;
 160     sink.listSoundProperties.push_back(soundProperty);
 161     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 162     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 163     EXPECT_CALL(pMockInterface,asyncSetSinkSoundProperty(_,_,sinkID)).Times(0);
 164     ASSERT_EQ(E_NO_CHANGE, pControlReceiver.setSinkSoundProperty(handle,sinkID,soundProperty));
 165 }
 166
 167 TEST_F(routingInterfaceTest,setSourceState)
 168 {
 169     am_Source_s source;
 170     am_sourceID_t sourceID;
 171     am_Domain_s domain;
 172     am_domainID_t domainID;
 173     am_Handle_s handle;
 174     handle.handle = 0;
 175     am_SourceState_e state = SS_PAUSED;
 176     pCF.createSource(source);
 177     pCF.createDomain(domain);
 178     domain.name = "mock";
 179     domain.busname = "mock";
 180     source.domainID = 1;
 181     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 182     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 183     EXPECT_CALL(pMockInterface,asyncSetSourceState(_,sourceID,state)).WillOnce(Return(E_OK));
 184     ASSERT_EQ(E_OK, pControlReceiver.setSourceState(handle,sourceID,state));
 185     ASSERT_NE(handle.handle, 0);
 186     ASSERT_EQ(handle.handleType, H_SETSOURCESTATE);
 187 }
 188
 189 TEST_F(routingInterfaceTest,setSourceSoundProperty)
 190 {
 191     am_Source_s source;
 192     am_sourceID_t sourceID;
 193     am_Domain_s domain;
 194     am_domainID_t domainID;
 195     am_Handle_s handle;
 196     am_SoundProperty_s soundProperty;
 197     std::vector<am_Handle_s> listHandles;
 198     pCF.createSource(source);
 199     pCF.createDomain(domain);
 200     domain.name = "mock";
 201     domain.busname = "mock";
 202     source.sourceID = 2;
 203     source.domainID = 1;
 204     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 205     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 206     EXPECT_CALL(pMockInterface,asyncSetSourceSoundProperty(_,_,sourceID)).WillOnce(Return(E_OK));
 207     ASSERT_EQ(E_OK, pControlReceiver.setSourceSoundProperty(handle,sourceID,soundProperty));
 208     ASSERT_NE(handle.handle, 0);
 209     ASSERT_EQ(handle.handleType, H_SETSOURCESOUNDPROPERTY);
 210     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 211     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 212     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 213 }
 214
 215 TEST_F(routingInterfaceTest,setSinkSoundProperty)
 216 {
 217     am_Sink_s sink;
 218     am_sinkID_t sinkID;
 219     am_Domain_s domain;
 220     am_domainID_t domainID;
 221     am_Handle_s handle;
 222     am_SoundProperty_s soundProperty;
 223     std::vector<am_Handle_s> listHandles;
 224     pCF.createSink(sink);
 225     pCF.createDomain(domain);
 226     domain.name = "mock";
 227     domain.busname = "mock";
 228     sink.sinkID = 2;
 229     sink.domainID = 1;
 230     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 231     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 232     EXPECT_CALL(pMockInterface,asyncSetSinkSoundProperty(_,_,sinkID)).WillOnce(Return(E_OK));
 233     ASSERT_EQ(E_OK, pControlReceiver.setSinkSoundProperty(handle,sinkID,soundProperty));
 234     ASSERT_NE(handle.handle, 0);
 235     ASSERT_EQ(handle.handleType, H_SETSINKSOUNDPROPERTY);
 236     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 237     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 238     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 239 }
 240
 241 TEST_F(routingInterfaceTest,setSourceVolumeNoChange)
 242 {
 243     am_Source_s source;
 244     am_sourceID_t sourceID;
 245     am_Domain_s domain;
 246     am_domainID_t domainID;
 247     am_Handle_s handle;
 248     am_volume_t volume = 34;
 249     am_RampType_e rampType = RAMP_DIRECT;
 250     am_time_t rampTime = 300;
 251     std::vector<am_Handle_s> listHandles;
 252     pCF.createSource(source);
 253     pCF.createDomain(domain);
 254     domain.name = "mock";
 255     domain.busname = "mock";
 256     source.sourceID = 2;
 257     source.domainID = 1;
 258     source.volume = volume;
 259     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 260     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 261     EXPECT_CALL(pMockInterface,asyncSetSourceVolume(_,2,volume,rampType,rampTime)).Times(0);
 262     ASSERT_EQ(E_NO_CHANGE, pControlReceiver.setSourceVolume(handle,2,volume,rampType,rampTime));
 263     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 264     ASSERT_TRUE(listHandles.empty());
 265 }
 266
 267 TEST_F(routingInterfaceTest,setSourceVolume)
 268 {
 269     am_Source_s source;
 270     am_sourceID_t sourceID;
 271     am_Domain_s domain;
 272     am_domainID_t domainID;
 273     am_Handle_s handle;
 274     am_volume_t volume = 34;
 275     am_RampType_e rampType = RAMP_DIRECT;
 276     am_time_t rampTime = 300;
 277     std::vector<am_Handle_s> listHandles;
 278     pCF.createSource(source);
 279     pCF.createDomain(domain);
 280     domain.name = "mock";
 281     domain.busname = "mock";
 282     source.sourceID = 2;
 283     source.domainID = 1;
 284     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 285     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 286     EXPECT_CALL(pMockInterface,asyncSetSourceVolume(_,2,volume,rampType,rampTime)).WillOnce(Return(E_OK));
 287     ASSERT_EQ(E_OK, pControlReceiver.setSourceVolume(handle,2,volume,rampType,rampTime));
 288     ASSERT_NE(handle.handle, 0);
 289     ASSERT_EQ(handle.handleType, H_SETSOURCEVOLUME);
 290     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 291     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 292     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 293 }
 294
 295 TEST_F(routingInterfaceTest,setSinkVolumeNoChange)
 296 {
 297     am_Sink_s sink;
 298     am_sinkID_t sinkID;
 299     am_Domain_s domain;
 300     am_domainID_t domainID;
 301     am_Handle_s handle;
 302     am_volume_t volume = 34;
 303     am_RampType_e rampType = RAMP_DIRECT;
 304     am_time_t rampTime = 300;
 305     std::vector<am_Handle_s> listHandles;
 306     pCF.createSink(sink);
 307     pCF.createDomain(domain);
 308     domain.name = "mock";
 309     domain.busname = "mock";
 310     sink.sinkID = 2;
 311     sink.domainID = 1;
 312     sink.volume = volume;
 313     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 314     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 315     EXPECT_CALL(pMockInterface,asyncSetSinkVolume(_,2,volume,rampType,rampTime)).Times(0);
 316     ASSERT_EQ(E_NO_CHANGE, pControlReceiver.setSinkVolume(handle,2,volume,rampType,rampTime));
 317     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 318     ASSERT_TRUE(listHandles.empty());
 319 }
 320
 321 TEST_F(routingInterfaceTest,setSinkVolume)
 322 {
 323     am_Sink_s sink;
 324     am_sinkID_t sinkID;
 325     am_Domain_s domain;
 326     am_domainID_t domainID;
 327     am_Handle_s handle;
 328     am_volume_t volume = 34;
 329     am_RampType_e rampType = RAMP_DIRECT;
 330     am_time_t rampTime = 300;
 331     std::vector<am_Handle_s> listHandles;
 332     pCF.createSink(sink);
 333     pCF.createDomain(domain);
 334     domain.name = "mock";
 335     domain.busname = "mock";
 336     sink.sinkID = 2;
 337     sink.domainID = 1;
 338     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 339     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 340     EXPECT_CALL(pMockInterface,asyncSetSinkVolume(_,2,volume,rampType,rampTime)).WillOnce(Return(E_OK));
 341     ASSERT_EQ(E_OK, pControlReceiver.setSinkVolume(handle,2,volume,rampType,rampTime));
 342     ASSERT_NE(handle.handle, 0);
 343     ASSERT_EQ(handle.handleType, H_SETSINKVOLUME);
 344     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 345     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 346     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 347 }
 348
 349 TEST_F(routingInterfaceTest,connect)
 350 {
 351     am_Sink_s sink;
 352     am_sinkID_t sinkID;
 353     am_Domain_s domain;
 354     am_domainID_t domainID;
 355     am_Handle_s handle;
 356     am_connectionID_t connectionID;
 357     std::vector<am_Handle_s> listHandles;
 358     pCF.createSink(sink);
 359     pCF.createDomain(domain);
 360     domain.name = "mock";
 361     domain.busname = "mock";
 362     sink.sinkID = 2;
 363     sink.domainID = 1;
 364     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 365     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 366     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
 367     ASSERT_EQ(E_OK, pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 368     ASSERT_NE(handle.handle, 0);
 369     ASSERT_EQ(handle.handleType, H_CONNECT);
 370     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 371     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 372     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 373 }
 374
 375 TEST_F(routingInterfaceTest,disconnect)
 376 {
 377     am_Sink_s sink;
 378     am_sinkID_t sinkID;
 379     am_Domain_s domain;
 380     am_domainID_t domainID;
 381     am_Handle_s handle;
 382     am_connectionID_t connectionID;
 383     std::vector<am_Handle_s> listHandles;
 384     pCF.createSink(sink);
 385     pCF.createDomain(domain);
 386     domain.name = "mock";
 387     domain.busname = "mock";
 388     sink.sinkID = 2;
 389     sink.domainID = 1;
 390     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 391     ASSERT_EQ(E_OK, pDatabaseHandler.enterSinkDB(sink,sinkID));
 392     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
 393     ASSERT_EQ(E_OK, pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 394     ASSERT_EQ(E_OK, pDatabaseHandler.changeConnectionFinal(connectionID));
 395     EXPECT_CALL(pMockInterface,asyncDisconnect(_,connectionID)).WillOnce(Return(E_OK));
 396     ASSERT_EQ(E_OK, pControlReceiver.disconnect(handle,connectionID));
 397     ASSERT_NE(handle.handle, 0);
 398     ASSERT_EQ(handle.handleType, H_DISCONNECT);
 399     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 400     ASSERT_TRUE(listHandles[1].handle==handle.handle);
 401     ASSERT_TRUE(listHandles[1].handleType==handle.handleType);
 402 }
 403
 404 TEST_F(routingInterfaceTest,nothingTodisconnect)
 405 {
 406     am_Handle_s handle;
 407     am_connectionID_t connectionID = 4;
 408     std::vector<am_Handle_s> listHandles;
 409     ASSERT_EQ(E_NON_EXISTENT, pControlReceiver.disconnect(handle,connectionID));
 410     ASSERT_EQ(E_OK, pControlReceiver.getListHandles(listHandles));
 411     ASSERT_TRUE(listHandles.empty());
 412 }
 413
 414 TEST_F(routingInterfaceTest,setSourceStateNoChange)
 415 {
 416     am_Source_s source;
 417     am_sourceID_t sourceID;
 418     am_Domain_s domain;
 419     am_domainID_t domainID;
 420     am_Handle_s handle;
 421     handle.handle = 0;
 422     am_SourceState_e state = SS_PAUSED;
 423     pCF.createSource(source);
 424     pCF.createDomain(domain);
 425     domain.name = "mock";
 426     domain.busname = "mock";
 427     source.domainID = 1;
 428     source.sourceState = state;
 429     ASSERT_EQ(E_OK, pDatabaseHandler.enterDomainDB(domain,domainID));
 430     ASSERT_EQ(E_OK, pDatabaseHandler.enterSourceDB(source,sourceID));
 431     EXPECT_CALL(pMockInterface,asyncSetSourceState(_,sourceID,state)).Times(0);
 432     ASSERT_EQ(E_NO_CHANGE, pControlReceiver.setSourceState(handle,sourceID,state));
 433 }
 434
 435 int main(int argc, char **argv)
 436 {
 437     ::testing::InitGoogleTest(&argc, argv);
 438     return RUN_ALL_TESTS();
 439 }
 440