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 //  CLASS HEADER

    20 #include "MT_CFScriptEngine.h"

    21 

    22 //  EXTERNAL INCLUDES

    23 #include <EUnitMacros.h>

    24 #include <ECom/ECom.h>

    25 #include <bautils.h>

    26 

    27 #include "CFContextSubscription.h"

    28 #include "CFContextSubscriptionImpl.h"

    29 #include "CFContextObject.h"

    30 #include "CFContextObjectImpl.h"

    31 #include "CFScriptHandler.h"

    32 

    33 //  INTERNAL INCLUDES

    34 #include "CFTestDelay.h"

    35 #include "cffakeenv.h"

    36 #include "ScriptEventNotifierSession.h"

    37 #include "basicoperationspluginconst.hrh"

    38 #include "cfcommon.h"

    39 #include "cfenvutils.h"

    40 

    41 // CONSTANTS

    42 

    43 const TUid KMT_CfScriptEngineUid = {0x7E577E57};

    44 const TUid KMT_CfScriptEngineOtherUid = {0x074E074E};

    45 const TUid KCFServerUid = {0x10282BC4};

    46 

    47 _LIT( KCFPrivateFolder, "c:\\private\\10282BC4\\rules\\" );

    48 

    49 // CONSTRUCTION

    50 MT_CFScriptEngine* MT_CFScriptEngine::NewL()

    51     {

    52     MT_CFScriptEngine* self = MT_CFScriptEngine::NewLC();

    53     CleanupStack::Pop();

    54 

    55     return self;

    56     }

    57 

    58 MT_CFScriptEngine* MT_CFScriptEngine::NewLC()

    59     {

    60     MT_CFScriptEngine* self = new( ELeave ) MT_CFScriptEngine();

    61     CleanupStack::PushL( self );

    62 

    63     self->ConstructL();

    64 

    65     return self;

    66     }

    67 

    68 // Destructor (virtual by CBase)

    69 MT_CFScriptEngine::~MT_CFScriptEngine()

    70     {

    71     // Enable screen saver

    72     CFEnvUtils::EnableScreenSaver( ETrue );

    73     }

    74 

    75 // Default constructor

    76 MT_CFScriptEngine::MT_CFScriptEngine()

    77     {

    78     }

    79 

    80 // Second phase construct

    81 void MT_CFScriptEngine::ConstructL()

    82     {

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

    84     // It generates the test case table.

    85     CEUnitTestSuiteClass::ConstructL();

    86 

    87     // Disable screen saver

    88     CFEnvUtils::EnableScreenSaver( EFalse );

    89     }

    90 

    91 

    92 //  METHODS

    93 

    94 void MT_CFScriptEngine::SetupEmptyL(  )

    95     {

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

    97     BaflUtils::EnsurePathExistsL( iFs, KCFPrivateFolder );

    98     iFileMan = CFileMan::NewL( iFs );

    99     iTestDelay = CCFTestDelay::NewL();

   100     }

   101 

   102 void MT_CFScriptEngine::SetupL(  )

   103     {

   104     SetupEmptyL();

   105 

   106     iDummyScriptEngineSession = CScriptEventNotifierSession::NewL();

   107 

   108     iCFFakeEnv = CCFFakeEnv::NewL();    

   109     }

   110 

   111 void MT_CFScriptEngine::Teardown(  )

   112     {

   113     TeardownNoFinalClose();

   114     

   115 #ifdef __WINS__

   116     REComSession::FinalClose();

   117 #endif

   118     }

   119 

   120 void MT_CFScriptEngine::TeardownNoFinalClose(  )

   121     {    

   122     iTestDelay->Start(100000); // 0.1 seconds

   123 

   124     delete iDummyScriptEngineSession;

   125     iDummyScriptEngineSession = NULL;

   126 

   127     iTestDelay->Start(100000); // 0.1 seconds

   128     delete iTestDelay;

   129     iTestDelay = NULL;

   130 

   131     delete iCFFakeEnv;

   132     iCFFakeEnv = NULL;

   133 

   134     CleanupSystemDrive();

   135     delete iFileMan;

   136     

   137     iFs.Close();

   138     }

   139 

   140 // -----------------------------------------------------------------------------

   141 // MT_CFScriptEngine::LoadScriptFromFile

   142 // -----------------------------------------------------------------------------

   143 //

   144 HBufC8* MT_CFScriptEngine::LoadScriptFromFile( const TDesC& aFilePath )

   145     {

   146     HBufC8* script = NULL;

   147     RFile file;

   148     TFileName fileName;

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

   150     fileName.Append(aFilePath);

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

   152     if( err == KErrNone )

   153         {

   154         TInt size = 0;

   155         err = file.Size( size );

   156         if( err == KErrNone )

   157             {

   158             script = HBufC8::New( size );

   159             if( script )

   160                 {

   161                 TPtr8 scriptPtr = script->Des();

   162                 err = file.Read( scriptPtr );

   163                 if( err == KErrNone )

   164                     {

   165                     // Strip all unnecassary data from script

   166                     TInt pos = scriptPtr.FindF( KScriptStartTag );

   167                     if( pos != KErrNotFound )

   168                         {

   169                         scriptPtr.Copy( scriptPtr.MidTPtr( pos ) );

   170                         }

   171                     else

   172                         {

   173                         // Incorrect script

   174                         delete script;

   175                         script = NULL;

   176                         }

   177                     }

   178                 else

   179                     {

   180                     delete script;

   181                     script = NULL;

   182                     }

   183                 }

   184             }

   185         }

   186 

   187     // Cleanup

   188     file.Close();

   189     return script;

   190     }

   191 

   192 

   193 TInt MT_CFScriptEngine::FindParameter(const RKeyValueArray& aArray,

   194     const TDesC& aKey, const TDesC& aValue)

   195     {

   196     TInt index = KErrNotFound;

   197     TBool found = EFalse;

   198     for (TInt i = 0; i < aArray.Count(); i++)

   199         {

   200         if ( aArray[i]->Key() == aKey )

   201             {

   202             if ( index == KErrNotFound )

   203                 {

   204                 index = i;

   205                 if ( aArray[i]->Value() == aValue )

   206                     {

   207                     found = ETrue;

   208                     }

   209                 else

   210                     {

   211                     return -3; // found but wrong value!

   212                     }

   213                 }

   214             else

   215                 {

   216                 index = -2; // Duplicate found!

   217                 }

   218             }

   219         }

   220     if (found)

   221         {

   222         return index;

   223         }

   224     return KErrNotFound;

   225     }

   226 

   227 

   228 TInt MT_CFScriptEngine::FindIndex( const RArray<TInt>& aArray, TInt aIndex )

   229     {

   230     TInt index = KErrNotFound;

   231     TBool found = EFalse;

   232     for (TInt i = 0; i < aArray.Count(); i++)

   233         {

   234         if ( aArray[i] == aIndex )

   235             {

   236             if ( index == KErrNotFound )

   237                 {

   238                 index = i;

   239                 found = ETrue;

   240                 }

   241             else

   242                 {

   243                 index = -2; // Duplicate found!

   244                 }

   245             }

   246         }

   247     if (found)

   248         {

   249         return index;

   250         }

   251     return KErrNotFound;

   252     }

   253 

   254 

   255 void MT_CFScriptEngine::CleanupSystemDrive()

   256     {

   257     iFileMan->RmDir( KCFPrivateFolder );

   258     }

   259 

   260 

   261 void MT_CFScriptEngine::MT_CCFScriptEvent_NewLL(  )

   262     {

   263     EUNIT_ASSERT_DESC( EFalse, "Test case not implemented!" );

   264     }

   265 

   266 void MT_CFScriptEngine::MT_CCFScriptEvent_ScriptIdL(  )

   267     {

   268     EUNIT_ASSERT_DESC( EFalse, "Test case not implemented!" );

   269     }

   270 

   271 void MT_CFScriptEngine::MT_CCFScriptEvent_IdentifierL(  )

   272     {

   273     EUNIT_ASSERT_DESC( EFalse, "Test case not implemented!" );

   274     }

   275 

   276 void MT_CFScriptEngine::MT_CCFScriptEvent_ParametersL(  )

   277     {

   278     EUNIT_ASSERT_DESC( EFalse, "Test case not implemented!" );

   279     }

   280 

   281 void MT_CFScriptEngine::MT_CCFScriptHandler_NewLL(  )

   282     {

   283     // below                                        // CLEANUP<< fakeEnv

   284     CCFFakeEnv* fakeEnv = CCFFakeEnv::NewLC();

   285 

   286     CCFScriptHandler* instance

   287         = CCFScriptHandler::NewL( *fakeEnv, iFs, *fakeEnv, *fakeEnv );

   288     CleanupStack::PushL ( instance );

   289     EUNIT_ASSERT_DESC ( instance, "CCFScriptHandler not created!" );

   290 

   291     CleanupStack::PopAndDestroy( instance );

   292     CleanupStack::PopAndDestroy( fakeEnv );         // CLEANUP<< fakeEnv

   293     }

   294 

   295 void MT_CFScriptEngine::MT_CCFScriptHandler_NewLCL(  )

   296     {

   297     // below                                        // CLEANUP<< fakeEnv

   298     CCFFakeEnv* fakeEnv = CCFFakeEnv::NewLC();

   299 

   300     CCFScriptHandler* instance

   301         = CCFScriptHandler::NewLC( *fakeEnv, iFs, *fakeEnv, *fakeEnv );

   302     EUNIT_ASSERT_DESC ( instance, "CCFScriptHandler not created!" );

   303 

   304     MCFStarterObserver* observer = (MCFStarterObserver*) instance;

   305     observer->InitializePhaseL( CCFPhaseBase::ECFDeviceStarting );

   306     observer->InitializePhaseL( CCFPhaseBase::ECFDeviceStarted );

   307     observer->InitializePhaseL( CCFPhaseBase::ECFStartEnd );

   308 

   309     CleanupStack::PopAndDestroy( instance );

   310     CleanupStack::PopAndDestroy( fakeEnv );         // CLEANUP<< fakeEnv

   311     }

   312 

   313 

   314 void MT_CFScriptEngine::MT_CCFScriptHandler_RemoveScriptByIdL(  )

   315     {

   316     RThread thread;

   317     CleanupClosePushL(thread);

   318 

   319     // Define context

   320     CCFContextObject* co = CCFContextObject::NewLC();

   321     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   322     co->SetSourceL(_L("t"));

   323     co->SetTypeL(_L("t.p.app"));

   324     TInt err = iCFFakeEnv->DefineContext( co->Source(),

   325             co->Type(), alwaysPass, alwaysPass );

   326     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   327 

   328     // load script

   329     HBufC8* script = LoadScriptFromFile(_L("test-equals.xml"));

   330     TInt id = iCFFakeEnv->AddScript(

   331             _L("test-equals.xml"), *script, thread.SecureId(), thread);

   332     EUNIT_ASSERT_DESC( id >= 0, "Parse error!" );

   333     delete script;

   334 

   335     // CONTEXT 1

   336     co->SetValueL(_L("ok"));

   337     iCFFakeEnv->ClearFireClientEvent();

   338     err = iCFFakeEnv->PublishContext( *co, thread );

   339     EUNIT_ASSERT_DESC( err == KErrNone, "PublishContext failed!" );

   340     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(), "Script did not fire event!" );

   341     EUNIT_ASSERT_DESC( iCFFakeEnv->ScriptEventScriptId() == id,

   342          "Script ID does not match!" );

   343     EUNIT_ASSERT_DESC( iCFFakeEnv->ScriptEventIdentifier() == _L("startApp"),

   344         "Identifier does not match!" );

   345 

   346     err = iCFFakeEnv->RemoveScriptById( id, thread );

   347     EUNIT_ASSERT( err == KErrNone );

   348 

   349     // Check that original script does not cause events anymore

   350     co->SetValueL(_L("notok"));

   351     iCFFakeEnv->ClearFireClientEvent();

   352     err = iCFFakeEnv->PublishContext( *co, thread );

   353     EUNIT_ASSERT_DESC( err == KErrNone, "PublishContext failed!" );

   354     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   355          "Script did fired although wrong context value!" );

   356 

   357     co->SetValueL(_L("ok"));

   358     iCFFakeEnv->ClearFireClientEvent();

   359     err = iCFFakeEnv->PublishContext( *co, thread );

   360     EUNIT_ASSERT_DESC( err == KErrNone, "PublishContext failed!" );

   361     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   362          "Script did fire event!" );

   363 

   364     CleanupStack::PopAndDestroy( co );

   365     CleanupStack::PopAndDestroy( &thread );

   366     }

   367 

   368 

   369 void MT_CFScriptEngine::MT_CCFScriptHandler_RemoveScriptsBySessionL(  )

   370     {

   371     RThread thread;

   372     CleanupClosePushL(thread);

   373 

   374     // Define and publish context

   375     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   376     TInt err = iCFFakeEnv->DefineContext( _L("t"),

   377             _L("t.p.app"), alwaysPass, alwaysPass );

   378     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   379 

   380     HBufC8* script = LoadScriptFromFile(_L("test-equals.xml"));

   381     TInt id1 = iCFFakeEnv->AddScript(

   382             _L("test-equals.xml"), *script, KMT_CfScriptEngineUid, thread);

   383     EUNIT_ASSERT_DESC( id1 >= 0, "Parse error!" );

   384     delete script;

   385 

   386     // Define context

   387     err = iCFFakeEnv->DefineContext( _L("Sensor"),

   388             _L("X.RawValue"), alwaysPass, alwaysPass );

   389     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   390 

   391     script = LoadScriptFromFile(_L("test-greater.xml"));

   392     TInt id2 = iCFFakeEnv->AddScript(

   393         _L("test-greater.xml"), *script, KMT_CfScriptEngineOtherUid, thread,

   394         *iDummyScriptEngineSession, NULL );

   395     EUNIT_ASSERT_DESC( id2 >= 0, "Parse error!" );

   396     delete script;

   397 

   398     // Define contexts

   399     err = iCFFakeEnv->DefineContext( _L("Application.State"),

   400             _L("Foreground.Application"), alwaysPass, alwaysPass );

   401     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   402     err = iCFFakeEnv->DefineContext( _L("Application.State"),

   403             _L("Foreground.View"), alwaysPass, alwaysPass );

   404     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   405 

   406     script = LoadScriptFromFile(_L("test-and.xml"));

   407     TInt id3 = iCFFakeEnv->AddScript(

   408             _L("test-and.xml"),*script, KMT_CfScriptEngineUid, thread);

   409     EUNIT_ASSERT_DESC( id3 >= 0, "Parse error!" );

   410     delete script;

   411 

   412     TInt numRemoved = iCFFakeEnv->RemoveScriptsBySession( *iCFFakeEnv );

   413 

   414     const RArray<TInt>& scriptIds = iCFFakeEnv->GetEveryScriptId();

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

   416         "Wrong count of Ids in array!" );

   417 

   418     // Check that all Ids are found

   419     EUNIT_ASSERT ( FindIndex( scriptIds, id2 ) >= 0 );

   420 

   421     CleanupStack::PopAndDestroy( &thread );

   422     }

   423 

   424 

   425 void MT_CFScriptEngine::MT_CCFScriptHandler_RemoveScriptByNameL()

   426     {

   427     _LIT( KScriptName1, "test-and.xml" );

   428     _LIT( KScriptName2, "test-or.xml" );

   429     HBufC8* script1 = LoadScriptFromFile( KScriptName1 );

   430     HBufC8* script2 = LoadScriptFromFile( KScriptName2 );

   431     EUNIT_ASSERT_DESC( script1 && script2, "Scripts not loaded" );

   432     if( script1 && script2 )

   433         {

   434         CleanupStack::PushL( script1 );

   435         CleanupStack::PushL( script2 );

   436         

   437         const TUid KClient1Uid = {0x12340001};

   438         const TUid KClient2Uid = {0x12340002};

   439 

   440         // Define needed contexts for scripts

   441         static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   442         TInt err = iCFFakeEnv->DefineContext( _L("Application.State"),

   443             _L("Foreground.Application"), alwaysPass, alwaysPass );

   444         EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   445         err = iCFFakeEnv->DefineContext( _L("Application.State"),

   446             _L("Foreground.View"), alwaysPass, alwaysPass );

   447         EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   448         

   449         // Test data

   450         RThread thread;

   451         CleanupClosePushL( thread );

   452         TInt id = 0;

   453         TInt scriptCount = 0;

   454         

   455         // Add script 1 from client 1

   456         id = iCFFakeEnv->AddScript( KScriptName1, *script1,

   457             KClient1Uid, thread );

   458         EUNIT_ASSERT_DESC( id >= 0, "Add script failed" );

   459         scriptCount = iCFFakeEnv->NumberOfScripts();

   460         EUNIT_ASSERT_DESC( scriptCount == id, "Invalid number of scripts" );

   461         

   462         // Add script 2 from client 1

   463         id = iCFFakeEnv->AddScript( KScriptName2, *script2,

   464             KClient1Uid, thread );

   465         EUNIT_ASSERT_DESC( id >= 0, "Add script failed" );

   466         scriptCount = iCFFakeEnv->NumberOfScripts();

   467         EUNIT_ASSERT_DESC( scriptCount == id, "Invalid number of scripts" );

   468         

   469         // Add script 1 from client 2

   470         id = iCFFakeEnv->AddScript( KScriptName1, *script1,

   471             KClient2Uid, thread );

   472         EUNIT_ASSERT_DESC( id >= 0, "Add script failed" );

   473         scriptCount = iCFFakeEnv->NumberOfScripts();

   474         EUNIT_ASSERT_DESC( scriptCount == id, "Invalid number of scripts" );

   475         

   476         // Add script 2 from client 2

   477         id = iCFFakeEnv->AddScript( KScriptName2, *script1,

   478             KClient2Uid, thread );

   479         EUNIT_ASSERT_DESC( id >= 0, "Add script failed" );

   480         scriptCount = iCFFakeEnv->NumberOfScripts();

   481         EUNIT_ASSERT_DESC( scriptCount == id, "Invalid number of scripts" );

   482         

   483         // Remove script 1 by name from client 1

   484         err = iCFFakeEnv->RemoveScriptByName( KScriptName1, KClient1Uid );

   485         EUNIT_ASSERT_DESC( err == KErrNone, "Invalid return value" );

   486         scriptCount = iCFFakeEnv->NumberOfScriptsByOwner( KClient1Uid );

   487         EUNIT_ASSERT_DESC( scriptCount == 1, "Invalid number of scripts" );

   488         

   489         // Remove script 1 by name from client 2

   490         err = iCFFakeEnv->RemoveScriptByName( KScriptName1, KClient2Uid );

   491         EUNIT_ASSERT_DESC( err == KErrNone, "Invalid return value" );

   492         scriptCount = iCFFakeEnv->NumberOfScriptsByOwner( KClient2Uid );

   493         EUNIT_ASSERT_DESC( scriptCount == 1, "Invalid number of scripts" );

   494         

   495         // Remove script 2 by name from client 1

   496         err = iCFFakeEnv->RemoveScriptByName( KScriptName2, KClient1Uid );

   497         EUNIT_ASSERT_DESC( err == KErrNone, "Invalid return value" );

   498         scriptCount = iCFFakeEnv->NumberOfScriptsByOwner( KClient1Uid );

   499         EUNIT_ASSERT_DESC( scriptCount == 0, "Invalid number of scripts" );

   500         

   501         // Remove script 2 by name from client 2

   502         err = iCFFakeEnv->RemoveScriptByName( KScriptName2, KClient2Uid );

   503         EUNIT_ASSERT_DESC( err == KErrNone, "Invalid return value" );

   504         scriptCount = iCFFakeEnv->NumberOfScriptsByOwner( KClient2Uid );

   505         EUNIT_ASSERT_DESC( scriptCount == 0, "Invalid number of scripts" );

   506         

   507         // Clean up

   508         CleanupStack::PopAndDestroy( &thread );

   509         CleanupStack::PopAndDestroy( script2 );

   510         CleanupStack::PopAndDestroy( script1 );

   511         }

   512     }

   513 

   514 

   515 void MT_CFScriptEngine::MT_CCFScriptHandler_RemoveScriptByUidL()

   516     {

   517     _LIT( KScriptName1, "test-and.xml" );

   518     _LIT( KScriptName2, "test-or.xml" );

   519     HBufC8* script1 = LoadScriptFromFile( KScriptName1 );

   520     HBufC8* script2 = LoadScriptFromFile( KScriptName2 );

   521     EUNIT_ASSERT_DESC( script1 && script2, "Scripts not loaded" );

   522     if( script1 && script2 )

   523         {

   524         CleanupStack::PushL( script1 );

   525         CleanupStack::PushL( script2 );

   526         

   527         // Define needed contexts for scripts

   528         static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   529         TInt err = iCFFakeEnv->DefineContext( _L("Application.State"),

   530             _L("Foreground.Application"), alwaysPass, alwaysPass );

   531         EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   532         err = iCFFakeEnv->DefineContext( _L("Application.State"),

   533             _L("Foreground.View"), alwaysPass, alwaysPass );

   534         EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   535         

   536         // Test data

   537         RThread thread;

   538         CleanupClosePushL( thread );

   539         TInt id = 0;

   540         TInt scriptCount = 0;

   541         const TUid KUid1 = {0x12340000};

   542         const TUid KUid2 = {0x12340001};

   543         

   544         // Add script 1 twice

   545         TInt count = 0;

   546         for( TInt i = 0; i < 2; i++ )

   547             {

   548             id = iCFFakeEnv->AddScript( KScriptName1, *script1,

   549                 KUid1, thread );

   550             count++;

   551             EUNIT_ASSERT_DESC( id >= 0, "Add script failed" );

   552             scriptCount = iCFFakeEnv->NumberOfScripts();

   553             EUNIT_ASSERT_DESC( scriptCount == count, "Invalid number of scripts" );

   554             }

   555         

   556         // Add script 2 three times

   557         for( TInt i = 0; i < 3; i++ )

   558             {

   559             id = iCFFakeEnv->AddScript( KScriptName2, *script2,

   560                 KUid2, thread );

   561             count++;

   562             EUNIT_ASSERT_DESC( id >= 0, "Add script failed" );

   563             scriptCount = iCFFakeEnv->NumberOfScripts();

   564             EUNIT_ASSERT_DESC( scriptCount == count, "Invalid number of scripts" );

   565             }

   566         

   567         // Remove scripts by uid1

   568         err = iCFFakeEnv->RemoveScriptByUid( KUid1 );

   569         EUNIT_ASSERT_DESC( err == KErrNone, "RemoveScriptByUid failed" );

   570         scriptCount = iCFFakeEnv->NumberOfScripts();

   571         EUNIT_ASSERT_DESC( scriptCount == 3, "Invalid number of scripts" );

   572         scriptCount = iCFFakeEnv->NumberOfScriptsByOwner( KUid1 );

   573         EUNIT_ASSERT_DESC( scriptCount == 0, "Invalid number of scripts" );

   574 

   575         // Remove scripts by uid2

   576         err = iCFFakeEnv->RemoveScriptByUid( KUid2 );

   577         EUNIT_ASSERT_DESC( err == KErrNone, "RemoveScriptByUid failed" );

   578         scriptCount = iCFFakeEnv->NumberOfScripts();

   579         EUNIT_ASSERT_DESC( scriptCount == 0, "Invalid number of scripts" );

   580         scriptCount = iCFFakeEnv->NumberOfScriptsByOwner( KUid2 );

   581         EUNIT_ASSERT_DESC( scriptCount == 0, "Invalid number of scripts" );

   582 

   583         // Clean up

   584         CleanupStack::PopAndDestroy( &thread );

   585         CleanupStack::PopAndDestroy( script2 );

   586         CleanupStack::PopAndDestroy( script1 );

   587         }

   588     }

   589 

   590 

   591 void MT_CFScriptEngine::MT_CCFScriptHandler_NumberOfScriptsL(  )

   592     {

   593     RThread thread;

   594     CleanupClosePushL(thread);

   595 

   596     EUNIT_ASSERT_DESC( iCFFakeEnv->NumberOfScripts() == 0,

   597             "Wrong number of scripts returned!" );

   598 

   599     // Define and publish context

   600     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   601     TInt err = iCFFakeEnv->DefineContext( _L("t"),

   602             _L("t.p.app"), alwaysPass, alwaysPass );

   603     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   604 

   605     HBufC8* script = LoadScriptFromFile(_L("test-equals.xml"));

   606     TInt id = iCFFakeEnv->AddScript(

   607             _L("test-equals.xml"),*script, KMT_CfScriptEngineUid, thread);

   608     EUNIT_ASSERT_DESC( id >= 0, "Parse error!" );

   609     delete script;

   610 

   611     EUNIT_ASSERT_DESC( iCFFakeEnv->NumberOfScripts() == 1,

   612             "Wrong number of scripts returned!" );

   613 

   614     // Define context

   615     err = iCFFakeEnv->DefineContext( _L("Sensor"),

   616             _L("X.RawValue"), alwaysPass, alwaysPass );

   617     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   618 

   619     script = LoadScriptFromFile(_L("test-greater.xml"));

   620     id = iCFFakeEnv->AddScript(_L("test-greater.xml"),

   621             *script, KMT_CfScriptEngineOtherUid, thread);

   622     EUNIT_ASSERT_DESC( id >= 0, "Parse error!" );

   623     delete script;

   624 

   625     EUNIT_ASSERT_DESC( iCFFakeEnv->NumberOfScripts() == 2,

   626             "Wrong number of scripts returned!" );

   627 

   628     CleanupStack::PopAndDestroy( &thread );

   629     }

   630 

   631 

   632 void MT_CFScriptEngine::MT_CCFScriptHandler_ScriptLengthL(  )

   633     {

   634     RThread thread;

   635     CleanupClosePushL(thread);

   636 

   637     // Define and publish context

   638     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   639     TInt err = iCFFakeEnv->DefineContext( _L("t"),

   640             _L("t.p.app"), alwaysPass, alwaysPass );

   641     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   642 

   643     HBufC8* script = LoadScriptFromFile(_L("test-equals.xml"));

   644     TInt id1 = iCFFakeEnv->AddScript(

   645             _L("test-equals.xml"), *script, KMT_CfScriptEngineUid, thread);

   646     EUNIT_ASSERT_DESC( id1 >= 0, "Parse error!" );

   647 

   648     TInt origLength = script->Length();

   649     delete script;

   650 

   651     EUNIT_ASSERT( iCFFakeEnv->ScriptLength( id1 ) == origLength);

   652 

   653     CleanupStack::PopAndDestroy( &thread );

   654     }

   655 

   656 

   657 void MT_CFScriptEngine::MT_CCFScriptHandler_NumberOfScriptsByOwnerL(  )

   658     {

   659     RThread thread;

   660     CleanupClosePushL(thread);

   661 

   662     EUNIT_ASSERT_DESC(

   663             iCFFakeEnv->NumberOfScriptsByOwner(KMT_CfScriptEngineUid) == 0,

   664             "Wrong number of scripts returned!" );

   665 

   666     // Define and publish context

   667     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   668     TInt err = iCFFakeEnv->DefineContext( _L("t"),

   669             _L("t.p.app"), alwaysPass, alwaysPass );

   670     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   671 

   672     HBufC8* script = LoadScriptFromFile(_L("test-equals.xml"));

   673     TInt id = iCFFakeEnv->AddScript(

   674             _L("test-equals.xml"), *script, KMT_CfScriptEngineUid, thread);

   675     EUNIT_ASSERT_DESC( id >= 0, "Parse error!" );

   676     delete script;

   677 

   678     EUNIT_ASSERT_DESC(

   679             iCFFakeEnv->NumberOfScriptsByOwner(KMT_CfScriptEngineUid) == 1,

   680             "Wrong number of scripts returned!" );

   681 

   682     // Define context for test-greater.xml

   683     err = iCFFakeEnv->DefineContext( _L("Sensor"),

   684             _L("X.RawValue"), alwaysPass, alwaysPass );

   685     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   686 

   687     script = LoadScriptFromFile(_L("test-greater.xml"));

   688     id = iCFFakeEnv->AddScript(_L("test-greater.xml"),

   689             *script, KMT_CfScriptEngineOtherUid, thread);

   690     EUNIT_ASSERT_DESC( id >= 0, "Parse error!" );

   691     delete script;

   692 

   693     EUNIT_ASSERT_DESC(

   694             iCFFakeEnv->NumberOfScriptsByOwner(KMT_CfScriptEngineUid) == 1,

   695             "Wrong number of scripts returned!" );

   696 

   697     // Define contexts test-and.xml -script

   698     err = iCFFakeEnv->DefineContext( _L("Application.State"),

   699             _L("Foreground.Application"), alwaysPass, alwaysPass );

   700     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   701     err = iCFFakeEnv->DefineContext( _L("Application.State"),

   702             _L("Foreground.View"), alwaysPass, alwaysPass );

   703     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   704 

   705     script = LoadScriptFromFile(_L("test-and.xml"));

   706     id = iCFFakeEnv->AddScript(

   707             _L("test-and.xml"), *script, KMT_CfScriptEngineUid, thread);

   708     EUNIT_ASSERT_DESC( id >= 0, "Parse error!" );

   709     delete script;

   710 

   711     EUNIT_ASSERT_DESC(

   712             iCFFakeEnv->NumberOfScriptsByOwner(KMT_CfScriptEngineUid) == 2,

   713             "Wrong number of scripts returned!" );

   714 

   715     CleanupStack::PopAndDestroy( &thread );

   716     }

   717 

   718 void MT_CFScriptEngine::MT_CCFScriptHandler_GetEveryScriptIdL(  )

   719     {

   720     RThread thread;

   721     CleanupClosePushL(thread);

   722 

   723     // Define context for test-equals.xml

   724     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   725     TInt err = iCFFakeEnv->DefineContext( _L("t"),

   726             _L("t.p.app"), alwaysPass, alwaysPass );

   727     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   728 

   729     HBufC8* script = LoadScriptFromFile(_L("test-equals.xml"));

   730     TInt id1 = iCFFakeEnv->AddScript(

   731             _L("test-equals.xml"), *script, KMT_CfScriptEngineUid, thread);

   732     EUNIT_ASSERT_DESC( id1 >= 0, "Parse error!" );

   733     delete script;

   734 

   735     // Define context for test-greater.xml

   736     err = iCFFakeEnv->DefineContext( _L("Sensor"),

   737             _L("X.RawValue"), alwaysPass, alwaysPass );

   738     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   739 

   740     script = LoadScriptFromFile(_L("test-greater.xml"));

   741     TInt id2 = iCFFakeEnv->AddScript(_L("test-greater.xml"),

   742             *script, KMT_CfScriptEngineOtherUid, thread);

   743     EUNIT_ASSERT_DESC( id2 >= 0, "Parse error!" );

   744     delete script;

   745 

   746 

   747     // Define contexts test-and.xml -script

   748     err = iCFFakeEnv->DefineContext( _L("Application.State"),

   749             _L("Foreground.Application"), alwaysPass, alwaysPass );

   750     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   751     err = iCFFakeEnv->DefineContext( _L("Application.State"),

   752             _L("Foreground.View"), alwaysPass, alwaysPass );

   753     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   754 

   755     script = LoadScriptFromFile(_L("test-and.xml"));

   756     TInt id3 = iCFFakeEnv->AddScript(

   757             _L("test-and.xml"), *script, KMT_CfScriptEngineUid, thread);

   758     EUNIT_ASSERT_DESC( id3 >= 0, "Parse error!" );

   759     delete script;

   760 

   761     const RArray<TInt>& scriptIds = iCFFakeEnv->GetEveryScriptId();

   762     EUNIT_ASSERT_DESC( scriptIds.Count() == 3, "Wrong count of Ids in array!" );

   763 

   764     // Check that all Ids are found

   765     EUNIT_ASSERT ( FindIndex( scriptIds, id1 ) >= 0 );

   766     EUNIT_ASSERT ( FindIndex( scriptIds, id2 ) >= 0 );

   767     EUNIT_ASSERT ( FindIndex( scriptIds, id3 ) >= 0 );

   768 

   769     CleanupStack::PopAndDestroy( &thread );

   770     }

   771 

   772 

   773 void MT_CFScriptEngine::MT_CCFScriptHandler_GetEveryScriptIdByOwnerL(  )

   774     {

   775     RThread thread;

   776     CleanupClosePushL(thread);

   777 

   778     // Define context for test-equals.xml

   779     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   780     TInt err = iCFFakeEnv->DefineContext( _L("t"),

   781             _L("t.p.app"), alwaysPass, alwaysPass );

   782     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   783 

   784     HBufC8* script = LoadScriptFromFile(_L("test-equals.xml"));

   785     TInt id1 = iCFFakeEnv->AddScript(

   786             _L("test-equals.xml"), *script, KMT_CfScriptEngineUid, thread);

   787     EUNIT_ASSERT_DESC( id1 >= 0, "Parse error!" );

   788     delete script;

   789 

   790     // Define context for test-greater.xml

   791     err = iCFFakeEnv->DefineContext( _L("Sensor"),

   792             _L("X.RawValue"), alwaysPass, alwaysPass );

   793     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   794 

   795     script = LoadScriptFromFile(_L("test-greater.xml"));

   796     TInt id2 = iCFFakeEnv->AddScript(_L("test-greater.xml"),

   797             *script, KMT_CfScriptEngineOtherUid, thread);

   798     EUNIT_ASSERT_DESC( id2 >= 0, "Parse error!" );

   799     delete script;

   800 

   801     // Define contexts test-and.xml -script

   802     err = iCFFakeEnv->DefineContext( _L("Application.State"),

   803             _L("Foreground.Application"), alwaysPass, alwaysPass );

   804     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   805     err = iCFFakeEnv->DefineContext( _L("Application.State"),

   806             _L("Foreground.View"), alwaysPass, alwaysPass );

   807     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   808 

   809     script = LoadScriptFromFile(_L("test-and.xml"));

   810     TInt id3 = iCFFakeEnv->AddScript(

   811             _L("test-and.xml"), *script, KMT_CfScriptEngineUid, thread);

   812     EUNIT_ASSERT_DESC( id3 >= 0, "Parse error!" );

   813     delete script;

   814 

   815     const RArray<TInt>& scriptIds

   816         = iCFFakeEnv->GetEveryScriptIdByOwner(KMT_CfScriptEngineUid);

   817     EUNIT_ASSERT_DESC( scriptIds.Count() == 2,

   818         "Wrong count of Ids in array!" );

   819 

   820     EUNIT_ASSERT ( FindIndex( scriptIds, id1 ) >= 0 );

   821     EUNIT_ASSERT ( FindIndex( scriptIds, id3 ) >= 0 );

   822 

   823     CleanupStack::PopAndDestroy( &thread );

   824     }

   825 

   826 

   827 void MT_CFScriptEngine::MT_CCFScriptHandler_UpdateScriptL(  )

   828     {

   829     RThread thread;

   830     CleanupClosePushL(thread);

   831 

   832     // Define and publish context

   833     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   834     CCFContextObject* co = CCFContextObject::NewLC();

   835     co->SetSourceL(_L("t"));

   836     co->SetTypeL(_L("t.p.app"));

   837     TInt err = iCFFakeEnv->DefineContext( co->Source(),

   838             co->Type(), alwaysPass, alwaysPass );

   839     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   840 

   841     // load script

   842     HBufC8* script = LoadScriptFromFile(_L("test-equals.xml"));

   843     TInt id = iCFFakeEnv->AddScript(

   844             _L("test-equals.xml"), *script, KMT_CfScriptEngineUid, thread);

   845     EUNIT_ASSERT_DESC( id >= 0, "Parse error!" );

   846     delete script;

   847 

   848     // CONTEXT 1

   849     co->SetValueL(_L("ok"));

   850     iCFFakeEnv->ClearFireClientEvent();

   851     err = iCFFakeEnv->PublishContext( *co, thread );

   852     EUNIT_ASSERT_DESC( err == KErrNone, "PublishContext failed!" );

   853     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(), "Script did not fire event!" );

   854     EUNIT_ASSERT_DESC( iCFFakeEnv->ScriptEventScriptId() == id,

   855          "Script ID does not match!" );

   856     EUNIT_ASSERT_DESC( iCFFakeEnv->ScriptEventIdentifier() == _L("startApp"),

   857         "Identifier does not match!" );

   858 

   859     // Define context

   860     CCFContextObject* co2 = CCFContextObject::NewLC();

   861     co2->SetSourceL(_L("Sensor"));

   862     co2->SetTypeL(_L("X.RawValue"));

   863     err = iCFFakeEnv->DefineContext( co2->Source(),

   864             co2->Type(), alwaysPass, alwaysPass );

   865     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   866 

   867     // update script

   868     HBufC8* updatedScript = LoadScriptFromFile(_L("test-less.xml"));

   869     err = iCFFakeEnv->UpdateScript(id,  thread,  *updatedScript, NULL );

   870     EUNIT_ASSERT_DESC( err == KErrNone, "Update error!" );

   871     delete updatedScript;

   872 

   873     // TEST 1: Should fire event if value < 150

   874     co2->SetValueL(_L("149")); // value in script: 150

   875     err = iCFFakeEnv->PublishContext( *co2, thread );

   876     EUNIT_ASSERT_DESC( err == KErrNone, "PublishContext failed!" );

   877     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(), "Script did not fire event!" );

   878     EUNIT_ASSERT_DESC( iCFFakeEnv->ScriptEventScriptId() == id,

   879          "Script ID does not match!" );

   880     EUNIT_ASSERT_DESC( iCFFakeEnv->ScriptEventIdentifier() == _L("startApp"),

   881         "Identifier does not match!" );

   882 

   883     // Check that original script does not cause events anymore

   884     co->SetValueL(_L("notok"));

   885     iCFFakeEnv->ClearFireClientEvent();

   886     err = iCFFakeEnv->PublishContext( *co, thread );

   887     EUNIT_ASSERT_DESC( err == KErrNone, "PublishContext failed!" );

   888     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(), "Script did fire event!" );

   889 

   890     co->SetValueL(_L("ok"));

   891     iCFFakeEnv->ClearFireClientEvent();

   892     err = iCFFakeEnv->PublishContext( *co, thread );

   893     EUNIT_ASSERT_DESC( err == KErrNone, "PublishContext failed!" );

   894     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(), "Script did fire event!" );

   895 

   896     CleanupStack::PopAndDestroy( co2 );

   897     CleanupStack::PopAndDestroy( co );

   898     CleanupStack::PopAndDestroy( &thread );

   899     }

   900 

   901 

   902 void MT_CFScriptEngine::MT_CCFScriptHandler_SaveScriptL()

   903     {    

   904     // Change timestamp to yesterday

   905     TTime time;

   906     time.UniversalTime();

   907     TDateTime dateTime = time.DateTime();

   908     dateTime.SetHour( dateTime.Hour() - 1 );

   909     

   910     // Update new time

   911     TTime entryTime( dateTime );

   912 

   913     // Load script

   914     HBufC8* script1 = LoadScriptFromFile( _L( "test-saveScript.xml" ) );

   915     EUNIT_ASSERT_DESC( script1 , "Scripts not loaded" );

   916     if( script1 )

   917         {

   918         CleanupStack::PushL( script1 );

   919         const TUid KUidClient1 = {0x12340001};

   920         const TUid KUidClient2 = {0x12340002};

   921         TInt err = KErrNone;

   922         TInt scriptId = 0;

   923         TBool exists = EFalse;

   924         _LIT( KClient1Path1, "c:\\private\\10282BC4\\rules\\12340001\\script1.rul" );

   925         _LIT( KClient1Path2, "c:\\private\\10282BC4\\rules\\12340001\\script2.rul" );

   926         _LIT( KClient2Path1, "c:\\private\\10282BC4\\rules\\12340002\\script1.rul" );

   927         _LIT( KClient2Path2, "c:\\private\\10282BC4\\rules\\12340002\\script2.rul" );

   928         _LIT( KUpgradePath, "c:\\private\\10282BC4\\rules\\scriptupgrade.rul" );

   929         RThread client;

   930         CleanupClosePushL( client );

   931         

   932         // Define needed contexts for scripts

   933         static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   934         CCFContextObject* co = CCFContextObject::NewLC();

   935         co->SetSourceL( _L("test") );

   936         co->SetTypeL( _L("save.script") );

   937         err = iCFFakeEnv->DefineContext( co->Source(), co->Type(), alwaysPass, alwaysPass );

   938         EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

   939 

   940         // Test script saving from different clients

   941         const TInt KCount = 5;

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

   943             {

   944             TPtrC fullPath( KNullDesC );

   945             TUid uid = {0x00000000};

   946             switch( i )

   947                 {

   948                 case 0:

   949                     {

   950                     fullPath.Set( KClient1Path1 );

   951                     uid = KUidClient1;

   952                     break;

   953                     }

   954                 case 1:

   955                     {

   956                     fullPath.Set( KClient1Path2 );

   957                     uid = KUidClient1;

   958                     break;

   959                     }

   960                 case 2:

   961                     {

   962                     fullPath.Set( KClient2Path1 );

   963                     uid = KUidClient2;

   964                     break;

   965                     }

   966                 case 3:

   967                     {

   968                     fullPath.Set( KClient2Path2 );

   969                     uid = KUidClient2;

   970                     break;

   971                     }

   972                 case 4:

   973                     {

   974                     fullPath.Set( KUpgradePath );

   975                     uid = KCFServerUid;

   976                     break;

   977                     }

   978                 default:

   979                     {

   980                     break;

   981                     }

   982                 }

   983             TParsePtrC parse( fullPath );

   984             scriptId = iCFFakeEnv->AddScript( parse.Name(), *script1, uid,

   985                 client );

   986             EUNIT_ASSERT_DESC( scriptId == i + 1, "Invalid script id" );

   987             err = iCFFakeEnv->SaveScript( *script1, scriptId, uid );

   988             EUNIT_ASSERT_DESC( err == KErrNone, "SaveScript failed" );

   989             exists = BaflUtils::FolderExists( iFs, parse.DriveAndPath() );

   990             EUNIT_ASSERT_DESC( exists, "Folder not created" );

   991             exists = BaflUtils::FileExists( iFs, parse.FullName() );

   992             EUNIT_ASSERT_DESC( exists, "File not created" );

   993             

   994             err = iFs.SetModified( fullPath, entryTime );

   995             EUNIT_ASSERT_DESC( err == KErrNone, "Failed to set modified time" );

   996             TEntry oldEntry;

   997             err = iFs.Entry( fullPath, oldEntry );

   998             EUNIT_ASSERT_DESC( err == KErrNone, "Failed to get file entry" );

   999             

  1000             // Save script again and check that it has been replaced

  1001             User::After( 100000 );

  1002             err = iCFFakeEnv->SaveScript( *script1, scriptId, uid );

  1003             EUNIT_ASSERT_DESC( err == KErrNone, "SaveScript failed" );

  1004             TEntry newEntry;

  1005             err = iFs.Entry( fullPath, newEntry );

  1006             EUNIT_ASSERT_DESC( err == KErrNone, "Failed to get file entry" );

  1007             EUNIT_ASSERT_DESC( oldEntry.iModified < newEntry.iModified,

  1008                 "Saved script not updated" );

  1009             }

  1010         

  1011         // Try to save a script from with a wrong owner UID

  1012         scriptId = iCFFakeEnv->AddScript( _L( "test" ), *script1, KUidClient1,   

  1013             client );

  1014         err = iCFFakeEnv->SaveScript( *script1, scriptId, KUidClient2 );

  1015         EUNIT_ASSERT_DESC( err == KErrAccessDenied,

  1016             "Allowed to save script with a wrong client uid" );

  1017         

  1018         // Check that the saved script are loaded when script engine

  1019         // is initialized

  1020         delete iCFFakeEnv;

  1021         iCFFakeEnv = NULL;

  1022         iCFFakeEnv = CCFFakeEnv::NewL();

  1023         iCFFakeEnv->InitAllPhasesL();

  1024         TInt numOfScripts = iCFFakeEnv->NumberOfScriptsByOwner( KUidClient1 );

  1025         EUNIT_ASSERT_DESC( numOfScripts == 2, "Invalid number of scripts" );

  1026         numOfScripts = iCFFakeEnv->NumberOfScriptsByOwner( KUidClient2 );

  1027         EUNIT_ASSERT_DESC( numOfScripts == 2, "Invalid number of scripts" );

  1028 

  1029         co->SetSourceL( _L("test") );

  1030         co->SetTypeL( _L("save.script") );

  1031         err = iCFFakeEnv->DefineContext( co->Source(), co->Type(), alwaysPass, alwaysPass );

  1032         EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

  1033         co->SetValueL( _L("true") );

  1034         err = iCFFakeEnv->PublishContext( *co, client );

  1035         EUNIT_ASSERT_DESC( err == KErrNone, "Publish context failed" );

  1036         

  1037         TBool eventFired = iCFFakeEnv->ClientEventFired();

  1038         EUNIT_ASSERT_DESC( eventFired, "Event not fired" );

  1039         TPtrC actionId( iCFFakeEnv->ScriptEventIdentifier() );

  1040         EUNIT_ASSERT_DESC( actionId == _L("saveScript"), "Incorrect action id" );

  1041         const RKeyValueArray& params = iCFFakeEnv->ScriptEventParameters();

  1042         EUNIT_ASSERT_DESC( params[0]->Key() == _L("id"), "Incorrect action id" );

  1043         EUNIT_ASSERT_DESC( params[0]->Value() == _L("triggered"), "Incorrect action id value" );

  1044         

  1045         // Clean up

  1046         CleanupStack::PopAndDestroy( co );

  1047         CleanupStack::PopAndDestroy( &client );

  1048         CleanupStack::PopAndDestroy( script1 );

  1049         }

  1050     }

  1051 

  1052 

  1053 void MT_CFScriptEngine::MT_CCFScriptHandler_DeleteScriptByNameL()

  1054     {

  1055     // Load script

  1056     HBufC8* script = LoadScriptFromFile( _L( "test-and.xml" ) );

  1057     EUNIT_ASSERT_DESC( script , "Scripts not loaded" );

  1058     User::LeaveIfNull( script );

  1059     CleanupStack::PushL( script );

  1060     RThread client;

  1061     CleanupClosePushL( client );

  1062     

  1063     // Test data

  1064     const TUid KUidClient1 = {0x12340001};

  1065     const TUid KUidClient2 = {0x12340002};

  1066     _LIT( KClient1Path1, "c:\\private\\10282BC4\\rules\\12340001\\script1.rul" );

  1067     _LIT( KClient1Path2, "c:\\private\\10282BC4\\rules\\12340001\\script2.rul" );

  1068     _LIT( KClient2Path1, "c:\\private\\10282BC4\\rules\\12340002\\script1.rul" );

  1069     _LIT( KClient2Path2, "c:\\private\\10282BC4\\rules\\12340002\\script2.rul" );

  1070 

  1071     TInt err = KErrNone;

  1072     TInt scriptId = 0;

  1073     TBool exists = EFalse;        

  1074     

  1075     // Define needed contexts for scripts

  1076     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

  1077     err = iCFFakeEnv->DefineContext( _L("Application.State"),

  1078         _L("Foreground.Application"), alwaysPass, alwaysPass );

  1079     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

  1080     err = iCFFakeEnv->DefineContext( _L("Application.State"),

  1081         _L("Foreground.View"), alwaysPass, alwaysPass );

  1082     EUNIT_ASSERT_DESC( err == KErrNone, "DefineContext failed!" );

  1083 

  1084     // Add and save scripts

  1085     const TInt KCount = 4;

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

  1087         {

  1088         TPtrC fullPath( KNullDesC );

  1089         TUid uid = {0x00000000};

  1090         switch( i )

  1091             {

  1092             case 0:

  1093                 {

  1094                 fullPath.Set( KClient1Path1 );

  1095                 uid = KUidClient1;

  1096                 break;

  1097                 }

  1098             case 1:

  1099                 {

  1100                 fullPath.Set( KClient1Path2 );

  1101                 uid = KUidClient1;

  1102                 break;

  1103                 }

  1104             case 2:

  1105                 {

  1106                 fullPath.Set( KClient2Path1 );

  1107                 uid = KUidClient2;

  1108                 break;

  1109                 }

  1110             case 3:

  1111                 {

  1112                 fullPath.Set( KClient2Path2 );

  1113                 uid = KUidClient2;

  1114                 break;

  1115                 }

  1116             default:

  1117                 {

  1118                 break;

  1119                 }

  1120             }

  1121         TParsePtrC parse( fullPath );

  1122         scriptId = iCFFakeEnv->AddScript( parse.Name(), *script, uid,

  1123             client );

  1124         EUNIT_ASSERT_DESC( scriptId == i + 1, "Invalid script id" );

  1125         err = iCFFakeEnv->SaveScript( *script, scriptId, uid );

  1126         EUNIT_ASSERT_DESC( err == KErrNone, "SaveScript failed" );

  1127         }

  1128     

  1129     // Delete and check scripts

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

  1131         {

  1132         switch( i )

  1133             {

  1134             case 0: