1 /*

     2 * Copyright (c) 2004 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 

    19 //  CLASS HEADER

    20 #include "sipprofile.h"

    21 #include "UT_CMusAvaOptionHandler.h"

    22 

    23 //  EXTERNAL INCLUDES

    24 #include <digia/eunit/eunitmacros.h>

    25 #include <digia/eunit/eunitdecorators.h>

    26 #include <EscapeUtils.h>

    27 #include <sipstrings.h>

    28 #include <sipstrconsts.h>

    29 #include <stringpool.h>

    30 #include <sipservertransaction.h>

    31 #include <siptransactionbase.h>

    32 //  INTERNAL INCLUDES

    33 #include "musavaoptionhandler.h"

    34 #include "musavaavailabilityobserver.h"

    35 #include "musavaavailabilityobserverimp.h"

    36 #include "musavasettingsimp.h"

    37 #include "musavaobserverimp.h"

    38 #include "muslogger.h"

    39 #include "musavasharedobject.h"

    40 #include "mussettingskeys.h"

    41 #include "mussettings.h"

    42 #include "musavasip.h"

    43 #include "CSipSseTestTls.h"

    44 #include "musavacapabilitytesthelper.h"

    45 #include "musavasettingsobserverimp.h"

    46 

    47 

    48 // CONSTRUCTION

    49 UT_CMusAvaOptionHandler* UT_CMusAvaOptionHandler::NewL()

    50     {

    51     UT_CMusAvaOptionHandler* self = UT_CMusAvaOptionHandler::NewLC(); 

    52     CleanupStack::Pop();

    53 

    54     return self;

    55     }

    56 

    57 UT_CMusAvaOptionHandler* UT_CMusAvaOptionHandler::NewLC()

    58     {

    59     UT_CMusAvaOptionHandler* self = new( ELeave ) UT_CMusAvaOptionHandler();

    60     CleanupStack::PushL( self );

    61 	self->ConstructL(); 

    62 

    63     return self;

    64     }

    65 

    66 // Destructor (virtual by CBase)

    67 UT_CMusAvaOptionHandler::~UT_CMusAvaOptionHandler()

    68     {

    69     }

    70 

    71 // Default constructor

    72 UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler()

    73     {

    74     }

    75 

    76 // Second phase construct

    77 void UT_CMusAvaOptionHandler::ConstructL()

    78     {

    79     // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    80     // It generates the test case table.

    81     CEUnitTestSuiteClass::ConstructL();

    82     }

    83 

    84 //  METHODS

    85 

    86 void UT_CMusAvaOptionHandler::SetupL(  )

    87     {

    88     iSharedObject = CMusAvaSharedObject::GetSingletonL();

    89     iAvailabilityObserver = CMusAvaAvailabilityObserverImp::NewL();

    90     iSettingsObserver = CMusAvaSettingsObserverImp::NewL();

    91     iConcreteSettings = CMusAvaSettingsImp::NewL();

    92     iConcreteSettings->SetObserver( *iSettingsObserver );

    93     iOptionHandler = CMusAvaOptionHandler::NewL( *iAvailabilityObserver,

    94                                     *iConcreteSettings );

    95 

    96     MSIPConnectionObserver& connectionObserver = 

    97                             iSharedObject->MusAvaSip().ConnectionObserver();

    98     CSIP& sip = iSharedObject->MusAvaSip().Sip();

    99     CSipSseTestTls::OpenL();

   100     iStorage = CSipSseTestTls::Storage();

   101     iStorage->Set( MusSettingsKeys::KFastStartupMode, 

   102         MusSettingsKeys::EFastModeOff );

   103 

   104     iSharedObject->MusAvaSip().CreateProfileL();

   105     iProfile = iSharedObject->MusAvaSip().Profile();

   106     iSharedObject->MusAvaSip().ConnectionL( );

   107 

   108     if ( !iProfile->iArray )

   109         {

   110         iProfile->iArray = new ( ELeave ) CDesC8ArrayFlat( 1 );

   111         iProfile->iArray->AppendL( _L8("sip:user@domain.com") );

   112         }

   113     if ( !iProfile->iRegisteredContact )

   114         {

   115         iProfile->iRegisteredContact = KRegisteredContact().AllocL();

   116         }

   117 

   118     MultimediaSharingSettings::SetCapabilityQuerySettingL(

   119                                                 MusSettingsKeys::ESequential );

   120     } 

   121 

   122 void UT_CMusAvaOptionHandler::Teardown(  )

   123     {

   124     CMusAvaSharedObject::DeleteSingleton();

   125     delete iAvailabilityObserver;

   126     delete iConcreteSettings;

   127     if ( iStorage )

   128         {

   129         iStorage->Clear();

   130         CSipSseTestTls::Close();

   131         iStorage = NULL;

   132         }

   133     delete iOptionHandler;

   134     delete iSettingsObserver;

   135     

   136     PropertyHelper::Close();

   137     }

   138 

   139 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_NewLL(  )

   140     {

   141     EUNIT_ASSERT( iOptionHandler );

   142     EUNIT_ASSERT( iOptionHandler->State() == 

   143                             MMusAvaObserver::EMusAvaStatusNotExecuted );

   144     }

   145 

   146 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_DoExecuteLL()

   147     {   

   148     // test for B-party && Cingular variant

   149     iOptionHandler->iSettings.SetCallDirection( 2 );

   150     MultimediaSharingSettings::SetOperatorVariantSettingL( 

   151                                         MusSettingsKeys::EOperatorSpecific );

   152     iOptionHandler->DoExecuteL();

   153     EUNIT_ASSERT( iOptionHandler->State() ==  

   154                             MMusAvaObserver::EMusAvaStatusOptionsNotSent ); 

   155     iOptionHandler->iSettings.SetCallDirection( 1 );

   156     MultimediaSharingSettings::SetOperatorVariantSettingL( 

   157                                         MusSettingsKeys::EStandard );

   158                             

   159     // usual case    

   160     TBufC16<16> str(KCapabilityTestSIPAddressUri_B);

   161     HBufC16* ptr;

   162     ptr = str.AllocLC(); 

   163     CDesCArrayFlat* sipAddress = new( ELeave ) CDesCArrayFlat( 1 );

   164     CleanupStack::PushL( sipAddress );

   165     sipAddress->AppendL( *ptr );

   166     iOptionHandler->iSettings.SetSipAddressesL( *sipAddress );

   167     sipAddress->Reset();

   168     CleanupStack::PopAndDestroy( sipAddress );

   169     CleanupStack::PopAndDestroy(); //ptr   

   170     

   171     MultimediaSharingSettings::SetCapabilityQuerySettingL(

   172                                                 MusSettingsKeys::ESequential );

   173     EUNIT_ASSERT( iSharedObject->MusAvaSip().CreateProfileL() == ETrue );

   174     MultimediaSharingSettings::SetSipProfileSettingL( 1 );

   175     TRAPD( error, iOptionHandler->DoExecuteL() );

   176     TInt count = 0;

   177     EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count );

   178     EUNIT_ASSERT( error == KErrNoMemory || error == KErrNone );

   179     if ( error == KErrNoMemory ) User::Leave( error );

   180         

   181     if ( count > 0 )

   182         {

   183         EUNIT_ASSERT( iOptionHandler->State() ==  

   184                             MMusAvaObserver::EMusAvaOptionNotAvailable ); 

   185         }

   186     else

   187         {

   188         EUNIT_ASSERT( iOptionHandler->State() ==  

   189                             MMusAvaObserver::EMusAvaStatusOptionsSent ); 

   190     

   191         EUNIT_ASSERT( iStorage->iClientRequest->Method() == 

   192                             SIPStrings::StringF( SipStrConsts::EOptions ) );

   193                             

   194         EUNIT_ASSERT( 

   195             iStorage->iClientRequest->MessageElements().Content().Length() > 0 );

   196         EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().ContentType() );

   197         EUNIT_ASSERT( iStorage->iClientRequest->RemoteUri().Uri().UriDes().Compare( 

   198             KCapabilityTestSIPAddressUri8_B ) == 0);

   199         EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().UserHeaders().

   200             Count() == 6 );

   201         MUS_HEADER_ASSERT( iStorage->iClientRequest, 

   202                     0, 

   203                     KCapabilityTestAcceptContactHeader );

   204         MUS_HEADER_ASSERT( iStorage->iClientRequest, 

   205                     5, 

   206                     KCapabilityTestContactHeader_A1Updated );

   207         }

   208 

   209     // when needed sip profile and not registered yet. means sip connection is still

   210     // null

   211     MultimediaSharingSettings::SetCapabilityQuerySettingL(

   212                                                 MusSettingsKeys::ESequential );

   213     EUNIT_ASSERT( iSharedObject->MusAvaSip().CreateProfileL() == ETrue );

   214     MultimediaSharingSettings::SetSipProfileSettingL( 1 );

   215     iSharedObject->MusAvaSip().ConnectionL(EFalse);

   216     

   217     delete iSharedObject->MusAvaSip().iSipConnection;

   218     iSharedObject->MusAvaSip().iSipConnection = NULL;

   219     

   220     iOptionHandler->SetState( MMusAvaObserver::EMusAvaStatusOptionsNotSent );

   221     

   222     iOptionHandler->DoExecuteL();

   223     EUNIT_ASSERT( iOptionHandler->State() ==  

   224                             MMusAvaObserver::EMusAvaStatusNotExecuted );

   225     }

   226 

   227 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_NameL()

   228     {

   229      EUNIT_ASSERT( iOptionHandler->Name() == 

   230                             MMusAvaObserver::EMusAvaOptionHandler );

   231     }

   232   

   233 

   234 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_StatusL()

   235     {

   236     EUNIT_ASSERT( iOptionHandler->State() == 

   237                             MMusAvaObserver::EMusAvaStatusNotExecuted );

   238     }

   239 

   240 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_StopL()

   241     {

   242     iOptionHandler->Stop();

   243     }

   244     

   245 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_CapabilitiesResolvedL()

   246     {

   247     _LIT( KSipAddress ,   "b@foobar.com" );

   248     _LIT( KSipAddressA ,   "a@foobar.com" );

   249     _LIT( KEmpty, "" );

   250     

   251     EUNIT_ASSERT( iOptionHandler->State() == 

   252                             MMusAvaObserver::EMusAvaStatusNotExecuted );

   253 	iOptionHandler->CapabilitiesResolvedL( KEmpty );

   254 	EUNIT_ASSERT( iOptionHandler->iSettings.SipAddresses().MdcaCount() == 0 );

   255     EUNIT_ASSERT( iOptionHandler->State() == 

   256                             MMusAvaObserver::EMusAvaStatusNotExecuted );

   257 	

   258     iOptionHandler->iState = MMusAvaObserver::EMusAvaStatusNotExecuted;

   259 	iOptionHandler->CapabilitiesResolvedL( KSipAddress );

   260     EUNIT_ASSERT( iOptionHandler->iSettings.SipAddresses().MdcaPoint( 0 ).

   261         Compare( KSipAddress() ) == KErrNone ); 

   262     EUNIT_ASSERT( iOptionHandler->State() == 

   263                             MMusAvaObserver::EMusAvaStatusNotExecuted );

   264         

   265     iOptionHandler->CapabilitiesResolvedL( KSipAddressA );    

   266     EUNIT_ASSERT( iOptionHandler->iSettings.SipAddresses().MdcaPoint( 0 ).

   267         Compare( KSipAddressA() ) == KErrNone ); 

   268                 

   269     EUNIT_ASSERT( iOptionHandler->State() == 

   270                             MMusAvaObserver::EMusAvaStatusNotExecuted );

   271     }

   272 

   273 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_CapabilitiesResolvedForCingularL()

   274     {

   275     EUNIT_ASSERT( iOptionHandler->CapabilitiesResolvedForCingular() == EFalse );

   276     iOptionHandler->SetCapabilitiesResolvedForCingular();

   277     EUNIT_ASSERT( iOptionHandler->CapabilitiesResolvedForCingular() == ETrue );

   278     }

   279 

   280 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_SipHeadersL()

   281     {    

   282     CDesCArrayFlat* headers = new( ELeave ) CDesCArrayFlat( 1 );    

   283     CleanupStack::PushL(headers);

   284     headers->AppendL(_L("sip:test1@10.21.32.51"));

   285     iOptionHandler->SipHeadersL(*headers,SipStrConsts::EToHeader);    

   286     EUNIT_ASSERT( iOptionHandler->iSettings.SipAddresses().MdcaCount()==1 );

   287 

   288     _LIT( KPAssertedIdentityTelNumber, "+4455667788");

   289     headers->Reset();

   290     headers->AppendL(KPAssertedIdentity_B_16);

   291     headers->AppendL(KPAssertedIdentity_B1_16);

   292     iOptionHandler->SipHeadersL(*headers,SipStrConsts::EToHeader);    

   293     EUNIT_ASSERT( iOptionHandler->iSettings.SipAddresses().MdcaCount()==1 );

   294     EUNIT_ASSERT( iOptionHandler->iSettings.SipAddresses().MdcaPoint( 0 ).Compare( 

   295         KPAssertedIdentity_B_16() ) == KErrNone );

   296     EUNIT_ASSERT( iOptionHandler->iSettings.TelNumber().Compare( 

   297         KPAssertedIdentityTelNumber ) == 0 );

   298 

   299     headers->Reset();

   300     iOptionHandler->SipHeadersL(*headers,SipStrConsts::EToHeader);            

   301     EUNIT_ASSERT( iOptionHandler->iSettings.SipAddresses().MdcaCount()==0 );

   302 

   303     headers->Reset();

   304     headers->AppendL(_L("sip:test1@10.21.32.51"));

   305     iOptionHandler->SipHeadersL(*headers,SipStrConsts::EFromHeader);        

   306     EUNIT_ASSERT( iOptionHandler->iSettings.SipAddresses().MdcaCount()==0 );

   307 

   308     CleanupStack::PopAndDestroy(headers);

   309     

   310     

   311     }

   312 

   313 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_VideoCodecsResolvedLL()

   314     {

   315     _LIT16( KVideoCodec , "H.264" );

   316     TBufC16<16> str(KVideoCodec);

   317     HBufC16* ptr;

   318     ptr = str.AllocLC();

   319 

   320     CDesCArrayFlat* videoCodecs = new( ELeave ) CDesCArrayFlat( 1 );

   321     CleanupStack::PushL( videoCodecs );

   322 

   323     videoCodecs->AppendL( *ptr );

   324     iOptionHandler->VideoCodecsResolvedL( *videoCodecs );

   325     EUNIT_ASSERT ( iOptionHandler->iSettings.iVideoCodecs->MdcaCount() > KErrNone );

   326     EUNIT_ASSERT ( iOptionHandler->iSettings.iVideoCodecs->MdcaPoint(0).Compare ( *ptr ) == 0 );

   327 

   328     videoCodecs->Reset();

   329     CleanupStack::PopAndDestroy( videoCodecs );

   330     CleanupStack::PopAndDestroy();

   331     

   332     }

   333 

   334 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_DoSetStateL()

   335     {

   336     // Set some state which does not cause special handling

   337     iOptionHandler->iFastModeCapable = EFalse;

   338     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaStatusOptionsSent );

   339     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusOptionsSent );

   340     

   341     // Set special handling state, but fast mode is not enabled

   342     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaStatusAvailable );

   343     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusAvailable );

   344     EUNIT_ASSERT( !iSettingsObserver->iApplicationStarted );

   345         

   346     // Set special handling state, fast capable but mode is not enabled

   347     iOptionHandler->iFastModeCapable = ETrue;

   348     iConcreteSettings->SetFastMode( MusSettingsKeys::EFastModeOff );

   349     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaStatusAvailable );

   350     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusAvailable );

   351     EUNIT_ASSERT( !iSettingsObserver->iApplicationStarted );

   352     }

   353 

   354 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_DoSetStateFastModeL()

   355     {

   356     iOptionHandler->iFastModeCapable = ETrue;

   357     iConcreteSettings->SetFastMode( MusSettingsKeys::EFastModeOn );

   358     iOptionHandler->iSettings.SetCallDirection( 1 );

   359     

   360     // State which does not have special handling

   361     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaFailureCode );

   362     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaFailureCode );

   363     EUNIT_ASSERT( !iOptionHandler->iFastModeAvailabilityDelayed );

   364     

   365     // OptionsNotSent handling

   366     //

   367         

   368     // MT, not answered

   369     iOptionHandler->iSettings.SetCallDirection( 2 );

   370     iOptionHandler->iCapabilityQueryAnswered = EFalse;

   371     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaStatusOptionsNotSent );

   372     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusOptionsNotSent );

   373     EUNIT_ASSERT( !iOptionHandler->iFastModeAvailabilityDelayed );

   374         

   375     // MT, answered (makes state available delayed)

   376     iOptionHandler->iCapabilityQueryAnswered = ETrue;

   377     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaStatusOptionsNotSent );

   378     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusOptionsNotSent );

   379     EUNIT_ASSERT( iOptionHandler->iFastModeAvailabilityDelayed );

   380     

   381     // Available handling

   382     //

   383     

   384     // MO, start app

   385     iOptionHandler->iSettings.SetCallDirection( 1 );

   386     iSettingsObserver->iApplicationStarted = EFalse;

   387     iOptionHandler->iFastModeAvailabilityDelayed = EFalse;

   388     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaStatusAvailable );

   389     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusAvailable );

   390     EUNIT_ASSERT( !iOptionHandler->iFastModeAvailabilityDelayed );

   391     EUNIT_ASSERT( iSettingsObserver->iApplicationStarted );

   392     

   393     // App already started by going to available state, do not do twice

   394     iSettingsObserver->iApplicationStarted = EFalse;

   395     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaStatusAvailable );

   396     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusAvailable );

   397     EUNIT_ASSERT( !iOptionHandler->iFastModeAvailabilityDelayed );

   398     EUNIT_ASSERT( !iSettingsObserver->iApplicationStarted );

   399      

   400     // MT, delayed availability publishing (state not changed yet)

   401     iOptionHandler->iSettings.SetCallDirection( 2 );

   402     iOptionHandler->iFastModeAvailabilityDelayed = EFalse;

   403     iSettingsObserver->iApplicationStarted = EFalse;

   404     iOptionHandler->iState = MMusAvaObserver::EMusAvaStatusOptionsNotSent;

   405     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaStatusAvailable );

   406     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusOptionsNotSent );

   407     EUNIT_ASSERT( iOptionHandler->iFastModeAvailabilityDelayed );

   408     EUNIT_ASSERT( !iSettingsObserver->iApplicationStarted );

   409     

   410     // Invite ends availability delaying

   411     iOptionHandler->PrepareForReceivedInviteL();

   412     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusAvailable );

   413     EUNIT_ASSERT( !iOptionHandler->iFastModeAvailabilityDelayed );

   414     

   415     // No effect if no delay pending

   416     iOptionHandler->iState = MMusAvaObserver::EMusAvaStatusOptionsNotSent;

   417     iOptionHandler->PrepareForReceivedInviteL();

   418     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusOptionsNotSent );

   419     

   420     // OptionNotAvailable handling

   421     //

   422     

   423     // Normal handling when no pending availabilty publishing nor state is

   424     // not already available

   425     iOptionHandler->iFastModeAvailabilityDelayed = EFalse;

   426     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaOptionNotAvailable );

   427     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaOptionNotAvailable );

   428     

   429     // If already set to available by succesfull answer, sending failure

   430     // does not clear availability

   431     iOptionHandler->iState = MMusAvaObserver::EMusAvaStatusAvailable;

   432     iOptionHandler->DoSetState( MMusAvaObserver::EMusAvaOptionNotAvailable );

   433     EUNIT_ASSERT( iOptionHandler->iState == MMusAvaObserver::EMusAvaStatusAvailable );

   434     }

   435 

   436 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_FastModeResolvedL()

   437     {

   438     iOptionHandler->iFastModeCapable = ETrue;

   439     

   440     // Normal case  

   441     iOptionHandler->iSettings.SetFastMode( MusSettingsKeys::EFastModeOff );

   442     iOptionHandler->FastModeResolved( MusSettingsKeys::EFastModeOn );

   443     EUNIT_ASSERT( iOptionHandler->iSettings.FastMode() == MusSettingsKeys::EFastModeOn )

   444     

   445     // MO side fast mode negotiation has failed, value is not set

   446     iOptionHandler->iSettings.SetFastMode( MusSettingsKeys::EFastModeOff );

   447     iOptionHandler->iSettings.SetCallDirection( 1 );

   448     iOptionHandler->iState = MMusAvaObserver::EMusAvaOptionNotAvailable;

   449     iOptionHandler->FastModeResolved( MusSettingsKeys::EFastModeOn );

   450     EUNIT_ASSERT( iOptionHandler->iSettings.FastMode() == MusSettingsKeys::EFastModeOff )

   451     }

   452 

   453 void UT_CMusAvaOptionHandler::UT_CMusAvaOptionHandler_CapabilityQueryAnsweredL()

   454     {

   455     iOptionHandler->iFastModeCapable = ETrue;

   456     

   457     // If fast mode MO side, no special handling for answer

   458     iOptionHandler->CapabilityQueryAnswered( ETrue );

   459     EUNIT_ASSERT( iOptionHandler->iCapabilityQueryAnswered )

   460     EUNIT_ASSERT( !iOptionHandler->iFastModeAvailabilityDelayed );

   461     

   462     // If fast mode MT side, MT can start waiting for invite already after answering

   463     iOptionHandler->iCapabilityQueryAnswered = EFalse;

   464     iOptionHandler->iSettings.SetFastMode( MusSettingsKeys::EFastModeOn );

   465     iOptionHandler->iSettings.SetCallDirection( 2 );

   466     iOptionHandler->CapabilityQueryAnswered( ETrue );

   467     EUNIT_ASSERT( iOptionHandler->iCapabilityQueryAnswered )

   468     EUNIT_ASSERT( iOptionHandler->iFastModeAvailabilityDelayed );

   469     }

   470 

   471 //  TEST TABLE

   472 

   473 EUNIT_BEGIN_TEST_TABLE( 

   474     UT_CMusAvaOptionHandler,

   475     "CMusAvaOptionHandler",

   476     "UNIT" )

   477 

   478 EUNIT_TEST(

   479     "NewL - test ",

   480     "CMusAvaOptionHandler",

   481     "NewL",

   482     "FUNCTIONALITY",

   483     SetupL,UT_CMusAvaOptionHandler_NewLL, Teardown)

   484     

   485 EUNIT_TEST(

   486     "DoExecuteL - test ",

   487     "CMusAvaOptionHandler",

   488     "DoExecuteL",

   489     "FUNCTIONALITY",

   490     SetupL,UT_CMusAvaOptionHandler_DoExecuteLL, Teardown)        

   491 

   492 EUNIT_TEST(

   493     "Name - test ",

   494     "CMusAvaOptionHandler",

   495     "Name",

   496     "FUNCTIONALITY",

   497     SetupL,UT_CMusAvaOptionHandler_NameL, Teardown)

   498     

   499 

   500 EUNIT_TEST(

   501     "Status - test ",

   502     "CMusAvaOptionHandler",

   503     "Status",

   504     "FUNCTIONALITY",

   505     SetupL,UT_CMusAvaOptionHandler_StatusL, Teardown)

   506 

   507 EUNIT_TEST(

   508     "Stop - test ",

   509     "CMusAvaOptionHandler",

   510     "Stop",

   511     "FUNCTIONALITY",

   512     SetupL,UT_CMusAvaOptionHandler_StopL, Teardown)   

   513      

   514 EUNIT_TEST(

   515     "CapabilitiesResolved - test ",

   516     "CMusAvaOptionHandler",

   517     "CapabilitiesResolved",

   518     "FUNCTIONALITY",

   519     SetupL,UT_CMusAvaOptionHandler_CapabilitiesResolvedL, Teardown)   

   520      

   521 EUNIT_TEST(

   522     "CapabilitiesResolvedForCingular - test ",

   523     "CMusAvaOptionHandler",

   524     "CapabilitiesResolvedForCingular",

   525     "FUNCTIONALITY",

   526     SetupL,UT_CMusAvaOptionHandler_CapabilitiesResolvedForCingularL, 

   527     Teardown)   

   528 

   529 EUNIT_TEST(

   530     "SipHeadersL - test ",

   531     "CMusAvaOptionHandler",

   532     "SipHeadersL",

   533     "FUNCTIONALITY",

   534     SetupL,UT_CMusAvaOptionHandler_SipHeadersL, 

   535     Teardown)  

   536      

   537 EUNIT_TEST(

   538     "VideoCodecsResolvedL - test ",

   539     "CMusAvaOptionHandler",

   540     "VideoCodecsResolvedL",

   541     "FUNCTIONALITY",

   542     SetupL,UT_CMusAvaOptionHandler_VideoCodecsResolvedLL, 

   543     Teardown) 

   544 

   545 EUNIT_TEST(

   546     "DoSetState - test ",

   547     "CMusAvaOptionHandler",

   548     "DoSetState",

   549     "FUNCTIONALITY",

   550     SetupL,UT_CMusAvaOptionHandler_DoSetStateL, 

   551     Teardown) 

   552 

   553 EUNIT_TEST(

   554     "DoSetState - fastmode test ",

   555     "CMusAvaOptionHandler",

   556     "DoSetState",

   557     "FUNCTIONALITY",

   558     SetupL,UT_CMusAvaOptionHandler_DoSetStateFastModeL, 

   559     Teardown) 

   560 

   561 EUNIT_TEST(

   562     "FastModeResolved - test ",

   563     "CMusAvaOptionHandler",

   564     "FastModeResolved",

   565     "FUNCTIONALITY",

   566     SetupL,UT_CMusAvaOptionHandler_FastModeResolvedL, 

   567     Teardown) 

   568 

   569 EUNIT_TEST(

   570     "CapabilityQueryAnswered - test ",

   571     "CMusAvaOptionHandler",

   572     "CapabilityQueryAnswered",

   573     "FUNCTIONALITY",

   574     SetupL,UT_CMusAvaOptionHandler_CapabilityQueryAnsweredL, 

   575     Teardown) 

   576 

   577 EUNIT_END_TEST_TABLE

   578 

   579 //  END OF FILE