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

// e32test\system\t_tick.cpp

// Overview:

// Test tick-based timers

// API Information:

// RTimer

// Details:

// - Create a number of periodic timers, start each and wait for them to 

// complete. Print results.

// - Create a number of random relative timers, start each and wait for 

// them to complete. Print results.

// - Create a number of separate random relative timers, start each and 

// wait for them to complete. Print results.

// - Create a number of random absolute timers, start each and wait for 

// them to complete. Print results.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32uid.h>

#include "d_tick.h"

RTest test(_L("T_TICK"));

RTickTest ticktest;

TInt ActiveCount;

TInt ErrorCount;

TBool PauseOnError = 0;

#define GETCH()		(PauseOnError&&test.Getch())

#define TEST(c)		((void)((c)||(test.Printf(_L("Failed at line %d\n"),__LINE__),GETCH(),test(0),0)))

#define CHECK(c)	((void)(((c)==0)||(test.Printf(_L("Error %d at line %d\n"),(c),__LINE__),GETCH(),test(0),0)))

const TPtrC KLddFileName=_L("D_TICK.LDD");

class CTickTest : public CActive

	{

public:

	CTickTest(TInt aPriority, TInt aId, RTickTest aLdd);

	~CTickTest();

	virtual void RunL();

	virtual void DoCancel();

public:

	void StartPeriodic(TInt aInterval, TInt aCount);

	void StartNShotRel(TInt aMin, TInt aRange, TInt aCount);

	void StartNShotAbs(TInt aMin, TInt aRange, TInt aCount);

	void GetInfo(STickTestInfo& aInfo);

public:

	TInt iId;

	TInt iCount;

	TInt iMin;

	TInt iRange;

	TInt64 iErrorAcc;

	RTickTest iLdd;

	STickTestInfo iInfo;

	};

class CBackgroundTimer : public CActive

	{

public:

	static CBackgroundTimer* NewL(TInt aPriority);

	CBackgroundTimer(TInt aPriority);

	~CBackgroundTimer();

	virtual void RunL();

	virtual void DoCancel();

	void Start();

public:

	RTimer iShort;

	RTimer iLong;

	TRequestStatus iLongStatus;

	};

CTickTest* TickTest[KMaxTimers];

CIdle* Idler;

CBackgroundTimer* BackgroundTimer;

CTickTest::CTickTest(TInt aPriority, TInt aId, RTickTest aLdd)

	:	CActive(aPriority),

		iId(aId),

		iLdd(aLdd)

	{

	}

CTickTest::~CTickTest()

	{

	Cancel();

	iLdd.SetHandle(0);

	}

void CTickTest::StartPeriodic(TInt aInterval, TInt aCount)

	{

	TInt r=iLdd.StartPeriodic(iStatus,iId,aInterval,aCount);

	if (r!=KErrNone)

		{

		TRequestStatus* pS=&iStatus;

		User::RequestComplete(pS,r);

		}

	SetActive();

	}

void CTickTest::StartNShotRel(TInt aMin, TInt aRange, TInt aCount)

	{

	TInt c=aCount;

	if (aCount<0)

		{

		iCount=-aCount;

		c=1;

		}

	iMin=aMin;

	iRange=aRange;

	iErrorAcc=0;

	iInfo.iMinErr=KMaxTInt;

	iInfo.iMaxErr=KMinTInt;

	iInfo.iCount=0;

	iInfo.iRequestedCount=iCount;

	iInfo.iTotalTime=0;

	TInt r=iLdd.StartNShotRel(iStatus,iId,aMin,aRange,c);

	if (r!=KErrNone)

		{

		TRequestStatus* pS=&iStatus;

		User::RequestComplete(pS,r);

		}

	SetActive();

	}

void CTickTest::StartNShotAbs(TInt aMin, TInt aRange, TInt aCount)

	{

	TInt r=iLdd.StartNShotAbs(iStatus,iId,aMin,aRange,aCount);

	if (r!=KErrNone)

		{

		TRequestStatus* pS=&iStatus;

		User::RequestComplete(pS,r);

		}

	SetActive();

	}

void CTickTest::GetInfo(STickTestInfo& aInfo)

	{

	iLdd.GetInfo(iId,aInfo);

	}

void CTickTest::RunL()

	{

	if (iStatus!=KErrNone)

		{

		test.Printf(_L("Timer %d error %d\n"),iId,iStatus.Int());

		++ErrorCount;

		CActiveScheduler::Stop();

		return;

		}

	if (iCount==0)

		GetInfo(iInfo);

	else

		{

		STickTestInfo info;

		iLdd.GetInfo(iId,info);

		TInt err=info.iMinErr;

		if (err<iInfo.iMinErr)

			iInfo.iMinErr=err;

		if (err>iInfo.iMaxErr)

			iInfo.iMaxErr=err;

		++iInfo.iCount;

		iErrorAcc+=err;

		if (--iCount)

			{

			TInt r=iLdd.StartNShotRel(iStatus,iId,iMin,iRange,1);

			if (r!=KErrNone)

				{

				TRequestStatus* pS=&iStatus;

				User::RequestComplete(pS,r);

				}

			SetActive();

			return;

			}

		iInfo.iAvgErr=I64INT(iErrorAcc/TInt64(iInfo.iCount));

		}

	test.Printf(_L("Timer %d\n"),iId);

	if (!--ActiveCount)

		CActiveScheduler::Stop();

	}

void CTickTest::DoCancel()

	{

	iLdd.Stop(iId);

	}

CBackgroundTimer::CBackgroundTimer(TInt aPriority)

	:	CActive(aPriority)

	{

	}

CBackgroundTimer::~CBackgroundTimer()

	{

	iShort.Close();

	iLong.Close();

	}

void CBackgroundTimer::Start()

	{

	iLong.After(iLongStatus, 100000);

	iShort.After(iStatus, 20000);

	SetActive();

	}

void CBackgroundTimer::RunL()

	{

	iLong.Cancel();

	Start();

	}

void CBackgroundTimer::DoCancel()

	{

	iShort.Cancel();

	iLong.Cancel();

	}

CBackgroundTimer* CBackgroundTimer::NewL(TInt aPriority)

	{

	CBackgroundTimer* pB=new (ELeave) CBackgroundTimer(aPriority);

	TInt r=pB->iShort.CreateLocal();

	if (r==KErrNone)

		r=pB->iLong.CreateLocal();

	if (r!=KErrNone)

		{

		delete pB;

		pB=NULL;

		}

	return pB;

	}

void InitialiseL()

	{

	CActiveScheduler* pS=new (ELeave) CActiveScheduler;

	CActiveScheduler::Install(pS);

	TInt i;

	for (i=0; i<KMaxTimers; ++i)

		{

		TickTest[i]=new (ELeave) CTickTest(0,i,ticktest);

		CActiveScheduler::Add(TickTest[i]);

		}

	Idler=CIdle::NewL(-100);

	BackgroundTimer=CBackgroundTimer::NewL(-10);

	CActiveScheduler::Add(BackgroundTimer);

	}

void PrintInfo(TInt aId, STickTestInfo& a)

	{

	test.Printf(_L("%1d: min=%-6d max=%-6d avg=%-6d tot=%-10u count=%d rcount=%d\n"),aId,a.iMinErr,a.iMaxErr,a.iAvgErr,a.iTotalTime,a.iCount,a.iRequestedCount);

	}

void PrintInfo(TInt aId)

	{

	PrintInfo(aId, TickTest[aId]->iInfo);

	}

void PrintInfo()

	{

	TInt i;

	for (i=0; i<KMaxTimers; ++i)

		PrintInfo(i);

	}

TInt ChangeTime(TAny*)

	{

	TTime now;

	now.UniversalTime();

	User::SetUTCTime(now+TTimeIntervalSeconds(1000));

	User::SetUTCTime(now);

	return 1;	// so we run again

	}

GLDEF_C TInt E32Main()

//

// Test tick-based timers

//

    {

	test.Title();

	test.Start(_L("Load test LDD"));

	TInt r=User::LoadLogicalDevice(KLddFileName);

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

	r=ticktest.Open();

	CHECK(r);

	test.Next(_L("Create test objects"));

	TRAP(r, InitialiseL());

	CHECK(r);

	test.Next(_L("Start periodics"));

	TickTest[0]->StartPeriodic(3,1000);

	TickTest[1]->StartPeriodic(5,600);

	TickTest[2]->StartPeriodic(7,400);

	TickTest[3]->StartPeriodic(11,300);

	TickTest[4]->StartPeriodic(13,30);

	TickTest[5]->StartPeriodic(19,30);

	TickTest[6]->StartPeriodic(23,30);

	TickTest[7]->StartPeriodic(37,30);

	ActiveCount=8;

	ErrorCount=0;

	CActiveScheduler::Start();

	PrintInfo();

	test.Next(_L("Start random relative"));

	TickTest[0]->StartNShotRel(1,10,1000);

	TickTest[1]->StartNShotRel(5,25,300);

	TickTest[2]->StartNShotRel(7,93,100);

	TickTest[3]->StartNShotRel(2,2,1000);

	TickTest[4]->StartPeriodic(13,30);

	TickTest[5]->StartPeriodic(19,30);

	TickTest[6]->StartPeriodic(23,30);

	TickTest[7]->StartPeriodic(37,30);

	ActiveCount=8;

	ErrorCount=0;

	CActiveScheduler::Start();

	PrintInfo();

	test.Next(_L("Start separate random relative"));

	TickTest[0]->StartNShotRel(1,10,1000);

	TickTest[1]->StartNShotRel(5,25,300);

	TickTest[2]->StartNShotRel(7,93,100);

	TickTest[3]->StartNShotRel(2,2,1000);

	TickTest[4]->StartNShotRel(1,10,-1000);

	TickTest[5]->StartNShotRel(5,25,-300);

	TickTest[6]->StartNShotRel(7,93,-100);

	TickTest[7]->StartNShotRel(2,2,-1000);

	ActiveCount=8;

	ErrorCount=0;

	CActiveScheduler::Start();

	PrintInfo();

	test.Next(_L("Start random absolute"));

	TickTest[0]->StartNShotAbs(1,10,10);

	TickTest[1]->StartNShotAbs(5,13,3);

	TickTest[2]->StartNShotAbs(1,3,20);

	TickTest[3]->StartNShotAbs(10,1,4);

	TickTest[4]->StartPeriodic(13,30);

	TickTest[5]->StartPeriodic(19,30);

	TickTest[6]->StartPeriodic(23,30);

	TickTest[7]->StartPeriodic(37,30);

	ActiveCount=8;

	ErrorCount=0;

	CActiveScheduler::Start();

	PrintInfo();

	ticktest.Close();

	test.End();

	return(KErrNone);

    }