/*

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

*  Name        : testrflextimer.cpp

*  Part of     : src / testflextimer

*  Description : STIF test cases for RFlexTimer

*  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 <rflextimer.h>             // for RFlexTimer

#include <stiftesteventinterface.h> // for TEventIf 

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

#include "testrflextimer.h"

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

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

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

// Constructor

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

//

CTestRFlexTimer::CTestRFlexTimer()

    {

    }

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

// Destructor

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

//

CTestRFlexTimer::~CTestRFlexTimer()

    {

    }

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

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

// |  \ |___ |    |__|  \_/     |    |__| |___ |    |_/  [__  

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

// 

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

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

TBool CTestRFlexTimer::IsDelayOk( 

    const TTimeIntervalMicroSeconds aDelay,

    const TTimeIntervalMicroSeconds32 aInterval,

    const TTimeIntervalMicroSeconds32 aWindow )

    {

    TTimeIntervalMicroSeconds interval( aInterval.Int() );

    TTimeIntervalMicroSeconds window( aWindow.Int() );

    return IsDelayOk( aDelay, interval, window );

    }

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

TBool CTestRFlexTimer::IsDelayOk( 

    const TTimeIntervalMicroSeconds aDelay,

    const TTimeIntervalMicroSeconds32 aInterval,

    const TTimeIntervalMicroSeconds aWindow )

    {

    TTimeIntervalMicroSeconds interval( aInterval.Int() );

    return IsDelayOk( aDelay, interval, aWindow );

    }

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

TBool CTestRFlexTimer::IsDelayOk( 

    const TTimeIntervalMicroSeconds aDelay,

    const TTimeIntervalMicroSeconds aInterval,

    const TTimeIntervalMicroSeconds32 aWindow )

    {

    TTimeIntervalMicroSeconds window( aWindow.Int() );

    return IsDelayOk( aDelay, aInterval, window );

    }

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

TBool CTestRFlexTimer::IsDelayOk( 

    const TTimeIntervalMicroSeconds aDelay,

    const TTimeIntervalMicroSeconds aInterval,

    const TTimeIntervalMicroSeconds aWindow )

    {

    /**

     *  Timer can be expired 1 sec late or 1 system tick (15625 microseconds)

     *  early.

     */

    const TInt64 KTimerResolution( 1000000 ); 

    const TInt64 KTickResolution( 1000000 / 64 );

    RDebug::Print( 

       _L("=== Timer delay: %Ld, interval: %Ld, window: %Ld"), 

       aDelay.Int64(),

       aInterval.Int64(),

       aWindow.Int64() );

    return !( aDelay.Int64() < aInterval.Int64() - aWindow.Int64() - KTickResolution ||

              aDelay.Int64() > aInterval.Int64() + KTimerResolution );

    }

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

// Create, configure, start with AfterTicks and close RFlexTimer 

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

//

TTimeIntervalMicroSeconds CTestRFlexTimer::ExecuteAfterTicksL(

    TInt aTicks,

    TTimeIntervalMicroSeconds aWindowSize )

    {

    // Create, connect and configure the timer handle

    RFlexTimer timer;

    User::LeaveIfError( timer.Connect() );

    User::LeaveIfError( timer.Configure( aWindowSize ) );

    TTime startTime;

    startTime.UniversalTime();

    // Run the timer and wait its expiration

    TRequestStatus status;

    timer.AfterTicks( status, aTicks );

    User::WaitForRequest( status );

    TTime endTime;

    endTime.UniversalTime();

    // Clean up

    timer.Close();

    // Return running time of the timer

    return endTime.MicroSecondsFrom( startTime );

    }

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

// ___ ____ ____ ___    ____ ____ ____ ____ ____ 

//  |  |___ [__   |     |    |__| [__  |___ [__  

//  |  |___ ___]  |     |___ |  | ___] |___ ___] 

//

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

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

// TEST CASE: Start a timer using After (32 bit) and wait it to expire.

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

//

TInt CTestRFlexTimer::ExpireAfter32L(

    TTestResult& aResult, 

    CTestFlexTimer* /* aCallback */ )

    {

    __UHEAP_MARK;

    const TTimeIntervalMicroSeconds32 KInterval( 3000000 ); // Time to wait timer

    const TTimeIntervalMicroSeconds KWindow( 0 );           // Window for check results

    // Initialize case

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

    TTime startTime;

    startTime.UniversalTime();

    TRequestStatus status;

    // Do the actual test

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

    RFlexTimer timer;

    User::LeaveIfError( timer.Connect() );

    timer.After( status, KInterval );

                                     //    //  ___     _____

    User::WaitForRequest( status ); // // // //_ // //  //

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

    timer.Close();

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

    // Verify the test

    TTime endTime;

    endTime.UniversalTime();

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

    if ( !IsDelayOk( endTime.MicroSecondsFrom( startTime ), KInterval, KWindow ) )

        {

        aResult.SetResult( KErrGeneral, _L("Test case failed. Wrong expiration.") );

        }

    __UHEAP_MARKEND;

    return KErrNone;

    }

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

// TEST CASE: Start a timer using After (32 bit) and wait it to expire.

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

//

TInt CTestRFlexTimer::ExpireAfter64L(

    TTestResult& aResult, 

    CTestFlexTimer* /* aCallback */ )

    {

    __UHEAP_MARK;

    const TTimeIntervalMicroSeconds KInterval( 3000000 );   // Time to wait timer

    const TTimeIntervalMicroSeconds KWindow( 0 );           // Window for check results

    // Initialize case

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

    TTime startTime;

    startTime.UniversalTime();

    TRequestStatus status;

    // Do the actual test

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

    RFlexTimer timer;

    User::LeaveIfError( timer.Connect() );

    timer.After( status, KInterval );

                                     //    //  ___     _____

    User::WaitForRequest( status ); // // // //_ // //  //

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

    timer.Close();

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

    // Verify the test

    TTime endTime;

    endTime.UniversalTime();

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

    if ( !IsDelayOk( endTime.MicroSecondsFrom( startTime ), KInterval, KWindow ) )

        {

        aResult.SetResult( KErrGeneral, _L("Test case failed. Wrong expiration.") );

        }

    __UHEAP_MARKEND;

    return KErrNone;

    }

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

// TEST CASE: Start a timer using AfterTicks and wait it to expire.

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

//

TInt CTestRFlexTimer::ExpireAfterTicksL(

    TTestResult& aResult, 

    CTestFlexTimer* /* aCallback */ )

    {

    __UHEAP_MARK;

    const TTimeIntervalMicroSeconds32 KInterval( 3000000 );     // Time to wait timer

    const TTimeIntervalMicroSeconds KWindow( 0 );               // Window for check results

    const TTimeIntervalMicroSeconds32 KOneTick( 1000000 / 64 ); // System tick: 1/64 sec

    // Initialize case

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

    TTime startTime;

    startTime.UniversalTime();

    TRequestStatus status;

    // Do the actual test

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

    RFlexTimer timer;

    User::LeaveIfError( timer.Connect() );

    timer.AfterTicks( status, KInterval.Int() / KOneTick.Int() );

                                     //    //  ___     _____

    User::WaitForRequest( status ); // // // //_ // //  //

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

    timer.Close();

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

    // Verify the test

    TTime endTime;

    endTime.UniversalTime();

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

    if ( !IsDelayOk( endTime.MicroSecondsFrom( startTime ), KInterval, KWindow ) )

        {

        aResult.SetResult( KErrGeneral, _L("Test case failed. Wrong expiration.") );

        }

    __UHEAP_MARKEND;

    return KErrNone;

    }

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

// TEST CASE: Start a timer using At and wait it to expire.

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

//

TInt CTestRFlexTimer::ExpireAtL(

    TTestResult& aResult, 

    CTestFlexTimer* /* aCallback */ )

    {

    __UHEAP_MARK;

    const TTimeIntervalMicroSeconds KInterval( 3000000 ); // Time to wait timer

    const TTimeIntervalMicroSeconds KWindow( 0 );         // Window for check results

    // Initialize case

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

    TTime startTime;

    startTime.UniversalTime();

    TRequestStatus status;

    // Do the actual test

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

    RFlexTimer timer;

    User::LeaveIfError( timer.Connect() );

    TTime now;

    now.HomeTime();

    timer.At( status, now + KInterval );

                                     //    //  ___     _____

    User::WaitForRequest( status ); // // // //_ // //  //

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

    timer.Close();

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

    // Verify the test

    TTime endTime;

    endTime.UniversalTime();

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

    if ( !IsDelayOk( endTime.MicroSecondsFrom( startTime ), KInterval, KWindow ) )

        {

        aResult.SetResult( KErrGeneral, _L("Test case failed. Wrong expiration.") );

        }

    __UHEAP_MARKEND;

    return KErrNone;

    }

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

// TEST CASE: Start a timer using AtUTC and wait it to expire.

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

//

TInt CTestRFlexTimer::ExpireAtUtcL(

    TTestResult& aResult, 

    CTestFlexTimer* /* aCallback */ )

    {

    __UHEAP_MARK;

    const TTimeIntervalMicroSeconds KInterval( 3000000 ); // Time to wait timer

    const TTimeIntervalMicroSeconds KWindow( 0 );         // Window for check results

    // Initialize case

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

    TTime startTime;

    startTime.UniversalTime();

    TRequestStatus status;

    // Do the actual test

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

    RFlexTimer timer;

    User::LeaveIfError( timer.Connect() );

    TTime now;

    now.UniversalTime();

    timer.AtUTC( status, now + KInterval );

                                     //    //  ___     _____

    User::WaitForRequest( status ); // // // //_ // //  //

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

    timer.Close();

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

    // Verify the test

    TTime endTime;

    endTime.UniversalTime();

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

    if ( !IsDelayOk( endTime.MicroSecondsFrom( startTime ), KInterval, KWindow ) )

        {

        aResult.SetResult( KErrGeneral, _L("Test case failed. Wrong expiration.") );

        }

    __UHEAP_MARKEND;

    return KErrNone;

    }

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

// TEST CASE: Start timer with After (32 bit) without connecting first

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

//

TInt CTestRFlexTimer::After32WithoutConnect(

    TTestResult& aResult, 

    CTestFlexTimer* aCallback )

    {

    TRequestStatus status;

    // Test should panic with

    // Category: "KERN-EXEC"

    // Reason:   0

    aCallback->TestModuleIf().SetExitReason( 

        CTestModuleIf::EPanic,

        0 );

    // Do the actual test

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

    RFlexTimer timer;

    timer.After( status, TTimeIntervalMicroSeconds32( 1000000 ) );

    User::WaitForRequest( status ); // PANIC

    timer.Close();

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

    // No panic, change result back to normal

    aCallback->TestModuleIf().SetExitReason( 

        CTestModuleIf::ENormal,

        KErrNone );

    aResult.SetResult( KErrGeneral, _L("Test case failed. No panic.") );

    return KErrNone;

    }

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

// TEST CASE: Start timer with After (64 bit) without connecting first

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

//

TInt CTestRFlexTimer::After64WithoutConnect(

    TTestResult& aResult, 

    CTestFlexTimer* aCallback )

    {

    TRequestStatus status;

    // Test should panic with

    // Category: "KERN-EXEC"

    // Reason:   0

    aCallback->TestModuleIf().SetExitReason( 

        CTestModuleIf::EPanic,

        0 );

    // Do the actual test

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

    RFlexTimer timer;

    timer.After( status, TTimeIntervalMicroSeconds( 1000000 ) );

    User::WaitForRequest( status ); // PANIC

    timer.Close();

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

    // No panic, change result back to normal

    aCallback->TestModuleIf().SetExitReason( 

        CTestModuleIf::ENormal,

        KErrNone );

    aResult.SetResult( KErrGeneral, _L("Test case failed. No panic.") );

    return KErrNone;

    }

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

// TEST CASE: Start timer with AfterTicks without connecting first

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

//

TInt CTestRFlexTimer::AfterTicksWithoutConnect(

    TTestResult& aResult, 

    CTestFlexTimer* aCallback )

    {

    TRequestStatus status;

    // Test should panic with

    // Category: "KERN-EXEC"

    // Reason:   0

    aCallback->TestModuleIf().SetExitReason( 

        CTestModuleIf::EPanic,

        0 );

    // Do the actual test

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

    RFlexTimer timer;

    timer.AfterTicks( status, 1000 );

    User::WaitForRequest( status ); // PANIC

    timer.Close();

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

    // No panic, change result back to normal

    aCallback->TestModuleIf().SetExitReason( 

        CTestModuleIf::ENormal,

        KErrNone );

    aResult.SetResult( KErrGeneral, _L("Test case failed. No panic.") );

    return KErrNone;

    }

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

// TEST CASE: Start timer with At without connecting first