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

    21 

    22 // EXTERNAL INCLUDES

    23 #include <EUnitMacros.h>

    24 #include <S32MEM.H>

    25 

    26 // INTERNAL INCLUDES

    27 #include "CFActionIndicationImpl.h"

    28 #include "CFActionSubscriptionImpl.h"

    29 #include "CFContextIndicationImpl.h"

    30 #include "cfcontextobjectimpl.h"

    31 #include "CFContextQueryImpl.h"

    32 #include "CFContextSubscriptionImpl.h"

    33 #include "CFKeyValuePair.h"

    34 #include "cfserviceutils.h"

    35 #include "cfcontextdataproxy.h"

    36 #include "cfenvutils.h"

    37 

    38 // CONSTANTS

    39 _LIT( KKey, "Key_%d" );

    40 _LIT( KValue, "Value_%d" );

    41 _LIT( KActionId, "ActionID" );

    42 _LIT( KShortActionId, "ActID" );

    43 _LIT( KLongActionId, "LongActionIdentifier" );

    44 static const TInt KParamCount = 10;

    45 

    46 _LIT( KContextSource, "ContextSource" );

    47 _LIT( KContextSourceLong, "ContextSourceQuiteABitLonger" );

    48 _LIT( KContextType, "ContextType" );

    49 _LIT( KContextTypeLong, "ContextTypeQuiteABitLonger" );

    50 _LIT( KContextValue, "ContextValue" );

    51 _LIT( KContextValueLong, "ContextValueQuiteABitLonger" );

    52 

    53 // CONSTRUCTION

    54 MT_CFServices* MT_CFServices::NewL()

    55     {

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

    57     CleanupStack::Pop();

    58 

    59     return self;

    60     }

    61 

    62 MT_CFServices* MT_CFServices::NewLC()

    63     {

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

    65     CleanupStack::PushL( self );

    66 

    67     self->ConstructL();

    68 

    69     return self;

    70     }

    71 

    72 // Destructor (virtual by CBase)

    73 MT_CFServices::~MT_CFServices()

    74     {

    75     Teardown();

    76 

    77     // Enable screen saver

    78     CFEnvUtils::EnableScreenSaver( ETrue );

    79     }

    80 

    81 // Default constructor

    82 MT_CFServices::MT_CFServices()

    83     {

    84     }

    85 

    86 // Second phase construct

    87 void MT_CFServices::ConstructL()

    88     {

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

    90     // It generates the test case table.

    91     CEUnitTestSuiteClass::ConstructL();

    92 

    93     // Disable screen saver

    94     CFEnvUtils::EnableScreenSaver( EFalse );

    95     }

    96 

    97 // METHODS

    98 

    99 void MT_CFServices::ActionIndicationL( CCFActionIndication* /*aIndication*/ )

   100     {

   101     

   102     }

   103 

   104 void MT_CFServices::ContextIndicationL( CCFContextIndication* aIndication )

   105     {

   106     delete iIndicatedContext;

   107     iIndicatedContext = NULL;

   108     

   109     iIndicatedContext = CCFContextObject::NewL();

   110     iIndicatedContext->CopyL( aIndication->Context() );

   111     

   112     delete aIndication;

   113     }

   114 

   115 TInt MT_CFServices::Client( RThread& /*aThread*/ ) const

   116     {

   117     return KErrNone;

   118     }

   119 

   120 void MT_CFServices::HandleContextSubscriptionError( TInt /*aError*/,

   121     const TDesC& /*aSource*/,

   122     const TDesC& /*aType*/ )

   123     {

   124 

   125     }

   126 

   127 void MT_CFServices::SetupL(  )

   128     {

   129 

   130     }

   131 

   132 void MT_CFServices::SetupActionIndicationL(  )

   133     {

   134     iActionIndication = CCFActionIndicationImpl::NewL();

   135     }

   136 

   137 void MT_CFServices::Teardown(  )

   138     {

   139     delete iActionIndication;

   140     iActionIndication = NULL;

   141     

   142     delete iIndicatedContext;

   143     iIndicatedContext = NULL;

   144     }

   145     

   146 CCFActionIndicationImpl* MT_CFServices::ConfigureActionIndicationL(

   147     const TDesC& aActionId,

   148     TInt aNumOfParams )

   149     {

   150     TBuf<20> key( KNullDesC );

   151     TBuf<20> value( KNullDesC );

   152 

   153     CCFActionIndicationImpl* actionIndication = CCFActionIndicationImpl::NewLC();

   154     if( aActionId.Length() )

   155         {

   156         actionIndication->SetIdentifierL( aActionId );

   157         }

   158     for( TInt i = 0; i < aNumOfParams; i++ )

   159         {

   160         key.Format( KKey, i );

   161         value.Format( KValue, i );

   162         actionIndication->AddParameterL( key, value );

   163         }

   164     

   165     CleanupStack::Pop( actionIndication );

   166     return actionIndication;

   167     }

   168 

   169 CCFActionSubscriptionImpl* MT_CFServices::ConfigureActionSubscriptionL(

   170     const TDesC& aActionId )

   171     {

   172     CCFActionSubscriptionImpl* actionSubscription =

   173         CCFActionSubscriptionImpl::NewLC();

   174     

   175     if( aActionId.Length() )

   176         {

   177         actionSubscription->SetActionIdentifierL( aActionId );

   178         }

   179     

   180     CleanupStack::Pop( actionSubscription );

   181     return actionSubscription;

   182     }

   183     

   184 CCFContextObjectImpl* MT_CFServices::ConfigureContextObjectLC(

   185     const TDesC& aSource,

   186     const TDesC& aType,

   187     const TDesC& aValue,

   188     TUint aConfidence,

   189     const TTime& aTime )

   190     {

   191     CCFContextObjectImpl* context = CCFContextObjectImpl::NewLC();

   192     

   193     if( aSource.Length() )

   194         {

   195         context->SetSourceL( aSource );

   196         }

   197     if( aType.Length() )

   198         {

   199         context->SetTypeL( aType );

   200         }

   201     if( aValue.Length() )

   202         {

   203         context->SetValueL( aValue );

   204         }

   205     context->SetConfidence( aConfidence );

   206     context->SetTimestamp( aTime );

   207     

   208     return context;

   209     }

   210     

   211 CCFContextSubscriptionImpl* MT_CFServices::ConfigureContextSubscriptionLC(

   212     const TDesC& aSource,

   213     const TDesC& aType,

   214     TBool aSubTypeMatch,

   215     TBool aIndicateOnlyChanges )

   216     {

   217     CCFContextSubscriptionImpl* subscription = CCFContextSubscriptionImpl::NewLC();

   218     

   219     if( aSource.Length() )

   220         {

   221         subscription->SetContextSourceL( aSource );

   222         }

   223     if( aType.Length() )

   224         {

   225         subscription->SetContextTypeL( aType );

   226         }

   227     subscription->SetSubTypeMatch( aSubTypeMatch );

   228     subscription->SetOnlyChangesIndicated( aIndicateOnlyChanges );

   229     

   230     return subscription;

   231     }

   232     

   233 //-----------------------------------------------------------------------------

   234 // CCFActionIndication class unit test cases

   235 //-----------------------------------------------------------------------------

   236 //

   237 void MT_CFServices::MT_CCFActionIndication_NewLL(  )

   238     {

   239     CCFActionIndication* instance = CCFActionIndication::NewL();

   240     CleanupStack::PushL( instance );

   241     

   242     EUNIT_ASSERT_DESC( instance, "CCFActionIndication class instance not created!" );

   243     

   244     CleanupStack::PopAndDestroy( instance );

   245     }

   246 

   247 void MT_CFServices::MT_CCFActionIndication_NewLCL(  )

   248     {

   249     CCFActionIndication* instance = CCFActionIndication::NewLC();

   250     

   251     EUNIT_ASSERT_DESC( instance, "CCFActionIndication class instance not created!" );

   252     

   253     CleanupStack::PopAndDestroy( instance );

   254     }

   255 

   256 //-----------------------------------------------------------------------------

   257 // CCFActionIndicationImpl class unit test cases

   258 //-----------------------------------------------------------------------------

   259 //

   260 void MT_CFServices::MT_CCFActionIndicationImpl_NewLL(  )

   261     {

   262     CCFActionIndicationImpl* instance = CCFActionIndicationImpl::NewL();

   263     CleanupStack::PushL( instance );

   264     

   265     EUNIT_ASSERT_DESC( instance, "CCFActionIndicationImpl class instance not created!" );

   266     

   267     CleanupStack::PopAndDestroy( instance );

   268     }

   269 

   270 void MT_CFServices::MT_CCFActionIndicationImpl_NewLCL(  )

   271     {

   272     CCFActionIndicationImpl* instance = CCFActionIndicationImpl::NewLC();

   273     

   274     EUNIT_ASSERT_DESC( instance, "CCFActionIndicationImpl class instance not created!" );

   275     

   276     CleanupStack::PopAndDestroy( instance );

   277     }

   278 

   279 void MT_CFServices::MT_CCFActionIndicationImpl_SetIdentifierLL(  )

   280     {

   281     TPtrC id( KNullDesC );

   282     

   283     id.Set( iActionIndication->Identifier() );

   284     EUNIT_ASSERT_DESC( id == KNullDesC, "Invalid action ID!" );

   285     

   286     iActionIndication->SetIdentifierL( KActionId );

   287     id.Set( iActionIndication->Identifier() );

   288     EUNIT_ASSERT_DESC( id == KActionId, "Invalid action ID!" );

   289 

   290     iActionIndication->SetIdentifierL( KShortActionId );

   291     id.Set( iActionIndication->Identifier() );

   292     EUNIT_ASSERT_DESC( id == KShortActionId, "Invalid action ID!" );

   293 

   294     iActionIndication->SetIdentifierL( KLongActionId );

   295     id.Set( iActionIndication->Identifier() );

   296     EUNIT_ASSERT_DESC( id == KLongActionId, "Invalid action ID!" );

   297     }

   298 

   299 void MT_CFServices::MT_CCFActionIndicationImpl_AddParameterLL(  )

   300     {

   301     TInt count = 0;

   302     TBuf<20> key( KNullDesC );

   303     TBuf<20> value( KNullDesC );

   304     

   305     count = iActionIndication->Parameters().Count();

   306     EUNIT_ASSERT_DESC( !count, "Invalid parameter count!" );

   307     

   308     delete iActionIndication;

   309     iActionIndication = NULL;

   310     iActionIndication = ConfigureActionIndicationL( KActionId, KParamCount );

   311     count = iActionIndication->Parameters().Count();

   312     EUNIT_ASSERT_DESC( count == KParamCount, "Invalid parameter count!" );

   313     

   314     const RKeyValueArray& params = iActionIndication->Parameters();

   315     for( TInt i = 0; i < KParamCount; i++ )

   316         {

   317         key.Format( KKey, i );

   318         EUNIT_ASSERT_DESC( key == params[i]->Key(), "Invalid key!" );

   319         

   320         value.Format( KValue, i );

   321         EUNIT_ASSERT_DESC( value == params[i]->Value(), "Invalid value!" );

   322         }

   323     }

   324 

   325 void MT_CFServices::MT_CCFActionIndicationImpl_ExternalizeLL(  )

   326     {

   327     TInt size = 0;

   328     CCFActionIndicationImpl* actionIndication = NULL;

   329     

   330     static const TInt KCount = 2;

   331     for( TInt i = 0; i < KCount; i++ )

   332         {

   333         switch( i )

   334             {

   335             case 0:

   336                 {

   337                 // Create action indication

   338                 actionIndication = ConfigureActionIndicationL( KActionId, KParamCount );

   339                 CleanupStack::PushL( actionIndication );

   340                 break;

   341                 }

   342             case 1:

   343             default:

   344                 {

   345                 // Create action indication

   346                 actionIndication = ConfigureActionIndicationL( KNullDesC, KParamCount * 2 );

   347                 CleanupStack::PushL( actionIndication );

   348                 break;

   349                 }

   350             }

   351         

   352         // Externalize

   353         size = actionIndication->Size();

   354         HBufC8* buffer = HBufC8::NewLC( size );

   355         TPtr8 bufferPtr = buffer->Des();

   356         RDesWriteStream writeStream( bufferPtr );

   357         writeStream.PushL();

   358         actionIndication->ExternalizeL( writeStream );

   359         CleanupStack::PopAndDestroy( &writeStream );

   360         

   361         // Internalize

   362         CCFActionIndicationImpl* newActionIndication = CCFActionIndicationImpl::NewLC();

   363         RDesReadStream readStream( bufferPtr );

   364         readStream.PushL();

   365         newActionIndication->InternalizeL( readStream );

   366 

   367         // Clean up

   368         CleanupStack::PopAndDestroy( &readStream );

   369         

   370         // Check result

   371         EUNIT_ASSERT_DESC(

   372             actionIndication->Identifier() == newActionIndication->Identifier(),

   373                 "Invalid identifier!" );

   374         EUNIT_ASSERT_DESC(

   375             actionIndication->Parameters().Count() == newActionIndication->Parameters().Count(),

   376                 "Invalid parameter count!");

   377         TInt count = actionIndication->Parameters().Count();

   378         for( TInt i = 0; i < count; i++ )

   379             {

   380             EUNIT_ASSERT_DESC(

   381                 actionIndication->Parameters()[i]->Key() == newActionIndication->Parameters()[i]->Key(),

   382                     "Invalid key!" );

   383             EUNIT_ASSERT_DESC(

   384                 actionIndication->Parameters()[i]->Value() == newActionIndication->Parameters()[i]->Value(),

   385                     "Invalid value!" );

   386             }

   387         

   388         // Clean up

   389         CleanupStack::PopAndDestroy( newActionIndication );

   390         CleanupStack::PopAndDestroy( buffer );

   391         CleanupStack::PopAndDestroy( actionIndication );

   392         }

   393     }

   394 

   395 //-----------------------------------------------------------------------------

   396 // CCFActionSubscription class unit test cases

   397 //-----------------------------------------------------------------------------

   398 //

   399 void MT_CFServices::MT_CCFActionSubscription_NewLL(  )

   400     {

   401     CCFActionSubscription* instance = CCFActionSubscription::NewL();

   402     CleanupStack::PushL( instance );

   403     

   404     EUNIT_ASSERT_DESC( instance, "CCFActionSubscription class instance not created!" );

   405     

   406     CleanupStack::PopAndDestroy( instance );

   407     }

   408 

   409 void MT_CFServices::MT_CCFActionSubscription_NewLCL(  )

   410     {

   411     CCFActionSubscription* instance = CCFActionSubscription::NewLC();

   412     

   413     EUNIT_ASSERT_DESC( instance, "CCFActionSubscription class instance not created!" );

   414     

   415     CleanupStack::PopAndDestroy( instance );

   416     }

   417 

   418 //-----------------------------------------------------------------------------

   419 // CCFActionSubscriptionImpl class unit test cases

   420 //-----------------------------------------------------------------------------

   421 //

   422 void MT_CFServices::MT_CCFActionSubscriptionImpl_NewLL(  )

   423     {

   424     CCFActionSubscriptionImpl* instance = CCFActionSubscriptionImpl::NewL();

   425     CleanupStack::PushL( instance );

   426     

   427     EUNIT_ASSERT_DESC( instance, "CCFActionSubscriptionImpl class instance not created!" );

   428     

   429     CleanupStack::PopAndDestroy( instance );

   430     }

   431 

   432 void MT_CFServices::MT_CCFActionSubscriptionImpl_NewLCL(  )

   433     {

   434     CCFActionSubscriptionImpl* instance = CCFActionSubscriptionImpl::NewLC();

   435     

   436     EUNIT_ASSERT_DESC( instance, "CCFActionSubscriptionImpl class instance not created!" );

   437     

   438     CleanupStack::PopAndDestroy( instance );

   439     }

   440 

   441 void MT_CFServices::MT_CCFActionSubscriptionImpl_SetActionIdentifierLL(  )

   442     {

   443     CCFActionSubscriptionImpl* instance = CCFActionSubscriptionImpl::NewLC();

   444     

   445     EUNIT_ASSERT_DESC( instance->ActionIdentifier() == KNullDesC,

   446         "Incorrect action identifier!" );

   447         

   448     instance->SetActionIdentifierL( KActionId );

   449     EUNIT_ASSERT_DESC( instance->ActionIdentifier() == KActionId,

   450         "Incorrect action identifier!" );

   451     

   452     // Clean up

   453     CleanupStack::PopAndDestroy( instance );

   454     }

   455 

   456 void MT_CFServices::MT_CCFActionSubscriptionImpl_ExternalizeLL(  )

   457     {

   458     static const TInt KCount = 2;

   459     CCFActionSubscriptionImpl* instance = NULL;

   460     for( TInt i = 0; i < KCount; i++ )

   461         {

   462         switch( i )

   463             {

   464             case 0:

   465                 {

   466                 instance = ConfigureActionSubscriptionL( KActionId );

   467                 CleanupStack::PushL( instance );

   468                 break;

   469                 }

   470             case 1:

   471             default:

   472                 {

   473                 instance = ConfigureActionSubscriptionL( KNullDesC );

   474                 CleanupStack::PushL( instance );

   475                 break;

   476                 }

   477             }

   478             

   479         // Externalize

   480         HBufC8* buffer = HBufC8::NewLC( instance->Size() );

   481         TPtr8 bufferPtr = buffer->Des();

   482         RDesWriteStream writeStream( bufferPtr );

   483         writeStream.PushL();

   484         instance->ExternalizeL( writeStream );

   485         CleanupStack::PopAndDestroy( &writeStream );

   486         

   487         // Internalize

   488         CCFActionSubscriptionImpl* newInstance = CCFActionSubscriptionImpl::NewLC();

   489         RDesReadStream readStream( bufferPtr );

   490         readStream.PushL();

   491         newInstance->InternalizeL( readStream );

   492         CleanupStack::PopAndDestroy( &readStream );

   493         

   494         // Check result

   495         EUNIT_ASSERT_DESC(

   496             instance->ActionIdentifier() == newInstance->ActionIdentifier(),

   497                 "Incorrect action identifier!" );

   498         

   499         // Clean up

   500         CleanupStack::PopAndDestroy( newInstance );

   501         CleanupStack::PopAndDestroy( buffer );

   502         CleanupStack::PopAndDestroy( instance );

   503         }

   504     }

   505 

   506 void MT_CFServices::MT_CCFActionSubscriptionImpl_SetListenerL(  )

   507     {

   508     CCFActionSubscriptionImpl* instance = CCFActionSubscriptionImpl::NewLC();

   509     

   510     EUNIT_ASSERT_DESC( !( &instance->Listener() ), "Invalid listener!" );

   511     

   512     instance->SetListener( this );

   513     EUNIT_ASSERT_DESC( ( &instance->Listener() ), "Invalid listener!" );

   514     

   515     CleanupStack::PopAndDestroy( instance );

   516     }

   517 

   518 //-----------------------------------------------------------------------------

   519 // CCFContextIndication class unit test cases

   520 //-----------------------------------------------------------------------------

   521 //

   522 void MT_CFServices::MT_CCFContextIndication_NewLL(  )

   523     {

   524     CCFContextIndication* instance = CCFContextIndication::NewL( KNullUid );

   525     CleanupStack::PushL( instance );

   526     

   527     EUNIT_ASSERT_DESC( instance, "CCFContextIndication class instance not created!" );

   528     

   529     CleanupStack::PopAndDestroy( instance );

   530     }

   531 

   532 void MT_CFServices::MT_CCFContextIndication_NewLCL(  )

   533     {

   534     CCFContextIndication* instance = CCFContextIndication::NewLC( KNullUid );

   535     

   536     EUNIT_ASSERT_DESC( instance, "CCFContextIndication class instance not created!" );

   537     

   538     CleanupStack::PopAndDestroy( instance );

   539     }

   540 

   541 //-----------------------------------------------------------------------------

   542 // CCFContextIndicationImpl class unit test cases

   543 //-----------------------------------------------------------------------------

   544 //

   545 void MT_CFServices::MT_CCFContextIndicationImpl_NewLL(  )

   546     {

   547     CCFContextIndicationImpl* instance = CCFContextIndicationImpl::NewL( KNullUid );

   548     CleanupStack::PushL( instance );

   549     

   550     EUNIT_ASSERT_DESC( instance, "CCFContextIndicationImpl class instance not created!" );

   551     

   552     CleanupStack::PopAndDestroy( instance );

   553     }

   554 

   555 void MT_CFServices::MT_CCFContextIndicationImpl_NewLCL(  )

   556     {

   557     CCFContextIndicationImpl* instance = CCFContextIndicationImpl::NewLC( KNullUid );

   558     

   559     EUNIT_ASSERT_DESC( instance, "CCFContextIndicationImpl class instance not created!" );

   560     

   561     CleanupStack::PopAndDestroy( instance );

   562     }

   563 

   564 void MT_CFServices::MT_CCFContextIndicationImpl_SetContextLL(  )

   565     {

   566     static const TUint KConfidence = 100;

   567     TTime time;

   568     time.HomeTime();

   569     CCFContextObjectImpl* context = ConfigureContextObjectLC(

   570         KContextSource,

   571         KContextType,

   572         KContextValue,

   573         KConfidence,

   574         time );

   575         

   576     CCFContextIndicationImpl* indication = CCFContextIndicationImpl::NewLC( KNullUid );

   577     indication->SetContextL( *context );

   578     EUNIT_ASSERT_DESC(

   579         CCFContextObjectImpl::IsSame( *context, indication->Context() ),

   580             "Incorrect comparison result!" );

   581             

   582     context->SetSourceL( KContextSourceLong );

   583     EUNIT_ASSERT_DESC(

   584         !CCFContextObjectImpl::IsSame( *context, indication->Context() ),

   585             "Incorrect comparison result!" );

   586         

   587     // clean up

   588     CleanupStack::PopAndDestroy( indication );

   589     CleanupStack::PopAndDestroy( context );

   590     }

   591 

   592 void MT_CFServices::MT_CCFContextIndicationImpl_ExternalizeLL(  )

   593     {

   594     static const TUint KConfidence = 100;

   595     TTime time;

   596     static const TInt KCount = 3;

   597     CCFContextObjectImpl* context = NULL;

   598     CCFContextIndicationImpl* indication = NULL;

   599     CCFContextIndicationImpl* copyIndication = NULL;

   600     for( TInt i = 0; i < KCount; i++ )

   601         {

   602         time.HomeTime();

   603         switch( i )

   604             {

   605             case 0:

   606                 {

   607                 context = ConfigureContextObjectLC(

   608                     KContextSource,

   609                     KNullDesC,

   610                     KNullDesC,

   611                     KConfidence,

   612                     time );

   613                 break;

   614                 }

   615             case 1:

   616                 {

   617                 context = ConfigureContextObjectLC(

   618                     KContextSource,

   619                     KContextType,

   620                     KNullDesC,

   621                     KConfidence,

   622                     time );

   623                 break;

   624                 }

   625             case 2:

   626             default:

   627                 {

   628                 context = ConfigureContextObjectLC(

   629                     KContextSource,

   630                     KContextType,

   631                     KContextValue,

   632                     KConfidence,

   633                     time );

   634                 break;

   635                 }

   636             }

   637         

   638         indication = CCFContextIndicationImpl::NewLC( KNullUid );

   639         indication->SetContextL( *context );

   640         

   641         // Externalize

   642         HBufC8* buffer = HBufC8::NewLC( indication->Size() );

   643         TPtr8 bufferPtr = buffer->Des();

   644         RDesWriteStream writeStream( bufferPtr );

   645         writeStream.PushL();

   646         indication->ExternalizeL( writeStream );

   647         CleanupStack::PopAndDestroy( &writeStream );

   648         

   649         // Internalize

   650         RDesReadStream readStream( bufferPtr );

   651         readStream.PushL();

   652         copyIndication = CCFContextIndicationImpl::NewLC( readStream );

   653         

   654         // Check result

   655         EUNIT_ASSERT_DESC(

   656             CCFContextObjectImpl::IsSame( indication->Context(), copyIndication->Context() ),

   657                 "Incorrect externalize result!" );

   658             

   659         // Clean up

   660         CleanupStack::PopAndDestroy( copyIndication );

   661         CleanupStack::PopAndDestroy( &readStream );

   662         CleanupStack::PopAndDestroy( buffer );

   663         CleanupStack::PopAndDestroy( indication );

   664         CleanupStack::PopAndDestroy( context );

   665         }

   666     }

   667 

   668 //-----------------------------------------------------------------------------

   669 // CCFContextObject class unit test cases

   670 //-----------------------------------------------------------------------------

   671 //

   672 void MT_CFServices::MT_CCFContextObject_NewLL(  )

   673     {

   674     CCFContextObject* context = CCFContextObject::NewL();

   675     CleanupStack::PushL( context );

   676     EUNIT_ASSERT_DESC( context, "CCFContextObject class instance not created!" );

   677     CleanupStack::PopAndDestroy( context );

   678 

   679     context = CCFContextObject::NewL(

   680         _L("Source"), _L("Type"), _L("Value") );

   681     CleanupStack::PushL( context );

   682     EUNIT_ASSERT_DESC( context, "CCFContextObject class instance not created!" );

   683     CleanupStack::PopAndDestroy( context );

   684     }

   685 

   686 void MT_CFServices::MT_CCFContextObject_NewLCL(  )

   687     {

   688     CCFContextObject* context = CCFContextObject::NewLC();

   689     EUNIT_ASSERT_DESC( context, "CCFContextObject class instance not created!" );

   690     CleanupStack::PopAndDestroy( context );

   691 

   692     context = CCFContextObject::NewLC(

   693         _L("Source"), _L("Type"), _L("Value") );

   694     EUNIT_ASSERT_DESC( context, "CCFContextObject class instance not created!" );

   695     CleanupStack::PopAndDestroy( context );

   696     }

   697 

   698 //-----------------------------------------------------------------------------

   699 // CCFContextObjectImpl class unit test cases

   700 //-----------------------------------------------------------------------------

   701 //

   702 void MT_CFServices::MT_CCFContextObjectImpl_NewLL(  )

   703     {

   704     CCFContextObjectImpl* context = CCFContextObjectImpl::NewL();

   705     CleanupStack::PushL( context );

   706     

   707     EUNIT_ASSERT_DESC( context, "CCFContextObjectImpl class instance not created!" );

   708     

   709     CleanupStack::PopAndDestroy( context );

   710     }

   711 

   712 void MT_CFServices::MT_CCFContextObjectImpl_NewLCL(  )

   713     {

   714     CCFContextObjectImpl* context = CCFContextObjectImpl::NewLC();

   715     

   716     EUNIT_ASSERT_DESC( context, "CCFContextObjectImpl class instance not created!" );

   717     

   718     CleanupStack::PopAndDestroy( context );

   719     }

   720 

   721 void MT_CFServices::MT_CCFContextObjectImpl_SetTypeLL(  )

   722     {

   723     CCFContextObjectImpl* context = CCFContextObjectImpl::NewLC();

   724     

   725     EUNIT_ASSERT_DESC( context->Type() == KNullDesC,

   726         "Invalid context type!" );

   727         

   728     context->SetTypeL( KContextType );

   729     EUNIT_ASSERT_DESC( context->Type() == KContextType,

   730         "Invalid context type!" );

   731     

   732     context->SetTypeL( KContextTypeLong );

   733     EUNIT_ASSERT_DESC( context->Type() == KContextTypeLong,

   734         "Invalid context type!" );

   735     

   736     // Clean up

   737     CleanupStack::PopAndDestroy( context );

   738     }

   739 

   740 void MT_CFServices::MT_CCFContextObjectImpl_SetValueLL(  )

   741     {

   742     CCFContextObjectImpl* context = CCFContextObjectImpl::NewLC();

   743     

   744     EUNIT_ASSERT_DESC( context->Value() == KNullDesC,

   745         "Invalid context value!" );

   746         

   747     context->SetValueL( KContextValue );

   748     EUNIT_ASSERT_DESC( context->Value() == KContextValue,

   749         "Invalid context value!" );

   750     

   751     context->SetValueL( KContextValueLong );

   752     EUNIT_ASSERT_DESC( context->Value() == KContextValueLong,

   753         "Invalid context value!" );

   754     

   755     // Clean up

   756     CleanupStack::PopAndDestroy( context );

   757     }

   758 

   759 void MT_CFServices::MT_CCFContextObjectImpl_SetSourceLL(  )

   760     {

   761     CCFContextObjectImpl* context = CCFContextObjectImpl::NewLC();

   762     

   763     EUNIT_ASSERT_DESC( context->Source() == KNullDesC,

   764         "Invalid context source!" );

   765         

   766     context->SetSourceL( KContextSource );

   767     EUNIT_ASSERT_DESC( context->Source() == KContextSource,

   768         "Invalid context source!" );

   769 

   770     context->SetSourceL( KContextSourceLong );

   771     EUNIT_ASSERT_DESC( context->Source() == KContextSourceLong,

   772         "Invalid context source!" );

   773 

   774     // Clean up

   775     CleanupStack::PopAndDestroy( context );

   776     }

   777 

   778 void MT_CFServices::MT_CCFContextObjectImpl_SetConfidenceL(  )

   779     {

   780     CCFContextObjectImpl* context = CCFContextObjectImpl::NewLC();

   781     

   782     EUNIT_ASSERT_DESC( context->Confidence() == 100,

   783         "Invalid confidence!" );

   784         

   785     context->SetConfidence( 50 );

   786     EUNIT_ASSERT_DESC( context->Confidence() == 50,

   787         "Invalid confidence!" );

   788     

   789     // Clean up

   790     CleanupStack::PopAndDestroy( context );

   791     }

   792 

   793 void MT_CFServices::MT_CCFContextObjectImpl_SetTimestampToHomeTimeL(  )

   794     {

   795     CCFContextObjectImpl* context = CCFContextObjectImpl::NewLC();

   796     

   797     TTime now;

   798     now.HomeTime();

   799     

   800     User::After( 1000 );

   801     context->SetTimestampToHomeTime();

   802     User::After( 1000 );

   803     

   804     TTime after;

   805     after.HomeTime();

   806     

   807     const TTime& time = context->Timestamp();

   808     EUNIT_ASSERT_DESC( time > now, "Invalid home timestamp!" );

   809     EUNIT_ASSERT_DESC( time < after, "Invalid home timestamp!" );

   810 

   811     // Clean up

   812     CleanupStack::PopAndDestroy( context );

   813     }

   814 

   815 void MT_CFServices::MT_CCFContextObjectImpl_SetTimestampL(  )

   816     {

   817     CCFContextObjectImpl* context = CCFContextObjectImpl::NewLC();

   818     TTime now;

   819     now.HomeTime();

   820     

   821     EUNIT_ASSERT_DESC( now != context->Timestamp(), "Invalid time stamp!" );

   822     

   823     context->SetTimestamp( now );

   824     EUNIT_ASSERT_DESC( now == context->Timestamp(), "Invalid time stamp!" );

   825     

   826     User::After( 1000 );

   827     now.HomeTime();

   828 

   829     context->SetTimestamp( now.Int64() );

   830     EUNIT_ASSERT_DESC( now == context->Timestamp(), "Invalid time stamp!" );

   831     

   832     // Clean up

   833     CleanupStack::PopAndDestroy( context );

   834     }

   835 

   836 void MT_CFServices::MT_CCFContextObjectImpl_CopyLL(  )

   837     {

   838     static const TInt KConfidence = 50;

   839     TTime time;

   840     time.HomeTime();

   841     CCFContextObjectImpl* context = ConfigureContextObjectLC(

   842         KContextSource,

   843         KContextType,

   844         KContextValue,

   845         KConfidence,

   846         time

   847         );

   848 

   849     CCFContextObjectImpl* copyContext = CCFContextObjectImpl::NewLC();

   850     copyContext->CopyL( *context );

   851     

   852     EUNIT_ASSERT_DESC( context->Source() == copyContext->Source(),

   853         "Invalid source copy!" );

   854     EUNIT_ASSERT_DESC( context->Type() == copyContext->Type(),

   855         "Invalid type copy!" );

   856     EUNIT_ASSERT_DESC( context->Value() == copyContext->Value(),

   857         "Invalid value copy!" );

   858     EUNIT_ASSERT_DESC( context->Confidence() == copyContext->Confidence(),

   859         "Invalid confidence copy!" );

   860     EUNIT_ASSERT_DESC( context->Timestamp() == copyContext->Timestamp(),

   861         "Invalid timestamp copy!" );

   862     

   863     // Clean up

   864     CleanupStack::PopAndDestroy( copyContext );

   865     CleanupStack::PopAndDestroy( context );

   866     }

   867 

   868 void MT_CFServices::MT_CCFContextObjectImpl_ExternalizeLL(  )

   869     {

   870     static const TInt KConfidence = 50;

   871     static const TInt KCount = 3;

   872     TTime time;

   873     CCFContextObjectImpl* context = NULL;

   874     for( TInt i = 0; i < KCount; i++ )

   875         {

   876         switch( i )

   877             {

   878             case 1:

   879                 {

   880                 context = ConfigureContextObjectLC(

   881                     KContextSource,

   882                     KNullDesC,

   883                     KContextValue,

   884                     KConfidence,

   885                     time );

   886                 break;

   887                 }

   888             case 2:

   889                 {

   890                 context = ConfigureContextObjectLC(

   891                     KContextSource,

   892                     KNullDesC,

   893                     KNullDesC,

   894                     KConfidence,

   895                     time );

   896                 break;

   897                 }

   898             case 0:

   899             default:

   900                 {

   901                 context = ConfigureContextObjectLC(

   902                     KContextSource,

   903                     KContextType,

   904                     KContextValue,

   905                     KConfidence,

   906                     time );

   907                 break;

   908                 }

   909             }

   910         time.HomeTime();

   911         

   912         // Externalize

   913         HBufC8* buffer = HBufC8::NewLC( context->Size() );

   914         TPtr8 bufferPtr = buffer->Des();

   915         RDesWriteStream writeStream( bufferPtr );

   916         writeStream.PushL();

   917         context->ExternalizeL( writeStream );

   918         CleanupStack::PopAndDestroy( &writeStream );

   919         

   920         // Internalize

   921         CCFContextObjectImpl* copyContext = CCFContextObjectImpl::NewLC();

   922         RDesReadStream readStream( bufferPtr );

   923         readStream.PushL();

   924         copyContext->InternalizeL( readStream );

   925         CleanupStack::PopAndDestroy( &readStream );

   926         

   927         // Check results

   928         EUNIT_ASSERT_DESC( context->Source() == copyContext->Source(),

   929             "Invalid source copy!" );

   930         EUNIT_ASSERT_DESC( context->Type() == copyContext->Type(),

   931             "Invalid type copy!" );

   932         EUNIT_ASSERT_DESC( context->Value() == copyContext->Value(),

   933             "Invalid value copy!" );

   934         EUNIT_ASSERT_DESC( context->Confidence() == copyContext->Confidence(),

   935             "Invalid confidence copy!" );

   936         EUNIT_ASSERT_DESC( context->Timestamp() == copyContext->Timestamp(),

   937             "Invalid timestamp copy!" );

   938         

   939         // Clean up

   940         CleanupStack::PopAndDestroy( copyContext );

   941         CleanupStack::PopAndDestroy( buffer );

   942         CleanupStack::PopAndDestroy( context );

   943         }

   944     }

   945 

   946 void MT_CFServices::MT_CCFContextObjectImpl_CompareValueL(  )

   947     {

   948     static const TInt KConfidence = 50;

   949     TTime time;

   950     time.HomeTime();

   951     CCFContextObjectImpl* context1 = ConfigureContextObjectLC(

   952         KContextSource,

   953         KContextType,

   954         KContextValue,

   955         KConfidence,

   956         time );

   957     CCFContextObjectImpl* context2 = ConfigureContextObjectLC(

   958         KNullDesC,

   959         KNullDesC,

   960         KContextValue,

   961         KConfidence,

   962         time );

   963     CCFContextObjectImpl* context3 = ConfigureContextObjectLC(

   964         KNullDesC,

   965         KNullDesC,

   966         KContextValueLong,

   967         KConfidence,

   968         time );

   969         

   970     EUNIT_ASSERT_DESC( context1->CompareValue( *context2 ) == KErrNone,

   971         "Incorrect comparison result!" );

   972     EUNIT_ASSERT_DESC( context1->CompareValue( *context3 ) != KErrNone,

   973         "Incorrect comparison result!" );

   974         

   975     CleanupStack::PopAndDestroy( context3 );

   976     CleanupStack::PopAndDestroy( context2 );

   977     CleanupStack::PopAndDestroy( context1 );

   978     }

   979 

   980 void MT_CFServices::MT_CCFContextObjectImpl_CompareByTypeL(  )

   981     {

   982     static const TInt KConfidence = 50;

   983     TTime time;

   984     time.HomeTime();

   985     CCFContextObjectImpl* context1 = ConfigureContextObjectLC(

   986         KContextSource,

   987         KContextType,

   988         KContextValue,

   989         KConfidence,

   990         time );

   991     CCFContextObjectImpl* context2 = ConfigureContextObjectLC(

   992         KNullDesC,

   993         KContextType,

   994         KNullDesC,

   995         KConfidence,

   996         time );

   997     CCFContextObjectImpl* context3 = ConfigureContextObjectLC(

   998         KNullDesC,

   999         KContextTypeLong,

  1000         KContextValueLong,

  1001         KConfidence,

  1002         time );

  1003         

  1004     EUNIT_ASSERT_DESC(

  1005         CCFContextObjectImpl::CompareByType( *context1, *context2 ) == KErrNone,

  1006             "Incorrect comparison result!" );

  1007     EUNIT_ASSERT_DESC(

  1008         CCFContextObjectImpl::CompareByType( *context1, *context3 ) != KErrNone,

  1009             "Incorrect comparison result!" );

  1010         

  1011     CleanupStack::PopAndDestroy( context3 );

  1012     CleanupStack::PopAndDestroy( context2 );

  1013     CleanupStack::PopAndDestroy( context1 );

  1014     }

  1015 

  1016 void MT_CFServices::MT_CCFContextObjectImpl_CompareByTypeAndSourceL(  )

  1017     {

  1018     static const TInt KConfidence = 50;

  1019     TTime time;

  1020     time.HomeTime();

  1021     CCFContextObjectImpl* context1 = ConfigureContextObjectLC(

  1022         KContextSource,

  1023         KContextType,

  1024         KContextValue,

  1025         KConfidence,

  1026         time );

  1027     CCFContextObjectImpl* context2 = ConfigureContextObjectLC(

  1028         KContextSource,

  1029         KContextType,

  1030         KNullDesC,

  1031         KConfidence,

  1032         time );

  1033     CCFContextObjectImpl* context3 = ConfigureContextObjectLC(

  1034         KNullDesC,

  1035         KContextTypeLong,

  1036         KContextValueLong,

  1037         KConfidence,

  1038         time );

  1039         

  1040     EUNIT_ASSERT_DESC(

  1041         CCFContextObjectImpl::CompareByTypeAndSource( *context1, *context2 ) == KErrNone,

  1042             "Incorrect comparison result!" );

  1043     EUNIT_ASSERT_DESC(

  1044         CCFContextObjectImpl::CompareByTypeAndSource( *context1, *context3 ) != KErrNone,

  1045             "Incorrect comparison result!" );

  1046         

  1047     CleanupStack::PopAndDestroy( context3 );

  1048     CleanupStack::PopAndDestroy( context2 );

  1049     CleanupStack::PopAndDestroy( context1 );

  1050     }

  1051 

  1052 void MT_CFServices::MT_CCFContextObjectImpl_CompareByTimeDescendingL(  )

  1053     {

  1054     static const TInt KConfidence = 50;

  1055     TTime time;

  1056     time.HomeTime();

  1057     CCFContextObjectImpl* context1 = ConfigureContextObjectLC(

  1058         KContextSource,

  1059         KContextType,

  1060         KContextValue,

  1061         KConfidence,

  1062         time );

  1063     CCFContextObjectImpl* context2 = ConfigureContextObjectLC(

  1064         KContextSource,

  1065         KContextType,

  1066         KNullDesC,

  1067         KConfidence,

  1068         time );

  1069     User::After( 1000 );

  1070     time.HomeTime();

  1071     CCFContextObjectImpl* context3 = ConfigureContextObjectLC(

  1072         KNullDesC,

  1073         KContextTypeLong,

  1074         KContextValueLong,

  1075         KConfidence,

  1076         time );

  1077         

  1078     EUNIT_ASSERT_DESC(

  1079         CCFContextObjectImpl::CompareByTimeDescending( *context1, *context2 ) == 0,

  1080             "Incorrect comparison result!" );

  1081     EUNIT_ASSERT_DESC(

  1082         CCFContextObjectImpl::CompareByTypeAndSource( *context1, *context3 ) < 0,

  1083             "Incorrect comparison result!" );

  1084     EUNIT_ASSERT_DESC(

  1085         CCFContextObjectImpl::CompareByTypeAndSource( *context3, *context2 ) > 0,

  1086             "Incorrect comparison result!" );

  1087         

  1088     CleanupStack::PopAndDestroy( context3 );

  1089     CleanupStack::PopAndDestroy( context2 );

  1090     CleanupStack::PopAndDestroy( context1 );

  1091     }

  1092 

  1093 void MT_CFServices::MT_CCFContextObjectImpl_IsSameL(  )

  1094     {

  1095     static const TInt KConfidence = 50;

  1096     TTime time;

  1097     time.HomeTime();

  1098     CCFContextObjectImpl* context1 = ConfigureContextObjectLC(

  1099         KContextSource,

  1100         KContextType,

  1101         KContextValue,

  1102         KConfidence,

  1103         time );

  1104     CCFContextObjectImpl* context2 = ConfigureContextObjectLC(

  1105         KContextSource,

  1106         KContextType,

  1107         KContextValue,

  1108         KConfidence,

  1109         time );

  1110     CCFContextObjectImpl* context3 = ConfigureContextObjectLC(

  1111         KContextSource,

  1112         KContextType,

  1113         KNullDesC,

  1114         KConfidence,

  1115         time );

  1116     

  1117     EUNIT_ASSERT_DESC( CCFContextObjectImpl::IsSame( *context1, *context2 ),

  1118         "Contexts are not same!" );

  1119     EUNIT_ASSERT_DESC( !CCFContextObjectImpl::IsSame( *context1, *context3 ),

  1120         "Contexts are same!" );

  1121         

  1122     CleanupStack::PopAndDestroy( context3 );

  1123     CleanupStack::PopAndDestroy( context2 );

  1124     CleanupStack::PopAndDestroy( context1 );

  1125     }

  1126 

  1127 //-----------------------------------------------------------------------------

  1128 // CCFContextQuery class unit test cases

  1129 //-----------------------------------------------------------------------------

  1130 //

  1131 void MT_CFServices::MT_CCFContextQuery_NewLL(  )

  1132     {

  1133     CCFContextQuery* query = CCFContextQuery::NewL();

  1134     CleanupStack::PushL( query );