/*

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

*  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 <flexperiodic.h>           // for CFlexPeriodic

#include <stiftesteventinterface.h> // for TEventIf 

#include "testflextimer.h"          // for global constants

#include "testflexperiodic.h"

/**

 *  Timer can be expired 1 sec late

 *  

 *  Note! Definition

 *  

 *      const TTimeIntervalMicroSeconds32 KTimerResolution( 1000000 );

 * 

 * will cause writable static data due non-trivial constructor of 

 * TTimeIntervalMicroSeconds32.

 *  

 */

const TInt KTimerResolution( 1000000 );

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

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

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

//

CTestFlexPeriodic::CTestFlexPeriodic()

    {

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CTestFlexPeriodic::~CTestFlexPeriodic()

    {

    }

// ---------------------------------------------------------------------------

// _ _ _ ____ _ ___    _    ____ ____ ___  

// | | | |__| |  |     |    |  | |  | |__] 

// |_|_| |  | |  |     |___ |__| |__| |    

//                                         

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// Start scheduler for given time.

// ---------------------------------------------------------------------------

//

void CTestFlexPeriodic::WaitL( TTimeIntervalMicroSeconds32 aPeriod )

    {

    CPeriodic* watchdog = CPeriodic::NewL( CActive::EPriorityStandard );

    CleanupStack::PushL( watchdog );

    watchdog->Start( aPeriod, aPeriod, TCallBack( StopScheduler, NULL ) );

    // Start scheduler. Wait here until the timer expires and stops the

    // scheduler.

    CActiveScheduler::Start();

    // Clean-up

    watchdog->Cancel();

    CleanupStack::PopAndDestroy( watchdog );

    }

// ---------------------------------------------------------------------------

// TCallBack function to stop the scheduler.

// ---------------------------------------------------------------------------

//

TInt CTestFlexPeriodic::StopScheduler( TAny* /* aArgument */ )

    {

    CActiveScheduler::Stop();

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// ____ ____ _    _    ___  ____ ____ _  _ ____ 

// |    |__| |    |    |__] |__| |    |_/  [__  

// |___ |  | |___ |___ |__] |  | |___ | \_ ___] 

//                                              

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// TCallBack function that does nothing. Not ment to be called - just to 

// fulfill the interface.

// ---------------------------------------------------------------------------

//

TInt CTestFlexPeriodic::DoNothing( TAny* /* aArgument */ )

    {

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// TCallBack function that panics testcase if it get called.

// ---------------------------------------------------------------------------

//

TInt CTestFlexPeriodic::PanicClient( TAny* /* aArgument */ )

    {

    User::Panic(_L("NotCalled CB got called"), 0xDEAD);

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// TCallBack function for adding time stamp to an RArray of TTimes.

// ---------------------------------------------------------------------------

//

TInt CTestFlexPeriodic::AddTimestamp( TAny* aArgument )

    {

    __ASSERT_ALWAYS(

        aArgument != NULL,

        User::Panic( KTestFlexTimerPanicCategory, KErrArgument ) );

    //RDebug::Print( _L("CTestFlexPeriodic::AddTimestamp()") );

    RArray<TTime>* times =  reinterpret_cast<RArray<TTime>*>( aArgument );

    TTime now;

    now.UniversalTime();

    TInt err = times->Append( now ); // Data is copied by RArray

    __ASSERT_ALWAYS(

        err == KErrNone,

        User::Panic( KTestFlexTimerPanicCategory, err ) );

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// TCallBack function for restarting CFlexPeriodic timer.

// Action depends the value of iFirstTicksLeft;

// >0 -- Add timestamp to iFirstTimestamps 

// <0 -- Add timestamp to iSecondTimestamps

// =0 -- Add timestamp to iFirstTimestamps AND iSecondTimestamps AND restart

//       the timer with iSecondInterval

// ---------------------------------------------------------------------------

//

TInt CTestFlexPeriodic::RestartTimer( TAny* aArgument )

    {

    __ASSERT_ALWAYS(

        aArgument != NULL,

        User::Panic( KTestFlexTimerPanicCategory, KErrArgument ) );

    TRestartInfo* info =  reinterpret_cast<TRestartInfo*>( aArgument );

    __ASSERT_ALWAYS(

        info->iTimer != NULL && 

        info->iFirstTimestamps != NULL && 

        info->iSecondTimestamps != NULL,

        User::Panic( KTestFlexTimerPanicCategory, KErrArgument ) );

    // Add current time to timestamps

    // Data is copied by RArray - no need to use heap

    TTime now;

    now.UniversalTime();

    TInt ticks( info->iFirstTicksLeft-- ); // Update the ticks

    TInt err( KErrNone );

    if ( ticks > 0 )

        {

        err = info->iFirstTimestamps->Append( now );

        }

    else if ( ticks < 0 )

        {

        err = info->iSecondTimestamps->Append( now );

        }

    else // ticks == 0

        {

        // Set the timestamps.

        // 1st timer settings expiration time is the starting time of the

        // second timer settings. Add timestamp to both arrays.

        err = info->iFirstTimestamps->Append( now );

        __ASSERT_ALWAYS(

            err == KErrNone,

            User::Panic( KTestFlexTimerPanicCategory, err ) );

        err = info->iSecondTimestamps->Append( now );

        // Restart the timer

        info->iTimer->Cancel();

        info->iTimer->Start(

            info->iSecondInterval,

            info->iSecondInterval, 

            TCallBack( RestartTimer, info ) );

        }

    __ASSERT_ALWAYS(

        err == KErrNone,

        User::Panic( KTestFlexTimerPanicCategory, err ) );

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// TCallBack function for trying to configure timer in callback.

// ---------------------------------------------------------------------------

//

TInt CTestFlexPeriodic::ConfigureTimer( TAny* aArgument )

    {

    __ASSERT_ALWAYS(

        aArgument != NULL,

        User::Panic( KTestFlexTimerPanicCategory, KErrArgument ) );

    TConfigureInfo* info =  reinterpret_cast<TConfigureInfo*>( aArgument );

    const TTimeIntervalMicroSeconds32 delayWindow32( info->iDelayWindow );

    const TTimeIntervalMicroSeconds32 intervalWindow32( info->iIntervalWindow );

    const TTimeIntervalMicroSeconds delayWindow64( info->iDelayWindow );

    const TTimeIntervalMicroSeconds intervalWindow64( info->iIntervalWindow );

    info->iConfigResult32 = info->iTimer->Configure( delayWindow32,

                                                     intervalWindow32);

    info->iConfigResult64 = info->iTimer->Configure( delayWindow64,

                                                     intervalWindow64);

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// TCallBack function for starting a flexible periodic timer.

// ---------------------------------------------------------------------------

//

TInt CTestFlexPeriodic::StartTimer( TAny* aArgument )

    {

    __ASSERT_ALWAYS(

        aArgument != NULL,

        User::Panic( KTestFlexTimerPanicCategory, KErrArgument ) );

    const TTimeIntervalMicroSeconds32 KTimerDelay( 2000000 );

    const TTimeIntervalMicroSeconds32 KTimerInterval( 2000000 );

    CFlexPeriodic* timer =  reinterpret_cast<CFlexPeriodic*>( aArgument );

    timer->Start(

        KTimerDelay,

        KTimerInterval,

        TCallBack( StartTimer, timer )

        );

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// ___ _ _  _ ____ ____ ___ ____ _  _ ___     ____ _  _ _  _ ____ . ____ 

//  |  | |\/| |___ [__   |  |__| |\/| |__]    |___ |  | |\ | |    ' [__  

//  |  | |  | |___ ___]  |  |  | |  | |       |    |__| | \| |___   ___] 

//

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// Verify that the timestamps are expired at window.

//

// Note that the timer resolution is 1 sec, so, the actual expiration time can

// be later than set.

// ---------------------------------------------------------------------------

//

TBool CTestFlexPeriodic::AreTimestampsAtWindow( 

    const RArray<TTime>& aTimestamps,

    const TTimeIntervalMicroSeconds32& aDelay,

    const TTimeIntervalMicroSeconds32& aInterval,

    const TTimeIntervalMicroSeconds32& aDelayWindow,

    const TTimeIntervalMicroSeconds32& aIntervalWindow )

    {

    __ASSERT_ALWAYS(

        aTimestamps.Count() >= 2 && 

        aDelay.Int() >= 0 &&

        aInterval.Int() >= 0 &&

        aDelayWindow.Int() >= 0 &&

        aIntervalWindow.Int() >= 0,

        User::Panic( KTestFlexTimerPanicCategory, KErrArgument ) );

    // Timestamps are correct unless proved otherwise 

    TBool ret = ETrue;

    // For the 1st expiration is delay

    TTimeIntervalMicroSeconds delay;

    delay = aTimestamps[1].MicroSecondsFrom( aTimestamps[0] );

    RDebug::Print( _L("Timer delay %Ld"), delay.Int64() );

    if ( delay < aDelay.Int() - aDelayWindow.Int() || 

         delay > aDelay.Int() + KTimerResolution )

        {

        ret = EFalse;

        }

    // The rest of the expirations are intervals

    for ( TInt i( 2 ); i < aTimestamps.Count(); ++i )

        {

        TTimeIntervalMicroSeconds interval;

        interval = aTimestamps[i].MicroSecondsFrom( aTimestamps[i-1] );

        RDebug::Print( _L("Timer interval %Ld"), interval.Int64() );

        if ( interval < aInterval.Int() - aIntervalWindow.Int() || 

             interval > aInterval.Int() + KTimerResolution )

            {

            ret = EFalse;

            }

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// Convert the intervals from 64 bit to 32 bit and call 32 bit checking 

// function.

// ---------------------------------------------------------------------------

//

TBool CTestFlexPeriodic::AreTimestampsAtWindow( 

    const RArray<TTime>& aTimestamps,

    const TTimeIntervalMicroSeconds& aDelay,

    const TTimeIntervalMicroSeconds& aInterval,

    const TTimeIntervalMicroSeconds& aDelayWindow,

    const TTimeIntervalMicroSeconds& aIntervalWindow )

    {

    __ASSERT_ALWAYS(

        I64HIGH( aDelay.Int64() ) == 0 &&

        I64HIGH( aInterval.Int64() ) == 0 &&

        I64HIGH( aDelayWindow.Int64() ) == 0 &&

        I64HIGH( aIntervalWindow.Int64() ) == 0,

        User::Panic( KTestFlexTimerPanicCategory, KErrArgument ) );

    TTimeIntervalMicroSeconds32 delay( I64INT( aDelay.Int64() ) );

    TTimeIntervalMicroSeconds32 interval( I64INT( aInterval.Int64() ) );

    TTimeIntervalMicroSeconds32 delayWindow( I64INT( aDelayWindow.Int64() ) );

    TTimeIntervalMicroSeconds32 intervalWindow( I64INT( aIntervalWindow.Int64() ) );

    return AreTimestampsAtWindow( aTimestamps, 

                                  delay,

                                  interval,

                                  delayWindow,

                                  intervalWindow );

    }

// ---------------------------------------------------------------------------

// Compare are timestamp arrays same

// ---------------------------------------------------------------------------

//

TBool CTestFlexPeriodic::AreTimestampsSame(

    const RArray<TTime>& aLeft,

    const RArray<TTime>& aRight )

    {

    TBool ret( ETrue );

    if ( aLeft.Count() == aRight.Count() )

        {

        for ( TInt i( 0 ); i < aLeft.Count(); ++i )

            {

            if ( aLeft[i] != aRight[i] )

                { // Different timestamp has been found

                ret = EFalse;

                break;

                }

            }

        }

    else

        { // Arrays has different number of timestamps.

        ret = EFalse;

        }

    return ret;

    }

// ---------------------------------------------------------------------------

// ___ ____ _  _ ___  _    ____ ___ ____    ____ _  _ _  _ ____ . ____ 

//  |  |___ |\/| |__] |    |__|  |  |___    |___ |  | |\ | |    ' [__  

//  |  |___ |  | |    |___ |  |  |  |___    |    |__| | \| |___   ___] 

//

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// Configure window sizes - template function

// 

// Timers are designed so that the 1st timer will test that the delay is

// correct and the 2nd timer will test that the interval is correct

// ---------------------------------------------------------------------------

template <class firstType, class secondType>

TInt CTestFlexPeriodic::ConfigureWindowL( TTestResult& aResult )

    {

    __UHEAP_MARK;

    // Constants

    const firstType KFirstDelay( 3000000 );             // 3 sec

    const firstType KFirstInterval( 2000000 );          // 2 sec

    const firstType KFirstDelayWindow( 0 );             // no window

    const firstType KFirstIntervalWindow( 1500000 );    // 1.5 sec

    const secondType KSecondDelay( 3500000 );           // 3.5 sec

    const secondType KSecondInterval( 1000000 );        // 1 sec

    const secondType KSecondDelayWindow( 1500000 );     // 1.5 sec

    const secondType KSecondIntervalWindow( 0 );        // no window

    const TUint KTestRunTime( 10000000 ); // 10 sec

    // Default result if anything leaves i.e. no analyze done.

    aResult.SetResult( KErrGeneral, _L("Test case leaved") );

    // Create, configure and start the flexible periodic timer

    RArray<TTime> firstTimestamps;

    CFlexPeriodic* firstTimer = CFlexPeriodic::NewL( CActive::EPriorityStandard );

    CleanupStack::PushL( firstTimer );

    firstTimer->Configure( KFirstDelayWindow, KFirstIntervalWindow );

    firstTimer->Start( 

        KFirstDelay, 

        KFirstInterval, 

        TCallBack( AddTimestamp, &firstTimestamps ) );

    RArray<TTime> secondTimestamps;

    CFlexPeriodic* secondTimer = CFlexPeriodic::NewL( CActive::EPriorityStandard );

    CleanupStack::PushL( secondTimer );

    secondTimer->Configure( KSecondDelayWindow, KSecondIntervalWindow );

    secondTimer->Start( 

        KSecondDelay, 

        KSecondInterval,

        TCallBack( AddTimestamp, &secondTimestamps ) );

    // Initialize timer expiration time array with starting time to 

    // ease analysing of data.

    TTime startTime;

    startTime.UniversalTime();

    firstTimestamps.Append( startTime );

    secondTimestamps.Append( startTime );

    // The execution will be pending here while active scheduler is running...

                            //    //  ___     _____

    WaitL( KTestRunTime ); // // // //_ // //  //

                          //_//_// //  // //  //

    // Analyze results

    aResult.SetResult( KErrNone, _L("Test case passed") );

    // Check the 1st timer expiration time

    if ( !AreTimestampsAtWindow( 

            firstTimestamps, 

            KFirstDelay, 

            KFirstInterval, 

            KFirstDelayWindow, 

            KFirstIntervalWindow ) )

        {

        aResult.SetResult( 

            KErrGeneral, 

            _L("Test case failed. First timer not in window.") );

        }

    // Check the 2nd timer expiration time

    else if ( !AreTimestampsAtWindow( 

            secondTimestamps, 

            KSecondDelay, 

            KSecondInterval, 

            KSecondDelayWindow, 

            KSecondIntervalWindow ) )

        {

        aResult.SetResult( 

            KErrGeneral, 

            _L("Test case failed. Second timer not in window.") );

        }

    // Check that both timers are expired at the same time

    else if ( !AreTimestampsSame( firstTimestamps, secondTimestamps ) )

        {

        aResult.SetResult( 

            KErrGeneral, 

            _L("Test case failed. Timers are not expired at the same time.") );

        }

    // Clean up

    secondTimer->Cancel();

    secondTimestamps.Close();

    CleanupStack::PopAndDestroy( secondTimer );

    firstTimer->Cancel();

    firstTimestamps.Close();

    CleanupStack::PopAndDestroy( firstTimer );

    __UHEAP_MARKEND;

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// Configure window sizes and start timer with given values - template 

// function

// ---------------------------------------------------------------------------

template <class configureType, class startType>

void CTestFlexPeriodic::ConfigureAndStartTimerL( 

    RArray<TTime>& aTimestamps,

    TInt64 aDelay,

    TInt64 aInterval,

    TInt64 aDelayWindow,

    TInt64 aIntervalWindow )

    {

    const startType KDelay( aDelay );

    const startType KInterval( aInterval );

    const configureType KDelayWindow( aDelayWindow );

    const configureType KIntervalWindow( aIntervalWindow );

    const TUint KTestRunTime( 3000000 );

    TTime now;

    now.UniversalTime();

    aTimestamps.Append( now );

    // Create and start the flexible periodic timer

    CFlexPeriodic* timer = CFlexPeriodic::NewL( CActive::EPriorityStandard );

    CleanupStack::PushL( timer );

    timer->Configure( KDelayWindow, KIntervalWindow );

    timer->Start( KDelay, KInterval, TCallBack( AddTimestamp, &aTimestamps ) );