// Copyright (c) 2003-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 <fbs.h>

 #include "TestFrameworkRecog.h"

 #include "TestFrameworkMain.h"

 #ifdef __WINS__

 #include <windows.h>	// for ExitProcess

 #endif // __WINS__

 GLREF_C void StartupL();

 const TInt KThreadStackSize=0x2000;			//  8KB

 const TInt KThreadInitHeapSize=0x1000;		//  4KB

 const TInt KThreadMaxHeapSize=0x1000000;	// 16MB

 const TInt KThreadStartupDelay=30000000;	// 30 seconds

 const TInt KMaxLineLength=256;				// max length of config file line

 _LIT(KLitConfigFileName, "C:\\MM\\AutorunTests.cfg");

 //

 CTestFrameworkRecognizer::CTestFrameworkRecognizer()

 	: CApaDataRecognizerType(KUidTestFrameworkRecognizer, CApaDataRecognizerType::ENormal)

 	{

 	}

 CTestFrameworkRecognizer::~CTestFrameworkRecognizer()

 	{

 	delete iTestActive;

 	}

 //

 // CApaDataRecognizerType stuff...

 TUint CTestFrameworkRecognizer::PreferredBufSize()

 	{

 	return 0;

 	}

 TDataType CTestFrameworkRecognizer::SupportedDataTypeL(TInt /*aIndex*/) const

 	{

 	return TDataType();

 	}

 void CTestFrameworkRecognizer::DoRecognizeL(const TDesC& /*aName*/, const TDesC8& /*aBuffer*/)

 	{

 	}

 //

 // Entry point of recognizer

 EXPORT_C CApaDataRecognizerType* CreateRecognizer()

 	{

 	CTestFrameworkRecognizer* self = new CTestFrameworkRecognizer();

 	TRAPD(err, self->DoCreateL());

 	return self;

 	}

 void CTestFrameworkRecognizer::DoCreateL()

 	{

 	// Open the config file

 	LoadConfigFileL(KLitConfigFileName);

 	// If the RUN_SCRIPT command is present in the config file, run each test in a separate thread

 	if (iRunScript)

 		{

 		// Create active object waiting on thread death

 		iTestActive = new(ELeave) CTestFrameworkRecogActive(iTestScriptArray);	// Takes ownership of iTestScriptArray

 		// Create the first test thread

 		iTestActive->CreateNextTestThread();

 		}

 	}

 void CTestFrameworkRecognizer::LoadConfigFileL(const TDesC& aFileName)

 	{

 	RFs fs;

 	User::LeaveIfError(fs.Connect());

 	CleanupClosePushL(fs);

 	TEntry entry;

 	User::LeaveIfError(fs.Entry(aFileName, entry));

 	RFile file;

 	User::LeaveIfError(file.Open(fs, aFileName, EFileRead));

 	CleanupClosePushL(file);

 	TInt size;

 	User::LeaveIfError(file.Size(size));

 	TUint8* fileData = (TUint8*)User::AllocLC(size);

 	TPtr8 ptr(fileData, 0, size);

 	User::LeaveIfError(file.Read(ptr));

 	iTestScriptArray = new(ELeave) CTestScriptArray(4);

 	// Process the config file

 	TLex8 lex(ptr);

 	while (!lex.Eos())

 		{

 		// skip any spaces

 		while (lex.Peek() == ' ')

 			lex.Inc();

 		// mark the start of the line

 		lex.Mark();

 		// move to the next

 		while (!lex.Eos() && lex.Peek() != '\n')

 			lex.Inc();

 		// step over \n

 		if (lex.Peek() == '\n' )

 			lex.Inc();

 		// Process line

 		TPtrC8 linePtr = lex.MarkedToken();

 		ProcessLineL(linePtr);

 		}

 	CleanupStack::PopAndDestroy(fileData);

 	CleanupStack::PopAndDestroy(2);	// file, fs

 	}

 void CTestFrameworkRecognizer::ProcessLineL(const TDesC8& aLine)

 	{

 	ASSERT(aLine.Length() <= KMaxLineLength);

 	TBuf<KMaxLineLength> buf;

 	buf.Copy(aLine);

 	if (buf.Find(_L("//"))==0)

 		{

 		// ignore comments

 		}

 	else

 		{

 		// Get the script path and startup delay

 		TLex lex(buf);

 		if (!iRunScript)

 			{

 			if (lex.NextToken().Compare(_L("RUN_SCRIPT")) == 0)

 				iRunScript = ETrue;

 			}

 		else

 			{

 			// Parse the parameters

 			TTestScriptInfo info;

 			info.iScriptPath = lex.NextToken();

 			info.iThreadStartupDelay = 0;

 			TPtrC token(lex.NextToken());

 			while (token.Length())

 				{

 				if (token[0] == '-')

 					{

 					info.iParams.Append(token);

 					info.iParams.Append(' ');

 					}

 				else

 					{

 					// Assume this to be the startup delay

 					TLex tokenLex(token);

 					User::LeaveIfError(tokenLex.Val(info.iThreadStartupDelay));

 					if (info.iThreadStartupDelay < 0)

 						info.iThreadStartupDelay = 0;

 					}

 				token.Set(lex.NextToken());

 				}

 			// Add the script info

 			if (info.iScriptPath.Length())

 				iTestScriptArray->AppendL(info);

 			}

 		}

 	}

 //

 // CTestFrameworkRecogActive

 CTestFrameworkRecogActive::CTestFrameworkRecogActive(CTestScriptArray* aTestScriptArray)

 	: CActive(EPriorityStandard), iTestScriptArray(aTestScriptArray)

 	{

 	CActiveScheduler::Add(this);

 	iCurrentScript = -1;

 	}

 CTestFrameworkRecogActive::~CTestFrameworkRecogActive()

 	{

 	delete iTestScriptArray;

 	}

 TInt CTestFrameworkRecogActive::CreateNextTestThread()

 	{

 	// Create the next test in a separate thread

 	iCurrentScript++;

 	RThread thread;

 	TBuf<16> threadName;

 	threadName.Format(_L("TFR_THREAD_%d"), iCurrentScript);

 	TInt err = thread.Create(threadName, &StartTestThreadFn, KThreadStackSize,

 							 &User::Heap(), this);

 	if (err == KErrNone)

 		{

 		thread.Logon(iStatus);

 		thread.Resume();

 		SetActive();

 		}

 	return err;

 	}

 void CTestFrameworkRecogActive::DoCancel()

 	{

 	}

 void CTestFrameworkRecogActive::RunL()

 	{

 	// This will run when the thread created in CreateNextTestThreadL dies

 	//

 	TInt err = KErrNone;

 	if (iCurrentScript < (iTestScriptArray->Count() - 1))

 		{

 		err = CreateNextTestThread();

 		}

 	else

 		{

 		// Tests finished

 		delete iTestScriptArray;

 		iTestScriptArray = NULL;

 #ifdef __WINS__

 		// Cause the emulator to exit

 		ExitProcess(0);

 #endif // __WINS__

 		}

 	}

 TInt CTestFrameworkRecogActive::StartTestThreadFn(TAny* aPtr)

 	{

 	CTestFrameworkRecogActive* self = static_cast<CTestFrameworkRecogActive*>(aPtr);

 	TRAPD(err, self->DoStartTestThreadL());

 	return err;

 	}

 void CTestFrameworkRecogActive::DoStartTestThreadL()

 	{

 	// Create the thread and wait until it's finished

 	RThread thread;

 	TBuf<16> threadName;

 	threadName.Format(_L("TESTFRMRECOG_%d"), iCurrentScript);

 	TInt err = thread.Create(threadName, &ThreadFunc, KThreadStackSize,

 							 &User::Heap(), this);

 	if (err == KErrNone)

 		{

 		RSemaphore sem;

 		err = sem.CreateGlobal(KRecogSemaphoreName, 0);

 		if (err == KErrAlreadyExists)

 			err = sem.OpenGlobal(KRecogSemaphoreName);

 		if (err == KErrNone)

 			{

 			// Start the thread and wait for it to signal us that it's finished

 			thread.Resume();

 			sem.Wait();

 			}

 		}

 	User::LeaveIfError(err);

 	}

 TInt CTestFrameworkRecogActive::ThreadFunc(TAny* aPtr)

 	{

 	CTrapCleanup* cleanup = CTrapCleanup::New(); // get clean-up stack

 	CTestFrameworkRecogActive* self = static_cast<CTestFrameworkRecogActive*>(aPtr);

 	TRAPD(err, self->DoThreadFuncL());

 	delete cleanup; // destroy clean-up stack

 	return err;

 	}

 void CTestFrameworkRecogActive::DoThreadFuncL()

 	{

 	// Run the test script, using filename held in iScriptPath

 	CActiveScheduler* scheduler=new(ELeave) CActiveScheduler;

 	CleanupStack::PushL(scheduler);

 	CActiveScheduler::Install(scheduler);

 // Hurricane emulator only - start all services which we require to run tests.

 // Future enhancement :- add these startups to TestUtils

 #if defined(__WINS__)

 	#ifndef EXCLUDE_FOR_UNITTEST

 	FbsStartup();

 	#endif // EXCLUDE_FOR_UNITTEST

 #endif

 	// Get the current script

 	const TTestScriptInfo& script = iTestScriptArray->At(iCurrentScript);

 	// Delay for several seconds to allow vital bits of the emulator to start up (window server bits)

 	User::After(script.iThreadStartupDelay);

 	// Format the parameter to be passed to the test framework

 	TFileName args;

 	if (script.iParams.Length())

 		{

 		// Add the params

 		args.Append(script.iParams);

 		args.Append(' ');

 		}

 	args.Append(script.iScriptPath);

 	// Run the script

 	CTestFrameworkMain* tester = CTestFrameworkMain::NewLC();

 	tester->StartTestingL(args);

 	CleanupStack::PopAndDestroy(2, scheduler);	// tester, scheduler

 	}