1 /*

     2 * Copyright (c) 2007 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 // INCLUDES

    20 #include "MT_CFClient.h"

    21 

    22 #include <EUnitMacros.h>

    23 #include <cfclient.h>

    24 #include <cfcontextsubscription.h>

    25 #include <cfcontextindication.h>

    26 #include <cfactionsubscription.h>

    27 #include <cfactionindication.h>

    28 #include <cfcontextsourcecommand.h>

    29 #include <f32file.h>

    30 #include <S32MEM.h>

    31 #include <e32property.h>

    32 #include <BAUTILS.H>

    33 

    34 #include "cfcommon.h"

    35 #include "testcontextdata.h"

    36 #include "cfcontextobjectimpl.h"

    37 #include "testcontextsourceplugin.h"

    38 #include "testcontextsourcepluginconst.hrh"

    39 #include "CFTestDelay.h"

    40 #include "cfenvutils.h"

    41 

    42 // CONSTANTS

    43 

    44 _LIT_SECURITY_POLICY_PASS( KPassSec );

    45 _LIT_SECURITY_POLICY_FAIL( KFailSec );

    46 

    47 _LIT( KContextSourceA, "TestSourceA" );

    48 _LIT( KContextTypeA, "TestTypeA" );

    49 _LIT( KContextValueA, "TestValueA" );

    50 _LIT( KContextValueB, "TestValueB" );

    51 

    52 _LIT( KContextSourceFormatWild, "Source" );

    53 _LIT( KContextTypeFormatWild, "Type" );

    54 _LIT( KContextSourceFormat, "Source.%d" );

    55 _LIT( KContextTypeFormat, "Type.%d" );

    56 _LIT( KContextValueFormat, "Value.%d" );

    57 

    58 _LIT( KActionIdFormat, "AcionId.%d" );

    59 

    60 _LIT( KActionA, "TestActionA" );

    61 _LIT( KActionAParamA1, "ParamA1" );

    62 _LIT( KActionAValueA1, "ValueA1" );

    63 

    64 _LIT( KActionB, "TestActionB" );

    65 _LIT( KActionBParamB1, "ParamB1" );

    66 _LIT( KActionBValueB1, "ValueB1" );

    67 _LIT( KActionBParamB2, "ParamB2" );

    68 _LIT( KActionBValueB2, "ValueB2" );

    69 

    70 _LIT( KActionC, "TestActionC" );

    71 

    72 _LIT( KTestContextSource, "TestContextSource" );

    73 _LIT( KTestContextType, "SubsNoSubsTest" );

    74 _LIT( KTestContextType2, "SubsNoSubsTest2" );

    75 _LIT( KTestContextValueType, "TestValue" );

    76 _LIT( KTestContextValueSubsOk, "SubsOk" );

    77 _LIT( KTestContextValueNosubsOk, "NoSubsOk" );

    78 _LIT( KTestContextValueNok, "Nok" );

    79 

    80 const TUid KTestContextSourcePluginImplUid =

    81     {

    82         KTestContextSourcePluginImplementationUid

    83     };

    84 const TUid KBogusContextSourcePluginImplUid =

    85     {

    86         0xBAD50BAD

    87     };

    88 

    89 const TInt KSecond = 1000000;

    90 

    91 _LIT( KSourceCommandId, "sourceCommand" );

    92 _LIT( KSourceCommandUidId, "uid" );

    93 _LIT( KSourceCommandParamCmd, "cmd" );

    94 _LIT( KSourceCommandParamCmdParam, "cmdParam" );

    95 _LIT( KSourceCommandParamCmdInfo, "cmdInfo" );

    96 _LIT( KSourceCommandParamModifiers, "modifiers" );

    97 _LIT( KSourceCommandAttributeType, "type" );

    98 _LIT( KSourceCommandAttributeMode, "mode" );

    99 _LIT( KSourceCommandAttributeOverride, "override" );

   100 _LIT( KSourceCommandAttributeText, "text" );

   101 _LIT( KSourceCommandAttributeValueText, "activate from really clean state" );

   102 _LIT( KSourceCommandAttributeValue, "value" );

   103 _LIT( KSourceCommandAttributeValueYes, "yes" );

   104 _LIT( KSourceCommandAttributeValueActivate, "Activate" );

   105 _LIT( KSourceCommandAttributeValueDeactivate, "Deactivate" );

   106 _LIT( KSourceCommandAttributeValueClean, "clean" );

   107 _LIT( KSourceCommandAttributeValueReally, "really" );

   108 _LIT( KSourceCommandAttributeValueFull, "full" );

   109 _LIT( KSourceCommandAttributeValueNoException, "noException" );

   110 

   111 _LIT( KSourceCommandPluginScriptContextSource, "TestSourcePlugIn" );

   112 _LIT( KSourceCommandClientScriptContextSource, "TestSourceClient" );

   113 _LIT( KSourceCommandScriptContextType, "SendSourceCommand" );

   114 _LIT( KSourceCommandScript1ContextValueActivate, "A" );

   115 _LIT( KSourceCommandScript1ContextValueDeactivate, "B" );

   116 _LIT( KSourceCommandScript2ContextValueActivate, "A2" );

   117 _LIT( KSourceCommandScript2ContextValueDeactivate, "B2" );

   118 

   119 _LIT( KSourceCommandSignalContextSource, "TestSourcePlugin" );

   120 _LIT( KSourceCommandSignalContextType, "SourceCommand" );

   121 _LIT( KSourceCommandSignalContextValueActivated, "Activated" );

   122 _LIT( KSourceCommandSignalContextValueDeactivated, "Deactivated" );

   123 _LIT( KSourceCommandSignalContextValueActiveReqActivate, "ActiveReqActivate" );

   124 _LIT( KSourceCommandSignalContextValueActiveReqDeactivate, "ActiveReqDeactivate" );

   125 _LIT( KSourceCommandSignalContextValueDeactiveReqDeactivate, "DeactiveReqDeactivate" );

   126 _LIT( KSourceCommandSignalContextValueError, "Error" );

   127 

   128 _LIT( KContextValueTriggerForSourceCommandClient, "SourceCommandClient" );

   129 

   130 _LIT( KReservedActionPublishContext, "publishContext" );

   131 _LIT( KReservedActionPublishContext2, "PUBLISHCONTEXT" );

   132 _LIT( KReservedActionSourceCommand, "sourceCommand" );

   133 _LIT( KReservedActionSourceCommand2, "SOURCECOMMAND" );

   134 

   135 _LIT( KRomScriptAutoDefineContextSource, "RomScript" );

   136 _LIT( KRomScriptAutoDefineContextType, "NewContext" );

   137 _LIT( KRomScriptAutoDefineContextValue, "AutoDefined" );

   138 _LIT( KRomScriptTriggerAutoDefineContextSource, "TestRomScript" );

   139 _LIT( KRomScriptTriggerAutoDefineContextType, "PublishContext" );

   140 _LIT( KRomScriptTriggerAutoDefineContextValue, "AutoDefine" );

   141 

   142 _LIT( KRomScriptDetectedAutoDefinedContextSource, "AutoDefined" );

   143 _LIT( KRomScriptDetectedAutoDefinedContextType, "RomScriptContext" );

   144 _LIT( KRomScriptDetectedAutoDefinedContextValue, "Detected" );

   145 

   146 // LOCAL DEFINITIONS

   147 

   148 /**

   149  * Clean up item for RContextObjectArray

   150  */

   151 LOCAL_C void CleanupContextObjectArray( TAny* aArray )

   152     {

   153     RContextObjectArray* array = static_cast<RContextObjectArray*>( aArray );

   154     array->ResetAndDestroy();

   155     }

   156 

   157 /**

   158  * Clean up function for RContextObjectArray

   159  */

   160 LOCAL_C void CleanupResetAndDestroyPushL( RContextObjectArray& aArray )

   161     {

   162     TCleanupItem item( CleanupContextObjectArray, &aArray );

   163     CleanupStack::PushL( item );

   164     }

   165 

   166 /**

   167  * Clean up item for RContextQueryArray

   168  */

   169 LOCAL_C void CleanupContextQueryArray( TAny* aArray )

   170     {

   171     RContextQueryArray* array = static_cast<RContextQueryArray*>( aArray );

   172     array->ResetAndDestroy();

   173     }

   174 

   175 /**

   176  * Clean up function for RContextQueryArray

   177  */

   178 LOCAL_C void CleanupResetAndDestroyPushL( RContextQueryArray& aArray )

   179     {

   180     TCleanupItem item( CleanupContextQueryArray, &aArray );

   181     CleanupStack::PushL( item );

   182     }

   183 

   184 /**

   185  * Wait info.

   186  */

   187 NONSHARABLE_CLASS( TWaitInfo )

   188     {

   189 public:

   190 

   191     CPeriodic* iPeriodic;

   192     CActiveSchedulerWait* iWait;

   193     };

   194 

   195 /**

   196  * Call back method when we need to stop active scheduler wait.

   197  */

   198 LOCAL_C TInt WaitCallBack( TAny* aSelf )

   199     {

   200     if( aSelf )

   201         {

   202         TWaitInfo* info = static_cast<TWaitInfo*>( aSelf );

   203         if( info->iPeriodic )

   204             {

   205             info->iPeriodic->Cancel();

   206             }

   207         if( info->iWait )

   208             {

   209             if( info->iWait->IsStarted() )

   210                 {

   211                 info->iWait->AsyncStop();

   212                 }

   213             }

   214         }

   215 

   216     return KErrNone;

   217     }

   218 

   219 /**

   220  * Helper method to wait current scheduler before teardown is completed.

   221  */

   222 LOCAL_C void Wait( TInt aIntervalInMicorseconds )

   223     {

   224     TWaitInfo info;

   225 

   226     // Construct periodic

   227     CPeriodic* periodic = CPeriodic::NewL( CActive::EPriorityStandard );

   228     CleanupStack::PushL( periodic );

   229     info.iPeriodic = periodic;

   230 

   231     // Construct active scheduler wait

   232     CActiveSchedulerWait* wait = new( ELeave ) CActiveSchedulerWait;

   233     CleanupStack::PushL( wait );

   234     info.iWait = wait;

   235 

   236     // Start timer and wait

   237     TCallBack cb( WaitCallBack, &info );

   238     periodic->Start( aIntervalInMicorseconds, aIntervalInMicorseconds, cb );

   239     wait->Start();

   240 

   241     // Cleanup

   242     CleanupStack::PopAndDestroy( wait );

   243     CleanupStack::PopAndDestroy( periodic );

   244     }

   245 

   246 const TInt KDelay = 2000000; // 2 seconds

   247 const TInt KConfigDelay = 4000;

   248 

   249 /**

   250  * Orders source command sender identities.

   251  * @param aFirst First source command sender id.

   252  * @param aSecond Second source command sender id.

   253  * @return Zero if the uid and the script id of the first and second are equal.

   254  *   Negative value if the uid of the first is less than the uid of the second

   255  *   or script id of the first is less than second's when uid are equal.

   256  *   Positive value if the uid of the first is greater than the uid of the

   257  *   second or script id of the first is greater than second's when uid are

   258  *   equal.

   259  */

   260  LOCAL_C TInt SourceCommandSenderIdOrder(

   261      const TCFSourceCommandSenderId& aFirst,

   262      const TCFSourceCommandSenderId& aSecond )

   263      {

   264      TInt orderValue = 1;

   265 

   266      if ( aFirst.iSender == aSecond.iSender )

   267          {

   268          if ( aFirst.iScriptId == aSecond.iScriptId )

   269              {

   270              orderValue = 0;

   271              }

   272          else if ( aFirst.iScriptId < aSecond.iScriptId )

   273              {

   274              orderValue = -1;

   275              }

   276          }

   277      else if ( aFirst.iSender < aSecond.iSender )

   278          {

   279          orderValue = -1;

   280          }

   281 

   282      return orderValue;

   283      }

   284 

   285 

   286 // CONSTRUCTION

   287 MT_CFClient* MT_CFClient::NewL( )

   288     {

   289     MT_CFClient* self = MT_CFClient::NewLC ( );

   290     CleanupStack::Pop ( );

   291 

   292     return self;

   293     }

   294 

   295 MT_CFClient* MT_CFClient::NewLC( )

   296     {

   297     MT_CFClient* self = new( ELeave ) MT_CFClient();

   298     CleanupStack::PushL ( self );

   299 

   300     self->ConstructL ( );

   301 

   302     return self;

   303     }

   304 

   305 // Destructor (virtual by CBase)

   306 MT_CFClient::~MT_CFClient( )

   307     {

   308     Teardown();

   309 

   310     // Enable screen saver

   311     CFEnvUtils::EnableScreenSaver( ETrue );

   312     }

   313 

   314 // Default constructor

   315 MT_CFClient::MT_CFClient( )

   316     {

   317     }

   318 

   319 // Second phase construct

   320 void MT_CFClient::ConstructL( )

   321     {

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

   323     // It generates the test case table.

   324     CEUnitTestSuiteClass::ConstructL ( );

   325 

   326     // Disable screen saver

   327     CFEnvUtils::EnableScreenSaver( EFalse );

   328     }

   329 

   330 //  METHODS

   331 

   332 void MT_CFClient::ContextIndicationL(const CCFContextIndication& aChangedContext )

   333     {

   334     if ( iCheckContextData )

   335         {

   336         CheckContextDataIndicationL ( aChangedContext );

   337         }

   338     else

   339         {

   340         CheckContextIndicationL ( aChangedContext );

   341         }

   342 

   343     // Common for both indications

   344     if ( iWait && !iCheckA && !iCheckB )

   345         {

   346         if ( iWait->IsStarted ( ) )

   347             {

   348             iWait->AsyncStop ( );

   349             }

   350         }

   351     if ( iDeleteClient )

   352         {

   353         delete iClient;

   354         iClient = NULL;

   355         iDeleteClient = EFalse;

   356         }

   357     }

   358 

   359 void MT_CFClient::ActionIndicationL(const CCFActionIndication& aActionToExecute )

   360     {

   361     TPtrC actionId( aActionToExecute.Identifier() );

   362     if ( iLastActionId )

   363         {

   364         delete iLastActionId;

   365         iLastActionId = NULL;

   366         }

   367     iLastActionId = actionId.AllocL();

   368 

   369     if ( iCheckA )

   370         {

   371         const RKeyValueArray& params = aActionToExecute.Parameters ( );

   372         EUNIT_ASSERT_DESC( actionId == KActionA,

   373             "Incorrect action identifier!" );

   374         EUNIT_ASSERT_DESC( params.Count() == 1,

   375             "Incorrect action param count!" )

   376         EUNIT_ASSERT_DESC( params[0]->Key() == KActionAParamA1,

   377             "Incorrect action param count!" )

   378         EUNIT_ASSERT_DESC( params[0]->Value() == KActionAValueA1,

   379             "Incorrect action param count!" )

   380         if ( iCountActionAIndications )

   381             {

   382             --iExpectedActionAIndicationCount;

   383             if ( !iExpectedActionAIndicationCount )

   384                 {

   385                 iCheckA = EFalse;

   386                 }

   387             }

   388         else

   389             {

   390             iCheckA = EFalse;

   391             }

   392         }

   393     else if ( iCheckB )

   394         {

   395         const RKeyValueArray& params = aActionToExecute.Parameters ( );

   396         EUNIT_ASSERT_DESC( actionId == KActionB,

   397             "Incorrect action identifier!" );

   398         EUNIT_ASSERT_DESC( params.Count() == 2,

   399             "Incorrect action param count!" )

   400         EUNIT_ASSERT_DESC( params[0]->Key() == KActionBParamB1,

   401             "Incorrect action param count!" )

   402         EUNIT_ASSERT_DESC( params[0]->Value() == KActionBValueB1,

   403             "Incorrect action param count!" )

   404         EUNIT_ASSERT_DESC( params[1]->Key() == KActionBParamB2,

   405             "Incorrect action param count!" )

   406         EUNIT_ASSERT_DESC( params[1]->Value() == KActionBValueB2,

   407             "Incorrect action param count!" )

   408         iCheckB = EFalse;

   409         }

   410     else if ( iCheckRegisterScriptAction )

   411         {

   412         const RKeyValueArray& params = aActionToExecute.Parameters ( );

   413         EUNIT_ASSERT_DESC( actionId == _L("RegisterScriptAction"),

   414             "Incorrect action identifier!" );

   415         EUNIT_ASSERT_DESC( params.Count() == 1,

   416             "Incorrect action param count!" )

   417         EUNIT_ASSERT_DESC( params[0]->Key() == _L("ParamA1"),

   418             "Incorrect action param count!" )

   419         EUNIT_ASSERT_DESC( params[0]->Value() == _L("ValueA1"),

   420             "Incorrect action param count!" )

   421         iCheckRegisterScriptAction = EFalse;

   422         }

   423     else if ( iCheckCustomAction )

   424         {

   425         EUNIT_ASSERT_DESC( iCustomActionId == actionId,

   426             "Incorrect action id" );

   427         const RKeyValueArray

   428             & params = aActionToExecute.Parameters ( );

   429         EUNIT_ASSERT_DESC( params.Count() == iCustomActionParams.Count(),

   430             "Invalid amount of action parameters" );

   431         for (TInt i = 0; i < iCustomActionParams.Count ( ); i++ )

   432             {

   433             CCFKeyValuePair* pair1 = iCustomActionParams[i];

   434             CCFKeyValuePair* pair2 = params[i];

   435             EUNIT_ASSERT_DESC( pair2->Key() == pair1->Key(),

   436                 "Invalid key" );

   437             EUNIT_ASSERT_DESC( pair2->Value() == pair1->Value(),

   438                 "Invalid value" );

   439             }

   440         iCheckCustomAction = EFalse;

   441         iCustomActionId.Zero ( );

   442         iCustomActionParams.ResetAndDestroy ( );

   443         }

   444 

   445     if ( iWait && !iCheckA && !iCheckB && !iCheckRegisterScriptAction &&!iCheckCustomAction )

   446         {

   447         if ( iWait->IsStarted ( ) )

   448             {

   449             iWait->AsyncStop ( );

   450             }

   451         }

   452 

   453     if ( iDeleteClient )

   454         {

   455         delete iClient;

   456         iClient = NULL;

   457         iDeleteClient = EFalse;

   458         }

   459     }

   460 

   461 void MT_CFClient::HandleContextFrameworkError( TCFError aError,

   462     const TDesC& aSource, const TDesC& aType )

   463     {

   464     if ( iCheckB )

   465         {

   466         EUNIT_ASSERT_DESC( aError == MCFListener::ESecurityCheckErrorForContextSubscription,

   467             "Incorrect HandleContextFrameworkError error code!" );

   468         EUNIT_ASSERT_DESC( aSource == iContextB->Source(),

   469             "Incorrect HandleContextFrameworkError context source!" );

   470         EUNIT_ASSERT_DESC( aType == iContextB->Type(),

   471             "Incorrect HandleContextFrameworkError context type!" );

   472         iCheckB = EFalse;

   473         }

   474     else if ( iCheckC )

   475         {

   476         EUNIT_ASSERT_DESC( aError == MCFListener::ESecurityCheckErrorForContextSubscription,

   477             "Incorrect HandleContextFrameworkError error code!" );

   478         EUNIT_ASSERT_DESC( aSource == iContextC->Source(),

   479             "Incorrect HandleContextFrameworkError context source!" );

   480         EUNIT_ASSERT_DESC( aType == iContextC->Type(),

   481             "Incorrect HandleContextFrameworkError context type!" );

   482         iCheckC = EFalse;

   483         }

   484     else if ( iCheckRomScriptContextAutoDefine )

   485         {

   486         EUNIT_ASSERT_DESC( aError == MCFListener::ESecurityCheckErrorForContextSubscription,

   487             "Incorrect HandleContextFrameworkError error code!" );

   488         EUNIT_ASSERT_DESC( aSource == KRomScriptAutoDefineContextSource,

   489             "Incorrect HandleContextFrameworkError context source!" );

   490         EUNIT_ASSERT_DESC( aType == KRomScriptAutoDefineContextType,

   491             "Incorrect HandleContextFrameworkError context type!" );

   492         iCheckRomScriptContextAutoDefine = EFalse;

   493         if ( iTestDelay )

   494             {

   495             iTestDelay->Stop();

   496             }

   497         }

   498 

   499     if ( iWait && !iCheckA && !iCheckB && !iCheckC && !iCheckRomScriptContextAutoDefine )

   500         {

   501         if ( iWait->IsStarted ( ) )

   502             {

   503             iWait->AsyncStop ( );

   504             }

   505         }

   506     }

   507 

   508 TAny* MT_CFClient::Extension( const TUid& aExtensionUid ) const

   509     {

   510     switch ( aExtensionUid.iUid )

   511         {

   512         case KCFContextSourceInterfaceUidValue:

   513             {

   514             if ( iReturnContextSourceInterface )

   515                 {

   516                 MCFContextSource* csinterface = (MCFContextSource*) this;

   517                 return (TAny*) csinterface;

   518                 }

   519             break;

   520             }

   521         default:

   522             {

   523             return NULL;

   524             }

   525         }

   526     return NULL;

   527     }

   528 

   529 // from MCFContextSource

   530 void MT_CFClient::Subscribers( const TDesC& aContextSource,

   531     const TDesC& aContextType )

   532     {

   533     if ( iCheckSubscribersNoSubscribersCalled )

   534         {

   535         iCheckSubscribersNoSubscribersCalled = EFalse;

   536         iSubscribersCalled = ETrue;

   537         EUNIT_ASSERT_DESC(

   538                 iExpectedSubscribersSource.Compare( aContextSource ) == 0,

   539                 "No expected source");

   540         EUNIT_ASSERT_DESC(

   541                 iExpectedSubscribersType.Compare( aContextType ) == 0,

   542                 "No expected type");

   543 

   544         if ( iWait )

   545             {

   546             if ( iWait->IsStarted ( ) )

   547                 {

   548                 iWait->AsyncStop ( );

   549                 }

   550             }

   551         }

   552     }

   553 

   554 // from MCFContextSource

   555 void MT_CFClient::NoSubscribers( const TDesC& aContextSource,

   556     const TDesC& aContextType )

   557     {

   558     if ( iCheckSubscribersNoSubscribersCalled )

   559         {

   560         iCheckSubscribersNoSubscribersCalled = EFalse;

   561         iNoSubscribersCalled = ETrue;

   562         EUNIT_ASSERT_DESC(

   563                 iExpectedSubscribersSource.Compare( aContextSource ) == 0,

   564                 "No expected source");

   565         EUNIT_ASSERT_DESC(

   566                 iExpectedSubscribersType.Compare( aContextType ) == 0,

   567                 "No expected type");

   568 

   569         if ( iWait )

   570             {

   571             if ( iWait->IsStarted ( ) )

   572                 {

   573                 iWait->AsyncStop ( );

   574                 }

   575             }

   576         }

   577     }

   578 

   579 // from MCFContextSource

   580 void MT_CFClient::HandleCommand( const CCFContextSourceCommand& aCommand )

   581     {

   582     TPtrC id( aCommand.Name() );

   583     EUNIT_ASSERT_DESC( id.CompareF( KSourceCommandId ) == 0,

   584             "No expected source command id" );

   585 

   586     // Parse context source command

   587     const RKeyValueArray& attributes = aCommand.Attributes();

   588     EUNIT_ASSERT_DESC( attributes.Count() == 1, "No expected attribute count" );

   589 

   590     TUid sourceUid = aCommand.SourceUid();

   591     RThread thread;

   592     EUNIT_ASSERT_DESC( sourceUid == thread.SecureId(), "No expected uid" );

   593     thread.Close();

   594 

   595     const RSourceCommandParameterArray& params = aCommand.Parameters();

   596     EUNIT_ASSERT_DESC( params.Count() >= 1, "No expected parameter count" );

   597 

   598     TPtrC paramName( params[ 0 ]->Name() );

   599     EUNIT_ASSERT_DESC( paramName.CompareF( KSourceCommandParamCmd ) == 0,

   600             "No expected param name" );

   601 

   602     const RKeyValueArray& paramAttributes = params[ 0 ]->Attributes();

   603     EUNIT_ASSERT_DESC( paramAttributes.Count() == 1, "No expected parameter attribute count" );

   604 

   605     CCFKeyValuePair* keyValuePair = paramAttributes[ 0 ];

   606     EUNIT_ASSERT_DESC( keyValuePair->Key().CompareF(

   607             KSourceCommandAttributeType ) == 0,

   608             "Type attribute expected" );

   609 

   610     TLinearOrder< TCFSourceCommandSenderId > cmdSenderOrder(

   611             SourceCommandSenderIdOrder );

   612     TCFSourceCommandSenderId sender = aCommand.Sender();

   613     TInt pos = iActiveRequests.FindInOrder( sender, cmdSenderOrder );

   614 

   615     TPtrC cmdType( keyValuePair->Value() );

   616     if ( cmdType.CompareF( KSourceCommandAttributeValueActivate ) == 0 )

   617         {

   618         if ( pos == KErrNotFound )

   619             {

   620             iActiveRequests.InsertInOrder( sender, cmdSenderOrder );

   621             }

   622         CheckActivateSourceCommandParams( params );

   623         }

   624     else if ( cmdType.CompareF( KSourceCommandAttributeValueDeactivate ) == 0 )

   625         {

   626         if ( pos != KErrNotFound )

   627             {

   628             iActiveRequests.Remove( pos );

   629             }

   630         CheckDeactivateSourceCommandParams( params );

   631         }

   632     else

   633         {

   634         EUNIT_ASSERT_DESC( EFalse, "WRONG type attribute value" );

   635         }

   636 

   637     iHandleCommandCalled = ETrue;

   638 

   639     if ( iWait && iWait->IsStarted() )

   640         {

   641         iWait->AsyncStop ( );

   642         }

   643     }

   644 

   645 void MT_CFClient::CheckActivateSourceCommandParams(

   646     const RSourceCommandParameterArray& aParams )

   647     {

   648     EUNIT_ASSERT_DESC( aParams.Count() == 2, "No expected param count" );

   649 

   650     // Check 1. param

   651     CCFContextSourceCommandParameter* param = aParams[ 0 ];

   652     TPtrC paramName( param->Name() );

   653     EUNIT_ASSERT_DESC( paramName.CompareF( KSourceCommandParamCmd ) == 0,

   654             "No expected param name" );

   655 

   656     // Check 1. param attributes

   657     const RKeyValueArray& attributes = param->Attributes();

   658     EUNIT_ASSERT_DESC( attributes.Count() == 1, "No expected attribute count" );

   659     CCFKeyValuePair* keyValuePair = attributes[ 0 ];

   660     EUNIT_ASSERT_DESC( keyValuePair->Key().CompareF(

   661             KSourceCommandAttributeType ) == 0,

   662             "Type attribute expected" );

   663     EUNIT_ASSERT_DESC( keyValuePair->Value().CompareF(

   664             KSourceCommandAttributeValueActivate ) == 0,

   665             "No expected type attribute value" );

   666 

   667     // Check 1. param nested params

   668     const RSourceCommandParameterArray& nestedParams = param->Parameters();

   669     EUNIT_ASSERT_DESC( nestedParams.Count() == 2, "No expected nested parameter count" );

   670 

   671     // Check 1. param 1. nested params attributes

   672     CCFContextSourceCommandParameter* nestedParam = nestedParams[ 0 ];

   673     EUNIT_ASSERT_DESC( nestedParam->Name().CompareF(

   674             KSourceCommandParamCmdParam ) == 0,

   675             "Parameter cmdParam expected" );

   676     const RKeyValueArray& nestedParamAttributes = nestedParam->Attributes();

   677     EUNIT_ASSERT_DESC( nestedParamAttributes.Count() == 1,

   678             "No expected nested parameter attribute count" );

   679     keyValuePair = nestedParamAttributes[ 0 ];

   680     EUNIT_ASSERT_DESC( keyValuePair->Key().CompareF(

   681             KSourceCommandAttributeMode ) == 0,

   682             "Mode attribute expected" );

   683     EUNIT_ASSERT_DESC( keyValuePair->Value().CompareF(

   684             KSourceCommandAttributeValueClean ) == 0,

   685             "No expected mode attribute value" );

   686 

   687     // Check 1. param 1. nested params parameters

   688     const RSourceCommandParameterArray& nested2Params = nestedParam->Parameters();

   689     EUNIT_ASSERT_DESC( nested2Params.Count() == 1, "No expected nested parameter count" );

   690 

   691     // Check 1. param 1. nested params parameters attributes

   692     nestedParam = nested2Params[ 0 ];

   693     EUNIT_ASSERT_DESC( nestedParam->Name().CompareF(

   694             KSourceCommandParamModifiers ) == 0,

   695             "Modifiers param expected" );

   696     const RKeyValueArray& nested2ParamAttributes = nestedParam->Attributes();

   697     EUNIT_ASSERT_DESC( nested2ParamAttributes.Count() == 1,

   698             "No expected nested parameter attribute count" );

   699     keyValuePair = nested2ParamAttributes[ 0 ];

   700     EUNIT_ASSERT_DESC( keyValuePair->Key().CompareF(

   701             KSourceCommandAttributeValue ) == 0,

   702             "Value attribute expected" );

   703     EUNIT_ASSERT_DESC( keyValuePair->Value().CompareF(

   704             KSourceCommandAttributeValueReally ) == 0,

   705             "No expected value attribute value" );

   706 

   707     const RSourceCommandParameterArray& nested3Params = nestedParam->Parameters();

   708     EUNIT_ASSERT_DESC( nested3Params.Count() == 0, "No expected nested parameter count" );

   709 

   710     // Check 1. param 2. nested params attributes

   711     nestedParam = nestedParams[ 1 ];

   712     EUNIT_ASSERT_DESC( nestedParam->Name().CompareF(

   713             KSourceCommandParamCmdParam ) == 0,

   714             "Parameter cmdParam expected" );

   715     const RKeyValueArray& nested3ParamAttributes = nestedParam->Attributes();

   716     EUNIT_ASSERT_DESC( nested3ParamAttributes.Count() == 1,

   717             "No expected nested parameter attribute count" );

   718     keyValuePair = nested3ParamAttributes[ 0 ];

   719     EUNIT_ASSERT_DESC( keyValuePair->Key().CompareF(

   720             KSourceCommandAttributeOverride ) == 0,

   721             "Override attribute expected" );

   722     EUNIT_ASSERT_DESC( keyValuePair->Value().CompareF(

   723             KSourceCommandAttributeValueYes ) == 0,

   724             "No expected override attribute value" );

   725 

   726     const RSourceCommandParameterArray& nested4Params = nestedParam->Parameters();

   727     EUNIT_ASSERT_DESC( nested4Params.Count() == 0, "No expected nested parameter count" );

   728 

   729     // Check 2. param

   730     param = aParams[ 1 ];

   731     paramName.Set( param->Name() );

   732     EUNIT_ASSERT_DESC( paramName.CompareF( KSourceCommandParamCmdInfo ) == 0,

   733             "No expected param name" );

   734 

   735     // Check 2. param attributes

   736     const RKeyValueArray& attributes2 = param->Attributes();

   737     EUNIT_ASSERT_DESC( attributes2.Count() == 1, "No expected attribute count" );

   738     keyValuePair = attributes2[ 0 ];

   739     EUNIT_ASSERT_DESC( keyValuePair->Key().CompareF(

   740             KSourceCommandAttributeType ) == 0,

   741             "Type attribute expected" );

   742     EUNIT_ASSERT_DESC( keyValuePair->Value().CompareF(

   743             KSourceCommandAttributeValueActivate ) == 0,

   744             "No expected type attribute value" );

   745 

   746     // Check 2. param nested params

   747     const RSourceCommandParameterArray& nestedParams2 = param->Parameters();

   748     EUNIT_ASSERT_DESC( nestedParams2.Count() == 1, "No expected nested parameter count" );

   749 

   750     // Check 2. param nested params attributes

   751     nestedParam = nestedParams2[ 0 ];

   752     EUNIT_ASSERT_DESC( nestedParam->Name().CompareF(

   753             KSourceCommandParamCmdParam ) == 0,

   754             "Parameter cmdParam expected" );

   755     const RKeyValueArray& nestedParamAttributes2 = nestedParam->Attributes();

   756     EUNIT_ASSERT_DESC( nestedParamAttributes2.Count() == 1,

   757             "No expected nested parameter attribute count" );

   758     keyValuePair = nestedParamAttributes2[ 0 ];

   759     EUNIT_ASSERT_DESC( keyValuePair->Key().CompareF(

   760             KSourceCommandAttributeText ) == 0,

   761             "Text attribute expected" );

   762     EUNIT_ASSERT_DESC( keyValuePair->Value().CompareF(

   763             KSourceCommandAttributeValueText ) == 0,

   764             "No expected text attribute value" );

   765 

   766     // Check 2. param 1. nested params parameters

   767     const RSourceCommandParameterArray& nested2Params2 = nestedParam->Parameters();

   768     EUNIT_ASSERT_DESC( nested2Params2.Count() == 0, "No expected nested parameter count" );

   769     }

   770 

   771 void MT_CFClient::CheckDeactivateSourceCommandParams(

   772     const RSourceCommandParameterArray& aParams )

   773     {

   774     EUNIT_ASSERT_DESC( aParams.Count() == 1, "No expected param count" );

   775 

   776     // Check param

   777     CCFContextSourceCommandParameter* param = aParams[ 0 ];

   778     TPtrC paramName( param->Name() );

   779     EUNIT_ASSERT_DESC( paramName.CompareF( KSourceCommandParamCmd ) == 0,

   780             "No expected param name" );

   781 

   782     // Check param attributes

   783     const RKeyValueArray& attributes = param->Attributes();

   784     EUNIT_ASSERT_DESC( attributes.Count() == 1, "No expected attribute count" );

   785     CCFKeyValuePair* keyValuePair = attributes[ 0 ];

   786     EUNIT_ASSERT_DESC( keyValuePair->Key().CompareF(

   787             KSourceCommandAttributeType ) == 0,

   788             "Type attribute expected" );

   789     EUNIT_ASSERT_DESC( keyValuePair->Value().CompareF(

   790             KSourceCommandAttributeValueDeactivate ) == 0,

   791             "No expected type attribute value" );

   792 

   793     // Check param nested params

   794     const RSourceCommandParameterArray& nestedParams = param->Parameters();

   795     EUNIT_ASSERT_DESC( nestedParams.Count() == 1, "No expected nested parameter count" );

   796 

   797     // Check param nested params attributes

   798     CCFContextSourceCommandParameter* nestedParam = nestedParams[ 0 ];

   799     EUNIT_ASSERT_DESC( nestedParam->Name().CompareF(

   800             KSourceCommandParamCmdParam ) == 0,

   801             "Parameter cmdParam expected" );

   802     const RKeyValueArray& nestedParamAttributes = nestedParam->Attributes();

   803     EUNIT_ASSERT_DESC( nestedParamAttributes.Count() == 1,

   804             "No expected nested parameter attribute count" );

   805     keyValuePair = nestedParamAttributes[ 0 ];

   806     EUNIT_ASSERT_DESC( keyValuePair->Key().CompareF(

   807             KSourceCommandAttributeMode ) == 0,

   808             "Mode attribute expected" );

   809     EUNIT_ASSERT_DESC( keyValuePair->Value().CompareF(

   810             KSourceCommandAttributeValueFull ) == 0,

   811             "No expected mode attribute value" );

   812 

   813     // Check param nested params parameters

   814     const RSourceCommandParameterArray& nested2Params = nestedParam->Parameters();

   815     EUNIT_ASSERT_DESC( nested2Params.Count() == 1, "No expected nested parameter count" );

   816 

   817     // Check param nested params parameters attributes

   818     nestedParam = nested2Params[ 0 ];

   819     EUNIT_ASSERT_DESC( nestedParam->Name().CompareF(

   820             KSourceCommandParamModifiers ) == 0,

   821             "Modifiers param expected" );

   822     const RKeyValueArray& nested2ParamAttributes = nestedParam->Attributes();

   823     EUNIT_ASSERT_DESC( nested2ParamAttributes.Count() == 1,

   824             "No expected nested parameter attribute count" );

   825     keyValuePair = nested2ParamAttributes[ 0 ];

   826     EUNIT_ASSERT_DESC( keyValuePair->Key().CompareF(

   827             KSourceCommandAttributeValue ) == 0,

   828             "Value attribute expected" );

   829     EUNIT_ASSERT_DESC( keyValuePair->Value().CompareF(

   830             KSourceCommandAttributeValueNoException ) == 0,

   831             "No expected value attribute value" );

   832 

   833     const RSourceCommandParameterArray& nested3Params = nestedParam->Parameters();

   834     EUNIT_ASSERT_DESC( nested3Params.Count() == 0, "No expected nested parameter count" );

   835     }

   836 

   837 

   838 void MT_CFClient::SetupL( )

   839     {

   840     }

   841 

   842 void MT_CFClient::SetupClientL( )

   843     {

   844     User::LeaveIfError ( iFs.Connect ( ) );

   845     iClient = CCFClient::NewL ( *this );

   846     iAnotherClient = CCFClient::NewL ( *this );

   847     iContextA = CCFContextObject::NewL ( );

   848     iContextB = CCFContextObject::NewL ( );

   849     iContextC = CCFContextObject::NewL ( );

   850     iWait = new( ELeave ) CActiveSchedulerWait;

   851     iContextDataA = CTestContextData::NewL ( _L("Key_A"), _L("Value_A") );

   852     iContextDataB = CTestContextData::NewL ( _L("Key_B"), _L("Value_B") );

   853     }

   854 

   855 void MT_CFClient::SetupNewClientL( )

   856     {

   857     iReturnContextSourceInterface = ETrue;

   858     iTestDelay = CCFTestDelay::NewL ( );

   859     SetupClientL ( );

   860     }

   861 

   862 void MT_CFClient::SetupSourceSettingTestClientL( )

   863     {

   864     iTestDelay = CCFTestDelay::NewL ( );

   865     SetupClientL ( );

   866     }

   867 

   868 void MT_CFClient::Teardown( )

   869     {

   870     if ( iWait )

   871         {

   872         if ( iWait->IsStarted ( ) )

   873             {

   874             iWait->AsyncStop ( );

   875             }

   876         delete iWait;

   877         iWait = NULL;

   878         }

   879 

   880     delete iClient;

   881     iClient = NULL;

   882 

   883     delete iAnotherClient;

   884     iAnotherClient = NULL;

   885 

   886     delete iContextA;

   887     iContextA = NULL;

   888 

   889     delete iContextB;

   890     iContextB = NULL;

   891 

   892     delete iContextC;

   893     iContextC = NULL;

   894     iFs.Close ( );

   895 

   896     delete iContextDataA;

   897     iContextDataA = NULL;

   898 

   899     delete iContextDataB;

   900     iContextDataB = NULL;

   901 

   902     iReturnContextSourceInterface = EFalse;

   903 

   904     iCustomActionParams.ResetAndDestroy();

   905 

   906     delete iLastActionId;

   907     iLastActionId = NULL;

   908 

   909     iActiveRequests.Close();

   910 

   911     if ( iTestDelay )

   912         {

   913         // Give some time for everything to be cleaned up.

   914         iTestDelay->Start ( 100000 ); // 100 ms

   915         }

   916 

   917     delete iTestDelay;

   918     iTestDelay = NULL;

   919     }

   920 

   921 void MT_CFClient::TeardownAndScriptCleanup( )

   922     {

   923     iClient->DeleteScripts ( );

   924     iClient->RestoreRomScript ( _L("test-scriptUpgradeRom") );

   925     iClient->RestoreRomScript ( _L("test-scriptUpgradeRomClientMissingCapability") );

   926     Teardown ( );

   927     }

   928 

   929 void MT_CFClient::CheckContextIndicationL(

   930     const CCFContextIndication& aChangedContext )

   931     {

   932     if ( iCheckA )

   933         {

   934         const CCFContextObject& co = aChangedContext.Context ( );

   935         EUNIT_ASSERT_DESC( co.Source() == iContextA->Source(),

   936             "Incorrect context source in context indication!" );

   937         EUNIT_ASSERT_DESC( co.Type() == iContextA->Type(),

   938             "Incorrect context type in context indication!" );

   939         EUNIT_ASSERT_DESC( co.Value() == iContextA->Value(),

   940             "Incorrect context value in context indication!" );

   941         iCheckA = EFalse;

   942         }

   943     else if ( iCheckB )

   944         {

   945         const CCFContextObject& co = aChangedContext.Context ( );

   946         EUNIT_ASSERT_DESC( co.Source() == iContextB->Source(),

   947             "Incorrect context source in context indication!" );

   948         EUNIT_ASSERT_DESC( co.Type() == iContextB->Type(),

   949             "Incorrect context type in context indication!" );

   950         EUNIT_ASSERT_DESC( co.Value() == iContextB->Value(),

   951             "Incorrect context value in context indication!" );

   952         iCheckB = EFalse;

   953         }

   954     else if ( iCheckPluginSubscribersCalled )

   955         {

   956         const CCFContextObject& co = aChangedContext.Context ( );

   957         EUNIT_ASSERT_DESC( iExpectedSubscribersSource == co.Source(),

   958             "No expected plugin subscriber source");

   959         EUNIT_ASSERT_DESC( iExpectedSubscribersType == co.Type(),

   960             "No expected plugin subscriber type");

   961         EUNIT_ASSERT_DESC( iExpectedSubscribersValue == co.Value(),

   962             "No expected plugin subscriber value");

   963 

   964         iPluginSubscribersCalled = ETrue;

   965         iCheckPluginSubscribersCalled = EFalse;

   966 

   967         if ( iWait && iWait->IsStarted ( ) )

   968             {

   969             iWait->AsyncStop ( );

   970             }

   971         }

   972     else if ( iCheckSourceCommandHandled )

   973         {

   974         const CCFContextObject& co = aChangedContext.Context ( );

   975         EUNIT_ASSERT_DESC( iExpectedSubscribersSource == co.Source(),

   976             "No expected source command signal context source");

   977         EUNIT_ASSERT_DESC( iExpectedSubscribersType == co.Type(),

   978             "No expected source command signal context type");

   979         EUNIT_ASSERT_DESC( iExpectedSubscribersValue == co.Value(),

   980             "No expected source command signal context value");

   981 

   982         iSourceCommandHandled = ETrue;

   983         iCheckSourceCommandHandled = EFalse;

   984 

   985         if ( iWait && iWait->IsStarted ( ) )

   986             {

   987             iWait->AsyncStop ( );

   988             }

   989         }

   990     else if ( iCheckRomScriptContextAutoDefineDetected )

   991         {

   992         const CCFContextObject& co = aChangedContext.Context ( );

   993         EUNIT_ASSERT_DESC( iExpectedSubscribersSource == co.Source(),

   994             "No expected source command signal context source");

   995         EUNIT_ASSERT_DESC( iExpectedSubscribersType == co.Type(),

   996             "No expected source command signal context type");

   997         EUNIT_ASSERT_DESC( iExpectedSubscribersValue == co.Value(),

   998             "No expected source command signal context value");

   999 

  1000         iCheckRomScriptContextAutoDefineDetected = EFalse;

  1001 

  1002         if ( iWait && iWait->IsStarted ( ) )

  1003             {

  1004             iWait->AsyncStop ( );

  1005             }

  1006         }

  1007     }

  1008 

  1009 void MT_CFClient::CheckContextDataIndicationL(

  1010     const CCFContextIndication& aChangedContext )

  1011     {

  1012     if ( iCheckA )

  1013         {

  1014         // Check context

  1015         const CCFContextObject& co = aChangedContext.Context ( );

  1016         EUNIT_ASSERT_DESC( co.Source() == iContextA->Source(),

  1017             "Incorrect context source in context indication!" );

  1018         EUNIT_ASSERT_DESC( co.Type() == iContextA->Type(),

  1019             "Incorrect context type in context indication!" );

  1020         EUNIT_ASSERT_DESC( co.Value() == iContextA->Value(),

  1021             "Incorrect context value in context indication!" );

  1022 

  1023         // Check data object

  1024         EUNIT_ASSERT_DESC( aChangedContext.Uid() == KTestContextDataUid,

  1025             "Incorrect context data UID!" );

  1026         if ( aChangedContext.Uid ( )== KTestContextDataUid )

  1027             {

  1028             CCFContextIndication

  1029                 & indication =const_cast<CCFContextIndication&>( aChangedContext );

  1030             CTestContextData* contextData =CTestContextData::NewLC ( KNullDesC,

  1031                 KNullDesC );

  1032             indication.CreateDataObjectL ( *contextData );

  1033             EUNIT_ASSERT_DESC( contextData->Key() == iContextDataA->Key(),

  1034                 "Incorrect context data object comparison!" );

  1035             EUNIT_ASSERT_DESC( contextData->Value() == iContextDataA->Value(),

  1036                 "Incorrect context data object comparison!" );

  1037             CleanupStack::PopAndDestroy ( contextData );

  1038             }

  1039         iCheckA = EFalse;

  1040         }

  1041     else if ( iCheckB )

  1042         {

  1043         // Check context

  1044         const CCFContextObject& co = aChangedContext.Context ( );

  1045         EUNIT_ASSERT_DESC( co.Source() == iContextB->Source(),

  1046             "Incorrect context source in context indication!" );

  1047         EUNIT_ASSERT_DESC( co.Type() == iContextB->Type(),

  1048             "Incorrect context type in context indication!" );

  1049         EUNIT_ASSERT_DESC( co.Value() == iContextB->Value(),

  1050             "Incorrect context value in context indication!" );

  1051 

  1052         // Check data object

  1053         EUNIT_ASSERT_DESC( aChangedContext.Uid() == KTestContextDataUid,

  1054             "Incorrect context data UID!" );

  1055         if ( aChangedContext.Uid ( )== KTestContextDataUid )

  1056             {

  1057             CCFContextIndication

  1058                 & indication =const_cast<CCFContextIndication&>( aChangedContext );

  1059             CTestContextData* contextData =CTestContextData::NewLC (

  1060                 KNullDesC, KNullDesC );

  1061             indication.CreateDataObjectL ( *contextData );

  1062             EUNIT_ASSERT_DESC( contextData->Key() == iContextDataB->Key(),

  1063                 "Incorrect context data object comparison!" );

  1064             EUNIT_ASSERT_DESC( contextData->Value() == iContextDataB->Value(),

  1065                 "Incorrect context data object comparison!" );

  1066             CleanupStack::PopAndDestroy ( contextData );

  1067             }

  1068         iCheckB = EFalse;

  1069         }

  1070     }

  1071 

  1072 void MT_CFClient::ConfigureContextL( CCFContextObject& aContext )

  1073     {

  1074     Wait ( KConfigDelay );

  1075 

  1076     TBuf<256> buf( KNullDesC );

  1077     TTime time;

  1078     time.HomeTime ( );

  1079 

  1080     buf.Format ( KContextSourceFormat, time.Int64 ( ) );

  1081     aContext.SetSourceL ( buf );

  1082 

  1083     buf.Format ( KContextTypeFormat, time.Int64 ( ) );

  1084     aContext.SetTypeL ( buf );

  1085 

  1086     buf.Format ( KContextValueFormat, time.Int64 ( ) );

  1087     aContext.SetValueL ( buf );

  1088     }

  1089 

  1090 void MT_CFClient::UpdateContextValueL( CCFContextObject& aContext )

  1091     {

  1092     Wait ( KConfigDelay );

  1093 

  1094     TBuf<256> buf( KNullDesC );

  1095     TTime time;

  1096     time.HomeTime ( );

  1097 

  1098     buf.Format ( KContextValueFormat, time.Int64 ( ) );

  1099     aContext.SetValueL ( buf );

  1100     }

  1101 

  1102 void MT_CFClient::UpdateContextTypeL( CCFContextObject& aContext )

  1103     {

  1104     Wait ( KConfigDelay );

  1105 

  1106     TBuf<256> buf( KNullDesC );

  1107     TTime time;

  1108     time.HomeTime ( );

  1109 

  1110     buf.Format ( KContextTypeFormat, time.Int64 ( ) );

  1111     aContext.SetTypeL ( buf );

  1112     }

  1113 

  1114 HBufC* MT_CFClient::ConfigureActionIdLC( )

  1115     {

  1116     Wait ( KConfigDelay );

  1117 

  1118     TTime time;

  1119     time.HomeTime ( );

  1120     HBufC* actionId = HBufC::NewLC ( 256 );

  1121     TPtr actionIdPtr = actionId->Des ( );

  1122     actionIdPtr.Format ( KActionIdFormat, time.Int64 ( ) );

  1123 

  1124     return actionId;

  1125     }

  1126 

  1127 HBufC8* MT_CFClient::LoadScriptFromFile( const TDesC& aFilePath )

  1128     {

  1129     HBufC8* script=  NULL;

  1130     RFile file;

  1131     TFileName fileName;

  1132     fileName.Copy (_L("z:\\data\\cftestdata\\testscripts\\") );

  1133     fileName.Append (aFilePath );

  1134     TInt err = file.Open ( iFs, fileName, EFileRead );