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