// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "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:

 //

 #include "IpuTestUtils.h"

 #include <e32consf.h>

 //

 //	Constants

 _LIT(KTestPanic, "IpuTestHarness");

 const TInt KFailedTestsGranularity = 10;

 const TInt KMaxLogEntrySize = 256;

 //

 //	CIpuTestHarness

 //

 CIpuTestHarness::CIpuTestHarness(const TDesC& aTitle)

 	: iTest(aTitle)

 //

 //	Default c'tor

 	{

     LogRTestToFile(iTest);

 	iTest.Title();

 	iCanStartTest = ETrue;

 	}

 CIpuTestHarness::~CIpuTestHarness()

 //

 //	D'tor

 	{

 	TTime endtime;

 	endtime.UniversalTime();

 	// Do resource handle leak test?

 	if (iDoResourceLeakTest)

 		ResourceLeakTest();

 	//	End of tests - see if failed or ok

 	if (iFailedTests->Count())

 		{

 		TestHarnessFailed();

 		}

 	else

 		{

 		TestHarnessComplete();

 		}

 	iFailedTests->ResetAndDestroy();

 	delete iFailedTests;

 	//	Log finish time

 	TDateTime t = endtime.DateTime();

 	LogIt(_L("Ended @ %d:%d:%d:%d"),t.Hour(),t.Minute(),t.Second(),t.MicroSecond());

 	TTime difftime(endtime.Int64() - iStartTime.Int64());

 	t = difftime.DateTime();

 	LogIt(_L("Execution time %d:%d:%d:%d"),t.Hour(),t.Minute(),t.Second(),t.MicroSecond());

 	//	Close logs and test harness

 	iFlogger.CloseLog();

 	// iTest test harness performs UHEAP MARK/UNMARK check upon creation/destruction

 	//   therefore, it must be destroyed last since it is created first in 

 	//   CIpuTestHarness

 	iTest.Close();

 	}

 EXPORT_C CIpuTestHarness* CIpuTestHarness::NewLC(const TDesC& aTitle)

 //

 //	Static factory c'tor

 	{

 	CIpuTestHarness* self = new (ELeave) CIpuTestHarness(aTitle);

 	CleanupStack::PushL(self);

 	self->ConstructL(aTitle);

 	return self;

 	}

 EXPORT_C CIpuTestHarness* CIpuTestHarness::NewL(const TDesC& aTitle)

 //

 //	Static factiry c'tor

 	{

 	CIpuTestHarness* self = CIpuTestHarness::NewLC(aTitle);

 	CleanupStack::Pop();

 	return self;

 	}

 void CIpuTestHarness::ConstructL(const TDesC& aTitle)

 //

 //	Non-trivial c'tor

 	{

 	//	Create iFailedTests

 	iFailedTests = new (ELeave) CArrayPtrFlat<CTestInfo> (KFailedTestsGranularity);

 	//	Start up logging server connection

 	TBuf<64> temp(aTitle);

 	DefaultLogFileName(temp);

 	CreateFlogger(temp, EFalse, EFalse);

 	iStartTime.UniversalTime();

 	TDateTime t = iStartTime.DateTime();

 	LogIt(_L("Started @ %d:%d:%d:%d"),t.Hour(),t.Minute(),t.Second(),t.MicroSecond());

 	// Find number of open resource handles

 	TInt processHandleCount=0;

 	RThread().HandleCount(processHandleCount,iStartHandleCount);

 	}

 EXPORT_C void CIpuTestHarness::StartTestL(const TDesC& aName)

 //

 //	Logs start of test aName

 	{

 	if (iCanStartTest)

 		{

 		//  - increment test count

 		++iTestCount;

 		if (iTestMode == ETestModeNormal) // don't add this info when we are doing memory leak testing otherwise it

 										  // would get leaked!

 			{

 			//	Add this test to failed test list - set errorcode to zero

 			CTestInfo* temp = CTestInfo::NewLC(aName, iTestCount, 0);

 			iFailedTests->AppendL(temp);

 			CleanupStack::Pop();	//	temp

 			//	Stop new test being started until this one has ended

 			iTest.Start(aName);

 			iCanStartTest = EFalse;

 			}

 		TBuf<KMaxFileName + 4> buf;

 		buf.Format(KTestStartingWithDesc, iTestCount, &aName);

 		WriteComment(buf);

 		// Reset iStepNumber - start at 1

 		iStepNumber = 1;

 		}

 	else

 		{

 		//	Panic client - bad usage - not allowed to nest tests

 		Panic(EBadStartTest);

 		}

 	}

 EXPORT_C void CIpuTestHarness::NextStep(const TDesC& aStepName)

 //

 //	Logs the next step in a test - for informative use.

 	{

 	if (!iCanStartTest)

 		{

 		TBuf<KMaxFileName + 4> buf;

 		buf.Format(KNextTestStepWithDesc, iTestCount, iStepNumber, &aStepName);

 		WriteComment(buf);

 		iTest.Next(aStepName);

 		++iStepNumber;

 		}

 	else

 		{

 		//	Panic client - bad usage - test not started

 		Panic(EBadStartTest);

 		}

 	}

 EXPORT_C void CIpuTestHarness::EndTest(TInt aErrorCode)

 //

 //	Logs end of test

 	{

 	if (!iCanStartTest)

 		{

 		if (iTestMode == ETestModeNormal)

 			{

 			//	Get ptr to this test's entry in failed list - will be the last entry

 			TBuf<KMaxFileName + 4> buf;

 			TInt index = iFailedTests->Count();

 			CTestInfo* ptr = iFailedTests->At(--index);

 			if (aErrorCode)

 				{

 				//	Set the error code

 				ptr->SetErrorCode(aErrorCode);

 				buf.Format(KTestFailed, iTestCount, aErrorCode);

 				WriteComment(buf);

 				}

 			else

 				{

 				//	Remove entry from list of failed tests

 				delete ptr;

 				iFailedTests->Delete(index);

 				}

 			}

 		//	Allow new test to start

 		iTest.End();

 		iCanStartTest = ETrue;

 		}

 	else

 		{

 		if (iTestMode == ETestModeNormal)

 			//	Panic client - bad usage - test not started

 			Panic(EBadEndTest);

 		// don't panic when we are memory leak testing as EndTestL will never get called to reset the test properly

 		}

 	}

 EXPORT_C void CIpuTestHarness::LogIt(TRefByValue<const TDesC> aFmt, ...)

 //

 //	Messages to the front end emulator and to the Inu log

 	{

 	VA_LIST list;

 	VA_START(list,aFmt);

 	TBuf<KMaxFileName + 4> buf;

 	buf.Append(KTestCommentPrepend);

 	buf.AppendFormatList(aFmt,list);

 	VA_END(list);

 	WriteComment(buf);

 	}

 EXPORT_C void CIpuTestHarness::operator()(TInt aResult,TInt aLineNum)

 //

 //	Overload operator ()

 	{

 	iTest(aResult, aLineNum);

 	}

 EXPORT_C void CIpuTestHarness::operator()(TInt aResult)

 //

 //	Overload operator ()

 	{

 	iTest(aResult);

 	}

 EXPORT_C void CIpuTestHarness::PressAnyKey()

 //

 //	Request a key press from user and wait - unless we are running a script

 	{

 	if (!iScriptRunning)

 		{

 		iTest.Printf(TRefByValue<const TDesC>_L("\nPress a key"));	

 		iTest.Getch();

 		}

 	}

 EXPORT_C void CIpuTestHarness::DumpData(HBufC8& aData, TBool logIt)

 //

 //	Do a formatted dump of binary data, optionally logging it

 	{

 	// Iterate the supplied block of data in blocks of 16 bytes

 	TInt pos = 0;

 	TBuf<KMaxLogEntrySize> logLine;

 	TBuf<KMaxLogEntrySize> anEntry;

 	while (pos < aData.Length())

 		{

 		anEntry.Format(TRefByValue<const TDesC>_L("%04x : "), pos);

 		logLine.Append(anEntry);

 		// Hex output

 		TInt offset = 0;

 		for (offset = 0; offset < 16; offset++)

 			{

 			if (pos + offset < aData.Length())

 				{

 				TInt nextByte = aData[pos + offset];

 				anEntry.Format(TRefByValue<const TDesC>_L("%02x "), nextByte);

 				logLine.Append(anEntry);

 				}

 			else

 				{

 				anEntry.Format(TRefByValue<const TDesC>_L("   "));

 				logLine.Append(anEntry);

 				}

 			}

 			anEntry.Format(TRefByValue<const TDesC>_L(": "));

 			logLine.Append(anEntry);

 		// Char output

 		for (offset = 0; offset < 16; offset++)

 			{

 			if (pos + offset < aData.Length())

 				{

 				TInt nextByte = aData[pos + offset];

 				if ((nextByte >= 32) && (nextByte <= 127))

 					{

 					anEntry.Format(TRefByValue<const TDesC>_L("%c"), nextByte);

 					logLine.Append(anEntry);

 					}

 				else

 					{

 					anEntry.Format(TRefByValue<const TDesC>_L("."));

 					logLine.Append(anEntry);

 					}

 				}

 			else

 				{

 				anEntry.Format(TRefByValue<const TDesC>_L(" "));

 				logLine.Append(anEntry);

 				}

 			}

 			if (logIt)

 				{

 				LogIt(TRefByValue<const TDesC>_L("%S"), &logLine);

 				}

 			else

 				{

 				iTest.Printf(TRefByValue<const TDesC>_L("%S\n"), &logLine);	

 				}

 			logLine.Zero();

 		// Advance to next 16 byte segment

 		pos += 16;

 		}

 	}

 EXPORT_C void CIpuTestHarness::GetAnEntry(const TDesC& ourPrompt, TDes& currentstring)

 //

 //	Get an input string from the user, displaying a supplied prompt and default string value

 	{

 	// If we're scripting, try reading from script first

 	TInt readScriptErr = KErrNotFound;

 	if (iScriptRunning)

 		{

 		readScriptErr = ReadLineFromScript(currentstring);

 		}

 	if (!readScriptErr)

 		return;

 	// Either not scripting, or hit end of script - continue with user input

 	TBuf16<KMaxUserEntrySize> ourLine;

 	TBuf<KMaxUserEntrySize> tempstring;				//tempstring is a unicode descriptor

 										//create a temporary buffer where the

 										//unicode strings are stored in order to 

 										//be displayed

 	ourLine.Zero ();

 	tempstring.Copy(currentstring);		//Copy current string to Unicode buffer

 	TKeyCode key = EKeyNull;						//current string buffer is 8 bits wide.

 										//Unicode string bufffer (tempstring) is 16 bits wide.

 	for (;;)

 		{

 		if (ourLine.Length () == 0)

 			{

 			iTest.Console()->SetPos (0, iTest.Console()->WhereY ());

 			iTest.Console()->Printf (_L ("%S"), &ourPrompt);

 			if (tempstring.Length () != 0)						//get tempstring's number of items

 				iTest.Console()->Printf (_L (" = %S"), &tempstring);	//if not zero print them to iTest.Console()

 			iTest.Console()->Printf (_L (" : "));

 			iTest.Console()->ClearToEndOfLine ();

 			}

 		key = iTest.Getch();

 		  if (key == EKeyBackspace)

 				{

 					if (ourLine.Length() !=0)

 					{

 						ourLine.SetLength(ourLine.Length()-1);

 						iTest.Console()->Printf (_L ("%c"), key);

 						iTest.Console()->SetPos(iTest.Console()->WhereX(),iTest.Console()->WhereY());

 						iTest.Console()->ClearToEndOfLine();

 					}	// end if (ourLine.Length() !=0)

 				}	// end if (key == KeyBackSpace)

 		  if (key == EKeyDelete) 			

 				{

 					ourLine.Zero();

 					iTest.Console()->SetPos (0, iTest.Console()->WhereY ());

 					iTest.Console()->ClearToEndOfLine ();

 					tempstring.Copy(ourLine);

 					break;

 				}

 		  if (key == EKeyEnter)

 			break;

 		  if (key < 32)

 			{

 			continue;

 			}

 		ourLine.Append (key);

 		iTest.Console()->Printf (_L ("%c"), key);

 		iTest.Console()->SetPos(iTest.Console()->WhereX(),iTest.Console()->WhereY());

 		iTest.Console()->ClearToEndOfLine();

 		if (ourLine.Length () == ourLine.MaxLength ())

 			break;

 		}	// end of for statement

 	if ((key == EKeyEnter) && (ourLine.Length () == 0))

 		tempstring.Copy (currentstring);				//copy contents of 8 bit "ourLine" descriptor

 	iTest.Console()->SetPos (0, iTest.Console()->WhereY ());		

 	iTest.Console()->ClearToEndOfLine ();

 	iTest.Console()->Printf (_L ("%S"), &ourPrompt);

 	if ((key == EKeyEnter) && (ourLine.Length() !=0))

 		tempstring.Copy(ourLine);

 	if (tempstring.Length () != 0)						//if temstring length is not zero

 		{

 		iTest.Console()->Printf (_L (" = %S\n"), &tempstring);	//print the contents to iTest.Console()

 		LogIt(_L ("%S = %S\n"), &ourPrompt, &tempstring);

 		}

 	else

 		//iTest.Console()->Printf (_L (" is empty"));

 	iTest.Console()->Printf (_L ("\n"));

 	currentstring.Copy(tempstring);						//copy 16 bit tempstring descriptor back 

 	}

 EXPORT_C TInt CIpuTestHarness::GetSelection(const TDesC& ourPrompt, const TDesC& validChoices)

 //

 //	Present the user with a list of options, and get their selection

 	{

 	// If we're scripting, try reading from script first

 	TInt readScriptErr = KErrNotFound;

 	if (iScriptRunning)

 		{

 		TBuf<1> oneCharBuf;

 		readScriptErr = ReadLineFromScript(oneCharBuf);

 		if (!readScriptErr)

 			{

 			return validChoices.Locate((TChar)oneCharBuf[0]);

 			}

 		}

 	// Either not scripting, or hit end of script - continue with user input

 	TKeyCode key = EKeyNull;

 	iTest.Console()->SetPos (0, iTest.Console()->WhereY ());

 	iTest.Console()->Printf(_L("%S "), &ourPrompt);

 	iTest.Console()->Printf(_L("[%S] :"), &validChoices);

 	TInt retVal = KErrNotFound;

 	while (retVal == KErrNotFound)

 		{

 		key = iTest.Getch();

 		// Check that key is in the list of valid choices

 		retVal = validChoices.Locate((TChar)key);

 		}

 	iTest.Console()->Printf(_L("%c\n\n"), key);

 	return retVal;

 	}

 EXPORT_C void CIpuTestHarness::SetScript(RFile& scriptFile)

 //

 //	Sets the file to be used for a test script - ie. a file that contains commands used by

 //  GetEntry() and GetSelection()

 	{

 	iScriptFile = &scriptFile;

 	iScriptRunning = ETrue;

 	LogIt(_L("***SCRIPT STARTING***\n"));

 	}

 TInt CIpuTestHarness::ReadLineFromScript(TDes& aBuffer)

 //

 // Reads the next line from the script file, and sets the passed-in descriptor with its contents.

 // Returns KErrNone if reading succeeded; KErrNotFound if the EOF was reached. When EOF is reached,

 // the file is closed.

 	{

 	// *********************************

 	// Assume script is 8-bit text file

 	// *********************************

 	TBool isAComment = ETrue;

 	TInt err = KErrNone;

 	TBuf<512> line;

 	while (isAComment && !err)

 		{

 		TFileText text;

 		text.Set(*iScriptFile);

 		line.SetLength(0);

 		for(;;)

 			{

 			TBuf8<2> c;

 			err = iScriptFile->Read(c,1);

 			if (err && err != KErrEof)

 				{

 				iTest.Printf(_L("Error reading file: %d\n"), err);

 				break;

 				}

 			if (c.Length() == 0)

 				{

 				err = KErrEof;

 				break;

 				}

 			else

 				{

 				if (c[0] == '\n') // break out if it is CR

 					break;

 				else if (c[0] != (TUint8)(0x0d)) // otherwise append the char, _unless_ it is a LF

 					line.Append(c[0]);

 				}

 			}

 		if (err == KErrNone && line.Locate('/') != 0) // comment (only works if it's the first character)

 			{

 			isAComment = EFalse;

 			}

 		}

 	// The line read is not a comment, or have hit end of file

 	if (!err)

 		{

 		// copy to passed in descriptor, but do not allow an overflow

 		aBuffer.Copy(line.Left(aBuffer.MaxLength()));

 		LogIt(_L("***SCRIPT : read command '%S' ***\n"), &aBuffer);

 		}

 	else

 		{

 		iScriptFile->Close();

 		err = KErrNotFound;

 		iScriptRunning = EFalse;

 		LogIt(_L("***SCRIPT ENDED***\n"));

 		}

 	return err;

 	}

 void CIpuTestHarness::Panic(TInt aPanic)

 //

 //	Panic the client program.

 	{

 	User::Panic(KTestPanic,aPanic);

 	}

 void CIpuTestHarness::TestHarnessComplete()

 //

 //	Test harness completed without failures

 	{

 	_LIT(KTestCompleteFormat, "Total Tests %d, Failed Tests %d");

 	TBuf<50> text;

 	text.AppendFormat(KTestCompleteFormat, iTestCount, iFailedTests->Count()); 

 	WriteComment(text);

 	WriteComment(KTestHarnessCompleted);

 	}

 void CIpuTestHarness::TestHarnessFailed()

 //

 //	Test harness has a failure - log information

 	{

 	TBuf<KMaxFileName + 4> buf;

 	buf.Format(KTestHarnessFailed, iFailedTests->Count());

 	WriteComment(buf);

 	//	Log fialed tests' information

 	for (TInt ii=0; ii<iFailedTests->Count(); ++ii)

 		{

 		CTestInfo* failed = iFailedTests->At(ii);

 		TPtrC name = failed->Name();

 		LogIt(KTestFailInfo, failed->Number(), &name, failed->ErrorCode());

 		}

 	}

 void CIpuTestHarness::ResourceLeakTest()

 //

 // Creates a new test that fails if any there are any leaked resource handles

 	{

 	// Start new test

 	_LIT(KResourceTestName, "Resource Handle Leak Test");

 	TRAPD(testError, StartTestL(KResourceTestName));

 	if(testError==KErrNone)

 		{

 		//	Find number of opened handles

 		TInt processHandleCount=0;

 		TInt threadHandleCount=0;

 		RThread().HandleCount(processHandleCount,threadHandleCount);

 		TInt openHandleCount = iStartHandleCount-threadHandleCount;

 		TInt err = KErrNone;

 		if ( openHandleCount !=0 )

 			{

 			err = KErrGeneral;

 			LogIt(_L("Number leaked handles is %D"), openHandleCount);

 			}

 		EndTest(err);

 		}

 	else

 		{

 		_LIT(KTxtResourceTestRunError, "Unable to complete Resource Leak Test, error: %d");

 		LogIt(KTxtResourceTestRunError, testError);

 		EndTest(testError);

 		}

 	}

 //

 //	CTestInfo

 //

 CIpuTestHarness::CTestInfo::CTestInfo()

 //

 //	Default c'tor

 	{

 	}

 CIpuTestHarness::CTestInfo::~CTestInfo()

 //

 //	D'tor

 	{

 	delete iName;

 	}

 CIpuTestHarness::CTestInfo* CIpuTestHarness::CTestInfo::NewLC(const TDesC& aName, TInt aNumber, TInt aErrorCode)

 //

 //	Static factory c'tor

 	{

 	CTestInfo* self = new (ELeave) CTestInfo();

 	CleanupStack::PushL(self);

 	self->ConstructL(aName, aNumber, aErrorCode);

 	return self;

 	}

 CIpuTestHarness::CTestInfo* CIpuTestHarness::CTestInfo::NewL(const TDesC& aName, TInt aNumber, TInt aErrorCode)

 //

 //	Static factory c'tor

 	{

 	CTestInfo* self = NewLC(aName, aNumber, aErrorCode);

 	CleanupStack::Pop();	//	self

 	return self;

 	}

 void CIpuTestHarness::CTestInfo::ConstructL(const TDesC& aName, TInt aNumber, TInt aErrorCode)

 //

 //	Non-trivial c'tor

 	{

 	iName = aName.AllocLC();

 	CleanupStack::Pop();	//	iName

 	iNumber = aNumber;

 	iErrorCode = aErrorCode;

 	}

 void CIpuTestHarness::CTestInfo::SetNameL(const TDesC& aName)

 //

 //	Sets iName

 	{

 	HBufC* temp = aName.AllocLC();

 	CleanupStack::Pop();	//	temp

 	delete iName;

 	iName = temp;

 	}

 void CIpuTestHarness::CTestInfo::SetNumber(TInt aNumber)

 //

 //	Sets iNumber

 	{

 	iNumber = aNumber;

 	}

 void CIpuTestHarness::CTestInfo::SetErrorCode(TInt aErrorCode)

 //

 //	Sets iErrorCode

 	{

 	iErrorCode = aErrorCode;

 	}