PluginRoutingInterfaceCAPI/test/CAmRoutingInterfaceCAPITests.cpp

   1 /**
   2  *  Copyright (c) 2012 BMW
   3  *
   4  *  \author Aleksandar Donchev, aleksander.donchev@partner.bmw.de BMW 2013
   5  *
   6  *  \copyright
   7  *  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction,
   8  *  including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
   9  *  subject to the following conditions:
  10  *  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  11  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  12  *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
  13  *  THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  14  *
  15  *  For further information see http://www.genivi.org/.
  16  */
  17
  18 #include <iostream>
  19 #include <fstream>
  20 #include <sstream>
  21 #include <algorithm>
  22 #include <string>
  23 #include <vector>
  24 #include <set>
  25 #include <sys/time.h>
  26 #include <CommonAPI/CommonAPI.h>
  27 #include <org/genivi/am.h>
  28 #include "CAmRoutingInterfaceCAPITests.h"
  29 #include "TAmPluginTemplate.h"
  30 #include "shared/CAmDltWrapper.h"
  31 #include "../include/CAmRoutingSenderCAPI.h"
  32 #include "../include/CAmRoutingSenderCommon.h"
  33 #include "CAmRoutingSenderService.h"
  34 #include "IAmRoutingSenderBackdoor.h"
  35
  36 using namespace am;
  37 using namespace CommonAPI;
  38 using namespace testing;
  39
  40 static CAmTestsEnvironment* env;
  41
  42 /**
  43  * Main thread synchronization
  44  */
  45 pthread_cond_t      cond                = PTHREAD_COND_INITIALIZER;
  46 pthread_mutex_t     mutex               = PTHREAD_MUTEX_INITIALIZER;
  47
  48 /**
  49  * Common-API connection thread synchronization
  50  */
  51 pthread_cond_t      condPxy     = PTHREAD_COND_INITIALIZER;
  52 pthread_mutex_t     mutexPxy    = PTHREAD_MUTEX_INITIALIZER;
  53
  54 /**
  55  * Proxy initialization thread synchronization
  56  */
  57 pthread_cond_t      condSer     = PTHREAD_COND_INITIALIZER;
  58 pthread_mutex_t     mutexSer    = PTHREAD_MUTEX_INITIALIZER;
  59
  60
  61 #define TEST_ID_1 102
  62 #define TEST_ID_2 103
  63
  64 /**
  65  * Initialize common-api and am sinks
  66  */
  67 void initSink(org::genivi::am::am_Sink_s & newSink, am_Sink_s & newAmSink, const org::genivi::am::am_domainID_t & domainID, const org::genivi::am::am_sinkID_t & sinkID = 0)
  68 {
  69         org::genivi::am::am_MuteState_e muteState = org::genivi::am::am_MuteState_e::MS_UNKNOWN;
  70     org::genivi::am::am_Availability_s available(org::genivi::am::am_Availability_e::A_MAX, AR_UNKNOWN);
  71         org::genivi::am::am_SoundProperty_L listSoundProperties;
  72         listSoundProperties.push_back(org::genivi::am::am_SoundProperty_s(SP_GENIVI_MID, 100));
  73         listSoundProperties.push_back(org::genivi::am::am_SoundProperty_s(SP_GENIVI_BASS, 101));
  74         listSoundProperties.push_back(org::genivi::am::am_SoundProperty_s(SP_UNKNOWN, 102));
  75         org::genivi::am::am_ConnectionFormat_L listConnectionFormats;
  76         listConnectionFormats.push_back(CF_UNKNOWN);
  77         org::genivi::am::am_MainSoundProperty_L listMainSoundProperties;
  78         listMainSoundProperties.push_back(org::genivi::am::am_MainSoundProperty_s(MSP_UNKNOWN, 100));
  79         org::genivi::am::am_NotificationConfiguration_L listMainNotificationConfigurations;
  80         listMainNotificationConfigurations.push_back(org::genivi::am::am_NotificationConfiguration_s(NT_UNKNOWN, org::genivi::am::am_NotificationStatus_e::NS_MAX, 100));
  81         org::genivi::am::am_NotificationConfiguration_L listNotificationConfigurations;
  82         listNotificationConfigurations.push_back(org::genivi::am::am_NotificationConfiguration_s(NT_UNKNOWN, org::genivi::am::am_NotificationStatus_e::NS_MAX, 100));
  83
  84         org::genivi::am::am_Sink_s sink(sinkID, "name", domainID, 104, 50, true, available, muteState, 50,
  85                                                         listSoundProperties, listConnectionFormats, listMainSoundProperties, listMainNotificationConfigurations, listNotificationConfigurations);
  86         newSink = sink;
  87         CAmConvertCAPI2AM(sink, newAmSink);
  88 }
  89
  90 /**
  91  * Initialize common-api and am sources
  92  */
  93 void initSource(org::genivi::am::am_Source_s & newSource, am_Source_s & newAmSource, const org::genivi::am::am_domainID_t & domainID, const org::genivi::am::am_sourceID_t & sourceID = 0)
  94 {
  95         org::genivi::am::am_SourceState_e srcState = org::genivi::am::am_SourceState_e::SS_MAX;
  96     org::genivi::am::am_Availability_s available(org::genivi::am::am_Availability_e::A_MAX, AR_UNKNOWN);
  97         org::genivi::am::am_SoundProperty_L listSoundProperties;
  98         listSoundProperties.push_back(org::genivi::am::am_SoundProperty_s(SP_GENIVI_MID, 100));
  99         listSoundProperties.push_back(org::genivi::am::am_SoundProperty_s(SP_GENIVI_BASS, 101));
 100         listSoundProperties.push_back(org::genivi::am::am_SoundProperty_s(SP_UNKNOWN, 102));
 101         org::genivi::am::am_ConnectionFormat_L listConnectionFormats;
 102         listConnectionFormats.push_back(CF_UNKNOWN);
 103         org::genivi::am::am_MainSoundProperty_L listMainSoundProperties;
 104         listMainSoundProperties.push_back(org::genivi::am::am_MainSoundProperty_s(MSP_UNKNOWN, 100));
 105         org::genivi::am::am_NotificationConfiguration_L listMainNotificationConfigurations;
 106         listMainNotificationConfigurations.push_back(org::genivi::am::am_NotificationConfiguration_s(NT_UNKNOWN, org::genivi::am::am_NotificationStatus_e::NS_MAX, 100));
 107         org::genivi::am::am_NotificationConfiguration_L listNotificationConfigurations;
 108         listNotificationConfigurations.push_back(org::genivi::am::am_NotificationConfiguration_s(NT_UNKNOWN, org::genivi::am::am_NotificationStatus_e::NS_MAX, 100));
 109
 110         org::genivi::am::am_Source_s source(sourceID, domainID, "name", 104, srcState, 50, true, available, org::genivi::am::am_InterruptState_e::IS_MAX,
 111                                                                 listSoundProperties, listConnectionFormats, listMainSoundProperties, listMainNotificationConfigurations, listNotificationConfigurations);
 112         newSource = source;
 113         CAmConvertCAPI2AM(source, newAmSource);
 114 }
 115
 116 /**
 117  * Initialize common-api and am crossfaders
 118  */
 119 void initCrossfader(org::genivi::am::am_Crossfader_s & newCrossfader, am_Crossfader_s & newAmCrossfader, const org::genivi::am::am_crossfaderID_t & crossfaderID = 0)
 120 {
 121         org::genivi::am::am_Crossfader_s crossfader(crossfaderID, "name", TEST_ID_1, TEST_ID_2, TEST_ID_1, org::genivi::am::am_HotSink_e::HS_MAX);
 122         CAmConvertCAPI2AM(crossfader, newAmCrossfader);
 123         newCrossfader = crossfader;
 124 }
 125
 126 /**
 127  * Client thread where the proxy and the routing test domain service run
 128  */
 129 void* run_client(void*)
 130 {
 131         CAmSocketHandler socketHandler;
 132         CAmTestCAPIWrapper wrapper(&socketHandler);
 133         env->mSocketHandlerClient = &socketHandler;
 134         std::shared_ptr<CommonAPI::Factory> factory = wrapper.factory();
 135
 136         env->mProxy = factory->buildProxy<org::genivi::am::RoutingControlObserverProxy>(CAmRoutingSenderCAPI::ROUTING_INTERFACE_SERVICE);
 137         env->mProxy->getProxyStatusEvent().subscribe(std::bind(&CAmTestsEnvironment::onServiceStatusEvent,env,std::placeholders::_1));
 138
 139         env->mDomainService = std::make_shared<CAmRoutingSenderService>(&wrapper, env->mProxy);
 140
 141         if( false == wrapper.registerStub(env->mDomainService, CAmRoutingSenderService::ROUTING_SENDER_SERVICE) )
 142         {
 143                 printf("\n Can't register service -> %s \n", CAmRoutingSenderService::ROUTING_SENDER_SERVICE);
 144                 logInfo("Can't register service -> ", CAmRoutingSenderService::ROUTING_SENDER_SERVICE);
 145         }
 146
 147         pthread_mutex_lock(&mutexSer);
 148         env->mIsProxyInitilized = true;
 149         pthread_mutex_unlock(&mutexSer);
 150         pthread_cond_signal(&condSer);
 151
 152         socketHandler.start_listenting();
 153
 154 //Cleanup
 155     env->mProxy.reset();
 156     env->mSocketHandlerClient = NULL;
 157
 158     return (NULL);
 159 }
 160
 161 /**
 162  * Service thread for the routing plugin
 163  */
 164 void* run_service(void*)
 165 {
 166         CAmSocketHandler socketHandler;
 167         CAmTestCAPIWrapper wrapper(&socketHandler);
 168         CAmRoutingSenderCAPI plugin(&wrapper);
 169         env->mpPlugin = &plugin;
 170         env->mSocketHandlerService = &socketHandler;
 171         MockIAmRoutingReceive mock;
 172         env->mpRoutingReceive = &mock;
 173     if(plugin.startupInterface(env->mpRoutingReceive)!=E_OK)
 174         {
 175                 logError("CommandSendInterface can't start!");
 176         }
 177     else
 178     {
 179         plugin.setRoutingReady(10);
 180         socketHandler.start_listenting();
 181         plugin.setRoutingRundown(10);
 182         plugin.tearDownInterface(env->mpRoutingReceive);
 183     }
 184  //Cleanup
 185         env->mpRoutingReceive = NULL;
 186     env->mpPlugin = NULL;
 187     env->mSocketHandlerClient = NULL;
 188
 189     return (NULL);
 190 }
 191
 192 /**
 193  * Helper thread that listens for signals from another threads in order to synchronize them.
 194  * This thread starts actually the unit tests.
 195  */
 196 void* run_listener(void*)
 197 {
 198     pthread_mutex_lock(&mutexSer);
 199     while (env->mIsProxyInitilized==false)
 200     {
 201         std::cout << "\n\r Intialize proxy..\n\r" ;
 202         pthread_cond_wait(&condSer, &mutexSer);
 203     }
 204     pthread_mutex_unlock(&mutexSer);
 205
 206     time_t start = time(0);
 207     time_t now = start;
 208     pthread_mutex_lock(&mutexPxy);
 209     while ( env->mIsServiceAvailable==false && now-start <= 15 )
 210     {
 211         std::cout << " Waiting for proxy..\n\r" ;
 212         struct timespec ts = { 0, 0 };
 213         clock_gettime(CLOCK_REALTIME, &ts);
 214         ts.tv_sec += 5;
 215         pthread_cond_timedwait(&condPxy, &mutexPxy, &ts);
 216         now = time(0);
 217     }
 218     pthread_mutex_unlock(&mutexPxy);
 219
 220     pthread_cond_signal(&cond);
 221
 222         return NULL;
 223 }
 224
 225
 226 CAmRoutingInterfaceCAPITests::CAmRoutingInterfaceCAPITests()
 227 {
 228
 229 }
 230
 231 CAmRoutingInterfaceCAPITests::~CAmRoutingInterfaceCAPITests()
 232 {
 233
 234 }
 235
 236 void CAmRoutingInterfaceCAPITests::SetUp()
 237 {
 238         ::testing::GTEST_FLAG(throw_on_failure) = false;
 239 }
 240
 241 void CAmRoutingInterfaceCAPITests::TearDown()
 242 {
 243         ::testing::GTEST_FLAG(throw_on_failure) = true;
 244 }
 245
 246
 247 CAmRoutingSenderCAPITests::CAmRoutingSenderCAPITests()
 248 {
 249
 250 }
 251
 252 CAmRoutingSenderCAPITests::~CAmRoutingSenderCAPITests()
 253 {
 254
 255 }
 256
 257 void CAmRoutingSenderCAPITests::SetUp()
 258 {
 259         ::testing::GTEST_FLAG(throw_on_failure) = false;
 260 }
 261
 262 void CAmRoutingSenderCAPITests::TearDown()
 263 {
 264         ::testing::GTEST_FLAG(throw_on_failure) = true;
 265 }
 266
 267 int main(int argc, char **argv)
 268 {
 269     ::testing::InitGoogleTest(&argc, argv);
 270     ::testing::AddGlobalTestEnvironment(new CAmTestsEnvironment);
 271     return RUN_ALL_TESTS();
 272 }
 273
 274 CAmTestsEnvironment::CAmTestsEnvironment() :
 275                                 mIsProxyInitilized(false),
 276                                 mIsServiceAvailable(false),
 277                                 mIsDomainAvailable(false),
 278                                 mListenerThread(0),
 279                                 mServicePThread(0),
 280                                 mClientPThread(0),
 281                                 mSocketHandlerService(NULL),
 282                                 mSocketHandlerClient(NULL),
 283                                 mpRoutingReceive(NULL),
 284                                 mpPlugin(NULL),
 285                                 mProxy(NULL),
 286                                 mDomainService(NULL)
 287 {
 288     env=this;
 289         CAmDltWrapper::instance()->registerApp("capiTest", "capiTest");
 290         pthread_create(&mListenerThread, NULL, run_listener, NULL);
 291     pthread_create(&mServicePThread, NULL, run_service, NULL);
 292     pthread_create(&mClientPThread, NULL, run_client, NULL);
 293 }
 294
 295 CAmTestsEnvironment::~CAmTestsEnvironment()
 296 {
 297
 298 }
 299
 300 void CAmTestsEnvironment::SetUp()
 301 {
 302         pthread_cond_wait(&cond, &mutex);
 303 }
 304
 305 void CAmTestsEnvironment::TearDown()
 306 {
 307         if(mSocketHandlerClient)
 308                 mSocketHandlerClient->exit_mainloop();
 309     pthread_join(mClientPThread, NULL);
 310
 311     if(mSocketHandlerService)
 312         mSocketHandlerService->exit_mainloop();
 313     pthread_join(mServicePThread, NULL);
 314     sleep(1);
 315 }
 316
 317 void CAmTestsEnvironment::onServiceStatusEvent(const CommonAPI::AvailabilityStatus& serviceStatus)
 318 {
 319     std::stringstream  avail;
 320     avail  << "(" << static_cast<int>(serviceStatus) << ")";
 321
 322     logInfo("Service Status changed to ", avail.str());
 323     std::cout << std::endl << "Service Status changed to " << avail.str() << std::endl;
 324     pthread_mutex_lock(&mutexPxy);
 325     mIsServiceAvailable = (serviceStatus==CommonAPI::AvailabilityStatus::AVAILABLE);
 326     pthread_mutex_unlock(&mutexPxy);
 327     pthread_cond_signal(&condPxy);
 328 }
 329
 330 TEST_F(CAmRoutingInterfaceCAPITests, ClientStartupTest)
 331 {
 332         ASSERT_TRUE(env->mIsServiceAvailable);
 333         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 334 }
 335
 336 MATCHER_P(IsHandleEqual, value, "") {
 337         am_Handle_s & lh = arg;
 338         return lh.handle == value.handle && lh.handleType == value.handleType;
 339 }
 340
 341 TEST_F(CAmRoutingInterfaceCAPITests, ackConnect)
 342 {
 343         ASSERT_TRUE(env->mIsServiceAvailable);
 344         if(env->mIsServiceAvailable)
 345         {
 346                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 347                 org::genivi::am::am_connectionID_t connectionID = TEST_ID_1;
 348                 am_Error_e error = E_OK;
 349                 am_Handle_s handle = {H_CONNECT, 20};
 350                 org::genivi::am::am_Handle_s CAPIHandle;
 351                 CAmConvertAM2CAPI(handle,CAPIHandle);
 352                 EXPECT_CALL(*env->mpRoutingReceive, ackConnect(IsHandleEqual(handle), connectionID, error)).Times(1);
 353                 env->mProxy->ackConnect(CAPIHandle, connectionID, static_cast<org::genivi::am::am_Error_e>(error), callStatus);
 354                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 355         }
 356         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 357 }
 358
 359 TEST_F(CAmRoutingInterfaceCAPITests, ackDisconnect)
 360 {
 361         ASSERT_TRUE(env->mIsServiceAvailable);
 362         if(env->mIsServiceAvailable)
 363         {
 364                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 365                 org::genivi::am::am_connectionID_t connectionID = TEST_ID_1;
 366                 am_Error_e error = E_OK;
 367                 am_Handle_s handle = {H_DISCONNECT, 20};
 368                 org::genivi::am::am_Handle_s CAPIHandle;
 369                 CAmConvertAM2CAPI(handle,CAPIHandle);
 370                 EXPECT_CALL(*env->mpRoutingReceive, ackDisconnect(IsHandleEqual(handle), connectionID, error)).Times(1);
 371                 env->mProxy->ackDisconnect(CAPIHandle, connectionID, static_cast<org::genivi::am::am_Error_e>(error), callStatus);
 372                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 373         }
 374         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 375 }
 376
 377 TEST_F(CAmRoutingInterfaceCAPITests, ackSetSinkVolumeChange)
 378 {
 379         ASSERT_TRUE(env->mIsServiceAvailable);
 380         if(env->mIsServiceAvailable)
 381         {
 382                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 383                 am_Error_e error = E_OK;
 384                 am_volume_t volume = 50;
 385                 am_Handle_s handle = {H_SETSINKVOLUME, 20};
 386                 org::genivi::am::am_Handle_s CAPIHandle;
 387                 CAmConvertAM2CAPI(handle,CAPIHandle);
 388                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSinkVolumeChange(IsHandleEqual(handle), volume, error)).Times(1);
 389                 env->mProxy->ackSetSinkVolumeChange(CAPIHandle, static_cast<org::genivi::am::am_volume_t>(volume), static_cast<org::genivi::am::am_Error_e>(error), callStatus);
 390                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 391         }
 392         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 393 }
 394
 395 TEST_F(CAmRoutingInterfaceCAPITests, ackSetSourceVolumeChange)
 396 {
 397         ASSERT_TRUE(env->mIsServiceAvailable);
 398         if(env->mIsServiceAvailable)
 399         {
 400                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 401                 am_Error_e error = E_OK;
 402                 am_volume_t volume = 50;
 403                 am_Handle_s handle = {H_SETSOURCEVOLUME, 20};
 404                 org::genivi::am::am_Handle_s CAPIHandle;
 405                 CAmConvertAM2CAPI(handle,CAPIHandle);
 406                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSourceVolumeChange(IsHandleEqual(handle), volume, error)).Times(1);
 407                 env->mProxy->ackSetSourceVolumeChange(CAPIHandle, static_cast<org::genivi::am::am_volume_t>(volume), static_cast<org::genivi::am::am_Error_e>(error), callStatus);
 408                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 409         }
 410
 411         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 412 }
 413
 414 TEST_F(CAmRoutingInterfaceCAPITests, ackSetSourceState)
 415 {
 416         ASSERT_TRUE(env->mIsServiceAvailable);
 417         if(env->mIsServiceAvailable)
 418         {
 419                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 420                 am_Error_e error = E_OK;
 421                 am_volume_t volume = 50;
 422                 am_Handle_s handle = {H_SETSOURCESTATE, 20};
 423                 org::genivi::am::am_Handle_s CAPIHandle;
 424                 CAmConvertAM2CAPI(handle,CAPIHandle);
 425                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSourceState(IsHandleEqual(handle), error)).Times(1);
 426                 env->mProxy->ackSetSourceState(CAPIHandle, static_cast<org::genivi::am::am_Error_e>(error), callStatus);
 427                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 428         }
 429
 430         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 431 }
 432
 433 TEST_F(CAmRoutingInterfaceCAPITests, ackSetSinkSoundProperties)
 434 {
 435         ASSERT_TRUE(env->mIsServiceAvailable);
 436         if(env->mIsServiceAvailable)
 437         {
 438                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 439                 am_Error_e error = E_OK;
 440                 am_volume_t volume = 50;
 441                 am_Handle_s handle = {H_SETSINKSOUNDPROPERTIES, 20};
 442                 org::genivi::am::am_Handle_s CAPIHandle;
 443                 CAmConvertAM2CAPI(handle,CAPIHandle);
 444                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSinkSoundProperties(IsHandleEqual(handle), error)).Times(1);
 445                 env->mProxy->ackSetSinkSoundProperties(CAPIHandle, static_cast<org::genivi::am::am_Error_e>(error), callStatus);
 446                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 447         }
 448
 449         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 450 }
 451
 452 TEST_F(CAmRoutingInterfaceCAPITests, ackSetSinkSoundProperty)
 453 {
 454         ASSERT_TRUE(env->mIsServiceAvailable);
 455         if(env->mIsServiceAvailable)
 456         {
 457                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 458                 am_Error_e error = E_OK;
 459                 am_volume_t volume = 50;
 460                 am_Handle_s handle = {H_SETSINKSOUNDPROPERTY, 20};
 461                 org::genivi::am::am_Handle_s CAPIHandle;
 462                 CAmConvertAM2CAPI(handle,CAPIHandle);
 463                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSinkSoundProperty(IsHandleEqual(handle), error)).Times(1);
 464                 env->mProxy->ackSetSinkSoundProperty(CAPIHandle, static_cast<org::genivi::am::am_Error_e>(error), callStatus);
 465                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 466         }
 467
 468         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 469 }
 470
 471 TEST_F(CAmRoutingInterfaceCAPITests, ackSetSourceSoundProperties)
 472 {
 473         ASSERT_TRUE(env->mIsServiceAvailable);
 474         if(env->mIsServiceAvailable)
 475         {
 476                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 477                 am_Error_e error = E_OK;
 478                 am_volume_t volume = 50;
 479                 am_Handle_s handle = {H_SETSOURCESOUNDPROPERTIES, 20};
 480                 org::genivi::am::am_Handle_s CAPIHandle;
 481                 CAmConvertAM2CAPI(handle,CAPIHandle);
 482                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSourceSoundProperties(IsHandleEqual(handle), error)).Times(1);
 483                 env->mProxy->ackSetSourceSoundProperties(CAPIHandle, static_cast<org::genivi::am::am_Error_e>(error), callStatus);
 484                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 485         }
 486
 487         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 488 }
 489
 490 TEST_F(CAmRoutingInterfaceCAPITests, ackSetSourceSoundProperty)
 491 {
 492         ASSERT_TRUE(env->mIsServiceAvailable);
 493         if(env->mIsServiceAvailable)
 494         {
 495                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 496                 am_Error_e error = E_OK;
 497                 am_volume_t volume = 50;
 498                 am_Handle_s handle = {H_SETSOURCESOUNDPROPERTY, 20};
 499                 org::genivi::am::am_Handle_s CAPIHandle;
 500                 CAmConvertAM2CAPI(handle,CAPIHandle);
 501                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSourceSoundProperty(IsHandleEqual(handle), error)).Times(1);
 502                 env->mProxy->ackSetSourceSoundProperty(CAPIHandle, static_cast<org::genivi::am::am_Error_e>(error), callStatus);
 503                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 504         }
 505         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 506 }
 507
 508 TEST_F(CAmRoutingInterfaceCAPITests, ackCrossFading)
 509 {
 510         ASSERT_TRUE(env->mIsServiceAvailable);
 511         if(env->mIsServiceAvailable)
 512         {
 513                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 514                 am_Error_e error = E_OK;
 515                 am_HotSink_e hotSink = HS_UNKNOWN;
 516                 am_Handle_s handle = {H_CROSSFADE, 20};
 517                 org::genivi::am::am_Handle_s CAPIHandle;
 518                 CAmConvertAM2CAPI(handle,CAPIHandle);
 519                 EXPECT_CALL(*env->mpRoutingReceive, ackCrossFading(IsHandleEqual(handle), hotSink, error)).Times(1);
 520                 env->mProxy->ackCrossFading(CAPIHandle, static_cast<org::genivi::am::am_HotSink_e>(hotSink), static_cast<org::genivi::am::am_Error_e>(error), callStatus);
 521                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 522         }
 523         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 524 }
 525
 526 TEST_F(CAmRoutingInterfaceCAPITests, ackSourceVolumeTick)
 527 {
 528         ASSERT_TRUE(env->mIsServiceAvailable);
 529         if(env->mIsServiceAvailable)
 530         {
 531                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 532                 am_Error_e error = E_OK;
 533                 am_sourceID_t sourceID = TEST_ID_1;
 534                 am_Handle_s handle = {H_SETSOURCEVOLUME, 20};
 535                 am_volume_t volume (20);
 536                 org::genivi::am::am_Handle_s CAPIHandle;
 537                 CAmConvertAM2CAPI(handle,CAPIHandle);
 538                 EXPECT_CALL(*env->mpRoutingReceive, ackSourceVolumeTick(IsHandleEqual(handle), sourceID, volume)).Times(1);
 539                 env->mProxy->ackSourceVolumeTick(CAPIHandle, sourceID, static_cast<org::genivi::am::am_volume_t>(volume), callStatus);
 540                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 541         }
 542         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 543 }
 544
 545 TEST_F(CAmRoutingInterfaceCAPITests, ackSinkVolumeTick)
 546 {
 547         ASSERT_TRUE(env->mIsServiceAvailable);
 548         if(env->mIsServiceAvailable)
 549         {
 550                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 551                 am_Error_e error = E_OK;
 552                 am_sinkID_t sID = TEST_ID_1;
 553                 am_Handle_s handle = {H_SETSINKVOLUME, 20};
 554                 org::genivi::am::am_Handle_s CAPIHandle;
 555                 CAmConvertAM2CAPI(handle,CAPIHandle);
 556                 am_volume_t volume (20);
 557                 EXPECT_CALL(*env->mpRoutingReceive, ackSinkVolumeTick(IsHandleEqual(handle), sID, volume)).Times(1);
 558                 env->mProxy->ackSinkVolumeTick(CAPIHandle, sID,static_cast<org::genivi::am::am_volume_t>(volume), callStatus);
 559                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 560         }
 561         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 562 }
 563
 564 ACTION(actionRegister){
 565         arg1=TEST_ID_1;
 566 }
 567
 568 ACTION(actionPeekDomain){
 569         arg1=TEST_ID_1;
 570 }
 571
 572 TEST_F(CAmRoutingInterfaceCAPITests, peekDomain)
 573 {
 574         ASSERT_TRUE(env->mIsServiceAvailable);
 575         if(env->mIsServiceAvailable)
 576         {
 577                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 578                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 579                 std::string  name("domain name");
 580                 org::genivi::am::am_domainID_t domainID = 0;
 581                 ON_CALL(*env->mpRoutingReceive, peekDomain(_, _)).WillByDefault(Return(E_OK));
 582                 EXPECT_CALL(*env->mpRoutingReceive, peekDomain(name, _)).WillOnce(DoAll(actionPeekDomain(), Return(E_OK)));
 583                 env->mProxy->peekDomain(name, callStatus, domainID, error);
 584                 ASSERT_EQ( domainID, TEST_ID_1 );
 585                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 586                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 587         }
 588         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 589 }
 590
 591 MATCHER_P(IsDomainDataEqualTo, value, "") {
 592         auto lh = arg;
 593         return lh.domainID == value.domainID &&
 594                         lh.name == value.name &&
 595                         lh.nodename == value.nodename &&
 596                         lh.early == value.early &&
 597                         lh.complete == value.complete &&
 598                         lh.state == value.state;
 599 }
 600
 601 TEST_F(CAmRoutingInterfaceCAPITests, registerDomain)
 602 {
 603         ASSERT_TRUE(env->mIsServiceAvailable);
 604         if(env->mIsServiceAvailable)
 605         {
 606                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 607                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 608
 609                 std::string name("domain name");
 610         std::string busname("busname");
 611         std::string nodename("nodename");
 612
 613                 org::genivi::am::am_Domain_s domainData(0, name, busname, nodename, false, false, org::genivi::am::am_DomainState_e::DS_CONTROLLED);
 614                 am::am_Domain_s amDomainData;
 615                 CAmConvertCAPI2AM(domainData, amDomainData);
 616                 org::genivi::am::am_domainID_t domainID = 0;
 617 //If the result is E_OK, then the routing service will try to establish a connection with the domain via common-api.
 618 //For now we won't test common-api connection with the domain therefore E_ABORTED is returned.
 619                 ON_CALL(*env->mpRoutingReceive, registerDomain(_, _)).WillByDefault(Return(E_ABORTED));
 620                 EXPECT_CALL(*env->mpRoutingReceive, registerDomain(IsDomainDataEqualTo(amDomainData), _)).WillOnce(DoAll(actionRegister(), Return(E_ABORTED)));
 621
 622 //example:      [local:org.genivi.audiomanager.testdomaininterface:org.genivi.audiomanager]
 623                 env->mProxy->registerDomain(domainData,
 624                                                                         "org.genivi.audiomanager", //(last part)
 625                                                                         "org.genivi.audiomanager.testdomaininterface", //(middle part)
 626                                                                         callStatus,
 627                                                                         domainID,
 628                                                                         error);
 629                 ASSERT_EQ( domainID, TEST_ID_1 );
 630                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_ABORTED );
 631                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 632         }
 633         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 634 }
 635
 636 TEST_F(CAmRoutingInterfaceCAPITests, deregisterDomain)
 637 {
 638         ASSERT_TRUE(env->mIsServiceAvailable);
 639         if(env->mIsServiceAvailable)
 640         {
 641                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 642                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 643                 org::genivi::am::am_domainID_t domainID = TEST_ID_1;
 644
 645                 ON_CALL(*env->mpRoutingReceive, deregisterDomain(_)).WillByDefault(Return(E_OK));
 646                 EXPECT_CALL(*env->mpRoutingReceive, deregisterDomain(domainID)).WillOnce(Return(E_OK));
 647                 env->mProxy->deregisterDomain(domainID, callStatus, error);
 648                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 649                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 650         }
 651         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 652 }
 653
 654 ACTION(actionRegisterGateway){
 655         arg1=TEST_ID_1;
 656 }
 657
 658 MATCHER_P(IsGatewayDataEqualTo, value, "") {
 659         auto lh = arg;
 660         return lh.gatewayID == value.gatewayID &&
 661                         lh.name == value.name &&
 662                         lh.sinkID == value.sinkID &&
 663                         lh.sourceID == value.sourceID &&
 664                         lh.domainSinkID == value.domainSinkID &&
 665                         lh.controlDomainID == value.controlDomainID &&
 666                         lh.listSourceFormats == value.listSourceFormats &&
 667                         lh.listSinkFormats == value.listSinkFormats &&
 668                         lh.convertionMatrix == value.convertionMatrix;
 669 }
 670
 671 TEST_F(CAmRoutingInterfaceCAPITests, registerGateway)
 672 {
 673         ASSERT_TRUE(env->mIsServiceAvailable);
 674         if(env->mIsServiceAvailable)
 675         {
 676                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 677                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 678
 679                 org::genivi::am::am_ConnectionFormat_L listSourceFormats;
 680                 listSourceFormats.push_back(static_cast<org::genivi::am::am_CustomConnectionFormat_t>(CF_GENIVI_ANALOG));
 681                 listSourceFormats.push_back(static_cast<org::genivi::am::am_CustomConnectionFormat_t>(CF_GENIVI_AUTO));
 682                 org::genivi::am::am_ConnectionFormat_L listSinkFormats;
 683                 listSinkFormats.push_back(static_cast<org::genivi::am::am_CustomConnectionFormat_t>(CF_GENIVI_AUTO));
 684                 listSinkFormats.push_back(static_cast<org::genivi::am::am_CustomConnectionFormat_t>(CF_GENIVI_ANALOG));
 685                 org::genivi::am::am_Convertion_L convertionMatrix;
 686                 convertionMatrix.push_back(1);
 687                 convertionMatrix.push_back(0);
 688
 689                 org::genivi::am::am_gatewayID_t gatewayID = 0;
 690                 org::genivi::am::am_Gateway_s gateway(gatewayID, "name", 103, 104, 105, 106, 107, listSourceFormats, listSinkFormats, convertionMatrix);
 691                 am_Gateway_s amGateway;
 692                 CAmConvertCAPI2AM(gateway, amGateway);
 693
 694                 ON_CALL(*env->mpRoutingReceive, registerGateway(_, _)).WillByDefault(Return(E_OK));
 695                 EXPECT_CALL(*env->mpRoutingReceive, registerGateway(IsGatewayDataEqualTo(amGateway), _)).WillOnce(DoAll(actionRegisterGateway(), Return(E_OK)));
 696                 env->mProxy->registerGateway(gateway, callStatus, gatewayID, error);
 697                 ASSERT_EQ( gatewayID, TEST_ID_1 );
 698                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 699                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 700         }
 701         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 702 }
 703
 704 TEST_F(CAmRoutingInterfaceCAPITests, deregisterGateway)
 705 {
 706         ASSERT_TRUE(env->mIsServiceAvailable);
 707         if(env->mIsServiceAvailable)
 708         {
 709                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 710                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 711                 org::genivi::am::am_gatewayID_t gatewayID = TEST_ID_1;
 712
 713                 ON_CALL(*env->mpRoutingReceive, deregisterGateway(_)).WillByDefault(Return(E_OK));
 714                 EXPECT_CALL(*env->mpRoutingReceive, deregisterGateway(gatewayID)).WillOnce(Return(E_OK));
 715                 env->mProxy->deregisterGateway(gatewayID, callStatus, error);
 716                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 717                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 718         }
 719         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 720 }
 721
 722 ACTION(actionPeek){
 723         arg1=TEST_ID_1;
 724 }
 725
 726 TEST_F(CAmRoutingInterfaceCAPITests, peekSink)
 727 {
 728         ASSERT_TRUE(env->mIsServiceAvailable);
 729         if(env->mIsServiceAvailable)
 730         {
 731                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 732                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 733                 std::string  name("name");
 734                 org::genivi::am::am_sinkID_t sinkID = 0;
 735                 ON_CALL(*env->mpRoutingReceive, peekSink(_, _)).WillByDefault(Return(E_OK));
 736                 EXPECT_CALL(*env->mpRoutingReceive, peekSink(name, _)).WillOnce(DoAll(actionPeek(), Return(E_OK)));
 737                 env->mProxy->peekSink(name, callStatus, sinkID, error);
 738                 ASSERT_EQ( sinkID, TEST_ID_1 );
 739                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 740                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 741         }
 742         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 743 }
 744
 745
 746 MATCHER_P(IsSinkDataEqualTo, value, "") {
 747         auto lh = arg;
 748
 749         bool bMainSoundProperties = lh.listMainSoundProperties.size() == value.listMainSoundProperties.size();
 750         for(int i=0; i<lh.listMainSoundProperties.size(); i++)
 751         {
 752                 bMainSoundProperties &= (lh.listMainSoundProperties.at(i).type==value.listMainSoundProperties.at(i).type &&
 753                                                                  lh.listMainSoundProperties.at(i).value==value.listMainSoundProperties.at(i).value);
 754         }
 755
 756         bool bSoundProperties = lh.listSoundProperties.size() == value.listSoundProperties.size();
 757         for(int i=0; i<lh.listSoundProperties.size(); i++)
 758         {
 759                 bSoundProperties &= (lh.listSoundProperties.at(i).type==value.listSoundProperties.at(i).type &&
 760                                                           lh.listSoundProperties.at(i).value==value.listSoundProperties.at(i).value);
 761         }
 762
 763         bool bMainNotificationConfigurations = lh.listMainNotificationConfigurations.size() == value.listMainNotificationConfigurations.size();
 764         for(int i=0; i<lh.listMainNotificationConfigurations.size(); i++)
 765         {
 766         bMainNotificationConfigurations &= (lh.listMainNotificationConfigurations.at(i).type==value.listMainNotificationConfigurations.at(i).type &&
 767                                                                                 lh.listMainNotificationConfigurations.at(i).status==value.listMainNotificationConfigurations.at(i).status &&
 768                                                                                 lh.listMainNotificationConfigurations.at(i).parameter==value.listMainNotificationConfigurations.at(i).parameter);
 769         }
 770
 771         bool bNotificationConfigurations = lh.listNotificationConfigurations.size() == value.listNotificationConfigurations.size();
 772         for(int i=0; i<lh.listNotificationConfigurations.size(); i++)
 773         {
 774                 bNotificationConfigurations &= (lh.listNotificationConfigurations.at(i).type==value.listNotificationConfigurations.at(i).type &&
 775                                                                                 lh.listNotificationConfigurations.at(i).status==value.listNotificationConfigurations.at(i).status &&
 776                                                                                 lh.listNotificationConfigurations.at(i).parameter==value.listNotificationConfigurations.at(i).parameter);
 777         }
 778
 779         return bMainSoundProperties &&
 780                         bSoundProperties &&
 781                         bNotificationConfigurations &&
 782                         bMainNotificationConfigurations &&
 783                         lh.sinkID == value.sinkID &&
 784                         lh.name == value.name &&
 785                         lh.domainID == value.domainID &&
 786                         lh.sinkClassID == value.sinkClassID &&
 787                         lh.volume == value.volume &&
 788                         lh.visible == value.visible &&
 789                         lh.available.availability == value.available.availability &&
 790                         lh.available.availabilityReason == value.available.availabilityReason &&
 791                         lh.muteState == value.muteState &&
 792                         lh.mainVolume == value.mainVolume &&
 793                         lh.listConnectionFormats == value.listConnectionFormats;
 794 }
 795
 796 TEST_F(CAmRoutingInterfaceCAPITests, registerSink)
 797 {
 798         ASSERT_TRUE(env->mIsServiceAvailable);
 799         if(env->mIsServiceAvailable)
 800         {
 801                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 802                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 803
 804                 org::genivi::am::am_Sink_s sink;
 805                 am_Sink_s amSink;
 806                 org::genivi::am::am_sinkID_t sinkID = 0;
 807                 initSink(sink, amSink, TEST_ID_2, sinkID);
 808
 809                 ON_CALL(*env->mpRoutingReceive, registerSink(_, _)).WillByDefault(Return(E_OK));
 810                 EXPECT_CALL(*env->mpRoutingReceive, registerSink(IsSinkDataEqualTo(amSink), _)).WillOnce(DoAll(actionRegister(), Return(E_OK)));
 811                 env->mProxy->registerSink(sink, callStatus, sinkID, error);
 812                 ASSERT_EQ( sinkID, TEST_ID_1 );
 813                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 814                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 815         }
 816         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 817 }
 818
 819 TEST_F(CAmRoutingInterfaceCAPITests, deregisterSink)
 820 {
 821         ASSERT_TRUE(env->mIsServiceAvailable);
 822         if(env->mIsServiceAvailable)
 823         {
 824                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 825                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 826                 org::genivi::am::am_sinkID_t sinkID = TEST_ID_1;
 827
 828                 ON_CALL(*env->mpRoutingReceive, deregisterSink(_)).WillByDefault(Return(E_OK));
 829                 EXPECT_CALL(*env->mpRoutingReceive, deregisterSink(sinkID)).WillOnce(Return(E_OK));
 830                 env->mProxy->deregisterSink(sinkID, callStatus, error);
 831                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 832                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 833         }
 834         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 835 }
 836
 837 TEST_F(CAmRoutingInterfaceCAPITests, peekSource)
 838 {
 839         ASSERT_TRUE(env->mIsServiceAvailable);
 840         if(env->mIsServiceAvailable)
 841         {
 842                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 843                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 844                 std::string  name("name");
 845                 org::genivi::am::am_sourceID_t sinkID = 0;
 846                 ON_CALL(*env->mpRoutingReceive, peekSource(_, _)).WillByDefault(Return(E_OK));
 847                 EXPECT_CALL(*env->mpRoutingReceive, peekSource(name, _)).WillOnce(DoAll(actionPeek(), Return(E_OK)));
 848                 env->mProxy->peekSource(name, callStatus, sinkID, error);
 849                 ASSERT_EQ( sinkID, TEST_ID_1 );
 850                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 851                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 852         }
 853         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 854 }
 855
 856 ACTION(actionRegisterSource){
 857         arg1=TEST_ID_1;
 858 }
 859
 860 MATCHER_P(IsSourceDataEqualTo, value, "") {
 861         auto lh = arg;
 862
 863         bool bMainSoundProperties = lh.listMainSoundProperties.size() == value.listMainSoundProperties.size();
 864         for(int i=0; i<lh.listMainSoundProperties.size(); i++)
 865         {
 866                 bMainSoundProperties &= (lh.listMainSoundProperties.at(i).type==value.listMainSoundProperties.at(i).type &&
 867                                                                  lh.listMainSoundProperties.at(i).value==value.listMainSoundProperties.at(i).value);
 868         }
 869
 870         bool bSoundProperties = lh.listSoundProperties.size() == value.listSoundProperties.size();
 871         for(int i=0; i<lh.listSoundProperties.size(); i++)
 872         {
 873                 bSoundProperties &= (lh.listSoundProperties.at(i).type==value.listSoundProperties.at(i).type &&
 874                                                           lh.listSoundProperties.at(i).value==value.listSoundProperties.at(i).value);
 875         }
 876
 877         bool bMainNotificationConfigurations = lh.listMainNotificationConfigurations.size() == value.listMainNotificationConfigurations.size();
 878         for(int i=0; i<lh.listMainNotificationConfigurations.size(); i++)
 879         {
 880         bMainNotificationConfigurations &= (lh.listMainNotificationConfigurations.at(i).type==value.listMainNotificationConfigurations.at(i).type &&
 881                                                                                 lh.listMainNotificationConfigurations.at(i).status==value.listMainNotificationConfigurations.at(i).status &&
 882                                                                                 lh.listMainNotificationConfigurations.at(i).parameter==value.listMainNotificationConfigurations.at(i).parameter);
 883         }
 884
 885         bool bNotificationConfigurations = lh.listNotificationConfigurations.size() == value.listNotificationConfigurations.size();
 886         for(int i=0; i<lh.listNotificationConfigurations.size(); i++)
 887         {
 888                 bNotificationConfigurations &= (lh.listNotificationConfigurations.at(i).type==value.listNotificationConfigurations.at(i).type &&
 889                                                                                 lh.listNotificationConfigurations.at(i).status==value.listNotificationConfigurations.at(i).status &&
 890                                                                                 lh.listNotificationConfigurations.at(i).parameter==value.listNotificationConfigurations.at(i).parameter);
 891         }
 892         return bMainSoundProperties &&
 893                         bSoundProperties &&
 894                         bNotificationConfigurations &&
 895                         bMainNotificationConfigurations &&
 896                         lh.sourceID == value.sourceID &&
 897                         lh.name == value.name &&
 898                         lh.domainID == value.domainID &&
 899                         lh.sourceClassID == value.sourceClassID &&
 900                         lh.volume == value.volume &&
 901                         lh.visible == value.visible &&
 902                         lh.available.availability == value.available.availability &&
 903                         lh.available.availabilityReason == value.available.availabilityReason &&
 904                         lh.sourceState == value.sourceState &&
 905                         lh.interruptState == value.interruptState &&
 906                         lh.listConnectionFormats == value.listConnectionFormats;
 907 }
 908
 909 TEST_F(CAmRoutingInterfaceCAPITests, registerSource)
 910 {
 911         ASSERT_TRUE(env->mIsServiceAvailable);
 912         if(env->mIsServiceAvailable)
 913         {
 914                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 915                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 916
 917                 org::genivi::am::am_Source_s source;
 918                 am_Source_s amSource;
 919                 org::genivi::am::am_sourceID_t sourceID = 0;
 920                 initSource(source, amSource, TEST_ID_2, sourceID);
 921
 922                 ON_CALL(*env->mpRoutingReceive, registerSource(_, _)).WillByDefault(Return(E_OK));
 923                 EXPECT_CALL(*env->mpRoutingReceive, registerSource(IsSourceDataEqualTo(amSource), _)).WillOnce(DoAll(actionRegister(), Return(E_OK)));
 924                 env->mProxy->registerSource(source, callStatus, sourceID, error);
 925                 ASSERT_EQ( sourceID, TEST_ID_1 );
 926                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 927                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 928         }
 929         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 930 }
 931
 932 TEST_F(CAmRoutingInterfaceCAPITests, deregisterSource)
 933 {
 934         ASSERT_TRUE(env->mIsServiceAvailable);
 935         if(env->mIsServiceAvailable)
 936         {
 937                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 938                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 939                 org::genivi::am::am_sourceID_t sinkID = TEST_ID_1;
 940
 941                 ON_CALL(*env->mpRoutingReceive, deregisterSource(_)).WillByDefault(Return(E_OK));
 942                 EXPECT_CALL(*env->mpRoutingReceive, deregisterSource(sinkID)).WillOnce(Return(E_OK));
 943                 env->mProxy->deregisterSource(sinkID, callStatus, error);
 944                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 945                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 946         }
 947         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 948 }
 949
 950 ACTION(actionRegisterCrossfader){
 951         arg1=TEST_ID_1;
 952 }
 953
 954 MATCHER_P(IsCrossfaderDataEqualTo, value, "") {
 955         auto lh = arg;
 956         return lh.crossfaderID == value.crossfaderID &&
 957                         lh.name == value.name &&
 958                         lh.sinkID_A == value.sinkID_A &&
 959                         lh.sinkID_B == value.sinkID_B &&
 960                         lh.sinkID_B == value.sinkID_B &&
 961                         lh.sourceID == value.sourceID &&
 962                         lh.hotSink == value.hotSink;
 963 }
 964
 965 TEST_F(CAmRoutingInterfaceCAPITests, registerCrossfader)
 966 {
 967         ASSERT_TRUE(env->mIsServiceAvailable);
 968         if(env->mIsServiceAvailable)
 969         {
 970                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 971                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 972
 973                 org::genivi::am::am_crossfaderID_t crossfaderID = 0;
 974                 org::genivi::am::am_Crossfader_s crossfader;
 975                 am_Crossfader_s amCrossfader;
 976                 initCrossfader(crossfader, amCrossfader, crossfaderID);
 977
 978                 ON_CALL(*env->mpRoutingReceive, registerCrossfader(_, _)).WillByDefault(Return(E_OK));
 979                 EXPECT_CALL(*env->mpRoutingReceive, registerCrossfader(IsCrossfaderDataEqualTo(amCrossfader), _)).WillOnce(DoAll(actionRegister(), Return(E_OK)));
 980                 env->mProxy->registerCrossfader(crossfader, callStatus, crossfaderID, error);
 981                 ASSERT_EQ( crossfaderID, TEST_ID_1 );
 982                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
 983                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
 984         }
 985         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
 986 }
 987
 988 TEST_F(CAmRoutingInterfaceCAPITests, deregisterCrossfader)
 989 {
 990         ASSERT_TRUE(env->mIsServiceAvailable);
 991         if(env->mIsServiceAvailable)
 992         {
 993                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
 994                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
 995                 org::genivi::am::am_crossfaderID_t crossfaderID = TEST_ID_1;
 996
 997                 ON_CALL(*env->mpRoutingReceive, deregisterCrossfader(_)).WillByDefault(Return(E_OK));
 998                 EXPECT_CALL(*env->mpRoutingReceive, deregisterCrossfader(crossfaderID)).WillOnce(Return(E_OK));
 999                 env->mProxy->deregisterCrossfader(crossfaderID, callStatus, error);
1000                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
1001                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1002         }
1003         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1004 }
1005
1006 TEST_F(CAmRoutingInterfaceCAPITests, peekSourceClassID)
1007 {
1008         ASSERT_TRUE(env->mIsServiceAvailable);
1009         if(env->mIsServiceAvailable)
1010         {
1011                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1012                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
1013                 std::string  name("name");
1014                 org::genivi::am::am_sourceClass_t sinkID = 0;
1015                 ON_CALL(*env->mpRoutingReceive, peekSourceClassID(_, _)).WillByDefault(Return(E_OK));
1016                 EXPECT_CALL(*env->mpRoutingReceive, peekSourceClassID(name, _)).WillOnce(DoAll(actionPeek(), Return(E_OK)));
1017                 env->mProxy->peekSourceClassID(name, callStatus, sinkID, error);
1018                 ASSERT_EQ( sinkID, TEST_ID_1 );
1019                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
1020                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1021         }
1022         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1023 }
1024
1025 TEST_F(CAmRoutingInterfaceCAPITests, peekSinkClassID)
1026 {
1027         ASSERT_TRUE(env->mIsServiceAvailable);
1028         if(env->mIsServiceAvailable)
1029         {
1030                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1031                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
1032                 std::string  name("name");
1033                 org::genivi::am::am_sinkClass_t sinkID = 0;
1034                 ON_CALL(*env->mpRoutingReceive, peekSinkClassID(_, _)).WillByDefault(Return(E_OK));
1035                 EXPECT_CALL(*env->mpRoutingReceive, peekSinkClassID(name, _)).WillOnce(DoAll(actionPeek(), Return(E_OK)));
1036                 env->mProxy->peekSinkClassID(name, callStatus, sinkID, error);
1037                 ASSERT_EQ( sinkID, TEST_ID_1 );
1038                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
1039                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1040         }
1041         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1042 }
1043
1044 TEST_F(CAmRoutingInterfaceCAPITests, hookInterruptStatusChange)
1045 {
1046         ASSERT_TRUE(env->mIsServiceAvailable);
1047         if(env->mIsServiceAvailable)
1048         {
1049                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1050                 am_Error_e error = E_OK;
1051                 org::genivi::am::am_sourceID_t sourceID = TEST_ID_1;
1052                 am_InterruptState_e interruptState = am_InterruptState_e::IS_MAX;
1053                 org::genivi::am::am_InterruptState_e CAPIInterruptState=static_cast<org::genivi::am::am_InterruptState_e>(interruptState);
1054                 EXPECT_CALL(*env->mpRoutingReceive, hookInterruptStatusChange(sourceID, interruptState)).Times(1);
1055                 env->mProxy->hookInterruptStatusChange(sourceID, CAPIInterruptState, callStatus);
1056                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1057         }
1058         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1059 }
1060
1061 TEST_F(CAmRoutingInterfaceCAPITests, hookDomainRegistrationComplete)
1062 {
1063         ASSERT_TRUE(env->mIsServiceAvailable);
1064         if(env->mIsServiceAvailable)
1065         {
1066                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1067                 am_Error_e error = E_OK;
1068                 org::genivi::am::am_domainID_t testID = TEST_ID_1;
1069                 EXPECT_CALL(*env->mpRoutingReceive, hookDomainRegistrationComplete(testID)).Times(1);
1070                 env->mProxy->hookDomainRegistrationComplete(testID, callStatus);
1071                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1072         }
1073         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1074 }
1075
1076 MATCHER_P(IsAvailabilityEqualTo, value, "") {
1077         am_Availability_s lh = arg;
1078         return lh.availability == value.availability &&
1079                         lh.availabilityReason == value.availabilityReason;
1080 }
1081
1082 TEST_F(CAmRoutingInterfaceCAPITests, hookSinkAvailablityStatusChange)
1083 {
1084         ASSERT_TRUE(env->mIsServiceAvailable);
1085         if(env->mIsServiceAvailable)
1086         {
1087                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1088                 am_Error_e error = E_OK;
1089                 org::genivi::am::am_sinkID_t testID = TEST_ID_1;
1090
1091                 org::genivi::am::am_Availability_s available(org::genivi::am::am_Availability_e::A_MAX, AR_UNKNOWN);
1092                 am_Availability_s amAvailable;
1093                 CAmConvertCAPI2AM(available, amAvailable);
1094
1095                 EXPECT_CALL(*env->mpRoutingReceive, hookSinkAvailablityStatusChange(testID, IsAvailabilityEqualTo(amAvailable))).Times(1);
1096                 env->mProxy->hookSinkAvailablityStatusChange(testID, available, callStatus);
1097                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1098         }
1099         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1100 }
1101
1102 TEST_F(CAmRoutingInterfaceCAPITests, hookSourceAvailablityStatusChange)
1103 {
1104         ASSERT_TRUE(env->mIsServiceAvailable);
1105         if(env->mIsServiceAvailable)
1106         {
1107                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1108                 am_Error_e error = E_OK;
1109                 org::genivi::am::am_sourceID_t testID = TEST_ID_1;
1110
1111                 org::genivi::am::am_Availability_s available(org::genivi::am::am_Availability_e::A_MAX, AR_UNKNOWN);
1112                 am_Availability_s amAvailable;
1113                 CAmConvertCAPI2AM(available, amAvailable);
1114
1115                 EXPECT_CALL(*env->mpRoutingReceive, hookSourceAvailablityStatusChange(testID, IsAvailabilityEqualTo(amAvailable))).Times(1);
1116                 env->mProxy->hookSourceAvailablityStatusChange(testID, available, callStatus);
1117                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1118         }
1119         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1120 }
1121
1122 TEST_F(CAmRoutingInterfaceCAPITests, hookDomainStateChange)
1123 {
1124         ASSERT_TRUE(env->mIsServiceAvailable);
1125         if(env->mIsServiceAvailable)
1126         {
1127                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1128                 am_Error_e error = E_OK;
1129                 org::genivi::am::am_domainID_t testID = TEST_ID_1;
1130                 org::genivi::am::am_DomainState_e domainState = org::genivi::am::am_DomainState_e::DS_MAX;
1131                 EXPECT_CALL(*env->mpRoutingReceive, hookDomainStateChange(testID, (am_DomainState_e)domainState)).Times(1);
1132                 env->mProxy->hookDomainStateChange(testID, domainState, callStatus);
1133                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1134         }
1135         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1136 }
1137
1138 TEST_F(CAmRoutingInterfaceCAPITests, hookTimingInformationChanged)
1139 {
1140         ASSERT_TRUE(env->mIsServiceAvailable);
1141         if(env->mIsServiceAvailable)
1142         {
1143                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1144                 am_Error_e error = E_OK;
1145                 org::genivi::am::am_connectionID_t testID = TEST_ID_1;
1146                 int16_t delay = 10;
1147                 org::genivi::am::am_DomainState_e domainState = org::genivi::am::am_DomainState_e::DS_MAX;
1148                 EXPECT_CALL(*env->mpRoutingReceive, hookTimingInformationChanged(testID, delay)).Times(1);
1149                 env->mProxy->hookTimingInformationChanged(testID, delay, callStatus);
1150                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1151         }
1152         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1153 }
1154
1155 MATCHER_P(IsEarlyDataEqualTo, value, "") {
1156
1157         std::vector<am_EarlyData_s> lh = arg;
1158         bool result = lh.size() == value.size();
1159         for(int i=0; result && i<lh.size(); i++)
1160         {
1161                 am_EarlyData_s ed_lh = lh.at(i);
1162                 org::genivi::am::am_EarlyData_s ed_rh = value.at(i);
1163                 if(ed_lh.type != static_cast<am_EarlyDataType_e>(ed_rh.type))
1164                 {
1165                         result = false;
1166                         break;
1167                 }
1168                 else
1169                 {
1170                         if(ed_lh.type==ED_SINK_VOLUME)
1171                         {
1172                                 result &= ed_lh.data.volume == ed_rh.data.get<org::genivi::am::am_volume_t>();
1173                                 result &= ed_lh.sinksource.sink == ed_rh.sinksource.get<org::genivi::am::am_sinkID_t>();
1174                         }
1175                         else if(ed_lh.type==ED_SINK_PROPERTY)
1176                         {
1177                                 org::genivi::am::am_SoundProperty_s soundproperty=ed_rh.data.get<org::genivi::am::am_SoundProperty_s>();
1178                                 result &= ed_lh.data.soundProperty.type == soundproperty.type;
1179                                 result &= ed_lh.data.soundProperty.value == soundproperty.value;
1180                                 result &= ed_lh.sinksource.sink == ed_rh.sinksource.get<org::genivi::am::am_sinkID_t>();
1181                         }
1182                         else if(ed_lh.type==ED_SOURCE_VOLUME)
1183                         {
1184                                 result &= ed_lh.data.volume == ed_rh.data.get<org::genivi::am::am_volume_t>();
1185                                 result &= ed_lh.sinksource.source == ed_rh.sinksource.get<org::genivi::am::am_sourceID_t>();
1186                         }
1187                         else if(ed_lh.type==ED_SOURCE_PROPERTY)
1188                         {
1189                                 org::genivi::am::am_SoundProperty_s soundproperty=ed_rh.data.get<org::genivi::am::am_SoundProperty_s>();
1190                                 result &= ed_lh.data.soundProperty.type == soundproperty.type;
1191                                 result &= ed_lh.data.soundProperty.value == soundproperty.value;
1192                                 result &= ed_lh.sinksource.source == ed_rh.sinksource.get<org::genivi::am::am_sinkID_t>();
1193                         }
1194                         else
1195                         {
1196                                 result = false;
1197                                 break;
1198                         }
1199                 }
1200         }
1201
1202         return result;
1203 }
1204
1205 TEST_F(CAmRoutingInterfaceCAPITests, sendChangedData)
1206 {
1207         ASSERT_TRUE(env->mIsServiceAvailable);
1208         if(env->mIsServiceAvailable)
1209         {
1210                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1211                 am_Error_e error = E_OK;
1212                 org::genivi::am::am_connectionID_t testID = TEST_ID_1;
1213                 org::genivi::am::am_EarlyData_L earlyData;
1214
1215                 org::genivi::am::am_DataType_u dt11(static_cast<org::genivi::am::am_sinkID_t>(103));
1216                 org::genivi::am::am_EarlyData_u ed11(static_cast<org::genivi::am::am_volume_t>(50));
1217                 earlyData.push_back(org::genivi::am::am_EarlyData_s(org::genivi::am::am_EarlyDataType_e::ED_SINK_VOLUME,
1218                                                                                         dt11,
1219                                                                                         ed11));
1220                 org::genivi::am::am_DataType_u dt12(static_cast<org::genivi::am::am_sinkID_t>(104));
1221                 earlyData.push_back(org::genivi::am::am_EarlyData_s(org::genivi::am::am_EarlyDataType_e::ED_SINK_VOLUME,
1222                                                                                         dt12,
1223                                                                                         ed11));
1224
1225                 org::genivi::am::am_DataType_u dt13(static_cast<org::genivi::am::am_sinkID_t>(105));
1226                 org::genivi::am::am_EarlyData_u ed12(org::genivi::am::am_SoundProperty_s(SP_UNKNOWN, 50));
1227                 earlyData.push_back(org::genivi::am::am_EarlyData_s(org::genivi::am::am_EarlyDataType_e::ED_SINK_PROPERTY,
1228                                                                                         dt13,
1229                                                                                         ed12));
1230                 org::genivi::am::am_DataType_u dt14(static_cast<org::genivi::am::am_sinkID_t>(106));
1231                 earlyData.push_back(org::genivi::am::am_EarlyData_s(org::genivi::am::am_EarlyDataType_e::ED_SINK_PROPERTY,
1232                                                                                         dt14,
1233                                                                                         ed12));
1234
1235                 EXPECT_CALL(*env->mpRoutingReceive, sendChangedData(IsEarlyDataEqualTo(earlyData))).Times(1);
1236
1237                 env->mProxy->sendChangedData(earlyData, callStatus);
1238         }
1239         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1240 }
1241
1242 TEST_F(CAmRoutingInterfaceCAPITests, updateGateway)
1243 {
1244         ASSERT_TRUE(env->mIsServiceAvailable);
1245         if(env->mIsServiceAvailable)
1246         {
1247                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1248                 am_Error_e error = E_OK;
1249                 org::genivi::am::am_gatewayID_t testID = TEST_ID_1;
1250
1251                 org::genivi::am::am_ConnectionFormat_L listSourceFormats;
1252                 listSourceFormats.push_back(static_cast<org::genivi::am::am_CustomConnectionFormat_t>(CF_GENIVI_ANALOG));
1253                 listSourceFormats.push_back(static_cast<org::genivi::am::am_CustomConnectionFormat_t>(CF_GENIVI_AUTO));
1254
1255                 org::genivi::am::am_ConnectionFormat_L listSinkFormats;
1256                 listSinkFormats.push_back(static_cast<org::genivi::am::am_CustomConnectionFormat_t>(CF_GENIVI_AUTO));
1257                 listSinkFormats.push_back(static_cast<org::genivi::am::am_CustomConnectionFormat_t>(CF_GENIVI_ANALOG));
1258
1259                 org::genivi::am::am_Convertion_L convertionMatrix;
1260                 convertionMatrix.push_back(1);
1261                 convertionMatrix.push_back(0);
1262
1263                 std::vector<am_CustomConnectionFormat_t> am_listSourceFormats;
1264                 am_listSourceFormats.push_back(CF_GENIVI_ANALOG);
1265                 am_listSourceFormats.push_back(CF_GENIVI_AUTO);
1266
1267                 std::vector<am_CustomConnectionFormat_t> am_listSinkFormats;
1268                 am_listSinkFormats.push_back(CF_GENIVI_AUTO);
1269                 am_listSinkFormats.push_back(CF_GENIVI_ANALOG);
1270
1271                 std::vector<bool> am_convertionMatrix;
1272                 am_convertionMatrix.push_back(1);
1273                 am_convertionMatrix.push_back(0);
1274                 ON_CALL(*env->mpRoutingReceive, updateGateway(_, _, _, _)).WillByDefault(Return(E_OK));
1275                 EXPECT_CALL(*env->mpRoutingReceive, updateGateway(testID, am_listSourceFormats, am_listSinkFormats, am_convertionMatrix)).Times(1);
1276
1277                 org::genivi::am::am_Error_e CAPIError;
1278                 env->mProxy->updateGateway(testID, listSourceFormats, listSinkFormats, convertionMatrix, callStatus,CAPIError);
1279                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1280         }
1281         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1282 }
1283
1284 MATCHER_P(IsSoundPropertiesArrayEqualTo, value, "") {
1285         auto lh = arg;
1286
1287         bool bSoundProperties = lh.size() == value.size();
1288         for(int i=0; i<lh.size(); i++)
1289         {
1290                 bSoundProperties &= (lh.at(i).type==value.at(i).type &&
1291                                                                  lh.at(i).value==value.at(i).value);
1292         }
1293         return bSoundProperties;
1294 }
1295
1296 void prepareArrays(     org::genivi::am::am_SoundProperty_L & listSoundProperties,
1297                                                 org::genivi::am::am_ConnectionFormat_L & listSinkFormats,
1298                                                 org::genivi::am::am_MainSoundProperty_L & listMainSoundProperties,
1299                                                 std::vector<am_CustomConnectionFormat_t> & am_listSinkFormats,
1300                                                 std::vector<am_SoundProperty_s> & am_listSoundProperties,
1301                                                 std::vector<am_MainSoundProperty_s> & am_listMainSoundProperties)
1302 {
1303         listSoundProperties.push_back(org::genivi::am::am_SoundProperty_s(SP_UNKNOWN, 50));
1304         listSoundProperties.push_back(org::genivi::am::am_SoundProperty_s(SP_UNKNOWN, 51));
1305
1306         listSinkFormats.push_back(static_cast<org::genivi::am::am_CustomConnectionFormat_t>(CF_GENIVI_AUTO));
1307         listSinkFormats.push_back(static_cast<org::genivi::am::am_CustomConnectionFormat_t>(CF_GENIVI_ANALOG));
1308
1309         listMainSoundProperties.push_back(org::genivi::am::am_MainSoundProperty_s(MSP_UNKNOWN, 50));
1310         listMainSoundProperties.push_back(org::genivi::am::am_MainSoundProperty_s(MSP_UNKNOWN, 51));
1311
1312         am_listSinkFormats.push_back(CF_GENIVI_AUTO);
1313         am_listSinkFormats.push_back(CF_GENIVI_ANALOG);
1314
1315         am_listSoundProperties.push_back((am_SoundProperty_s){SP_UNKNOWN, 50});
1316         am_listSoundProperties.push_back((am_SoundProperty_s){SP_UNKNOWN, 51});
1317
1318         am_listMainSoundProperties.push_back((am_MainSoundProperty_s){MSP_UNKNOWN, 50});
1319         am_listMainSoundProperties.push_back((am_MainSoundProperty_s){MSP_UNKNOWN, 51});
1320 }
1321
1322 TEST_F(CAmRoutingInterfaceCAPITests, updateSink)
1323 {
1324         ASSERT_TRUE(env->mIsServiceAvailable);
1325         if(env->mIsServiceAvailable)
1326         {
1327                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1328                 am_Error_e error = E_OK;
1329                 org::genivi::am::am_sinkID_t testID = TEST_ID_1;
1330
1331                 org::genivi::am::am_SoundProperty_L listSoundProperties;
1332                 org::genivi::am::am_ConnectionFormat_L listSinkFormats;
1333                 org::genivi::am::am_MainSoundProperty_L listMainSoundProperties;
1334                 std::vector<am_CustomConnectionFormat_t> am_listSinkFormats;
1335                 std::vector<am_SoundProperty_s> am_listSoundProperties;
1336                 std::vector<am_MainSoundProperty_s> am_listMainSoundProperties;
1337                 prepareArrays(listSoundProperties, listSinkFormats, listMainSoundProperties, am_listSinkFormats, am_listSoundProperties, am_listMainSoundProperties);
1338
1339                 ON_CALL(*env->mpRoutingReceive, updateSink(_, _, _, _, _)).WillByDefault(Return(E_OK));
1340                 EXPECT_CALL(*env->mpRoutingReceive, updateSink(testID, TEST_ID_2, IsSoundPropertiesArrayEqualTo(am_listSoundProperties), am_listSinkFormats, IsSoundPropertiesArrayEqualTo(am_listMainSoundProperties))).Times(1);
1341                 org::genivi::am::am_Error_e CAPIError;
1342                 env->mProxy->updateSink(testID, TEST_ID_2, listSoundProperties, listSinkFormats, listMainSoundProperties, callStatus,CAPIError);
1343                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1344         }
1345         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1346 }
1347
1348 TEST_F(CAmRoutingInterfaceCAPITests, updateSource)
1349 {
1350         ASSERT_TRUE(env->mIsServiceAvailable);
1351         if(env->mIsServiceAvailable)
1352         {
1353                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1354                 am_Error_e error = E_OK;
1355                 org::genivi::am::am_sourceID_t testID = TEST_ID_1;
1356
1357                 org::genivi::am::am_SoundProperty_L listSoundProperties;
1358                 org::genivi::am::am_ConnectionFormat_L listSinkFormats;
1359                 org::genivi::am::am_MainSoundProperty_L listMainSoundProperties;
1360                 std::vector<am_CustomConnectionFormat_t> am_listSinkFormats;
1361                 std::vector<am_SoundProperty_s> am_listSoundProperties;
1362                 std::vector<am_MainSoundProperty_s> am_listMainSoundProperties;
1363                 prepareArrays(listSoundProperties, listSinkFormats, listMainSoundProperties, am_listSinkFormats, am_listSoundProperties, am_listMainSoundProperties);
1364
1365                 ON_CALL(*env->mpRoutingReceive, updateSource(_, _, _, _, _)).WillByDefault(Return(E_OK));
1366                 EXPECT_CALL(*env->mpRoutingReceive, updateSource(testID, TEST_ID_2, IsSoundPropertiesArrayEqualTo(am_listSoundProperties), am_listSinkFormats, IsSoundPropertiesArrayEqualTo(am_listMainSoundProperties))).Times(1);
1367                 org::genivi::am::am_Error_e CAPIError;
1368                 env->mProxy->updateSource(testID, TEST_ID_2, listSoundProperties, listSinkFormats, listMainSoundProperties, callStatus,CAPIError);
1369                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1370         }
1371         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1372 }
1373
1374
1375 MATCHER_P2(IsSinkVolumeArrayEqualTo, value, isSink,  "") {
1376
1377         std::vector<am_Volumes_s> lh = arg;
1378         bool bResult = lh.size() == value.size();
1379         for(int i=0; i<lh.size(); i++)
1380         {
1381                 bResult &= (((isSink && lh.at(i).volumeID.sink==value.at(i).volumeID.sink) || (!isSink && lh.at(i).volumeID.source==value.at(i).volumeID.source)) &&
1382                                         lh.at(i).volume==value.at(i).volume &&
1383                                         lh.at(i).ramp==value.at(i).ramp &&
1384                                         lh.at(i).time==value.at(i).time);
1385         }
1386         return bResult;
1387 }
1388
1389 MATCHER_P(IsHandleStructEqualTo, value, "") {
1390         am_Handle_s lh = arg;
1391         return lh.handle==value.handle &&
1392                         lh.handleType==value.handleType ;
1393 }
1394
1395 TEST_F(CAmRoutingInterfaceCAPITests, ackSetVolumes)
1396 {
1397         ASSERT_TRUE(env->mIsServiceAvailable);
1398         if(env->mIsServiceAvailable)
1399         {
1400                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1401                 uint16_t error = (uint16_t)E_OK;
1402                 uint16_t testID = 10;
1403                 org::genivi::am::am_Volumes_L listVolumes;
1404                 org::genivi::am::am_DataType_u dt(static_cast<org::genivi::am::am_sinkID_t>(103));
1405                 listVolumes.push_back(org::genivi::am::am_Volumes_s(org::genivi::am::am_VolumeType_e::VT_MAX,
1406                                                                                                    dt,
1407                                                                                                    50,
1408                                                                                                    static_cast<org::genivi::am::am_CustomRampType_t>(RAMP_GENIVI_DIRECT),
1409                                                                                                    50));
1410
1411                 std::vector<am_Volumes_s> am_listVolumes;
1412                 am_DataType_u dt1;
1413                 dt1.sink = 103;
1414                 am_listVolumes.push_back((am_Volumes_s){VT_MAX,
1415                                                                                                 dt1,
1416                                                                                                 50,
1417                                                                                                 RAMP_GENIVI_DIRECT,
1418                                                                                                 50});
1419
1420                 am_Handle_s handle_s;
1421                 handle_s.handle = 10;
1422                 handle_s.handleType = H_SETVOLUMES;
1423                 org::genivi::am::am_Handle_s handle;
1424                 CAmConvertAM2CAPI(handle_s,handle);
1425                 org::genivi::am::am_Error_e genError(org::genivi::am::am_Error_e::E_OK);
1426                 EXPECT_CALL(*env->mpRoutingReceive, ackSetVolumes(IsHandleStructEqualTo(handle_s), IsSinkVolumeArrayEqualTo(am_listVolumes, true), E_OK)).Times(1);
1427                 env->mProxy->ackSetVolumes(handle, listVolumes, genError, callStatus);
1428                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1429         }
1430         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1431 }
1432
1433 TEST_F(CAmRoutingInterfaceCAPITests, ackSinkNotificationConfiguration)
1434 {
1435         ASSERT_TRUE(env->mIsServiceAvailable);
1436         if(env->mIsServiceAvailable)
1437         {
1438                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1439                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_OK;
1440                 uint16_t testID = TEST_ID_1;
1441                 am_Handle_s handle_s;
1442                 handle_s.handle = testID;
1443                 handle_s.handleType = H_CONNECT;
1444                 org::genivi::am::am_Handle_s CAPIHandle;
1445                 CAmConvertAM2CAPI(handle_s,CAPIHandle);
1446                 org::genivi::am::am_Error_e genError(org::genivi::am::am_Error_e::E_OK);
1447                 EXPECT_CALL(*env->mpRoutingReceive, ackSinkNotificationConfiguration(IsHandleStructEqualTo(handle_s), (am_Error_e)error)).Times(1);
1448                 env->mProxy->ackSinkNotificationConfiguration(CAPIHandle, genError, callStatus);
1449                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1450         }
1451         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1452 }
1453
1454 TEST_F(CAmRoutingInterfaceCAPITests, ackSourceNotificationConfiguration)
1455 {
1456         ASSERT_TRUE(env->mIsServiceAvailable);
1457         if(env->mIsServiceAvailable)
1458         {
1459                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1460                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_OK;
1461                 uint16_t testID = TEST_ID_1;
1462                 am_Handle_s handle_s;
1463                 handle_s.handle = testID;
1464                 handle_s.handleType = H_CONNECT;
1465                 org::genivi::am::am_Handle_s CAPIHandle;
1466                 CAmConvertAM2CAPI(handle_s,CAPIHandle);
1467                 org::genivi::am::am_Error_e genError(org::genivi::am::am_Error_e::E_OK);
1468                 EXPECT_CALL(*env->mpRoutingReceive, ackSourceNotificationConfiguration(IsHandleStructEqualTo(handle_s), (am_Error_e)error)).Times(1);
1469                 env->mProxy->ackSourceNotificationConfiguration(CAPIHandle, genError, callStatus);
1470                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1471         }
1472         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1473 }
1474
1475 MATCHER_P(IsPayloadEqualTo, value,  "") {
1476
1477         auto lh = arg;
1478         return lh.type == value.type && lh.value == value.value;
1479 }
1480
1481
1482 TEST_F(CAmRoutingInterfaceCAPITests, hookSinkNotificationDataChange)
1483 {
1484         ASSERT_TRUE(env->mIsServiceAvailable);
1485         if(env->mIsServiceAvailable)
1486         {
1487                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1488                 am_Error_e error = E_OK;
1489                 org::genivi::am::am_sinkID_t testID = TEST_ID_1;
1490                 org::genivi::am::am_NotificationPayload_s payload(NT_UNKNOWN, 50);
1491
1492                 am_NotificationPayload_s am_payload = (am_NotificationPayload_s){NT_UNKNOWN, 50};
1493
1494                 EXPECT_CALL(*env->mpRoutingReceive, hookSinkNotificationDataChange(testID, IsPayloadEqualTo(am_payload))).Times(1);
1495                 env->mProxy->hookSinkNotificationDataChange(testID, payload, callStatus);
1496                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1497         }
1498         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1499 }
1500
1501 TEST_F(CAmRoutingInterfaceCAPITests, hookSourceNotificationDataChange)
1502 {
1503         ASSERT_TRUE(env->mIsServiceAvailable);
1504         if(env->mIsServiceAvailable)
1505         {
1506                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1507                 am_Error_e error = E_OK;
1508                 org::genivi::am::am_sourceID_t testID = TEST_ID_1;
1509                 org::genivi::am::am_NotificationPayload_s payload(NT_UNKNOWN, 50);
1510
1511                 am_NotificationPayload_s am_payload = (am_NotificationPayload_s){NT_UNKNOWN, 50};
1512
1513                 EXPECT_CALL(*env->mpRoutingReceive, hookSourceNotificationDataChange(testID, IsPayloadEqualTo(am_payload))).Times(1);
1514                 env->mProxy->hookSourceNotificationDataChange(testID, payload, callStatus);
1515                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1516         }
1517         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1518 }
1519
1520 ACTION(actionRegister2){
1521         arg1=TEST_ID_2;
1522 }
1523
1524 TEST_F(CAmRoutingInterfaceCAPITests, confirmRoutingRundown)
1525 {
1526         ASSERT_TRUE(env->mIsServiceAvailable);
1527         if(env->mIsServiceAvailable)
1528         {
1529                 CallStatus callStatus = CallStatus::NOT_AVAILABLE, domainstatus = CallStatus::NOT_AVAILABLE;
1530                 org::genivi::am::am_domainID_t domainID;
1531                 am_Error_e error = E_OK;
1532                 org::genivi::am::am_Error_e CAPIError;
1533                 std::string name("test domain name");
1534         std::string busname("busname");
1535         std::string nodename("nodename");
1536                 org::genivi::am::am_Domain_s domainData(0, name, busname, nodename, false, false, org::genivi::am::am_DomainState_e::DS_CONTROLLED);
1537                 ON_CALL(*env->mpRoutingReceive, registerDomain(_,_)).WillByDefault(Return(E_OK));
1538                 EXPECT_CALL(*env->mpRoutingReceive, registerDomain(_, _));
1539                 env->mProxy->registerDomain(domainData,"sd","sd",domainstatus,domainID,CAPIError);
1540                 ASSERT_EQ( domainstatus, CallStatus::SUCCESS );
1541                 env->mpPlugin->setRoutingRundown(5);
1542                 EXPECT_CALL(*env->mpRoutingReceive, confirmRoutingRundown(5,E_OK)).Times(1);
1543                 env->mProxy->confirmRoutingRundown(name, callStatus);
1544                 EXPECT_CALL(*env->mpRoutingReceive, deregisterDomain(_));
1545                 env->mProxy->deregisterDomain(domainID,domainstatus,CAPIError);
1546                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1547         }
1548         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1549 }
1550
1551 /** CAmRoutingSenderCAPITests
1552  * The following methods must be executed in the given order.
1553  * It is important that the TestDomain_register* methods are executed first because they make domain, sink, source and crossfader registrations.
1554  * The last couple of methods are TestDomain_deregister* methods which check whether the 'deregistration' functionality works properly.
1555  */
1556
1557 TEST_F(CAmRoutingSenderCAPITests, TestDomain_registerDomain)
1558 {
1559         ASSERT_TRUE(env->mIsServiceAvailable);
1560         if(env->mIsServiceAvailable)
1561         {
1562                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1563                 ASSERT_FALSE( backdoor.containsDomainWithID( (const am_domainID_t)TEST_ID_1) );
1564
1565                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1566                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
1567                 org::genivi::am::am_domainID_t domainID = 0;
1568             org::genivi::am::am_Domain_s domainData;
1569             domainData.name = "TestDomain";
1570             domainData.busname ="TestDomain";
1571             domainData.complete = true;
1572             domainData.domainID = domainID;
1573             domainData.early = false;
1574             domainData.nodename = "Test";
1575             domainData.state = org::genivi::am::am_DomainState_e::DS_CONTROLLED;
1576
1577                 am::am_Domain_s amDomainData;
1578                 CAmConvertCAPI2AM(domainData, amDomainData);
1579
1580                 ON_CALL(*env->mpRoutingReceive, registerDomain(_, _)).WillByDefault(Return(E_OK));
1581
1582                 EXPECT_CALL(*env->mpRoutingReceive, registerDomain(IsDomainDataEqualTo(amDomainData), _)).WillOnce(DoAll(actionRegister(), Return(E_OK)));
1583             env->mProxy->registerDomain(domainData,
1584                                                                     CAPI_SENDER_INSTANCE,
1585                                                                     CAPI_SENDER_INTERFACE,
1586                                                                     callStatus,
1587                                                                     domainID,
1588                                                                     error);
1589             usleep(50000);
1590                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1591                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
1592                 ASSERT_EQ( domainID, TEST_ID_1 );
1593                 ASSERT_TRUE( backdoor.containsDomainWithID(domainID) );
1594
1595                 domainID = 0;
1596                 domainData.domainID = 0;
1597             domainData.name = "TestDomain2";
1598             domainData.busname ="TestDomain2";
1599                 CAmConvertCAPI2AM(domainData, amDomainData);
1600                 EXPECT_CALL(*env->mpRoutingReceive, registerDomain(IsDomainDataEqualTo(amDomainData), _)).WillOnce(DoAll(actionRegister2(), Return(E_OK)));
1601                 env->mProxy->registerDomain(domainData,
1602                                                                         CAPI_SENDER_INSTANCE,
1603                                                                         CAPI_SENDER_INTERFACE,
1604                                                                         callStatus,
1605                                                                         domainID,
1606                                                                         error);
1607                 usleep(50000);
1608                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1609                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
1610                 ASSERT_EQ( domainID, TEST_ID_2 );
1611                 ASSERT_TRUE( backdoor.domainsCount()==2 );
1612                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)TEST_ID_1) );
1613                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)TEST_ID_2) );
1614                 ASSERT_FALSE( backdoor.containsDomainWithID( (const am_domainID_t)10000) );
1615         }
1616         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1617 }
1618
1619 TEST_F(CAmRoutingSenderCAPITests, TestDomain_registerSource)
1620 {
1621         ASSERT_TRUE(env->mIsServiceAvailable);
1622         if(env->mIsServiceAvailable)
1623         {
1624                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1625                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1626                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1627
1628                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1629                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
1630
1631                 org::genivi::am::am_Source_s source;
1632                 am_Source_s amSource;
1633                 org::genivi::am::am_sourceID_t sinkID = 0;
1634                 initSource(source, amSource, domainID, sinkID);
1635
1636                 ON_CALL(*env->mpRoutingReceive, registerSource(_, _)).WillByDefault(Return(E_OK));
1637                 EXPECT_CALL(*env->mpRoutingReceive, registerSource(IsSourceDataEqualTo(amSource), _)).WillOnce(DoAll(actionRegister(), Return(E_OK)));
1638                 env->mProxy->registerSource(source, callStatus, sinkID, error);
1639                 usleep(50000);
1640                 ASSERT_EQ( sinkID, TEST_ID_1 );
1641                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
1642                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1643                 ASSERT_TRUE( backdoor.containsSourceWithID( (const am_sourceID_t)TEST_ID_1) );
1644
1645                 initSource(source, amSource, domainID, sinkID);
1646                 EXPECT_CALL(*env->mpRoutingReceive, registerSource(IsSourceDataEqualTo(amSource), _)).WillOnce(DoAll(actionRegister2(), Return(E_OK)));
1647                 env->mProxy->registerSource(source, callStatus, sinkID, error);
1648                 usleep(50000);
1649                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1650                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
1651                 ASSERT_EQ( sinkID, TEST_ID_2 );
1652                 ASSERT_TRUE( backdoor.containsSourceWithID( (const am_sourceID_t)TEST_ID_2) );
1653                 ASSERT_TRUE( backdoor.sourcesCount()==2 );
1654         }
1655         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1656 }
1657
1658
1659
1660 TEST_F(CAmRoutingSenderCAPITests, TestDomain_registerSink)
1661 {
1662         ASSERT_TRUE(env->mIsServiceAvailable);
1663         if(env->mIsServiceAvailable)
1664         {
1665                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1666                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1667                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1668
1669                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1670                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
1671
1672                 org::genivi::am::am_Sink_s sink;
1673                 am_Sink_s amSink;
1674                 org::genivi::am::am_sinkID_t sinkID = 0;
1675                 initSink(sink, amSink, domainID, sinkID);
1676
1677                 ON_CALL(*env->mpRoutingReceive, registerSink(_, _)).WillByDefault(Return(E_OK));
1678                 EXPECT_CALL(*env->mpRoutingReceive, registerSink(IsSinkDataEqualTo(amSink), _)).WillOnce(DoAll(actionRegister(), Return(E_OK)));
1679                 env->mProxy->registerSink(sink, callStatus, sinkID, error);
1680
1681                 usleep(50000);
1682                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1683                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
1684                 ASSERT_EQ( sinkID, TEST_ID_1 );
1685                 ASSERT_TRUE( backdoor.containsSinkWithID( (const am_sourceID_t)TEST_ID_1) );
1686
1687                 initSink(sink, amSink, TEST_ID_1, 0);
1688                 EXPECT_CALL(*env->mpRoutingReceive, registerSink(IsSinkDataEqualTo(amSink), _)).WillOnce(DoAll(actionRegister2(), Return(E_OK)));
1689                 env->mProxy->registerSink(sink, callStatus, sinkID, error);
1690
1691                 usleep(50000);
1692                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1693                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
1694                 ASSERT_EQ( sinkID, TEST_ID_2 );
1695                 ASSERT_TRUE( backdoor.containsSinkWithID( (const am_sourceID_t)TEST_ID_2) );
1696                 ASSERT_TRUE( backdoor.sinksCount()==2 );
1697         }
1698         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1699 }
1700
1701 TEST_F(CAmRoutingSenderCAPITests, TestDomain_setDomainState)
1702 {
1703 //todo: Decide how to test
1704 }
1705
1706 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncSetSourceState)
1707 {
1708         ASSERT_TRUE(env->mIsServiceAvailable);
1709         if(env->mIsServiceAvailable)
1710         {
1711                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1712                 const org::genivi::am::am_sourceID_t sID = TEST_ID_1;
1713                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1714                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1715                 ASSERT_TRUE( backdoor.containsSourceWithID( (const am_sourceID_t)sID) );
1716
1717                 am_volume_t volume = 50;
1718                 am_Handle_s handle = {H_SETSOURCESTATE, 20};
1719                 am_SourceState_e state = am_SourceState_e::SS_MAX;
1720                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSourceState(IsHandleEqual(handle), E_OK)).Times(1);
1721                 am_Error_e error = env->mpPlugin->asyncSetSourceState(handle, sID, state);
1722                 usleep(50000);
1723                 ASSERT_EQ( error, E_OK );
1724                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
1725         }
1726
1727         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1728 }
1729
1730 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncSetSourceVolume)
1731 {
1732         ASSERT_TRUE(env->mIsServiceAvailable);
1733         if(env->mIsServiceAvailable)
1734         {
1735                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1736                 const org::genivi::am::am_sourceID_t sID = TEST_ID_1;
1737                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1738                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1739                 ASSERT_TRUE( backdoor.containsSourceWithID( (const am_sourceID_t)sID) );
1740
1741                 am_volume_t volume = 50;
1742                 am_time_t time = 10;
1743                 am_CustomRampType_t ramp = RAMP_GENIVI_DIRECT;
1744                 am_Handle_s handle = {H_SETSOURCEVOLUME, 20};
1745                 am_SourceState_e state = am_SourceState_e::SS_MAX;
1746                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSourceVolumeChange(IsHandleEqual(handle), volume, E_OK)).Times(1);
1747                 am_Error_e error = env->mpPlugin->asyncSetSourceVolume(handle, sID, volume, ramp, time);
1748                 usleep(50000);
1749                 ASSERT_EQ( error, E_OK );
1750                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
1751         }
1752
1753         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1754 }
1755
1756 TEST_F(CAmRoutingSenderCAPITests, TestDomain_registerCrossfader)
1757 {
1758         ASSERT_TRUE(env->mIsServiceAvailable);
1759         if(env->mIsServiceAvailable)
1760         {
1761                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1762                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1763                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1764
1765                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
1766                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
1767
1768                 org::genivi::am::am_crossfaderID_t crossfaderID = 0;
1769                 org::genivi::am::am_Crossfader_s crossfaderData;
1770                 am_Crossfader_s amCrossfaderData;
1771                 initCrossfader(crossfaderData, amCrossfaderData, crossfaderID);
1772
1773                 ON_CALL(*env->mpRoutingReceive, registerCrossfader(_, _)).WillByDefault(Return(E_OK));
1774                 EXPECT_CALL(*env->mpRoutingReceive, registerCrossfader(IsCrossfaderDataEqualTo(amCrossfaderData), _)).WillOnce(DoAll(actionRegister(), Return(E_OK)));
1775                 env->mProxy->registerCrossfader(crossfaderData, callStatus, crossfaderID, error);
1776
1777                 usleep(50000);
1778                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
1779                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
1780                 ASSERT_EQ( crossfaderID, TEST_ID_1 );
1781                 ASSERT_TRUE( backdoor.containsCrossfader( TEST_ID_1) );
1782         }
1783         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1784 }
1785
1786 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncSetSinkVolume)
1787 {
1788         ASSERT_TRUE(env->mIsServiceAvailable);
1789         if(env->mIsServiceAvailable)
1790         {
1791                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1792                 const org::genivi::am::am_sinkID_t sID = TEST_ID_1;
1793                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1794                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1795                 ASSERT_TRUE( backdoor.containsSourceWithID( (const am_sourceID_t)sID) );
1796
1797                 am_volume_t volume = 50;
1798                 am_time_t time = 10;
1799                 am_CustomRampType_t ramp = RAMP_GENIVI_DIRECT;
1800                 am_Handle_s handle = {H_SETSINKVOLUME, 20};
1801                 am_SourceState_e state = am_SourceState_e::SS_MAX;
1802                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSinkVolumeChange(IsHandleEqual(handle), volume, E_OK)).Times(1);
1803                 am_Error_e error = env->mpPlugin->asyncSetSinkVolume(handle, sID, volume, ramp, time);
1804                 usleep(50000);
1805                 ASSERT_EQ( error, E_OK );
1806                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
1807         }
1808
1809         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1810 }
1811
1812 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncConnect)
1813 {
1814         ASSERT_TRUE(env->mIsServiceAvailable);
1815         if(env->mIsServiceAvailable)
1816         {
1817 //              const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1818                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1819                 ASSERT_TRUE( backdoor.containsDomainWithID( TEST_ID_1 ));
1820                 ASSERT_TRUE( backdoor.containsSinkWithID( TEST_ID_1 ));
1821                 ASSERT_TRUE( backdoor.containsSourceWithID( TEST_ID_1 ));
1822
1823                 org::genivi::am::am_connectionID_t connectionID = TEST_ID_1;
1824                 am_Handle_s handle = {H_CONNECT, 20};
1825                 am_CustomConnectionFormat_t cf = CF_GENIVI_STEREO;
1826                 EXPECT_CALL(*env->mpRoutingReceive, ackConnect(IsHandleEqual(handle), connectionID, E_OK)).Times(1);
1827                 am_Error_e error = env->mpPlugin->asyncConnect(handle, connectionID, TEST_ID_1, TEST_ID_1, cf);
1828                 usleep(50000);
1829                 ASSERT_EQ( error, E_OK );
1830                 ASSERT_FALSE( backdoor.containsHandle( handle.handle ) );
1831                 ASSERT_EQ( backdoor.connectionsCount( ) , 1 );
1832         }
1833         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1834 }
1835
1836 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncDisconnect)
1837 {
1838         ASSERT_TRUE(env->mIsServiceAvailable);
1839         if(env->mIsServiceAvailable)
1840         {
1841                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1842                 ASSERT_TRUE( backdoor.containsDomainWithID( TEST_ID_1 ));
1843                 ASSERT_TRUE( backdoor.containsConnection( TEST_ID_1 ));
1844
1845                 org::genivi::am::am_connectionID_t connectionID = TEST_ID_1;
1846                 am_Handle_s handle = {H_DISCONNECT, 20};
1847                 am_CustomConnectionFormat_t cf = CF_GENIVI_STEREO;
1848                 EXPECT_CALL(*env->mpRoutingReceive, ackDisconnect(IsHandleEqual(handle), connectionID, E_OK)).Times(1);
1849                 am_Error_e error = env->mpPlugin->asyncDisconnect(handle, connectionID);
1850                 usleep(50000);
1851                 ASSERT_EQ( error, E_OK );
1852                 ASSERT_FALSE( backdoor.containsHandle( handle.handle ) );
1853                 ASSERT_FALSE( backdoor.containsConnection( TEST_ID_1 ) );
1854         }
1855         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1856 }
1857
1858 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncAbort)
1859 {
1860         ASSERT_TRUE(env->mIsServiceAvailable);
1861         if(env->mIsServiceAvailable)
1862         {
1863                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1864                 const org::genivi::am::am_sourceID_t sID = TEST_ID_1;
1865                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1866                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1867                 ASSERT_TRUE( backdoor.containsSourceWithID( (const am_sourceID_t)sID) );
1868
1869                 am_volume_t volume = 50;
1870                 am_Handle_s handle = {H_SETSOURCESTATE, 200};
1871                 org::genivi::am::am_Handle_s CAPIHandle;
1872                 CAPIHandle.handle=200;
1873                 CAPIHandle.handleType=org::genivi::am::am_Handle_e::H_SETSOURCESTATE;
1874                 am_SourceState_e state = am_SourceState_e::SS_MAX;
1875
1876                 //we set an abort handle in order to test the return status
1877                 env->mDomainService->setAbortHandle(CAPIHandle);
1878
1879                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSourceState(IsHandleEqual(handle), E_ABORTED)).Times(1);
1880                 am_Error_e error = env->mpPlugin->asyncSetSourceState(handle, sID, state);
1881                 usleep(50000);
1882                 ASSERT_EQ( error, E_OK );
1883                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
1884         }
1885
1886         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1887 }
1888
1889 MATCHER_P(IsListMainSoundPropertiesEqualTo, value, "") {
1890         auto lh = arg;
1891
1892         bool bMainSoundProperties = lh.size() == value.size();
1893         for(int i=0; i<lh.size(); i++)
1894         {
1895                 bMainSoundProperties &= (lh.at(i).type==value.at(i).type &&
1896                                                                  lh.at(i).value==value.at(i).value);
1897         }
1898         return bMainSoundProperties;
1899 }
1900
1901 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncSetSinkSoundProperties)
1902 {
1903         ASSERT_TRUE(env->mIsServiceAvailable);
1904         if(env->mIsServiceAvailable)
1905         {
1906                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1907                 const org::genivi::am::am_sinkID_t sID = TEST_ID_1;
1908                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1909                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1910                 ASSERT_TRUE( backdoor.containsSourceWithID( (const am_sourceID_t)sID) );
1911
1912                 am_Handle_s handle = {H_SETSINKSOUNDPROPERTIES, 200};
1913                 am_SourceState_e state = am_SourceState_e::SS_MAX;
1914
1915                 std::vector<am_SoundProperty_s> listSoundProperties;
1916                 listSoundProperties.push_back((am_SoundProperty_s){SP_GENIVI_MID, 100});
1917                 listSoundProperties.push_back((am_SoundProperty_s){SP_UNKNOWN, 101});
1918                 listSoundProperties.push_back((am_SoundProperty_s){SP_GENIVI_TREBLE, 100});
1919
1920                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSinkSoundProperties(IsHandleEqual(handle), E_OK)).Times(1);
1921                 am_Error_e error = env->mpPlugin->asyncSetSinkSoundProperties(handle, sID, listSoundProperties);
1922                 usleep(50000);
1923                 ASSERT_EQ( error, E_OK );
1924                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
1925         }
1926
1927         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1928 }
1929
1930 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncSetSinkSoundProperty)
1931 {
1932         ASSERT_TRUE(env->mIsServiceAvailable);
1933         if(env->mIsServiceAvailable)
1934         {
1935                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1936                 const org::genivi::am::am_sinkID_t sID = TEST_ID_1;
1937                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1938                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1939                 ASSERT_TRUE( backdoor.containsSourceWithID( (const am_sourceID_t)sID) );
1940
1941                 am_Handle_s handle = {H_SETSINKSOUNDPROPERTY, 200};
1942                 am_SourceState_e state = am_SourceState_e::SS_MAX;
1943
1944                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSinkSoundProperty(IsHandleEqual(handle), E_OK)).Times(1);
1945                 am_Error_e error = env->mpPlugin->asyncSetSinkSoundProperty(handle, sID, (am_SoundProperty_s){SP_GENIVI_MID, 100});
1946                 usleep(50000);
1947                 ASSERT_EQ( error, E_OK );
1948                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
1949         }
1950
1951         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1952 }
1953
1954 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncSetSourceSoundProperties)
1955 {
1956         ASSERT_TRUE(env->mIsServiceAvailable);
1957         if(env->mIsServiceAvailable)
1958         {
1959                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1960                 const org::genivi::am::am_sourceID_t sID = TEST_ID_1;
1961                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1962                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1963                 ASSERT_TRUE( backdoor.containsSourceWithID( (const am_sourceID_t)sID) );
1964
1965                 am_Handle_s handle = {H_SETSOURCESOUNDPROPERTIES, 200};
1966                 am_SourceState_e state = am_SourceState_e::SS_MAX;
1967
1968                 std::vector<am_SoundProperty_s> listSoundProperties;
1969                 listSoundProperties.push_back((am_SoundProperty_s){SP_GENIVI_MID, 100});
1970                 listSoundProperties.push_back((am_SoundProperty_s){SP_UNKNOWN, 101});
1971                 listSoundProperties.push_back((am_SoundProperty_s){SP_GENIVI_TREBLE, 100});
1972
1973                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSourceSoundProperties(IsHandleEqual(handle), E_OK)).Times(1);
1974                 am_Error_e error = env->mpPlugin->asyncSetSourceSoundProperties(handle, sID, listSoundProperties);
1975                 usleep(50000);
1976                 ASSERT_EQ( error, E_OK );
1977                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
1978         }
1979
1980         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
1981 }
1982
1983 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncSetSourceSoundProperty)
1984 {
1985         ASSERT_TRUE(env->mIsServiceAvailable);
1986         if(env->mIsServiceAvailable)
1987         {
1988                 const org::genivi::am::am_domainID_t domainID = TEST_ID_1;
1989                 const org::genivi::am::am_sourceID_t sID = TEST_ID_1;
1990                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
1991                 ASSERT_TRUE( backdoor.containsDomainWithID( (const am_domainID_t)domainID) );
1992                 ASSERT_TRUE( backdoor.containsSourceWithID( (const am_sourceID_t)sID) );
1993
1994                 am_Handle_s handle = {H_SETSOURCESOUNDPROPERTY, 200};
1995                 am_SourceState_e state = am_SourceState_e::SS_MAX;
1996
1997                 EXPECT_CALL(*env->mpRoutingReceive, ackSetSourceSoundProperty(IsHandleEqual(handle), E_OK)).Times(1);
1998                 am_Error_e error = env->mpPlugin->asyncSetSourceSoundProperty(handle, sID, (am_SoundProperty_s){SP_GENIVI_MID, 100});
1999                 usleep(50000);
2000                 ASSERT_EQ( error, E_OK );
2001                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
2002         }
2003
2004         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
2005 }
2006
2007 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncCrossFade)
2008 {
2009         ASSERT_TRUE(env->mIsServiceAvailable);
2010         if(env->mIsServiceAvailable)
2011         {
2012                 const org::genivi::am::am_crossfaderID_t sID = TEST_ID_1;
2013                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
2014                 ASSERT_TRUE( backdoor.containsDomainWithID( TEST_ID_1 ));
2015                 ASSERT_TRUE( backdoor.containsSourceWithID( TEST_ID_1 ));
2016                 ASSERT_TRUE( backdoor.containsCrossfader( TEST_ID_1 ));
2017
2018                 am_Handle_s handle = {H_CROSSFADE, 200};
2019                 am_CustomRampType_t state = RAMP_GENIVI_DIRECT;
2020                 am_HotSink_e hotSink = HS_UNKNOWN;
2021                 EXPECT_CALL(*env->mpRoutingReceive, ackCrossFading(IsHandleEqual(handle), hotSink, E_OK)).Times(1);
2022                 am_Error_e error = env->mpPlugin->asyncCrossFade(handle, sID, hotSink, state, 50);
2023                 usleep(50000);
2024                 ASSERT_EQ( error, E_OK );
2025                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
2026         }
2027
2028         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
2029 }
2030
2031 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncSetSinkNotificationConfiguration)
2032 {
2033         ASSERT_TRUE(env->mIsServiceAvailable);
2034         if(env->mIsServiceAvailable)
2035         {
2036                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
2037                 ASSERT_TRUE( backdoor.containsDomainWithID( TEST_ID_1 ));
2038                 ASSERT_TRUE( backdoor.containsSinkWithID( TEST_ID_1 ));
2039
2040                 am_Handle_s handle = {H_CONNECT, 200};
2041                 am_NotificationConfiguration_s nc = (am_NotificationConfiguration_s){NT_UNKNOWN, am_NotificationStatus_e::NS_MAX};
2042                 EXPECT_CALL(*env->mpRoutingReceive, ackSinkNotificationConfiguration(IsHandleStructEqualTo(handle), E_OK)).Times(1);
2043                 am_Error_e error = env->mpPlugin->asyncSetSinkNotificationConfiguration(handle, TEST_ID_1, nc);
2044                 usleep(50000);
2045                 ASSERT_EQ( error, E_OK );
2046                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
2047         }
2048
2049         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
2050 }
2051
2052 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncSetSourceNotificationConfiguration)
2053 {
2054         ASSERT_TRUE(env->mIsServiceAvailable);
2055         if(env->mIsServiceAvailable)
2056         {
2057                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
2058                 ASSERT_TRUE( backdoor.containsDomainWithID( TEST_ID_1 ));
2059                 ASSERT_TRUE( backdoor.containsSinkWithID( TEST_ID_1 ));
2060
2061                 am_Handle_s handle = {H_CONNECT, 200};
2062                 am_NotificationConfiguration_s nc = (am_NotificationConfiguration_s){NT_UNKNOWN, am_NotificationStatus_e::NS_MAX};
2063                 EXPECT_CALL(*env->mpRoutingReceive, ackSourceNotificationConfiguration(IsHandleStructEqualTo(handle), E_OK)).Times(1);
2064                 am_Error_e error = env->mpPlugin->asyncSetSourceNotificationConfiguration(handle, TEST_ID_1, nc);
2065                 usleep(50000);
2066                 ASSERT_EQ( error, E_OK );
2067                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
2068         }
2069
2070         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
2071 }
2072
2073 TEST_F(CAmRoutingSenderCAPITests, TestDomain_asyncSetVolumes)
2074 {
2075         ASSERT_TRUE(env->mIsServiceAvailable);
2076         if(env->mIsServiceAvailable)
2077         {
2078                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
2079                 ASSERT_TRUE( backdoor.containsDomainWithID( TEST_ID_1) );
2080                 ASSERT_TRUE( backdoor.containsSourceWithID( TEST_ID_1) );
2081
2082                 org::genivi::am::am_Volumes_L listVolumes;
2083                 org::genivi::am::am_DataType_u dt(static_cast<org::genivi::am::am_sourceID_t>(TEST_ID_1));
2084                 listVolumes.push_back(org::genivi::am::am_Volumes_s(org::genivi::am::am_VolumeType_e::VT_SOURCE,
2085                                                                                                    dt,
2086                                                                                                    50,
2087                                                                                                    static_cast<org::genivi::am::am_CustomRampType_t>(RAMP_GENIVI_DIRECT),
2088                                                                                                    50));
2089
2090                 std::vector<am_Volumes_s> am_listVolumes;
2091                 am_DataType_u dt1;
2092                 dt1.source = TEST_ID_2;
2093                 am_listVolumes.push_back((am_Volumes_s){VT_SOURCE,
2094                                                                                                 dt1,
2095                                                                                                 50,
2096                                                                                                 RAMP_GENIVI_DIRECT,
2097                                                                                                 50});
2098
2099                 am_Handle_s handle = {H_SETVOLUMES, 200};
2100                 EXPECT_CALL(*env->mpRoutingReceive, ackSetVolumes(IsHandleStructEqualTo(handle), IsSinkVolumeArrayEqualTo(am_listVolumes, false), E_OK)).Times(1);
2101                 am_Error_e error = env->mpPlugin->asyncSetVolumes(handle, am_listVolumes);
2102
2103                 usleep(50000);
2104                 ASSERT_EQ( error, E_OK );
2105                 ASSERT_FALSE( backdoor.containsHandle( handle.handle) );
2106
2107         }
2108         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
2109 }
2110
2111 TEST_F(CAmRoutingSenderCAPITests, TestDomain_deregisterSink)
2112 {
2113         ASSERT_TRUE(env->mIsServiceAvailable);
2114         if(env->mIsServiceAvailable)
2115         {
2116                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
2117                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
2118                 org::genivi::am::am_sinkID_t sinkID = TEST_ID_2;
2119
2120                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
2121                 ASSERT_TRUE( backdoor.containsSinkWithID( sinkID ));
2122
2123                 ON_CALL(*env->mpRoutingReceive, deregisterSink(_)).WillByDefault(Return(E_OK));
2124                 EXPECT_CALL(*env->mpRoutingReceive, deregisterSink(sinkID)).WillOnce(Return(E_OK));
2125                 env->mProxy->deregisterSink(sinkID, callStatus, error);
2126                 usleep(50000);
2127                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
2128                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
2129                 ASSERT_FALSE( backdoor.containsSinkWithID( sinkID ));
2130         }
2131         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
2132 }
2133
2134 TEST_F(CAmRoutingSenderCAPITests, TestDomain_deregisterSource)
2135 {
2136         ASSERT_TRUE(env->mIsServiceAvailable);
2137         if(env->mIsServiceAvailable)
2138         {
2139                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
2140                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
2141                 org::genivi::am::am_sourceID_t sID = TEST_ID_2;
2142
2143                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
2144                 ASSERT_TRUE( backdoor.containsSourceWithID( sID ));
2145
2146                 ON_CALL(*env->mpRoutingReceive, deregisterSource(_)).WillByDefault(Return(E_OK));
2147                 EXPECT_CALL(*env->mpRoutingReceive, deregisterSource(sID)).WillOnce(Return(E_OK));
2148                 env->mProxy->deregisterSource(sID, callStatus, error);
2149                 usleep(50000);
2150                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
2151                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
2152                 ASSERT_FALSE( backdoor.containsSourceWithID( sID ));
2153         }
2154         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
2155 }
2156
2157 TEST_F(CAmRoutingSenderCAPITests, TestDomain_deregisterCrossfader)
2158 {
2159         ASSERT_TRUE(env->mIsServiceAvailable);
2160         if(env->mIsServiceAvailable)
2161         {
2162                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
2163                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
2164                 org::genivi::am::am_crossfaderID_t sID = TEST_ID_1;
2165
2166                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
2167                 ASSERT_TRUE( backdoor.containsCrossfader( sID ));
2168
2169                 ON_CALL(*env->mpRoutingReceive, deregisterCrossfader(_)).WillByDefault(Return(E_OK));
2170                 EXPECT_CALL(*env->mpRoutingReceive, deregisterCrossfader(sID)).WillOnce(Return(E_OK));
2171                 env->mProxy->deregisterCrossfader(sID, callStatus, error);
2172                 usleep(50000);
2173                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
2174                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
2175                 ASSERT_FALSE( backdoor.containsCrossfader( sID ));
2176         }
2177         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
2178 }
2179
2180 TEST_F(CAmRoutingSenderCAPITests, TestDomain_deregisterDomain)
2181 {
2182         ASSERT_TRUE(env->mIsServiceAvailable);
2183         if(env->mIsServiceAvailable)
2184         {
2185                 IAmRoutingSenderBackdoor backdoor(env->mpPlugin);
2186                 ASSERT_TRUE( backdoor.containsDomainWithID( TEST_ID_2 ));
2187                 CallStatus callStatus = CallStatus::NOT_AVAILABLE;
2188                 org::genivi::am::am_Error_e error = org::genivi::am::am_Error_e::E_UNKNOWN;
2189
2190                 ON_CALL(*env->mpRoutingReceive, deregisterDomain(_)).WillByDefault(Return(E_OK));
2191                 EXPECT_CALL(*env->mpRoutingReceive, deregisterDomain(TEST_ID_2)).WillOnce(Return(E_OK));
2192                 env->mProxy->deregisterDomain(TEST_ID_2, callStatus, error);
2193                 usleep(50000);
2194                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
2195                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
2196                 ASSERT_EQ( backdoor.domainsCount(), 1 );
2197                 ASSERT_FALSE( backdoor.containsDomainWithID( TEST_ID_2 ));
2198
2199                 EXPECT_CALL(*env->mpRoutingReceive, deregisterDomain(TEST_ID_1)).WillOnce(Return(E_OK));
2200                 env->mProxy->deregisterDomain(TEST_ID_1, callStatus, error);
2201                 usleep(50000);
2202                 ASSERT_EQ( error, org::genivi::am::am_Error_e::E_OK );
2203                 ASSERT_EQ( callStatus, CallStatus::SUCCESS );
2204                 ASSERT_FALSE( backdoor.containsDomainWithID( TEST_ID_1 ));
2205                 ASSERT_EQ( backdoor.domainsCount(), 0 );
2206                 ASSERT_EQ( backdoor.sourcesCount(), 0 );
2207                 ASSERT_EQ( backdoor.sinksCount(), 0 );
2208                 ASSERT_EQ( backdoor.crossfadersCount(), 0 );
2209                 ASSERT_EQ( backdoor.connectionsCount(), 0 );
2210         }
2211         EXPECT_TRUE(Mock::VerifyAndClearExpectations(env->mpRoutingReceive));
2212 }
2213