// Copyright (c) 2007-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:

 // @file testengine.cpp

 // @internalComponent

 // 

 //

 #include "TestEngine.h"

 #include "testdebug.h"

 #include "TestCaseController.h"

 #include "TestCaseFactory.h"

 // Console application options

 _LIT(KArgRole,"-role=");

 _LIT(KArgTestCases,"-cases=");

 _LIT(KArgTestRepeats,"-repeats=");

 // Role values 

 _LIT(KArgRoleHost,"host");

 _LIT(KArgRoleClient,"client");

 extern RTest gtest;

 namespace NUnitTesting_USBDI

 	{

 const TUint KDefaultNumRepeats = 1;

 const TUint KTestIdSize = 4;

 _LIT(KTestStringPreamble,"PBASE-T_USBDI-");

 CTestEngine* CTestEngine::NewL()

 	{

 	CTestEngine* self = new (ELeave) CTestEngine;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CTestEngine::CTestEngine()

 :	CActive(EPriorityUserInput),

 	iTestCaseIndex(0), iRepeat(0), iNumRepeats(KDefaultNumRepeats)

 	{

 	}

 CTestEngine::~CTestEngine()

 	{

 	// Cancel reading user console input

 	Cancel();

 	// Destroy the test case controller

 	delete iTestCaseController;

 	// Destroy the identity array and its contents

 	iTestCasesIdentities.ResetAndDestroy();

 	// Finish test and release resources

 	gtest.End();

 	gtest.Close();

 	}

 void CTestEngine::ConstructL()

 	{

 	LOG_FUNC

 	CActiveScheduler::Add(this);

 	// Display information (construction text and OS build version number

 	gtest.Title();

 	gtest.Start(_L("Test Engine Initiation"));

 	gtest.Printf(_L(">>\n"));

 	gtest.Printf(_L(">>   T E S T   R U N \n"));

 	gtest.Printf(_L(">>\n"));

 	// Process the command line option for role

 	TInt cmdLineLength(User::CommandLineLength());

 	HBufC* cmdLine = HBufC::NewMax(cmdLineLength);

 	CleanupStack::PushL(cmdLine);

 	TPtr cmdLinePtr = cmdLine->Des();

 	User::CommandLine(cmdLinePtr);

 	// be careful, command line length is limited(248 characters)	

 	gtest.Printf(_L("***cmdLine = %lS\n"), cmdLine);

 	TLex args(*cmdLine);

 	args.SkipSpace();

 	// Obtain the role of this test module

 	TPtrC roleToken = args.NextToken(); // e.g. -role=host

 	TBool hostFlag(ETrue);

 	TInt pos(roleToken.FindF(KArgRole));

 	if(pos != KErrNotFound)

 		{

 		pos = roleToken.FindF(_L("="));

 		TPtrC role = roleToken.Right(roleToken.Length()-pos-1);

 		if(role.Compare(KArgRoleHost) == 0)

 			{

 			hostFlag = ETrue;

 			}

 		else if(role.Compare(KArgRoleClient) == 0)

 			{

 			hostFlag = EFalse;

 			}

 		else

 			{

 			gtest.Printf(_L("Test configuration: could not find option -role\n"));

 			gtest(EFalse);

 			}

 		}

 	else

 		{

 		gtest.Printf(_L("Test configuration option not found: %S\n"),&KArgRole);

 		gtest(EFalse);

 		}

 	// Obtain the test cases to be run

 	TPtrC casesToken = args.NextToken();

 	pos = casesToken.FindF(KArgTestCases);

 	if(pos != KErrNotFound)

 		{

 		pos = casesToken.FindF(_L("="));

 		TPtrC testCases = casesToken.Right(casesToken.Length()-pos-1);

 		// Remaining test cases

 		TPtrC remCases(testCases);

 		while(pos != KErrNotFound)

 			{

 			pos = remCases.FindF(_L(","));

 			HBufC* tc = HBufC::NewLC(KTestCaseIdLength);

 			TPtr tcPtr = tc->Des();

 			tcPtr.Append(KTestStringPreamble);	

 			if(pos == KErrNotFound)

 				{

 				// This is the last test case identity			

 				tcPtr.Append(remCases);

 				}

 			else

 				{ 			

 				tcPtr.Append(remCases.Left(KTestIdSize));

 				}									

 			gtest.Printf(_L("Test case specified: %S\n"),tc);

 			iTestCasesIdentities.Append(tc);

 			CleanupStack::Pop(tc);

 			remCases.Set(testCases.Right(remCases.Length()-pos-1));

 			}

 		}

 	else

 		{

 		gtest.Printf(_L("Test configuration option not found: %S\n"),&KArgTestCases);

 		gtest(EFalse);		

 		}

 	// Obtain the role of this test module

 	TPtrC repeatsToken = args.NextToken(); // e.g. -repeats=4

 	pos = repeatsToken.FindF(KArgTestRepeats);

 	if(pos != KErrNotFound)

 		{

 		pos = repeatsToken.FindF(_L("="));

 		TPtrC repeats = repeatsToken.Right(repeatsToken.Length()-pos-1);

 		TLex lex(repeats);

 		TInt ret = lex.Val(iNumRepeats, EDecimal);

 		if(ret)

 			{

 			gtest.Printf(_L("Test configuration option not found: %S\n"),&KArgTestRepeats);

 			gtest.Printf(_L("DEFAULT to number of repeats = %d\n"),KDefaultNumRepeats);

 			iNumRepeats = KDefaultNumRepeats;

 			}

 		gtest.Printf(_L("Test repeats specified: %d cycles\n"),iNumRepeats);

 		}

 	else

 		{

 		gtest.Printf(_L("Test configuration option not found: %S\n"),&KArgTestRepeats);

 		gtest.Printf(_L("DEFAULT to number of repeats = %d\n"),KDefaultNumRepeats);

 		iNumRepeats = KDefaultNumRepeats;

 		}

 	// Create the test case controller

 	gtest.Printf(_L("Creating the test controller\n"));

 	iTestCaseController = CTestCaseController::NewL(*this,hostFlag);

 	CleanupStack::PopAndDestroy(cmdLine);

 	gtest.Console()->Read(iStatus);

 	SetActive();	

 	}

 TInt CTestEngine::NextTestCaseId(TDes& aTestCaseId)

 	{

 	LOG_FUNC

 	if(iTestCaseIndex < iTestCasesIdentities.Count())

 		{

 		aTestCaseId = *iTestCasesIdentities[iTestCaseIndex++];

 		if(iTestCaseIndex==iTestCasesIdentities.Count())

 			{

 			iRepeat++;

 			if(iRepeat < iNumRepeats)

 				{

 				iTestCaseIndex = 0; //prepare to start again

 				}

 			}

 		return KErrNone;

 		}

 	else

 		{

 		return KErrNotFound;

 		}

 	}

 RPointerArray<HBufC>& CTestEngine::TestCasesIdentities()

 	{

 	return iTestCasesIdentities;

 	}

 TUint CTestEngine::NumRepeats()

 	{

 	return iNumRepeats;

 	}

 void CTestEngine::DoCancel()

 	{

 	LOG_FUNC

 	gtest.Console()->ReadCancel();	

 	}

 void CTestEngine::RunL()

 	{

 	LOG_FUNC

 	TInt completionCode(iStatus.Int());

 	if(completionCode == KErrNone)

 		{

 		// Possibility of displaying a range of key commands

 		// then gtest.Console()->Getch()

 		TKeyCode keyCode(gtest.Console()->KeyCode());

 		if(keyCode == EKeySpace)

 			{

 			iTestCaseController->Cancel();

 			gtest.Printf(_L("Test module terminating\n"));

 			RDebug::Printf("CActiveScheduler::Stop CTestEngine::RunL");

 			CActiveScheduler::Stop();

 			}

 		else

 			{

 			gtest.Printf(_L("%d key pressed"),keyCode);

 			}

 		}

 	else

 		{

 		gtest.Printf(_L("Manual key error %d\n"),completionCode);

 		SetActive();

 		}

 	}

 TInt CTestEngine::RunError(TInt aError)

 	{

 	return KErrNone;

 	}

 	}