// Copyright (c) 2004-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 "DstStep.h"

// Type definitions

#define UNUSED_VAR(a) a = a

const TInt KErrTestFileHandle = -7400;

_LIT(KRunTestCount, "MaxRunLimit");

_LIT(KLeakTestCount, "MaxOOMLimit");

_LIT(KFirstLeakIter, "MinOOMLimit");

_LIT(KFileTestCount, "MaxOOFLimit");

_LIT(KCheckHandles, "CheckHandles");

_LIT(KNormalTestStarted, "Normal Test Started");

_LIT(KNormalTestComplete, "Normal Test Completed; Attempts: %d");

_LIT(KOOMTestStarted, "Out-of-Memory test started");

_LIT(KOOMTestTerminated, "Out-of-Memory test ended; Allocations made: %d");

_LIT(KOOFTestStarted, "Out-of-File-Handle Test Started");

_LIT(KOOFTestTerminated, "Out-of-File-Handle test ended; Handles used: %d");

_LIT(KOOFTestAborted, "Out-of-File-Handle Test Aborted; No File Session supplied.");

//

// CDSTActiveWorker

//

CDSTActiveWorker::~CDSTActiveWorker()

	{

	Deque();

	}

CDSTActiveWorker::CDSTActiveWorker(const CDstStep& aTestStep) : 

	CActive(CActive::EPriorityStandard), iTestStep(const_cast<CDstStep&>(aTestStep))

	{}

void CDSTActiveWorker::Start()

	{

	CompleteSelf();

	}

void CDSTActiveWorker::CompleteSelf()

	{

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status,KErrNone);

	}

CDSTActiveWorker* CDSTActiveWorker::NewL(const CDstStep& aTestStep)

	{

	CDSTActiveWorker* self = new(ELeave) CDSTActiveWorker(aTestStep);

	CActiveScheduler::Add(self);

	self->CompleteSelf();

	return self;

	}

void CDSTActiveWorker::RunL()

	{

	iTestStep.RunTest();

	}

void CDSTActiveWorker::DoCancel()

	{

	// do nothing

	}

TInt CDSTActiveWorker::RunError(TInt aError)

	{

	iTestStep.TestCompleted(aError);

	return KErrNone;

	}

//

// CDstStep

//

CDstStep::CDstStep() : 

	iState(ERunningNormalTest),

	iTestCmd(ECreateUnit),

	iMaxRunTestCount (1),				

	iMaxLeakTestCount (0),

	iFirstLeakIter (0),

	iMaxFileTestCount (0),

	iCheckHandles(EFalse)

	{

	}

CDstStep::~CDstStep()

	{

	delete iActiveWorker;

	delete iScheduler;

	}

void CDstStep::PrepareTestEnvironmentL()

	{

	// do nothing

	// sub-classes derive from this to load any script settings they require

	}

TVerdict CDstStep::doTestStepPreambleL()

	{

	iScheduler = new CActiveScheduler();

	CActiveScheduler::Install(iScheduler);

	GetIntFromConfig(ConfigSection(), KRunTestCount, iMaxRunTestCount);

	GetIntFromConfig(ConfigSection(), KLeakTestCount, iMaxLeakTestCount);

	GetIntFromConfig(ConfigSection(), KFirstLeakIter, iFirstLeakIter);

	GetIntFromConfig(ConfigSection(), KFileTestCount, iMaxFileTestCount);

	GetBoolFromConfig(ConfigSection(), KCheckHandles, iCheckHandles);

	// there must be at least a single normal run;

	if (iMaxRunTestCount <= 0) iMaxRunTestCount = 1;

	INFO_PRINTF1(KNormalTestStarted);

	PrepareTestEnvironmentL();

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CDstStep::doTestStepL()

	{

	if(TestStepResult() == EPass)

		{

		// the activeWorker is responsible for starting the actual test

		// from its RunL

		iActiveWorker = CDSTActiveWorker::NewL(*this);

		CActiveScheduler::Start();

		delete iActiveWorker;

		iActiveWorker = NULL;

		}

	return TestStepResult();

	}

TVerdict CDstStep::doTestStepPostambleL()

	{

	delete iScheduler;

	iScheduler=NULL;

	CActiveScheduler::Install(NULL);

	return TestStepResult();

	}

void CDstStep::SetFileSession(RFs& aFs)

	{

	if (ERunningFileTest == iState)

		{

		iFs = &aFs;

		// set handles to allow

		iFs->SetErrorCondition(KErrTestFileHandle, iTestCount);

		}

	}

void CDstStep::TestCompleted(TInt aCondition)

	{

	iTestCmd = EDestroyUnit;

	iTestCondition = aCondition;

	iFs = NULL;

	// Puts the test clean-up into our own active object RunL.

	// we don't want to delete the test unit in a call from its own RunL or

	// that of its delegates

	iActiveWorker->Start();

	}

TInt CDstStep::FinishTest()

	{

	TRAPD(error, DestroyTestUnit());

	UNUSED_VAR(error); //Used to supress build warnings

	++iTestCount;

	switch (iState)

		{

	case ERunningNormalTest:

		if (iTestCount == iMaxRunTestCount)

			{

			TInt endPHandleCount;

			TInt endTHandleCount;

			RThread().HandleCount(endPHandleCount, endTHandleCount);

			_LIT(KThreadHandleLeaks, "This test leaked %d thread handles");

			_LIT(KThreadHandlesLeakCheck, "Thread Handle Leak Check");

			// we cannot test process handles because other threads may be

			// running in the server

			if (endTHandleCount != iStartTHandleCount)

				{

				// TODO: check if EFF_PRINTF2 is better

				INFO_PRINTF2(KThreadHandleLeaks, endTHandleCount - iStartTHandleCount);

				}

			if (iCheckHandles)

				{

				LogCheck(KThreadHandlesLeakCheck(), 

					(endTHandleCount == iStartTHandleCount) ? KErrNone : KErrBadHandle);

				}

			INFO_PRINTF2(KNormalTestComplete, iTestCount);

			iTestCount = 0;

			if (iMaxLeakTestCount)

				{

				iState = ERunningLeakTest;

				INFO_PRINTF1(KOOMTestStarted);

				}

			else if (iMaxFileTestCount)

				{

				iState = ERunningFileTest;

				INFO_PRINTF1(KOOFTestStarted);

				}

			else

				{

				iState = EIdle;

				}

			}

		break;

	case ERunningLeakTest:

		__UHEAP_MARKEND;

		User::Heap().Check();

		__UHEAP_RESET;

		if ((iTestCondition != KErrNoMemory) || (iTestCount == iMaxLeakTestCount ))

			{

			INFO_PRINTF2(KOOMTestTerminated, iTestCount);

			iTestCount = 0;

			// TODO: save memory leak test result

			// out of memory test completed

			if (iMaxFileTestCount)

				{

				iState = ERunningFileTest;

				INFO_PRINTF1(KOOFTestStarted);

				}

			else

				{

				iState = EIdle;

				}

			}

		break;

	case ERunningFileTest:

		if (!iFs)

			{

			// no file session object was provided, stop the file test

			INFO_PRINTF1(KOOFTestAborted);

			iTestCount = 0;

			// TODO: save file handle leak test result

			iState = EIdle;

			// _LIT(KFileTestTerm, "Out Of File Handles test terminated: No file session provided");

			// Utils().LogIt(KFileTestTerm);

			}

		else

			{

			// clean-up file session handles restriction

			iFs->SetErrorCondition(KErrNone);

			if ((iTestCondition != KErrTestFileHandle) || (iTestCount == iMaxFileTestCount))

				{

				// out of file handle test completed

				INFO_PRINTF2(KOOFTestTerminated, iTestCount);

				iTestCount = 0;

				// TODO: save file handle leak test result

				iState = EIdle;

				}

			}

		break;

	default:

		break;

		}

	// prepare for the next test state

	iTestCmd = ECreateUnit;

	iActiveWorker->Start();

	return iTestCondition;

	}

TInt CDstStep::StartTest()

	{

	RThread().HandleCount(iStartPHandleCount, iStartTHandleCount);

	SetTestStepResult(EFail);

	TInt results = KErrNone;

	switch (iState)

		{

		case ERunningLeakTest:

			__UHEAP_MARK;

			__UHEAP_FAILNEXT(iTestCount);

		case ERunningFileTest:

		case ERunningNormalTest:

			TRAPD(error, results = CreateAndRunTestUnitL());

			if ((results != KRequestPending) || (error != KErrNone))

				{

				// TODO: if there is a leave; log a message to that effect

				// Test is Synchronous, or leave condition

				if (results == KErrNone)

					{

					results = error;

					}

				TestCompleted(results);

				}

			break;

		default:

			// stop the scheduler

			// All test states covered

			SetTestStepResult(((iTestCondition == KErrNone) && (iChecksFailed == 0)) ? EPass : EFail);

			CActiveScheduler::Stop();

			break;

		}

	return (results);

	}

TInt CDstStep::RunTest()

	{

	TInt results = KErrNone;

	switch (iTestCmd)

		{

		case ECreateUnit:

			results = StartTest();

			break;

		case EDestroyUnit:

			results = FinishTest();

			break;

		default:

			// stop the scheduler

			// something bad has happened

			// TODO: Panic

			SetTestStepResult(EFail);

			CActiveScheduler::Stop();

			break;

		}

	return (results);

	}

void CDstStep::LogCheck(const TDesC& aDescription, TInt aCondition)

	{

	// set the result for the temporary benefit of any dependent test step

	// it will be overwritten when the test completes

	if (aCondition == KErrNone)

		{

		SetTestStepResult(EPass);

		++iChecksPassed;

		}

	else

		{

		SetTestStepResult(EFail);

		++iChecksFailed;

		if (iState == ERunningNormalTest)

			{

			// only do the logging in normal test mode.

			// we don't want to use any resources that interferes with stress testing

			ERR_PRINTF3(_L("Check: %S: Error Code: %d"), &aDescription, aCondition);

			}

		}

	}

TTime CDstStep::ReadTimeParamStringL(const TDesC& aParamString)

	{

	// Format of buffer to construct a TTime is YYYYMMDD:HHMMSS (15 characters).

	// TTime uses zero-based values for month and day - which is confusing for scripting.

	// In our script, we use actual month and day numbers to make things simpler so we

	// must modify the string here to take account of this.

	TBuf<32> buf;

	TInt m, d;

	buf.Zero();

	buf.Copy(aParamString.Left(4));		// The year

	TLex lexMonth = aParamString.Mid(4, 2);

	lexMonth.Val(m);

	TLex lexDay = aParamString.Mid(6, 2);

	lexDay.Val(d);

	buf.AppendFormat(_L("%02d%02d"), m - 1, d - 1);	// The month and day

	buf.Append(aParamString.Right(7));

	return TTime(buf);

	}