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
 415 TEST_F(routingInterfaceTest,setSourceStateNoChange)
 416 {
 417         am_Source_s source;
 418         am_sourceID_t sourceID;
 419         am_Domain_s domain;
 420         am_domainID_t domainID;
 421         am_Handle_s handle;
 422         handle.handle=0;
 423         am_SourceState_e state=SS_PAUSED;
 424         pCF.createSource(source);
 425         pCF.createDomain(domain);
 426         domain.name="mock";
 427         domain.busname="mock";
 428         source.domainID=1;
 429         source.sourceState=state;
 430         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 431         ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
 432         EXPECT_CALL(pMockInterface,asyncSetSourceState(_,sourceID,state)).Times(0);
 433     ASSERT_EQ(E_NO_CHANGE,pControlReceiver.setSourceState(handle,sourceID,state));
 434 }
 435
 436
 437 int main(int argc, char **argv)
 438 {
 439         ::testing::InitGoogleTest(&argc, argv);
 440         return RUN_ALL_TESTS();
 441 }
 442