AudioManagerDaemon/test/controlInterface/controlInterfaceTest.cpp

   1 /*
   2  * routingInterfaceTest.cpp
   3  *
   4  *  Created on: Dec 10, 2011
   5  *      Author: christian
   6  */
   7
   8 #include "controlInterfaceTest.h"
   9
  10
  11
  12 controlInterfaceTest::controlInterfaceTest()
  13         :plistCommandPluginDirs(),
  14          plistRoutingPluginDirs(),
  15          pDatabaseHandler(std::string(":memory:")),
  16          pRoutingSender(plistRoutingPluginDirs),
  17          pCommandSender(plistCommandPluginDirs),
  18          pMockControlInterface(),
  19          pMockRoutingInterface(),
  20          pControlSender(std::string("")),
  21          pRoutingInterfaceBackdoor(),
  22          pCommandInterfaceBackdoor(),
  23          pControlInterfaceBackdoor(),
  24          pDatabaseObserver(&pCommandSender,&pRoutingSender),
  25          pControlReceiver(&pDatabaseHandler,&pRoutingSender,&pCommandSender),
  26          pRoutingReceiver(&pDatabaseHandler,&pRoutingSender,&pControlSender)
  27 {
  28         pDatabaseHandler.registerObserver(&pDatabaseObserver);
  29         pRoutingInterfaceBackdoor.unloadPlugins(&pRoutingSender);
  30         pCommandInterfaceBackdoor.unloadPlugins(&pCommandSender);
  31         pControlInterfaceBackdoor.replaceController(&pControlSender,&pMockControlInterface);
  32         pRoutingInterfaceBackdoor.injectInterface(&pRoutingSender,&pMockRoutingInterface,"mock");
  33
  34 }
  35
  36 controlInterfaceTest::~controlInterfaceTest()
  37 {
  38 }
  39
  40 void controlInterfaceTest::SetUp()
  41 {
  42         DLT_REGISTER_APP("Rtest","RoutingInterfacetest");
  43         DLT_REGISTER_CONTEXT(AudioManager,"Main","Main Context");
  44         DLT_LOG(AudioManager,DLT_LOG_INFO, DLT_STRING("RoutingSendInterface Test started "));
  45
  46 }
  47
  48 void controlInterfaceTest::TearDown()
  49 {
  50         DLT_UNREGISTER_CONTEXT(AudioManager);
  51 }
  52
  53 TEST_F(controlInterfaceTest,registerDomain)
  54 {
  55
  56         am_Domain_s domain;
  57         am_domainID_t domainID;
  58         pCF.createDomain(domain);
  59         EXPECT_CALL(pMockControlInterface,hookSystemRegisterDomain(_,_)).WillRepeatedly(DoAll(SetArgReferee<1>(2),Return(E_OK)));
  60         ASSERT_EQ(E_OK,pRoutingReceiver.registerDomain(domain,domainID));
  61         ASSERT_EQ(domainID,2);
  62 }
  63
  64 TEST_F(controlInterfaceTest,deregisterDomain)
  65 {
  66         am_domainID_t domainID=34;
  67         EXPECT_CALL(pMockControlInterface,hookSystemDeregisterDomain(34)).WillRepeatedly(Return(E_OK));
  68         ASSERT_EQ(E_OK,pRoutingReceiver.deregisterDomain(domainID));
  69 }
  70
  71 TEST_F(controlInterfaceTest,registerSink)
  72 {
  73         am_Sink_s sink;
  74         am_sinkID_t sinkID;
  75         pCF.createSink(sink);
  76         EXPECT_CALL(pMockControlInterface,hookSystemRegisterSink(_,_)).WillRepeatedly(DoAll(SetArgReferee<1>(2),Return(E_OK)));
  77         ASSERT_EQ(E_OK,pRoutingReceiver.registerSink(sink,sinkID));
  78         ASSERT_EQ(sinkID,2);
  79 }
  80
  81 TEST_F(controlInterfaceTest,deregisterSink)
  82 {
  83         am_sinkID_t sinkID=12;
  84         EXPECT_CALL(pMockControlInterface,hookSystemDeregisterSink(12)).WillRepeatedly(Return(E_OK));
  85         ASSERT_EQ(E_OK,pRoutingReceiver.deregisterSink(sinkID));
  86 }
  87
  88 TEST_F(controlInterfaceTest,registerSource)
  89 {
  90         am_Source_s source;
  91         am_sourceID_t sourceID;
  92         pCF.createSource(source);
  93         EXPECT_CALL(pMockControlInterface,hookSystemRegisterSource(_,_)).WillRepeatedly(DoAll(SetArgReferee<1>(2),Return(E_OK)));
  94         ASSERT_EQ(E_OK,pRoutingReceiver.registerSource(source,sourceID));
  95         ASSERT_EQ(sourceID,2);
  96 }
  97
  98 TEST_F(controlInterfaceTest,deregisterSource)
  99 {
 100         am_sourceID_t sourceID=12;
 101         EXPECT_CALL(pMockControlInterface,hookSystemDeregisterSource(12)).WillRepeatedly(Return(E_OK));
 102         ASSERT_EQ(E_OK,pRoutingReceiver.deregisterSource(sourceID));
 103 }
 104
 105 TEST_F(controlInterfaceTest,registerGateway)
 106 {
 107         am_Gateway_s gateway;
 108         am_gatewayID_t gatewayID;
 109         pCF.createGateway(gateway);
 110         EXPECT_CALL(pMockControlInterface,hookSystemRegisterGateway(_,_)).WillRepeatedly(DoAll(SetArgReferee<1>(2),Return(E_OK)));
 111         ASSERT_EQ(E_OK,pRoutingReceiver.registerGateway(gateway,gatewayID));
 112         ASSERT_EQ(gatewayID,2);
 113 }
 114
 115 TEST_F(controlInterfaceTest,deregisterGateway)
 116 {
 117         am_gatewayID_t gatewayID=12;
 118         EXPECT_CALL(pMockControlInterface,hookSystemDeregisterGateway(12)).WillRepeatedly(Return(E_OK));
 119         ASSERT_EQ(E_OK,pRoutingReceiver.deregisterGateway(gatewayID));
 120 }
 121
 122
 123 TEST_F(controlInterfaceTest,ackConnect)
 124 {
 125         am_Connection_s connection;
 126         am_connectionID_t connectionID;
 127         am_Sink_s sink;
 128         am_sinkID_t sinkID;
 129         am_Domain_s domain;
 130         am_domainID_t domainID;
 131         std::vector<am_Connection_s> connectionList;
 132         std::vector<am_Handle_s> handlesList;
 133         am_Handle_s handle;
 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(pMockRoutingInterface,asyncConnect(_,1,2,2,CF_STEREO)).WillOnce(Return(E_OK));
 143         ASSERT_EQ(E_OK,pControlReceiver.connect(handle,connectionID,CF_STEREO,2,2));
 144         ASSERT_EQ(handle.handleType,H_CONNECT);
 145         ASSERT_EQ(handle.handle,1);
 146         ASSERT_EQ(connectionID,1);
 147         ASSERT_EQ(E_OK,pControlReceiver.getListHandles(handlesList));
 148         ASSERT_EQ(handlesList[0].handle,handle.handle);
 149         ASSERT_EQ(handlesList[0].handleType,handle.handleType);
 150         ASSERT_EQ(E_OK,pDatabaseHandler.getListConnections(connectionList));
 151         ASSERT_TRUE(connectionList.empty()); //ok, because Ack did not come
 152         EXPECT_CALL(pMockControlInterface,cbAckConnect(_,E_OK)).Times(1);
 153         pRoutingReceiver.ackConnect(handle,connectionID,E_OK);
 154         ASSERT_EQ(E_OK,pControlReceiver.getListHandles(handlesList));
 155         ASSERT_TRUE(handlesList.empty());
 156         ASSERT_EQ(E_OK,pDatabaseHandler.getListConnections(connectionList));
 157         ASSERT_TRUE(!connectionList.empty()); //ok, because Ack did not come
 158
 159 }
 160
 161 TEST_F(controlInterfaceTest,ackDisconnect)
 162 {
 163         am_Connection_s connection;
 164         am_connectionID_t connectionID;
 165         am_Sink_s sink;
 166         am_sinkID_t sinkID;
 167         am_Domain_s domain;
 168         am_domainID_t domainID;
 169         std::vector<am_Connection_s> connectionList;
 170         std::vector<am_Handle_s> handlesList;
 171         am_Handle_s handle;
 172         pCF.createSink(sink);
 173         pCF.createDomain(domain);
 174         domain.name="mock";
 175         domain.busname="mock";
 176         sink.sinkID=2;
 177         sink.domainID=1;
 178         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 179         ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
 180         EXPECT_CALL(pMockRoutingInterface,asyncConnect(_,1,2,2,CF_STEREO)).WillOnce(Return(E_OK));
 181         ASSERT_EQ(E_OK,pControlReceiver.connect(handle,connectionID,CF_STEREO,2,2));
 182         EXPECT_CALL(pMockControlInterface,cbAckConnect(_,E_OK)).Times(1);
 183         pRoutingReceiver.ackConnect(handle,connectionID,E_OK);
 184         EXPECT_CALL(pMockRoutingInterface,asyncDisconnect(_,1)).WillOnce(Return(E_OK));
 185         ASSERT_EQ(E_OK,pControlReceiver.disconnect(handle,1));
 186         EXPECT_CALL(pMockControlInterface,cbAckDisconnect(_,E_OK)).Times(1);
 187         pRoutingReceiver.ackDisconnect(handle,connectionID,E_OK);
 188         ASSERT_EQ(E_OK,pControlReceiver.getListHandles(handlesList));
 189         ASSERT_TRUE(handlesList.empty());
 190         ASSERT_EQ(E_OK,pDatabaseHandler.getListConnections(connectionList));
 191         ASSERT_TRUE(connectionList.empty()); //ok, because Ack did not come
 192 }
 193
 194 TEST_F(controlInterfaceTest,setSourceState)
 195 {
 196
 197         am_Source_s source;
 198         am_sourceID_t sourceID;
 199         am_Domain_s domain;
 200         am_domainID_t domainID;
 201         std::vector<am_Handle_s> handlesList;
 202         am_Handle_s handle;
 203         am_SourceState_e state;
 204         pCF.createSource(source);
 205         pCF.createDomain(domain);
 206         domain.name="mock";
 207         domain.busname="mock";
 208         source.sourceID=2;
 209         source.domainID=1;
 210         ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
 211         ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
 212         EXPECT_CALL(pMockRoutingInterface,asyncSetSourceState(_,2,SS_PAUSED)).WillOnce(Return(E_OK));
 213         ASSERT_EQ(E_OK,pControlReceiver.setSourceState(handle,source.sourceID,SS_PAUSED));
 214         ASSERT_EQ(E_OK,pControlReceiver.getListHandles(handlesList));
 215         ASSERT_EQ(handlesList[0].handle,handle.handle);
 216         ASSERT_EQ(handlesList[0].handleType,handle.handleType);
 217         ASSERT_EQ(E_OK,pDatabaseHandler.getSoureState(source.sourceID,state));
 218         ASSERT_EQ(state,SS_ON); //ok, since value will be added after the ack!
 219         EXPECT_CALL(pMockControlInterface,cbAckSetSourceState(_,E_OK)).Times(1);
 220         pRoutingReceiver.ackSetSourceState(handle,E_OK);
 221         ASSERT_EQ(E_OK,pDatabaseHandler.getSoureState(source.sourceID,state));
 222         ASSERT_EQ(state,SS_PAUSED);
 223
 224 }
 225
 226
 227 int main(int argc, char **argv)
 228 {
 229         ::testing::InitGoogleTest(&argc, argv);
 230         return RUN_ALL_TESTS();
 231 }
 232