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

    21 

    22 //  EXTERNAL INCLUDES

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

    24 

    25 

    26 //  INTERNAL INCLUDES

    27 #include "musavaCapabilityExchange.h"

    28 #include "musavaavailabilityobserver.h"

    29 #include "musavaavailabilityobserverimp.h"

    30 #include "musavaoptionhandler.h"

    31 #include "musavasettingsimp.h"

    32 #include "musavaobserverimp.h"

    33 #include "musavaterminal.h"

    34 #include "MusAvaCapability.h"

    35 #include "MusAvaCapabilityQuery.h"

    36 #include "MusAvaCapabilityTestHelper.h"

    37 #include "CSipSseTestTls.h"

    38 #include "musavacapabilitycontext.h"

    39 #include "musavasip.h"

    40 #include "musavasharedobject.h"

    41 #include "mussettings.h"

    42 

    43 

    44 // CONSTRUCTION

    45 UT_CMusAvaTerminal* UT_CMusAvaTerminal::NewL()

    46     {

    47     UT_CMusAvaTerminal* self = UT_CMusAvaTerminal::NewLC();

    48     CleanupStack::Pop();

    49 

    50     return self;

    51     }

    52 

    53 UT_CMusAvaTerminal* UT_CMusAvaTerminal::NewLC()

    54     {

    55     UT_CMusAvaTerminal* self = new( ELeave ) UT_CMusAvaTerminal();

    56     CleanupStack::PushL( self );

    57 

    58     self->ConstructL();

    59 

    60     return self;

    61     }

    62 

    63 // Destructor (virtual by CBase)

    64 UT_CMusAvaTerminal::~UT_CMusAvaTerminal()

    65     {

    66     }

    67 

    68 // Default constructor

    69 UT_CMusAvaTerminal::UT_CMusAvaTerminal()

    70     {

    71     }

    72 

    73 // Second phase construct

    74 void UT_CMusAvaTerminal::ConstructL()

    75     {

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

    77     // It generates the test case table.

    78     CEUnitTestSuiteClass::ConstructL();

    79     }

    80 

    81 //  METHODS

    82 

    83 

    84 

    85 void UT_CMusAvaTerminal::SetupL(  )

    86     {

    87 

    88     MSIPObserver* dummyObserver = NULL;

    89     CSIPProfileRegistry* dummyRegistry = NULL;

    90     MSIPConnectionObserver* dummyConnectionObserver = NULL;

    91     

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

    93     TUint32 iapId = 32;

    94     

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

    96     iProfile = CSIPProfile::NewL( dummyRegistry );

    97     iSIPConnection = CSIPConnection::NewL( *iSIP, 

    98                                             iapId,

    99                                             *dummyConnectionObserver );

   100                                

   101     

   102     iAvailabilityObserver = CMusAvaAvailabilityObserverImp::NewL();

   103     iConcreteSettings = CMusAvaSettingsImp::NewL();

   104     iOptionHandler = CMusAvaOptionHandler::NewL( *iAvailabilityObserver,

   105                                                  *iConcreteSettings );

   106 

   107     iExchange = iOptionHandler->iCapabilityExchange;

   108     

   109     iCapability = iOptionHandler->iSwisCapability;

   110 

   111     iTerminal = CMusAvaTerminal::NewL( *iExchange,

   112                                      KCapabilityTestAddress_B,

   113                                      KCapabilityTestTerminalID_B );

   114     if ( !iProfile->iRegisteredContact )

   115         {

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

   117         }

   118     

   119     CSipSseTestTls::OpenL();

   120     }

   121 

   122 

   123 void UT_CMusAvaTerminal::Teardown(  )

   124     {

   125 

   126     CSipSseTestTls::Close();

   127     delete iTerminal;

   128     delete iOptionHandler;

   129     delete iConcreteSettings;

   130     delete iAvailabilityObserver;

   131 

   132     delete iSIPConnection;

   133     delete iProfile;

   134     delete iSIP;

   135     

   136     }

   137 

   138 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_NewLL(  )

   139     {

   140     

   141                                          

   142     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   143     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   144     EUNIT_ASSERT( iTerminal->IsDiscovered() );

   145     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   146     

   147 

   148     }

   149 

   150 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_MatchLL(  )

   151     {

   152 

   153     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   154     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   155     EUNIT_ASSERT( iTerminal->IsDiscovered() );

   156     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   157 

   158     

   159     EUNIT_ASSERT( iTerminal->MatchL( KCapabilityTestAddress_B, 

   160                                 KCapabilityTestTerminalID_B ) );

   161     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   162     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) 

   163                 == 0 );

   164     

   165     EUNIT_ASSERT( !iTerminal->MatchL( KCapabilityTestTerminalID_B, 

   166                 KCapabilityTestAddress_B ) );//!wrong way around

   167     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   168     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) 

   169                 == 0 );

   170 

   171     EUNIT_ASSERT( iTerminal->MatchL( KCapabilityTestAddress_B, KNullDesC8 ) );

   172     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   173     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) 

   174                 == 0 );

   175 

   176     EUNIT_ASSERT( !iTerminal->MatchL( KNullDesC8, KNullDesC8 ) );

   177     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   178     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) 

   179                 == 0 );

   180     

   181     EUNIT_ASSERT( !iTerminal->MatchL( KNullDesC8, 

   182                 KCapabilityTestTerminalID_B ) );

   183     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   184     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) 

   185                 == 0 );

   186 

   187     iTerminal->AttachUriL( KNullDesC8 );

   188     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   189     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) 

   190                 == 0 );

   191 

   192     iTerminal->AttachIdL( KNullDesC8 );

   193     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   194     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) 

   195                 == 0 );

   196     

   197     delete iTerminal->iTerminalId;

   198     iTerminal->iTerminalId = NULL;

   199     iTerminal->iTerminalId = KNullDesC8().AllocL();

   200     EUNIT_ASSERT( iTerminal->Id().Compare( KNullDesC8 ) == 0 );

   201 

   202     EUNIT_ASSERT( iTerminal->MatchL( KCapabilityTestAddress_B, KNullDesC8 ) );

   203     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   204     EUNIT_ASSERT( iTerminal->Id().Compare( KNullDesC8 ) == 0 );

   205     

   206     EUNIT_ASSERT( iTerminal->MatchL( KCapabilityTestAddress_B, 

   207                                     KCapabilityTestTerminalID_B ) );

   208     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   209     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) 

   210                 == 0 );

   211     

   212     

   213     }

   214 

   215 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_ExecuteQueryLL(  )

   216     {

   217     MultimediaSharingSettings::SetSipProfileSettingL( 1 );

   218     if ( !iProfile->iArray )

   219         {

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

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

   222         }

   223     

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

   225     

   226     CMusAvaCapabilityQuery* query = NULL;

   227     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   228                                             *iSIPConnection,

   229                                             *iProfile,

   230                                             KCapabilityTestSIPAddressUri_B );

   231     CleanupStack::PushL( query );

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

   233         

   234     CMusAvaTerminal& terminal = query->Terminal();

   235     EUNIT_ASSERT( terminal.iQueries == 1 );

   236     EUNIT_ASSERT( terminal.iQuery == NULL );

   237     

   238     TRAPD( error, terminal.ExecuteQueryL( NULL ) );

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

   240     EUNIT_ASSERT( error != KErrNone );

   241 

   242     EUNIT_ASSERT( terminal.iQueries == 1 );

   243     EUNIT_ASSERT( terminal.iQuery == NULL );

   244 

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

   246     TRAP( error, terminal.ExecuteQueryL( query ) );

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

   248     EUNIT_ASSERT( error != KErrNone );

   249     

   250     EUNIT_ASSERT( terminal.iQueries == 1 );

   251     EUNIT_ASSERT( terminal.iQuery == NULL );

   252     

   253     query->SetState( CMusAvaCapabilityQueryBase::ECapabilityQueryCreated );

   254     terminal.ExecuteQueryL( query );

   255     CleanupStack::Pop( query );

   256     

   257     EUNIT_ASSERT( terminal.iQueries == 1 );

   258     EUNIT_ASSERT( terminal.iQuery == query );

   259     

   260     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   261                                         *iSIPConnection,

   262                                         *iProfile,

   263                                         KCapabilityTestSIPAddressUri_B );

   264     CleanupStack::PushL( query );

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

   266     EUNIT_ASSERT( terminal.iQueries == 2 );

   267     

   268     //Second query cannot be executed

   269     EUNIT_ASSERT_SPECIFIC_LEAVE( terminal.ExecuteQueryL( query ),

   270                                  KErrAlreadyExists )

   271     EUNIT_ASSERT( terminal.iQuery != query );

   272     CleanupStack::PopAndDestroy( query );

   273     }

   274 

   275 

   276 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_QueryCompletedLL(  )

   277     {

   278     MultimediaSharingSettings::SetSipProfileSettingL( 1 );

   279     if ( !iProfile->iArray )

   280         {

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

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

   283         }

   284     

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

   286     

   287     CMusAvaCapabilityQuery* query = NULL;

   288     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   289                                             *iSIPConnection,

   290                                             *iProfile,

   291                                             KCapabilityTestSIPAddressUri_B  );

   292     CleanupStack::PushL( query );

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

   294         

   295     CMusAvaTerminal& terminal = query->Terminal();

   296     EUNIT_ASSERT( terminal.iQueries == 1 );

   297 

   298     TBool ret;

   299     TRAPD( err, ret = terminal.QueryCompletedL( *query->iTrx ) );

   300     if ( err == KErrNoMemory ) User::Leave( err );

   301     EUNIT_ASSERT( !ret );

   302     

   303     terminal.ExecuteQueryL( query );

   304     CleanupStack::Pop( query );

   305 

   306     EUNIT_ASSERT( terminal.iQueries == 1 );

   307     EUNIT_ASSERT( terminal.iQuery == query );

   308 

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

   310 

   311     //timeout

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

   313                                     KMUSAVASIPTimeout, 

   314                                     SipStrConsts::EPhraseRequestTimeout,

   315                                     KCapabilityTestAddress_B,

   316                                     KNullDesC8,

   317                                     KNullDesC8,

   318                                     KNullDesC8,

   319                                     KNullDesC8 );

   320 

   321     TRAP( err, ret = terminal.QueryCompletedL( *query->iTrx ) );

   322     if ( err == KErrNoMemory ) User::Leave( err );

   323     EUNIT_ASSERT( !ret );

   324     

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

   326     

   327     //200 OK with no User-Agent

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

   329                                 KMUSAVASIP200, 

   330                                 SipStrConsts::EPhraseOk,

   331                                 KCapabilityTestAddress_B,

   332                                 KCapabilitySwisFeature,

   333                                 KNullDesC8,

   334                                 KPAssertedIdentity_B,

   335                                 KCapabilityTestSDP );

   336 

   337     TRAP( err, ret = terminal.QueryCompletedL( *query->iTrx ) );

   338     if ( err == KErrNoMemory ) User::Leave( err );

   339     EUNIT_ASSERT( ret );

   340     

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

   342     

   343     //200 OK with User-Agent

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

   345                                 KMUSAVASIP200, 

   346                                 SipStrConsts::EPhraseOk,

   347                                 KCapabilityTestAddress_B,

   348                                 KCapabilitySwisFeature,

   349                                 KCapabilityTestTerminalID_B,

   350                                 KPAssertedIdentity_B,

   351                                 KCapabilityTestSDP );

   352                               

   353     TRAP( err, ret = terminal.QueryCompletedL( *query->iTrx ) );

   354     if ( err == KErrNoMemory ) User::Leave( err );

   355     EUNIT_ASSERT( ret );

   356     

   357     TRAP( err, ret = terminal.QueryCompletedL( *query->iTrx ) );

   358     if ( err == KErrNoMemory ) User::Leave( err );

   359     EUNIT_ASSERT( !ret );

   360     }

   361 

   362 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_QueryCanceledL(  )

   363     {

   364     if ( !iProfile->iArray )

   365         {

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

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

   368         }

   369 

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

   371     

   372     CMusAvaCapabilityQuery* query = NULL;

   373     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   374                                             *iSIPConnection,

   375                                             *iProfile,

   376                                             KCapabilityTestSIPAddressUri_B  );

   377     CleanupStack::PushL( query );

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

   379         

   380     CMusAvaTerminal& terminal = query->Terminal();

   381     EUNIT_ASSERT( terminal.iQueries == 1 );

   382     

   383     terminal.ExecuteQueryL( query );

   384     CleanupStack::Pop( query );

   385 

   386     EUNIT_ASSERT( terminal.iQueries == 1 );

   387     EUNIT_ASSERT( terminal.iQuery == query );

   388 

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

   390 

   391     //200 OK with User-Agent

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

   393                                 KMUSAVASIP200, 

   394                                 SipStrConsts::EPhraseOk,

   395                                 KCapabilityTestAddress_B,

   396                                 KCapabilitySwisFeature,

   397                                 KCapabilityTestTerminalID_B,

   398                                 KPAssertedIdentity_B,

   399                                 KCapabilityTestSDP );

   400     //TInt err = 404;

   401     EUNIT_ASSERT( terminal.QueryCanceled( *query->iTrx ) );

   402     EUNIT_ASSERT( query->State() == 

   403                 CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

   404 

   405     }

   406 

   407 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_QueryRequestedLL(  )

   408     {    

   409 

   410     CSIPServerTransaction* options = NULL;

   411     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

   412     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   413     EUNIT_ASSERT( iTerminal->IsDiscovered() );

   414     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   415 

   416         

   417     options =   

   418         CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   419                                          KCapabilityTestAddress_B,

   420                                          KNullDesC8,

   421                                          KCapabilitySwisFeature,

   422                                          KCapabilityTestAcceptHeader,

   423                                          KCapabilityTestTerminalID_B );

   424     CleanupStack::PushL( options );    

   425 

   426     TRAPD( error, iTerminal->QueryRequestedL( *options ) );

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

   428     EUNIT_ASSERT( error != KErrNone );

   429     

   430     

   431     CleanupStack::PopAndDestroy( options );

   432 

   433     options =   

   434         CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   435                                          KCapabilityTestAddress_B,

   436                                          KCapabilitySwisFeature,

   437                                          KCapabilitySwisFeature,

   438                                          KCapabilityTestAcceptHeader,

   439                                          KCapabilityTestTerminalID_B );

   440     CleanupStack::PushL( options );

   441 

   442     iTerminal->QueryRequestedL( *options );

   443     

   444     EUNIT_ASSERT( iTerminal->RequestedQuery() == iCapability );

   445     EUNIT_ASSERT( iConcreteSettings->SipAddresses().MdcaCount() == 0 );

   446     

   447     CleanupStack::PopAndDestroy( options );

   448 

   449     // with Asserted Identity, check also that SDP of received request is used

   450     options =   

   451         CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   452                                          KCapabilityTestAddress_B,

   453                                          KCapabilitySwisFeature,

   454                                          KCapabilitySwisFeature,

   455                                          KCapabilityTestAcceptHeader,

   456                                          KCapabilityTestTerminalID_B,

   457                                          KCapabilityPAssertedIdentity,

   458                                          KCapabilityTestSDP);

   459     CleanupStack::PushL( options );        

   460     iTerminal->QueryRequestedL( *options );   

   461 

   462     

   463     EUNIT_ASSERT( iConcreteSettings->SipAddresses().MdcaCount() == 1 );    

   464     EUNIT_ASSERT_EQUALS( iConcreteSettings->iVideoCodecs->MdcaCount(), 1 );

   465     EUNIT_ASSERT_EQUALS( iConcreteSettings->iVideoCodecs->MdcaPoint(0), _L("H263-2000/90000") );

   466     CleanupStack::PopAndDestroy( options );

   467   

   468     CSipSseTestTls* server = CSipSseTestTls::Storage();

   469     CSipSseTestTls::Storage()->Clear();

   470     iTerminal->iRequestedQuery = NULL;

   471     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   472     

   473     // with Asserted Identity, check also that SDP of received request is used

   474    options =   

   475         CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   476                                          KCapabilityTestAddress_B,

   477                                          KCapabilitySwisFeature,

   478                                          KCapabilitySwisFeature,

   479                                          KCapabilityTestAcceptHeader,

   480                                          KCapabilityTestTerminalID_B,

   481                                          KCapabilityPAssertedIdentity,

   482                                          KCapabilityTestSDP264And263);

   483     CleanupStack::PushL( options );        

   484     iTerminal->QueryRequestedL( *options );   

   485     EUNIT_ASSERT( iConcreteSettings->SipAddresses().MdcaCount() == 1 );    

   486     EUNIT_ASSERT_EQUALS( iConcreteSettings->iVideoCodecs->MdcaCount(), 2 );

   487     EUNIT_ASSERT_EQUALS( iConcreteSettings->iVideoCodecs->MdcaPoint(0), _L("H264/90000") );

   488     EUNIT_ASSERT_EQUALS( iConcreteSettings->iVideoCodecs->MdcaPoint(1), _L("H263-2000/90000") );

   489     CleanupStack::PopAndDestroy( options );

   490     

   491     CSipSseTestTls::Storage()->Clear();

   492     

   493     iTerminal->iRequestedQuery = NULL;

   494     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   495 

   496     options =   

   497         CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   498                                          KCapabilityTestAddress_B,

   499                                          KCapabilityTestDataFeature,

   500                                          KCapabilitySwisFeature,

   501                                          KCapabilityTestAcceptHeader,

   502                                          KCapabilityTestTerminalID_B);

   503     CleanupStack::PushL( options );

   504     

   505     iTerminal->QueryRequestedL( *options );

   506     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   507     EUNIT_ASSERT( server->iResponseToRequest == 

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

   509     EUNIT_ASSERT( server->iClientResponse->StatusCode() == 

   510                             KMUSAVASIPNotImplemented );

   511     

   512     CleanupStack::PopAndDestroy( options );   

   513   

   514 

   515     }

   516 

   517 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_IsDiscoveredL(  )

   518     {

   519     if ( !iProfile->iArray )

   520         {

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

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

   523         }

   524 

   525     CMusAvaCapabilityQuery* query = NULL;

   526     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   527                                             *iSIPConnection,

   528                                             *iProfile,

   529                                              KCapabilityTestSIPAddressUri_B );

   530     CleanupStack::PushL( query );

   531 

   532     EUNIT_ASSERT( iTerminal->Id().Compare( KCapabilityTestTerminalID_B ) 

   533                 == 0 );

   534     EUNIT_ASSERT( iTerminal->Uri().Compare( KCapabilityTestAddress_B ) == 0 );

   535     

   536     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   537     EUNIT_ASSERT( iTerminal->iQueries == 0 );

   538     

   539     EUNIT_ASSERT( iTerminal->IsDiscovered() );

   540 

   541     iTerminal->iQueries = 0;

   542     iTerminal->iRequestedQuery = iCapability;

   543     EUNIT_ASSERT( !iTerminal->IsDiscovered() );

   544 

   545     iTerminal->AttachQuery( *query );

   546     EUNIT_ASSERT( iTerminal->iQueries == 1 );

   547     iTerminal->iRequestedQuery = NULL;

   548     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   549     

   550     EUNIT_ASSERT( !iTerminal->IsDiscovered() );

   551 

   552     iTerminal->iRequestedQuery = iCapability;

   553 

   554     EUNIT_ASSERT( iTerminal->iQueries == 1 );

   555     EUNIT_ASSERT( iTerminal->RequestedQuery() == iCapability );

   556     EUNIT_ASSERT( !iTerminal->IsDiscovered() );

   557     

   558     iTerminal->AttachQuery( *query );

   559     EUNIT_ASSERT( iTerminal->iQueries == 2 );

   560     EUNIT_ASSERT( iTerminal->RequestedQuery() == iCapability );

   561     EUNIT_ASSERT( !iTerminal->IsDiscovered() );

   562 

   563     iTerminal->iRequestedQuery = NULL;

   564     EUNIT_ASSERT( iTerminal->iQueries == 2 );

   565     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   566     EUNIT_ASSERT( !iTerminal->IsDiscovered() );

   567 

   568     iTerminal->iQuery = query;

   569     CleanupStack::Pop( query );

   570 

   571     EUNIT_ASSERT( iTerminal->iQueries == 2 );

   572     EUNIT_ASSERT( iTerminal->iQuery == query );

   573     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   574     EUNIT_ASSERT( !iTerminal->IsDiscovered() );

   575     

   576     iTerminal->DetachQuery( *query );

   577     

   578     EUNIT_ASSERT( iTerminal->iQueries == 1 );

   579     EUNIT_ASSERT( iTerminal->iQuery == query );

   580     EUNIT_ASSERT( iTerminal->iQuery->State() == 

   581                         CMusAvaCapabilityQueryBase::ECapabilityQueryCreated );

   582     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   583     EUNIT_ASSERT( !iTerminal->IsDiscovered() );

   584     

   585     iTerminal->iRequestedQuery = iCapability;

   586     EUNIT_ASSERT( iTerminal->iQueries == 1 );

   587     EUNIT_ASSERT( iTerminal->iQuery == query );

   588     EUNIT_ASSERT( iTerminal->iQuery->State() == 

   589             CMusAvaCapabilityQueryBase::ECapabilityQueryCreated );

   590     EUNIT_ASSERT( iTerminal->RequestedQuery() == iCapability );

   591     EUNIT_ASSERT( !iTerminal->IsDiscovered() );

   592     

   593     iTerminal->iQuery->SetState( 

   594                     CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

   595     iTerminal->iRequestedQuery = NULL;

   596     EUNIT_ASSERT( iTerminal->iQueries == 1 );

   597     EUNIT_ASSERT( iTerminal->iQuery == query );

   598     EUNIT_ASSERT( iTerminal->iQuery->State() == 

   599                     CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

   600     EUNIT_ASSERT( iTerminal->RequestedQuery() == NULL );

   601     EUNIT_ASSERT( iTerminal->IsDiscovered() );

   602 

   603     iTerminal->iRequestedQuery = iCapability;

   604     EUNIT_ASSERT( iTerminal->iQueries == 1 );

   605     EUNIT_ASSERT( iTerminal->iQuery == query );

   606     EUNIT_ASSERT( iTerminal->iQuery->State() == 

   607                     CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

   608     EUNIT_ASSERT( iTerminal->RequestedQuery() == iCapability );

   609     EUNIT_ASSERT( iTerminal->IsDiscovered() );

   610 //    CMusAvaSharedObject::DeleteSingleton();

   611     }

   612 

   613 //  TEST TABLE

   614 EUNIT_BEGIN_TEST_TABLE(

   615     UT_CMusAvaTerminal,

   616     "CMusAvaTerminal",

   617     "UNIT" )

   618 

   619 EUNIT_TEST(

   620     "NewL - test ",

   621     "CMusAvaTerminal",

   622     "NewL",

   623     "FUNCTIONALITY",

   624     SetupL, UT_CMusAvaTerminal_NewLL, Teardown)

   625 

   626 EUNIT_TEST(

   627     "MatchL - test ",

   628     "CMusAvaTerminal",

   629     "MatchL",

   630     "FUNCTIONALITY",

   631     SetupL, UT_CMusAvaTerminal_MatchLL, Teardown)

   632 

   633 

   634 EUNIT_TEST(

   635     "ExecuteQueryL - test ",

   636     "CMusAvaTerminal",

   637     "ExecuteQueryL",

   638     "FUNCTIONALITY",

   639     SetupL, UT_CMusAvaTerminal_ExecuteQueryLL, Teardown)

   640 

   641 

   642 EUNIT_TEST(

   643     "QueryCompletedL - test ",

   644     "CMusAvaTerminal",

   645     "QueryCompletedL",

   646     "FUNCTIONALITY",

   647     SetupL, UT_CMusAvaTerminal_QueryCompletedLL, Teardown)

   648 

   649 

   650 EUNIT_TEST(

   651     "QueryCanceled - test ",

   652     "CMusAvaTerminal",

   653     "QueryCanceled",

   654     "FUNCTIONALITY",

   655     SetupL, UT_CMusAvaTerminal_QueryCanceledL, Teardown)

   656 

   657 

   658 EUNIT_TEST(

   659     "QueryRequestedL - test ",

   660     "CMusAvaTerminal",

   661     "QueryRequestedL",

   662     "FUNCTIONALITY",

   663     SetupL, UT_CMusAvaTerminal_QueryRequestedLL, Teardown)

   664 

   665 EUNIT_TEST(

   666     "IsDiscovered - test ",

   667     "CMusAvaTerminal",

   668     "IsDiscovered",

   669     "FUNCTIONALITY",

   670     SetupL, UT_CMusAvaTerminal_IsDiscoveredL, Teardown)

   671 

   672 

   673 

   674 

   675     

   676 EUNIT_END_TEST_TABLE

   677 

   678 //  END OF FILE