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