// Copyright (c) 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:

//

// Description:

//  

// This test checks the accuracy if NKern::Timestamp (in SMP systems) or

// NKern::Fastcounter (in unicore), when low power modes are being selected

// during idle.

// Platforms requiring this test need to provide a d_timestamp.pdd which

// implements the functions required to test the accurary. If no pdd is 

// supplied the test is skipped and claims to succeed.

// Overview:

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

//! @SYMTestCaseID				KBASE-t_timestamp-2706

//! @SYMTestCaseDesc			verifying that NKern::Timestamp/FastCounter works correctly 

//!                             accross low power modes

//! @SYMPREQ					417-52765

//! @SYMTestPriority			High

//! @SYMTestActions				

//! 1. This test harness first gets information about NKern::Timestamp or

//!     NKern::FastCounter in particular its frequency. It also obtains

//!     the following constants: Number of timer to run the test, number

//!     of retries before giving up if no low power modes are detected,

//!     and acceptable error percent. Length in nanokernel ticks of each cycle

//! 2. Then it measures the timestamp before and after a time interval 

//!    controlled by NTimerIntervalInS (constant is in seconds)

//!    2.1 If in period of KTimerInterval a low power mode was entered and 

//!        the timer underlying NKern::Timestamp had to be restated then before

//!        and after time is stored. The cycle is considered successful.

//! 3. If KNMaxentries occur with no successful entries the test fails

//! 4. If any valid entry has an interval as measured with NKern::Timestamp that

//!    is outside KNErrPercent of the same interval as measured with nanokernel 

//!    ticks then the test fails

//! 5. If KNValidRuns valid cycles have an acceptable error the test succeeds

//! 

//! @SYMTestExpectedResults 

//!     test passed

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

#include <e32std.h>

#include <e32base.h>

#include <e32debug.h>

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <hal.h>

#include <u32hal.h>

#include <e32svr.h>

#include "d_timestamp.h"

_LIT(KTimestampTestLddFileName,"D_TIMESTAMP.LDD");

_LIT(KTimestampTestPddFileName,"D_TIMESTAMP.PDD");

RTest test(_L("T_TIMESTAMP"));

LOCAL_C void UnloadDrivers()

	{

    test.Printf(_L("Unloading LDD\n"));

	TInt r=User::FreeLogicalDevice(RTimestampTest::Name());

    test_KErrNone(r);

	TName pddName(RTimestampTest::Name());

	_LIT(KPddWildcardExtension,".*");

	pddName.Append(KPddWildcardExtension);

	TFindPhysicalDevice findPD(pddName);

	TFullName findResult;

	r=findPD.Next(findResult);

	while (r==KErrNone)

		{

        test.Printf(_L("Unloading PDD: %S\n"),&findResult);

		r=User::FreePhysicalDevice(findResult);

        test_KErrNone(r);

		findPD.Find(pddName); // Reset the find handle now that we have deleted something from the container.

		r=findPD.Next(findResult);

		} 

	}

GLDEF_C TInt E32Main()

    {

    TBool dontFail = (User::CommandLineLength()!=0);

    test.Title();

    test.Start(_L("Timestamp accuracy test"));

    TInt r;

    TRequestStatus st;

    r = User::LoadPhysicalDevice(KTimestampTestPddFileName);

    if (KErrNotFound == r)

        {

        test.Printf(_L("No timestamp pdd, test skipped\n"));

        test.End(); // skip test if this platform does not supply a PDD

        return 0;

        }

	r=User::LoadLogicalDevice(KTimestampTestLddFileName);

	test(r==KErrNone || r==KErrAlreadyExists);

    RTimestampTest ldd;

    r = ldd.Open();

    test_KErrNone(r);

    test.Next(_L("Get timestamp frequency"));

    STimestampTestConfig info;

    r = ldd.Config(info);

    test_KErrNone(r);

    TUint retries = 0;

    TUint validruns = 0;

    test.Next(_L("Get nanotick frequency"));

	TInt tickPeriod = 0;

	r = HAL::Get(HAL::ENanoTickPeriod, tickPeriod);

    test_KErrNone(r);

    test.Printf(_L(" tick period in uS== %d\n"), tickPeriod);

    TInt ticks = info.iTimerDurationS*1000000/tickPeriod;

    TUint64 expected = info.iTimerDurationS*info.iFreq;

    TUint64 acceptError = info.iErrorPercent*expected/100;

    test.Printf(_L("running at %dHz for %d interations, each lasting %d seconds and with %d retries\n"),

                info.iFreq,

                info.iIterations,

                info.iTimerDurationS,

                info.iRetries

        );

    test.Printf(_L("expecting %lu with up to %lu error\n"),expected,acceptError);

    test.Next(_L("test timer interval"));

    STimestampResult result;

    STimestampResult* validResults = new STimestampResult[info.iIterations];

    memset(&validResults[0],0,sizeof(validResults));

    ldd.Start(st,ticks);

    User::WaitForRequest(st);

    test_KErrNone(st.Int());

    FOREVER

        {

        ldd.WaitOnTimer(st,result);

        User::WaitForRequest(st);

        test_KErrNone(st.Int());

        TUint64 error = (result.iDelta>expected) ? result.iDelta-expected : expected - result.iDelta;

        if (error < acceptError)

            {

            test.Printf(_L("Got %lu expected %lu, LPM Entered:%d, error %lu is OK \n"),

                        result.iDelta,expected,result.iLPMEntered,error);

            }

        else 

            {

            test.Printf(_L("Got %lu expected %lu, LPM Entered:%d, error %lu is BAD\n"),

                        result.iDelta,expected,result.iLPMEntered,error);

            if (!dontFail) 

                {

                delete [] validResults;

                ldd.Close();

                UnloadDrivers();

                test(error < acceptError);

                }

            }

        if (result.iLPMEntered)

            {

            retries = 0;

            validResults[validruns] = result;

            if (++validruns==info.iIterations) break;

            }

        else

            {

            retries++;

            if (retries==info.iRetries) 

                {

                test.Printf(_L("several retries with no power mode entry ... aborting ...\n"));

                ldd.Close();

                delete [] validResults;

                UnloadDrivers();

                test_Compare(retries,<,info.iRetries);

                }

            }

        }

    delete [] validResults;

    ldd.Close();

    UnloadDrivers();

    test.End();

	return(0);

    }