AudioManagerDaemon/test/routingInterface/routingInterfaceTest.cpp

   1 /*
   2  * routingInterfaceTest.cpp
   3  *
   4  *  Created on: Dec 10, 2011
   5  *      Author: christian
   6  */
   7
   8 #include "routingInterfaceTest.h"
   9
  10 using ::testing::Field;
  11 using ::testing::Property;
  12 using ::testing::Matcher;
  13 using ::testing::Pointee;
  14 using ::testing::AllOf;
  15 using ::testing::SafeMatcherCast;
  16 using ::testing::MatcherCast;
  17 using ::testing::DefaultValue;
  18 using ::testing::Eq;
  19 using ::testing::An;
  20 using ::testing::ElementsAreArray;
  21 using ::testing::ElementsAre;
  22 using ::testing::NotNull;
  23
  24 routingInterfaceTest::routingInterfaceTest()
  25         :plistCommandPluginDirs(),
  26          pDatabaseHandler(std::string(":memory:")),
  27          pRoutingSender(plistRoutingPluginDirs),
  28          pCommandSender(plistCommandPluginDirs),
  29          pMockInterface(),
  30          pRoutingInterfaceBackdoor(),
  31          pCommandInterfaceBackdoor(),
  32          pControlReceiver(&pDatabaseHandler,&pRoutingSender,&pCommandSender),
  33          pObserver(&pCommandSender,&pRoutingSender)
  34 {
  35         pDatabaseHandler.registerObserver(&pObserver);
  36         pRoutingInterfaceBackdoor.unloadPlugins(&pRoutingSender);
  37         pRoutingInterfaceBackdoor.injectInterface(&pRoutingSender,&pMockInterface,"mock");
  38         pCommandInterfaceBackdoor.unloadPlugins(&pCommandSender);
  39 }
  40
  41 routingInterfaceTest::~routingInterfaceTest()
  42 {
  43 }
  44
  45 void routingInterfaceTest::SetUp()
  46 {
  47         DLT_REGISTER_APP("Rtest","RoutingInterfacetest");
  48         DLT_REGISTER_CONTEXT(AudioManager,"Main","Main Context");
  49         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("RoutingSendInterface Test started "));
  50
  51 }
  52
  53 void routingInterfaceTest::TearDown()
  54 {
  55         DLT_UNREGISTER_CONTEXT(AudioManager);
  56 }
  57
  58 TEST_F(routingInterfaceTest,abort)
  59 {
  60         am_Sink_s sink;
  61         am_sinkID_t sinkID;
  62         am_Domain_s domain;
  63         am_domainID_t domainID;
  64     am_Handle_s handle;
  65     am_connectionID_t connectionID;
  66     std::vector<am_Handle_s>listHandles;
  67         pCF.createSink(sink);
  68         pCF.createDomain(domain);
  69         domain.name="mock";
  70         domain.busname="mock";
  71         sink.sinkID=2;
  72         sink.domainID=1;
  73         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
  74         ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
  75     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
  76     ASSERT_EQ(E_OK,pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
  77     ASSERT_NE(handle.handle,0);
  78     ASSERT_EQ(handle.handleType,H_CONNECT);
  79     ASSERT_EQ(E_OK,pControlReceiver.getListHandles(listHandles));
  80     ASSERT_TRUE(listHandles[0].handle==handle.handle);
  81     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
  82     EXPECT_CALL(pMockInterface,asyncAbort(_)).WillOnce(Return(E_OK));
  83     ASSERT_EQ(E_OK,pControlReceiver.abortAction(handle));
  84 }
  85
  86 TEST_F(routingInterfaceTest,abortNonExistent)
  87 {
  88     EXPECT_CALL(pMockInterface,asyncAbort(_)).Times(0);
  89     am_Handle_s handle;
  90     ASSERT_EQ(E_NON_EXISTENT,pControlReceiver.abortAction(handle));
  91 }
  92
  93 TEST_F(routingInterfaceTest,alreadyConnected)
  94 {
  95         am_Sink_s sink;
  96         am_sinkID_t sinkID;
  97         am_Domain_s domain;
  98         am_domainID_t domainID;
  99         pCF.createSink(sink);
 100         pCF.createDomain(domain);
 101         domain.name="mock";
 102         domain.busname="mock";
 103         sink.sinkID=2;
 104         sink.domainID=1;
 105         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 106         ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
 107     EXPECT_CALL(pMockInterface,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
 108     am_Handle_s handle;
 109     am_connectionID_t connectionID;
 110     ASSERT_EQ(E_OK,pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 111     ASSERT_EQ(E_OK,pDatabaseHandler.changeConnectionFinal(connectionID));
 112     ASSERT_EQ(E_ALREADY_EXISTS,pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 113     ASSERT_NE(handle.handle,0);
 114     ASSERT_EQ(handle.handleType,H_CONNECT);
 115 }
 116
 117 TEST_F(routingInterfaceTest,setSinkSoundPropertyNoChange)
 118 {
 119         am_Sink_s sink;
 120         am_sinkID_t sinkID;
 121         am_Domain_s domain;
 122         am_domainID_t domainID;
 123     am_Handle_s handle;
 124     am_SoundProperty_s soundProperty;
 125     soundProperty.type=SP_TREBLE;
 126     soundProperty.value=23;
 127     std::vector<am_Handle_s>listHandles;
 128         pCF.createSink(sink);
 129         pCF.createDomain(domain);
 130         domain.name="mock";
 131         domain.busname="mock";
 132         sink.sinkID=2;
 133         sink.domainID=1;
 134         sink.listSoundProperties.push_back(soundProperty);
 135         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 136         ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
 137     EXPECT_CALL(pMockInterface,asyncSetSinkSoundProperty(_,_,sinkID)).Times(0);
 138     ASSERT_EQ(E_NO_CHANGE,pControlReceiver.setSinkSoundProperty(handle,sinkID,soundProperty));
 139 }
 140
 141 TEST_F(routingInterfaceTest,setSourceState)
 142 {
 143         am_Source_s source;
 144         am_sourceID_t sourceID;
 145         am_Domain_s domain;
 146         am_domainID_t domainID;
 147         am_Handle_s handle;
 148         handle.handle=0;
 149         am_SourceState_e state=SS_PAUSED;
 150         pCF.createSource(source);
 151         pCF.createDomain(domain);
 152         domain.name="mock";
 153         domain.busname="mock";
 154         source.domainID=1;
 155         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 156         ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
 157         EXPECT_CALL(pMockInterface,asyncSetSourceState(_,sourceID,state)).WillOnce(Return(E_OK));
 158     ASSERT_EQ(E_OK,pControlReceiver.setSourceState(handle,sourceID,state));
 159     ASSERT_NE(handle.handle,0);
 160     ASSERT_EQ(handle.handleType,H_SETSOURCESTATE);
 161 }
 162
 163 TEST_F(routingInterfaceTest,setSourceSoundProperty)
 164 {
 165         am_Source_s source;
 166         am_sourceID_t sourceID;
 167         am_Domain_s domain;
 168         am_domainID_t domainID;
 169     am_Handle_s handle;
 170     am_SoundProperty_s soundProperty;
 171     std::vector<am_Handle_s>listHandles;
 172         pCF.createSource(source);
 173         pCF.createDomain(domain);
 174         domain.name="mock";
 175         domain.busname="mock";
 176         source.sourceID=2;
 177         source.domainID=1;
 178         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 179         ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
 180     EXPECT_CALL(pMockInterface,asyncSetSourceSoundProperty(_,_,sourceID)).WillOnce(Return(E_OK));
 181     ASSERT_EQ(E_OK,pControlReceiver.setSourceSoundProperty(handle,sourceID,soundProperty));
 182     ASSERT_NE(handle.handle,0);
 183     ASSERT_EQ(handle.handleType,H_SETSOURCESOUNDPROPERTY);
 184     ASSERT_EQ(E_OK,pControlReceiver.getListHandles(listHandles));
 185     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 186     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 187 }
 188
 189 TEST_F(routingInterfaceTest,setSinkSoundProperty)
 190 {
 191         am_Sink_s sink;
 192         am_sinkID_t sinkID;
 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.createSink(sink);
 199         pCF.createDomain(domain);
 200         domain.name="mock";
 201         domain.busname="mock";
 202         sink.sinkID=2;
 203         sink.domainID=1;
 204         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 205         ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
 206     EXPECT_CALL(pMockInterface,asyncSetSinkSoundProperty(_,_,sinkID)).WillOnce(Return(E_OK));
 207     ASSERT_EQ(E_OK,pControlReceiver.setSinkSoundProperty(handle,sinkID,soundProperty));
 208     ASSERT_NE(handle.handle,0);
 209     ASSERT_EQ(handle.handleType,H_SETSINKSOUNDPROPERTY);
 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,setSourceVolumeNoChange)
 216 {
 217         am_Source_s source;
 218         am_sourceID_t sourceID;
 219         am_Domain_s domain;
 220         am_domainID_t domainID;
 221     am_Handle_s handle;
 222     am_volume_t volume=34;
 223     am_RampType_e rampType=RAMP_DIRECT;
 224     am_time_t rampTime=300;
 225     std::vector<am_Handle_s>listHandles;
 226         pCF.createSource(source);
 227         pCF.createDomain(domain);
 228         domain.name="mock";
 229         domain.busname="mock";
 230         source.sourceID=2;
 231         source.domainID=1;
 232         source.volume=volume;
 233         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 234         ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
 235     EXPECT_CALL(pMockInterface,asyncSetSourceVolume(_,2,volume,rampType,rampTime)).Times(0);
 236     ASSERT_EQ(E_NO_CHANGE,pControlReceiver.setSourceVolume(handle,2,volume,rampType,rampTime));
 237     ASSERT_EQ(E_OK,pControlReceiver.getListHandles(listHandles));
 238     ASSERT_TRUE(listHandles.empty());
 239 }
 240
 241 TEST_F(routingInterfaceTest,setSourceVolume)
 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         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 259         ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
 260     EXPECT_CALL(pMockInterface,asyncSetSourceVolume(_,2,volume,rampType,rampTime)).WillOnce(Return(E_OK));
 261     ASSERT_EQ(E_OK,pControlReceiver.setSourceVolume(handle,2,volume,rampType,rampTime));
 262     ASSERT_NE(handle.handle,0);
 263     ASSERT_EQ(handle.handleType,H_SETSOURCEVOLUME);
 264     ASSERT_EQ(E_OK,pControlReceiver.getListHandles(listHandles));
 265     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 266     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 267 }
 268
 269 TEST_F(routingInterfaceTest,setSinkVolumeNoChange)
 270 {
 271         am_Sink_s sink;
 272         am_sinkID_t sinkID;
 273         am_Domain_s domain;
 274         am_domainID_t domainID;
 275     am_Handle_s handle;
 276     am_volume_t volume=34;
 277     am_RampType_e rampType=RAMP_DIRECT;
 278     am_time_t rampTime=300;
 279     std::vector<am_Handle_s>listHandles;
 280         pCF.createSink(sink);
 281         pCF.createDomain(domain);
 282         domain.name="mock";
 283         domain.busname="mock";
 284         sink.sinkID=2;
 285         sink.domainID=1;
 286         sink.volume=volume;
 287         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 288         ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
 289     EXPECT_CALL(pMockInterface,asyncSetSinkVolume(_,2,volume,rampType,rampTime)).Times(0);
 290     ASSERT_EQ(E_NO_CHANGE,pControlReceiver.setSinkVolume(handle,2,volume,rampType,rampTime));
 291     ASSERT_EQ(E_OK,pControlReceiver.getListHandles(listHandles));
 292     ASSERT_TRUE(listHandles.empty());
 293 }
 294
 295 TEST_F(routingInterfaceTest,setSinkVolume)
 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         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 313         ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
 314     EXPECT_CALL(pMockInterface,asyncSetSinkVolume(_,2,volume,rampType,rampTime)).WillOnce(Return(E_OK));
 315     ASSERT_EQ(E_OK,pControlReceiver.setSinkVolume(handle,2,volume,rampType,rampTime));
 316     ASSERT_NE(handle.handle,0);
 317     ASSERT_EQ(handle.handleType,H_SETSINKVOLUME);
 318     ASSERT_EQ(E_OK,pControlReceiver.getListHandles(listHandles));
 319     ASSERT_TRUE(listHandles[0].handle==handle.handle);
 320     ASSERT_TRUE(listHandles[0].handleType==handle.handleType);
 321 }
 322
 323 TEST_F(routingInterfaceTest,connect)
 324 {
 325         am_Sink_s sink;
 326         am_sinkID_t sinkID;
 327         am_Domain_s domain;
 328         am_domainID_t domainID;
 329     am_Handle_s handle;
 330     am_connectionID_t connectionID;
 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,asyncConnect(_,_,1,sinkID,CF_ANALOG)).WillOnce(Return(E_OK));
 341     ASSERT_EQ(E_OK,pControlReceiver.connect(handle,connectionID,CF_ANALOG,1,2));
 342     ASSERT_NE(handle.handle,0);
 343     ASSERT_EQ(handle.handleType,H_CONNECT);
 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,disconnect)
 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_EQ(E_OK,pDatabaseHandler.changeConnectionFinal(connectionID));
 369     EXPECT_CALL(pMockInterface,asyncDisconnect(_,connectionID)).WillOnce(Return(E_OK));
 370     ASSERT_EQ(E_OK,pControlReceiver.disconnect(handle,connectionID));
 371     ASSERT_NE(handle.handle,0);
 372     ASSERT_EQ(handle.handleType,H_DISCONNECT);
 373     ASSERT_EQ(E_OK,pControlReceiver.getListHandles(listHandles));
 374     ASSERT_TRUE(listHandles[1].handle==handle.handle);
 375     ASSERT_TRUE(listHandles[1].handleType==handle.handleType);
 376 }
 377
 378 TEST_F(routingInterfaceTest,nothingTodisconnect)
 379 {
 380         am_Handle_s handle;
 381         am_connectionID_t connectionID=4;
 382     std::vector<am_Handle_s>listHandles;
 383     ASSERT_EQ(E_NON_EXISTENT,pControlReceiver.disconnect(handle,connectionID));
 384     ASSERT_EQ(E_OK,pControlReceiver.getListHandles(listHandles));
 385     ASSERT_TRUE(listHandles.empty());
 386 }
 387
 388
 389 TEST_F(routingInterfaceTest,setSourceStateNoChange)
 390 {
 391         am_Source_s source;
 392         am_sourceID_t sourceID;
 393         am_Domain_s domain;
 394         am_domainID_t domainID;
 395         am_Handle_s handle;
 396         handle.handle=0;
 397         am_SourceState_e state=SS_PAUSED;
 398         pCF.createSource(source);
 399         pCF.createDomain(domain);
 400         domain.name="mock";
 401         domain.busname="mock";
 402         source.domainID=1;
 403         source.sourceState=state;
 404         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 405         ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
 406         EXPECT_CALL(pMockInterface,asyncSetSourceState(_,sourceID,state)).Times(0);
 407     ASSERT_EQ(E_NO_CHANGE,pControlReceiver.setSourceState(handle,sourceID,state));
 408 }
 409
 410
 411 int main(int argc, char **argv)
 412 {
 413         ::testing::InitGoogleTest(&argc, argv);
 414         return RUN_ALL_TESTS();
 415 }
 416