diff -r f18401adf8e1 -r 641f389e9157 authenticationservices/authenticationserver/test/tAuthSvr/src/step_oom.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/authenticationservices/authenticationserver/test/tAuthSvr/src/step_oom.cpp	Tue Aug 31 17:00:08 2010 +0300
@@ -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);
+	}
+