/*

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

*

*/

#ifndef __T_TESTRUNNER_H__

#define __T_TESTRUNNER_H__

#include <e32base.h>

class Output;

class CTestAction;

/**

 * A class that is used to invoke individual tests.  This can be derived to

 * implement OOM testing, cancel testing and the like.  The default

 * implementation just runs the test.

 *

 * One instance of this class is used to run multiple tests.  A CTestHandler

 * owns an instance of this class (or a class derived from it).

 *

 * Note that this class provides a synchronous interface, which is implemented

 * in terms of CTestActions's asynchronous interface.

 */

class CTestRunner : public CActive

    {

 public:

    IMPORT_C CTestRunner(Output& aOut);

    IMPORT_C virtual ~CTestRunner();

    // The following methods return the status code from test action, but leave

    // if there is an error in the test handler.

    IMPORT_C virtual TInt PerformPrerequisiteL(CTestAction* aAction);

    IMPORT_C virtual TInt PerformActionL(CTestAction* aAction);

    IMPORT_C virtual TInt PerformPostrequisiteL(CTestAction* aAction, TInt aInitialStatus);

 protected:

    /// Typedef for any of CTestAction's async methods

    typedef void (CTestAction::*TTestMethod)(TRequestStatus&);

    /// Run one of CTestAction's async methods synchronously and return the result

    TInt RunAsyncMethodL(TTestMethod aMethod, CTestAction* aAction, TInt aInitialStatus);

	/// Run the active scheduler until our request is completed

	void RunSchedulerL();

	/// Run the active scheduler to process one outstanding request

	/// @return If our request has been completed yet

	TBool StepScheduler();

 protected:

    Output& iOut;

 private:

    IMPORT_C virtual TInt RunError(TInt aError);

    IMPORT_C virtual void DoCancel();

    IMPORT_C virtual void RunL();

 private:

    /// Whether an async method is currently being executed by the active scheduler

    TBool iSchedulerRunning;  

    };

/**

 * Abstract base class for a test runner that implements OOM testing.

 */

class COOMTestRunnerBase : public CTestRunner

    {

 public:

    IMPORT_C virtual ~COOMTestRunnerBase();

 protected:

    IMPORT_C COOMTestRunnerBase(Output& aOut);

	/// Called at the start of the OOM test

	virtual void StartOOMTestL() = 0;	

	/// Increment the simulated heap fail point

	virtual void IncHeapFailPoint() = 0;

	/// Reset simulated heap failures

	virtual void ResetHeapFail() = 0;

	/// Get the number of cells currently allocated

	virtual TInt AllocCount() = 0;

	/// Called at the end of the OOM test

	virtual void EndOOMTestL() = 0;

 private:

	// Override CTestRunner interface

    IMPORT_C virtual TInt PerformActionL(CTestAction* aAction);

    };

/**

 * Implementation of an test runner for OOM testing.

 */

class COOMTestRunner : public COOMTestRunnerBase

	{

 public:

	COOMTestRunner(Output& aOut);

	virtual ~COOMTestRunner();

 private:

	// Implement interface defined by COOMTestRunnerBase

	virtual void StartOOMTestL();	

	virtual void IncHeapFailPoint();

	virtual void ResetHeapFail();

	virtual TInt AllocCount();

	virtual void EndOOMTestL();

 private:

	TInt iFailPoint;

	};

/// A test runner that performs cancellation tests.

class CCancelTestRunner : public CTestRunner

    {

 public:

    CCancelTestRunner(Output& aOut);

    virtual ~CCancelTestRunner();

    virtual TInt PerformActionL(CTestAction* aAction);

 private:

    TInt RunAndCancelPeformActionMethod(CTestAction* aAction, TInt aInitialStatus,

                                        TInt aCancelStep, TInt& aStep);

    TInt RunAndCancelTestAction(CTestAction* aAction, TInt aCancelStep);

 private:

    TBool iAbort;         ///< Set when we want to abort the test

    };

#endif