1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include "T_MediatorSender.h"

    19 #include <EUnitMacros.h>

    20 #include <EUnitDecorators.h>

    21 

    22 #include <PEVirtualEngine.h>

    23 #include <mediatoreventsfromtelephonyapi.h>

    24 #include <videotelcontrolmediatorapi.h>

    25 #include <MediatorEventProvider.h>

    26 //#include <bmbubblemanager.h>

    27 #include "mphoneshutdowncommand.h"

    28 #include "phoneui.pan"

    29 #include "TPhoneCmdParamBoolean.h"

    30 #include "TPhoneCmdParamCallHeaderData.h"

    31 #include "PhoneViewCommandDefinitions.h"

    32 #include "CPhoneMediatorSender.h"

    33 #include "MediatorDomainUIDs.h"

    34 

    35 CPhoneMediatorSender* coeEnvMediatorSenderInstance;

    36 

    37 // Mediator registeration

    38 TInt mediatorRegisterationReturnValue;

    39 TUid domain;

    40 TUid category;

    41 MediatorService::REventList eventList;

    42 

    43 // Raise event

    44 TUid raiseEventDomain;

    45 TUid raiseEventCategory;

    46 TInt raiseEventEventId;

    47 TVersion raiseEventVersion;

    48 HBufC8* raiseEventData;

    49 

    50 // Issue command

    51 TInt issueCommandReturnValue;

    52 TUid issueCommandDomain;

    53 TUid issueCommandCategory;

    54 TInt issueCommandCommandId;

    55 TVersion issueCommandVersion;

    56 HBufC8* issueCommandData;

    57 

    58 

    59 

    60 

    61 // - Construction -----------------------------------------------------------

    62 

    63 T_MediatorSender* T_MediatorSender::NewL()

    64     {

    65     T_MediatorSender* self = T_MediatorSender::NewLC();

    66     CleanupStack::Pop();

    67     return self;

    68     }

    69 

    70 T_MediatorSender* T_MediatorSender::NewLC()

    71     {

    72     T_MediatorSender* self = new( ELeave ) T_MediatorSender();

    73     CleanupStack::PushL( self );

    74     self->ConstructL();

    75     return self;

    76     }

    77 

    78 T_MediatorSender::~T_MediatorSender()

    79     {

    80     }

    81 

    82 T_MediatorSender::T_MediatorSender()

    83     {

    84     }

    85 

    86 void T_MediatorSender::ConstructL()

    87     {

    88     CEUnitTestSuiteClass::ConstructL();

    89     }

    90 

    91 class CShutdownCommandMock : public CBase, public MPhoneShutdownCommand

    92     {

    93 public:

    94     

    95     static CShutdownCommandMock* NewL() { return new( ELeave )CShutdownCommandMock(); }

    96     

    97     void ExecuteLD() { iExecuteLDCalled = ETrue; }

    98     

    99     TBool iExecuteLDCalled;

   100     };

   101 

   102 // - Test methods -----------------------------------------------------------

   103 

   104 

   105 

   106 void T_MediatorSender::SetupL(  )

   107     {

   108     eventList = MediatorService::REventList();

   109     coeEnvMediatorSenderInstance = NULL;

   110     domain = TUid::Null();

   111     category = TUid::Null();

   112     mediatorRegisterationReturnValue = KErrNone;

   113     issueCommandDomain = raiseEventDomain = TUid::Null();

   114     issueCommandCategory = raiseEventCategory = TUid::Null();

   115     issueCommandCommandId = raiseEventEventId = 0;

   116     issueCommandVersion = raiseEventVersion = TVersion(); 

   117     issueCommandData = raiseEventData = NULL;

   118     issueCommandReturnValue = KErrNone;

   119     iSender = CPhoneMediatorSender::Instance();

   120     }    

   121 

   122 void T_MediatorSender::Teardown(  )

   123     {

   124     eventList.Close();

   125     delete iSender;

   126     delete raiseEventData;

   127     delete issueCommandData;

   128     }

   129 

   130 void T_MediatorSender::VerifyIssueCommandBoilerplateL()

   131     {

   132     EUNIT_ASSERT( issueCommandDomain == KMediatorVideoTelephonyDomain );

   133     EUNIT_ASSERT( issueCommandCategory == KCatPhoneToVideotelCommands );

   134     EUNIT_ASSERT( issueCommandVersion.iMajor == KPhoneToVideotelCmdVersionMajor );

   135     EUNIT_ASSERT( issueCommandVersion.iMinor == KPhoneToVideotelCmdVersionMinor );

   136     EUNIT_ASSERT( issueCommandVersion.iBuild == KPhoneToVideotelCmdVersionBuild );

   137     }

   138 

   139 void T_MediatorSender::VerifyRaiseEventBoilerplateL()

   140     {

   141     EUNIT_ASSERT( raiseEventDomain == KMediatorTelephonyDomain );

   142     EUNIT_ASSERT( raiseEventCategory == KCatEventsFromTelephony );

   143     EUNIT_ASSERT( raiseEventEventId == EPhoneEventCallData );

   144     EUNIT_ASSERT( raiseEventVersion.iMajor == KTelephonyEventsVersionMajor );

   145     EUNIT_ASSERT( raiseEventVersion.iMinor == KTelephonyEventsVersionMinor );

   146     EUNIT_ASSERT( raiseEventVersion.iBuild == KTelephonyEventsVersionBuild );

   147 

   148     }

   149     

   150 void T_MediatorSender::FreeIssueCommandGlobals()

   151     {

   152     issueCommandDomain = TUid::Null();

   153     issueCommandCategory = TUid::Null();

   154     issueCommandCommandId = 0;

   155     issueCommandVersion = TVersion(); 

   156     delete issueCommandData; issueCommandData = NULL; 

   157     }

   158 

   159 void T_MediatorSender::TestInstanceGotFromCoeEnvL()

   160     {

   161     coeEnvMediatorSenderInstance = reinterpret_cast<CPhoneMediatorSender*>( 0xdeadbeef );

   162     

   163     CPhoneMediatorSender* instance = CPhoneMediatorSender::Instance();

   164     EUNIT_ASSERT( instance == coeEnvMediatorSenderInstance );

   165     }

   166 

   167 void T_MediatorSender::TestInstanceCreatedL()

   168     {

   169     CPhoneMediatorSender* instance = CPhoneMediatorSender::Instance();

   170     EUNIT_ASSERT( instance != NULL );

   171     delete instance;

   172     }

   173 

   174 void T_MediatorSender::TestGenericEventsAreRegisteredL()

   175     {    

   176     EUNIT_ASSERT( domain == KMediatorTelephonyDomain );

   177     EUNIT_ASSERT( category == KCatEventsFromTelephony );

   178     EUNIT_ASSERT( eventList.Count() == 1 );

   179     MediatorService::TEvent event = eventList[0];

   180     EUNIT_ASSERT( event.iEventId == EPhoneEventCallData );

   181     EUNIT_ASSERT( event.iVersion.iMajor == KTelephonyEventsVersionMajor );

   182     EUNIT_ASSERT( event.iVersion.iMinor == KTelephonyEventsVersionMinor );

   183     EUNIT_ASSERT( event.iVersion.iBuild == KTelephonyEventsVersionBuild );

   184     }

   185 

   186 void T_MediatorSender::TestGenericEventRegisterationFailsL()

   187     {    

   188     mediatorRegisterationReturnValue = KErrGeneral;

   189     EUNIT_ASSERT_PANIC( CPhoneMediatorSender::Instance(), "Common phone", EPhoneMediatorCenterRegistrationFailed  );

   190     }

   191 

   192 void T_MediatorSender::TestSendingCallDataWhenCallHeaderIsRemovedL()

   193     {       

   194     iSender->SendEvent( EPhoneViewRemoveCallHeader, 2 );

   195     

   196     VerifyRaiseEventBoilerplateL();

   197     

   198     TTelephonyCallDataParamPackage pckg;

   199     pckg.Copy( *raiseEventData );

   200     const TTelephonyCallDataParam params = pckg();  

   201 

   202     EUNIT_ASSERT( params.iCallId == 2 );

   203     EUNIT_ASSERT( params.iCallState == ECallStateIdle );   

   204     }

   205 

   206 void T_MediatorSender::TestSendingAudioMuteCommandL()

   207     {

   208     TPhoneCmdParamBoolean param;

   209     param.SetBoolean( ETrue );

   210     

   211     iSender->SendEvent( EPhoneViewActivateMuteUIChanges, param );

   212     

   213     VerifyIssueCommandBoilerplateL();

   214     EUNIT_ASSERT( issueCommandCommandId == EVtCmdMute );

   215     EUNIT_ASSERT( issueCommandData->Match( KNullDesC8 ) == KErrNone );  

   216     }

   217 

   218 void T_MediatorSender::TestSendingAudioUnMuteCommandL()

   219     {

   220     TPhoneCmdParamBoolean param;

   221     param.SetBoolean( EFalse );

   222     

   223     iSender->SendEvent( EPhoneViewActivateMuteUIChanges, param );

   224     

   225     VerifyIssueCommandBoilerplateL();

   226     EUNIT_ASSERT( issueCommandCommandId == EVtCmdUnmute );

   227     EUNIT_ASSERT( issueCommandData->Match( KNullDesC8 ) == KErrNone );  

   228     }

   229 

   230 void T_MediatorSender::TestAudioMuteCommandBufferedIfMediatorBusyAndResendWhenResponseArrivesL()

   231     {

   232     issueCommandReturnValue = KErrInUse; // Make the mediator busy

   233     

   234     TPhoneCmdParamBoolean param;

   235     param.SetBoolean( ETrue );

   236     iSender->SendEvent( EPhoneViewActivateMuteUIChanges, param );

   237     

   238     // Clear the issue command sensing globals, because SendEvent tries to send the data and we need to verify

   239     // that when response arrives the mute command is send again.

   240     FreeIssueCommandGlobals();

   241     

   242     iSender->CommandResponseL( TUid::Null(), TUid::Null(), 0, 0, KNullDesC8() );

   243     

   244     

   245     VerifyIssueCommandBoilerplateL();

   246     EUNIT_ASSERT( issueCommandCommandId == EVtCmdMute );

   247     EUNIT_ASSERT( issueCommandData->Match( KNullDesC8 ) == KErrNone ); 

   248     

   249     // Verify that next response wont send the mute command

   250     FreeIssueCommandGlobals();

   251     iSender->CommandResponseL( TUid::Null(), TUid::Null(), 0, 0, KNullDesC8() );

   252     

   253     EUNIT_ASSERT( issueCommandDomain == TUid::Null() );

   254     }

   255 

   256 

   257 // - EUnit test table -------------------------------------------------------

   258 

   259 EUNIT_BEGIN_TEST_TABLE(

   260     T_MediatorSender,

   261     "Tests for CPhoneMediatorSender",

   262     "UNIT" )

   263 

   264 EUNIT_TEST(

   265     "Instance got from coeenv",

   266     "CPhoneMediatorSender",

   267     "Instance",

   268     "FUNCTIONALITY",

   269     SetupL, TestInstanceGotFromCoeEnvL, Teardown)

   270     

   271 EUNIT_TEST(

   272     "Instance created",

   273     "CPhoneMediatorSender",

   274     "Instance",

   275     "FUNCTIONALITY",

   276     SetupL, TestInstanceCreatedL, Teardown)

   277     

   278 EUNIT_TEST(

   279     "Generic event registeration",

   280     "CPhoneMediatorSender",

   281     "SendEvent",

   282     "FUNCTIONALITY",

   283     SetupL, TestGenericEventsAreRegisteredL, Teardown)

   284     

   285 EUNIT_TEST(

   286     "Generic event registeration fails",

   287     "CPhoneMediatorSender",

   288     "SendEvent",

   289     "FUNCTIONALITY",

   290     SetupL, TestGenericEventRegisterationFailsL, Teardown)

   291 

   292     

   293 EUNIT_TEST(

   294     "Sending call data when call header is removed",

   295     "CPhoneMediatorSender",

   296     "SendEvent",

   297     "FUNCTIONALITY",

   298     SetupL, TestSendingCallDataWhenCallHeaderIsRemovedL, Teardown)

   299 

   300 EUNIT_TEST(

   301     "Sending audio mute command",

   302     "CPhoneMediatorSender",

   303     "SendEvent",

   304     "FUNCTIONALITY",

   305     SetupL, TestSendingAudioMuteCommandL, Teardown)

   306 

   307 EUNIT_TEST(

   308     "Sending audio unmute command",

   309     "CPhoneMediatorSender",

   310     "SendEvent",

   311     "FUNCTIONALITY",

   312     SetupL, TestSendingAudioUnMuteCommandL, Teardown)

   313     

   314 EUNIT_TEST(

   315     "Mute command sending buffered",

   316     "CPhoneMediatorSender",

   317     "CommandResponseL",

   318     "FUNCTIONALITY",

   319     SetupL, TestAudioMuteCommandBufferedIfMediatorBusyAndResendWhenResponseArrivesL, Teardown)

   320 

   321 EUNIT_END_TEST_TABLE