1 /*

     2 * Copyright (c) 2002 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 //  CLASS HEADER

    19 #include "mt_basicoperationsplugin.h"

    20 

    21 //  EXTERNAL INCLUDES

    22 #include <EUnitMacros.h>

    23 #include <EUnitDecorators.h>

    24 #include <ECom/ECom.h>

    25 

    26 #include <bautils.h>

    27 

    28 #include "CFContextSubscription.h"

    29 #include "CFContextSubscriptionImpl.h"

    30 #include "CFContextObject.h"

    31 #include "CFContextObjectImpl.h"

    32 #include "CFScriptHandler.h"

    33 

    34 //  INTERNAL INCLUDES

    35 #include "CFTestDelay.h"

    36 #include "cffakeenv.h"

    37 #include "ScriptEventNotifierSession.h"

    38 #include "cfenvutils.h"

    39 

    40 // CONSTANTS

    41 

    42 const TUid KMT_CfScriptEngineUid = {0x7E577E57};

    43 //const TUid KMT_CfScriptEngineOtherUid = {0x074E074E};

    44 _LIT8( KScriptStartTag, "<script" );

    45 

    46 

    47 // CONSTRUCTION

    48 mt_basicoperationsplugin* mt_basicoperationsplugin::NewL()

    49     {

    50     mt_basicoperationsplugin* self = mt_basicoperationsplugin::NewLC();

    51     CleanupStack::Pop();

    52 

    53     return self;

    54     }

    55 

    56 mt_basicoperationsplugin* mt_basicoperationsplugin::NewLC()

    57     {

    58     mt_basicoperationsplugin* self = new( ELeave ) mt_basicoperationsplugin();

    59     CleanupStack::PushL( self );

    60 

    61     self->ConstructL();

    62 

    63     return self;

    64     }

    65 

    66 // Destructor (virtual by CBase)

    67 mt_basicoperationsplugin::~mt_basicoperationsplugin()

    68     {

    69     // Enable screen saver

    70     CFEnvUtils::EnableScreenSaver( ETrue );

    71     }

    72 

    73 // Default constructor

    74 mt_basicoperationsplugin::mt_basicoperationsplugin()

    75     {

    76     }

    77 

    78 // Second phase construct

    79 void mt_basicoperationsplugin::ConstructL()

    80     {

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

    82     // It generates the test case table.

    83     CEUnitTestSuiteClass::ConstructL();

    84     

    85     // Disable screen saver

    86     CFEnvUtils::EnableScreenSaver( EFalse );

    87     }

    88 

    89 //  METHODS

    90 

    91 

    92 void mt_basicoperationsplugin::SetupEmptyL(  )

    93     {

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

    95     iTestDelay = CCFTestDelay::NewL();

    96     }

    97 

    98 void mt_basicoperationsplugin::SetupL(  )

    99     {

   100     SetupEmptyL();

   101 

   102     iDummyScriptEngineSession = CScriptEventNotifierSession::NewL();

   103 

   104     iCFFakeEnv = CCFFakeEnv::NewL();

   105     }

   106 

   107 void mt_basicoperationsplugin::SetupMidtestL( CCFContextObject& aContext1,

   108     CCFContextObject& aContext2,

   109     const TDesC& aScriptFile )

   110     {

   111     iDummyScriptEngineSession = CScriptEventNotifierSession::NewL();

   112 

   113     iCFFakeEnv = CCFFakeEnv::NewL();

   114 

   115     RThread thread;

   116     CleanupClosePushL( thread );

   117 

   118     // Define contexts

   119     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   120     TInt err = iCFFakeEnv->DefineContext( aContext1.Source(),

   121             aContext1.Type(), alwaysPass, alwaysPass );

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

   123 

   124     err = iCFFakeEnv->DefineContext( aContext2.Source(),

   125             aContext2.Type(), alwaysPass, alwaysPass );

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

   127 

   128     // Publish context before loading so that subscribing will find the initial

   129     // value used to evaluate the operation

   130     aContext1.SetValueL(_L("A"));

   131     err = iCFFakeEnv->PublishContext( aContext1, thread );

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

   133     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   134         "Script did cause event!" );

   135 

   136     aContext2.SetValueL(_L("True"));

   137     err = iCFFakeEnv->PublishContext( aContext2, thread );

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

   139     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   140         "Script did cause event!" );

   141 

   142     // load script

   143     HBufC8* script = LoadScriptFromFile( aScriptFile );

   144     TInt id = iCFFakeEnv->AddScript( aScriptFile, *script,

   145             KMT_CfScriptEngineUid, thread );

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

   147     delete script;

   148 

   149     iCFFakeEnv->ClearFireClientEventCount();

   150 

   151     CleanupStack::PopAndDestroy( &thread );

   152     }

   153 

   154 void mt_basicoperationsplugin::TeardownMidtest(  )

   155     {

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

   157 

   158     delete iDummyScriptEngineSession;

   159     iDummyScriptEngineSession = NULL;

   160 

   161     delete iCFFakeEnv;

   162     iCFFakeEnv = NULL;

   163 

   164 #ifdef __WINS__    

   165     REComSession::FinalClose();

   166 #endif

   167     }

   168 

   169 void mt_basicoperationsplugin::Teardown(  )

   170     {

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

   172 

   173     delete iDummyScriptEngineSession;

   174     iDummyScriptEngineSession = NULL;

   175 

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

   177     delete iTestDelay;

   178     iTestDelay = NULL;

   179 

   180     delete iCFFakeEnv;

   181     iCFFakeEnv = NULL;

   182 

   183     iFs.Close();

   184 

   185 #ifdef __WINS__    

   186     REComSession::FinalClose();

   187 #endif

   188     }

   189 

   190 // -----------------------------------------------------------------------------

   191 // mt_basicoperationsplugin::LoadScriptFromFile

   192 // -----------------------------------------------------------------------------

   193 //

   194 HBufC8* mt_basicoperationsplugin::LoadScriptFromFile( const TDesC& aFilePath )

   195     {

   196     HBufC8* script = NULL;

   197     RFile file;

   198     TFileName fileName;

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

   200     fileName.Append(aFilePath);

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

   202     if( err == KErrNone )

   203         {

   204         TInt size = 0;

   205         err = file.Size( size );

   206         if( err == KErrNone )

   207             {

   208             script = HBufC8::New( size );

   209             if( script )

   210                 {

   211                 TPtr8 scriptPtr = script->Des();

   212                 err = file.Read( scriptPtr );

   213                 if( err == KErrNone )

   214                     {

   215                     // Strip all unnecassary data from script

   216                     TInt pos = scriptPtr.FindF( KScriptStartTag );

   217                     if( pos != KErrNotFound )

   218                         {

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

   220                         }

   221                     else

   222                         {

   223                         // Incorrect script

   224                         delete script;

   225                         script = NULL;

   226                         }

   227                     }

   228                 else

   229                     {

   230                     delete script;

   231                     script = NULL;

   232                     }

   233                 }

   234             }

   235         }

   236 

   237     // Cleanup

   238     file.Close();

   239     return script;

   240     }

   241 

   242 // Format string to create persistent data file from:

   243 // - Owner uid

   244 // - Script name

   245 // - Persistent data name

   246 _LIT( KCFPersistenDataFormat, "c:\\private\\10282bc4\\rules\\%x\\%S-%S.dat" );

   247 

   248 void mt_basicoperationsplugin::DeletePersistencyFile( const TDesC& aScriptName,

   249     const TDesC& aPersistencyFilename )

   250     {

   251     // Format name

   252     TParsePtrC parse( aScriptName );

   253     TPtrC scriptFilename( parse.Name() );

   254     TParsePtrC parsePersistency( aPersistencyFilename );

   255     TPtrC persistencyFilename( parsePersistency.Name() );

   256 

   257     TFileName fileName;

   258     fileName.Format( KCFPersistenDataFormat,

   259             KMT_CfScriptEngineUid, &scriptFilename, &persistencyFilename );

   260 

   261     TInt err = BaflUtils::DeleteFile( iFs, fileName );

   262     EUNIT_ASSERT_DESC(

   263             err == KErrNone || err == KErrNotFound || err == KErrPathNotFound, 

   264             "Persistency file delete error!");

   265     }

   266 

   267 TInt mt_basicoperationsplugin::FindParameter(const RKeyValueArray& aArray,

   268     const TDesC& aKey, const TDesC& aValue)

   269     {

   270     TInt index = KErrNotFound;

   271     TBool found = EFalse;

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

   273         {

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

   275             {

   276             if ( index == KErrNotFound )

   277                 {

   278                 index = i;

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

   280                     {

   281                     found = ETrue;

   282                     }

   283                 else

   284                     {

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

   286                     }

   287                 }

   288             else

   289                 {

   290                 index = -2; // Duplicate found!

   291                 }

   292             }

   293         }

   294     if (found)

   295         {

   296         return index;

   297         }

   298     return KErrNotFound;

   299     }

   300 

   301 

   302 TInt mt_basicoperationsplugin::FindIndex( const RArray<TInt>& aArray, TInt aIndex )

   303     {

   304     TInt index = KErrNotFound;

   305     TBool found = EFalse;

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

   307         {

   308         if ( aArray[i] == aIndex )

   309             {

   310             if ( index == KErrNotFound )

   311                 {

   312                 index = i;

   313                 found = ETrue;

   314                 }

   315             else

   316                 {

   317                 index = -2; // Duplicate found!

   318                 }

   319             }

   320         }

   321     if (found)

   322         {

   323         return index;

   324         }

   325     return KErrNotFound;

   326     }

   327 

   328     

   329 

   330 

   331 

   332 void mt_basicoperationsplugin::MT_ScriptTest_equals_L(  )

   333     {

   334     RThread thread;

   335     CleanupClosePushL(thread);

   336 

   337     TInt id = iCFFakeEnv->AddScript(_L("dummyscript"),

   338             _L8("dummyscript"), KMT_CfScriptEngineUid, thread);

   339     EUNIT_ASSERT_DESC( id < 0, "No parse error of dummy script" );

   340 

   341     // Define and publish context

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

   343     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

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

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

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

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

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

   349 

   350     iCFFakeEnv->ClearFireClientEvent();

   351     // load script

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

   353     id = iCFFakeEnv->AddScript(

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

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

   356     delete script;

   357 

   358     // publish context

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

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

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

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

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

   364          "Script ID does not match!" );

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

   366         "Identifier does not match!" );

   367 

   368     // Check parameters:

   369     // appUid='10005901' viewUid='00000001' msgUid='00000000' msg='msg'

   370     EUNIT_ASSERT(iCFFakeEnv->ScriptEventParameters().Count() == 4);

   371     EUNIT_ASSERT( FindParameter(iCFFakeEnv->ScriptEventParameters(),

   372         _L("appUid"), _L("10005901")) >= 0 );

   373     EUNIT_ASSERT( FindParameter(iCFFakeEnv->ScriptEventParameters(),

   374         _L("viewUid"), _L("00000001")) >= 0 );

   375     EUNIT_ASSERT( FindParameter(iCFFakeEnv->ScriptEventParameters(),

   376         _L("msgUid"), _L("00000000")) >= 0 );

   377     EUNIT_ASSERT( FindParameter(iCFFakeEnv->ScriptEventParameters(),

   378         _L("msg"), _L("msg")) >= 0 );

   379 

   380     iCFFakeEnv->ClearFireClientEvent();

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

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

   383     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   384          "Script did fired although context value did not change!" );

   385 

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

   387     iCFFakeEnv->ClearFireClientEvent();

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

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

   390     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

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

   392 

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

   394     iCFFakeEnv->ClearFireClientEvent();

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

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

   397     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   398          "Script did not fire event!" );

   399 

   400     CleanupStack::PopAndDestroy( co );

   401     CleanupStack::PopAndDestroy( &thread );

   402     }

   403 

   404 

   405 void mt_basicoperationsplugin::MT_ScriptTest_notEqual_L(  )

   406     {

   407     RThread thread;

   408     CleanupClosePushL(thread);

   409 

   410     // Define context

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

   412     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

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

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

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

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

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

   418 

   419     // load script

   420     HBufC8* script = LoadScriptFromFile(_L("test-notEqual.xml"));

   421     TInt id = iCFFakeEnv->AddScript(

   422             _L("test-notEqual.xml"), *script, KMT_CfScriptEngineUid, thread);

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

   424     delete script;

   425 

   426     // TEST 1: Should fire event if not ok value

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

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

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

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

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

   432          "Script ID does not match!" );

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

   434         "Identifier does not match!" );

   435 

   436     // TEST 2: Should not fire event if the context value did not change

   437     iCFFakeEnv->ClearFireClientEvent();

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

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

   440     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   441          "Script did fired although context value did not change!" );

   442 

   443     // TEST 3: Should not fire event if context value ok

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

   445     iCFFakeEnv->ClearFireClientEvent();

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

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

   448     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

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

   450 

   451     // TEST 4: Should fire event if context value not ok

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

   453     iCFFakeEnv->ClearFireClientEvent();

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

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

   456     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   457          "Script did not fire event!" );

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

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

   460 

   461     CleanupStack::PopAndDestroy( co );

   462     CleanupStack::PopAndDestroy( &thread );

   463     }

   464 

   465 

   466 void mt_basicoperationsplugin::MT_ScriptTest_less_L(  )

   467     {

   468     RThread thread;

   469     CleanupClosePushL(thread);

   470 

   471     // Define context

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

   473     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   474     co->SetSourceL(_L("Sensor"));

   475     co->SetTypeL(_L("X.RawValue"));

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

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

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

   479 

   480     HBufC8* script = LoadScriptFromFile(_L("test-less.xml"));

   481     TInt id = iCFFakeEnv->AddScript(

   482             _L("test-less.xml"), *script, KMT_CfScriptEngineUid, thread);

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

   484     delete script;

   485 

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

   487     co->SetValueL(_L("149")); // value in script: 150

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

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

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

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

   492          "Script ID does not match!" );

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

   494         "Identifier does not match!" );

   495 

   496     // TEST 2: Should not fire event if the context value did not change

   497     iCFFakeEnv->ClearFireClientEvent();

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

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

   500     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   501          "Script did fired although context value did not change!" );

   502 

   503     // TEST 3: Should not fire event if context value = 150

   504     co->SetValueL(_L("150"));

   505     iCFFakeEnv->ClearFireClientEvent();

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

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

   508     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

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

   510 

   511     // TEST 4: Should fire event if context value < 150

   512     co->SetValueL(_L("-1"));

   513     iCFFakeEnv->ClearFireClientEvent();

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

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

   516     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   517          "Script did not fire event!" );

   518 

   519     CleanupStack::PopAndDestroy( co );

   520     CleanupStack::PopAndDestroy( &thread );

   521     }

   522 

   523 

   524 void mt_basicoperationsplugin::MT_ScriptTest_greater_L(  )

   525     {

   526     RThread thread;

   527     CleanupClosePushL(thread);

   528 

   529     // Define context

   530     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

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

   532     co->SetSourceL(_L("Sensor"));

   533     co->SetTypeL(_L("X.RawValue"));

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

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

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

   537 

   538     HBufC8* script = LoadScriptFromFile(_L("test-greater.xml"));

   539     TInt id = iCFFakeEnv->AddScript(

   540             _L("test-greater.xml"), *script, KMT_CfScriptEngineUid, thread);

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

   542     delete script;

   543 

   544     // TEST 1: Should fire event if value > 149

   545     co->SetValueL(_L("150")); // value in script: 149

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

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

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

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

   550          "Script ID does not match!" );

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

   552         "Identifier does not match!" );

   553 

   554     // TEST 2: Should not fire event if the context value did not change

   555     iCFFakeEnv->ClearFireClientEvent();

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

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

   558     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   559          "Script did fired although context value did not change!" );

   560 

   561     // TEST 3: Should not fire event if context value = 149

   562     co->SetValueL(_L("149"));

   563     iCFFakeEnv->ClearFireClientEvent();

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

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

   566     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

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

   568 

   569     // TEST 4: Should fire event if context value > 149

   570     co->SetValueL(_L("17400"));

   571     iCFFakeEnv->ClearFireClientEvent();

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

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

   574     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   575          "Script did not fire event!" );

   576 

   577     CleanupStack::PopAndDestroy( co );

   578     CleanupStack::PopAndDestroy( &thread );

   579     }

   580 

   581 void mt_basicoperationsplugin::MT_ScriptTest_lessOrEqual_L(  )

   582     {

   583     RThread thread;

   584     CleanupClosePushL(thread);

   585 

   586     // Define and publish context

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

   588     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   589 

   590     co->SetSourceL(_L("Sensor"));

   591     co->SetTypeL(_L("Y.RawValue"));

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

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

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

   595 

   596     HBufC8* script = LoadScriptFromFile(_L("test-lessOrEqual.xml"));

   597     TInt id = iCFFakeEnv->AddScript(

   598             _L("test-lessOrEqual.xml"), *script, KMT_CfScriptEngineUid, thread);

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

   600     delete script;

   601 

   602     // TEST 1: Should fire event if value <= 150

   603     co->SetValueL(_L("150")); // value in script: 150

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

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

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

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

   608          "Script ID does not match!" );

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

   610         "Identifier does not match!" );

   611 

   612     // TEST 2: Should not fire event if the context value did not change

   613     iCFFakeEnv->ClearFireClientEvent();

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

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

   616     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   617          "Script did fired although context value did not change!" );

   618 

   619     // TEST 3: Should not fire event if context value > 150

   620     co->SetValueL(_L("151"));

   621     iCFFakeEnv->ClearFireClientEvent();

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

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

   624     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

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

   626 

   627     // TEST 4: Should fire event if context value <= 150

   628     co->SetValueL(_L("-378"));

   629     iCFFakeEnv->ClearFireClientEvent();

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

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

   632     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   633          "Script did not fire event!" );

   634 

   635     CleanupStack::PopAndDestroy( co );

   636     CleanupStack::PopAndDestroy( &thread );

   637     }

   638 

   639 

   640 void mt_basicoperationsplugin::MT_ScriptTest_greaterOrEqual_L(  )

   641     {

   642     RThread thread;

   643     CleanupClosePushL(thread);

   644 

   645     // Define context

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

   647     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   648 

   649     co->SetSourceL(_L("Sensor"));

   650     co->SetTypeL(_L("Y.RawValue"));

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

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

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

   654 

   655     HBufC8* script = LoadScriptFromFile(_L("test-greaterOrEqual.xml"));

   656     TInt id = iCFFakeEnv->AddScript(_L("test-greaterOrEqual.xml"),

   657             *script, KMT_CfScriptEngineUid, thread);

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

   659     delete script;

   660 

   661     // TEST 1: Should fire event if value >= 151

   662     co->SetValueL(_L("151")); // value in script: 151

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

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

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

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

   667          "Script ID does not match!" );

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

   669         "Identifier does not match!" );

   670 

   671     // TEST 2: Should not fire event if the context value did not change

   672     iCFFakeEnv->ClearFireClientEvent();

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

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

   675     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   676          "Script did fired although context value did not change!" );

   677 

   678     // TEST 3: Should not fire event if context value < 151

   679     co->SetValueL(_L("150"));

   680     iCFFakeEnv->ClearFireClientEvent();

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

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

   683     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

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

   685 

   686     // TEST 4: Should fire event if context value >= 150

   687     co->SetValueL(_L("23689"));

   688     iCFFakeEnv->ClearFireClientEvent();

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

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

   691     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   692          "Script did not fire event!" );

   693 

   694     CleanupStack::PopAndDestroy( co );

   695     CleanupStack::PopAndDestroy( &thread );

   696     }

   697 

   698 

   699 void mt_basicoperationsplugin::MT_ScriptTest_contains_L(  )

   700     {

   701     RThread thread;

   702     CleanupClosePushL(thread);

   703 

   704     TInt id = iCFFakeEnv->AddScript(_L("dummyscript"), 

   705             _L8("dummyscript"), KMT_CfScriptEngineUid, thread);

   706     EUNIT_ASSERT_DESC( id < 0, "No parse error of dummy script" );

   707 

   708     // Define and publish context

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

   710     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

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

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

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

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

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

   716 

   717     iCFFakeEnv->ClearFireClientEvent();

   718 

   719     // load script

   720     HBufC8* script = LoadScriptFromFile(_L("test-contains.xml"));

   721     id = iCFFakeEnv->AddScript(

   722             _L("test-contains.xml"), *script, KMT_CfScriptEngineUid, thread);

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

   724     delete script;

   725 

   726     // publish context

   727     co->SetValueL(_L("sisaltaa"));

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

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

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

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

   732          "Script ID does not match!" );

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

   734         "Identifier does not match!" );

   735 

   736     // Check parameters:

   737     // appUid='10005901' viewUid='00000001' msgUid='00000000' msg='msg'

   738     EUNIT_ASSERT(iCFFakeEnv->ScriptEventParameters().Count() == 4);

   739     EUNIT_ASSERT( FindParameter(iCFFakeEnv->ScriptEventParameters(),

   740         _L("appUid"), _L("10005901")) >= 0 );

   741     EUNIT_ASSERT( FindParameter(iCFFakeEnv->ScriptEventParameters(),

   742         _L("viewUid"), _L("00000001")) >= 0 );

   743     EUNIT_ASSERT( FindParameter(iCFFakeEnv->ScriptEventParameters(),

   744         _L("msgUid"), _L("00000000")) >= 0 );

   745     EUNIT_ASSERT( FindParameter(iCFFakeEnv->ScriptEventParameters(),

   746         _L("msg"), _L("msg")) >= 0 );

   747 

   748     iCFFakeEnv->ClearFireClientEvent();

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

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

   751     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   752          "Script did fired although context value did not change!" );

   753 

   754     co->SetValueL(_L("sisalt"));

   755     iCFFakeEnv->ClearFireClientEvent();

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

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

   758     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

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

   760 

   761     co->SetValueL(_L("isalta"));

   762     iCFFakeEnv->ClearFireClientEvent();

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

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

   765     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   766          "Script did not fire event!" );

   767 

   768     CleanupStack::PopAndDestroy( co );

   769     CleanupStack::PopAndDestroy( &thread );

   770     }

   771 

   772 void mt_basicoperationsplugin::MT_ScriptTest_inRange_L(  )

   773     {

   774     RThread thread;

   775     CleanupClosePushL(thread);

   776 

   777     // Define context

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

   779     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   780     co->SetSourceL(_L("Sensor"));

   781     co->SetTypeL(_L("Z.RawValue"));

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

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

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

   785 

   786     // load script

   787     HBufC8* script = LoadScriptFromFile(_L("test-inRange.xml"));

   788     TInt id = iCFFakeEnv->AddScript(

   789             _L("test-inRange.xml"), *script, KMT_CfScriptEngineUid, thread);

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

   791     delete script;

   792 

   793     // TEST 1: Should fire event if value 100-200

   794     co->SetValueL(_L("100")); // range in script: 100-200

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

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

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

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

   799          "Script ID does not match!" );

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

   801         "Identifier does not match!" );

   802 

   803     // TEST 2: Should not fire event if the context value did not change

   804     iCFFakeEnv->ClearFireClientEvent();

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

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

   807     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   808          "Script did fired although context value did not change!" );

   809 

   810     // TEST 3: Should not fire event if context value is outside 100-200

   811     co->SetValueL(_L("99"));

   812     iCFFakeEnv->ClearFireClientEvent();

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

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

   815     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

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

   817 

   818     // TEST 3: Should not fire event if context value is outside 100-200

   819     co->SetValueL(_L("201"));

   820     iCFFakeEnv->ClearFireClientEvent();

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

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

   823     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

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

   825 

   826     // TEST 4: Should fire event if context value in range 100-200

   827     co->SetValueL(_L("200"));

   828     iCFFakeEnv->ClearFireClientEvent();

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

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

   831     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   832          "Script did not fire event!" );

   833 

   834     CleanupStack::PopAndDestroy( co );

   835     CleanupStack::PopAndDestroy( &thread );

   836     }

   837 

   838 void mt_basicoperationsplugin::MT_ScriptTest_contextChanged_L(  )

   839     {

   840     RThread thread;

   841     CleanupClosePushL(thread);

   842 

   843     // Define context

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

   845     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   846     co->SetSourceL(_L("Application.State"));

   847     co->SetTypeL(_L("Foreground.View"));

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

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

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

   851 

   852     // load script

   853     HBufC8* script = LoadScriptFromFile(_L("test-contextChanged.xml"));

   854     TInt id = iCFFakeEnv->AddScript(_L("test-contextChanged.xml"),

   855             *script, KMT_CfScriptEngineUid, thread);

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

   857     delete script;

   858 

   859     iCFFakeEnv->ClearFireClientEventCount();

   860 

   861     // TEST 1: Context Changed, should fire event

   862     co->SetValueL(_L("WebBrowser"));

   863     iCFFakeEnv->ClearFireClientEvent();

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

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

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

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

   868          "Script ID does not match!" );

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

   870         "Identifier does not match!" );

   871 

   872     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFiredCount() == 1,

   873         "Wrong amount of events!" );

   874 

   875     // TEST 2: Should not fire event if the context value did not change

   876     iCFFakeEnv->ClearFireClientEvent();

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

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

   879     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   880          "Script did fired although context value did not change!" );

   881 

   882     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFiredCount() == 1,

   883         "Wrong amount of events!" );

   884 

   885     // TEST 3: Should not fire again if value is changed

   886     co->SetValueL(_L("WormGame"));

   887     iCFFakeEnv->ClearFireClientEvent();

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

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

   890     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   891          "Script did not fired although context changed!" );

   892 

   893     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFiredCount() == 2,

   894         "Wrong amount of events!" );

   895 

   896     CleanupStack::PopAndDestroy( co );

   897     CleanupStack::PopAndDestroy( &thread );

   898     }

   899 

   900 void mt_basicoperationsplugin::MT_ScriptTest_contextUpdated_L(  )

   901     {

   902     RThread thread;

   903     CleanupClosePushL(thread);

   904 

   905     // Define and publish context

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

   907     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   908     co->SetSourceL(_L("Application.State"));

   909     co->SetTypeL(_L("Foreground.View"));

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

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

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

   913 

   914     // load script

   915     HBufC8* script = LoadScriptFromFile(_L("test-contextUpdated.xml"));

   916     TInt id = iCFFakeEnv->AddScript(_L("test-contextUpdated.xml"),

   917             *script, KMT_CfScriptEngineUid, thread);

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

   919     delete script;

   920 

   921     iCFFakeEnv->ClearFireClientEventCount();

   922 

   923     // TEST 1: Context Changed, should fire event

   924     co->SetValueL(_L("WebBrowser"));

   925     iCFFakeEnv->ClearFireClientEvent();

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

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

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

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

   930          "Script ID does not match!" );

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

   932         "Identifier does not match!" );

   933 

   934     // TEST 2: Should fire event even if the context value did not change

   935     iCFFakeEnv->ClearFireClientEvent();

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

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

   938     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   939          "Script did not fired!" );

   940 

   941     // TEST 3: Should not fire again if value is changed

   942     co->SetValueL(_L("WormGame"));

   943     iCFFakeEnv->ClearFireClientEvent();

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

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

   946     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   947          "Script did not fired although context changed!" );

   948 

   949     CleanupStack::PopAndDestroy( co );

   950     CleanupStack::PopAndDestroy( &thread );

   951     }

   952 

   953 void mt_basicoperationsplugin::MT_ScriptTest_and_L(  )

   954     {

   955     RThread thread;

   956     CleanupClosePushL(thread);

   957 

   958     // Define contexts

   959     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

   960     CCFContextObject* co1 = CCFContextObject::NewLC();

   961     co1->SetSourceL(_L("Application.State"));

   962     co1->SetTypeL(_L("Foreground.Application"));

   963     TInt err = iCFFakeEnv->DefineContext( co1->Source(),

   964             co1->Type(), alwaysPass, alwaysPass );

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

   966 

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

   968     co2->SetSourceL(_L("Application.State"));

   969     co2->SetTypeL(_L("Foreground.View"));

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

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

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

   973 

   974     // load script

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

   976     TInt id = iCFFakeEnv->AddScript(

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

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

   979     delete script;

   980 

   981     iCFFakeEnv->ClearFireClientEventCount();

   982 

   983     // TEST 1: Only first context published should not cause event

   984     co1->SetValueL(_L("MusicPlayer"));

   985     iCFFakeEnv->ClearFireClientEvent();

   986     err = iCFFakeEnv->PublishContext( *co1, thread );

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

   988     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

   989         "Script cause event although both contexts not set!" );

   990 

   991     // TEST 2: Both contexts published with right values should cause event

   992     co2->SetValueL(_L("NowPlaying"));

   993     iCFFakeEnv->ClearFireClientEvent();

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

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

   996     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

   997         "Script did not cause event although both context set with right values!" );

   998 

   999     // TEST 3: Publish Context 1 again, no event should come

  1000     iCFFakeEnv->ClearFireClientEvent();

  1001     err = iCFFakeEnv->PublishContext( *co1, thread );

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

  1003     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

  1004         "Script did cause event althought context 1 did not change!" );

  1005 

  1006     // TEST 4: Change context 1 to wrong value, no event should come

  1007     co1->SetValueL(_L("WebBrowser"));

  1008     iCFFakeEnv->ClearFireClientEvent();

  1009     err = iCFFakeEnv->PublishContext( *co1, thread );

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

  1011     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

  1012         "Script did cause event althought context 1 did not change!" );

  1013 

  1014     // TEST 5: Change context 1 to right value, event should come

  1015     co1->SetValueL(_L("MusicPlayer"));

  1016     iCFFakeEnv->ClearFireClientEvent();

  1017     err = iCFFakeEnv->PublishContext( *co1, thread );

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

  1019     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

  1020         "Script did not cause event although both contexts have right value!" );

  1021 

  1022     CleanupStack::PopAndDestroy( co2 );

  1023     CleanupStack::PopAndDestroy( co1 );

  1024     CleanupStack::PopAndDestroy( &thread );

  1025     }

  1026 

  1027 void mt_basicoperationsplugin::MT_ScriptTest_and_contextChanged_L(  )

  1028     {

  1029     RThread thread;

  1030     CleanupClosePushL(thread);

  1031 

  1032     // Define and publish context

  1033     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

  1034     CCFContextObject* co1 = CCFContextObject::NewLC();

  1035     co1->SetSourceL(_L("Application.State"));

  1036     co1->SetTypeL(_L("Foreground.Application"));

  1037     TInt err = iCFFakeEnv->DefineContext( co1->Source(),

  1038             co1->Type(), alwaysPass, alwaysPass );

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

  1040 

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

  1042     co2->SetSourceL(_L("Application.State"));

  1043     co2->SetTypeL(_L("Foreground.View"));

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

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

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

  1047 

  1048     // load script

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

  1050     TInt id = iCFFakeEnv->AddScript(_L("test-and-contextChanged.xml"),

  1051             *script, KMT_CfScriptEngineUid, thread);

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

  1053     delete script;

  1054 

  1055     iCFFakeEnv->ClearFireClientEventCount();

  1056 

  1057     // TEST 1: Only first context published should not cause event

  1058     co1->SetValueL(_L("MusicPlayer"));

  1059     iCFFakeEnv->ClearFireClientEvent();

  1060     err = iCFFakeEnv->PublishContext( *co1, thread );

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

  1062     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

  1063         "Script cause event although both contexts not set!" );

  1064 

  1065     // TEST 2: Both contexts published with right values should cause event

  1066     co2->SetValueL(_L("NowPlaying"));

  1067     iCFFakeEnv->ClearFireClientEvent();

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

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

  1070     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

  1071         "Script did not cause event although both context set with right values!" );

  1072 

  1073     // TEST 3: Publish Context 2 again, no event should come

  1074     iCFFakeEnv->ClearFireClientEvent();

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

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

  1077     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

  1078         "Script did cause event althought context 1 did not change!" );

  1079 

  1080     // TEST 4: Change context 1 to wrong value, no event should come

  1081     co1->SetValueL(_L("WebBrowser"));

  1082     iCFFakeEnv->ClearFireClientEvent();

  1083     err = iCFFakeEnv->PublishContext( *co1, thread );

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

  1085     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

  1086         "Script did cause event althought context 1 did not change!" );

  1087 

  1088     // TEST 5: Change context 1 to right value, no event should come

  1089     // because contextChanged -operation

  1090     co1->SetValueL(_L("MusicPlayer"));

  1091     iCFFakeEnv->ClearFireClientEvent();

  1092     err = iCFFakeEnv->PublishContext( *co1, thread );

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

  1094     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

  1095         "Script did cause event despite of contextChanged-operation!" );

  1096 

  1097     // TEST 6: Change context 2 to wrong value, no event should come

  1098     co2->SetValueL(_L("Playlist"));

  1099     iCFFakeEnv->ClearFireClientEvent();

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

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

  1102     EUNIT_ASSERT_DESC( !iCFFakeEnv->ClientEventFired(),

  1103         "Script cause event although context 2 changed to wrong value!" );

  1104 

  1105     // TEST 7: Change context 2 to right value, event should come

  1106     co2->SetValueL(_L("NowPlaying"));

  1107     iCFFakeEnv->ClearFireClientEvent();

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

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

  1110     EUNIT_ASSERT_DESC( iCFFakeEnv->ClientEventFired(),

  1111         "Script did not cause event although context 2 changed to right value!" );

  1112 

  1113     CleanupStack::PopAndDestroy( co2 );

  1114     CleanupStack::PopAndDestroy( co1 );

  1115     CleanupStack::PopAndDestroy( &thread );

  1116     }

  1117 

  1118 void mt_basicoperationsplugin::MT_ScriptTest_and_contextUpdated_L(  )

  1119     {

  1120     RThread thread;

  1121     CleanupClosePushL(thread);

  1122 

  1123     // Define context

  1124     static _LIT_SECURITY_POLICY_PASS( alwaysPass );

  1125     CCFContextObject* co1 = CCFContextObject::NewLC();

  1126     co1->SetSourceL(_L("Sensor"));

  1127     co1->SetTypeL(_L("DoubleTap"));

  1128     TInt err = iCFFakeEnv->DefineContext( co1->Source(),

  1129             co1->Type(), alwaysPass, alwaysPass );

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

  1131 

  1132     // load script

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

  1134     TInt id = iCFFakeEnv->AddScript(_L("test-and-contextUpdated.xml"),