/*

* 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 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: 

*

*/

#include "t_testrunner.h"

#include "t_testaction.h"

#include "t_output.h"

// CTestRunner /////////////////////////////////////////////////////////////////

EXPORT_C CTestRunner::CTestRunner(Output& aOut) :

    CActive(EPriorityNormal),

    iOut(aOut)

    {

	CActiveScheduler::Add(this);

    }

EXPORT_C CTestRunner::~CTestRunner()

    {

    Cancel();

    }

EXPORT_C TInt CTestRunner::PerformPrerequisiteL(CTestAction* aAction)

    {

    TInt err = KErrNone;

    while (!aAction->Finished() && aAction->iActionState == CTestAction::EPrerequisite)

        {

        err = RunAsyncMethodL(&CTestAction::PerformPrerequisite, aAction, err);

        }

    return err;

    }

EXPORT_C TInt CTestRunner::PerformActionL(CTestAction* aAction)

    {

    TInt err = KErrNone;

    while (!aAction->Finished() && aAction->iActionState == CTestAction::EAction)

        {

        err = RunAsyncMethodL(&CTestAction::PerformAction, aAction, err);

        }

    return err;

    }

EXPORT_C TInt CTestRunner::PerformPostrequisiteL(CTestAction* aAction, TInt aInitialStatus)

    {

    TInt err = aInitialStatus;

    while (!aAction->Finished() && aAction->iActionState == CTestAction::EPostrequisite)

        {

        err = RunAsyncMethodL(&CTestAction::PerformPostrequisite, aAction, err);

        }

    return err;

    }

TInt CTestRunner::RunAsyncMethodL(TTestMethod aMethod, CTestAction* aAction, TInt aInitialStatus)

    {

    iStatus = aInitialStatus;

    TRAPD(err, (aAction->*aMethod)(iStatus));

    if (err != KErrNone)

        {

        iStatus = err;

        if (err != KErrNoMemory)

        	{

        	aAction->iActionState = CTestAction::EPostrequisite;

        	}

        }

    else

        {

        SetActive();

		RunSchedulerL();

        }

    return iStatus.Int();

    }

void CTestRunner::RunSchedulerL()

	{

	iSchedulerRunning = ETrue;

	CActiveScheduler::Start();

	}

TBool CTestRunner::StepScheduler()

	{

    User::WaitForAnyRequest();

	TInt err;

    if (!CActiveScheduler::Current()->RunIfReady(err, EPriorityNull)) 

        {

        User::Invariant(); 

        }

	return !IsActive();

	}

EXPORT_C void CTestRunner::RunL()

    {

	if (iSchedulerRunning)

		{

		iSchedulerRunning = EFalse;

		CActiveScheduler::Stop();    

		}

	}

EXPORT_C TInt CTestRunner::RunError(TInt /*aError*/)

    {

    return KErrGeneral; // RunL() can never leave

    }

EXPORT_C void CTestRunner::DoCancel()

    {

    }

// COOMTestRunnerBase ////////////////////////////////////////////////////////////////////

/// Max OOM fail count, to prevent runaway tests

const TInt KOOMFailLimit = 10000;

EXPORT_C COOMTestRunnerBase::COOMTestRunnerBase(Output& aOut) :

    CTestRunner(aOut)

    {

    }

EXPORT_C COOMTestRunnerBase::~COOMTestRunnerBase()

    {

    }

EXPORT_C TInt COOMTestRunnerBase::PerformActionL(CTestAction* aAction)

    {

    iOut.writeString(_L("Running OOM test..."));

    iOut.writeNewLine();            

    iOut.writeString(_L("Fail point:  Heap used:  Action state:  Status:"));

    iOut.writeNewLine();            

	StartOOMTestL();

    TInt allocStart = AllocCount();

	TInt failCount;

	TInt err = KErrNone;

	for (failCount = 1 ; failCount < KOOMFailLimit ; ++failCount)

        {

		IncHeapFailPoint();

        err = KErrNone;

        TInt actionState = 0;

        while (!aAction->Finished() && aAction->iActionState == CTestAction::EAction && err != KErrNoMemory)

            {

            ++actionState;

            err = RunAsyncMethodL(&CTestAction::PerformAction, aAction, err);            

            }

        TInt allocEnd = AllocCount();

		ResetHeapFail();

        TBuf<128> buffer;

        buffer.Format(_L("  %8d    %8d       %8d %8d"), failCount, allocEnd - allocStart, actionState, err);

        iOut.writeString(buffer);

        iOut.writeNewLine();

		if (err != KErrNoMemory || aAction->Finished() || aAction->iActionState != CTestAction::EAction)

            {

			// Test finished

			break;

            }

        aAction->AfterOOMFailure();

        aAction->Reset();

        aAction->ResetState();

        }

	EndOOMTestL();

	if (failCount == KOOMFailLimit)

		{

		// Runaway OOM test

		iOut.writeString(_L("OOM test failed to terminate"));

		iOut.writeNewLine();

		return KErrGeneral;

		}

	return err;

    }

// COOMTestRunner ////////////////////////////////////////////////////////////////////////

COOMTestRunner::COOMTestRunner(Output& aOut) :

    COOMTestRunnerBase(aOut)

    {

    }

COOMTestRunner::~COOMTestRunner()

    {

    }

void COOMTestRunner::StartOOMTestL()

	{

	iFailPoint = 0;

	}

void COOMTestRunner::IncHeapFailPoint()

	{

	++iFailPoint;

	__UHEAP_SETFAIL(RHeap::EDeterministic, iFailPoint);

	}

void COOMTestRunner::ResetHeapFail()

	{

	__UHEAP_RESET;        		

	}

TInt COOMTestRunner::AllocCount()

	{

	return User::CountAllocCells();

	}

void COOMTestRunner::EndOOMTestL()

	{

	}

// CCancelTestRunner /////////////////////////////////////////////////////////////////////

/// Max cancel step, to prevent runaway tests

const TInt KCancelStepLimit = 200;

CCancelTestRunner::CCancelTestRunner(Output& aOut) :

    CTestRunner(aOut)

    {

    }

CCancelTestRunner::~CCancelTestRunner()

    {

    }

/**

 * Run the async PerformAction method for a specified number of steps and then

 * cancel it.  This does the equivalent of RunAsyncMethod, but calling

 * PerformAction and cancelling it.

 */

TInt CCancelTestRunner::RunAndCancelPeformActionMethod(CTestAction* aAction, TInt aInitialStatus,

                                                       TInt aCancelStep, TInt& aStep)

    {

    iStatus = aInitialStatus;

    TRAPD(err, aAction->PerformAction(iStatus));

    if (err != KErrNone)

        {

        return err;

        }

    SetActive();

    // This is our equivalent of an active scheduler loop

	while (IsActive())

		{

		StepScheduler();

        // Check if we can cancel this step

        if (iStatus.Int() == KRequestPending)

			{

            ++aStep;

			// Check if this is the step we want to cancel

			if (aStep == aCancelStep)

				{

				// Cancel request

				aAction->PerformCancel();

				// Check request completed immediately

				if (iStatus.Int() == KRequestPending)

					{

					iOut.writeString(_L("Cancelled request not completed immediately!"));

					iOut.writeNewLine();

					iAbort = ETrue;

					}

				}

			}

		}

    return iAbort ? KErrGeneral : iStatus.Int();

    }

/**

 * Run the test action for a specified number of steps and then cancel it.

 */

TInt CCancelTestRunner::RunAndCancelTestAction(CTestAction* aAction, TInt aCancelStep)

    {

    TInt err = KErrNone;

	TInt step = 0;

    TInt actionState = 0;

    while (!iAbort && !aAction->Finished() && aAction->iActionState == CTestAction::EAction && err != KErrCancel)

        {

        ++actionState;

		err = RunAndCancelPeformActionMethod(aAction, err, aCancelStep, step);

        }

	TBuf<128> buffer;

	buffer.Format(_L(" %8d      %8d      %8d %8d"), aCancelStep, step, actionState, err);

	iOut.writeString(buffer);

	iOut.writeNewLine();

    return err;

    }

TInt CCancelTestRunner::PerformActionL(CTestAction* aAction)

    {

    iOut.writeString(_L("Running cancellation test..."));

    iOut.writeNewLine();            

    iOut.writeString(_L("Fail step:  Total steps:  Action state:  Status:"));

    iOut.writeNewLine();            

    iAbort = EFalse;

    for (TInt step = 1 ; step <= KCancelStepLimit ; ++step) 

        {

        TInt err = RunAndCancelTestAction(aAction, step);

        if (iAbort || aAction->Finished() || aAction->iActionState != CTestAction::EAction)	

			{

            return err;

			}

        aAction->Reset();

        }

    // Runaway cancel test

    iOut.writeString(_L("Cancel test failed to terminate"));

    iOut.writeNewLine();

    return KErrGeneral;

    }