--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/authenticationservices/authenticationserver/test/tAuthSvr/src/step_oom.cpp Tue Nov 24 09:06:03 2009 +0200
@@ -0,0 +1,861 @@
+/*
+* Copyright (c) 2008-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 "tAuthSvrStep.h"
+
+#include "authserver/authclient.h"
+#include "authserver/authmgrclient.h"
+#include "authrepository.h"
+#include <scs/cleanuputils.h>
+
+using namespace AuthServer;
+class CAuthOomActive : public CActive
+ {
+ public:
+ CAuthOomActive(RAuthMgrClient& aClient, CAuthExpression* aExpression,
+ TInt aFresh, TBool aClientSpecific, TBool aAuthViaAlias, const TDesC& aClientMessage, TBool aStop = ETrue) :
+ CActive(EPriorityNormal),
+ iClient(aClient),
+ iResult(EFail),
+ iRunCount(0),
+ iAe(aExpression),
+ iStop(aStop),
+ iFresh(aFresh),
+ iIdToStore(0),
+ iClientSpecific(aClientSpecific),
+ iAuthViaAlias(aAuthViaAlias),
+ iClientMessage(aClientMessage)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+ void doAuth()
+ {
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+ iRunCount = 0;
+ }
+ void DoCancel()
+ {
+ }
+
+ TInt RunError(TInt aError)
+ {
+ TRequestStatus* status = &iStatus;
+ if(iStatus.Int() == KErrNoMemory)
+ {
+ CActiveScheduler::Stop();
+ User::Leave(aError);
+
+ }
+ else if (iStatus == KRequestPending)
+ {
+ User::RequestComplete(status, aError);
+ CActiveScheduler::Stop();
+ User::Leave(aError);
+ }
+
+ CActiveScheduler::Stop();
+ if(aError == KErrNoMemory)
+ {
+ User::Leave(aError);
+ }
+ return KErrNone;
+ }
+
+ void RunL()
+ {
+ iErr = iStatus.Int();
+ TUid val = TUid::Uid(0);
+ switch (iRunCount)
+ {
+ case 0:
+ {
+ iId = 0;
+
+ TUid uid = TUid::Uid(0);
+
+
+ iClient.AuthenticateL(*iAe, iFresh, iClientSpecific, val, EFalse, iClientMessage, iId, iStatus);
+
+ SetActive();
+
+ break;
+ }
+
+ case 1:
+ if (0 != iId)
+ {
+ iIdToStore = iId->Id();
+ delete iId;
+ iId = NULL;
+ }
+
+ iResult = iStatus == KErrNone ? EPass : EFail;
+ iErr = iStatus.Int();
+ if(iErr == KErrNoMemory)
+ {
+ User::Leave(KErrNoMemory);
+ }
+ if (iStop)
+ {
+ CActiveScheduler::Stop();
+ }
+
+ break;
+
+ default:
+ iResult = EFail;
+
+ if (iStop)
+ {
+ CActiveScheduler::Stop();
+ }
+ }
+ ++iRunCount;
+ }
+
+ ~CAuthOomActive()
+ {
+ if(iId != NULL)
+ delete iId;
+ }
+
+
+ RAuthMgrClient& iClient;
+ TVerdict iResult;
+ TInt iRunCount;
+ CAuthExpression* iAe;
+ CIdentity* iId;
+ TBool iStop;
+ TInt iErr;
+ TInt iFresh;
+ TIdentityId iIdToStore;
+ TBool iClientSpecific;
+ TBool iAuthViaAlias;
+ const TDesC& iClientMessage;
+ };
+
+class CRegOomActive : public CActive
+ {
+ public:
+ CRegOomActive(RAuthMgrClient& aClient, CIdentity*& aResult) :
+ CActive(EPriorityNormal),
+ iFirstTime(true),
+ iClient(aClient),
+ iResult(aResult),
+ iErr(KErrNone)
+ {
+ CActiveScheduler::Add(this);
+ }
+ void doReg()
+ {
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+ iFirstTime = ETrue;
+ }
+ void DoCancel()
+ {
+ }
+ void RunL()
+ {
+ iErr = iStatus.Int();
+ if (iFirstTime)
+ {
+ SetActive();
+ iStatus = KRequestPending;
+ iClient.RegisterIdentityL(iResult, _L("SOMENAME"), iStatus);
+ iFirstTime = false;
+ }
+ else
+ {
+ iErr = iStatus.Int();
+
+ if (iErr == KErrNoMemory)
+ {
+ User::Leave(KErrNoMemory);
+ }
+ CActiveScheduler::Stop();
+ }
+ }
+ TInt RunError(TInt error)
+ {
+
+ TRequestStatus* status = &iStatus;
+ if(iStatus.Int() == KErrNoMemory)
+ {
+ CActiveScheduler::Stop();
+ User::Leave(error);
+
+ }
+ else if (iStatus == KRequestPending)
+ {
+ User::RequestComplete(status, error);
+ CActiveScheduler::Stop();
+ User::Leave(error);
+ }
+
+ CActiveScheduler::Stop();
+ User::Leave(error);
+ return KErrNone;
+ }
+
+ ~CRegOomActive()
+ {
+ Cancel();
+ }
+
+ TBool iFirstTime;
+ RAuthMgrClient& iClient;
+ CIdentity*& iResult;
+ TInt iErr;
+ };
+
+class CTrainOomActive : public CActive
+ {
+ public:
+ CTrainOomActive(RAuthMgrClient& aClient, TPluginId plugin1IdValue, TIdentityId iIdFromFile, TBool aStop = ETrue) :
+ CActive(EPriorityNormal),
+ iClient(aClient),
+ iResult(EFail),
+ iRunCount(0),
+ iStop(aStop),
+ pluginIdVal(plugin1IdValue),
+ idToTrain (iIdFromFile)
+ {
+ CActiveScheduler::Add(this);
+ }
+ void doTrain()
+ {
+
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+ iRunCount = 0;
+ }
+ void DoCancel()
+ {
+ }
+ void RunL()
+ {
+ iErr = iStatus.Int();
+ if (iStatus.Int() != KErrNone)
+ {
+ }
+ switch (iRunCount)
+ {
+ case 0:
+ iStatus = KRequestPending;
+ iClient.TrainPlugin(idToTrain, pluginIdVal, iStatus);
+ SetActive();
+ break;
+
+ case 1:
+ iResult = iStatus.Int() == KErrNone ? EPass : EFail;
+ iErr = iStatus.Int();
+ if (iErr == KErrNoMemory)
+ {
+ User::Leave(KErrNoMemory);
+ }
+ if (iStop)
+ {
+ CActiveScheduler::Stop();
+ }
+
+ break;
+
+ default:
+ iResult = EFail;
+ if (iErr == KErrNoMemory)
+ {
+ User::Leave(KErrNoMemory);
+ }
+ if (iStop)
+ {
+ CActiveScheduler::Stop();
+ }
+ }
+ ++iRunCount;
+ }
+ TInt RunError(TInt error)
+ {
+
+ TRequestStatus* status = &iStatus;
+ if(iStatus.Int() == KErrNoMemory)
+ {
+ CActiveScheduler::Stop();
+ User::Leave(error);
+
+ }
+ else if (iStatus == KRequestPending)
+ {
+ User::RequestComplete(status, error);
+ CActiveScheduler::Stop();
+ User::Leave(error);
+ }
+
+ CActiveScheduler::Stop();
+ User::Leave(error);
+ return KErrNone;
+
+ }
+ RAuthMgrClient& iClient;
+ TVerdict iResult;
+ TInt iRunCount;
+ TBool iStop;
+ TInt iErr;
+ TPluginId pluginIdVal;
+ TIdentityId idToTrain;
+ };
+
+CAuthSvrOom::~CAuthSvrOom()
+/**
+ Destructor
+ */
+ {}
+
+CAuthSvrOom::CAuthSvrOom(CTAuthSvrServer& aParent): iParent(aParent)
+/**
+ Constructor
+ */
+ {
+
+ SetTestStepName(KTAuthServerOom);
+ }
+
+TVerdict CAuthSvrOom::doTestStepPreambleL()
+/**
+ @return - TVerdict code
+
+ */
+ {
+ CTStepActSch::doTestStepPreambleL();
+ CActiveScheduler::Install(iActSchd);
+ return TestStepResult();
+ }
+
+
+TVerdict CAuthSvrOom::doTestStepL()
+ {
+
+ //Client side/Server side OOM test or Performance test??
+
+ TInt testType(0);
+ GetIntFromConfig(ConfigSection(), _L("TestType"), testType);
+ ReadTestConfigurationL();
+ switch(testType)
+ {
+ case 1: doClientOOMTestL();
+ break;
+
+ case 2: doServerOOMTestL();
+ break;
+
+ case 3: doPerformanceTestL();
+ break;
+
+ default:
+ //Should not reach here !
+ break;
+ }
+
+ return TestStepResult();
+ }
+TVerdict CAuthSvrOom::doClientOOMTestL()
+/**
+ * Runs the test step under OOM Conditions checking that each heap allocation is fail safe
+ */
+ {
+ // Pre and Post test heap cell allocation counts
+ TInt cellCountAfter = 0;
+ TInt cellCountBefore = 0;
+
+ /**
+ * The loop tests each heap allocation under out of memory conditions to determine whether
+ * the framework cleans up correctly without leaking memory.
+ *
+ * The 'for' loop does not have any completion criteria, so the loop breaks out as soon
+ * as any of the following events occur:
+ * a) The pre and post heap cell counts mismatch signalling a memory leakage
+ * b) An unexpected leave (any leave with an error code other than 'KErrNoMemory')
+ * c) All heap allocations have been tested and the test returns 'KErrNone'
+ */
+ for (TInt testCount = 0; ; ++testCount)
+ {
+ __UHEAP_RESET;
+ __UHEAP_MARK;
+
+__UHEAP_SETFAIL(RHeap::EDeterministic, testCount+1);
+ cellCountBefore = User::CountAllocCells();
+ AuthServer::RAuthMgrClient authMgrClient;
+ CleanupClosePushL(authMgrClient);
+ authMgrClient.Connect();
+
+ TRAPD(err, doTestL(authMgrClient));
+ authMgrClient.ShutdownServer();
+ CleanupStack::PopAndDestroy(&authMgrClient);
+
+ cellCountAfter = User::CountAllocCells();
+ __UHEAP_MARKEND;
+
+
+ if (err == KErrNone)
+ {
+ INFO_PRINTF1(_L("Client OOM Test Finished"));
+ break;
+ }
+ else if(err == KErrNoMemory)
+ {
+
+ if (cellCountBefore != cellCountAfter)
+ {
+ ERR_PRINTF2(_L("OOM Test Result: Failed - Memory leakage on iteration %d"), testCount);
+ SetTestStepResult(EFail);
+ break;
+ }
+ else
+ {
+ INFO_PRINTF2(_L("OOM Pass %d"), testCount);
+ }
+ }
+ else
+ {
+ User::Leave(err);
+ break;
+ }
+ }
+
+
+ return TestStepResult();
+ }
+
+TVerdict CAuthSvrOom::doServerOOMTestL()
+ {
+
+ TInt err(0),err2(0);
+ AuthServer::RAuthMgrClient authMgrClient;
+ CleanupClosePushL(authMgrClient);
+ authMgrClient.Connect();
+ // Pre and Post test heap cell allocation counts
+ for (TInt testCount=0; ; ++testCount)
+ {
+
+ err = authMgrClient.SetServerHeapFail(testCount+1);
+ if(KErrNoMemory == err)
+ {
+ ERR_PRINTF1(_L("ReInitializing..."));
+ authMgrClient.ResetServerHeapFail();
+ continue;
+ }
+
+ TRAPD(retStepVal, doTestL(authMgrClient));
+ err2 = authMgrClient.ResetServerHeapFail();
+ if((err == KErrServerTerminated) || (err2 == KErrServerTerminated))
+ {
+ INFO_PRINTF1(_L("AuthServer Terminated"));
+ SetTestStepResult(EFail);
+ break;
+ }
+
+ if(KErrNone != err)
+ {
+ SetTestStepResult(EFail);
+ break;
+ }
+
+
+ if(KErrNoMemory == retStepVal)
+ {
+ INFO_PRINTF2(_L("OOM Pass %d"), testCount);
+ }
+ else if (KErrNone == retStepVal)
+ {
+ INFO_PRINTF1(_L("Server OOM Test Finished"));
+ break;
+ }
+ else
+ {
+ // Propagate all errors apart from KErrNoMemory
+ User::Leave(retStepVal);
+ }
+
+
+ }// for
+ CleanupStack::PopAndDestroy(&authMgrClient);
+ WaitForServerToReleaseDb();
+ return TestStepResult();
+ }
+
+
+TVerdict CAuthSvrOom::doTestL(AuthServer::RAuthMgrClient& ac)
+ {
+ TInt oomValue;
+ GetIntFromConfig(ConfigSection(), _L("OOMTest"), oomValue);
+
+ switch(oomValue)
+ {
+ case 1:
+
+ break;
+
+ case 2:
+ //Registration API check
+ doRegOOMTestL(ac);
+ break;
+
+ case 3:
+ //Synchronous Authenticate API check
+ doSyncAuthOOMTestL(ac);
+ break;
+
+ case 4:
+ //Asynchronous Authenticate API check
+ doAsyncAuthOOMTestL(ac);
+ break;
+
+ case 5:
+ //Set preffered plugin type check
+ doSetPreferredTypeL(ac);
+ break;
+
+ case 6:
+ //Check Remove Identity API
+ doRemoveIdentityL(ac);
+ break;
+ case 7:
+ //Check forget plugin API
+ doForgetPluginL(ac);
+ break;
+ case 8:
+ //Check Retrain Plugin API
+ doRetrainPluginL(ac);
+ break;
+ case 9:
+ //Check List PluginsL API
+ doListPluginsL(ac);
+ break;
+ case 10:
+ //Check List Active Plugins API
+ doListActivePluginsL(ac);
+ break;
+ case 11:
+ //Check List Plugins of type API
+ doListPluginsOfTypeL(ac);
+ break;
+ case 12:
+ //Check List Plugins With Training status API
+ doListPluginsWithTrainingStatusL(ac);
+ break;
+ case 13:
+ //Check List Authentication aliases API
+ doListAuthStrengthAliasesL(ac);
+ break;
+ case 14:
+ // Check the reset API (all plugins)
+ doResetAll(ac);
+ break;
+ case 15:
+ // Check the reset API (plugins of specified type)
+ doResetType(ac);
+ break;
+ case 16:
+ // Check the reset API (specified plugins)
+ doResetList(ac);
+ break;
+ default:
+ //Should never reach here
+ break;
+ }
+ return TestStepResult();
+ }
+
+void CAuthSvrOom::doStartupTestL()
+ {
+ RAuthClient r1;
+ CleanupClosePushL(r1);
+ r1.Connect();
+ CleanupStack::PopAndDestroy(&r1);
+ }
+
+void CAuthSvrOom::doRegOOMTestL(AuthServer::RAuthMgrClient &ac)
+ {
+
+ CIdentity* identity1 = 0;
+ CRegOomActive active(ac, identity1);
+ active.doReg();
+ CActiveScheduler::Start();
+ delete identity1;
+ }
+
+void CAuthSvrOom::doSyncAuthOOMTestL(AuthServer::RAuthMgrClient &ac)
+ {
+ TUid val = TUid::Uid(0);
+ CIdentity* id = 0;
+ CAuthExpression* expr = CreateAuthExprLC(iExprString);
+ id = ac.AuthenticateL(*expr, iFreshnessVal, iClientSpecificKeyVal, val, EFalse, iMessage);
+
+ delete id;
+ id = 0;
+ CleanupStack::PopAndDestroy(expr);
+ }
+
+void CAuthSvrOom::doAsyncAuthOOMTestL(AuthServer::RAuthMgrClient &ac)
+ {
+ CAuthExpression* expr = ac.CreateAuthExpressionL(iExprString);
+ CleanupStack::PushL(expr);
+
+ CAuthOomActive active(ac, expr, iFreshnessVal, iClientSpecificKeyVal, EFalse, iMessage);
+ active.doAuth();
+ CActiveScheduler::Start();
+
+ if(expr)
+ {
+ CleanupStack::PopAndDestroy(expr);
+ }
+ }
+
+void CAuthSvrOom::doSetPreferredTypeL(AuthServer::RAuthMgrClient &ac)
+ {
+ TInt plugin(0);
+ GetHexFromConfig(ConfigSection(),KKnowledgePrefsTag, plugin);
+ TPluginId id = plugin;
+ ac.SetPreferredTypePluginL(EAuthKnowledge, id);
+ }
+
+void CAuthSvrOom::doRemoveIdentityL(AuthServer::RAuthMgrClient &ac)
+ {
+ TInt plugin1IdValue = 0;
+ GetHexFromConfig(ConfigSection(),_L("plugin1Id"), plugin1IdValue);
+
+ //Read the identityId to be removed
+ TIdentityId idToRemove = getLastAuthId();
+ ac.RemoveIdentityL(idToRemove);
+ }
+
+void CAuthSvrOom::doForgetPluginL(AuthServer::RAuthMgrClient &ac)
+ {
+ TInt plugin1IdValue = 0;
+ GetHexFromConfig(ConfigSection(),_L("plugin1Id"), plugin1IdValue);
+
+ //Read the identityId to be forgotten
+ TIdentityId idToForget = getLastAuthId();
+ ac.ForgetPluginL( idToForget , plugin1IdValue);
+ }
+
+void CAuthSvrOom::doRetrainPluginL(AuthServer::RAuthMgrClient &ac)
+ {
+ TInt plugin1IdValue = 0;
+ GetHexFromConfig(ConfigSection(),_L("plugin1Id"), plugin1IdValue);
+
+ TIdentityId idToTrain = getLastAuthId();
+ //Train the plugin again with this identity.
+ CTrainOomActive active(ac, plugin1IdValue, idToTrain);
+ active.doTrain();
+ CActiveScheduler::Start();
+ }
+
+void CAuthSvrOom::doListPluginsL(AuthServer::RAuthMgrClient &ac)
+ {
+ RPluginDescriptions pluginList1;
+ TCleanupItem cleanup(CleanupEComArray, &pluginList1);
+ CleanupStack::PushL(cleanup);
+ ac.PluginsL(pluginList1);
+ CleanupStack::PopAndDestroy(&pluginList1);
+
+ }
+
+void CAuthSvrOom::doListActivePluginsL(AuthServer::RAuthMgrClient &ac)
+ {
+ RPluginDescriptions pluginList1;
+ TCleanupItem cleanup(CleanupEComArray, &pluginList1);
+ CleanupStack::PushL(cleanup);
+ ac.ActivePluginsL(pluginList1);
+ CleanupStack::PopAndDestroy(&pluginList1);
+ }
+
+void CAuthSvrOom::doListPluginsOfTypeL(AuthServer::RAuthMgrClient &ac)
+ {
+ RCPointerArray<const CPluginDesc> pluginsList;
+ CleanupClosePushL(pluginsList);
+ TAuthPluginType t1 = EAuthKnowledge;
+ ac.PluginsOfTypeL(t1, pluginsList);
+ CleanupStack::PopAndDestroy(&pluginsList);
+ }
+
+void CAuthSvrOom::doListPluginsWithTrainingStatusL(AuthServer::RAuthMgrClient &ac)
+ {
+ RCPointerArray<const CPluginDesc> pluginsList;
+ CleanupClosePushL(pluginsList);
+ TAuthTrainingStatus t1 = EAuthTrained;
+ ac.PluginsWithTrainingStatusL(t1, pluginsList);
+ CleanupStack::PopAndDestroy(&pluginsList);
+ }
+
+void CAuthSvrOom::doListAuthStrengthAliasesL(AuthServer::RAuthMgrClient &ac)
+ {
+ RPointerArray<HBufC> aliasList;
+ CleanupResetAndDestroyPushL(aliasList);
+ ac.ListAuthAliasesL(aliasList);
+ CleanupStack::PopAndDestroy(&aliasList);
+ }
+
+// Check the reset API (all plugins)
+void CAuthSvrOom::doResetAll(AuthServer::RAuthMgrClient& ac)
+ {
+ TIdentityId identity = getLastAuthId(); // Anything but 0 since client does sanity check
+ ac.ResetIdentityL(identity, _L("1234"));
+ }
+
+// Check the reset API (plugins of specified type)
+void CAuthSvrOom::doResetType(AuthServer::RAuthMgrClient& ac)
+ {
+ TIdentityId identity = getLastAuthId(); // Anything but 0 since client does sanity check
+ ac.ResetIdentityL(identity, EAuthKnowledge, _L("2342"));
+ }
+
+// Check the reset API (specified plugins)
+void CAuthSvrOom::doResetList(AuthServer::RAuthMgrClient& ac)
+ {
+ TIdentityId identity = getLastAuthId(); // Anything but 0 since client does sanity check
+ TInt pluginId(0);
+ GetHexFromConfig(ConfigSection(),_L("plugin1Id"), pluginId);
+ RArray<TPluginId> pluginList;
+ CleanupClosePushL(pluginList);
+ RPointerArray<const HBufC> regDataList;
+ CleanupResetAndDestroyPushL(regDataList);
+ pluginList.AppendL(pluginId);
+ regDataList.AppendL(_L("1344").AllocL());
+ ac.ResetIdentityL(identity, pluginList, regDataList);
+ CleanupStack::PopAndDestroy(2, &pluginList);
+ }
+
+void CAuthSvrOom::ReadTestConfigurationL()
+ {
+
+ TPtrC displayMessage;
+ TBool messageSent = (GetStringFromConfig(ConfigSection(),_L("DisplayMessage"), displayMessage) != EFalse);
+ iMessage = displayMessage;
+ ClientMessage(messageSent, displayMessage);
+ if(!messageSent)
+ {
+ iMessage = KNullDesC();
+ }
+
+ TPinValue pinValue = GetPinFromOutputFileL();
+ CreatePinPluginInputFileL(EPinPluginIdentify, pinValue);
+
+
+ GetStringFromConfig(ConfigSection(),_L("pluginId"), iExprString);
+
+
+ //Retrieve the value of 'freshness' from the ini file, but if it's absent use the default value
+ if(GetIntFromConfig(ConfigSection(),_L("freshness"), iFreshnessVal) == EFalse)
+ {
+ iFreshnessVal = 10;
+ }
+
+ iClientSpecificKeyVal = EFalse;
+ //Retrieve the value of 'clientSpecificKey' from the ini file, but if it's absent use the default value
+ if(GetBoolFromConfig(ConfigSection(),_L("clientSpecificKey"), iClientSpecificKeyVal) == EFalse)
+ {
+ iClientSpecificKeyVal = EFalse;
+ }
+
+ iDefaultpluginusage = EFalse;
+ if(GetBoolFromConfig(ConfigSection(),_L("defaultpluginusage"), iDefaultpluginusage ) == EFalse)
+ {
+ iDefaultpluginusage = EFalse;
+ }
+
+ }
+
+
+TVerdict CAuthSvrOom::doTestStepPostambleL()
+/**
+ @return - TVerdict code
+
+ */
+ {
+
+ CTStepActSch::doTestStepPostambleL();
+ return TestStepResult();
+ }
+
+TVerdict CAuthSvrOom::doPerformanceTestL()
+/**
+ * Runs the test step under OOM Conditions checking that each heap allocation is fail safe
+ */
+ {
+ TInt oomValue;
+ GetIntFromConfig(ConfigSection(), _L("OOMTest"), oomValue);
+ GetIntFromConfig(ConfigSection(), _L("iterationCount"), iIterationCount);
+ StartTimer();
+
+ for (TInt i = 0; i < iIterationCount; ++i)
+ {
+
+ AuthServer::RAuthMgrClient authMgrClient;
+ CleanupClosePushL(authMgrClient);
+ authMgrClient.Connect();
+
+ TRAPD(err, doTestL(authMgrClient));
+ authMgrClient.ShutdownServer();
+ CleanupStack::PopAndDestroy(&authMgrClient);
+ if(err != KErrNone)
+ {
+ User::Leave(err);
+ break;
+ }
+
+ ReadTestConfigurationL();
+ if (oomValue == 2)
+ {
+ RemoveExistingDbL();
+ }
+ }
+
+ StopTimerAndPrintResultL();
+ return TestStepResult();
+ }
+
+void CAuthSvrOom::PrintPerformanceLog(TTime aTime)
+ {
+ TDateTime timer = aTime.DateTime();
+ INFO_PRINTF6(_L("%S,%d:%d:%d:%d"), &KPerformanceTestInfo(), timer.Hour(), timer.Minute(), timer.Second(), timer.MicroSecond());
+ }
+
+void CAuthSvrOom::StartTimer()
+ {
+ iStartTime.HomeTime();
+ PrintPerformanceLog(iStartTime);
+ }
+
+void CAuthSvrOom::StopTimerAndPrintResultL()
+ {
+ TTime endTime;
+ endTime.HomeTime();
+ PrintPerformanceLog(endTime);
+
+ TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(iStartTime);
+ TInt actualDuration = (I64INT(duration.Int64())/1000)/iIterationCount; // in millisecond
+
+ INFO_PRINTF3(_L("%S,%d"), &KActualTestCaseDuration(), actualDuration);
+ }
+