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     iStorage = CSipSseTestTls::Storage();

   121     iStorage->Set( MusSettingsKeys::KFastStartupMode, 

   122         MusSettingsKeys::EFastModeOff );

   123     }

   124 

   125 

   126 void UT_CMusAvaTerminal::Teardown(  )

   127     {

   128     if ( iStorage )

   129         {

   130         iStorage->Clear();

   131         CSipSseTestTls::Close();

   132         iStorage = NULL;

   133         }

   134 

   135     delete iTerminal;

   136     delete iOptionHandler;

   137     delete iConcreteSettings;

   138     delete iAvailabilityObserver;

   139 

   140     delete iSIPConnection;

   141     delete iProfile;

   142     delete iSIP;

   143     

   144     }

   145 

   146 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_NewLL(  )

   147     {

   148     

   149                                          

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

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

   152     EUNIT_ASSERT( iTerminal->IsDiscovered() );

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

   154     

   155 

   156     }

   157 

   158 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_MatchLL(  )

   159     {

   160 

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

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

   163     EUNIT_ASSERT( iTerminal->IsDiscovered() );

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

   165 

   166     

   167     EUNIT_ASSERT( iTerminal->MatchL( KCapabilityTestAddress_B, 

   168                                 KCapabilityTestTerminalID_B ) );

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

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

   171                 == 0 );

   172     

   173     EUNIT_ASSERT( !iTerminal->MatchL( KCapabilityTestTerminalID_B, 

   174                 KCapabilityTestAddress_B ) );//!wrong way around

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

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

   177                 == 0 );

   178 

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

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

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

   182                 == 0 );

   183 

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

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

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

   187                 == 0 );

   188     

   189     EUNIT_ASSERT( !iTerminal->MatchL( KNullDesC8, 

   190                 KCapabilityTestTerminalID_B ) );

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

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

   193                 == 0 );

   194 

   195     iTerminal->AttachUriL( KNullDesC8 );

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

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

   198                 == 0 );

   199 

   200     iTerminal->AttachIdL( KNullDesC8 );

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

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

   203                 == 0 );

   204     

   205     delete iTerminal->iTerminalId;

   206     iTerminal->iTerminalId = NULL;

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

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

   209 

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

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

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

   213     

   214     EUNIT_ASSERT( iTerminal->MatchL( KCapabilityTestAddress_B, 

   215                                     KCapabilityTestTerminalID_B ) );

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

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

   218                 == 0 );

   219     

   220     

   221     }

   222 

   223 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_ExecuteQueryLL(  )

   224     {

   225     MultimediaSharingSettings::SetSipProfileSettingL( 1 );

   226     if ( !iProfile->iArray )

   227         {

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

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

   230         }

   231     

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

   233     

   234     CMusAvaCapabilityQuery* query = NULL;

   235     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   236                                             *iSIPConnection,

   237                                             *iProfile,

   238                                             KCapabilityTestSIPAddressUri_B );

   239     CleanupStack::PushL( query );

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

   241         

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

   243     EUNIT_ASSERT( terminal.iQueries == 1 );

   244     EUNIT_ASSERT( terminal.iQuery == NULL );

   245     

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

   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::ECapabilityQueryExecuting );

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

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

   256     EUNIT_ASSERT( error != KErrNone );

   257     

   258     EUNIT_ASSERT( terminal.iQueries == 1 );

   259     EUNIT_ASSERT( terminal.iQuery == NULL );

   260     

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

   262     terminal.ExecuteQueryL( query );

   263     CleanupStack::Pop( query );

   264     

   265     EUNIT_ASSERT( terminal.iQueries == 1 );

   266     EUNIT_ASSERT( terminal.iQuery == query );

   267     

   268     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   269                                         *iSIPConnection,

   270                                         *iProfile,

   271                                         KCapabilityTestSIPAddressUri_B );

   272     CleanupStack::PushL( query );

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

   274     EUNIT_ASSERT( terminal.iQueries == 2 );

   275     

   276     //Second query cannot be executed

   277     EUNIT_ASSERT_SPECIFIC_LEAVE( terminal.ExecuteQueryL( query ),

   278                                  KErrAlreadyExists )

   279     EUNIT_ASSERT( terminal.iQuery != query );

   280     CleanupStack::PopAndDestroy( query );

   281     }

   282 

   283 

   284 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_QueryCompletedLL(  )

   285     {

   286     MultimediaSharingSettings::SetSipProfileSettingL( 1 );

   287     if ( !iProfile->iArray )

   288         {

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

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

   291         }

   292     

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

   294     

   295     CMusAvaCapabilityQuery* query = NULL;

   296     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   297                                             *iSIPConnection,

   298                                             *iProfile,

   299                                             KCapabilityTestSIPAddressUri_B  );

   300     CleanupStack::PushL( query );

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

   302         

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

   304     EUNIT_ASSERT( terminal.iQueries == 1 );

   305 

   306     TBool ret;

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

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

   309     EUNIT_ASSERT( !ret );

   310     

   311     terminal.ExecuteQueryL( query );

   312     CleanupStack::Pop( query );

   313 

   314     EUNIT_ASSERT( terminal.iQueries == 1 );

   315     EUNIT_ASSERT( terminal.iQuery == query );

   316 

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

   318 

   319     //timeout

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

   321                                     KMUSAVASIPTimeout, 

   322                                     SipStrConsts::EPhraseRequestTimeout,

   323                                     KCapabilityTestAddress_B,

   324                                     KNullDesC8,

   325                                     KNullDesC8,

   326                                     KNullDesC8,

   327                                     KNullDesC8 );

   328 

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

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

   331     EUNIT_ASSERT( !ret );

   332     

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

   334     

   335     //200 OK with no User-Agent

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

   337                                 KMUSAVASIP200, 

   338                                 SipStrConsts::EPhraseOk,

   339                                 KCapabilityTestAddress_B,

   340                                 KCapabilitySwisFeature,

   341                                 KNullDesC8,

   342                                 KPAssertedIdentity_B,

   343                                 KCapabilityTestSDP );

   344 

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

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

   347     EUNIT_ASSERT( ret );

   348     

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

   350     

   351     //200 OK with User-Agent

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

   353                                 KMUSAVASIP200, 

   354                                 SipStrConsts::EPhraseOk,

   355                                 KCapabilityTestAddress_B,

   356                                 KCapabilitySwisFeature,

   357                                 KCapabilityTestTerminalID_B,

   358                                 KPAssertedIdentity_B,

   359                                 KCapabilityTestSDP );

   360                               

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

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

   363     EUNIT_ASSERT( ret );

   364     

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

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

   367     EUNIT_ASSERT( !ret );

   368     }

   369 

   370 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_QueryCanceledL(  )

   371     {

   372     if ( !iProfile->iArray )

   373         {

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

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

   376         }

   377 

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

   379     

   380     CMusAvaCapabilityQuery* query = NULL;

   381     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   382                                             *iSIPConnection,

   383                                             *iProfile,

   384                                             KCapabilityTestSIPAddressUri_B  );

   385     CleanupStack::PushL( query );

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

   387         

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

   389     EUNIT_ASSERT( terminal.iQueries == 1 );

   390     

   391     terminal.ExecuteQueryL( query );

   392     CleanupStack::Pop( query );

   393 

   394     EUNIT_ASSERT( terminal.iQueries == 1 );

   395     EUNIT_ASSERT( terminal.iQuery == query );

   396 

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

   398 

   399     //200 OK with User-Agent

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

   401                                 KMUSAVASIP200, 

   402                                 SipStrConsts::EPhraseOk,

   403                                 KCapabilityTestAddress_B,

   404                                 KCapabilitySwisFeature,

   405                                 KCapabilityTestTerminalID_B,

   406                                 KPAssertedIdentity_B,

   407                                 KCapabilityTestSDP );

   408     //TInt err = 404;

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

   410     EUNIT_ASSERT( query->State() == 

   411                 CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

   412 

   413     }

   414 

   415 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_QueryRequestedLL(  )

   416     {    

   417 

   418     CSIPServerTransaction* options = NULL;

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

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

   421     EUNIT_ASSERT( iTerminal->IsDiscovered() );

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

   423 

   424         

   425     options =   

   426         CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   427                                          KCapabilityTestAddress_B,

   428                                          KNullDesC8,

   429                                          KCapabilitySwisFeature,

   430                                          KCapabilityTestAcceptHeader,

   431                                          KCapabilityTestTerminalID_B );

   432     CleanupStack::PushL( options );    

   433 

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

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

   436     EUNIT_ASSERT( error != KErrNone );

   437     

   438     

   439     CleanupStack::PopAndDestroy( options );

   440 

   441     options =   

   442         CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   443                                          KCapabilityTestAddress_B,

   444                                          KCapabilitySwisFeature,

   445                                          KCapabilitySwisFeature,

   446                                          KCapabilityTestAcceptHeader,

   447                                          KCapabilityTestTerminalID_B );

   448     CleanupStack::PushL( options );

   449 

   450     iTerminal->QueryRequestedL( *options );

   451     

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

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

   454     

   455     CleanupStack::PopAndDestroy( options );

   456 

   457     // with Asserted Identity

   458     options =   

   459         CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   460                                          KCapabilityTestAddress_B,

   461                                          KCapabilitySwisFeature,

   462                                          KCapabilitySwisFeature,

   463                                          KCapabilityTestAcceptHeader,

   464                                          KCapabilityTestTerminalID_B,

   465                                          KCapabilityPAssertedIdentity );

   466     CleanupStack::PushL( options );        

   467     iTerminal->QueryRequestedL( *options );            

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

   469     CleanupStack::PopAndDestroy( options );

   470   

   471 

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

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

   474     

   475     iTerminal->iRequestedQuery = NULL;

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

   477 

   478     options =   

   479         CapabilityTestHelper::OptionsRequestL( KCapabilityTestAddress_A,

   480                                          KCapabilityTestAddress_B,

   481                                          KCapabilityTestDataFeature,

   482                                          KCapabilitySwisFeature,

   483                                          KCapabilityTestAcceptHeader,

   484                                          KCapabilityTestTerminalID_B );

   485     CleanupStack::PushL( options );

   486     

   487     iTerminal->QueryRequestedL( *options );

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

   489     EUNIT_ASSERT( server->iResponseToRequest == 

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

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

   492                             KMUSAVASIPNotImplemented );

   493     

   494     CleanupStack::PopAndDestroy( options );   

   495   

   496 

   497     }

   498 

   499 void UT_CMusAvaTerminal::UT_CMusAvaTerminal_IsDiscoveredL(  )

   500     {

   501     if ( !iProfile->iArray )

   502         {

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

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

   505         }

   506 

   507     CMusAvaCapabilityQuery* query = NULL;

   508     query = CMusAvaCapabilityQuery::NewL( *iCapability,

   509                                             *iSIPConnection,

   510                                             *iProfile,

   511                                              KCapabilityTestSIPAddressUri_B );

   512     CleanupStack::PushL( query );

   513 

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

   515                 == 0 );

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

   517     

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

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

   520     

   521     EUNIT_ASSERT( iTerminal->IsDiscovered() );

   522 

   523     iTerminal->iQueries = 0;

   524     iTerminal->iRequestedQuery = iCapability;

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

   526 

   527     iTerminal->AttachQuery( *query );

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

   529     iTerminal->iRequestedQuery = NULL;

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

   531     

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

   533 

   534     iTerminal->iRequestedQuery = iCapability;

   535 

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

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

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

   539     

   540     iTerminal->AttachQuery( *query );

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

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

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

   544 

   545     iTerminal->iRequestedQuery = NULL;

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

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

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

   549 

   550     iTerminal->iQuery = query;

   551     CleanupStack::Pop( query );

   552 

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

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

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

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

   557     

   558     iTerminal->DetachQuery( *query );

   559     

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

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

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

   563                         CMusAvaCapabilityQueryBase::ECapabilityQueryCreated );

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

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

   566     

   567     iTerminal->iRequestedQuery = iCapability;

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

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

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

   571             CMusAvaCapabilityQueryBase::ECapabilityQueryCreated );

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

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

   574     

   575     iTerminal->iQuery->SetState( 

   576                     CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

   577     iTerminal->iRequestedQuery = NULL;

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

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

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

   581                     CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

   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::ECapabilityQueryCompleted );

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

   591     EUNIT_ASSERT( iTerminal->IsDiscovered() );

   592 //    CMusAvaSharedObject::DeleteSingleton();

   593     }

   594 

   595 //  TEST TABLE

   596 EUNIT_BEGIN_TEST_TABLE(

   597     UT_CMusAvaTerminal,

   598     "CMusAvaTerminal",

   599     "UNIT" )

   600 

   601 EUNIT_TEST(

   602     "NewL - test ",

   603     "CMusAvaTerminal",

   604     "NewL",

   605     "FUNCTIONALITY",

   606     SetupL, UT_CMusAvaTerminal_NewLL, Teardown)

   607 

   608 EUNIT_TEST(

   609     "MatchL - test ",

   610     "CMusAvaTerminal",

   611     "MatchL",

   612     "FUNCTIONALITY",

   613     SetupL, UT_CMusAvaTerminal_MatchLL, Teardown)

   614 

   615 

   616 EUNIT_TEST(

   617     "ExecuteQueryL - test ",

   618     "CMusAvaTerminal",

   619     "ExecuteQueryL",

   620     "FUNCTIONALITY",

   621     SetupL, UT_CMusAvaTerminal_ExecuteQueryLL, Teardown)

   622 

   623 

   624 EUNIT_TEST(

   625     "QueryCompletedL - test ",

   626     "CMusAvaTerminal",

   627     "QueryCompletedL",

   628     "FUNCTIONALITY",

   629     SetupL, UT_CMusAvaTerminal_QueryCompletedLL, Teardown)

   630 

   631 

   632 EUNIT_TEST(

   633     "QueryCanceled - test ",

   634     "CMusAvaTerminal",

   635     "QueryCanceled",

   636     "FUNCTIONALITY",

   637     SetupL, UT_CMusAvaTerminal_QueryCanceledL, Teardown)

   638 

   639 

   640 EUNIT_TEST(

   641     "QueryRequestedL - test ",

   642     "CMusAvaTerminal",

   643     "QueryRequestedL",

   644     "FUNCTIONALITY",

   645     SetupL, UT_CMusAvaTerminal_QueryRequestedLL, Teardown)

   646 

   647 EUNIT_TEST(

   648     "IsDiscovered - test ",

   649     "CMusAvaTerminal",

   650     "IsDiscovered",

   651     "FUNCTIONALITY",

   652     SetupL, UT_CMusAvaTerminal_IsDiscoveredL, Teardown)

   653 

   654 

   655 

   656 

   657     

   658 EUNIT_END_TEST_TABLE

   659 

   660 //  END OF FILE