diff -r fc7b30ed2058 -r 05bc53fe583b keepalive/flextimer/test/testflextimer/src/testcflextimer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/keepalive/flextimer/test/testflextimer/src/testcflextimer.cpp Tue Aug 31 15:35:44 2010 +0300 @@ -0,0 +1,3236 @@ +/* + * ============================================================================ + * Name : testflexperiodic.cpp + * Part of : src / testflextimer + * Description : STIF test cases for CFlexPeriodic timer. + * Version : %version: 1 % + * + * Copyright © 2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * Nokia Corporation + * ============================================================================ + * Template version: 4.1 + */ + +#include // for RDebug +#include // for Math::Rand() +#include +#include "testflextimer.h" // for global constants & CB +#include "testcflextimer.h" +#include "flextimerpanic.h" // for panic constants +#include "inheritedcflextimer.h"// CFlexTimer implementation (CB is always TExtendedTestResult*) +#include "inheritedcflextimer2.h"// another CFlexTimer implementation (CB is always RArray *list) +// ======== LOCAL FUNCTIONS ======== + +// ======== MEMBER FUNCTIONS ======== + +const TInt64 KTickResolution( 1000000 / 64 ); +const TInt KExtraSlack = 500 * 1000; +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +CTestCFlexTimer::CTestCFlexTimer() + { + } + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// +CTestCFlexTimer::~CTestCFlexTimer() + { + } +// -------------------------------------------------------------------------- +// Start timer and delete it. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CreateAndDestroyCFlexTimerL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TExtendedTestResult *eResult = new TExtendedTestResult(&aResult); + CInheritedCFlexTimer + * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, + TCallBack( + InheritedFlexTimerCallbackStopSchedulerKErrNone, + eResult)); + + TTimeIntervalMicroSeconds32 expireTime(5 * 1000 * 1000); //5s + timer->After(expireTime); + CActiveScheduler::Start(); + + delete timer; + timer = NULL; + _LIT( KDescription , "Test case passed"); + aResult.SetResult(KErrNone, KDescription); + delete eResult; + return KErrNone; + + } + +// -------------------------------------------------------------------------- +// Start timer and see that it expires at max time +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CreateAndExpireCFlexTimerL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TExtendedTestResult *eResult = new TExtendedTestResult(&aResult); + CInheritedCFlexTimer + * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, + TCallBack( + InheritedFlexTimerCallbackStopSchedulerKErrNone, + eResult)); + + // Expire in 5 seconds + TTimeIntervalMicroSeconds32 expireTime(5 * 1000 * 1000); + + // Save current time. + TTime utcNow(0); + utcNow.UniversalTime(); + + timer->After(expireTime); + + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + //See if CB has failed the case + if (eResult->iCaseAlreadyFailed) + { + delete timer; + delete eResult; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timer expiry happened within maxtime to maxtime+accuracy + if ((utcNow + expireTime) <= utcNow2 && (utcNow + expireTime + + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds)) + > utcNow2) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer; + delete eResult; + return KErrNone; + + } + +// -------------------------------------------------------------------------- +// Start two timers and see that they expire at the same time. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CreateAndExpireTwoOverlappingAfterTimersL( + TTestResult& aResult, CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); + //Expire within first timers default window + TTimeIntervalMicroSeconds32 expireTime2(static_cast ((10 * 1000 + * 1000 - static_cast (10 * 1000 * 1000) + * KDefaultWindowMultiplier))); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + + //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy + if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) + && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32( + KTimerAccuracyMicroSeconds)) > TTime( + eResult2->iTimerStoppedTime) && + + (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow + + expireTime2 + TTimeIntervalMicroSeconds32( + KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + RDebug::Printf("utcNow = %lld\n", utcNow.Int64()); + RDebug::Printf("eResult1->iTimerStoppedTime = %lld\n", + eResult1->iTimerStoppedTime); + RDebug::Printf("eResult2->iTimerStoppedTime = %lld\n", + eResult2->iTimerStoppedTime); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + + } + +// -------------------------------------------------------------------------- +// Start two timers and see that they expire at the same time. 64bit version +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CreateAndExpireTwoOverlappingAfterTimers64L( + TTestResult& aResult, CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000); + //Expire within first timers default window + TTimeIntervalMicroSeconds expireTime2(static_cast ((10 * 1000 + * 1000 - static_cast (10 * 1000 * 1000) + * KDefaultWindowMultiplier))); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy + if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) + && (utcNow + expireTime2 + TTimeIntervalMicroSeconds( + KTimerAccuracyMicroSeconds)) > TTime( + eResult2->iTimerStoppedTime) && + + (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow + + expireTime2 + TTimeIntervalMicroSeconds( + KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + + } + +// -------------------------------------------------------------------------- +// Start two timers and see that they expire at their own max time. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CreateAndExpireTwoNonOverlappingAfterTimersL( + TTestResult& aResult, CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); + //Expire one second before first timers window starts + TTimeIntervalMicroSeconds32 expireTime2(static_cast ((10 * 1000 + * 1000 - static_cast (10 * 1000 * 1000) + * KDefaultWindowMultiplier)) - 1 * 1000 * 1000); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timers expiry happened within at their own max time edge. + if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) + && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32( + KTimerAccuracyMicroSeconds)) > TTime( + eResult2->iTimerStoppedTime) && + + (utcNow + expireTime1) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow + + expireTime1 + TTimeIntervalMicroSeconds32( + KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + + } + +// -------------------------------------------------------------------------- +// Start many timers and see that nothing goes wrong when they are expired at rapid sequence +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::HumongousAmountOfTimeridelidilidousL( + TTestResult& aResult, CTestFlexTimer */*cb*/) + { + RDebug::Printf("HugemongousAmountOfTimeridelidilidousL"); + // This list will contain all the timer structs, expiry times etc. + // First cell will always tell which timer is currently active + // active info is transferred from e.g. InheritedCFlexTimer2::RunL to CB function + RArray timers; + // This CB contains all the logic about timer addition + StartTimerAndAddToList( &timers, 2000 ); + // CBs stop this after all timers are expired + CActiveScheduler::Start(); + // Delete CPeriodic that was used to launch new FlexTimers + delete timers[0].iStartTimer; + _LIT( KDescriptionP , "Passed"); + aResult.SetResult(KErrNone, KDescriptionP); + // Loop throug list and see if timers fired within limits. + // also delete all stuff reserved earlier by StartTimerAndAddToList + while (timers.Count()) + { + // Have fun with reading this. It is not as bad as it looks + // Just checks if CB already failed the case + // and if timer was launched within its window(default) and timer accuracy + if (!(!timers[0].iEResult->iCaseAlreadyFailed + && (timers[0].iEResult->iTimerStartedTime + + timers[0].iEResult->iTimerExpiryTime + - (static_cast (timers[0].iEResult->iTimerExpiryTime) + * KDefaultWindowMultiplier) + <= timers[0].iEResult->iTimerStoppedTime+KTickResolution) + && (timers[0].iEResult->iTimerStartedTime + + timers[0].iEResult->iTimerExpiryTime + + KTimerAccuracyMicroSeconds) + > timers[0].iEResult->iTimerStoppedTime)) + { + _LIT( KDescription , "Some timer was not fired within its window.\n"); + aResult.SetResult(KErrGeneral, KDescription); + + } + delete timers[0].iEResult->iTestResult; + delete timers[0].iEResult; + delete timers[0].iTimer; + timers.Remove(0); + } + // Case was executed + timers.Close(); + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start three timers At, AtUTC and After and see that they are treated equally. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CreateAndExpireThreeTimersL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TTestResult *res3 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + TExtendedTestResult *eResult3 = new TExtendedTestResult(res3); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + eResult2->iTimerID = 3; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + CInheritedCFlexTimer* timer3 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult3)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000); + //Expire within first timers default window + TTimeIntervalMicroSeconds expireTime2(9 * 1000 * 1000); + TTimeIntervalMicroSeconds expireTime3(3 * 1000 * 1000); // Expire far enough from others + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + TTime homeNow(0); + homeNow.HomeTime(); + + timer1->After(expireTime1); + timer2->At(homeNow + expireTime2); + timer3->AtUTC(utcNow + expireTime3); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult( + eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes ); + } + else if (eResult2->iCaseAlreadyFailed) + { + aResult.SetResult( + eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes ); + } + else if (eResult3->iCaseAlreadyFailed) + { + aResult.SetResult( + eResult3->iTestResult->iResult, + eResult3->iTestResult->iResultDes ); + } + + // Check if timers expiry happened within limits. + // First and second timer at seconds timers max time and third at its own max time. + // + // Compare results against utcNow due timer's stopped time is UTC. + else if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) && + (utcNow + expireTime2 + TTimeIntervalMicroSeconds( KTimerAccuracyMicroSeconds)) > TTime( eResult2->iTimerStoppedTime) && + + (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && + (utcNow + expireTime2 + TTimeIntervalMicroSeconds( KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime) && + + (utcNow + expireTime3) <= TTime(eResult3->iTimerStoppedTime+KTickResolution) && + (utcNow + expireTime3 + TTimeIntervalMicroSeconds( KTimerAccuracyMicroSeconds)) > TTime( eResult3->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete timer3; + delete eResult1; + delete eResult2; + delete eResult3; + delete res1; + delete res2; + delete res3; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start three timers At, AtUTC and After and see that they can be cancelled. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::NormalCancelL( TTestResult& aResult, CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TTestResult *res3 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + TExtendedTestResult *eResult3 = new TExtendedTestResult(res3); + eResult1->iTimerID = 0; + eResult2->iTimerID = 1; + eResult3->iTimerID = 2; + CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult1), 0); + CInheritedCFlexTimer2* timer2 = CInheritedCFlexTimer2::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult2), 1); + CInheritedCFlexTimer2* timer3 = CInheritedCFlexTimer2::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult3), 2); + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000); + //just something + TTimeIntervalMicroSeconds expireTime2(static_cast ((10 * 1000 + * 1000 - static_cast (10 * 1000 * 1000) + * KDefaultWindowMultiplier))); + TTimeIntervalMicroSeconds expireTime3(7 * 1000 * 1000); // just something + RArray timers; + TTimerStruct *s1 = new TTimerStruct(); + s1->iEResult = eResult1; + s1->iTimer = timer1; + timers.Append(*s1); + TTimerStruct *s2 = new TTimerStruct(); + s2->iEResult = eResult2; + s2->iTimer = timer2; + timers.Append(*s2); + TTimerStruct *s3 = new TTimerStruct(); + s3->iEResult = eResult3; + s3->iTimer = timer3; + timers.Append(*s3); + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + TTime homeNow(0); + homeNow.HomeTime(); + + timer1->After(expireTime1); + timer2->At(homeNow + expireTime2); + timer3->AtUTC(utcNow + expireTime3); + + timers[0].iCurrentlyActive = 0; //CB uses this to decide which timer to cancel; + + //Timer to cancel timers under test and cancel active scheduler + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(15 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + StopActiveScheduler)); + CPeriodic *pp = CPeriodic::NewL(EPriorityNormal); + s1->iStartTimer = pp; + pp->Start(3 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + CancelCFlexTimerArray, &timers)); + CPeriodic *ppp = CPeriodic::NewL(EPriorityNormal); + s2->iStartTimer = ppp; + ppp->Start(4 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + CancelCFlexTimerArray, &timers)); + CPeriodic *pppp = CPeriodic::NewL(EPriorityNormal); + s3->iStartTimer = pppp; + pppp->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + CancelCFlexTimerArray, &timers)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + delete pp; + delete ppp; + delete pppp; + delete s1; + delete s2; + delete s3; + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed + || eResult3->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + if (eResult2->iCaseAlreadyFailed) + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult3->iTestResult->iResult, + eResult3->iTestResult->iResultDes); + } + } + delete timer1; + delete timer2; + delete timer3; + delete eResult1; + delete eResult2; + delete eResult3; + delete res1; + delete res2; + delete res3; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start two timers and see that they expire at the same time. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CancelTimerThatWouldHaveTriggeredAnotherTimerL( + TTestResult& aResult, CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult1)); + CInheritedCFlexTimer + * timer2 = + CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack( + InheritedFlexTimerCallbackKErrNoneMarkTimestampStopScheduler, + eResult2)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); + //Expire within first timers default window + TTimeIntervalMicroSeconds32 expireTime2(static_cast ((10 * 1000 + * 1000 - static_cast (10 * 1000 * 1000) + * KDefaultWindowMultiplier))); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to cancel Timer 1 + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(3 * 1000 * 1000, 1000, TCallBack(CancelCFlexTimer, timer1)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy + if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) + && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32( + KTimerAccuracyMicroSeconds)) > TTime( + eResult2->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + + } + +// -------------------------------------------------------------------------- +// Start two timers and see that they expire at the same time. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureCTimerOverlap1L( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds32 expireTime1(16 * 1000 * 1000); + TTimeIntervalMicroSeconds32 window1(8 * 1000 * 1000); + timer1->Configure(window1); + //Expire within first timers default window + TTimeIntervalMicroSeconds32 expireTime2(9 * 1000 * 1000); + TTimeIntervalMicroSeconds32 window2(1 * 1000 * 1000); + timer2->Configure(window2); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(17 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy + if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) + && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32( + KTimerAccuracyMicroSeconds)) > TTime( + eResult2->iTimerStoppedTime) && + + (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow + + expireTime2 + TTimeIntervalMicroSeconds32( + KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start two timers and see that they expire at the same time. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureCTimerOverlap2L( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000); + TTimeIntervalMicroSeconds window1(8 * 1000 * 1000); + timer1->Configure(window1); + //Expire within first timers default window + TTimeIntervalMicroSeconds expireTime2(17 * 1000 * 1000); + TTimeIntervalMicroSeconds window2(1 * 1000 * 1000); + timer2->Configure(window2); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timers expiry happened within timer1 maxtime to maxtime+accuracy + if ((utcNow + expireTime1) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) + && (utcNow + expireTime1 + TTimeIntervalMicroSeconds( + KTimerAccuracyMicroSeconds)) > TTime( + eResult2->iTimerStoppedTime) && + + (utcNow + expireTime1) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow + + expireTime1 + TTimeIntervalMicroSeconds( + KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start two timers and see that they expire at the same time. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureCTimerOverlap3L( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000); + TTimeIntervalMicroSeconds window1(16 * 1000 * 1000); + TTimeIntervalMicroSeconds32 zeroWindow(0); + timer1->Configure(zeroWindow); + timer1->Configure(window1); + //Expire within first timers default window + TTimeIntervalMicroSeconds expireTime2(8 * 1000 * 1000); + TTimeIntervalMicroSeconds window2(0); + timer2->Configure(window2); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy + if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) + && (utcNow + expireTime2 + TTimeIntervalMicroSeconds( + KTimerAccuracyMicroSeconds)) > TTime( + eResult2->iTimerStoppedTime) && + + (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow + + expireTime2 + TTimeIntervalMicroSeconds( + KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start two timers and see that they expire at their own max time +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureCTimerNonOverlap1L( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000); + TTimeIntervalMicroSeconds window1(0); + timer1->Configure(window1); + //Expire within first timers default window + TTimeIntervalMicroSeconds expireTime2(15 * 1000 * 1000); + TTimeIntervalMicroSeconds window2(1 * 1000 * 1000); + timer2->Configure(window2); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timer expired within their own maxtime to maxtime+accuracy + if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) + && (utcNow + expireTime2 + TTimeIntervalMicroSeconds( + KTimerAccuracyMicroSeconds)) > TTime( + eResult2->iTimerStoppedTime) && + + (utcNow + expireTime1) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow + + expireTime1 + TTimeIntervalMicroSeconds( + KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start two timers and see that they expire at their own max time +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureCTimerNonOverlap2L( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1(16 * 1000 * 1000); + TTimeIntervalMicroSeconds window1(16 * 1000 * 1000); + timer1->Configure(window1); + window1 = 8 * 1000 * 1000; + timer1->Configure(window1); + //Expire within first timers default window + TTimeIntervalMicroSeconds expireTime2(7 * 1000 * 1000); + TTimeIntervalMicroSeconds window2(4 * 1000 * 1000); + timer2->Configure(window2); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(18 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timer expired within their own maxtime to maxtime+accuracy + if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) + && (utcNow + expireTime2 + TTimeIntervalMicroSeconds( + KTimerAccuracyMicroSeconds)) > TTime( + eResult2->iTimerStoppedTime) && + + (utcNow + expireTime1) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow + + expireTime1 + TTimeIntervalMicroSeconds( + KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start three timers and see that system time change aborts At & AtUtc timers +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::SystemTimeChangesL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TTestResult *res3 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + TExtendedTestResult *eResult3 = new TExtendedTestResult(res3); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + eResult3->iTimerID = 3; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack( + InheritedFlexTimerCallbackKErrAbort, eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack( + InheritedFlexTimerCallbackKErrAbort, eResult2)); + CInheritedCFlexTimer* timer3 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackStopSchedulerKErrNone, + eResult3)); + // Expire in 10, 11 and 12 seconds. One and two are to be aborted + TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); + TTimeIntervalMicroSeconds32 expireTime2(11 * 1000 * 1000); + TTimeIntervalMicroSeconds32 expireTime3(12 * 1000 * 1000); + + + // Save current time as ticks. This use case will change system time + // and timestamps will not be exact -- ticks are. + TUint startTicks( User::TickCount() ); + + TTime now, nowUtc; + now.HomeTime(); + nowUtc.UniversalTime(); + + timer1->At(now + expireTime1); + timer2->AtUTC(nowUtc + expireTime2); + timer3->After(expireTime3); + + //Timer to change system time after timers have been running for a while + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(5 * 1000 * 1000, 1000, TCallBack(ChangeSystemTime1sAndCancel, p)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed + || eResult3->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else if (eResult2->iCaseAlreadyFailed) + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult3->iTestResult->iResult, + eResult3->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete timer3; + delete eResult1; + delete eResult2; + delete eResult3; + delete res1; + delete res2; + delete res3; + return KErrNone; + } + // Get new current time + TUint endTicks( User::TickCount() ); + TInt delay( ( endTicks - startTicks ) * KTickInMicroSeconds ); + + //Check if timers expiry happened within timer3 maxtime to maxtime+accuracy + if ( delay+KTickResolution >= expireTime3.Int() && + delay < expireTime3.Int() + KTimerAccuracyMicroSeconds ) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete timer3; + delete eResult1; + delete eResult2; + delete eResult3; + delete res1; + delete res2; + delete res3; + + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start three timers and see that time zone change aborts At & AtUtc timers +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::TimeZoneChangesL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TTestResult *res3 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + TExtendedTestResult *eResult3 = new TExtendedTestResult(res3); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + eResult3->iTimerID = 3; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack( + InheritedFlexTimerCallbackKErrAbort, eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack( + InheritedFlexTimerCallbackKErrAbort, eResult2)); + CInheritedCFlexTimer* timer3 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackStopSchedulerKErrNone, + eResult3)); + // Expire in 10, 11 and 12 seconds. One and two are to be aborted + TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); + TTimeIntervalMicroSeconds32 expireTime2(11 * 1000 * 1000); + TTimeIntervalMicroSeconds32 expireTime3(12 * 1000 * 1000); + + // Save current time as ticks. This use case will change system time + // and timestamps will not be exact -- ticks are. + TUint startTicks( User::TickCount() ); + + TTime now, nowUtc; + now.HomeTime(); + nowUtc.UniversalTime(); + + timer1->At(now + expireTime1); + timer2->AtUTC(nowUtc + expireTime2); + timer3->After(expireTime3); + + //Timer to change system time after timers have been running for a while + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(5 * 1000 * 1000, 1000, TCallBack(ChangeTimeZoneAndCancel, p)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed + || eResult3->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else if (eResult2->iCaseAlreadyFailed) + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult3->iTestResult->iResult, + eResult3->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete timer3; + delete eResult1; + delete eResult2; + delete eResult3; + delete res1; + delete res2; + delete res3; + return KErrNone; + } + + // Get new current time + TUint endTicks( User::TickCount() ); + TInt delay( ( endTicks - startTicks ) * KTickInMicroSeconds ); + + //Check if timers expiry happened within timer3 maxtime to maxtime+accuracy + if ( delay+KTickResolution >= expireTime3.Int() && + delay < expireTime3.Int() + KTimerAccuracyMicroSeconds ) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete timer3; + delete eResult1; + delete eResult2; + delete eResult3; + delete res1; + delete res2; + delete res3; + + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timers with dumbass parameters +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::DumbAssParametersForCTimerL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = 1; + CInheritedCFlexTimer + * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, + TCallBack( + InheritedFlexTimerCallbackStopSchedulerKErrNone, + eResult)); + + /*32 bit IF called with 1 parameter*/ + /***********************************/ + // Expire in 3 seconds. + TTimeIntervalMicroSeconds32 expireTime(1); + // Save current time + TTime now(0); + now.HomeTime(); + timer->After(expireTime); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + //See if CB has failed the case + if (eResult->iCaseAlreadyFailed) + { + aResult.SetResult(eResult->iTestResult->iResult, + eResult->iTestResult->iResultDes); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + // Get new current time + TTime now2(0); + now2.HomeTime(); + //Check if timers expiry happened immediately. + if (!((now + expireTime) <= now2 && (now + expireTime + + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds)) > now2)) + { + _LIT( KDescription , "32 bit After(1) failed.\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + + /*32 bit IF called with max parameter*/ + /***********************************/ + expireTime = 0x7FFFFFFF; + now.HomeTime(); + delete timer; + timer = NULL; + timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, TCallBack( + NotCalledCB, eResult)); + timer->After(expireTime); + //Timer to change system time after timers have been running for a while + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(5 * 1000 * 1000, 1000, TCallBack( + CancelCFlexTimerAndStopActiveScheduler, timer)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + p->Cancel(); + delete p; + //See if CB has failed the case + if (eResult->iCaseAlreadyFailed) + { + aResult.SetResult(eResult->iTestResult->iResult, + eResult->iTestResult->iResultDes); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + + /*64 bit IF called with 1 parameter*/ + /***********************************/ + // Expire in 3 seconds. + TTimeIntervalMicroSeconds expireTime64(1); + // Save current time + now.HomeTime(); + delete timer; + timer = NULL; + timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, TCallBack( + InheritedFlexTimerCallbackStopSchedulerKErrNone, eResult)); + timer->After(expireTime64); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + //See if CB has failed the case + if (eResult->iCaseAlreadyFailed) + { + aResult.SetResult(eResult->iTestResult->iResult, + eResult->iTestResult->iResultDes); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + // Get new current time + now2.HomeTime(); + //Check if timers expiry happened immediately + if (!((now + expireTime64) <= now2 && (now + expireTime64 + + TTimeIntervalMicroSeconds(KTimerAccuracyMicroSeconds)) > now2)) + { + _LIT( KDescription , "64 bit After(1) failed.\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + // Finally if we are here set whole case to passed. + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timers with dumbass parameters +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::DumbAssParametersForCTimerZero32bitL( TTestResult& aResult, + CTestFlexTimer* /* cb */ ) + { + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = 1; + + /*32 bit IF called with 0 parameter*/ + /***********************************/ + const TTimeIntervalMicroSeconds32 kExpireTime32(0); + + // Save current time + TTime startTime; + startTime.HomeTime(); + + CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack( InheritedFlexTimerCallbackStopSchedulerKErrNone, eResult ) ); + + timer->After( kExpireTime32 ); + + CActiveScheduler::Start(); // WAIT timer to expire + + TTime endTime; + endTime.HomeTime(); + + TTimeIntervalMicroSeconds delay = endTime.MicroSecondsFrom( startTime ); + + if ( delay.Int64() < kExpireTime32.Int() || + delay.Int64() > kExpireTime32.Int() + KTimerAccuracyMicroSeconds ) + { + aResult.SetResult( KErrGeneral, _L("Wrong expiration") ); + } + else + { + aResult.SetResult( KErrNone, _L("Test case passed") ); + } + + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timers with dumbass parameters +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::DumbAssParametersForCTimerZero64bitL( TTestResult& aResult, + CTestFlexTimer* /* cb */ ) + { + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = 1; + + /*64 bit IF called with 0 parameter*/ + /***********************************/ + const TTimeIntervalMicroSeconds kExpireTime64(0); + + // Save current time + TTime startTime; + startTime.HomeTime(); + + CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(InheritedFlexTimerCallbackStopSchedulerKErrNone, eResult)); + + timer->After(kExpireTime64); + CActiveScheduler::Start(); // WAIT timer to expire + + TTime endTime; + endTime.HomeTime(); + + TTimeIntervalMicroSeconds delay = endTime.MicroSecondsFrom( startTime ); + + if ( delay.Int64()+KTickResolution < kExpireTime64.Int64() || + delay.Int64() > kExpireTime64.Int64() + KTimerAccuracyMicroSeconds ) + { + aResult.SetResult( KErrGeneral, _L("Wrong expiration") ); + } + else + { + aResult.SetResult( KErrNone, _L("Test case passed") ); + } + + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timers with dumbass parameters +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::DumbAssParametersForCTimer64MaxL( TTestResult& aResult, + CTestFlexTimer *cb ) + { + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = 1; + + /*64 bit IF called with 0x7FFFFFFFFFFFFFFF parameter*/ + /***********************************/ + // This will cause panic + TTimeIntervalMicroSeconds expireTime64(0x7FFFFFFFFFFFFFFF); + // Save current time + TTime now(0); + now.HomeTime(); + CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); + //Accept panic as passed case + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, + EFlexTimerServerIllegalTimerValue); + timer->After(expireTime64); + // Start timer that stops active scheduler just in case. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(3 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + StopActiveScheduler)); + CActiveScheduler::Start(); + delete p; + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + _LIT( KDescription , "64 bit After(0x7FFFFFFFFFFFFFFF) failed to panic.\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timers with dumbass parameters +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::DumbAssParametersForCTimer64ThreeYearsL( TTestResult& aResult, + CTestFlexTimer *cb ) + { + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = 1; + + /*64 bit IF called with 93312000000000 (about three years) parameter*/ + /***********************************/ + // This will cause panic since only two years ahead timers are supported + TTimeIntervalMicroSeconds expireTime64(93312000000000); + // Save current time + TTime now(0); + now.HomeTime(); + CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); + //Accept panic as passed case + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, + EFlexTimerServerIllegalTimerValue); + timer->After(expireTime64); + // Start timer that stops active scheduler just in case. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(3 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + StopActiveScheduler)); + CActiveScheduler::Start(); + delete p; + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + _LIT( KDescription , "64 bit After(93312000000000) failed to panic.\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start one year timer and cancel it. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::DumbAssParametersForCTimer64OneYearL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + RDebug::Printf("DumbAssParametersForCTimer64OneYearL"); + TTestResult *res1 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + eResult1->iTimerID = 0; + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1( 33312000000000 ); // About on year + //just something + RArray timers; + CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, + &timers), 0); + TTimerStruct *s1 = new TTimerStruct(); + s1->iEResult = eResult1; + s1->iTimer = timer1; + timers.Append(*s1); + + timer1->After(expireTime1); + + timers[0].iCurrentlyActive = 0; + + //Timers to cancel timer and stop scheduler. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(7 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + StopActiveScheduler)); + CPeriodic *pp = CPeriodic::NewL(EPriorityNormal); + s1->iStartTimer = pp; + pp->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + CancelCFlexTimerArray, &timers)); + + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; delete pp; + delete s1; + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + + delete timer1; + delete eResult1; + delete res1; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timers with negative value +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::AfterWithNegativeValueL( TTestResult& aResult, + CTestFlexTimer *cb ) + { + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = 1; + + // This will cause panic + TTimeIntervalMicroSeconds32 expireTime(-1); + CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); + //Accept panic as passed case + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, + EFlexTimerAfterIntervalLessThanZero); + timer->After(expireTime); + CActiveScheduler::Start(); + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + _LIT( KDescription , "32 bit After(-1) failed to panic.\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timers with negative value +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::AfterWithNegativeValue64L( TTestResult& aResult, + CTestFlexTimer *cb ) + { + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = 1; + + // This will cause panic + TTimeIntervalMicroSeconds expireTime(-1); + CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); + //Accept panic as passed case + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, + EFlexTimerAfterIntervalLessThanZero); + timer->After(expireTime); + CActiveScheduler::Start(); + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + _LIT( KDescription , "64 bit After(-1) failed to panic.\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + + +// -------------------------------------------------------------------------- +// Start timers with dumbass parameters +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::AtWithCurrentTimeL( TTestResult& aResult, + CTestFlexTimer* /* cb */ ) + { + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = 1; + + TTimeIntervalMicroSeconds expireTime64(0); + CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackStopSchedulerKErrNone, eResult)); + + // Save current time + TTime now(0); + now.HomeTime(); + timer->At(now + expireTime64); + CActiveScheduler::Start(); // WAIT timer to expire + + // Analyze results + TTime endTime; + endTime.HomeTime(); + + TTimeIntervalMicroSeconds delay = endTime.MicroSecondsFrom( now ); + + if ( delay.Int64()+KTickResolution < expireTime64.Int64() || + delay.Int64() > expireTime64.Int64() + KTimerAccuracyMicroSeconds ) + { + aResult.SetResult(KErrGeneral, _L("Wrong expiration")); + } + else + { + aResult.SetResult( KErrNone, _L("Test case passed") ); + } + + // Clean up + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timers with dumbass parameters +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::AtUTCWithCurrentTimeL( TTestResult& aResult, + CTestFlexTimer* /* cb */ ) + { + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = 1; + + TTimeIntervalMicroSeconds expireTime64(0); + CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackStopSchedulerKErrNone, eResult)); + + // Save current time + TTime now(0); + now.UniversalTime(); + timer->AtUTC(now + expireTime64); + CActiveScheduler::Start(); // WAIT timer to expire + + // Analyze results + TTime endTime; + endTime.UniversalTime(); + + TTimeIntervalMicroSeconds delay = endTime.MicroSecondsFrom( now ); + + if ( delay.Int64()+KTickResolution < expireTime64.Int64() || + delay.Int64() > expireTime64.Int64() + KTimerAccuracyMicroSeconds ) + { + aResult.SetResult(KErrGeneral, _L("Wrong expiration")); + } + else + { + aResult.SetResult( KErrNone, _L("Test case passed") ); + } + + // Clean up + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timers with dumbass parameters +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::AtWithThreeYearsL( TTestResult& aResult, + CTestFlexTimer *cb ) + { + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = 1; + + // This will cause panic + TTimeIntervalMicroSeconds expireTime64(93312000000000); + CInheritedCFlexTimer *timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); + //Accept panic as passed case + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, + EFlexTimerServerIllegalTimerValue); + // Save current time + TTime now(0); + now.HomeTime(); + timer->At(now + expireTime64); + // Start timer that stops active scheduler just in case. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(3 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + StopActiveScheduler)); + CActiveScheduler::Start(); + delete p; + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + _LIT( KDescription , "At(93312000000000) failed to panic.\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start one year timer and cancel it. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::AtWithOneYearL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + RDebug::Printf("AtWithOneYearL"); + TTestResult *res1 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + eResult1->iTimerID = 0; + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1( 33312000000000 ); // About on year + //just something + RArray timers; + CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, + &timers), 0); + TTimerStruct *s1 = new TTimerStruct(); + s1->iEResult = eResult1; + s1->iTimer = timer1; + timers.Append(*s1); + TTime now(0); + now.HomeTime(); + timer1->At(now + expireTime1); + + timers[0].iCurrentlyActive = 0; + + //Timers to cancel timer and stop scheduler. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(7 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + StopActiveScheduler)); + CPeriodic *pp = CPeriodic::NewL(EPriorityNormal); + s1->iStartTimer = pp; + pp->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + CancelCFlexTimerArray, &timers)); + + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; delete pp; + delete s1; + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + delete timer1; + delete eResult1; + delete res1; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Call At and AtUTC with time in the past +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::AtWithTimeInThePastL( TTestResult& aResult, + CTestFlexTimer *cb ) + { + RDebug::Printf("AtWithTimeInThePastL"); + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + + // Expire in the past + TTimeIntervalMicroSeconds expireTime(-1); + CInheritedCFlexTimer* timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); + // Save current time + TTime homeNow(0); + homeNow.HomeTime(); + TTime homeExpireTime(homeNow + expireTime); + //Accept panic as passed case + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, + EFlexTimerAtIntervalLessThanZero); + timer->At(homeExpireTime); + CActiveScheduler::Start(); + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + _LIT( KDescription , "At in the past failed to panic.\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timer, expire, cancel, start again and expire +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CancelExpiredTimerL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TExtendedTestResult *eResult = new TExtendedTestResult(&aResult); + CInheritedCFlexTimer + * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, + TCallBack( + InheritedFlexTimerCallbackStopSchedulerKErrNone, + eResult)); + + // Expire in 5 seconds + TTimeIntervalMicroSeconds32 expireTime(5 * 1000 * 1000); + + // Save current time. + TTime utcNow(0); + utcNow.UniversalTime(); + + timer->After(expireTime); + + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + // Ignore time and cb stuff + // Cancel timer that just expired + timer->Cancel(); + + // Start timer again + // Save current time. + utcNow.UniversalTime(); + + timer->After(expireTime); + + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + //See if CB has failed the case + if (eResult->iCaseAlreadyFailed) + { + delete timer; + delete eResult; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timer expiry happened within maxtime to maxtime+accuracy + if ((utcNow + expireTime) <= utcNow2+TTimeIntervalMicroSeconds32(KTickResolution) && (utcNow + expireTime + + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds)) + > utcNow2) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer; + delete eResult; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start timer that has left side of the window in the past. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureLeftSideInThePastL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + TExtendedTestResult *eResult = new TExtendedTestResult(&aResult); + CInheritedCFlexTimer + * timer = CInheritedCFlexTimer::NewL(CActive::EPriorityStandard, + TCallBack( + InheritedFlexTimerCallbackStopSchedulerKErrNone, + eResult)); + + // Expire in 5 seconds + TTimeIntervalMicroSeconds32 winTime(10 * 1000 * 1000); + TTimeIntervalMicroSeconds32 expireTime(5 * 1000 * 1000); + + // Save current time. + TTime utcNow(0); + utcNow.UniversalTime(); + timer->Configure(winTime); + timer->After(expireTime); + + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + //See if CB has failed the case + if (eResult->iCaseAlreadyFailed) + { + delete timer; + delete eResult; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timer expiry happened within maxtime to maxtime+accuracy + if ((utcNow + expireTime) <= utcNow2+TTimeIntervalMicroSeconds32(KTickResolution) && (utcNow + expireTime + + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds)) + > utcNow2) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer; + delete eResult; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Start two timers and see that window works if another is started with left +// side of the window in the past. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureLeftSideInThePastWindowCheckL( + TTestResult& aResult, CTestFlexTimer */*cb*/) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + // Expire in 10 seconds + TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); + //Expire within first timers default window + TTimeIntervalMicroSeconds32 expireTime2(9 * 1000 * 1000); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->Configure(TTimeIntervalMicroSeconds(15 * 1000 * 1000)); + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(17 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed || eResult2->iCaseAlreadyFailed) + { + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + else + { + aResult.SetResult(eResult2->iTestResult->iResult, + eResult2->iTestResult->iResultDes); + } + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + } + // Get new current time + TTime utcNow2(0); + utcNow2.UniversalTime(); + + //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy + if ((utcNow + expireTime2) <= TTime(eResult2->iTimerStoppedTime+KTickResolution) + && (utcNow + expireTime2 + TTimeIntervalMicroSeconds32( + KTimerAccuracyMicroSeconds)) > TTime( + eResult2->iTimerStoppedTime) && + + (utcNow + expireTime2) <= TTime(eResult1->iTimerStoppedTime+KTickResolution) && (utcNow + + expireTime2 + TTimeIntervalMicroSeconds32( + KTimerAccuracyMicroSeconds)) > TTime(eResult1->iTimerStoppedTime)) + { + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + } + else + { + _LIT( KDescription , "Some timer was fired either too early or too late.\n"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + return KErrNone; + + } + +// -------------------------------------------------------------------------- +// Call Configure 32 bit with Negative window size +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureWithNegativeWindowSize32L( + TTestResult& aResult, CTestFlexTimer *cb ) + { + RDebug::Printf("ConfigureWithNegativeWindowSize32L"); + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + + // negative time + TTimeIntervalMicroSeconds32 confTime(-1); + CInheritedCFlexTimer* timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); + //Accept panic as passed case + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, + EFlexTimerWindowLessThanZero); + timer->Configure(confTime); + //CActiveScheduler::Start(); + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + _LIT( KDescription , "Configure(32) with negative interval failed to panic\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// Call Configure 64 bit with Negative window size +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureWithNegativeWindowSize64L( + TTestResult& aResult, CTestFlexTimer *cb ) + { + RDebug::Printf("ConfigureWithNegativeWindowSize64L"); + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + + // negative time + TTimeIntervalMicroSeconds confTime(-1); + CInheritedCFlexTimer* timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); + //Accept panic as passed case + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, + EFlexTimerWindowLessThanZero); + timer->Configure(confTime); + //CActiveScheduler::Start(); + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + _LIT( KDescription , "Configure(64) with negative interval failed to panic\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// - +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureWithMaxWindow32L( + TTestResult& aResult, CTestFlexTimer* /* cb */ ) + { + RDebug::Printf("ConfigureWithMaxWindow32L"); + TTestResult *res1 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + eResult1->iTimerID = 0; + TTimeIntervalMicroSeconds32 expireTime1( 0x7FFFFFFF ); + //just something + RArray timers; + CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, + &timers), 0); + TTimerStruct *s1 = new TTimerStruct(); + s1->iEResult = eResult1; + s1->iTimer = timer1; + timers.Append(*s1); + timer1->Configure(expireTime1); + timer1->After(expireTime1); + + timers[0].iCurrentlyActive = 0; + + //Timers to cancel timer and stop scheduler. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(7 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + StopActiveScheduler)); + CPeriodic *pp = CPeriodic::NewL(EPriorityNormal); + s1->iStartTimer = pp; + pp->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + CancelCFlexTimerArray, &timers)); + + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; delete pp; + delete s1; + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + } + delete timer1; + delete eResult1; + delete res1; + return KErrNone; + } +// -------------------------------------------------------------------------- +// - +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureWithThreeYearWindow64L( + TTestResult& aResult, CTestFlexTimer *cb ) + { + RDebug::Printf("ConfigureWithThreeYearWindow64L"); + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + + // negative time + TTimeIntervalMicroSeconds confTime(93312000000000); + CInheritedCFlexTimer* timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); + //Accept panic as passed case + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, + EFlexTimerServerIllegalTimerValue); + timer->Configure(confTime); + //CActiveScheduler::Start(); + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + _LIT( KDescription , "Configure(93312000000000 failed to panic\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// - +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureWithMaxWindow64L( + TTestResult& aResult, CTestFlexTimer *cb ) + { + RDebug::Printf("ConfigureWithMaxWindow64L"); + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + + // negative time + TTimeIntervalMicroSeconds confTime(0x7FFFFFFFFFFFFFFF); + CInheritedCFlexTimer* timer = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult)); + //Accept panic as passed case + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, + EFlexTimerServerIllegalTimerValue); + timer->Configure(confTime); + //CActiveScheduler::Start(); + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + _LIT( KDescription , "Configure(0x7FFFFFFFFFFFFFFF) failed to panic\n"); + aResult.SetResult(KErrGeneral, KDescription); + delete timer; + delete eResult; + delete res; + return KErrNone; + } +// -------------------------------------------------------------------------- +// Start timer and call configure while it is running +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureWhileTimerIsInUseL( TTestResult& aResult, + CTestFlexTimer */*cb*/) + { + RDebug::Printf("ConfigureWhileTimerIsInUseL"); + TTestResult *res1 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + eResult1->iTimerID = 0; + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000); + //just something + RArray timers; + CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( + CActive::EPriorityStandard, TCallBack(StopSchedulerKErrNoneArray, + &timers), 0); + TTimerStruct *s1 = new TTimerStruct(); + s1->iEResult = eResult1; + s1->iTimer = timer1; + timers.Append(*s1); + + TTime homeNow(0); + homeNow.HomeTime(); + + timer1->After(expireTime1); + + timers[0].iCurrentlyActive = 0; + + //Timer to call configure while timer is running + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + ConfigureKErrInUseArray, &timers)); + + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + delete p; + delete s1; + _LIT( KDescription , "Passed"); + aResult.SetResult(KErrNone, KDescription); + //See if CB has failed the case + if (eResult1->iCaseAlreadyFailed) + { + aResult.SetResult(eResult1->iTestResult->iResult, + eResult1->iTestResult->iResultDes); + delete timer1; + delete eResult1; + delete res1; + return KErrNone; + } + TTime homeNow2(0); + homeNow2.HomeTime(); + //Check if timers expiry happened within timer2 maxtime to maxtime+accuracy + if (!((homeNow + expireTime1) <= homeNow2+TTimeIntervalMicroSeconds32(KTickResolution) && (homeNow + expireTime1 + + TTimeIntervalMicroSeconds32(KTimerAccuracyMicroSeconds)) + > homeNow2)) + { + _LIT( KEDescription , "Timer was not fired within limits"); + aResult.SetResult(KErrGeneral, KEDescription); + } + delete timer1; + delete eResult1; + delete res1; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// timer is started twice +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::TimerIsStartedTwiceL( TTestResult& aResult, + CTestFlexTimer *cb ) + { + TTestResult *res1 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + eResult1->iTimerID = 0; + CInheritedCFlexTimer2* timer1 = CInheritedCFlexTimer2::NewL( + CActive::EPriorityStandard, TCallBack(NotCalledCB, eResult1), 0); + // Expire in 10 seconds + TTimeIntervalMicroSeconds expireTime1(10 * 1000 * 1000); + RArray timers; + TTimerStruct *s1 = new TTimerStruct(); + s1->iEResult = eResult1; + s1->iTimer = timer1; + timers.Append(*s1); + + timer1->After(expireTime1); + timers[0].iCurrentlyActive = 0; //CB uses this to decide which timer to start again; + + //Timer to start timer again + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(5 * 1000 * 1000, 30 * 1000 * 1000, TCallBack( + StartTimerAgainArray, &timers)); + // Panic category: "E32USER-CBase" + // Panic reason: 42 (attempt to active CActive when a request is still + // outstanding. + cb->TestModuleIf().SetExitReason(CTestModuleIf::EPanic, 42); + // Start scheduler and wait for callback to panic it + CActiveScheduler::Start(); + // We should never get here -> fail the case + cb->TestModuleIf().SetExitReason(CTestModuleIf::ENormal, KErrNone); + delete p; + delete s1; + _LIT( KDescription , "double start failed to panic."); + aResult.SetResult(KErrGeneral, KDescription); + + delete timer1; + delete eResult1; + delete res1; + return KErrNone; + } + +// -------------------------------------------------------------------------- +// See that timer is stoppped with valid reason and stop scheduler +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::InheritedFlexTimerCallbackStopSchedulerKErrNone( + TAny* aArgument ) + { + RDebug::Printf("InheritedFlexTimerCallbackStopSchedulerKErrNone"); + TExtendedTestResult *eRes = + reinterpret_cast (aArgument); + if (eRes->iStatusCode != KErrNone) + { + eRes->iCaseAlreadyFailed = ETrue; + _LIT(KError,"Error: Wrong timer expiry reason\n"); + eRes->iTestResult->SetResult(KErrGeneral, KError); + } + CActiveScheduler::Stop(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// See that timer is stoppped with valid reason and stop scheduler +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::InheritedFlexTimerCallbackStopSchedulerKErrAbort( + TAny* aArgument ) + { + RDebug::Printf("InheritedFlexTimerCallbackStopSchedulerKErrAbort"); + TExtendedTestResult *eRes = + reinterpret_cast (aArgument); + if (eRes->iStatusCode != KErrAbort) + { + eRes->iCaseAlreadyFailed = ETrue; + _LIT(KError,"Error: Wrong timer expiry reason"); + eRes->iTestResult->SetResult(KErrGeneral, KError); + } + CActiveScheduler::Stop(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// See that timer is stoppped with valid reason and stop scheduler +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::InheritedFlexTimerCallbackStopSchedulerKErrCancel( + TAny* aArgument ) + { + RDebug::Printf("InheritedFlexTimerCallbackStopSchedulerKErrCancel"); + TExtendedTestResult *eRes = + reinterpret_cast (aArgument); + if (eRes->iStatusCode != KErrCancel) + { + eRes->iCaseAlreadyFailed = ETrue; + _LIT(KError,"Error: Wrong timer expiry reason"); + eRes->iTestResult->SetResult(KErrGeneral, KError); + } + CActiveScheduler::Stop(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// See that timer is stoppped with valid reason +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::InheritedFlexTimerCallbackKErrNone( TAny* aArgument ) + { + TExtendedTestResult *eRes = + reinterpret_cast (aArgument); + if (eRes->iStatusCode != KErrNone) + { + eRes->iCaseAlreadyFailed = ETrue; + _LIT(KError,"Error: Wrong timer expiry reason"); + eRes->iTestResult->SetResult(KErrGeneral, KError); + } + return 1; // nada + } + +// -------------------------------------------------------------------------- +// See that timer is stoppped with valid reason +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::InheritedFlexTimerCallbackKErrAbort( TAny* aArgument ) + { + TExtendedTestResult *eRes = + reinterpret_cast (aArgument); + if (eRes->iStatusCode != KErrAbort) + { + eRes->iCaseAlreadyFailed = ETrue; + _LIT(KError,"Error: Wrong timer expiry reason"); + eRes->iTestResult->SetResult(KErrGeneral, KError); + } + return 1; // nada + } + +// -------------------------------------------------------------------------- +// See that both timers are stoppped with valid reason and save expiry time +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::InheritedFlexTimerCallbackKErrNoneMarkTimestamp( + TAny* aArgument ) + { + TExtendedTestResult *eRes = + reinterpret_cast (aArgument); + if (eRes->iStatusCode != KErrNone) + { + eRes->iCaseAlreadyFailed = ETrue; + _LIT(KError,"Error: Wrong timer expiry reason"); + eRes->iTestResult->SetResult(KErrGeneral, KError); + } + TTime utcNow(0); + utcNow.UniversalTime(); + eRes->iTimerStoppedTime = utcNow.Int64(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// See that both timers are stoppped with valid reason and save expiry time +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::InheritedFlexTimerCallbackKErrNoneMarkTimestampStopScheduler( + TAny* aArgument ) + { + TExtendedTestResult *eRes = + reinterpret_cast (aArgument); + if (eRes->iStatusCode != KErrNone) + { + eRes->iCaseAlreadyFailed = ETrue; + _LIT(KError,"Error: Wrong timer expiry reason"); + eRes->iTestResult->SetResult(KErrGeneral, KError); + } + TTime utcNow(0); + utcNow.UniversalTime(); + eRes->iTimerStoppedTime = utcNow.Int64(); + CActiveScheduler::Stop(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// Stop active scheduler +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::StopActiveScheduler( TAny*/*aArgument*/) + { + CActiveScheduler::Stop(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// Change system time + 1s and cancel Periodic timer given as parameter +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ChangeSystemTime1sAndCancel( TAny* aArgument ) + { + RDebug::Printf("ChangeSystemTime1sAndCancel"); + TTime now(0); + now.HomeTime(); + User::SetHomeTime(now + TTimeIntervalMicroSeconds32(1000 * 1000)); + CPeriodic *p = reinterpret_cast (aArgument); + p->Cancel(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// Change time zone and cancel Periodic timer given as parameter +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ChangeTimeZoneAndCancel( TAny* aArgument ) + { + RDebug::Printf("ChangeTimeZoneAndCancel"); + TTimeIntervalSeconds currentUtcOffset( User::UTCOffset() ); + User::SetUTCOffset( currentUtcOffset.Int() + 3000 ); + CPeriodic *p = reinterpret_cast (aArgument); + p->Cancel(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// Change secure time + 1s and cancel Periodic timer given as parameter +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ChangeSecureTimeAndCancel( TAny* aArgument ) + { + RDebug::Printf("ChangeSecureTimeAndCancel"); + TTime now(0); + now.UniversalTime(); + User::SetUTCTimeSecure(now + TTimeIntervalMicroSeconds32(1000 * 1000)); + CPeriodic *p = reinterpret_cast (aArgument); + p->Cancel(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// Fail result if this is called +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::NotCalledCB( TAny* aArgument ) + { + TExtendedTestResult *eRes = + reinterpret_cast (aArgument); + eRes->iCaseAlreadyFailed = ETrue; + _LIT(KError,"Error: invalid CB called"); + eRes->iTestResult->SetResult(KErrGeneral, KError); + return 1; //nada + } + +// -------------------------------------------------------------------------- +// Stop active schduler and cancel Periodic timer given as paramter +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::StopSchedulerAndCancel( TAny* aArgument ) + { + CPeriodic *p = reinterpret_cast (aArgument); + p->Cancel(); + CActiveScheduler::Stop(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// Cancels CFlexTimer given a parameter +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CancelCFlexTimer( TAny* aArgument ) + { + CFlexTimer *p = reinterpret_cast (aArgument); + p->Cancel(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// Cancels CFlexTimer +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CancelCFlexTimerArray( TAny* aArgument ) + { + RDebug::Printf("CancelCFlexTimerCancelPeriodic"); + RArray *list = + reinterpret_cast*> (aArgument); + (*list)[(*list)[0].iCurrentlyActive].iTimer->Cancel(); + (*list)[0].iCurrentlyActive += 1; + return 1; // nada + } +// -------------------------------------------------------------------------- +// Cancels CFlexTimer and CPeriodic given a parameter +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CancelCFlexTimerCancelPeriodic( TAny* aArgument ) + { + RDebug::Printf("CancelCFlexTimerCancelPeriodic"); + RArray *list = + reinterpret_cast*> (aArgument); + (*list)[(*list)[0].iCurrentlyActive].iTimer->Cancel(); + (*list)[0].iCurrentlyActive += 1; + (*list)[0].iStartTimer->Cancel(); + return 1; // nada + } +// -------------------------------------------------------------------------- +// See that timer is stoppped with valid reason and stop scheduler +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::StopSchedulerKErrNoneArray( TAny* aArgument ) + { + RDebug::Printf("StopSchedulerKErrNoneArray"); + RArray *list = + reinterpret_cast*> (aArgument); + if ((*list)[(*list)[0].iCurrentlyActive].iEResult->iStatusCode + != KErrNone) + { + (*list)[(*list)[0].iCurrentlyActive].iEResult->iCaseAlreadyFailed + = ETrue; + _LIT(KErrorDes,"Error: Wrong timer expiry reason"); + (*list)[(*list)[0].iCurrentlyActive].iEResult->iTestResult->SetResult( + KErrGeneral, KErrorDes); + } + CActiveScheduler::Stop(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// Cancels CFlexTimer given a parameter and stops active scheduler +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CancelCFlexTimerAndStopActiveScheduler( TAny* aArgument ) + { + CFlexTimer *p = reinterpret_cast (aArgument); + p->Cancel(); + CActiveScheduler::Stop(); + return 1; // nada + } + +// -------------------------------------------------------------------------- +// Callback for StartTimerAndAddToList method. This is hack to enable aTimers +// parameter in StartTimerAndAddToList method. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::StartTimerAndAddToListCB( TAny* aArgument ) + { + return StartTimerAndAddToList( + reinterpret_cast*> (aArgument), -1 ); + } + +// -------------------------------------------------------------------------- +// Starts timer and adds it to list given as param +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::StartTimerAndAddToList( + RArray* aList, TInt aTimers ) + { + const TInt KTimerStartInterval = 5 * 1000; //Start new timer every 5ms + const TInt KTimerMaxDelay = 15 * 1000 * 1000; //Timer delay is between 0 and 15 seconds + static TInt numberOfTimers = 0; // How many timers to start + + if (aTimers > 0) + { + numberOfTimers = aTimers; + } + + TTestResult *res = new TTestResult(); + TExtendedTestResult *eResult = new TExtendedTestResult(res); + eResult->iTimerID = aList->Count(); + CInheritedCFlexTimer2* timer = CInheritedCFlexTimer2::NewL( + CActive::EPriorityStandard, + TCallBack(StopTimer, reinterpret_cast (aList)), + eResult->iTimerID); + + // Expire in 0-15s seconds + TInt random = Math::Random() % (KTimerMaxDelay); + TTimeIntervalMicroSeconds expireTime(random); + TTimerStruct *s = new TTimerStruct(); + s->iEResult = eResult; + s->iTimer = timer; + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + s->iEResult->iTimerStartedTime = utcNow.Int64(); + s->iEResult->iTimerExpiryTime = expireTime.Int64(); + TInt listerr = aList->Append(*s); + if (KErrNone != listerr) + { + RDebug::Printf("Error: Adding to list failed %d", listerr); + } + (*aList)[0].iTimersRunning += 1; + timer->After(expireTime); + //First time here. Lets start timer to make many timers. + if (aList->Count() == 1) + { + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + p->Start(KTimerStartInterval, KTimerStartInterval, TCallBack( + StartTimerAndAddToListCB, reinterpret_cast (aList) )); + (*aList)[0].iStartTimer = p; + } + RDebug::Printf("StartTimerAndAddToList: timers running %d", + (*aList)[0].iTimersRunning); + RDebug::Printf("StartTimerAndAddToList: list->Count() %d", aList->Count()); + if (aList->Count() == numberOfTimers) + { + ((*aList)[0].iStartTimer->Cancel()); + } + return 1; // nada + } + +// -------------------------------------------------------------------------- +// Starts timer and adds it to list given as param +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::StopTimer( TAny* aArgument ) + { + RArray *list = + reinterpret_cast*> (aArgument); + RDebug::Printf("StopTimer: timers running %d", (*list)[0].iTimersRunning); + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + (*list)[0].iTimersRunning -= 1; + (*list)[(*list)[0].iCurrentlyActive].iEResult->iTimerStoppedTime + = utcNow.Int64(); + if ((*list)[0].iTimersRunning == 0) + { + (*list)[0].iStartTimer->Cancel(); + CActiveScheduler::Stop(); + } + return 1; // nada + } +// -------------------------------------------------------------------------- +// Try to configure timer ans see that correct error code is returned +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::ConfigureKErrInUseArray( TAny* aArgument ) + { + RDebug::Printf("ConfigureKErrInUseArray"); + RArray *list = + reinterpret_cast*> (aArgument); + TInt error = (*list)[(*list)[0].iCurrentlyActive].iTimer->Configure( + TTimeIntervalMicroSeconds(12 * 1000 * 1000)); + if (KErrInUse != error) + { + (*list)[(*list)[0].iCurrentlyActive].iEResult->iCaseAlreadyFailed + = ETrue; + _LIT(KError,"Error: Wrong return code 64bit if\n"); + (*list)[(*list)[0].iCurrentlyActive].iEResult->iTestResult->SetResult( + KErrGeneral, KError); + return 1; + } + //Try same with 32 bit if + error = (*list)[(*list)[0].iCurrentlyActive].iTimer->Configure( + TTimeIntervalMicroSeconds32(12 * 1000 * 1000)); + if (KErrInUse != error) + { + (*list)[(*list)[0].iCurrentlyActive].iEResult->iCaseAlreadyFailed + = ETrue; + _LIT(KError,"Error: Wrong return code 32bit if\n"); + (*list)[(*list)[0].iCurrentlyActive].iEResult->iTestResult->SetResult( + KErrGeneral, KError); + } + return 1; // nada + } + +// -------------------------------------------------------------------------- +// start timer again +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::StartTimerAgainArray( TAny* aArgument ) + { + RDebug::Printf("StartTimerAgainArray"); + RArray *list = + reinterpret_cast*> (aArgument); + (*list)[(*list)[0].iCurrentlyActive].iTimer->After( + TTimeIntervalMicroSeconds(12 * 1000 * 1000)); + return 1; // nada + } +// -------------------------------------------------------------------------- +// Start two timers and see that they expire at the same time. +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CpuLoadCreateAndExpireTwoOverlappingAfterTimersL( + TTestResult& aResult, CTestFlexTimer *cb ) + { + TTestResult *res1 = new TTestResult(); + TTestResult *res2 = new TTestResult(); + TExtendedTestResult *eResult1 = new TExtendedTestResult(res1); + TExtendedTestResult *eResult2 = new TExtendedTestResult(res2); + + + eResult1->iTimerID = 1; + eResult2->iTimerID = 2; + + CInheritedCFlexTimer* timer1 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult1)); + CInheritedCFlexTimer* timer2 = CInheritedCFlexTimer::NewL( + CActive::EPriorityStandard, + TCallBack(InheritedFlexTimerCallbackKErrNoneMarkTimestamp, + eResult2)); + + // Expire in 10 seconds + TTimeIntervalMicroSeconds32 expireTime1(10 * 1000 * 1000); + //Expire within first timers default window + TTimeIntervalMicroSeconds32 expireTime2(static_cast ((10 * 1000 + * 1000 - static_cast (10 * 1000 * 1000) + * KDefaultWindowMultiplier))); + + // Save current time + TTime utcNow(0); + utcNow.UniversalTime(); + + timer1->After(expireTime1); + timer2->After(expireTime2); + + //Timer to stop active scheduler after timers under test are completed. + CPeriodic *p = CPeriodic::NewL(EPriorityNormal); + + p->Start(15 * 1000 * 1000, 1000, TCallBack(StopActiveScheduler)); + + MSTIFTestInterference* interference = MSTIFTestInterference::NewL( + cb, MSTIFTestInterference::EThread ); + + // Start interference to generate 99% CPU load (100 ms load, 1% idle) + interference->StartL( MSTIFTestInterference::ECpuLoad, 1, 100 ); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + interference->Stop(); + delete interference; + + delete p; + + // Check results + TInt64 timer1RightWin = + utcNow.Int64() + static_cast(expireTime1.Int()); + TInt64 timer2RightWin = + utcNow.Int64() + static_cast(expireTime2.Int()); + TInt64 timer1LeftWin = timer2RightWin - static_cast( + (static_cast(expireTime1.Int()) * KDefaultWindowMultiplier)); + TInt64 timer2LeftWin = timer2RightWin - static_cast( + (static_cast(expireTime2.Int()) * KDefaultWindowMultiplier)); + TInt64 timer1StopedTime = eResult1->iTimerStoppedTime; + TInt64 timer2StopedTime = eResult2->iTimerStoppedTime; + + //See if Timer 1 Callback has failed the case + if (eResult1->iCaseAlreadyFailed) + { + _LIT( KDescription ,"Timer 1 has failed" ); + aResult.SetResult( KErrGeneral, KDescription ); + } + //See if Timer 2 Callback has failed the case + else if (eResult2->iCaseAlreadyFailed) + { + _LIT( KDescription,"Timer 2 has failed" ); + aResult.SetResult( KErrGeneral, KDescription ); + } + // Check if timer 1 has timed out too early + else if ((timer1StopedTime + KTickResolution) < timer1LeftWin) + { + _LIT( KDescription, "Timer 1 timed out too early" ); + aResult.SetResult( KErrGeneral, KDescription ); + } + // Check if timer 1 has timed out too Late + else if ((timer1StopedTime - KTimerAccuracyMicroSeconds) > timer1RightWin) + { + _LIT( KDescription, "Timer 1 timed out too late" ); + aResult.SetResult( KErrGeneral, KDescription ); + } + // Check if timer 2 has timed out too early + else if ((timer2StopedTime + KTickResolution) < timer2LeftWin) + { + _LIT( KDescription, "Timer 2 timed out too early" ); + aResult.SetResult( KErrGeneral, KDescription ); + } + // Check if timer 2 has timed out too Late + else if ((timer2StopedTime - KTimerAccuracyMicroSeconds - KExtraSlack) > timer2RightWin) + { + _LIT( KDescription, "Timer 2 timed out too late" ); + aResult.SetResult( KErrGeneral, KDescription ); + } + // Check that the timers 1 and 2 timed out at the same time + else if (((timer1StopedTime + KTimerAccuracyMicroSeconds) < timer2StopedTime) || + ((timer1StopedTime - KTimerAccuracyMicroSeconds) > timer2StopedTime)) + { + _LIT( KDescription, "Timers 1 and 2 did not timeout at the same time" ); + aResult.SetResult( KErrGeneral, KDescription ); + } + // Everything was successful + else + { + _LIT( KDescription, "Passed" ); + aResult.SetResult( KErrNone, KDescription ); + } + + // Case was executed + delete timer1; + delete timer2; + delete eResult1; + delete eResult2; + delete res1; + delete res2; + + return KErrNone; + } +// -------------------------------------------------------------------------- +// Start many timers and see that nothing goes wrong when they are expired at rapid sequence +// -------------------------------------------------------------------------- +// +TInt CTestCFlexTimer::CpuLoadManyTimersL( + TTestResult& aResult, CTestFlexTimer *cb ) + { + RDebug::Printf("CpuLoadManyTimersL"); + // This list will contain all the timer structs, expiry times etc. + // First cell will always tell which timer is currently active + // active info is transferred from e.g. InheritedCFlexTimer2::RunL to CB function + RArray timers; + // This CB contains all the logic about timer addition + StartTimerAndAddToList( &timers, 100 ); + + MSTIFTestInterference* interference = MSTIFTestInterference::NewL( + cb, MSTIFTestInterference::EThread ); + // Start interference to generate 99% CPU load (100 ms load, 1% idle) + interference->StartL( MSTIFTestInterference::ECpuLoad, 1, 50 ); + // Start scheduler and wait for callback to stop it + CActiveScheduler::Start(); + interference->Stop(); + delete interference; + + // Delete CPeriodic that was used to launch new FlexTimers + delete timers[0].iStartTimer; + _LIT( KDescriptionP , "Passed"); + aResult.SetResult(KErrNone, KDescriptionP); + // Loop throug list and see if timers fired within limits. + // also delete all stuff reserved earlier by StartTimerAndAddToList + while (timers.Count()) + { + TInt64 rightWin = timers[0].iEResult->iTimerStartedTime + + timers[0].iEResult->iTimerExpiryTime; + TInt64 leftWin = rightWin - + (static_cast (timers[0].iEResult->iTimerExpiryTime) * + KDefaultWindowMultiplier); + TInt64 stopTime = timers[0].iEResult->iTimerStoppedTime; + + // Have fun with reading this. It is not as bad as it looks + // Just checks if CB already failed the case + // and if timer was launched within its window(default) and timer accuracy + if (timers[0].iEResult->iCaseAlreadyFailed) + { + _LIT( KDescription , "Case was failed earlier for unknown reason."); + aResult.SetResult(KErrGeneral, KDescription); + } + // Check if timer has expired before the window has started. + else if((stopTime + KTickResolution) < leftWin) + { + _LIT( KDescription , "Some timer has expired too soon"); + aResult.SetResult(KErrGeneral, KDescription); + } + // Check if timeout has happened too long time after window end. + else if (stopTime > (rightWin + KTimerAccuracyMicroSeconds + KExtraSlack)) + { + _LIT( KDescription , "Some timer has expired too late"); + aResult.SetResult(KErrGeneral, KDescription); + } + delete timers[0].iEResult->iTestResult; + delete timers[0].iEResult; + delete timers[0].iTimer; + timers.Remove(0); + } + // Case was executed + timers.Close(); + return KErrNone; + } + +// ======== GLOBAL FUNCTIONS ========