--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/system/t_tock.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,443 @@
+// 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);
+    }
+