// 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_tock.cpp

// Overview:

// Test tick-based timers

// API Information:

// RTimer

// Details:

// - Create a number of periodic timers, start each and change the time

// offset via TLocale::SetUniversalTimeOffset(). Print the results.

// - Create a number of periodic timers, start each and change the system

// time. Print the results.

// - Create a number of periodic timers, start each and change the system

// time in a second thread. Print the results.

// - Create a number of periodic timers, start each along with a background

// timer. Print the results.

// - Create a number of periodic timers, start each and change the system

// time and tick delay. Print the 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_TOCK"));

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 StartNShotDelay(TInt aPeriod, TInt aDelay, 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::StartNShotDelay(TInt aPeriod, TInt aDelay, TInt aCount)

	{

	iCount=0;

	TInt r=iLdd.StartNShotDelay(iStatus,iId,aPeriod,aDelay,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();

	User::WaitForRequest(iLongStatus);

	Start();

	}

void CBackgroundTimer::DoCancel()

	{

	iShort.Cancel();

	iLong.Cancel();

	User::WaitForRequest(iLongStatus);

	}

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 ChangeOffset(TAny*)

	{

	User::SetUTCOffset(3600);

	User::SetUTCOffset(0);

	return 1;	// so we run again

	}

TInt ChangeTime(TAny*)

	{

	TTime now;

	now.UniversalTime();

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

	User::SetUTCTime(now);

	return 1;	// so we run again

	}

TInt ChangeTimeThread(TAny*)

	{

	FOREVER

		{

		User::AfterHighRes(3000);

		TTime now;

		now.UniversalTime();

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

		User::AfterHighRes(1000);

		User::SetUTCTime(now);

		}

	}

GLDEF_C TInt E32Main()

//

// Test tick-based timers

//

    {

//	test.SetLogged(EFalse);

	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("Periodics with changing home time offset"));

	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);

	Idler->Start(TCallBack(ChangeOffset,NULL));

	ActiveCount=8;

	ErrorCount=0;

	CActiveScheduler::Start();

	Idler->Cancel();

	PrintInfo();

	test.Next(_L("Periodics with changing system time"));

	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);

	Idler->Start(TCallBack(ChangeTime,NULL));

	ActiveCount=8;

	ErrorCount=0;

	CActiveScheduler::Start();

	Idler->Cancel();

	PrintInfo();

	test.Next(_L("Periodics with changing system time in second thread"));

	RThread t;

	r=t.Create(KNullDesC(),ChangeTimeThread,0x1000,NULL,NULL);

	CHECK(r);

	t.SetPriority(EPriorityMore);

	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);

	Idler->Start(TCallBack(ChangeTime,NULL));

	ActiveCount=8;

	ErrorCount=0;

	t.Resume();

	CActiveScheduler::Start();

	Idler->Cancel();

	TRequestStatus s;

	t.Logon(s);

	t.Kill(0);

	User::WaitForRequest(s);

	test(t.ExitType()==EExitKill);

	test(t.ExitReason()==0);

	test(s==0);

	CLOSE_AND_WAIT(t);

	PrintInfo();

	test.Next(_L("Periodics with background timer"));

	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);

	BackgroundTimer->Start();

	ActiveCount=8;

	ErrorCount=0;

	CActiveScheduler::Start();

	BackgroundTimer->Cancel();

	PrintInfo();

	test.Next(_L("Periodics with changing system time and tick delay"));

	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]->StartNShotDelay(17,30,200);

	Idler->Start(TCallBack(ChangeTime,NULL));

	ActiveCount=8;

	ErrorCount=0;

	CActiveScheduler::Start();

	Idler->Cancel();

	PrintInfo();

	ticktest.Close();

	test.End();

	return(KErrNone);

    }