/*

 * ============================================================================

 *  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 <e32debug.h>           // for RDebug

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

#include <StifTestInterference.h>

#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<TTimerStruct> *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<TInt64> ((10 * 1000

            * 1000 - static_cast<float> (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<TInt64> ((10 * 1000

            * 1000 - static_cast<float> (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<TInt64> ((10 * 1000

            * 1000 - static_cast<float> (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<TTimerStruct> 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<float> (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,