sl@0: /*
sl@0: * Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: * All rights reserved.
sl@0: * This component and the accompanying materials are made available
sl@0: * under the terms of the License "Eclipse Public License v1.0"
sl@0: * which accompanies this distribution, and is available
sl@0: * at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: *
sl@0: * Initial Contributors:
sl@0: * Nokia Corporation - initial contribution.
sl@0: *
sl@0: * Contributors:
sl@0: *
sl@0: * Description: 
sl@0: *
sl@0: */
sl@0: 
sl@0: 
sl@0: #include "t_testrunner.h"
sl@0: #include "t_testaction.h"
sl@0: #include "t_output.h"
sl@0: 
sl@0: // CTestRunner /////////////////////////////////////////////////////////////////
sl@0: 
sl@0: EXPORT_C CTestRunner::CTestRunner(Output& aOut) :
sl@0:     CActive(EPriorityNormal),
sl@0:     iOut(aOut)
sl@0:     {
sl@0: 	CActiveScheduler::Add(this);
sl@0:     }
sl@0: 
sl@0: EXPORT_C CTestRunner::~CTestRunner()
sl@0:     {
sl@0:     Cancel();
sl@0:     }
sl@0: 
sl@0: EXPORT_C TInt CTestRunner::PerformPrerequisiteL(CTestAction* aAction)
sl@0:     {
sl@0:     TInt err = KErrNone;
sl@0:     while (!aAction->Finished() && aAction->iActionState == CTestAction::EPrerequisite)
sl@0:         {
sl@0:         err = RunAsyncMethodL(&CTestAction::PerformPrerequisite, aAction, err);
sl@0:         }
sl@0:     return err;
sl@0:     }
sl@0: 
sl@0: EXPORT_C TInt CTestRunner::PerformActionL(CTestAction* aAction)
sl@0:     {
sl@0:     TInt err = KErrNone;
sl@0:     while (!aAction->Finished() && aAction->iActionState == CTestAction::EAction)
sl@0:         {
sl@0:         err = RunAsyncMethodL(&CTestAction::PerformAction, aAction, err);
sl@0:         }
sl@0:     return err;
sl@0:     }
sl@0: 
sl@0: EXPORT_C TInt CTestRunner::PerformPostrequisiteL(CTestAction* aAction, TInt aInitialStatus)
sl@0:     {
sl@0:     TInt err = aInitialStatus;
sl@0:     while (!aAction->Finished() && aAction->iActionState == CTestAction::EPostrequisite)
sl@0:         {
sl@0:         err = RunAsyncMethodL(&CTestAction::PerformPostrequisite, aAction, err);
sl@0:         }
sl@0:     return err;
sl@0:     }
sl@0: 
sl@0: TInt CTestRunner::RunAsyncMethodL(TTestMethod aMethod, CTestAction* aAction, TInt aInitialStatus)
sl@0:     {
sl@0:     iStatus = aInitialStatus;
sl@0:     TRAPD(err, (aAction->*aMethod)(iStatus));
sl@0:     if (err != KErrNone)
sl@0:         {
sl@0:         iStatus = err;
sl@0:         if (err != KErrNoMemory)
sl@0:         	{
sl@0:         	aAction->iActionState = CTestAction::EPostrequisite;
sl@0:         	}
sl@0:         }
sl@0:     else
sl@0:         {
sl@0:         SetActive();
sl@0: 		RunSchedulerL();
sl@0:         }
sl@0: 
sl@0:     return iStatus.Int();
sl@0:     }
sl@0: 
sl@0: void CTestRunner::RunSchedulerL()
sl@0: 	{
sl@0: 	iSchedulerRunning = ETrue;
sl@0: 	CActiveScheduler::Start();
sl@0: 	}
sl@0: 
sl@0: TBool CTestRunner::StepScheduler()
sl@0: 	{
sl@0:     User::WaitForAnyRequest();
sl@0: 	TInt err;
sl@0:     if (!CActiveScheduler::Current()->RunIfReady(err, EPriorityNull)) 
sl@0:         {
sl@0:         User::Invariant(); 
sl@0:         }
sl@0: 	return !IsActive();
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CTestRunner::RunL()
sl@0:     {
sl@0: 	if (iSchedulerRunning)
sl@0: 		{
sl@0: 		iSchedulerRunning = EFalse;
sl@0: 		CActiveScheduler::Stop();    
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CTestRunner::RunError(TInt /*aError*/)
sl@0:     {
sl@0:     return KErrGeneral; // RunL() can never leave
sl@0:     }
sl@0: 
sl@0: EXPORT_C void CTestRunner::DoCancel()
sl@0:     {
sl@0:     }
sl@0: 
sl@0: // COOMTestRunnerBase ////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /// Max OOM fail count, to prevent runaway tests
sl@0: const TInt KOOMFailLimit = 10000;
sl@0: 
sl@0: EXPORT_C COOMTestRunnerBase::COOMTestRunnerBase(Output& aOut) :
sl@0:     CTestRunner(aOut)
sl@0:     {
sl@0:     }
sl@0: 
sl@0: EXPORT_C COOMTestRunnerBase::~COOMTestRunnerBase()
sl@0:     {
sl@0:     }
sl@0: 
sl@0: EXPORT_C TInt COOMTestRunnerBase::PerformActionL(CTestAction* aAction)
sl@0:     {
sl@0:     iOut.writeString(_L("Running OOM test..."));
sl@0:     iOut.writeNewLine();            
sl@0:     iOut.writeString(_L("Fail point:  Heap used:  Action state:  Status:"));
sl@0:     iOut.writeNewLine();            
sl@0: 
sl@0: 	StartOOMTestL();
sl@0: 	
sl@0:     TInt allocStart = AllocCount();
sl@0: 
sl@0: 	TInt failCount;
sl@0: 	TInt err = KErrNone;
sl@0: 	for (failCount = 1 ; failCount < KOOMFailLimit ; ++failCount)
sl@0:         {
sl@0: 		IncHeapFailPoint();
sl@0:         
sl@0:         err = KErrNone;
sl@0:         TInt actionState = 0;
sl@0:         while (!aAction->Finished() && aAction->iActionState == CTestAction::EAction && err != KErrNoMemory)
sl@0:             {
sl@0:             ++actionState;
sl@0:             err = RunAsyncMethodL(&CTestAction::PerformAction, aAction, err);            
sl@0:             }
sl@0: 
sl@0:         TInt allocEnd = AllocCount();
sl@0: 		ResetHeapFail();
sl@0: 
sl@0:         TBuf<128> buffer;
sl@0:         buffer.Format(_L("  %8d    %8d       %8d %8d"), failCount, allocEnd - allocStart, actionState, err);
sl@0:         iOut.writeString(buffer);
sl@0:         iOut.writeNewLine();
sl@0:         
sl@0: 		if (err != KErrNoMemory || aAction->Finished() || aAction->iActionState != CTestAction::EAction)
sl@0:             {
sl@0: 			// Test finished
sl@0: 			break;
sl@0:             }
sl@0: 
sl@0:         aAction->AfterOOMFailure();
sl@0:         aAction->Reset();
sl@0:         aAction->ResetState();
sl@0:         }
sl@0: 
sl@0: 	EndOOMTestL();
sl@0: 
sl@0: 	if (failCount == KOOMFailLimit)
sl@0: 		{
sl@0: 		// Runaway OOM test
sl@0: 		iOut.writeString(_L("OOM test failed to terminate"));
sl@0: 		iOut.writeNewLine();
sl@0: 		return KErrGeneral;
sl@0: 		}
sl@0: 
sl@0: 	return err;
sl@0:     }
sl@0: 
sl@0: // COOMTestRunner ////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: COOMTestRunner::COOMTestRunner(Output& aOut) :
sl@0:     COOMTestRunnerBase(aOut)
sl@0:     {
sl@0:     }
sl@0: 
sl@0: COOMTestRunner::~COOMTestRunner()
sl@0:     {
sl@0:     }
sl@0: 
sl@0: void COOMTestRunner::StartOOMTestL()
sl@0: 	{
sl@0: 	iFailPoint = 0;
sl@0: 	}
sl@0: 
sl@0: void COOMTestRunner::IncHeapFailPoint()
sl@0: 	{
sl@0: 	++iFailPoint;
sl@0: 	__UHEAP_SETFAIL(RHeap::EDeterministic, iFailPoint);
sl@0: 	}
sl@0: 
sl@0: void COOMTestRunner::ResetHeapFail()
sl@0: 	{
sl@0: 	__UHEAP_RESET;        		
sl@0: 	}
sl@0: 
sl@0: TInt COOMTestRunner::AllocCount()
sl@0: 	{
sl@0: 	return User::CountAllocCells();
sl@0: 	}
sl@0: 
sl@0: void COOMTestRunner::EndOOMTestL()
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: // CCancelTestRunner /////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /// Max cancel step, to prevent runaway tests
sl@0: const TInt KCancelStepLimit = 200;
sl@0: 
sl@0: CCancelTestRunner::CCancelTestRunner(Output& aOut) :
sl@0:     CTestRunner(aOut)
sl@0:     {
sl@0:     }
sl@0: 
sl@0: CCancelTestRunner::~CCancelTestRunner()
sl@0:     {
sl@0:     }
sl@0: 
sl@0: /**
sl@0:  * Run the async PerformAction method for a specified number of steps and then
sl@0:  * cancel it.  This does the equivalent of RunAsyncMethod, but calling
sl@0:  * PerformAction and cancelling it.
sl@0:  */
sl@0: TInt CCancelTestRunner::RunAndCancelPeformActionMethod(CTestAction* aAction, TInt aInitialStatus,
sl@0:                                                        TInt aCancelStep, TInt& aStep)
sl@0:     {
sl@0:     iStatus = aInitialStatus;
sl@0:     TRAPD(err, aAction->PerformAction(iStatus));
sl@0:     if (err != KErrNone)
sl@0:         {
sl@0:         return err;
sl@0:         }
sl@0: 
sl@0:     SetActive();
sl@0:     
sl@0:     // This is our equivalent of an active scheduler loop
sl@0: 	while (IsActive())
sl@0: 		{
sl@0: 		StepScheduler();
sl@0: 		
sl@0:         // Check if we can cancel this step
sl@0:         if (iStatus.Int() == KRequestPending)
sl@0: 			{
sl@0:             ++aStep;
sl@0: 			// Check if this is the step we want to cancel
sl@0: 			if (aStep == aCancelStep)
sl@0: 				{
sl@0: 				// Cancel request
sl@0: 				aAction->PerformCancel();
sl@0: 
sl@0: 				// Check request completed immediately
sl@0: 				if (iStatus.Int() == KRequestPending)
sl@0: 					{
sl@0: 					iOut.writeString(_L("Cancelled request not completed immediately!"));
sl@0: 					iOut.writeNewLine();
sl@0: 					iAbort = ETrue;
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0:     return iAbort ? KErrGeneral : iStatus.Int();
sl@0:     }
sl@0: 
sl@0: /**
sl@0:  * Run the test action for a specified number of steps and then cancel it.
sl@0:  */
sl@0: TInt CCancelTestRunner::RunAndCancelTestAction(CTestAction* aAction, TInt aCancelStep)
sl@0:     {
sl@0:     TInt err = KErrNone;
sl@0: 	TInt step = 0;
sl@0:     TInt actionState = 0;
sl@0:     while (!iAbort && !aAction->Finished() && aAction->iActionState == CTestAction::EAction && err != KErrCancel)
sl@0:         {
sl@0:         ++actionState;
sl@0: 		err = RunAndCancelPeformActionMethod(aAction, err, aCancelStep, step);
sl@0:         }
sl@0: 
sl@0: 	TBuf<128> buffer;
sl@0: 	buffer.Format(_L(" %8d      %8d      %8d %8d"), aCancelStep, step, actionState, err);
sl@0: 	iOut.writeString(buffer);
sl@0: 	iOut.writeNewLine();
sl@0: 
sl@0:     return err;
sl@0:     }
sl@0: 
sl@0: TInt CCancelTestRunner::PerformActionL(CTestAction* aAction)
sl@0:     {
sl@0:     iOut.writeString(_L("Running cancellation test..."));
sl@0:     iOut.writeNewLine();            
sl@0:     iOut.writeString(_L("Fail step:  Total steps:  Action state:  Status:"));
sl@0:     iOut.writeNewLine();            
sl@0: 
sl@0:     iAbort = EFalse;
sl@0:     for (TInt step = 1 ; step <= KCancelStepLimit ; ++step) 
sl@0:         {
sl@0:         TInt err = RunAndCancelTestAction(aAction, step);
sl@0: 
sl@0:         if (iAbort || aAction->Finished() || aAction->iActionState != CTestAction::EAction)	
sl@0: 			{
sl@0:             return err;
sl@0: 			}
sl@0: 		
sl@0:         aAction->Reset();
sl@0:         }
sl@0:     
sl@0:     // Runaway cancel test
sl@0:     iOut.writeString(_L("Cancel test failed to terminate"));
sl@0:     iOut.writeNewLine();
sl@0:     return KErrGeneral;
sl@0:     }