diff -r 675a964f4eb5 -r 35751d3474b7 cryptomgmtlibs/securitytestfw/test/testhandler2/t_testrunner.cpp --- a/cryptomgmtlibs/securitytestfw/test/testhandler2/t_testrunner.cpp Tue Jul 21 01:04:32 2009 +0100 +++ b/cryptomgmtlibs/securitytestfw/test/testhandler2/t_testrunner.cpp Thu Sep 10 14:01:51 2009 +0300 @@ -1,336 +1,336 @@ -/* -* 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; - } +/* +* 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; + }