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

	}