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

 // Overview:

 // Test millisecond timers

 // API Information:

 // NTimer

 // Details:

 // - Create and start a number of periodic timers, verify results are

 // as expected.

 // - Attempt to start a timer that has already been started. Verify returned

 // error results.

 // - Start one shot interrupt and one shot DFC timers and verify that the 

 // delay time is correct.

 // - Start additional one shot interrupt timers with various values and verify

 // results are as expected.

 // - Calculate and print the elapsed time.

 // - Start some timers, display min. max, avg and count information on each.

 // Verify results are as expected.

 // - Cancel a periodic timer and reuse it in a variety of conditions. Time how

 // long it takes for each to complete.

 // - Perform some random timer tests and display the results.

 // - Check idle time while a variety of one shot timers run. Verify results are

 // within the expected range.

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32test.h>

 #include <e32uid.h>

 #include "d_mstim.h"

 RTest test(_L("T_MSTIM"));

 RMsTim mstim;

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

 #ifdef __WINS__

 #define TESTTIME(v,min,max) test.Printf(_L("Expected range [%d,%d]\n"),min,max+1)

 #else

 #define TESTTIME(v,min,max) TEST(v>=min && v<max)

 #endif

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

 void GetInfo(TInt aId)

 	{

 	SMsTimerInfo info;

 	TInt r=mstim.GetInfo(aId,info);

 	CHECK(r);

 	test.Printf(_L("%1d: min=%-6d max=%-6d avg=%-6d count=%d\n"),aId,info.iMin,info.iMax,info.iAvg,info.iCount);

 	}

 void GetAllInfo()

 	{

 	GetInfo(0);

 	GetInfo(1);

 	GetInfo(2);

 	GetInfo(3);

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

 	}

 TInt GetOneShotTime(TInt aId)

 	{

 	SMsTimerInfo info;

 	TInt r=mstim.GetInfo(aId,info);

 	CHECK(r);

 	TEST(info.iCount==1);

 	return info.iMin/1000;

 	}

 GLDEF_C TInt E32Main()

 //

 // Test millisecond timers

 //

     {

 //	test.SetLogged(EFalse);

 	test.Title();

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

 	TInt r=User::LoadLogicalDevice(KLddFileName);

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

 	r=mstim.Open();

 	CHECK(r);

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

 	TUint init_count=User::NTickCount();

 	r=mstim.StartPeriodicInt(0,31);

 	CHECK(r);

 	r=mstim.StartPeriodicInt(1,32);

 	CHECK(r);

 	r=mstim.StartPeriodicInt(4,7);

 	CHECK(r);

 	r=mstim.StartPeriodicInt(5,43);

 	CHECK(r);

 	r=mstim.StartPeriodicDfc(6,19);

 	CHECK(r);

 	r=mstim.StartPeriodicDfc(7,71);

 	CHECK(r);

 	test.Next(_L("Start while started"));

 	TRequestStatus s;

 	mstim.StartOneShotInt(s,0,100);

 	User::WaitForRequest(s);

 	TEST(s==KErrInUse);

 	test.Next(_L("One shot interrupt"));

 	mstim.StartOneShotInt(s,2,100);

 	User::WaitForRequest(s);

 	TUint fc1=User::NTickCount();

 	TEST(s==KErrNone);

 	TInt time=GetOneShotTime(2);

 	test.Printf(_L("Took %dms\n"),time);

 	TESTTIME(time,100,102);

 	test.Next(_L("One shot DFC"));

 	mstim.StartOneShotDfc(s,3,200);

 	User::WaitForRequest(s);

 	TUint fc3=User::NTickCount();

 	TEST(s==KErrNone);

 	time=GetOneShotTime(3);

 	test.Printf(_L("Took %dms\n"),time);

 	TESTTIME(time,200,202);

 	test.Next(_L("One shot interrupt again"));

 	TUint fc2=User::NTickCount();

 	mstim.StartOneShotIntAgain(s,2,300);

 	User::WaitForRequest(s);

 	TEST(s==KErrNone);

 	TInt time2=GetOneShotTime(2);

 	test.Printf(_L("Took %dms, delay %dms\n"),time2,fc2-fc1);

 	time2+=TInt(fc2-fc1);

 	TESTTIME(time2,295,306);

 	test.Next(_L("One shot interrupt again too late"));

 	mstim.StartOneShotIntAgain(s,3,10);

 	User::WaitForRequest(s);

 	TEST(s==KErrArgument);

 	test.Next(_L("One shot interrupt again"));

 	fc2=User::NTickCount();

 	mstim.StartOneShotIntAgain(s,3,300);

 	User::WaitForRequest(s);

 	TEST(s==KErrNone);

 	time=GetOneShotTime(3);

 	test.Printf(_L("Took %dms, delay %dms\n"),time,fc2-fc3);

 	time+=TInt(fc2-fc3);

 	TESTTIME(time,295,306);

 	test.Printf(_L("Please wait...\n"));

 	User::After(10000000);

 	SMsTimerInfo info[8];

 	TInt i;

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

 		{

 		r=mstim.GetInfo(i,info[i]);

 		CHECK(r);

 		}

 	TUint final_count=User::NTickCount();

 	TInt elapsed=TInt(final_count-init_count);

 	test.Printf(_L("Elapsed time %dms\n"),elapsed);

 	const TInt period[8]={31,32,0,0,7,43,19,71};

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

 		{

 		TInt p=period[i];

 		if (p==0)

 			continue;

 		SMsTimerInfo& z=info[i];

 		test.Printf(_L("%1d: min=%-6d max=%-6d avg=%-6d count=%d\n"),i,z.iMin,z.iMax,z.iAvg,z.iCount);

 		TInt count=elapsed/p;

 		TInt cdiff=count-z.iCount;

 		TEST(cdiff>=0 && cdiff<=2);

 #ifndef __WINS__

 		TEST(Abs(z.iMin-1000*p)<1000);

 		TEST(Abs(z.iMax-1000*p)<1000);

 #endif

 		TEST(Abs(z.iAvg-1000*p)<1000);

 		}

 	test.Next(_L("Cancel periodic"));

 	r=mstim.StopPeriodic(7);

 	CHECK(r);

 	r=mstim.GetInfo(7,info[7]);

 	CHECK(r);

 	User::After(1000000);

 	r=mstim.GetInfo(7,info[6]);

 	CHECK(r);

 	TEST(info[6].iCount==info[7].iCount);

 	test.Next(_L("Reuse cancelled"));

 	mstim.StartOneShotInt(s,7,128);

 	User::WaitForRequest(s);

 	TEST(s==KErrNone);

 	time=GetOneShotTime(7);

 	test.Printf(_L("Took %dms\n"),time);

 	TESTTIME(time,128,130);

 	TRequestStatus s2;

 	test.Next(_L("Timed Cancel"));

 	mstim.StartOneShotInt(s,2,128);

 	mstim.IntCancel(s2,2,130);

 	User::WaitForRequest(s);

 	TEST(s==KErrNone);

 	User::WaitForRequest(s2);

 	TEST(s2==KErrNone);

 	time=GetOneShotTime(2);

 	test.Printf(_L("Took %dms\n"),time);

 	TESTTIME(time,128,130);

 	time=GetOneShotTime(7);

 	test.Printf(_L("Cancel Took %dms\n"),time);

 	TESTTIME(time,130,132);

 	mstim.StartOneShotInt(s,2,128);

 	mstim.IntCancel(s2,2,126);

 	User::WaitForRequest(s);

 	TEST(s==KErrAbort);

 	User::WaitForRequest(s2);

 	TEST(s2==KErrNone);

 	time=GetOneShotTime(7);

 	test.Printf(_L("Cancel Took %dms\n"),time);

 	TESTTIME(time,126,128);

 	test.Next(_L("Reuse cancelled"));

 	mstim.StartOneShotInt(s,2,64);

 	User::WaitForRequest(s);

 	TEST(s==KErrNone);

 	time=GetOneShotTime(2);

 	test.Printf(_L("Took %dms\n"),time);

 	TESTTIME(time,64,66);

 #ifdef _DEBUG

 	test.Next(_L("Random test"));

 	r=mstim.BeginRandomTest();

 	CHECK(r);

 #endif

 	test.Printf(_L("Please wait...\n"));

 	User::After(10000000);

 #ifdef _DEBUG

 	r=mstim.EndRandomTest();

 	CHECK(r);

 	SRandomTestInfo rInfo;

 	r=mstim.GetRandomTestInfo(rInfo);

 	test.Printf(_L("min error = %d\n"),rInfo.iMin);

 	test.Printf(_L("max error = %d\n"),rInfo.iMax);

 	test.Printf(_L("xfer cancel = %d\n"),rInfo.iXferC);

 	test.Printf(_L("crit cancel = %d\n"),rInfo.iCritC);

 	test.Printf(_L("start fails = %d\n"),rInfo.iStartFail);

 	test.Printf(_L("debug calls = %d\n"),rInfo.iCallBacks);

 	test.Printf(_L("completions = %d\n"),rInfo.iCompletions);

 #endif

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

 		{

 		r=mstim.GetInfo(i,info[i]);

 		CHECK(r);

 		}

 	final_count=User::NTickCount();

 	elapsed=TInt(final_count-init_count);

 	test.Printf(_L("Elapsed time %dms\n"),elapsed);

 	const TInt period2[8]={31,32,0,0,7,43,19,0};

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

 		{

 		TInt p=period2[i];

 		if (p==0)

 			continue;

 		r=mstim.StopPeriodic(i);

 		CHECK(r);

 		SMsTimerInfo& z=info[i];

 		test.Printf(_L("%1d: min=%-6d max=%-6d avg=%-6d count=%d\n"),i,z.iMin,z.iMax,z.iAvg,z.iCount);

 		TInt count=elapsed/p;

 		TInt cdiff=count-z.iCount;

 		TEST(cdiff>=0 && cdiff<=2);

 #ifndef __WINS__

 		TEST(Abs(z.iMin-1000*p)<=1000);

 		TEST(Abs(z.iMax-1000*p)<=1000);

 #endif

 		TEST(Abs(z.iAvg-1000*p)<=1000);

 		}

 	test.Next(_L("Idle time"));

 	time=0;

 	TInt idle=0;

 	while (time<3000)

 		{

 		idle=mstim.GetIdleTime();

 		if (idle>=1000)

 			break;

 		if (idle<32)

 			idle=32;

 		User::AfterHighRes(idle*1000);

 		time+=idle;

 		}

 	if (time>=3000)

 		test.Printf(_L("Never got long enough idle time\n"));

 	else

 		{

 		mstim.StartOneShotInt(s,0,900);

 		TUint fc0=User::NTickCount();

 		User::AfterHighRes(20000);

 		idle=mstim.GetIdleTime();

 		test.Printf(_L("Idle time %dms\n"),idle);

 		TESTTIME(idle,860,881);

 		mstim.StartOneShotInt(s2,1,200);

 		fc1=User::NTickCount();

 		User::AfterHighRes(20000);

 		idle=mstim.GetIdleTime();

 		test.Printf(_L("Idle time %dms\n"),idle);

 		TESTTIME(idle,160,181);

 		TRequestStatus s3;

 		mstim.StartOneShotInt(s3,2,10);

 		idle=mstim.GetIdleTime();

 		test.Printf(_L("Idle time %dms\n"),idle);

 		TEST(idle==0);

 		User::WaitForRequest(s3);

 		fc2=User::NTickCount();

 		idle=mstim.GetIdleTime();

 		elapsed=fc2-fc1;

 		test.Printf(_L("Idle time %dms elapsed %dms\n"),idle,elapsed);

 		TESTTIME(idle,180-elapsed,201-elapsed);

 		User::WaitForRequest(s2);

 		fc2=User::NTickCount();

 		idle=mstim.GetIdleTime();

 		elapsed=fc2-fc0;

 		test.Printf(_L("Idle time %dms elapsed %dms\n"),idle,elapsed);

 		TESTTIME(idle,880-elapsed,900-elapsed);

 		User::WaitForRequest(s);

 		}

 	TUint fc4, fc5;

 	test.Next(_L("One shot int "));

 	mstim.StartOneShotInt(s,8,100);

 	User::WaitForRequest(s);

 	TEST(s==KErrNone);

 	time=GetOneShotTime(8);

 	test.Printf(_L("Took %dms\n"),time);

 	TESTTIME(time,100,102);

 	test.Next(_L("One shot int "));

 	mstim.StartOneShotInt(s,8,300);

 	User::WaitForRequest(s);

 	fc4=User::NTickCount();

 	TEST(s==KErrNone);

 	time=GetOneShotTime(8);

 	test.Printf(_L("Took %dms\n"),time);

 	TESTTIME(time,300,302);

 	test.Next(_L("One shot int again"));

 	fc5=User::NTickCount();

 	mstim.StartOneShotIntAgain(s,8,300);

 	User::WaitForRequest(s);

 	TEST(s==KErrNone);

 	time2=GetOneShotTime(8);

 	test.Printf(_L("Took %dms, delay %dms\n"),time2,fc5-fc4);

 	time2+=TInt(fc5-fc4);

 	TESTTIME(time2,295,306);

 	test.Next(_L("One shot with provided Dfc queue"));

 	mstim.StartOneShotUserDfc(s,8,100);

 	User::WaitForRequest(s);

 	TEST(s==KErrNone);

 	time=GetOneShotTime(8);

 	test.Printf(_L("Took %dms\n"),time);

 	TESTTIME(time,100,102);

 	test.Next(_L("One shot with provided Dfc queue"));

 	mstim.StartOneShotUserDfc(s,8,300);

 	User::WaitForRequest(s);

 	fc4=User::NTickCount();

 	TEST(s==KErrNone);

 	time=GetOneShotTime(8);

 	test.Printf(_L("Took %dms\n"),time);

 	TESTTIME(time,300,302);

 	test.Next(_L("One shot with provided Dfc queue again"));

 	fc5=User::NTickCount();

 	mstim.StartOneShotUserDfcAgain(s,8,300);

 	User::WaitForRequest(s);

 	TEST(s==KErrNone);

 	time2=GetOneShotTime(8);

 	test.Printf(_L("Took %dms, delay %dms\n"),time2,fc5-fc4);

 	time2+=TInt(fc5-fc4);

 	TESTTIME(time2,295,306);

 	test.End();

 	return(KErrNone);

     }