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 "UT_CMusAvaCapabilityExchange.h"

    21 #include "muslogger.h"

    22 

    23 

    24 

    25 //  EXTERNAL INCLUDES

    26 #include <EscapeUtils.h>

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

    28 #include <sipstrings.h>

    29 #include <sipstrconsts.h>

    30 #include <stringpool.h>

    31 #include <sipservertransaction.h>

    32 #include <siptransactionbase.h>

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

    34 //  INTERNAL INCLUDES

    35 #include "musavaCapabilityExchange.h"

    36 #include "musavaavailabilityobserver.h"

    37 #include "musavaavailabilityobserverimp.h"

    38 #include "musavacapabilitytesthelper.h"

    39 #include "musavacapability.h"

    40 #include "musavaterminal.h"

    41 #include "CSipSseTestTls.h"

    42 #include "musavaoptionhandler.h"

    43 #include "musavasettingsimp.h"

    44 #include "CSipSseTestTls.h"

    45 #include "musavacapabilityquery.h"

    46 #include "mussettings.h"

    47 #include "mussettingskeys.h"

    48 #include "musavaobserverimp.h"

    49 #include "musavasharedobject.h"

    50 #include "musavasip.h"

    51 #include "musavaobserver.h"

    52 // CONSTRUCTION

    53 UT_CMusAvaCapabilityExchange* UT_CMusAvaCapabilityExchange::NewL()

    54     {

    55     UT_CMusAvaCapabilityExchange* self = UT_CMusAvaCapabilityExchange::NewLC(); 

    56     CleanupStack::Pop();

    57 

    58     return self;

    59     }

    60 

    61 UT_CMusAvaCapabilityExchange* UT_CMusAvaCapabilityExchange::NewLC()

    62     {

    63     UT_CMusAvaCapabilityExchange* self = new( ELeave ) UT_CMusAvaCapabilityExchange();

    64     CleanupStack::PushL( self );

    65 	self->ConstructL(); 

    66 

    67     return self;

    68     }

    69 

    70 // Destructor (virtual by CBase)

    71 UT_CMusAvaCapabilityExchange::~UT_CMusAvaCapabilityExchange()

    72     {

    73     }

    74 

    75 // Default constructor

    76 UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange()

    77     {

    78     }

    79 

    80 // Second phase construct

    81 void UT_CMusAvaCapabilityExchange::ConstructL()

    82     {

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

    84     // It generates the test case table.

    85     CEUnitTestSuiteClass::ConstructL();

    86     }

    87 

    88 //  METHODS

    89 

    90 _LIT8( KTestNewTerminal, "new@foo.bar");

    91 

    92 void UT_CMusAvaCapabilityExchange::SetupL(  )

    93     {

    94     MSIPObserver* dummyObserver = NULL;

    95     CSIPProfileRegistry* dummyRegistry = NULL;

    96     MSIPConnectionObserver* dummyConnectionObserver = NULL;

    97     

    98     TUid uid = TUid::Uid( 1 );

    99     TUint32 iapId = 32;

   100     

   101     iAvailabilityObserver = CMusAvaAvailabilityObserverImp::NewL();

   102     iConcreteSettings = CMusAvaSettingsImp::NewL();

   103     iOptionHandler = CMusAvaOptionHandler::NewL( *iAvailabilityObserver,

   104                                                  *iConcreteSettings );

   105     iSIP = CSIP::NewL( uid, *dummyObserver );

   106     iProfile = CSIPProfile::NewL( dummyRegistry );

   107     iOptionHandler->iSharedObj->MusAvaSip().iSipProfile = iProfile;                                                

   108     iSIPConnection = CSIPConnection::NewL( *iSIP, 

   109                                             iapId,

   110                                             *dummyConnectionObserver );

   111     iOptionHandler->iSharedObj->MusAvaSip().iSipConnection = iSIPConnection;

   112                                

   113     iExchange = iOptionHandler->iCapabilityExchange;

   114     

   115     iCapability = iOptionHandler->iSwisCapability;

   116     if ( !iProfile->iRegisteredContact )

   117         {

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

   119         }

   120     

   121     CSipSseTestTls::OpenL();

   122     iStorage = CSipSseTestTls::Storage();

   123     } 

   124 

   125 void UT_CMusAvaCapabilityExchange::Teardown(  )

   126     {

   127     if ( iStorage )

   128        {

   129        iStorage->Clear();

   130        CSipSseTestTls::Close();

   131        iStorage = NULL;

   132        }

   133        

   134     delete iOptionHandler;

   135     delete iAvailabilityObserver;

   136     delete iConcreteSettings;

   137     delete iSIP;

   138     }

   139 

   140 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_NewLL(  )

   141     {

   142     EUNIT_ASSERT( iExchange->Capabilities().Count() == 1 );

   143     EUNIT_ASSERT( iExchange->Terminals().Count() == 0 );

   144     EUNIT_ASSERT( iExchange->Capabilities()[0] == iCapability );

   145     }

   146 

   147 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_QueryObserverL(  )

   148     {

   149     EUNIT_ASSERT( &iExchange->QueryObserver() == iOptionHandler );

   150     }

   151 

   152 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_TerminalIdL(  )

   153     {

   154     EUNIT_ASSERT( iExchange->TerminalId().Compare( KNullDesC8 ) == 0 );

   155     }

   156 

   157 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_QueryReceivedL()

   158     {

   159     EUNIT_DISABLE_ALLOC_DECORATOR;

   160     MultimediaSharingSettings::SetSipProfileSettingL( 1 );

   161     if ( !iProfile->iArray )

   162         {

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

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

   165         }

   166     

   167     MultimediaSharingSettings::SetOperatorVariantSettingL( 

   168                                         MusSettingsKeys::EStandard );

   169     MultimediaSharingSettings::SetCapabilityQuerySettingL(

   170                                         MusSettingsKeys::ESequential );

   171     

   172     CSIPServerTransaction* request = NULL;

   173     

   174     TBufC16<16> str(KCapabilityTestSIPAddressUri_BSIP);

   175     HBufC16* ptr;

   176     ptr = str.AllocLC(); 

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

   178     CleanupStack::PushL( sipAddress );

   179     sipAddress->AppendL( *ptr );

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

   181     sipAddress->Reset();

   182     CleanupStack::PopAndDestroy( sipAddress );

   183     CleanupStack::PopAndDestroy(); //ptr   

   184     EUNIT_ENABLE_ALLOC_DECORATOR;

   185 

   186     EUNIT_ASSERT( iExchange->Capabilities().Count() == 1 );

   187     EUNIT_ASSERT( iExchange->Capabilities()[0] == iCapability );

   188     EUNIT_ASSERT( iCapability->Feature().DesC().Compare( KCapabilitySwisFeature ) == 0 );

   189 

   190 //ok & No terminal id configured

   191     EUNIT_DISABLE_ALLOC_DECORATOR;

   192 	iStorage->Clear();

   193     iExchange->iTerminals.ResetAndDestroy();

   194 	iOptionHandler->iState = MMusAvaObserver::EMusAvaStatusNotExecuted;

   195     request = CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   196                                                 KCapabilityTestAddress_B,

   197                                                 KCapabilitySwisFeature,

   198                                                 KCapabilitySwisFeature,

   199                                                 KCapabilityTestAcceptHeader,

   200                                                 KCapabilityTestTerminalID_B );

   201     

   202     iOptionHandler->iCapabilitiesRequestAnswered = EFalse;                                         

   203     EUNIT_ENABLE_ALLOC_DECORATOR;

   204     iExchange->QueryReceived( request );

   205     TInt count = NULL;

   206     EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count );

   207     if ( count > 0 && 

   208         iOptionHandler->State() != MMusAvaObserver::EMusAvaStatusOptionsSent )

   209         {

   210         User::Leave( KErrNoMemory );

   211         }

   212     

   213     EUNIT_ASSERT( iOptionHandler->State() == MMusAvaObserver::EMusAvaStatusOptionsSent );    

   214     EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

   215     EUNIT_ASSERT( iExchange->Terminals()[0]->Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   216     EUNIT_ASSERT( iExchange->Terminals()[0]->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   217     EUNIT_ASSERT( iExchange->Terminals()[0]->RequestedQuery() );

   218     EUNIT_ASSERT( !iExchange->Terminals()[0]->IsDiscovered() );

   219 

   220     EUNIT_ASSERT( iStorage->iResponseToRequest == SIPStrings::StringF( SipStrConsts::EOptions ) );

   221     EUNIT_ASSERT( iStorage->iClientResponse->StatusCode() == KMUSAVASIP200 );

   222     EUNIT_ASSERT( iStorage->iClientResponse->MessageElements().Content().Length() > 0 );

   223     EUNIT_ASSERT( iStorage->iClientResponse->MessageElements().Content().Compare( KCapabilityTestSDP264And263 ) == 0 );

   224         

   225     EUNIT_ASSERT( iStorage->iClientResponse->MessageElements().UserHeaders().Count() == 3 );

   226     MUS_HEADER_ASSERT( iStorage->iClientResponse, 0, KCapabilityTestContactHeader_A );

   227     iStorage->Clear();

   228     }

   229     

   230 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_QueryReceived1L()

   231     {

   232     EUNIT_DISABLE_ALLOC_DECORATOR;

   233     MultimediaSharingSettings::SetSipProfileSettingL( 1 );

   234     if ( !iProfile->iArray )

   235         {

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

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

   238         }

   239     

   240     MultimediaSharingSettings::SetOperatorVariantSettingL( 

   241                                         MusSettingsKeys::EStandard );

   242     MultimediaSharingSettings::SetCapabilityQuerySettingL(

   243                                         MusSettingsKeys::ESequential );

   244     

   245     CSIPServerTransaction* request = NULL;

   246     

   247 //fails

   248     iStorage->Clear();

   249     iOptionHandler->iState = MMusAvaObserver::EMusAvaStatusNotExecuted;

   250     request = CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   251                                                 KCapabilityTestAddress_B,

   252                                                 KNullDesC8,//Accepct-Contact

   253                                                 KCapabilitySwisFeature,

   254                                                 KCapabilityTestAcceptHeader,

   255                                                 KCapabilityTestTerminalID_B );

   256                                          

   257     EUNIT_ENABLE_ALLOC_DECORATOR;

   258     iExchange->QueryReceived( request );

   259     TInt count = NULL;

   260     EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count );

   261     if ( count > 0 && 

   262         ( iStorage->iResponseToRequest != SIPStrings::StringF( SipStrConsts::EOptions ) ||

   263         iExchange->Terminals().Count() < 1 ) )

   264         {

   265         User::Leave( KErrNoMemory );

   266         }

   267 

   268     EUNIT_ASSERT( iStorage->iResponseToRequest == SIPStrings::StringF( SipStrConsts::EOptions ) );

   269     EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

   270     EUNIT_ASSERT( iExchange->Terminals()[0]->IsDiscovered() );

   271     EUNIT_ASSERT( iStorage->iResponseToRequest == SIPStrings::StringF( SipStrConsts::EOptions ) );

   272     EUNIT_ASSERT( iStorage->iClientResponse->StatusCode() == KMUSAVASIPServerInternalError );

   273     EUNIT_ASSERT( iStorage->iClientResponse->MessageElements().Content().Length() == 0 );

   274     

   275     delete iExchange->iTerminals[ 0 ];

   276     iExchange->iTerminals.Remove( 0 );

   277     EUNIT_ASSERT( iExchange->Terminals().Count() == 0 );

   278     iStorage->Clear();

   279     }

   280     

   281 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_QueryReceived2L()

   282     {

   283     EUNIT_DISABLE_ALLOC_DECORATOR;

   284     MultimediaSharingSettings::SetSipProfileSettingL( 1 );

   285     if ( !iProfile->iArray )

   286         {

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

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

   289         }

   290     

   291     MultimediaSharingSettings::SetOperatorVariantSettingL( 

   292                                         MusSettingsKeys::EStandard );

   293     MultimediaSharingSettings::SetCapabilityQuerySettingL(

   294                                         MusSettingsKeys::ESequential );

   295     

   296     CSIPServerTransaction* request = NULL;

   297     

   298     TBufC16<16> str(KCapabilityTestSIPAddressUri_BSIP);

   299     HBufC16* ptr;

   300     ptr = str.AllocLC(); 

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

   302     CleanupStack::PushL( sipAddress );

   303     sipAddress->AppendL( *ptr );

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

   305     sipAddress->Reset();

   306     CleanupStack::PopAndDestroy( sipAddress );

   307     CleanupStack::PopAndDestroy(); //ptr   

   308     EUNIT_ENABLE_ALLOC_DECORATOR;

   309 

   310     // cingular case && first OPTIONS request received

   311 

   312     iExchange->iTerminals.ResetAndDestroy();

   313     iOptionHandler->iCapabilitiesRequestAnswered = EFalse;

   314     // set cingular variant key on

   315     MultimediaSharingSettings::SetOperatorVariantSettingL( 

   316                                         MusSettingsKeys::EOperatorSpecific );                           

   317     request = CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   318                                                 KCapabilityTestAddress_B,

   319                                                 KCapabilitySwisFeature,

   320                                                 KCapabilitySwisFeature,

   321                                                 KCapabilityTestAcceptHeader,

   322                                                 KCapabilityTestTerminalID_B );

   323                                                 

   324     iOptionHandler->iState = MMusAvaObserver::EMusAvaStatusNotExecuted;

   325     iExchange->QueryReceived( request );

   326     TInt count = NULL;

   327     EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count );

   328     if ( count > 0 && 

   329         iOptionHandler->State() != MMusAvaObserver::EMusAvaStatusOptionsSent )

   330         {

   331         User::Leave( KErrNoMemory );

   332         }

   333 

   334     EUNIT_ASSERT( iOptionHandler->State() == MMusAvaObserver::EMusAvaStatusOptionsSent);

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

   336     MUS_HEADER_ASSERT( iStorage->iClientResponse, 0, KCapabilityTestContactHeader_A );

   337 

   338     iStorage->Clear();

   339     // cingular case && second OPTIONS request received

   340     // set cingular variant key on

   341     EUNIT_DISABLE_ALLOC_DECORATOR;

   342     MultimediaSharingSettings::SetOperatorVariantSettingL( 

   343                                         MusSettingsKeys::EOperatorSpecific );                           

   344 

   345 

   346     iExchange->iTerminals.ResetAndDestroy();

   347     iOptionHandler->iState = MMusAvaObserver::EMusAvaStatusNotExecuted;

   348     iOptionHandler->iCapabilitiesRequestAnswered = ETrue;

   349 

   350     request = CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   351                                                 KCapabilityTestAddress_B,

   352                                                 KCapabilitySwisFeature,

   353                                                 KCapabilitySwisFeature,

   354                                                 KCapabilityTestAcceptHeader,

   355                                                 KCapabilityTestTerminalID_B );

   356     EUNIT_ENABLE_ALLOC_DECORATOR;

   357     iExchange->QueryReceived( request );

   358     EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count );

   359     if ( count > 0 && 

   360         iStorage->iClientResponse->MessageElements().UserHeaders().Count() == 0 )

   361         {

   362         User::Leave( KErrNoMemory );

   363         }

   364         

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

   366     EUNIT_ASSERT( MultimediaSharingSettings::OperatorVariantSettingL() ==

   367             MusSettingsKeys::EOperatorSpecific );

   368     EUNIT_ASSERT( iOptionHandler->State() == MMusAvaObserver::EMusAvaStatusNotExecuted );

   369     MUS_HEADER_ASSERT( iStorage->iClientResponse, 0, KCapabilityTestContactHeaderNoFeaturetag_A );

   370     }

   371     

   372 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_CancelQueryL()

   373     {

   374     EUNIT_DISABLE_ALLOC_DECORATOR;

   375     if ( !iProfile->iArray )

   376         {

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

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

   379         }

   380     

   381     CMusAvaCapabilityQuery* query = NULL;

   382     

   383     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   384                                             *iSIPConnection,

   385                                             *iProfile,

   386                                             KCapabilityTestSIPAddressUri_B );

   387     CleanupStack::PushL( query );

   388 

   389     EUNIT_ASSERT( query->Result() ==  KCapabilityQueryNotReady );

   390     EUNIT_ASSERT( query->State() == 

   391                     CMusAvaCapabilityQueryBase::ECapabilityQueryCreated );

   392     EUNIT_ASSERT( !query->iTimer );

   393     EUNIT_ASSERT( !query->iTrx );

   394         

   395     EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

   396     EUNIT_ASSERT( query->Terminal().Id().Length() == 0 );

   397     EUNIT_ASSERT( !query->Terminal().RequestedQuery() );

   398     EUNIT_ASSERT( !query->Terminal().IsDiscovered() );

   399         

   400     query->Terminal().ExecuteQueryL( query );

   401     CleanupStack::Pop( query );

   402 

   403     EUNIT_ASSERT( query->Terminal().iQuery == query );

   404     EUNIT_ASSERT( query->Result() ==  KCapabilityQueryNotReady );

   405     EUNIT_ASSERT( query->State() == 

   406                     CMusAvaCapabilityQueryBase::ECapabilityQueryExecuting );

   407     EUNIT_ASSERT( !query->iTimer );

   408     EUNIT_ASSERT( query->iTrx );

   409 

   410     query->SetState( CMusAvaCapabilityQueryBase::ECapabilityQueryExecuting );

   411 

   412     //200 OK with User-Agent

   413     CapabilityTestHelper::SetResponseL( *query->iTrx, 

   414                                 KMUSAVASIP200, 

   415                                 SipStrConsts::EPhraseOk,

   416                                 KCapabilityTestAddress_B,

   417                                 KCapabilitySwisFeature,

   418                                 KCapabilityTestTerminalID_B,

   419                                 KPAssertedIdentity_B,

   420                                 KCapabilityTestSDP );

   421     TInt err = 404;

   422     EUNIT_ENABLE_ALLOC_DECORATOR;

   423     iExchange->CancelQuery( err, *query->iTrx );

   424     EUNIT_ASSERT( query->State() == 

   425                 CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

   426     }

   427   

   428 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_AddCapabilityLL(  )

   429     {

   430     TInt index = KErrNotFound;

   431     CMusAvaCapability* capability = NULL;

   432     

   433         for ( TInt i=0; i < iExchange->iCapabilities.Count() && index == KErrNotFound; i++ )

   434         {

   435         capability = iExchange->iCapabilities[i];

   436         if ( capability->Feature() == iCapability->Feature() )

   437             {

   438             index = i;

   439             }

   440         }

   441     EUNIT_ASSERT( index == 0 );

   442     }

   443 

   444 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_TerminalLL()

   445     {

   446     EUNIT_ASSERT( iExchange->Terminals().Count() == 0 );

   447 

   448     CSIPServerTransaction* request = NULL;

   449     

   450     for( TInt i = 0;i<6;i++ )

   451         {

   452         

   453         if ( i == 0 || i == 1 )

   454             {

   455                 

   456             request = 

   457                 CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   458                                                  KCapabilityTestAddress_B,

   459                                                  KCapabilitySwisFeature,

   460                                                  KCapabilitySwisFeature,

   461                                                  KCapabilityTestAcceptHeader,

   462                                                  KNullDesC8 );

   463             }

   464         else if ( i == 2 || i == 3 )

   465             {

   466             request = 

   467                 CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   468                                                  KCapabilityTestAddress_B,

   469                                                  KCapabilitySwisFeature,

   470                                                  KCapabilitySwisFeature,

   471                                                  KCapabilityTestAcceptHeader,

   472                                                  KCapabilityTestTerminalID_B );

   473             }

   474         else if ( i == 4 )

   475             {

   476             request = 

   477                 CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   478                                                  KCapabilityTestAddress_A,//OK

   479                                                  KCapabilitySwisFeature,

   480                                                  KCapabilitySwisFeature,

   481                                                  KCapabilityTestAcceptHeader,

   482                                                  KNullDesC8 );

   483             }

   484         else if ( i == 5 )

   485             {

   486             request = 

   487                 CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   488                                                  KCapabilityTestAddress_A,//OK

   489                                                  KCapabilitySwisFeature,

   490                                                  KCapabilitySwisFeature,

   491                                                  KCapabilityTestAcceptHeader,

   492                                                  KCapabilityTestTerminalID_A );

   493             }

   494 

   495         CleanupStack::PushL( request );

   496         

   497         // Next function call creates a terminal for capability exchage

   498         iExchange->TerminalL( *request );

   499         

   500         if ( i == 0 )

   501             {

   502             // Next function has the same uri as the already created terminal has, it should not create the new one

   503             iExchange->TerminalL( KCapabilityTestAddress_B );

   504             EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

   505             EUNIT_ASSERT( iExchange->Terminals()[0]->Id().Compare( KNullDesC8 ) == 0 );

   506             EUNIT_ASSERT( iExchange->Terminals()[0]->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   507             }

   508         else if ( i == 1 )

   509             {

   510             // Next function has the same uri as the already created terminal has, it should not create the new one

   511             iExchange->TerminalL( KCapabilityTestAddress_B );

   512             EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

   513             EUNIT_ASSERT( iExchange->Terminals()[0]->Id().Compare( KNullDesC8 ) == 0 );

   514             EUNIT_ASSERT( iExchange->Terminals()[0]->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   515             }

   516         else if ( i == 2 )

   517             {

   518             // Next function has the same uri as the already created terminal has, it should not create the new one

   519             iExchange->TerminalL( KCapabilityTestAddress_B );

   520             EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

   521             EUNIT_ASSERT( iExchange->Terminals()[0]->Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   522             EUNIT_ASSERT( iExchange->Terminals()[0]->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   523             }

   524         else if ( i == 3 )

   525             {

   526             // Next function has the same uri as the already created terminal has, it should not create the new one

   527             iExchange->TerminalL( KCapabilityTestAddress_B );

   528             EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

   529             EUNIT_ASSERT( iExchange->Terminals()[0]->Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   530             EUNIT_ASSERT( iExchange->Terminals()[0]->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   531             }

   532         else if ( i == 4 )

   533             {

   534             // Next function has the same uri as the already created terminal has, it should not create the new one

   535             iExchange->TerminalL( KCapabilityTestAddress_B );

   536             EUNIT_ASSERT( iExchange->Terminals().Count() == 2 );

   537             EUNIT_ASSERT( iExchange->Terminals()[0]->Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   538             EUNIT_ASSERT( iExchange->Terminals()[0]->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   539             EUNIT_ASSERT( iExchange->Terminals()[1]->Id().Compare( KNullDesC8 ) == 0 );

   540             EUNIT_ASSERT( iExchange->Terminals()[1]->Uri().Compare( KCapabilityTestAddress_A ) == 0 );

   541             }

   542         else if ( i == 5 )

   543             {

   544             // Next function has the same uri as the already created terminal has, it should not create the new one

   545             iExchange->TerminalL( KCapabilityTestAddress_B );

   546             EUNIT_ASSERT( iExchange->Terminals().Count() == 2 );

   547             EUNIT_ASSERT( iExchange->Terminals()[0]->Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   548             EUNIT_ASSERT( iExchange->Terminals()[0]->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   549             EUNIT_ASSERT( iExchange->Terminals()[1]->Id().Compare( KCapabilityTestTerminalID_A ) == 0 );

   550             EUNIT_ASSERT( iExchange->Terminals()[1]->Uri().Compare( KCapabilityTestAddress_A ) == 0 );

   551             }

   552 

   553         CleanupStack::PopAndDestroy( request );

   554 

   555         }

   556     

   557     }

   558 

   559 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_RejectQueryLL()

   560     {

   561     EUNIT_DISABLE_ALLOC_DECORATOR;

   562     CSIPServerTransaction* request = NULL;

   563     

   564     iStorage->Clear();

   565     

   566     request = 

   567         CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   568                                          KCapabilityTestAddress_B,

   569                                          KCapabilitySwisFeature,

   570                                          KCapabilitySwisFeature,

   571                                          KCapabilityTestAcceptHeader,

   572                                          KNullDesC8 );

   573 

   574 

   575     CleanupStack::PushL( request );

   576     EUNIT_ENABLE_ALLOC_DECORATOR;

   577 

   578     iExchange->RejectQueryL( *request, KMUSAVASIPNotImplemented );

   579     EUNIT_ASSERT( iStorage->iResponseToRequest == SIPStrings::StringF( SipStrConsts::EOptions ) );

   580     EUNIT_ASSERT( iStorage->iClientResponse->StatusCode() == KMUSAVASIPNotImplemented );

   581     EUNIT_ASSERT( iStorage->iClientResponse->ReasonPhrase() == SIPStrings::StringF( SipStrConsts::EEmpty ) );

   582     EUNIT_ASSERT( iStorage->iClientResponse->MessageElements().Content().Length() == 0 );

   583 

   584     iStorage->Clear();

   585 

   586     iExchange->RejectQueryL( *request, KErrGeneral );

   587     EUNIT_ASSERT( iStorage->iResponseToRequest == SIPStrings::StringF( SipStrConsts::EOptions ) );

   588     EUNIT_ASSERT( iStorage->iClientResponse->StatusCode() == KMUSAVASIPServerInternalError );

   589     EUNIT_ASSERT( iStorage->iClientResponse->ReasonPhrase() == SIPStrings::StringF( SipStrConsts::EPhraseServerInternalError ) );

   590     EUNIT_ASSERT( iStorage->iClientResponse->MessageElements().Content().Length() == 0 );

   591 

   592     CleanupStack::PopAndDestroy( request );

   593     }

   594 

   595 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_FindByFeatureL()

   596     {

   597     EUNIT_ASSERT( iExchange->FindByFeature(*iCapability) == 0 );

   598     }

   599 

   600 void UT_CMusAvaCapabilityExchange::UT_CMusAvaCapabilityExchange_AnswerToQueryReceivedL(  )

   601     {

   602     if ( !iProfile->iArray )

   603         {

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

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

   606         }

   607     

   608     MultimediaSharingSettings::SetOperatorVariantSettingL( 

   609                                         MusSettingsKeys::EStandard );

   610 

   611     EUNIT_ASSERT( iExchange->Capabilities().Count() == 1 );

   612     EUNIT_ASSERT( iExchange->Capabilities()[0] == iCapability );

   613     EUNIT_ASSERT( iCapability->Feature().DesC().Compare( KCapabilitySwisFeature ) == 0 );

   614     

   615     CMusAvaCapabilityQuery* query = NULL;

   616     

   617     

   618 //init

   619     for( TInt i = 0; i<5;i++ )

   620         {

   621         query = CMusAvaCapabilityQuery::NewL( *iCapability,

   622                                             *iSIPConnection,

   623                                             *iProfile,

   624                                             KCapabilityTestSIPAddressUri_B );

   625         CleanupStack::PushL( query );

   626 

   627         EUNIT_ASSERT( query->Result() ==  KCapabilityQueryNotReady );

   628         EUNIT_ASSERT( query->State() == CMusAvaCapabilityQueryBase::ECapabilityQueryCreated );

   629         EUNIT_ASSERT( !query->iTimer );

   630         EUNIT_ASSERT( !query->iTrx );

   631     

   632         EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

   633         if ( i == 0 )

   634             {

   635             EUNIT_ASSERT( query->Terminal().Id().Length() == 0 );

   636             }

   637         else

   638             {

   639             EUNIT_ASSERT( query->Terminal().Id().Length() > 0 );

   640             EUNIT_ASSERT( query->Terminal().Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   641             }

   642 

   643         EUNIT_ASSERT( !query->Terminal().RequestedQuery() );

   644         EUNIT_ASSERT( !query->Terminal().IsDiscovered() );

   645         

   646         // Since several queries cannot be executed, we delete the old one... 

   647         delete query->iTerminal->iQuery;

   648         query->iTerminal->iQuery = NULL;

   649         

   650         // ...before execution

   651         query->Terminal().ExecuteQueryL( query );

   652         CleanupStack::Pop( query );

   653 

   654         EUNIT_ASSERT( query->Terminal().iQuery == query );

   655         EUNIT_ASSERT( query->Result() ==  KCapabilityQueryNotReady );

   656         EUNIT_ASSERT( query->State() == CMusAvaCapabilityQueryBase::ECapabilityQueryExecuting );

   657         EUNIT_ASSERT( !query->iTimer );

   658         EUNIT_ASSERT( query->iTrx );

   659         

   660         EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

   661         if ( i == 0 )

   662             {

   663             EUNIT_ASSERT( query->Terminal().Id().Length() == 0 );

   664             }

   665         else

   666             {

   667             EUNIT_ASSERT( query->Terminal().Id().Length() > 0 );

   668             EUNIT_ASSERT( query->Terminal().Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   669             }

   670         

   671         HBufC* uri16 = EscapeUtils::ConvertToUnicodeFromUtf8L( query->Terminal().Uri() );

   672         EUNIT_ASSERT( uri16->Compare( KCapabilityTestSIPAddressUri_B ) == 0 );

   673         delete uri16;

   674         uri16 = NULL;

   675         EUNIT_ASSERT( !query->Terminal().RequestedQuery() );

   676         EUNIT_ASSERT( !query->Terminal().IsDiscovered() );

   677 

   678         EUNIT_ASSERT( iStorage->iClientRequest->Method() == SIPStrings::StringF( SipStrConsts::EOptions ) );

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

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

   681         EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().UserHeaders().Count() == 6 );

   682         MUS_HEADER_ASSERT( iStorage->iClientRequest, 0, KCapabilityTestAcceptContactHeader );

   683         MUS_HEADER_ASSERT( iStorage->iClientRequest, 5, KCapabilityTestContactHeader_A1Updated );

   684         MUS_HEADER_ASSERT( iStorage->iClientRequest, 3, KCapabilityTestAcceptHeader );

   685 

   686     //set response

   687 

   688         //    GSMA     Cingular

   689         if ( i == 0 || i == 3 )//200 OK FT

   690             {

   691             CapabilityTestHelper::SetResponseL( *query->iTrx, KMUSAVASIP200, SipStrConsts::EPhraseOk,

   692                                           KCapabilityTestAddress_B,

   693                                           KCapabilitySwisFeature,

   694                                           KCapabilityTestTerminalID_B,

   695                                           KPAssertedIdentity_B,

   696                                           KCapabilityTestSDP );

   697             }

   698         //         GSMA     Cingular

   699         else if ( i == 1 || i == 4 )//200 OK NO FT

   700             {

   701             CapabilityTestHelper::SetResponseL( *query->iTrx, KMUSAVASIP200, SipStrConsts::EPhraseOk,

   702                                           KCapabilityTestAddress_B,

   703                                           KNullDesC8,

   704                                           KCapabilityTestTerminalID_B,

   705                                           KPAssertedIdentity_B,

   706                                           KCapabilityTestSDP );

   707             

   708             }

   709         else if ( i == 2 )//GSMA & 404

   710             {

   711             CapabilityTestHelper::SetResponseL( *query->iTrx, KMUSAVASIPNotFound, SipStrConsts::EPhraseNotFound,

   712                                           KCapabilityTestAddress_B,

   713                                           KNullDesC8,

   714                                           KNullDesC8,

   715                                           KNullDesC8,

   716                                           KNullDesC8 );

   717             

   718             }

   719 

   720         if ( i == 4 )

   721             {

   722             EUNIT_ASSERT( 

   723                 MultimediaSharingSettings::OperatorVariantSettingL() ==

   724                                                 MusSettingsKeys::EStandard );

   725                 // set cingular variant key on

   726             MultimediaSharingSettings::SetOperatorVariantSettingL( 

   727                                         MusSettingsKeys::EOperatorSpecific );

   728             EUNIT_ASSERT( MultimediaSharingSettings::OperatorVariantSettingL()

   729                         == MusSettingsKeys::EOperatorSpecific );

   730             }

   731 

   732         //iExchange->iTerminal

   733         iExchange->AnswerToQueryReceived( *query->iTrx );

   734         TInt count = NULL;

   735         EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count );

   736         if ( count > 0 && 

   737             query->Terminal().Id().Length() == 0 )

   738             {

   739             User::Leave( KErrNoMemory );

   740             }

   741         if ( count > 0 && 

   742             i == 1 && 

   743             query->Terminal().iQuery->Result() != KCapabilityCapabilitesNotFound )

   744             {

   745             User::Leave( KErrNoMemory );

   746             }

   747         if ( count > 0 && 

   748             i == 2 && 

   749             !query->Retrying() )

   750             {

   751             User::Leave( KErrNoMemory );

   752             }

   753         

   754         EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

   755         EUNIT_ASSERT( query->Terminal().Id().Length() > 0 );

   756         EUNIT_ASSERT( query->Terminal().Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   757         uri16 = EscapeUtils::ConvertToUnicodeFromUtf8L( query->Terminal().Uri() );

   758         delete uri16;

   759         uri16 = NULL;

   760         EUNIT_ASSERT( !query->Terminal().RequestedQuery() );

   761 

   762 

   763         if ( i == 0 || i == 3 )//200 OK FT

   764             {

   765             EUNIT_ASSERT( 

   766                 MultimediaSharingSettings::OperatorVariantSettingL() ==

   767                                                 MusSettingsKeys::EStandard );

   768             EUNIT_ASSERT( query->Terminal().iQuery->State() == CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

   769             EUNIT_ASSERT( query->Terminal().IsDiscovered() );

   770             EUNIT_ASSERT( !query->Retrying() );

   771             EUNIT_ASSERT( query->iTimer == NULL );

   772             }

   773         else if ( i == 1 )//GSMA & 200 OK NO FT

   774             {

   775             EUNIT_ASSERT( 

   776                 MultimediaSharingSettings::OperatorVariantSettingL() ==

   777                                                 MusSettingsKeys::EStandard );

   778             EUNIT_ASSERT( query->Terminal().iQuery == query );

   779             EUNIT_ASSERT( query->Terminal().iQuery->Result() == KCapabilityCapabilitesNotFound );

   780             EUNIT_ASSERT( query->Terminal().IsDiscovered() );

   781             EUNIT_ASSERT( !query->Retrying() );

   782             EUNIT_ASSERT( query->iTimer == NULL );

   783             }

   784         else if ( i == 4 )//( not yet Cingular) & 200 OK NO FT

   785             {

   786             EUNIT_ASSERT( MultimediaSharingSettings::OperatorVariantSettingL()

   787                         == MusSettingsKeys::EOperatorSpecific );

   788             MultimediaSharingSettings::SetOperatorVariantSettingL( 

   789                                         MusSettingsKeys::EStandard );

   790             EUNIT_ASSERT( query->Terminal().iQuery == query );

   791             EUNIT_ASSERT( query->Terminal().iQuery->Result() == KCapabilityCapabilitesNotFound );

   792             EUNIT_ASSERT( query->Terminal().IsDiscovered() );

   793             EUNIT_ASSERT( !query->Retrying() );

   794             EUNIT_ASSERT( query->iTimer == NULL );

   795             }

   796         else if ( i == 2 )  //GSMA & 404

   797             {

   798             EUNIT_ASSERT( 

   799                 MultimediaSharingSettings::OperatorVariantSettingL() ==

   800                                                 MusSettingsKeys::EStandard );

   801             EUNIT_ASSERT( !query->Terminal().iQuery == NULL );

   802             EUNIT_ASSERT( !query->Terminal().IsDiscovered() );

   803             EUNIT_ASSERT( query->Retrying() );

   804             EUNIT_ASSERT( query->iTimer != NULL );

   805             

   806             query->OnExpiredL( KErrNone );

   807             EUNIT_ASSERT( iStorage->iClientRequest->Method() == SIPStrings::StringF( SipStrConsts::EOptions ) );

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

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

   810             EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().UserHeaders().Count() == 6 );

   811             MUS_HEADER_ASSERT( iStorage->iClientRequest, 0, KCapabilityTestAcceptContactHeader );

   812             MUS_HEADER_ASSERT( iStorage->iClientRequest, 5, KCapabilityTestContactHeader_A1Updated );

   813             

   814             CapabilityTestHelper::SetResponseL( *query->iTrx, KMUSAVASIPNotFound, SipStrConsts::EPhraseNotFound,

   815                                           KCapabilityTestAddress_B,

   816                                           KNullDesC8,

   817                                           KNullDesC8,

   818                                           KNullDesC8,

   819                                           KNullDesC8 );

   820             iExchange->AnswerToQueryReceived( *query->iTrx );

   821             EUNIT_ASSERT( query->Terminal().iQuery == query );

   822             EUNIT_ASSERT( query->Terminal().iQuery->Result() == KCapabilityCapabilitesNotFound );

   823             EUNIT_ASSERT( query->Terminal().IsDiscovered() );

   824             EUNIT_ASSERT( !query->Retrying() );

   825             EUNIT_ASSERT( query->iTimer == NULL );

   826 

   827             }

   828         }

   829     MultimediaSharingSettings::SetOperatorVariantSettingL( 

   830                                         MusSettingsKeys::EStandard );

   831     }

   832 

   833 

   834 //  TEST TABLE

   835 

   836 EUNIT_BEGIN_TEST_TABLE( 

   837     UT_CMusAvaCapabilityExchange,

   838     "CMusAvaCapabilityExchange",

   839     "UNIT" )

   840 

   841 EUNIT_TEST(

   842     "NewL - test ",

   843     "CMusAvaCapabilityExchange",

   844     "NewL",

   845     "FUNCTIONALITY",

   846     SetupL,UT_CMusAvaCapabilityExchange_NewLL, Teardown)

   847     

   848 EUNIT_TEST(

   849     "QueryObserverL - test ",

   850     "CMusAvaCapabilityExchange",

   851     "QueryObserver",

   852     "FUNCTIONALITY",

   853     SetupL,UT_CMusAvaCapabilityExchange_QueryObserverL, Teardown)        

   854 

   855 EUNIT_TEST(

   856     "TerminalId - test ",

   857     "CMusAvaCapabilityExchange",

   858     "TerminalId",

   859     "FUNCTIONALITY",

   860     SetupL,UT_CMusAvaCapabilityExchange_TerminalIdL, Teardown)

   861     

   862 

   863 EUNIT_TEST(

   864     "QueryReceivedL - test ",

   865     "CMusAvaCapabilityExchange",

   866     "QueryReceivedL",

   867     "FUNCTIONALITY",

   868     SetupL,UT_CMusAvaCapabilityExchange_QueryReceivedL, Teardown)

   869 

   870 EUNIT_TEST(

   871     "QueryReceivedL1 - test ",

   872     "CMusAvaCapabilityExchange",

   873     "QueryReceivedL",

   874     "FUNCTIONALITY",

   875     SetupL,UT_CMusAvaCapabilityExchange_QueryReceived1L, Teardown)

   876 

   877 EUNIT_TEST(

   878     "QueryReceivedL2 - test ",

   879     "CMusAvaCapabilityExchange",

   880     "QueryReceivedL",

   881     "FUNCTIONALITY",

   882     SetupL,UT_CMusAvaCapabilityExchange_QueryReceived2L, Teardown)

   883 

   884 EUNIT_TEST(

   885     "CancelQuery - test ",

   886     "CMusAvaCapabilityExchange",

   887     "CancelQuery",

   888     "FUNCTIONALITY",

   889     SetupL,UT_CMusAvaCapabilityExchange_CancelQueryL, Teardown)   

   890      

   891  EUNIT_TEST(

   892     "AddCapability - test ",

   893     "CMusAvaCapabilityExchange",

   894     "AddCapability",

   895     "FUNCTIONALITY",

   896     SetupL,UT_CMusAvaCapabilityExchange_AddCapabilityLL, Teardown)           

   897          

   898  EUNIT_TEST(

   899     "TerminalL - test ",

   900     "CMusAvaCapabilityExchange",

   901     "TerminalL",

   902     "FUNCTIONALITY",

   903     SetupL,UT_CMusAvaCapabilityExchange_TerminalLL, Teardown)           

   904          

   905  EUNIT_TEST(

   906     "RejectQueryL - test ",

   907     "CMusAvaCapabilityExchange",

   908     "RejectQueryL",

   909     "FUNCTIONALITY",

   910     SetupL,UT_CMusAvaCapabilityExchange_RejectQueryLL, Teardown)           

   911          

   912  EUNIT_TEST(

   913     "FindByFeature - test ",

   914     "CMusAvaCapabilityExchange",

   915     "FindByFeature",

   916     "FUNCTIONALITY",

   917     SetupL,UT_CMusAvaCapabilityExchange_FindByFeatureL, Teardown)           

   918          

   919  EUNIT_TEST(

   920     "AnswerToQueryReceived - test ",

   921     "CMusAvaCapabilityExchange",

   922     "AnswerToQueryReceived",

   923     "FUNCTIONALITY",

   924     SetupL,UT_CMusAvaCapabilityExchange_AnswerToQueryReceivedL, Teardown)           

   925          

   926 EUNIT_END_TEST_TABLE

   927 

   928 //  END OF FILE