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

    21 #include "musavasettingsimp.h"

    22 #include "musavaobserverimp.h"

    23 #include "musavaavailabilityobserver.h"

    24 #include "musavaavailabilityobserverimp.h"

    25 #include "muslogger.h"

    26 

    27 

    28 

    29 //  EXTERNAL INCLUDES

    30 #include <EscapeUtils.h>

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

    32 #include <sipstrings.h>

    33 #include <sipstrconsts.h>

    34 #include <stringpool.h>

    35 #include <sipservertransaction.h>

    36 #include <siptransactionbase.h>

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

    38 //  INTERNAL INCLUDES

    39 #include "musavaoptionhandler.h"

    40 #include "musavacapabilitytesthelper.h"

    41 #include "CSipSseTestTls.h"

    42 #include "musavaCapabilityExchange.h"

    43 #include "musavacapabilitysipagent.h"

    44 #include "MusAvaCapabilityQuery.h"

    45 #include "musavaterminal.h"

    46 #include "sipprofile.h"

    47 #include "musavasharedobject.h"

    48 #include "mussettingskeys.h"

    49 #include "mussettings.h"

    50 #include "musavasip.h"

    51 

    52 

    53 // CONSTRUCTION

    54 UT_CMusAvaCapabilitySipAgent* UT_CMusAvaCapabilitySipAgent::NewL()

    55     {

    56     UT_CMusAvaCapabilitySipAgent* self = UT_CMusAvaCapabilitySipAgent::NewLC(); 

    57     CleanupStack::Pop();

    58 

    59     return self;

    60     }

    61 

    62 UT_CMusAvaCapabilitySipAgent* UT_CMusAvaCapabilitySipAgent::NewLC()

    63     {

    64     UT_CMusAvaCapabilitySipAgent* self = new( ELeave ) UT_CMusAvaCapabilitySipAgent();

    65     CleanupStack::PushL( self );

    66 	self->ConstructL(); 

    67 

    68     return self;

    69     }

    70 

    71 // Destructor (virtual by CBase)

    72 UT_CMusAvaCapabilitySipAgent::~UT_CMusAvaCapabilitySipAgent()

    73     {

    74     }

    75 

    76 // Default constructor

    77 UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent()

    78     {

    79     }

    80 

    81 // Second phase construct

    82 void UT_CMusAvaCapabilitySipAgent::ConstructL()

    83     {

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

    85     // It generates the test case table.

    86     CEUnitTestSuiteClass::ConstructL();

    87     }

    88 

    89 //  METHODS

    90 

    91 void UT_CMusAvaCapabilitySipAgent::SetupL(  )

    92     {

    93     iSharedObject = CMusAvaSharedObject::GetSingletonL();

    94     iAvailabilityObserver = CMusAvaAvailabilityObserverImp::NewL();

    95     iConcreteSettings = CMusAvaSettingsImp::NewL();

    96     iOptionHandler = CMusAvaOptionHandler::NewL( *iAvailabilityObserver,

    97                                                  *iConcreteSettings );

    98     iExchange = iOptionHandler->iCapabilityExchange;

    99     iSipAgent = CMusAvaCapabilitySipAgent::NewL( *iExchange, 

   100                                                 *iOptionHandler->iSharedObj,

   101                                                  iOptionHandler->iObserver);

   102     

   103     iCapability = iOptionHandler->iSwisCapability;

   104 

   105     MSIPConnectionObserver& connectionObserver = 

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

   107     

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

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

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

   111     TUint32 iapId;

   112     TInt err = iProfile->GetParameter( KSIPAccessPointId, iapId );

   113     iSIPConnection = CSIPConnection::NewL( sip, 

   114                                            iapId,

   115                                            connectionObserver );

   116 

   117     iSharedObject->MusAvaSip().ConnectionL(); // Forced connection creation

   118 

   119     if ( !iProfile->iArray )

   120         {

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

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

   123         }

   124     if ( !iProfile->iRegisteredContact )

   125         {

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

   127         }

   128     if ( !iProfile->iRegisteredContact )

   129         {

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

   131         }

   132 

   133     CSipSseTestTls::OpenL();

   134     iStorage = CSipSseTestTls::Storage();

   135     

   136     iProfileId = MultimediaSharingSettings::SipProfileSettingL();

   137     } 

   138 

   139 void UT_CMusAvaCapabilitySipAgent::Teardown(  )

   140     {

   141     CMusAvaSharedObject::DeleteSingleton();

   142 

   143     if ( iStorage )

   144        {

   145        iStorage->Clear();

   146        CSipSseTestTls::Close();

   147        iStorage = NULL;

   148        }

   149     delete iSipAgent;

   150     delete iOptionHandler;

   151     delete iConcreteSettings;

   152     delete iAvailabilityObserver;

   153 

   154     delete iSIPConnection;

   155     }

   156 

   157 void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_NewLL(  )

   158     {

   159     EUNIT_ASSERT( iSipAgent );

   160     }

   161 

   162 void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_ExecuteCapabilityQueryLL(  )

   163     {

   164     EUNIT_ASSERT( iSipAgent );

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

   166     

   167     TInt ret = NULL;

   168     TRAPD ( error, ret = iSharedObject->MusAvaSip().CreateProfileL() );

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

   170     EUNIT_ASSERT( ret );

   171     MultimediaSharingSettings::SetSipProfileSettingL( 1 );

   172     

   173     iSipAgent->ExecuteCapabilityQueryL( *iCapability, 

   174                                         KCapabilityTestSIPAddressUri_B );

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

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

   177                             

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

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

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

   181             KCapabilityTestSIPAddressUri8_B ) == 0);

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

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

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

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

   186     }

   187 

   188 void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_IncomingRequestL(  )

   189     {

   190     

   191     CSIPServerTransaction* request = CapabilityTestHelper::OptionsRequestL( 

   192                                                 KCapabilityTestAddress_A,

   193                                                 KCapabilityTestAddress_B,

   194                                                 KCapabilitySwisFeature,

   195                                                 KCapabilitySwisFeature,

   196                                                 KCapabilityTestAcceptHeader,

   197                                                 KCapabilityTestTerminalID_B );

   198                                                 

   199     TUint32 iapId = iSIPConnection->IapId();

   200 

   201     /*EUNIT_ASSERT( iSipAgent->IncomingRequest( iapId, request ) == KErrNone );

   202 

   203     EUNIT_ASSERT( server->iResponseToRequest == SIPStrings::StringF( SipStrConsts::EOptions ) );

   204     EUNIT_ASSERT( server->iClientResponse->StatusCode() == KMUSAVASIP200 );

   205     EUNIT_ASSERT( server->iClientResponse->MessageElements().Content().Length() > 0 );

   206     EUNIT_ASSERT( server->iClientResponse->MessageElements().Content().Compare( KCapabilityTestSDP ) == 0 );

   207         

   208     EUNIT_ASSERT( server->iClientResponse->MessageElements().UserHeaders().Count() == 1 );

   209     MUS_HEADER_ASSERT( server->iClientResponse, 0, KCapabilityTestContactHeader_A );

   210     */

   211     EUNIT_ASSERT( iSipAgent->IncomingRequest( iapId, request ) == KErrNotFound );

   212     delete request;

   213     

   214     EUNIT_ASSERT( !iOptionHandler->iCapabilityQueryAnswered );  

   215     iOptionHandler->iObserver.AvailabilityChanged(MMusAvaObserver::EMusAvaOptionHandler,

   216             MMusAvaObserver::EMusAvaStatusCallOnHold);

   217     request = CapabilityTestHelper::OptionsRequestL( 

   218                                                 KCapabilityTestAddress_A,

   219                                                 KCapabilityTestAddress_B,

   220                                                 KCapabilitySwisFeature,

   221                                                 KCapabilitySwisFeature,

   222                                                 KCapabilityTestAcceptHeader,

   223                                                 KCapabilityTestTerminalID_B );    

   224     EUNIT_ASSERT( iSipAgent->IncomingRequest( request ) == KErrNotFound );

   225     delete request;

   226     

   227     iOptionHandler->iObserver.AvailabilityChanged(MMusAvaObserver::EMusAvaOptionHandler,

   228                 MMusAvaObserver::EMusAvaStatusOptionsNotSent);

   229     request = CapabilityTestHelper::OptionsRequestL( 

   230                                                  KCapabilityTestAddress_A,

   231                                                  KCapabilityTestAddress_B,

   232                                                  KCapabilitySwisFeature,

   233                                                  KCapabilitySwisFeature,

   234                                                  KCapabilityTestAcceptHeader,

   235                                                  KCapabilityTestTerminalID_B );    

   236     EUNIT_ASSERT( iSipAgent->IncomingRequest( request ) == KErrNone );   

   237 

   238     iOptionHandler->iCapabilityQueryAnswered = ETrue; 

   239     EUNIT_ASSERT( iOptionHandler->iCapabilityQueryAnswered );

   240 

   241     request = CapabilityTestHelper::OptionsRequestL( 

   242                                                 KCapabilityTestAddress_A,

   243                                                 KCapabilityTestAddress_B,

   244                                                 KCapabilitySwisFeature,

   245                                                 KCapabilitySwisFeature,

   246                                                 KCapabilityTestAcceptHeader,

   247                                                 KCapabilityTestTerminalID_B );

   248     

   249     EUNIT_ASSERT( iSipAgent->IncomingRequest( request ) == KErrNotFound ); 

   250     delete request;

   251     

   252     CSIPServerTransaction* transaction = 

   253                 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EInvite ) );

   254     iStorage->SetError( KErrGeneral );

   255     EUNIT_ASSERT( iSipAgent->IncomingRequest( transaction ) == KErrNone );   

   256     iStorage->SetError( KErrNone );

   257     

   258     

   259     

   260     

   261     }

   262 

   263 void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_HandleIncomingRequestLL(  )

   264     {

   265     CSIPServerTransaction* transaction = 

   266     CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EInvite ) );

   267     CleanupStack::PushL( transaction );

   268     transaction->iIsClientTransaction = ETrue;

   269     transaction->iState = CSIPTransactionBase::ETrying; 

   270     

   271     TUriParser8 Uri;

   272     User::LeaveIfError( Uri.Parse( KCapabilityTestAddress_A ) );

   273     

   274   	CUri8* uri = CUri8::NewLC( Uri );

   275   	

   276     CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri ); 

   277     CleanupStack::Pop( uri );

   278     CleanupStack::PushL( requestelements );

   279     requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EInvite ) );

   280     transaction->SetRequestElements( requestelements );

   281     CleanupStack::Pop( requestelements );

   282     

   283     iSipAgent->HandleIncomingRequestL( *transaction );

   284     //iSipAgent->IncomingRequest( transaction );

   285     

   286     EUNIT_ASSERT( iStorage->iClientResponse->ReasonPhrase() == 

   287                 SIPStrings::StringF( SipStrConsts::EPhraseNotImplemented ) );

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

   289     CleanupStack::PopAndDestroy( transaction );

   290     

   291     }

   292 

   293 void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_IncomingResponseL(  )

   294     {

   295     CMusAvaCapabilityQuery* query = NULL;

   296     MultimediaSharingSettings::SetOperatorVariantSettingL( 

   297                                         MusSettingsKeys::EStandard );

   298 //init

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

   300         {

   301         query = CMusAvaCapabilityQuery::NewL( *iCapability,

   302                                             *iSIPConnection,

   303                                             *iProfile,

   304                                             KCapabilityTestSIPAddressUri_B );

   305         CleanupStack::PushL( query );

   306 

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

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

   309         EUNIT_ASSERT( !query->iTimer );

   310         EUNIT_ASSERT( !query->iTrx );

   311         

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

   313         if ( i == 0 )

   314             {

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

   316             }

   317         else

   318             {

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

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

   321             }

   322         

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

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

   325         

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

   327         delete query->iTerminal->iQuery;

   328         query->iTerminal->iQuery = NULL;

   329         

   330         // ...before execution

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

   332         CleanupStack::Pop( query );

   333 

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

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

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

   337         EUNIT_ASSERT( !query->iTimer );

   338         EUNIT_ASSERT( query->iTrx );

   339         

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

   341         if ( i == 0 )

   342             {

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

   344             }

   345         else

   346             {

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

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

   349             }

   350         

   351         

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

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

   354         delete uri16;

   355         uri16 = NULL;

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

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

   358 

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

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

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

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

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

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

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

   366     

   367     //set response

   368         //    GSMA     Cingular

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

   370             {

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

   372                                           KCapabilityTestAddress_B,

   373                                           KCapabilitySwisFeature,

   374                                           KCapabilityTestTerminalID_B,

   375                                           KPAssertedIdentity_B,

   376                                           KCapabilityTestSDP );

   377             }

   378         //         GSMA     Cingular

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

   380             {

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

   382                                           KCapabilityTestAddress_B,

   383                                           KNullDesC8,

   384                                           KCapabilityTestTerminalID_B,

   385                                           KPAssertedIdentity_B,

   386                                           KCapabilityTestSDP );

   387             

   388             }

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

   390             {

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

   392                                           KCapabilityTestAddress_B,

   393                                           KNullDesC8,

   394                                           KNullDesC8,

   395                                           KNullDesC8,

   396                                           KNullDesC8 );

   397             

   398             }

   399 

   400         if ( i == 4 )

   401             {

   402             EUNIT_ASSERT( 

   403                 MultimediaSharingSettings::OperatorVariantSettingL() ==

   404                                                 MusSettingsKeys::EStandard );

   405                 // set cingular variant key on

   406             MultimediaSharingSettings::SetOperatorVariantSettingL( 

   407                                         MusSettingsKeys::EOperatorSpecific );

   408             EUNIT_ASSERT( MultimediaSharingSettings::OperatorVariantSettingL()

   409                         == MusSettingsKeys::EOperatorSpecific );

   410             }

   411 

   412         iSipAgent->IncomingResponse( *query->iTrx );

   413         

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

   415         TInt count = 0;

   416         EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count );

   417         if ( count == 0 )

   418             {

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

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

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

   422             //EUNIT_ASSERT( uri16->Compare( iOptionHandler->SipAddressProposal() ) == 0 );

   423             delete uri16;

   424             uri16 = NULL;

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

   426 

   427 

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

   429                 {

   430                 EUNIT_ASSERT( 

   431                     MultimediaSharingSettings::OperatorVariantSettingL() ==

   432                                                 MusSettingsKeys::EStandard );

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

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

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

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

   437                 }

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

   439                 {

   440                 EUNIT_ASSERT( 

   441                     MultimediaSharingSettings::OperatorVariantSettingL() ==

   442                                                 MusSettingsKeys::EStandard );

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

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

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

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

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

   448                 }

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

   450                 {

   451                 EUNIT_ASSERT( MultimediaSharingSettings::OperatorVariantSettingL()

   452                         == MusSettingsKeys::EOperatorSpecific );

   453                 MultimediaSharingSettings::SetOperatorVariantSettingL( 

   454                                         MusSettingsKeys::EStandard );

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

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

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

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

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

   460                 }

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

   462                 {

   463                 EUNIT_ASSERT( 

   464                     MultimediaSharingSettings::OperatorVariantSettingL() ==

   465                                                     MusSettingsKeys::EStandard );

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

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

   468                 EUNIT_ASSERT( query->Retrying() );

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

   470             

   471                 query->OnExpiredL( KErrNone );

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

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

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

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

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

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

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

   479         

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

   481                                           KCapabilityTestAddress_B,

   482                                           KNullDesC8,

   483                                           KNullDesC8,

   484                                           KNullDesC8,

   485                                           KNullDesC8 );

   486                 //iExchange->AnswerToQueryReceived( *query->iTrx );

   487                 iSipAgent->IncomingResponse( *query->iTrx );

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

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

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

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

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

   493                 }

   494             }

   495         else

   496             {

   497             break;    

   498             }

   499         }

   500     }

   501 

   502 void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_ErrorOccuredL(  )

   503     {

   504     CMusAvaCapabilityQuery* query = NULL;

   505     

   506     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   507                                             *iSIPConnection,

   508                                             *iProfile,

   509                                             KCapabilityTestSIPAddressUri_B );

   510     CleanupStack::PushL( query );

   511 

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

   513     EUNIT_ASSERT( query->State() == 

   514                     CMusAvaCapabilityQueryBase::ECapabilityQueryCreated );

   515     EUNIT_ASSERT( !query->iTimer );

   516     EUNIT_ASSERT( !query->iTrx );

   517         

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

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

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

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

   522         

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

   524     CleanupStack::Pop( query );

   525 

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

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

   528     EUNIT_ASSERT( query->State() == 

   529                     CMusAvaCapabilityQueryBase::ECapabilityQueryExecuting );

   530     EUNIT_ASSERT( !query->iTimer );

   531     EUNIT_ASSERT( query->iTrx );

   532 

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

   534 

   535     //200 OK with User-Agent

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

   537                                 KMUSAVASIP200, 

   538                                 SipStrConsts::EPhraseOk,

   539                                 KCapabilityTestAddress_B,

   540                                 KCapabilitySwisFeature,

   541                                 KCapabilityTestTerminalID_B,

   542                                 KPAssertedIdentity_B,

   543                                 KCapabilityTestSDP );

   544     TInt err = 404;

   545     EUNIT_ASSERT( iSipAgent->ErrorOccured( err, *query->iTrx ) == KErrNone );

   546     EUNIT_ASSERT( query->State() == 

   547                 CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

   548                 

   549     CSIPServerTransaction* transaction = 

   550                 CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EInvite ) );                

   551     EUNIT_ASSERT( iSipAgent->ErrorOccured( err, *transaction ) == KErrNone );                

   552     delete transaction;

   553     }

   554     

   555 void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_TimedOutL()    

   556     {

   557     CSIPServerTransaction* request = CapabilityTestHelper::OptionsRequestL( 

   558                                             KCapabilityTestAddress_A,

   559                                             KCapabilityTestAddress_B,

   560                                             KCapabilitySwisFeature,

   561                                             KCapabilitySwisFeature,

   562                                             KCapabilityTestAcceptHeader,

   563                                             KCapabilityTestTerminalID_B );

   564     EUNIT_ASSERT( iSipAgent->TimedOut( *request ) == KErrNotSupported );

   565     delete request;

   566     }

   567 

   568 

   569 //  TEST TABLE

   570 

   571 EUNIT_BEGIN_TEST_TABLE( 

   572     UT_CMusAvaCapabilitySipAgent,

   573     "CMusAvaCapabilitySipAgent",

   574     "UNIT" )

   575 

   576 EUNIT_TEST(

   577     "NewL - test ",

   578     "CMusAvaCapabilitySipAgent",

   579     "NewL",

   580     "FUNCTIONALITY",

   581     SetupL,UT_CMusAvaCapabilitySipAgent_NewLL, Teardown)

   582     

   583 EUNIT_TEST(

   584     "ExecuteCapabilityQueryL - test ",

   585     "CMusAvaCapabilitySipAgent",

   586     "ExecuteCapabilityQueryL",

   587     "FUNCTIONALITY",

   588     SetupL,UT_CMusAvaCapabilitySipAgent_ExecuteCapabilityQueryLL, Teardown)

   589     

   590 EUNIT_TEST(

   591     "IncomingRequest - test ",

   592     "CMusAvaCapabilitySipAgent",

   593     "IncomingRequest",

   594     "FUNCTIONALITY",

   595     SetupL,UT_CMusAvaCapabilitySipAgent_IncomingRequestL, Teardown)

   596 

   597 EUNIT_TEST(

   598     "HandleIncomingRequestL - test ",

   599     "CMusAvaCapabilitySipAgent",

   600     "HandleIncomingRequestL",

   601     "FUNCTIONALITY",

   602     SetupL,UT_CMusAvaCapabilitySipAgent_HandleIncomingRequestLL, Teardown)

   603 

   604 EUNIT_TEST(

   605     "IncomingResponse - test ",

   606     "CMusAvaCapabilitySipAgent",

   607     "IncomingResponse",

   608     "FUNCTIONALITY",

   609     SetupL,UT_CMusAvaCapabilitySipAgent_IncomingResponseL, Teardown)

   610 

   611 EUNIT_TEST(

   612     "ErrorOccured - test ",

   613     "CMusAvaCapabilitySipAgent",

   614     "ErrorOccured",

   615     "FUNCTIONALITY",

   616     SetupL,UT_CMusAvaCapabilitySipAgent_ErrorOccuredL, Teardown)

   617          

   618 EUNIT_TEST(

   619     "TimedOut - test ",

   620     "CMusAvaCapabilitySipAgent",

   621     "TimedOut",

   622     "FUNCTIONALITY",

   623     SetupL,UT_CMusAvaCapabilitySipAgent_TimedOutL, Teardown)

   624 

   625 EUNIT_END_TEST_TABLE

   626 

   627 //  END OF FILE