/*

* Copyright (c) 2005-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:  

* Implementation of the following classes

* CTestServer

* n x  CTestSession Maps to RTestServ session)

* n x  CStepControl or CPersistentStepControl (Maps to RTestSession)

* CTestStep (1 to 1 mapping with parent)

* CTestServer

* Derives CServer

* Test servers derive from this and implement the CreateTestStep() pure virtual

* CTestSession

* Derives CSharableSession

* Implements the ServiceL() pure virtual and creates CStepControl object(s)

* when a test step is opened.

* Implements the MSessionNotify interface for callbacks from CStepControl when

* a test step completes.

* CStepControl

* Derives CActive

* Runs a test step instance in its own thread and heap

* CTestStep

* Derives CBase

* Test Servers derive test steps from this

*

*/

/**

 @file TestClient.cpp

*/

#include "testexecuteserverbase.h"

#include "testserver2.h"

#include "testexecuteserverutils.h"

#include "testexecuteclient.h"

#include <e32math.h>

#include <test/wrapperutilsplugin.h>

#include <test/tefutils.h>

const TUint KDefaultHeapSize = 0x100000;

//> @internalComponent

// see the impletation below.

void SytemWideErrToTefErr(TInt &aErr);

/**

 * Constructor

 */

EXPORT_C CTestServer::CTestServer() : CServer2(EPriorityStandard)

,	iSeed(0)

,	iSessionCount(0)

	{

	// Random seed for unique thread id's

	iSeed = (TInt)this;

	// Default is not to allow Server Logging

	iLoggerStarted = EFalse;

	}

/**

 * Destructor

 */

EXPORT_C CTestServer::~CTestServer()

	{

	if (iLoggerStarted)

		{

		// Shut down the Servers' logger instance.

		Logger().Close();

		}

	}

/**

 * @param aName - Reference to the Server name

 * StartL + initiate server logging

 * Servers can StartL themselves or call this to gain server logging.

 */

EXPORT_C void CTestServer::ConstructL(const TDesC& aName)

	 {

	 StartL(aName);

	 StartLoggerL();

	 iServerName = aName;

	 }

/**

 * Will extract the script logfile name from the temporary file 'LogFileName.txt'

 * (assuming no ScheduleTest compatible logging) and then opens a logging session

 * to that file. If ScheduleTest logging is in effect then we will open ScriptEngine.htm

 * instead as the file to log to.

 */	 

void CTestServer::StartLoggerL()

	{

	TDriveName defaultSysDrive(KTEFLegacySysDrive);

	RFs fileServer;

	TVersionName version(fileServer.Version().Name());

	RLibrary pluginLibrary;

	CWrapperUtilsPlugin* plugin = TEFUtils::WrapperPluginNew(pluginLibrary);

	if (plugin!=NULL)

		{

		TDriveUnit driveUnit(plugin->GetSystemDrive());

		defaultSysDrive.Copy(driveUnit.Name());

		delete plugin;

		pluginLibrary.Close();

		}

	CTestExecuteIniData* parseTestExecuteIni = NULL;

	TBuf<KMaxTestExecuteNameLength> resultFilePath;

	TBuf<KMaxTestExecuteNameLength> xmlFilePath;

	TInt logMode;

	TInt logLevel;

	TRAPD(err,parseTestExecuteIni = CTestExecuteIniData::NewL(defaultSysDrive));

	if (err == KErrNone)

		{

		CleanupStack::PushL(parseTestExecuteIni);

		parseTestExecuteIni->ExtractValuesFromIni();

		parseTestExecuteIni->GetKeyValueFromIni(KTEFHtmlKey, resultFilePath);

		parseTestExecuteIni->GetKeyValueFromIni(KTEFXmlKey, xmlFilePath);

		parseTestExecuteIni->GetKeyValueFromIni(KTEFLogMode, logMode);

		parseTestExecuteIni->GetKeyValueFromIni(KTEFLogSeverityKey, logLevel);

		}

	else

		{

		TBuf<KMaxTestExecuteNameLength> testExecuteLogPath(KTestExecuteLogPath);

		testExecuteLogPath.Replace(0, 2, defaultSysDrive);

		resultFilePath.Copy(testExecuteLogPath);

		xmlFilePath.Copy(testExecuteLogPath);

		logMode = TLoggerOptions(ELogHTMLOnly);

		logLevel = RFileFlogger::TLogSeverity(ESevrAll);

		}

	Logger().SetLoggerOptions(logMode);

	// Initialise a handle to the file logger

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

	RFs fS;

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

	CleanupClosePushL(fS);

	RFile file;

	TBuf<KMaxTestExecuteNameLength> xmlLogFile(xmlFilePath);

	TBuf<KMaxTestExecuteNameLength> logFile;

	TBuf<KMaxTestExecuteNameLength> logFileNameFile(resultFilePath);

	logFileNameFile.Append(KTestExecuteScheduleTestLogCompatibilityNameFile);

	if(file.Open(fS,logFileNameFile,EFileRead | EFileShareAny) != KErrNone)

		{

		// If LogFileName.txt is not present then we are using ScheduleTest

		// compliant logging, any logging issued by the server will therefore

		// go to ScriptEngine.htm

		_LIT(KScriptEngine,"ScriptEngine");

		logFile.Copy(KScriptEngine);

		}

	else

		{

		CleanupClosePushL(file);

		TBuf8<KMaxTestExecuteNameLength> logFile8;

		TInt fileSize;

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

		User::LeaveIfError(file.Read(logFile8,fileSize));

		logFile.Copy(logFile8);

		CleanupStack::Pop(&file);

		file.Close();

		}

	xmlLogFile.Append(logFile);

	_LIT(KXmlExtension,".xml");

	xmlLogFile.Append(KXmlExtension);

	_LIT(KHtmExtension,".htm");

	logFile.Append(KHtmExtension);

	TBuf<KMaxTestExecuteLogFilePath> logFilePath(resultFilePath);

	logFilePath.Append(logFile);

	CleanupStack::Pop(&fS);

	fS.Close();

	if (logMode == 0 || logMode == 2)

		{

		User::LeaveIfError(Logger().HtmlLogger().CreateLog(logFilePath,RTestExecuteLogServ::ELogModeAppend));

		Logger().HtmlLogger().SetLogLevel(TLogSeverity(logLevel));

		}

	if (logMode == 1 || logMode == 2)

		{

		User::LeaveIfError(Logger().XmlLogger().CreateLog(xmlLogFile,RFileFlogger::ELogModeAppend));

		Logger().XmlLogger().SetLogLevel(RFileFlogger::TLogSeverity(logLevel));

		}

	User::LeaveIfError( Logger().ShareAuto() );

	iLoggerStarted = ETrue;

	if (parseTestExecuteIni != NULL)

		{

		CleanupStack::PopAndDestroy(parseTestExecuteIni);

		}

	}

/**

 * Last one out switch off the lights

 * Stop the active sheduler and hence the server, if this is the last session

 */	 

void CTestServer::SessionClosed()

	{

	iSessionCount--;

	if (iSessionCount == 0)

		CActiveScheduler::Stop();

	}

/**

 * @param RMessage - RMessage for the session open

 * Secure version

 */

EXPORT_C CSession2* CTestServer::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMessage*/) const

	{

	CTestSession* session = new (ELeave) CTestSession();

	CONST_CAST(CTestServer*,this)->iSessionCount++;

	return session;

	}

/**

 * Constructor

 */

EXPORT_C CTestSession::CTestSession()

:	iPersistentStepControl(NULL)

,	iPersistentBlockControl(NULL)

,	iBlockArray(NULL)

	{

	}

/**

 * Destructor

 */

EXPORT_C CTestSession::~CTestSession()

	{

	if( iBlockArray )

		{

		delete iBlockArray;

		iBlockArray = NULL;

		}	

	CTestServer* p=(CTestServer*) Server();

	//delete the persistent step

	if(iPersistentStepControl)

		delete iPersistentStepControl;

	//delete the persistent block

	if(iPersistentBlockControl)

		delete iPersistentBlockControl;

	// Shuts Down the server if this is the last open session

	p->SessionClosed();

	}

/**

 * @param aMessage - Function and data for the session

 * Session was created by pure virtual CTestServer::NewSessionL()

 * Message Functions defined in TestExecuteClient.h

 * 

 * EOpenTestStep - Creates a new subsession

 * ERunTestStep - Executes the test step asynchronously

 * EAbortTestStep - Kill()'s the executing test step

 * ECloseTestStep - Free's the resource

 *

 * Secure and non-secure variants

 * There are two modes of operation:

 * Test step is opened with the shared data boolean set to FALSE:

 *		Create a new CStepControl instance and hence a new thread in its own heap

 *		Consecutive or Concurrent operation

 * Test step is opened with the shared data boolean set to TRUE:

 *		Create a CPersistentStepControl and keep reusing it, and its thread

 *		Consecutive operation only

 */

EXPORT_C void CTestSession::ServiceL(const RMessage2& aMessage)

	{

	switch(aMessage.Function())

		{

		case EOpenTestStep :

			{

			// Open the test step

			// Buffer size policed on the client side

			TBuf<KMaxTestStepNameLength> stepName;

			// Read the step name from the descriptor

			TBool sharedData;

			aMessage.ReadL(0,stepName);

			// Find out what mode we're working in

			sharedData = aMessage.Int1();

			// Both types derive from base class and implement pure virtuals

			CControlBase* stepControl = NULL;

			if(sharedData)

				{

				// Shared data mode

				// Create the instance if it doesn't exist

				if(!iPersistentStepControl)

					iPersistentStepControl = new (ELeave)CPersistentStepControl(*(CTestServer*)Server());

				stepControl = iPersistentStepControl;

				iPersistentStepControl->StepName() = stepName;

				}

			else

				{

				// Default operation. Create a new instance

				stepControl = new (ELeave)CStepControl(*(CTestServer*)Server(),stepName);

				}

			// We pass back the address of the CStepControl class which is passed to

			// us in all calls on the subsession in Message 3

			TPtrC8 stepRef(REINTERPRET_CAST(TUint8*,&stepControl),sizeof(TInt));

			aMessage.Write(3,stepRef);

			aMessage.Complete(KErrNone);

			}

			break;

		case EOpenTestBlock :

			{

			// Open the test block

			// Buffer size policed on the client side

			TBuf<KMaxTestExecuteNameLength> stepName;

			// Find out what mode we're working in

			TBool sharedData = aMessage.Int1();

			// Both types derive from base class and implement pure virtuals

			CBlockControlBase* blockControl = NULL;

			if(sharedData)

				{

				// Shared data mode

				// Create the instance if it doesn't exist

				if(!iPersistentBlockControl)

					iPersistentBlockControl = new (ELeave)CPersistentBlockControl(*(CTestServer*)Server());

				blockControl = iPersistentBlockControl;

				}

			else

				{

				// Default operation. Create a new instance

				blockControl = new (ELeave)CBlockControl(*(CTestServer*)Server());

				}

			// We pass back the address of the CStepControl class which is passed to

			// us in all calls on the subsession in Message 3

			TPtrC8 blockRef(REINTERPRET_CAST(TUint8*,&blockControl),sizeof(TInt));

			aMessage.Write(3,blockRef);

			aMessage.Complete(KErrNone);

			}

			break;

		case ERunTestStep :

			{

			// Execute the test step

			// Buffer size policed on client side

			// Message 0 contains the test step arguments

			// Message 1 contains a descriptor for the panic string, if the test step panics

			TBuf<KMaxTestExecuteCommandLength> stepArgs;

			aMessage.ReadL(0,stepArgs);

			// Get the address of our CStepControl object

			CStepControlBase* stepControl = REINTERPRET_CAST(CStepControlBase*,aMessage.Int3());

			// Kick off the test step

			// Message completed when the test step completes

			// StartL() is mode dependent pure virtual

			TRAPD(err,stepControl->StartL(aMessage, stepArgs));

			if(err)

				// Complete now if we can't start the test step

				// Client has possibly called run before waiting for last completion

				aMessage.Complete(err);

			}

			break;

		case ERunTestBlock :

			{

			// Execute the test step

			// Buffer size policed on client side

			// Message 0 contains the test step arguments

			// Message 1 contains a descriptor for the panic string, if the test step panics

			TBuf<KMaxTestExecuteCommandLength> blockArgs;

			aMessage.ReadL(0,blockArgs);

			// Get the test block of commands

			HBufC8*	itemArray = HBufC8::NewLC( aMessage.GetDesMaxLengthL(2) );

			TPtr8	itemArrayPtr( itemArray->Des() );

			aMessage.ReadL( 2, itemArrayPtr );

			// Get the address of our CStepControl object

			CBlockControlBase* blockControl = REINTERPRET_CAST(CBlockControlBase*,aMessage.Int3());

			// Kick off the test step

			// Message completed when the test step completes

			// StartL() is mode dependent pure virtual

			TRAPD(err,blockControl->StartL(aMessage, blockArgs, itemArrayPtr ));

			if(err)

				// Complete now if we can't start the test step

				// Client has possibly called run before waiting for last completion

				aMessage.Complete(err);

			CleanupStack::PopAndDestroy( itemArray );

			}

			break;

		case EAbortTestStep :

			{

			CControlBase* control = REINTERPRET_CAST(CControlBase*,aMessage.Int3());

			// Stop is mode dependent pure virtual

			control->Stop();

			// Complete synchronously

			aMessage.Complete(KErrNone);

			break;

			}

		case ECloseTestStep :

			{

			CControlBase* control = REINTERPRET_CAST(CControlBase*,aMessage.Int3());

			// Only delete if we are in non-shared data mode

			if(	control != iPersistentStepControl &&

				control != iPersistentBlockControl )

				{

				delete control;

				}

			aMessage.Complete(KErrNone);

			}

			break;

		default:

			break;

		}

	}

/**

 * @param aServer - Reference to the CTestServer base class

 * @param aStepName - The test step name

 * The Non-Shared data step control implementation

 */

CStepControl::CStepControl(CTestServer& aServer, const TDesC& aStepName) :

	CStepControlBase(aServer)

	{

	StepName() = aStepName;

	}

/**

 * Thread completion

 */

void CStepControl::RunL()

	{

	// Error value if set in the test step will be saved in the Message()

	if (Error() != KNull)

		{

		TBuf<KMaxTestExecuteNameLength> errorParam(KErrorEquals);

		errorParam.Append(Error());

		Message().Write(1,errorParam);

		}

	// If the thread panicked, pick up the panic string and return it to the client

	// Overwrites the error value previously saved in Message()

	if(WorkerThread().ExitType() == EExitPanic)

		{

		TBuf<KMaxTestExecuteNameLength> panicParam(KPanicEquals);

		panicParam.Append(WorkerThread().ExitCategory());

		Message().Write(1,panicParam);

		}

	if (WorkerThread().ExitType() == EExitPanic)

		{

		TInt err = WorkerThread().ExitReason();

		SytemWideErrToTefErr(err);

		Message().Complete(err);

		}

	else

		{

		if (iStatus.Int() == KErrAbort && TimedOut())

			{

			if (Server().LoggerStarted())

				{

				Server().ERR_PRINTF1(_L("TEST IS ABOUT TO ABORT DUE TO TEF TIMEOUT"));				

				}

			}

		// iStatus.Int() is the same as the thread ExitReason

		Message().Complete(iStatus.Int());

		}

	// Close thread handle

	WorkerThread().Close();

	}

/**

 * Destructor

 */

CStepControl::~CStepControl()

	{

	}

/**

 * Step Execution module which is wrapped within UHEAP macros to trap memory leaks during execution

 * @param aStepControl - Is a generic type of class T passed as template parameter. Either CStepControl/CWorkerControl

 * for normal execution mode and persistant thread mode for concurrent execution of steps respectively

 * @param aStep - Object derived from CTestStep class for execution of test steps both in normal mode and persistent mode

 */

template<class T>

void ThreadStepExecutionL(T* aStepControl, CTestStep* aStep)

	{

	TInt loop = 0;

	TBool simulateOOM = EFalse; //ShouldRunOOMTest();

	FOREVER

		{

		TInt errRun = KErrNone;

		// Call the CTestStep virtuals 

		aStep->doTestStepPreambleL();

		// count cells so we can know how many we leaked

		TInt cellsStart = User::CountAllocCells();

		if (simulateOOM)

			{

			__UHEAP_MARK;

			// set allocator to fail on the loop'th alloc

			aStep->SetHeapFailNext(loop);

			}

		aStepControl->TimedOut() = ETrue;

		TRAP(errRun, aStep->doTestStepL());

		if (errRun != KErrNone && !simulateOOM)

			{

			if (errRun == KErrAbort)

				{

				aStepControl->TimedOut() = EFalse;

				}

			aStep->doTestStepPostambleL();

			User::Leave(errRun);

			}

		TBool finishedCorrectly = EFalse;

		// cancel the alloc failures