1 /*

     2  * ============================================================================

     3  *  Name        : testflexperiodic.cpp

     4  *  Part of     : src / testflextimer

     5  *  Description : STIF test cases for CFlexPeriodic timer.

     6  *  Version     : %version: 1 %

     7  *

     8  *  Copyright © 2010 Nokia Corporation and/or its subsidiary(-ies).

     9  *  All rights reserved.

    10  *  This component and the accompanying materials are made available

    11  *  under the terms of the License "Eclipse Public License v1.0"

    12  *  which accompanies this distribution, and is available

    13  *  at the URL "http://www.eclipse.org/legal/epl-v10.html".

    14  *

    15  *  Initial Contributors:

    16  *  Nokia Corporation - initial contribution.

    17  *

    18  *  Contributors:

    19  *  Nokia Corporation

    20  * ============================================================================

    21  * Template version: 4.1

    22  */

    23 

    24 #include <e32debug.h>           // for RDebug

    25 #include <e32math.h>             // for Math::Rand()

    26 #include <StifTestInterference.h>

    27 #include "testflextimer.h"      // for global constants & CB

    28 #include "testcflextimer.h"

    29 #include "flextimerpanic.h"     // for panic constants

    30 #include "inheritedcflextimer.h"// CFlexTimer implementation (CB is always TExtendedTestResult*)

    31 #include "inheritedcflextimer2.h"// another CFlexTimer implementation (CB is always RArray<TTimerStruct> *list)

    32 // ======== LOCAL FUNCTIONS ========

    33 

    34 // ======== MEMBER FUNCTIONS ========

    35 

    36 const TInt64 KTickResolution( 1000000 / 64 );

    37 const TInt KExtraSlack = 500 * 1000;

    38 // ---------------------------------------------------------------------------

    39 // Constructor

    40 // ---------------------------------------------------------------------------

    41 //

    42 CTestCFlexTimer::CTestCFlexTimer()

    43     {

    44     }

    45 

    46 // ---------------------------------------------------------------------------

    47 // Destructor

    48 // ---------------------------------------------------------------------------

    49 //

    50 CTestCFlexTimer::~CTestCFlexTimer()

    51     {

    52     }

    53 // --------------------------------------------------------------------------

    54 // Start timer and delete it.

    55 // --------------------------------------------------------------------------

    56 //

    57 TInt CTestCFlexTimer::CreateAndDestroyCFlexTimerL( TTestResult& aResult,

    58         CTestFlexTimer */*cb*/)

    59     {

    60     TExtendedTestResult *eResult = new TExtendedTestResult(&aResult);

    61     CInheritedCFlexTimer

    62             * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard,

    63                     TCallBack(

    64                             InheritedFlexTimerCallbackStopSchedulerKErrNone,

    65                             eResult));

    66 

    67     TTimeIntervalMicroSeconds32 expireTime(5 * 1000 * 1000); //5s

    68     timer->After(expireTime);

    69     CActiveScheduler::Start();

    70 

    71     delete timer;

    72     timer = NULL;

    73     _LIT( KDescription , "Test case passed");

    74     aResult.SetResult(KErrNone, KDescription);

    75     delete eResult;

    76     return KErrNone;

    77 

    78     }

    79 

    80 // --------------------------------------------------------------------------

    81 // Start timer and see that it expires at max time

    82 // --------------------------------------------------------------------------

    83 //

    84 TInt CTestCFlexTimer::CreateAndExpireCFlexTimerL( TTestResult& aResult,

    85         CTestFlexTimer */*cb*/)

    86     {

    87     TExtendedTestResult *eResult = new TExtendedTestResult(&aResult);

    88     CInheritedCFlexTimer

    89             * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard,

    90                     TCallBack(

    91                             InheritedFlexTimerCallbackStopSchedulerKErrNone,

    92                             eResult));

    93 

    94     // Expire in 5 seconds

    95     TTimeIntervalMicroSeconds32 expireTime(5 * 1000 * 1000);

    96 

    97     // Save current time.

    98     TTime utcNow(0);

    99     utcNow.UniversalTime();

   100 

   101     timer->After(expireTime);

   102 

   103     // Start scheduler and wait for callback to stop it

   104     CActiveScheduler::Start();

   105     //See if CB has failed the case

   106     if (eResult->iCaseAlreadyFailed)

   107         {

   108         delete timer;

   109         delete eResult;

   110         return KErrNone;

   111         }

   112     // Get new current time

   113     TTime utcNow2(0);

   114     utcNow2.UniversalTime();

   115 

   116     //Check if timer expiry happened within maxtime to maxtime+accuracy

   117     if ((utcNow + expireTime) <= utcNow2 && (utcNow + expireTime

   118             + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds))

   119             > utcNow2)

   120         {

   121         _LIT( KDescription , "Passed");

   122         aResult.SetResult(KErrNone, KDescription);

   123         }

   124     else

   125         {

   126         _LIT( KDescription , "Timer was fired either too early or too late.\n");

   127         aResult.SetResult(KErrGeneral, KDescription);

   128         }

   129     // Case was executed

   130     delete timer;

   131     delete eResult;

   132     return KErrNone;

   133 

   134     }

   135 

   136 // --------------------------------------------------------------------------

   137 // Start two timers and see that they expire at the same time.

   138 // --------------------------------------------------------------------------

   139 //

   140 TInt CTestCFlexTimer::CreateAndExpireTwoOverlappingAfterTimersL(

   141         TTestResult& aResult, CTestFlexTimer */*cb*/)

   142     {

   143     TTestResult *res1 = new TTestResult();

   144     TTestResult *res2 = new TTestResult();

   145     TExtendedTestResult *eResult1 = new TExtendedTestResult(res1);

   146     TExtendedTestResult *eResult2 = new TExtendedTestResult(res2);

   147     eResult1->iTimerID = 1;

   148     eResult2->iTimerID = 2;

   149     CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL(

   150             CActive::EPriorityStandard,

   151             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   152                     eResult1));

   153     CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL(

   154             CActive::EPriorityStandard,

   155             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   156                     eResult2));

   157     // Expire in 10 seconds

   158     TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000);

   159     //Expire within first timers default window

   160     TTimeIntervalMicroSeconds32 expireTime2(static_cast<TInt64> ((10 * 1000

   161             * 1000 - static_cast<float> (10 * 1000 * 1000)

   162             * KDefaultWindowMultiplier)));

   163 

   164     // Save current time

   165     TTime utcNow(0);

   166     utcNow.UniversalTime();

   167 

   168     timer1->After(expireTime1);

   169     timer2->After(expireTime2);

   170 

   171     //Timer to stop active scheduler after timers under test are completed.

   172     CPeriodic *p = CPeriodic::NewL(EPriorityNormal);

   173     p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler));

   174     // Start scheduler and wait for callback to stop it

   175     CActiveScheduler::Start();

   176     delete p;

   177     //See if CB has failed the case

   178     if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed)

   179         {

   180         if (eResult1->iCaseAlreadyFailed)

   181             {

   182             aResult.SetResult(eResult1->iTestResult->iResult,

   183                     eResult1->iTestResult->iResultDes);

   184             }

   185         else

   186             {

   187             aResult.SetResult(eResult2->iTestResult->iResult,

   188                     eResult2->iTestResult->iResultDes);

   189             }

   190         delete timer1;

   191         delete timer2;

   192         delete eResult1;

   193         delete eResult2;

   194         delete res1;

   195         delete res2;

   196         return KErrNone;

   197         }

   198 

   199     //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy

   200     if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution)

   201             && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32(

   202                     KTimerAccuracyMicroSeconds)) > TTime(

   203                     eResult2->iTimerStoppedTime) &&

   204 

   205     (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow

   206             + expireTime2 + TTimeIntervalMicroSeconds32(

   207             KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime))

   208         {

   209         _LIT( KDescription , "Passed");

   210         aResult.SetResult(KErrNone, KDescription);

   211         }

   212     else

   213         {

   214         _LIT( KDescription , "Some timer was fired either too early or too late.\n");

   215         RDebug::Printf("utcNow = %lld\n", utcNow.Int64());

   216         RDebug::Printf("eResult1->iTimerStoppedTime = %lld\n",

   217                 eResult1->iTimerStoppedTime);

   218         RDebug::Printf("eResult2->iTimerStoppedTime = %lld\n",

   219                 eResult2->iTimerStoppedTime);

   220         aResult.SetResult(KErrGeneral, KDescription);

   221         }

   222     // Case was executed

   223     delete timer1;

   224     delete timer2;

   225     delete eResult1;

   226     delete eResult2;

   227     delete res1;

   228     delete res2;

   229     return KErrNone;

   230 

   231     }

   232 

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

   234 // Start two timers and see that they expire at the same time. 64bit version

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

   236 //

   237 TInt CTestCFlexTimer::CreateAndExpireTwoOverlappingAfterTimers64L(

   238         TTestResult& aResult, CTestFlexTimer */*cb*/)

   239     {

   240     TTestResult *res1 = new TTestResult();

   241     TTestResult *res2 = new TTestResult();

   242     TExtendedTestResult *eResult1 = new TExtendedTestResult(res1);

   243     TExtendedTestResult *eResult2 = new TExtendedTestResult(res2);

   244     eResult1->iTimerID = 1;

   245     eResult2->iTimerID = 2;

   246     CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL(

   247             CActive::EPriorityStandard,

   248             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   249                     eResult1));

   250     CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL(

   251             CActive::EPriorityStandard,

   252             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   253                     eResult2));

   254     // Expire in 10 seconds

   255     TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000);

   256     //Expire within first timers default window

   257     TTimeIntervalMicroSeconds expireTime2(static_cast<TInt64> ((10 * 1000

   258             * 1000 - static_cast<float> (10 * 1000 * 1000)

   259             * KDefaultWindowMultiplier)));

   260 

   261     // Save current time

   262     TTime utcNow(0);

   263     utcNow.UniversalTime();

   264 

   265     timer1->After(expireTime1);

   266     timer2->After(expireTime2);

   267 

   268     //Timer to stop active scheduler after timers under test are completed.

   269     CPeriodic *p = CPeriodic::NewL(EPriorityNormal);

   270     p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler));

   271     // Start scheduler and wait for callback to stop it

   272     CActiveScheduler::Start();

   273     delete p;

   274     //See if CB has failed the case

   275     if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed)

   276         {

   277         if (eResult1->iCaseAlreadyFailed)

   278             {

   279             aResult.SetResult(eResult1->iTestResult->iResult,

   280                     eResult1->iTestResult->iResultDes);

   281             }

   282         else

   283             {

   284             aResult.SetResult(eResult2->iTestResult->iResult,

   285                     eResult2->iTestResult->iResultDes);

   286             }

   287         delete timer1;

   288         delete timer2;

   289         delete eResult1;

   290         delete eResult2;

   291         delete res1;

   292         delete res2;

   293         return KErrNone;

   294         }

   295     // Get new current time

   296     TTime utcNow2(0);

   297     utcNow2.UniversalTime();

   298 

   299     //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy

   300     if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution)

   301             && (utcNow + expireTime2 + TTimeIntervalMicroSeconds(

   302                     KTimerAccuracyMicroSeconds)) > TTime(

   303                     eResult2->iTimerStoppedTime) &&

   304 

   305     (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow

   306             + expireTime2 + TTimeIntervalMicroSeconds(

   307             KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime))

   308         {

   309         _LIT( KDescription , "Passed");

   310         aResult.SetResult(KErrNone, KDescription);

   311         }

   312     else

   313         {

   314         _LIT( KDescription , "Some timer was fired either too early or too late.\n");

   315         aResult.SetResult(KErrGeneral, KDescription);

   316         }

   317     // Case was executed

   318     delete timer1;

   319     delete timer2;

   320     delete eResult1;

   321     delete eResult2;

   322     delete res1;

   323     delete res2;

   324     return KErrNone;

   325 

   326     }

   327 

   328 // --------------------------------------------------------------------------

   329 // Start two timers and see that they expire at their own max time.

   330 // --------------------------------------------------------------------------

   331 //

   332 TInt CTestCFlexTimer::CreateAndExpireTwoNonOverlappingAfterTimersL(

   333         TTestResult& aResult, CTestFlexTimer */*cb*/)

   334     {

   335     TTestResult *res1 = new TTestResult();

   336     TTestResult *res2 = new TTestResult();

   337     TExtendedTestResult *eResult1 = new TExtendedTestResult(res1);

   338     TExtendedTestResult *eResult2 = new TExtendedTestResult(res2);

   339     eResult1->iTimerID = 1;

   340     eResult2->iTimerID = 2;

   341     CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL(

   342             CActive::EPriorityStandard,

   343             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   344                     eResult1));

   345     CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL(

   346             CActive::EPriorityStandard,

   347             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   348                     eResult2));

   349     // Expire in 10 seconds

   350     TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000);

   351     //Expire one second before first timers window starts

   352     TTimeIntervalMicroSeconds32 expireTime2(static_cast<TInt64> ((10 * 1000

   353             * 1000 - static_cast<float> (10 * 1000 * 1000)

   354             * KDefaultWindowMultiplier)) - 1 * 1000 * 1000);

   355 

   356     // Save current time

   357     TTime utcNow(0);

   358     utcNow.UniversalTime();

   359 

   360     timer1->After(expireTime1);

   361     timer2->After(expireTime2);

   362 

   363     //Timer to stop active scheduler after timers under test are completed.

   364     CPeriodic *p = CPeriodic::NewL(EPriorityNormal);

   365     p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler));

   366     // Start scheduler and wait for callback to stop it

   367     CActiveScheduler::Start();

   368     delete p;

   369     //See if CB has failed the case

   370     if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed)

   371         {

   372         if (eResult1->iCaseAlreadyFailed)

   373             {

   374             aResult.SetResult(eResult1->iTestResult->iResult,

   375                     eResult1->iTestResult->iResultDes);

   376             }

   377         else

   378             {

   379             aResult.SetResult(eResult2->iTestResult->iResult,

   380                     eResult2->iTestResult->iResultDes);

   381             }

   382         delete timer1;

   383         delete timer2;

   384         delete eResult1;

   385         delete eResult2;

   386         delete res1;

   387         delete res2;

   388         return KErrNone;

   389         }

   390     // Get new current time

   391     TTime utcNow2(0);

   392     utcNow2.UniversalTime();

   393 

   394     //Check if timers expiry happened within at their own max time edge.

   395     if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution)

   396             && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32(

   397                     KTimerAccuracyMicroSeconds)) > TTime(

   398                     eResult2->iTimerStoppedTime) &&

   399 

   400     (utcNow + expireTime1) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow

   401             + expireTime1 + TTimeIntervalMicroSeconds32(

   402             KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime))

   403         {

   404         _LIT( KDescription , "Passed");

   405         aResult.SetResult(KErrNone, KDescription);

   406         }

   407     else

   408         {

   409         _LIT( KDescription , "Some timer was fired either too early or too late.\n");

   410         aResult.SetResult(KErrGeneral, KDescription);

   411         }

   412     // Case was executed

   413     delete timer1;

   414     delete timer2;

   415     delete eResult1;

   416     delete eResult2;

   417     delete res1;

   418     delete res2;

   419     return KErrNone;

   420 

   421     }

   422 

   423 // --------------------------------------------------------------------------

   424 // Start many timers and see that nothing goes wrong when they are expired at rapid sequence

   425 // --------------------------------------------------------------------------

   426 //

   427 TInt CTestCFlexTimer::HumongousAmountOfTimeridelidilidousL(

   428         TTestResult& aResult, CTestFlexTimer */*cb*/)

   429     {

   430     RDebug::Printf("HugemongousAmountOfTimeridelidilidousL");

   431     // This list will contain all the timer structs, expiry times etc.

   432     // First cell will always tell which timer is currently active

   433     // active info is transferred from e.g. InheritedCFlexTimer2::RunL to CB function

   434     RArray<TTimerStruct> timers;

   435     // This CB contains all the logic about timer addition

   436     StartTimerAndAddToList( &timers, 2000 );

   437     // CBs stop this after all timers are expired 

   438     CActiveScheduler::Start();

   439     // Delete CPeriodic that was used to launch new FlexTimers

   440     delete timers[0].iStartTimer;

   441     _LIT( KDescriptionP , "Passed");

   442     aResult.SetResult(KErrNone, KDescriptionP);

   443     // Loop throug list and see if timers fired within limits.

   444     // also delete all stuff reserved earlier by StartTimerAndAddToList

   445     while (timers.Count())

   446         {

   447         // Have fun with reading this. It is not as bad as it looks

   448         // Just checks if CB already failed the case

   449         // and if timer was launched within its window(default) and timer accuracy

   450         if (!(!timers[0].iEResult->iCaseAlreadyFailed

   451                 && (timers[0].iEResult->iTimerStartedTime

   452                         + timers[0].iEResult->iTimerExpiryTime

   453                         - (static_cast<float> (timers[0].iEResult->iTimerExpiryTime)

   454                                 * KDefaultWindowMultiplier)

   455                         <= timers[0].iEResult->iTimerStoppedTime+KTickResolution)

   456                 && (timers[0].iEResult->iTimerStartedTime

   457                         + timers[0].iEResult->iTimerExpiryTime

   458                         + KTimerAccuracyMicroSeconds)

   459                         > timers[0].iEResult->iTimerStoppedTime))

   460             {

   461             _LIT( KDescription , "Some timer was not fired within its window.\n");

   462             aResult.SetResult(KErrGeneral, KDescription);

   463 

   464             }

   465         delete timers[0].iEResult->iTestResult;

   466         delete timers[0].iEResult;

   467         delete timers[0].iTimer;

   468         timers.Remove(0);

   469         }

   470     // Case was executed

   471     timers.Close();

   472     return KErrNone;

   473     }

   474 

   475 // --------------------------------------------------------------------------

   476 // Start three timers At, AtUTC and After and see that they are treated equally.

   477 // --------------------------------------------------------------------------

   478 //

   479 TInt CTestCFlexTimer::CreateAndExpireThreeTimersL( TTestResult& aResult,

   480         CTestFlexTimer */*cb*/)

   481     {

   482     TTestResult *res1 = new TTestResult();

   483     TTestResult *res2 = new TTestResult();

   484     TTestResult *res3 = new TTestResult();

   485     TExtendedTestResult *eResult1 = new TExtendedTestResult(res1);

   486     TExtendedTestResult *eResult2 = new TExtendedTestResult(res2);

   487     TExtendedTestResult *eResult3 = new TExtendedTestResult(res3);

   488     eResult1->iTimerID = 1;

   489     eResult2->iTimerID = 2;

   490     eResult2->iTimerID = 3;

   491     CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL(

   492             CActive::EPriorityStandard,

   493             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   494                     eResult1));

   495     CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL(

   496             CActive::EPriorityStandard,

   497             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   498                     eResult2));

   499     CInheritedCFlexTimer* timer3 = CInheritedCFlexTimer::NewL(

   500             CActive::EPriorityStandard,

   501             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   502                     eResult3));

   503     // Expire in 10 seconds

   504     TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000);

   505     //Expire within first timers default window

   506     TTimeIntervalMicroSeconds expireTime2(9 * 1000 * 1000);

   507     TTimeIntervalMicroSeconds expireTime3(3 * 1000 * 1000); // Expire far enough from others

   508 

   509     // Save current time

   510     TTime utcNow(0);

   511     utcNow.UniversalTime();

   512     TTime homeNow(0);

   513     homeNow.HomeTime();

   514 

   515     timer1->After(expireTime1);

   516     timer2->At(homeNow + expireTime2);

   517     timer3->AtUTC(utcNow + expireTime3);

   518 

   519     //Timer to stop active scheduler after timers under test are completed.

   520     CPeriodic *p = CPeriodic::NewL(EPriorityNormal);

   521     p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler));

   522     // Start scheduler and wait for callback to stop it

   523     CActiveScheduler::Start();

   524     delete p;

   525     //See if CB has failed the case

   526     if (eResult1->iCaseAlreadyFailed)

   527         {

   528         aResult.SetResult(

   529             eResult1->iTestResult->iResult,

   530             eResult1->iTestResult->iResultDes );

   531         }

   532     else if (eResult2->iCaseAlreadyFailed)

   533         {

   534         aResult.SetResult(

   535             eResult2->iTestResult->iResult,

   536             eResult2->iTestResult->iResultDes );

   537         }

   538     else if (eResult3->iCaseAlreadyFailed)

   539         {

   540         aResult.SetResult(

   541             eResult3->iTestResult->iResult,

   542             eResult3->iTestResult->iResultDes );

   543         }

   544 

   545     // Check if timers expiry happened within limits.

   546     // First and second timer at seconds timers max time and third at its own max time.

   547     //

   548     // Compare results against utcNow due timer's stopped time is UTC.

   549     else if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) && 

   550         (utcNow + expireTime2 + TTimeIntervalMicroSeconds( KTimerAccuracyMicroSeconds)) > TTime( eResult2->iTimerStoppedTime) &&

   551 

   552         (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && 

   553         (utcNow + expireTime2 + TTimeIntervalMicroSeconds( KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime) &&

   554 

   555         (utcNow + expireTime3) <= TTime(eResult3->iTimerStoppedTime+KTickResolution) && 

   556         (utcNow + expireTime3 + TTimeIntervalMicroSeconds( KTimerAccuracyMicroSeconds)) > TTime( eResult3->iTimerStoppedTime))

   557         {

   558         _LIT( KDescription , "Passed");

   559         aResult.SetResult(KErrNone, KDescription);

   560         }

   561     else

   562         {

   563         _LIT( KDescription , "Some timer was fired either too early or too late.\n");

   564         aResult.SetResult(KErrGeneral, KDescription);

   565         }

   566     // Case was executed

   567     delete timer1;

   568     delete timer2;

   569     delete timer3;

   570     delete eResult1;

   571     delete eResult2;

   572     delete eResult3;

   573     delete res1;

   574     delete res2;

   575     delete res3;

   576     return KErrNone;

   577     }

   578 

   579 // --------------------------------------------------------------------------

   580 // Start three timers At, AtUTC and After and see that they can be cancelled.

   581 // --------------------------------------------------------------------------

   582 //

   583 TInt CTestCFlexTimer::NormalCancelL( TTestResult& aResult, CTestFlexTimer */*cb*/)

   584     {

   585     TTestResult *res1 = new TTestResult();

   586     TTestResult *res2 = new TTestResult();

   587     TTestResult *res3 = new TTestResult();

   588     TExtendedTestResult *eResult1 = new TExtendedTestResult(res1);

   589     TExtendedTestResult *eResult2 = new TExtendedTestResult(res2);

   590     TExtendedTestResult *eResult3 = new TExtendedTestResult(res3);

   591     eResult1->iTimerID = 0;

   592     eResult2->iTimerID = 1;

   593     eResult3->iTimerID = 2;

   594     CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL(

   595             CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult1), 0);

   596     CInheritedCFlexTimer2* timer2 = CInheritedCFlexTimer2::NewL(

   597             CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult2), 1);

   598     CInheritedCFlexTimer2* timer3 = CInheritedCFlexTimer2::NewL(

   599             CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult3), 2);

   600     // Expire in 10 seconds

   601     TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000);

   602     //just something

   603     TTimeIntervalMicroSeconds expireTime2(static_cast<TInt64> ((10 * 1000

   604             * 1000 - static_cast<float> (10 * 1000 * 1000)

   605             * KDefaultWindowMultiplier)));

   606     TTimeIntervalMicroSeconds expireTime3(7 * 1000 * 1000); // just something

   607     RArray<TTimerStruct> timers;

   608     TTimerStruct *s1 = new TTimerStruct();

   609     s1->iEResult = eResult1;

   610     s1->iTimer = timer1;

   611     timers.Append(*s1);

   612     TTimerStruct *s2 = new TTimerStruct();

   613     s2->iEResult = eResult2;

   614     s2->iTimer = timer2;

   615     timers.Append(*s2);

   616     TTimerStruct *s3 = new TTimerStruct();

   617     s3->iEResult = eResult3;

   618     s3->iTimer = timer3;

   619     timers.Append(*s3);

   620     // Save current time

   621     TTime utcNow(0);

   622     utcNow.UniversalTime();

   623     TTime homeNow(0);

   624     homeNow.HomeTime();

   625 

   626     timer1->After(expireTime1);

   627     timer2->At(homeNow + expireTime2);

   628     timer3->AtUTC(utcNow + expireTime3);

   629 

   630     timers[0].iCurrentlyActive = 0; //CB uses this to decide which timer to cancel;

   631 

   632     //Timer to cancel timers under test and cancel active scheduler

   633     CPeriodic *p = CPeriodic::NewL(EPriorityNormal);

   634     p->Start(15 * 1000 * 1000, 30 * 1000 * 1000, TCallBack(

   635             StopActiveScheduler));

   636     CPeriodic *pp = CPeriodic::NewL(EPriorityNormal);

   637     s1->iStartTimer = pp;

   638     pp->Start(3 * 1000 * 1000, 30 * 1000 * 1000, TCallBack(

   639             CancelCFlexTimerArray, &timers));

   640     CPeriodic *ppp = CPeriodic::NewL(EPriorityNormal);

   641     s2->iStartTimer = ppp;

   642     ppp->Start(4 * 1000 * 1000, 30 * 1000 * 1000, TCallBack(

   643             CancelCFlexTimerArray, &timers));

   644     CPeriodic *pppp = CPeriodic::NewL(EPriorityNormal);

   645     s3->iStartTimer = pppp;

   646     pppp->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack(

   647             CancelCFlexTimerArray, &timers));

   648     // Start scheduler and wait for callback to stop it

   649     CActiveScheduler::Start();

   650     delete p;

   651     delete pp;

   652     delete ppp;

   653     delete pppp;

   654     delete s1;

   655     delete s2;

   656     delete s3;

   657     _LIT( KDescription , "Passed");

   658     aResult.SetResult(KErrNone, KDescription);

   659     //See if CB has failed the case

   660     if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed

   661             || eResult3->iCaseAlreadyFailed)

   662         {

   663         if (eResult1->iCaseAlreadyFailed)

   664             {

   665             aResult.SetResult(eResult1->iTestResult->iResult,

   666                     eResult1->iTestResult->iResultDes);

   667             }

   668         if (eResult2->iCaseAlreadyFailed)

   669             {

   670             aResult.SetResult(eResult2->iTestResult->iResult,

   671                     eResult2->iTestResult->iResultDes);

   672             }

   673         else

   674             {

   675             aResult.SetResult(eResult3->iTestResult->iResult,

   676                     eResult3->iTestResult->iResultDes);

   677             }

   678         }

   679     delete timer1;

   680     delete timer2;

   681     delete timer3;

   682     delete eResult1;

   683     delete eResult2;

   684     delete eResult3;

   685     delete res1;

   686     delete res2;

   687     delete res3;

   688     return KErrNone;

   689     }

   690 

   691 // --------------------------------------------------------------------------

   692 // Start two timers and see that they expire at the same time.

   693 // --------------------------------------------------------------------------

   694 //

   695 TInt CTestCFlexTimer::CancelTimerThatWouldHaveTriggeredAnotherTimerL(

   696         TTestResult& aResult, CTestFlexTimer */*cb*/)

   697     {

   698     TTestResult *res1 = new TTestResult();

   699     TTestResult *res2 = new TTestResult();

   700     TExtendedTestResult *eResult1 = new TExtendedTestResult(res1);

   701     TExtendedTestResult *eResult2 = new TExtendedTestResult(res2);

   702     eResult1->iTimerID = 1;

   703     eResult2->iTimerID = 2;

   704     CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL(

   705             CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult1));

   706     CInheritedCFlexTimer

   707             * timer2 =

   708                     CInheritedCFlexTimer::NewL(

   709                             CActive::EPriorityStandard,

   710                             TCallBack(

   711                                     InheritedFlexTimerCallbackKErrNoneMarkTimestampStopScheduler,

   712                                     eResult2));

   713     // Expire in 10 seconds

   714     TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000);

   715     //Expire within first timers default window

   716     TTimeIntervalMicroSeconds32 expireTime2(static_cast<TInt64> ((10 * 1000

   717             * 1000 - static_cast<float> (10 * 1000 * 1000)

   718             * KDefaultWindowMultiplier)));

   719 

   720     // Save current time

   721     TTime utcNow(0);

   722     utcNow.UniversalTime();

   723 

   724     timer1->After(expireTime1);

   725     timer2->After(expireTime2);

   726 

   727     //Timer to cancel Timer 1

   728     CPeriodic *p = CPeriodic::NewL(EPriorityNormal);

   729     p->Start(3 * 1000 * 1000, 1000, TCallBack(CancelCFlexTimer, timer1));

   730     // Start scheduler and wait for callback to stop it

   731     CActiveScheduler::Start();

   732     delete p;

   733     //See if CB has failed the case

   734     if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed)

   735         {

   736         if (eResult1->iCaseAlreadyFailed)

   737             {

   738             aResult.SetResult(eResult1->iTestResult->iResult,

   739                     eResult1->iTestResult->iResultDes);

   740             }

   741         else

   742             {

   743             aResult.SetResult(eResult2->iTestResult->iResult,

   744                     eResult2->iTestResult->iResultDes);

   745             }

   746         delete timer1;

   747         delete timer2;

   748         delete eResult1;

   749         delete eResult2;

   750         delete res1;

   751         delete res2;

   752         return KErrNone;

   753         }

   754     // Get new current time

   755     TTime utcNow2(0);

   756     utcNow2.UniversalTime();

   757 

   758     //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy

   759     if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution)

   760             && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32(

   761                     KTimerAccuracyMicroSeconds)) > TTime(

   762                     eResult2->iTimerStoppedTime))

   763         {

   764         _LIT( KDescription , "Passed");

   765         aResult.SetResult(KErrNone, KDescription);

   766         }

   767     else

   768         {

   769         _LIT( KDescription , "Some timer was fired either too early or too late.\n");

   770         aResult.SetResult(KErrGeneral, KDescription);

   771         }

   772     // Case was executed

   773     delete timer1;

   774     delete timer2;

   775     delete eResult1;

   776     delete eResult2;

   777     delete res1;

   778     delete res2;

   779     return KErrNone;

   780 

   781     }

   782 

   783 // --------------------------------------------------------------------------

   784 // Start two timers and see that they expire at the same time.

   785 // --------------------------------------------------------------------------

   786 //

   787 TInt CTestCFlexTimer::ConfigureCTimerOverlap1L( TTestResult& aResult,

   788         CTestFlexTimer */*cb*/)

   789     {

   790     TTestResult *res1 = new TTestResult();

   791     TTestResult *res2 = new TTestResult();

   792     TExtendedTestResult *eResult1 = new TExtendedTestResult(res1);

   793     TExtendedTestResult *eResult2 = new TExtendedTestResult(res2);

   794     eResult1->iTimerID = 1;

   795     eResult2->iTimerID = 2;

   796     CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL(

   797             CActive::EPriorityStandard,

   798             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   799                     eResult1));

   800     CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL(

   801             CActive::EPriorityStandard,

   802             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   803                     eResult2));

   804     // Expire in 10 seconds

   805     TTimeIntervalMicroSeconds32 expireTime1(16 * 1000 * 1000);

   806     TTimeIntervalMicroSeconds32 window1(8 * 1000 * 1000);

   807     timer1->Configure(window1);

   808     //Expire within first timers default window

   809     TTimeIntervalMicroSeconds32 expireTime2(9 * 1000 * 1000);

   810     TTimeIntervalMicroSeconds32 window2(1 * 1000 * 1000);

   811     timer2->Configure(window2);

   812 

   813     // Save current time

   814     TTime utcNow(0);

   815     utcNow.UniversalTime();

   816 

   817     timer1->After(expireTime1);

   818     timer2->After(expireTime2);

   819 

   820     //Timer to stop active scheduler after timers under test are completed.

   821     CPeriodic *p = CPeriodic::NewL(EPriorityNormal);

   822     p->Start(17 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler));

   823     // Start scheduler and wait for callback to stop it

   824     CActiveScheduler::Start();

   825     delete p;

   826     //See if CB has failed the case

   827     if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed)

   828         {

   829         if (eResult1->iCaseAlreadyFailed)

   830             {

   831             aResult.SetResult(eResult1->iTestResult->iResult,

   832                     eResult1->iTestResult->iResultDes);

   833             }

   834         else

   835             {

   836             aResult.SetResult(eResult2->iTestResult->iResult,

   837                     eResult2->iTestResult->iResultDes);

   838             }

   839         delete timer1;

   840         delete timer2;

   841         delete eResult1;

   842         delete eResult2;

   843         delete res1;

   844         delete res2;

   845         return KErrNone;

   846         }

   847     // Get new current time

   848     TTime utcNow2(0);

   849     utcNow2.UniversalTime();

   850 

   851     //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy

   852     if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution)

   853             && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32(

   854                     KTimerAccuracyMicroSeconds)) > TTime(

   855                     eResult2->iTimerStoppedTime) &&

   856 

   857     (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow

   858             + expireTime2 + TTimeIntervalMicroSeconds32(

   859             KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime))

   860         {

   861         _LIT( KDescription , "Passed");

   862         aResult.SetResult(KErrNone, KDescription);

   863         }

   864     else

   865         {

   866         _LIT( KDescription , "Some timer was fired either too early or too late.\n");

   867         aResult.SetResult(KErrGeneral, KDescription);

   868         }

   869     // Case was executed

   870     delete timer1;

   871     delete timer2;

   872     delete eResult1;

   873     delete eResult2;

   874     delete res1;

   875     delete res2;

   876     return KErrNone;

   877     }

   878 

   879 // --------------------------------------------------------------------------

   880 // Start two timers and see that they expire at the same time.

   881 // --------------------------------------------------------------------------

   882 //

   883 TInt CTestCFlexTimer::ConfigureCTimerOverlap2L( TTestResult& aResult,

   884         CTestFlexTimer */*cb*/)

   885     {

   886     TTestResult *res1 = new TTestResult();

   887     TTestResult *res2 = new TTestResult();

   888     TExtendedTestResult *eResult1 = new TExtendedTestResult(res1);

   889     TExtendedTestResult *eResult2 = new TExtendedTestResult(res2);

   890     eResult1->iTimerID = 1;

   891     eResult2->iTimerID = 2;

   892     CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL(

   893             CActive::EPriorityStandard,

   894             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   895                     eResult1));

   896     CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL(

   897             CActive::EPriorityStandard,

   898             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   899                     eResult2));

   900     // Expire in 10 seconds

   901     TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000);

   902     TTimeIntervalMicroSeconds window1(8 * 1000 * 1000);

   903     timer1->Configure(window1);

   904     //Expire within first timers default window

   905     TTimeIntervalMicroSeconds expireTime2(17 * 1000 * 1000);

   906     TTimeIntervalMicroSeconds window2(1 * 1000 * 1000);

   907     timer2->Configure(window2);

   908 

   909     // Save current time

   910     TTime utcNow(0);

   911     utcNow.UniversalTime();

   912 

   913     timer1->After(expireTime1);

   914     timer2->After(expireTime2);

   915 

   916     //Timer to stop active scheduler after timers under test are completed.

   917     CPeriodic *p = CPeriodic::NewL(EPriorityNormal);

   918     p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler));

   919     // Start scheduler and wait for callback to stop it

   920     CActiveScheduler::Start();

   921     delete p;

   922     //See if CB has failed the case

   923     if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed)

   924         {

   925         if (eResult1->iCaseAlreadyFailed)

   926             {

   927             aResult.SetResult(eResult1->iTestResult->iResult,

   928                     eResult1->iTestResult->iResultDes);

   929             }

   930         else

   931             {

   932             aResult.SetResult(eResult2->iTestResult->iResult,

   933                     eResult2->iTestResult->iResultDes);

   934             }

   935         delete timer1;

   936         delete timer2;

   937         delete eResult1;

   938         delete eResult2;

   939         delete res1;

   940         delete res2;

   941         return KErrNone;

   942         }

   943     // Get new current time

   944     TTime utcNow2(0);

   945     utcNow2.UniversalTime();

   946 

   947     //Check if timers expiry happened within timer1 maxtime to maxtime+accuracy

   948     if ((utcNow + expireTime1) <= TTime(eResult2->iTimerStoppedTime+KTickResolution)

   949             && (utcNow + expireTime1 + TTimeIntervalMicroSeconds(

   950                     KTimerAccuracyMicroSeconds)) > TTime(

   951                     eResult2->iTimerStoppedTime) &&

   952 

   953     (utcNow + expireTime1) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow

   954             + expireTime1 + TTimeIntervalMicroSeconds(

   955             KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime))

   956         {

   957         _LIT( KDescription , "Passed");

   958         aResult.SetResult(KErrNone, KDescription);

   959         }

   960     else

   961         {

   962         _LIT( KDescription , "Some timer was fired either too early or too late.\n");

   963         aResult.SetResult(KErrGeneral, KDescription);

   964         }

   965     // Case was executed

   966     delete timer1;

   967     delete timer2;

   968     delete eResult1;

   969     delete eResult2;

   970     delete res1;

   971     delete res2;

   972     return KErrNone;

   973     }

   974 

   975 // --------------------------------------------------------------------------

   976 // Start two timers and see that they expire at the same time.

   977 // --------------------------------------------------------------------------

   978 //

   979 TInt CTestCFlexTimer::ConfigureCTimerOverlap3L( TTestResult& aResult,

   980         CTestFlexTimer */*cb*/)

   981     {

   982     TTestResult *res1 = new TTestResult();

   983     TTestResult *res2 = new TTestResult();

   984     TExtendedTestResult *eResult1 = new TExtendedTestResult(res1);

   985     TExtendedTestResult *eResult2 = new TExtendedTestResult(res2);

   986     eResult1->iTimerID = 1;

   987     eResult2->iTimerID = 2;

   988     CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL(

   989             CActive::EPriorityStandard,

   990             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   991                     eResult1));

   992     CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL(

   993             CActive::EPriorityStandard,

   994             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

   995                     eResult2));

   996     // Expire in 10 seconds

   997     TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000);

   998     TTimeIntervalMicroSeconds window1(16 * 1000 * 1000);

   999     TTimeIntervalMicroSeconds32 zeroWindow(0);

  1000     timer1->Configure(zeroWindow);

  1001     timer1->Configure(window1);

  1002     //Expire within first timers default window

  1003     TTimeIntervalMicroSeconds expireTime2(8 * 1000 * 1000);

  1004     TTimeIntervalMicroSeconds window2(0);

  1005     timer2->Configure(window2);

  1006 

  1007     // Save current time

  1008     TTime utcNow(0);

  1009     utcNow.UniversalTime();

  1010 

  1011     timer1->After(expireTime1);

  1012     timer2->After(expireTime2);

  1013 

  1014     //Timer to stop active scheduler after timers under test are completed.

  1015     CPeriodic *p = CPeriodic::NewL(EPriorityNormal);

  1016     p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler));

  1017     // Start scheduler and wait for callback to stop it

  1018     CActiveScheduler::Start();

  1019     delete p;

  1020     //See if CB has failed the case

  1021     if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed)

  1022         {

  1023         if (eResult1->iCaseAlreadyFailed)

  1024             {

  1025             aResult.SetResult(eResult1->iTestResult->iResult,

  1026                     eResult1->iTestResult->iResultDes);

  1027             }

  1028         else

  1029             {

  1030             aResult.SetResult(eResult2->iTestResult->iResult,

  1031                     eResult2->iTestResult->iResultDes);

  1032             }

  1033         delete timer1;

  1034         delete timer2;

  1035         delete eResult1;

  1036         delete eResult2;

  1037         delete res1;

  1038         delete res2;

  1039         return KErrNone;

  1040         }

  1041     // Get new current time

  1042     TTime utcNow2(0);

  1043     utcNow2.UniversalTime();

  1044 

  1045     //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy

  1046     if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution)

  1047             && (utcNow + expireTime2 + TTimeIntervalMicroSeconds(

  1048                     KTimerAccuracyMicroSeconds)) > TTime(

  1049                     eResult2->iTimerStoppedTime) &&

  1050 

  1051     (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow

  1052             + expireTime2 + TTimeIntervalMicroSeconds(

  1053             KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime))

  1054         {

  1055         _LIT( KDescription , "Passed");

  1056         aResult.SetResult(KErrNone, KDescription);

  1057         }

  1058     else

  1059         {

  1060         _LIT( KDescription , "Some timer was fired either too early or too late.\n");

  1061         aResult.SetResult(KErrGeneral, KDescription);

  1062         }

  1063     // Case was executed

  1064     delete timer1;

  1065     delete timer2;

  1066     delete eResult1;

  1067     delete eResult2;

  1068     delete res1;

  1069     delete res2;

  1070     return KErrNone;

  1071     }

  1072 

  1073 // --------------------------------------------------------------------------

  1074 // Start two timers and see that they expire at their own max time

  1075 // --------------------------------------------------------------------------

  1076 //

  1077 TInt CTestCFlexTimer::ConfigureCTimerNonOverlap1L( TTestResult& aResult,

  1078         CTestFlexTimer */*cb*/)

  1079     {

  1080     TTestResult *res1 = new TTestResult();

  1081     TTestResult *res2 = new TTestResult();

  1082     TExtendedTestResult *eResult1 = new TExtendedTestResult(res1);

  1083     TExtendedTestResult *eResult2 = new TExtendedTestResult(res2);

  1084     eResult1->iTimerID = 1;

  1085     eResult2->iTimerID = 2;

  1086     CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL(

  1087             CActive::EPriorityStandard,

  1088             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

  1089                     eResult1));

  1090     CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL(

  1091             CActive::EPriorityStandard,

  1092             TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp,

  1093                     eResult2));

  1094     // Expire in 10 seconds

  1095     TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000);

  1096     TTimeIntervalMicroSeconds window1(0);

  1097     timer1->Configure(window1);

  1098     //Expire within first timers default window

  1099     TTimeIntervalMicroSeconds expireTime2(15 * 1000 * 1000);

  1100     TTimeIntervalMicroSeconds window2(1 * 1000 * 1000);

  1101     timer2->Configure(window2);

  1102 

  1103     // Save current time

  1104     TTime utcNow(0);

  1105     utcNow.UniversalTime();

  1106 

  1107     timer1->After(expireTime1);

  1108     timer2->After(expireTime2);

  1109 

  1110     //Timer to stop active scheduler after timers under test are completed.

  1111     CPeriodic *p = CPeriodic::NewL(EPriorityNormal);

  1112     p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler));

  1113     // Start scheduler and wait for callback to stop it

  1114     CActiveScheduler::Start();

  1115     delete p;

  1116     //See if CB has failed the case

  1117     if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed)

  1118         {

  1119         if (eResult1->iCaseAlreadyFailed)

  1120             {

  1121             aResult.SetResult(eResult1->iTestResult->iResult,

  1122                     eResult1->iTestResult->iResultDes);

  1123             }

  1124         else

  1125             {

  1126             aResult.SetResult(eResult2->iTestResult->iResult,

  1127                     eResult2->iTestResult->iResultDes);

  1128             }

  1129         delete timer1;

  1130         delete timer2;

  1131         delete eResult1;

  1132         delete eResult2;

  1133         delete res1;

  1134         delete res2;

  1135         return KErrNone;