.

5 files changed, 286 insertions, 40 deletions

diff --git a/AudioManagerDaemon/test/controlInterface/MockControlInterface.h b/AudioManagerDaemon/test/controlInterface/MockInterfaces.h
index 28d26af..5b1cf2c 100644
--- a/AudioManagerDaemon/test/controlInterface/MockControlInterface.h
+++ b/AudioManagerDaemon/test/controlInterface/MockInterfaces.h
@@ -9,11 +9,45 @@
 #define MOCKROUTINGINTERFACE_H_
 
 #include <control/ControlSendInterface.h>
+#include <routing/RoutingSendInterface.h>
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
 namespace am {
 
+class MockRoutingSendInterface : public RoutingSendInterface {
+ public:
+  MOCK_METHOD1(startupRoutingInterface,
+	  void(RoutingReceiveInterface* routingreceiveinterface));
+  MOCK_METHOD0(routingInterfacesReady,
+	  void());
+  MOCK_METHOD0(routingInterfacesRundown,
+	  void());
+  MOCK_METHOD1(asyncAbort,
+	  am_Error_e(const am_Handle_s handle));
+  MOCK_METHOD5(asyncConnect,
+	  am_Error_e(const am_Handle_s handle, const am_connectionID_t connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_ConnectionFormat_e connectionFormat));
+  MOCK_METHOD2(asyncDisconnect,
+	  am_Error_e(const am_Handle_s handle, const am_connectionID_t connectionID));
+  MOCK_METHOD5(asyncSetSinkVolume,
+	  am_Error_e(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time));
+  MOCK_METHOD5(asyncSetSourceVolume,
+	  am_Error_e(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time));
+  MOCK_METHOD3(asyncSetSourceState,
+	  am_Error_e(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SourceState_e state));
+  MOCK_METHOD3(asyncSetSinkSoundProperty,
+	  am_Error_e(const am_Handle_s handle, const am_SoundProperty_s& soundProperty, const am_sinkID_t sinkID));
+  MOCK_METHOD3(asyncSetSourceSoundProperty,
+	  am_Error_e(const am_Handle_s handle, const am_SoundProperty_s& soundProperty, const am_sourceID_t sourceID));
+  MOCK_METHOD5(asyncCrossFade,
+	  am_Error_e(const am_Handle_s handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_RampType_e rampType, const am_time_t time));
+  MOCK_METHOD2(setDomainState,
+	  am_Error_e(const am_domainID_t domainID, const am_DomainState_e domainState));
+  MOCK_CONST_METHOD1(returnBusName,
+	  am_Error_e(std::string& BusName));
+};
+
+
 class MockControlSendInterface : public ControlSendInterface {
  public:
   MOCK_METHOD1(startupController,
diff --git a/AudioManagerDaemon/test/controlInterface/controlInterfaceTest.cpp b/AudioManagerDaemon/test/controlInterface/controlInterfaceTest.cpp
index 1a8c48b..8c57cfd 100644
--- a/AudioManagerDaemon/test/controlInterface/controlInterfaceTest.cpp
+++ b/AudioManagerDaemon/test/controlInterface/controlInterfaceTest.cpp
@@ -7,30 +7,14 @@
 
 #include "controlInterfaceTest.h"
 
-using namespace am;
-
-using ::testing::Field;
-using ::testing::Property;
-using ::testing::Matcher;
-using ::testing::Pointee;
-using ::testing::AllOf;
-using ::testing::SafeMatcherCast;
-using ::testing::MatcherCast;
-using ::testing::DefaultValue;
-using ::testing::Eq;
-using ::testing::An;
-using ::testing::ElementsAreArray;
-using ::testing::ElementsAre;
-using ::testing::NotNull;
-using ::testing::Assign;
-using ::testing::SetArgReferee;
-using ::testing::DoAll;
+
 
 controlInterfaceTest::controlInterfaceTest()
 	:pDatabaseHandler(),
 	 pRoutingSender(),
 	 pCommandSender(),
-	 pMockInterface(),
+	 pMockControlInterface(),
+	 pMockRoutingInterface(),
 	 pControlSender(),
 	 pRoutingInterfaceBackdoor(),
 	 pCommandInterfaceBackdoor(),
@@ -42,7 +26,8 @@ controlInterfaceTest::controlInterfaceTest()
 	pDatabaseHandler.registerObserver(&pObserver);
 	pRoutingInterfaceBackdoor.unloadPlugins(&pRoutingSender);
 	pCommandInterfaceBackdoor.unloadPlugins(&pCommandSender);
-	pControlInterfaceBackdoor.replaceController(&pControlSender,&pMockInterface);
+	pControlInterfaceBackdoor.replaceController(&pControlSender,&pMockControlInterface);
+	pRoutingInterfaceBackdoor.injectInterface(&pRoutingSender,&pMockRoutingInterface,"mock");
 
 }
 
@@ -69,8 +54,169 @@ TEST_F(controlInterfaceTest,registerDomain)
 	am_Domain_s domain;
 	am_domainID_t domainID;
 	pCF.createDomain(domain);
-	EXPECT_CALL(pMockInterface,hookSystemRegisterDomain(_,_)).WillRepeatedly(DoAll(SetArgReferee<1>(2),Return(E_OK)));
+	EXPECT_CALL(pMockControlInterface,hookSystemRegisterDomain(_,_)).WillRepeatedly(DoAll(SetArgReferee<1>(2),Return(E_OK)));
 	ASSERT_EQ(E_OK,pRoutingReceiver.registerDomain(domain,domainID));
+	ASSERT_EQ(domainID,2);
+}
+
+TEST_F(controlInterfaceTest,deregisterDomain)
+{
+	am_domainID_t domainID=34;
+	EXPECT_CALL(pMockControlInterface,hookSystemDeregisterDomain(34)).WillRepeatedly(Return(E_OK));
+	ASSERT_EQ(E_OK,pRoutingReceiver.deregisterDomain(domainID));
+}
+
+TEST_F(controlInterfaceTest,registerSink)
+{
+	am_Sink_s sink;
+	am_sinkID_t sinkID;
+	pCF.createSink(sink);
+	EXPECT_CALL(pMockControlInterface,hookSystemRegisterSink(_,_)).WillRepeatedly(DoAll(SetArgReferee<1>(2),Return(E_OK)));
+	ASSERT_EQ(E_OK,pRoutingReceiver.registerSink(sink,sinkID));
+	ASSERT_EQ(sinkID,2);
+}
+
+TEST_F(controlInterfaceTest,deregisterSink)
+{
+	am_sinkID_t sinkID=12;
+	EXPECT_CALL(pMockControlInterface,hookSystemDeregisterSink(12)).WillRepeatedly(Return(E_OK));
+	ASSERT_EQ(E_OK,pRoutingReceiver.deregisterSink(sinkID));
+}
+
+TEST_F(controlInterfaceTest,registerSource)
+{
+	am_Source_s source;
+	am_sourceID_t sourceID;
+	pCF.createSource(source);
+	EXPECT_CALL(pMockControlInterface,hookSystemRegisterSource(_,_)).WillRepeatedly(DoAll(SetArgReferee<1>(2),Return(E_OK)));
+	ASSERT_EQ(E_OK,pRoutingReceiver.registerSource(source,sourceID));
+	ASSERT_EQ(sourceID,2);
+}
+
+TEST_F(controlInterfaceTest,deregisterSource)
+{
+	am_sourceID_t sourceID=12;
+	EXPECT_CALL(pMockControlInterface,hookSystemDeregisterSource(12)).WillRepeatedly(Return(E_OK));
+	ASSERT_EQ(E_OK,pRoutingReceiver.deregisterSource(sourceID));
+}
+
+TEST_F(controlInterfaceTest,registerGateway)
+{
+	am_Gateway_s gateway;
+	am_gatewayID_t gatewayID;
+	pCF.createGateway(gateway);
+	EXPECT_CALL(pMockControlInterface,hookSystemRegisterGateway(_,_)).WillRepeatedly(DoAll(SetArgReferee<1>(2),Return(E_OK)));
+	ASSERT_EQ(E_OK,pRoutingReceiver.registerGateway(gateway,gatewayID));
+	ASSERT_EQ(gatewayID,2);
+}
+
+TEST_F(controlInterfaceTest,deregisterGateway)
+{
+	am_gatewayID_t gatewayID=12;
+	EXPECT_CALL(pMockControlInterface,hookSystemDeregisterGateway(12)).WillRepeatedly(Return(E_OK));
+	ASSERT_EQ(E_OK,pRoutingReceiver.deregisterGateway(gatewayID));
+}
+
+
+TEST_F(controlInterfaceTest,ackConnect)
+{
+	am_Connection_s connection;
+	am_connectionID_t connectionID;
+	am_Sink_s sink;
+	am_sinkID_t sinkID;
+	am_Domain_s domain;
+	am_domainID_t domainID;
+	std::vector<am_Connection_s> connectionList;
+	std::vector<am_Handle_s> handlesList;
+	am_Handle_s handle;
+	pCF.createSink(sink);
+	pCF.createDomain(domain);
+	domain.name="mock";
+	domain.busname="mock";
+	sink.sinkID=2;
+	sink.domainID=1;
+	ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
+	ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
+	EXPECT_CALL(pMockRoutingInterface,asyncConnect(_,1,2,2,CF_STEREO)).WillOnce(Return(E_OK));
+	ASSERT_EQ(E_OK,pControlReceiver.connect(handle,connectionID,CF_STEREO,2,2));
+	ASSERT_EQ(handle.handleType,H_CONNECT);
+	ASSERT_EQ(handle.handle,1);
+	ASSERT_EQ(connectionID,1);
+	ASSERT_EQ(E_OK,pControlReceiver.getListHandles(handlesList));
+	ASSERT_EQ(handlesList[0].handle,handle.handle);
+	ASSERT_EQ(handlesList[0].handleType,handle.handleType);
+	ASSERT_EQ(E_OK,pDatabaseHandler.getListConnections(connectionList));
+	ASSERT_TRUE(connectionList.empty()); //ok, because Ack did not come
+	EXPECT_CALL(pMockControlInterface,cbAckConnect(_,E_OK)).Times(1);
+	pRoutingReceiver.ackConnect(handle,connectionID,E_OK);
+	ASSERT_EQ(E_OK,pControlReceiver.getListHandles(handlesList));
+	ASSERT_TRUE(handlesList.empty());
+	ASSERT_EQ(E_OK,pDatabaseHandler.getListConnections(connectionList));
+	ASSERT_TRUE(!connectionList.empty()); //ok, because Ack did not come
+
+}
+
+TEST_F(controlInterfaceTest,ackDisconnect)
+{
+	am_Connection_s connection;
+	am_connectionID_t connectionID;
+	am_Sink_s sink;
+	am_sinkID_t sinkID;
+	am_Domain_s domain;
+	am_domainID_t domainID;
+	std::vector<am_Connection_s> connectionList;
+	std::vector<am_Handle_s> handlesList;
+	am_Handle_s handle;
+	pCF.createSink(sink);
+	pCF.createDomain(domain);
+	domain.name="mock";
+	domain.busname="mock";
+	sink.sinkID=2;
+	sink.domainID=1;
+	ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
+	ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
+	EXPECT_CALL(pMockRoutingInterface,asyncConnect(_,1,2,2,CF_STEREO)).WillOnce(Return(E_OK));
+	ASSERT_EQ(E_OK,pControlReceiver.connect(handle,connectionID,CF_STEREO,2,2));
+	EXPECT_CALL(pMockControlInterface,cbAckConnect(_,E_OK)).Times(1);
+	pRoutingReceiver.ackConnect(handle,connectionID,E_OK);
+	EXPECT_CALL(pMockRoutingInterface,asyncDisconnect(_,1)).WillOnce(Return(E_OK));
+	ASSERT_EQ(E_OK,pControlReceiver.disconnect(handle,1));
+	EXPECT_CALL(pMockControlInterface,cbAckDisconnect(_,E_OK)).Times(1);
+	pRoutingReceiver.ackDisconnect(handle,connectionID,E_OK);
+	ASSERT_EQ(E_OK,pControlReceiver.getListHandles(handlesList));
+	ASSERT_TRUE(handlesList.empty());
+	ASSERT_EQ(E_OK,pDatabaseHandler.getListConnections(connectionList));
+	ASSERT_TRUE(connectionList.empty()); //ok, because Ack did not come
+}
+
+TEST_F(controlInterfaceTest,setSourceState)
+{
+
+	am_Source_s source;
+	am_sourceID_t sourceID;
+	am_Domain_s domain;
+	am_domainID_t domainID;
+	std::vector<am_Handle_s> handlesList;
+	am_Handle_s handle;
+	am_SourceState_e state;
+	pCF.createSource(source);
+	pCF.createDomain(domain);
+	domain.name="mock";
+	domain.busname="mock";
+	source.sourceID=2;
+	source.domainID=1;
+	ASSERT_EQ(E_OK,pDatabaseHandler.enterDomainDB(domain,domainID));
+	ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
+	EXPECT_CALL(pMockRoutingInterface,asyncSetSourceState(_,2,SS_PAUSED));
+	ASSERT_EQ(E_OK,pControlReceiver.setSourceState(handle,source.sourceID,SS_PAUSED));
+	ASSERT_EQ(E_OK,pControlReceiver.getListHandles(handlesList));
+	ASSERT_EQ(handlesList[0].handle,handle.handle);
+	ASSERT_EQ(handlesList[0].handleType,handle.handleType);
+	ASSERT_EQ(E_OK,pDatabaseHandler.getSoureState(source.sourceID,state));
+	ASSERT_EQ(state,SS_PAUSED);
+	EXPECT_CALL(pMockControlInterface,cbAckSetSourceState(_,E_OK)).Times(1);
+	//pRoutingReceiver.ackSetSourceState(handle,SS_PAUSED);
+
 }
 
 
diff --git a/AudioManagerDaemon/test/controlInterface/controlInterfaceTest.h b/AudioManagerDaemon/test/controlInterface/controlInterfaceTest.h
index 2b73af6..d85c1f0 100644
--- a/AudioManagerDaemon/test/controlInterface/controlInterfaceTest.h
+++ b/AudioManagerDaemon/test/controlInterface/controlInterfaceTest.h
@@ -15,14 +15,16 @@
 #include <string>
 #include <vector>
 #include <set>
-#include "MockControlInterface.h"
+#include "MockInterfaces.h"
 #include "DatabaseHandler.h"
 #include "ControlReceiver.h"
-#include "ControlSender.h"
-#include "Observer.h"
 #include "RoutingReceiver.h"
+#include "Observer.h"
+#include "ControlSender.h"
+#include "RoutingSender.h"
 #include "../RoutingInterfaceBackdoor.h"
 #include "../CommandInterfaceBackdoor.h"
+#include "../ControlInterfaceBackdoor.h"
 #include "../CommonFunctions.h"
 
 DLT_DECLARE_CONTEXT(AudioManager)
@@ -30,6 +32,25 @@ DLT_DECLARE_CONTEXT(AudioManager)
 using namespace testing;
 using namespace am;
 
+using ::testing::Field;
+using ::testing::Property;
+using ::testing::Matcher;
+using ::testing::Pointee;
+using ::testing::AllOf;
+using ::testing::SafeMatcherCast;
+using ::testing::MatcherCast;
+using ::testing::DefaultValue;
+using ::testing::Eq;
+using ::testing::An;
+using ::testing::ElementsAreArray;
+using ::testing::ElementsAre;
+using ::testing::NotNull;
+using ::testing::Assign;
+using ::testing::SetArgReferee;
+using ::testing::DoAll;
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+
 class controlInterfaceTest : public Test{
 public:
 	controlInterfaceTest();
@@ -37,7 +58,8 @@ public:
 	DatabaseHandler pDatabaseHandler;
 	RoutingSender pRoutingSender;
 	CommandSender pCommandSender;
-	MockControlSendInterface pMockInterface;
+	MockRoutingSendInterface pMockRoutingInterface;
+	MockControlSendInterface pMockControlInterface;
 	ControlSender pControlSender;
 	RoutingInterfaceBackdoor pRoutingInterfaceBackdoor;
 	CommandInterfaceBackdoor pCommandInterfaceBackdoor;
diff --git a/AudioManagerDaemon/test/database/databaseTest.cpp b/AudioManagerDaemon/test/database/databaseTest.cpp
index 75fb389..6f269e9 100644
--- a/AudioManagerDaemon/test/database/databaseTest.cpp
+++ b/AudioManagerDaemon/test/database/databaseTest.cpp
@@ -120,6 +120,50 @@ void databaseTest::TearDown()
 	DLT_UNREGISTER_CONTEXT(AudioManager);
 }
 
+TEST_F(databaseTest,crossfaders)
+{
+	//todo:implement crossfader tests
+}
+
+TEST_F(databaseTest,sourceState)
+{
+	am_Source_s source;
+	am_sourceID_t sourceID;
+	std::vector<am_Source_s> listSources;
+	pCF.createSource(source);
+	source.sourceState=SS_OFF;
+	ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
+	ASSERT_EQ(E_OK,pDatabaseHandler.changeSourceState(sourceID,SS_ON));
+	ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(listSources));
+	ASSERT_EQ(listSources[0].sourceState,SS_ON);
+}
+
+TEST_F(databaseTest,sinkVolumeChange)
+{
+	am_Sink_s sink;
+	am_sinkID_t sinkID;
+	std::vector<am_Sink_s> listSinks;
+	pCF.createSink(sink);
+	sink.volume=23;
+	ASSERT_EQ(E_OK,pDatabaseHandler.enterSinkDB(sink,sinkID));
+	ASSERT_EQ(E_OK,pDatabaseHandler.changeSinkVolume(sinkID,34));
+	ASSERT_EQ(E_OK,pDatabaseHandler.getListSinks(listSinks));
+	ASSERT_EQ(listSinks[0].volume,34);
+}
+
+TEST_F(databaseTest,sourceVolumeChange)
+{
+	am_Source_s source;
+	am_sourceID_t sourceID;
+	std::vector<am_Source_s> listSources;
+	pCF.createSource(source);
+	source.volume=23;
+	ASSERT_EQ(E_OK,pDatabaseHandler.enterSourceDB(source,sourceID));
+	ASSERT_EQ(E_OK,pDatabaseHandler.changeSourceVolume(sourceID,34));
+	ASSERT_EQ(E_OK,pDatabaseHandler.getListSources(listSources));
+	ASSERT_EQ(listSources[0].volume,34);
+}
+
 TEST_F(databaseTest, peekSource)
 {
 	std::vector<am_Source_s> listSources;
diff --git a/AudioManagerDaemon/test/routingInterface/MockRoutingInterface.h b/AudioManagerDaemon/test/routingInterface/MockRoutingInterface.h
index bd25156..0f29a5a 100644
--- a/AudioManagerDaemon/test/routingInterface/MockRoutingInterface.h
+++ b/AudioManagerDaemon/test/routingInterface/MockRoutingInterface.h
@@ -14,36 +14,36 @@
 
 namespace am {
 
-class MockRoutingSendInterface : public RoutingSendInterface {
+	class MockRoutingSendInterface : public RoutingSendInterface {
 	 public:
 	  MOCK_METHOD1(startupRoutingInterface,
-	      void(RoutingReceiveInterface* routingreceiveinterface));
+		  void(RoutingReceiveInterface* routingreceiveinterface));
 	  MOCK_METHOD0(routingInterfacesReady,
-	      void());
+		  void());
 	  MOCK_METHOD0(routingInterfacesRundown,
-	      void());
+		  void());
 	  MOCK_METHOD1(asyncAbort,
-	      am_Error_e(const am_Handle_s handle));
+		  am_Error_e(const am_Handle_s handle));
 	  MOCK_METHOD5(asyncConnect,
-	      am_Error_e(const am_Handle_s handle, const am_connectionID_t connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_ConnectionFormat_e connectionFormat));
+		  am_Error_e(const am_Handle_s handle, const am_connectionID_t connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_ConnectionFormat_e connectionFormat));
 	  MOCK_METHOD2(asyncDisconnect,
-	      am_Error_e(const am_Handle_s handle, const am_connectionID_t connectionID));
+		  am_Error_e(const am_Handle_s handle, const am_connectionID_t connectionID));
 	  MOCK_METHOD5(asyncSetSinkVolume,
-	      am_Error_e(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time));
+		  am_Error_e(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time));
 	  MOCK_METHOD5(asyncSetSourceVolume,
-	      am_Error_e(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time));
+		  am_Error_e(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time));
 	  MOCK_METHOD3(asyncSetSourceState,
-	      am_Error_e(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SourceState_e state));
+		  am_Error_e(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SourceState_e state));
 	  MOCK_METHOD3(asyncSetSinkSoundProperty,
-	      am_Error_e(const am_Handle_s handle, const am_SoundProperty_s& soundProperty, const am_sinkID_t sinkID));
+		  am_Error_e(const am_Handle_s handle, const am_SoundProperty_s& soundProperty, const am_sinkID_t sinkID));
 	  MOCK_METHOD3(asyncSetSourceSoundProperty,
-	      am_Error_e(const am_Handle_s handle, const am_SoundProperty_s& soundProperty, const am_sourceID_t sourceID));
+		  am_Error_e(const am_Handle_s handle, const am_SoundProperty_s& soundProperty, const am_sourceID_t sourceID));
 	  MOCK_METHOD5(asyncCrossFade,
-	      am_Error_e(const am_Handle_s handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_RampType_e rampType, const am_time_t time));
+		  am_Error_e(const am_Handle_s handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_RampType_e rampType, const am_time_t time));
 	  MOCK_METHOD2(setDomainState,
-	      am_Error_e(const am_domainID_t domainID, const am_DomainState_e domainState));
+		  am_Error_e(const am_domainID_t domainID, const am_DomainState_e domainState));
 	  MOCK_CONST_METHOD1(returnBusName,
-	      am_Error_e(std::string& BusName));
+		  am_Error_e(std::string& BusName));
 	};
 
 }  // namespace am