--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sysstatemgmt/systemstatereferenceplugins/test/tintcustcmd/src/tcustcmd_step_simsecuritypincheck.cpp	Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,559 @@
+// 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 "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 "tcustcmd_step_simsecuritypincheck.h"
+#include <ssm/ssmuiproviderdll.h>
+#include <ssm/startupdomainpskeys.h>
+#include <w32std.h>
+#include <s32file.h>
+
+const TInt KNumOfTestCases = 8;
+
+static TInt CustomCmdTestSecurityCheckCallBackL(TAny* aCustomCmdTestSecurityPinCheck)
+	{
+	CCustomCmdTestSecurityPinCheck* test = reinterpret_cast<CCustomCmdTestSecurityPinCheck*>(aCustomCmdTestSecurityPinCheck);
+	CleanupStack::PushL(test);
+	test->CallBackForEnterPin();
+	CleanupStack::Pop(); 
+	return KErrNone;
+	}
+	
+/*
+Call back function to enter a PIN 
+*/
+void CCustomCmdTestSecurityPinCheck::CallBackForEnterPin()
+	{
+	iAsyncStopScheduler->CallBack();
+	
+	RWsSession wsSession;
+	wsSession.Connect();
+
+	TRawEvent eventDown;
+	TRawEvent eventUp;
+	
+	if(iValidPin)
+		{
+		eventDown.Set(TRawEvent::EKeyDown, EStdKeyComma);
+		UserSvr::AddEvent(eventDown);
+		eventUp.Set(TRawEvent::EKeyUp, EStdKeyComma);
+		UserSvr::AddEvent(eventUp);
+		User::After(100000);
+		}
+	
+	eventDown.Set(TRawEvent::EKeyDown, EStdKeyEnter);
+	UserSvr::AddEvent(eventDown);
+	eventUp.Set(TRawEvent::EKeyUp, EStdKeyEnter);
+	UserSvr::AddEvent(eventUp);
+	User::After(100000);
+		
+	wsSession.Flush();
+	wsSession.Close();
+	}
+	
+void CCustomCmdTestSecurityPinCheck::StopScheduler()
+	{
+	//Stop the active scheduler
+	RDebug::Printf("CCustomCmdTestSecurityPinCheck::StopScheduler()");	
+	iActiveSchedulerWait->AsyncStop();
+	}
+
+CCustomCmdTestSecurityPinCheck::~CCustomCmdTestSecurityPinCheck()
+	{
+	delete iAsyncStopScheduler;
+	delete iActiveSchedulerWait;
+	delete iActiveScheduler;
+	delete iStopSimulatekey;
+	}
+
+CCustomCmdTestSecurityPinCheck::CCustomCmdTestSecurityPinCheck():iSwp(TSsmSwp(KTestSwp, 0))
+	{
+	SetTestStepName(KTCCustomCmdTestSecurityPinCheck);
+	}
+
+TVerdict CCustomCmdTestSecurityPinCheck::doTestStepPreambleL()
+	{
+	iActiveScheduler = new(ELeave) CActiveScheduler;
+	CActiveScheduler::Install (iActiveScheduler);
+
+	iActiveSchedulerWait = new(ELeave) CActiveSchedulerWait;
+
+	iAsyncStopScheduler = new(ELeave) CAsyncCallBack(CActive::EPriorityIdle);
+	
+	//Start the test exe which defines startup related property keys
+	RProcess processHandle;
+	CleanupClosePushL(processHandle);
+	processHandle.Create(KExeToDefineStartUpPS, KNullDesC);
+	processHandle.Resume();
+	
+	// wait for the newly created process to rendezvous
+	TRequestStatus status;
+	processHandle.Rendezvous(status);
+	User::WaitForRequest(status);
+	
+	TInt retVal = status.Int();
+	TEST(KErrNone == retVal);
+	// leave if the process has not started properly
+	User::LeaveIfError(retVal);
+	CleanupStack::PopAndDestroy();
+	
+	RProcess processHandle1;
+	TInt err1 = processHandle1.Create(KExeToDefineStartUpStatePS, KNullDesC);
+	INFO_PRINTF2(_L("KExeToDefineStartUpStatePS ret is %d"), err1);
+	processHandle1.Resume();
+	processHandle1.Close();
+
+	//there are 8 different scenarios to test the custom command. Check the test spec for the scenarios.
+ 	//CMiscAdaptationRef::SecurityStateChange() has been changed to simulate the scenarios.
+	//CMiscAdaptationRef::SecurityStateChange() uses KTestCmdSecurityCheckTestFile to get the scenario number
+	//connect to file server
+    User::LeaveIfError(iFs.Connect());
+	TInt err = iFs.MkDirAll(KDirNameOfTestCasesNumFile);
+	if (KErrAlreadyExists != err && KErrNone != err)
+		{
+		User::Leave(err);
+		}
+	err = iFile.Replace(iFs, KTestCmdSecurityCheckTestFile, EFileWrite | EFileStream);
+	iFile.Close();
+	
+	//For stopping the key simulation when execution behaviour is deferredwaitforsignal and fireandforget
+	iStopSimulatekey = CStopSimulatekey::NewL(this);
+ 	
+ 	//Connect to SsmStateManager
+ 	const TInt connect = iClient.Connect();
+	TEST(KErrNone == connect);
+	
+	//RProperty property;
+	iProperty.Define(KCustomcmdServerSID, iSwp.Key(), RProperty::EInt);
+	
+	// Register mapping between keys and swp policy DLL (done once per ssmserver)
+	INFO_PRINTF1(_L("Registering swp..."));
+	iClient.RegisterSwpMapping(KTestSwp, KTestSwpPolicyCustomCmd);
+	
+	RegisterSimSecurityStatus();
+	return TestStepResult();
+	}
+	
+void CCustomCmdTestSecurityPinCheck::RegisterSimSecurityStatus()
+	{
+	INFO_PRINTF1(_L("RegisterSimSecurityStatus"));
+	
+	_LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);
+	//Define the property for sim status for swp.
+	TInt ret = RProperty::Define(RProcess().SecureId(), CSsmUiSpecific::SimStatusPropertyKey(), RProperty::EInt,KAllowAllPolicy, KAllowAllPolicy);
+	TEST(KErrNone == ret || KErrAlreadyExists == ret);
+
+
+	const TUint KStartupSimSecurityStatusKey = {CSsmUiSpecific::SimStatusPropertyKey()};
+	
+	//register the swp mapping for Sim security status with its swp policy
+	ret = iClient.RegisterSwpMapping(KStartupSimSecurityStatusKey, KTestSimStatusSwpPolicy);
+	TEST(KErrNone == ret || KErrAlreadyExists == ret);
+	}
+		
+TVerdict CCustomCmdTestSecurityPinCheck::doTestStepL()
+	{
+	INFO_PRINTF1(_L("doTestStepL"));
+	TInt err = 0;
+	__UHEAP_MARK;
+	
+	iCancelRequest = EFalse;
+	TRAP(err,TestHandleSecCustCmdWithExeBehaviourFireAndForgetL());
+	TEST(KErrNone == err);
+	TRAP(err,TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalL());
+	TEST(KErrNone == err);
+	TRAP(err,TestHandleSecCustCmdWithExeBehaviourWaitForSignalL());	
+	TEST(KErrNone == err);
+
+	iCancelRequest = ETrue;
+	TRAP(err,TestHandleSecCustCmdWithExeBehaviourWaitForSignalCancelL());
+	TEST(KErrNone == err);
+	TRAP(err,TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalCancelL());	
+	TEST(KErrNone == err);	
+	
+	TRAP(err,TestOOMDevSecCustCmdwithExeBehaviourDWFL());
+	TEST(KErrNone == err);	
+
+    return TestStepResult();
+	}
+	
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0019
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0019
+ */
+
+void CCustomCmdTestSecurityPinCheck::TestHandleSecCustCmdWithExeBehaviourWaitForSignalL()	
+	{
+	TInt testNum;	
+	iExecutionBehaviour = ESsmWaitForSignal;
+	iValidPin = ETrue;
+	INFO_PRINTF1(_L("TestHandleSecCustCmdWithExeBehaviourWaitForSignal"));	
+	for(testNum = 1; testNum <= KNumOfTestCases; testNum++)
+		{
+		INFO_PRINTF2(_L("EPINCHECK%d started"),testNum);
+		WritePinCheckTestCaseNumToFileL(testNum);
+		iStopSimulatekey->Start();
+		CreateAndExecuteCustCmd();
+		StartSimulateKey();
+		TEST(KErrNone == iStatus.Int());
+		INFO_PRINTF3(_L("Security PIN check completed with %d, expected %d"),iStatus.Int(),KErrNone);
+		}
+	INFO_PRINTF1(_L("Test security custom command for a invalid PIN "));		
+	iValidPin = EFalse;
+	for(testNum = 1; testNum < KNumOfTestCases; testNum++)
+		{
+		INFO_PRINTF2(_L("EPINCHECK%d started"),testNum);
+		WritePinCheckTestCaseNumToFileL(testNum);
+		iStopSimulatekey->Start();
+		CreateAndExecuteCustCmd();
+		StartSimulateKey();
+		TEST(KErrNone == iStatus.Int());
+		INFO_PRINTF3(_L("Security PIN check completed with %d, expected %d"),iStatus.Int(),KErrNone);
+		}
+	INFO_PRINTF1(_L("TestHandleSecCustCmdWithExeBehaviourWaitForSignal completed"));		
+	}
+
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0027
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0019
+ */
+
+void CCustomCmdTestSecurityPinCheck::TestHandleSecCustCmdWithExeBehaviourWaitForSignalCancelL()	
+	{
+	INFO_PRINTF1(_L("TestHandleSecCustCmdWithExeBehaviourWaitForSignalCancelL"));
+	TInt testNum = 1;
+	iValidPin = ETrue;
+	WritePinCheckTestCaseNumToFileL(testNum);
+	iExecutionBehaviour = ESsmWaitForSignal;
+	iStopSimulatekey->Start();
+	CreateAndExecuteCancelCustCmd();
+	StartSimulateKey();
+	TEST(KErrCancel == iCancelReqStatus.Int());
+	RDebug::Print(_L("TestHandleSecCustCmdWithExeBehaviourWaitForSignalCancelL completed with %d, expected %d"),iCancelReqStatus.Int(),KErrCancel);	
+	INFO_PRINTF3(_L("TestHandleSecCustCmdWithExeBehaviourWaitForSignalCancelL completed with %d, expected %d"),iCancelReqStatus.Int(),KErrCancel);	
+	}
+
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0019
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0019
+ */
+
+void CCustomCmdTestSecurityPinCheck::TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalL()
+	{
+	INFO_PRINTF1(_L("TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalL"));
+	TInt testNum = 1;
+	iValidPin = ETrue;
+	WritePinCheckTestCaseNumToFileL(testNum);
+	iExecutionBehaviour = ESsmDeferredWaitForSignal;
+	iStopSimulatekey->Start();
+	CreateAndExecuteCustCmd();
+	StartSimulateKey();
+	TEST(KErrNone == iStatus.Int());
+	RDebug::Print(_L("TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalL completed with %d, expected %d"),iStatus.Int(),KErrNone);	
+	INFO_PRINTF3(_L("TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalL completed with %d, expected %d"),iStatus.Int(),KErrNone);	
+	}
+
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0027
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0019
+ */
+
+void CCustomCmdTestSecurityPinCheck::TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalCancelL()	
+	{
+	INFO_PRINTF1(_L("TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalCancelL"));	
+	TInt testNum = 1;
+	iValidPin = ETrue;
+	WritePinCheckTestCaseNumToFileL(testNum);
+	iExecutionBehaviour = ESsmDeferredWaitForSignal;
+	iStopSimulatekey->Start();
+	CreateAndExecuteCancelCustCmd();
+	StartSimulateKey();
+	TEST(KErrCancel == iCancelReqStatus.Int());
+	RDebug::Print(_L("TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalCancelL completed with %d, expected %d"),iCancelReqStatus.Int(),KErrCancel);	
+	INFO_PRINTF3(_L("TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalCancelL completed with %d, expected %d"),iCancelReqStatus.Int(),KErrCancel);	
+	}
+	
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0019
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0019
+ */
+
+void CCustomCmdTestSecurityPinCheck::TestHandleSecCustCmdWithExeBehaviourFireAndForgetL()
+	{
+	INFO_PRINTF1(_L("TestHandleSecCustCmdWithExeBehaviourFireAndForgetL"));	
+	TInt testNum = 1;
+	iValidPin = ETrue;
+	WritePinCheckTestCaseNumToFileL(testNum);
+	iExecutionBehaviour = ESsmFireAndForget;
+	iStopSimulatekey->Start();
+	CreateAndExecuteCustCmd();
+	StartSimulateKey();
+	TEST(KErrNone == iStatus.Int());
+	RDebug::Print(_L("TestHandleSecCustCmdWithExeBehaviourFireAndForgetL completed with %d, expected %d"),iStatus.Int(),KErrNone);	
+	INFO_PRINTF3(_L("TestHandleSecCustCmdWithExeBehaviourFireAndForgetL completed with %d, expected %d"),iStatus.Int(),KErrNone);	
+	}
+	
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0025
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0019
+ */
+
+void CCustomCmdTestSecurityPinCheck::TestOOMDevSecCustCmdwithExeBehaviourDWFL()
+	{
+	INFO_PRINTF1(_L("*** Starting TestOOMDevSecCustCmdwithExeBehaviourDWF"));
+	TInt failRate = 1;
+	for (;;failRate++)
+	    {
+	    __UHEAP_SETFAIL(RHeap::EDeterministic,failRate);
+	    __UHEAP_MARK;
+
+	    TRAPD(ret, TestHandleSecCustCmdWithExeBehaviourDeferredWaitForSignalL());
+	    	    
+        TEST((ret==KErrNone || ret==KErrNoMemory));
+        __UHEAP_MARKEND;
+
+	    if (ret==KErrNone)
+	        {
+	        break;
+	        }
+	    }
+	__UHEAP_RESET;
+	INFO_PRINTF2(_L(" Executed securitypincheck custom command %d number of times."),failRate);    
+	}
+		
+void CCustomCmdTestSecurityPinCheck::CancelSwpRequest()
+	{
+	iStopSimulatekey->Start();
+	if(iCancelRequest)
+		{
+		iClient.RequestSwpChangeCancel();
+		}
+	RDebug::Printf("Cancel Swp Request");
+
+	}
+			
+void CCustomCmdTestSecurityPinCheck::CreateAndExecuteCustCmd()
+	{
+	//set the SIM status property as ESimStatusUninitialized
+	TInt result = RProperty::Set(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), ESimStatusUninitialized);
+	TEST(KErrNone == result);   
+	
+	TInt swpValue = 0;
+	switch(iExecutionBehaviour)
+		{
+		case ESsmWaitForSignal:
+			swpValue = ERPropertyValForSecCustCmdWaitForSignal;
+		break;
+		case ESsmDeferredWaitForSignal:
+			swpValue = ERPropertyValForSecCustCmdDeferrdWaitForSignal;	
+		break;
+		case ESsmFireAndForget:
+			swpValue = ERPropertyValForSecCustCmdFireAndForget;
+		break;
+		default:
+		break;
+		}
+	// Create swps
+	INFO_PRINTF1(_L("Creating swp..."));
+	//set this property to create appropriate command by ssm.swp.policy.test.customcmd.dll
+	iSwp.Set(KTestSwp, swpValue);	
+	
+	TEST(KErrNone == iProperty.Set(KCustomcmdServerSID, iSwp.Key(), iSwp.Value()));
+	
+	//Ensure the environment is clean
+	TInt value = 0;
+	TEST(KErrNone == iProperty.Get(KCustomcmdServerSID, iSwp.Key(), value));
+	TESTE(swpValue == value, value);
+	
+	//Let client request swp changes
+	INFO_PRINTF1(_L("Request several swp changes "));
+	iSwp.Set(KTestSwp, -99);
+	
+	iClient.RequestSwpChange(iSwp, iStatus);		
+
+	TEST(iStatus == KRequestPending);
+	User::WaitForRequest(iStatus);
+	User::After(500000); // Wait for 0.5sec to allow transitions to fully complete
+	TEST(iStatus.Int() == KErrNone);	
+	}
+	
+void CCustomCmdTestSecurityPinCheck::CreateAndExecuteCancelCustCmd()
+	{
+	TInt swpValue = 0;
+		switch(iExecutionBehaviour)
+		{
+		case ESsmWaitForSignal:
+			swpValue = ERPropertyValForSecCustCmdWaitForSignal;
+		break;
+		case ESsmDeferredWaitForSignal:
+			swpValue = ERPropertyValForSecCustCmdDeferrdWaitForSignal;	
+		break;
+		case ESsmFireAndForget:
+			swpValue = ERPropertyValForSecCustCmdFireAndForget;
+		break;
+		default:
+		break;
+		}
+	// Create swps
+	INFO_PRINTF1(_L("Creating swp..."));
+	//set this property to create appropriate command by ssm.swp.policy.test.customcmd.dll
+	iSwp.Set(KTestSwp, swpValue);	
+	
+	TEST(KErrNone == iProperty.Set(KCustomcmdServerSID, iSwp.Key(), iSwp.Value()));
+	
+	//Ensure the environment is clean
+	TInt value = 0;
+	TEST(KErrNone == iProperty.Get(KCustomcmdServerSID, iSwp.Key(), value));
+	TESTE(swpValue == value, value);
+	
+	//Let client request swp changes
+	INFO_PRINTF1(_L("Request several swp changes "));
+	iSwp.Set(KTestSwp, -99);
+	
+	//Transition engine will no cancel any request that is currently in execution. It will delete only quad request.
+	TRequestStatus status;
+	iClient.RequestSwpChange(iSwp, iStatus);		
+	iClient.RequestSwpChange(iSwp, iCancelReqStatus);			
+	TEST(iStatus == KRequestPending);
+	//User::After(5000); // Wait for 0.005sec to allow transitions to start
+	User::WaitForRequest(iStatus);
+	TEST(iStatus.Int() == KErrNone);
+	iClient.RequestSwpChangeCancel();
+	RDebug::Print(_L("CreateAndExecuteCancelCustCmdL completes with %d err"),iStatus.Int());
+	
+	}						
+/**
+write the pin check test case number to a file so that misc ref plugin can read the 
+it and check corresponding PIN Check security plug-in functionality in different SIM status
+*/
+void CCustomCmdTestSecurityPinCheck::WritePinCheckTestCaseNumToFileL(TInt aTestNum)
+	{
+	INFO_PRINTF1(_L("WritePinCheckTestCaseNumToFileL"));
+    //RFile file;
+    const TInt err = iFile.Open(iFs, KTestCmdSecurityCheckTestFile, EFileWrite | EFileStream);
+	User::LeaveIfError(err);
+
+	RFileWriteStream stream(iFile);
+	CleanupClosePushL(stream);
+   
+    stream.WriteInt32L(aTestNum);
+    stream.CommitL();
+    CleanupStack::PopAndDestroy(&stream);
+	}
+
+TVerdict CCustomCmdTestSecurityPinCheck::doTestStepPostambleL()
+	{
+	TEST(KErrNone == iProperty.Delete(KCustomcmdServerSID, iSwp.Key()));
+	iProperty.Close();
+	iClient.Close();
+	//delete the file		
+    iFs.Delete(KTestCmdSecurityCheckTestFile);
+	iFs.Close();
+	__UHEAP_MARKEND;
+	return TestStepResult();
+	}
+	
+void CCustomCmdTestSecurityPinCheck::StartSimulateKey()
+	{
+	//Callback function for simulating the key
+	TCallBack stop(CustomCmdTestSecurityCheckCallBackL, this);
+	if(!iAsyncStopScheduler->IsActive())
+		{
+		iAsyncStopScheduler->Set(stop);
+		}
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	}
+
+TSsmExecutionBehaviour CCustomCmdTestSecurityPinCheck::GetExecutionBehaviour()	
+	{
+	return iExecutionBehaviour;	
+	}
+//
+/**
+CStopSimulatekey class is used for stoping the scheduler and for canceling the swp request.
+*/
+CStopSimulatekey::~CStopSimulatekey()
+	{
+	iProperty.Close();
+	Cancel();
+	}
+
+CStopSimulatekey::CStopSimulatekey() : CActive(CActive::EPriorityHigh)  //Standard)
+	{	
+	CActiveScheduler::Add(this);
+	}
+
+CStopSimulatekey* CStopSimulatekey::NewL(CCustomCmdTestSecurityPinCheck* aCustomCmdTestSecurityPinCheck)
+	{
+	CStopSimulatekey* self = new (ELeave) CStopSimulatekey();
+	CleanupStack::PushL(self);
+	self->Construct(aCustomCmdTestSecurityPinCheck);
+	CleanupStack::Pop();
+	return self;
+	}
+
+void CStopSimulatekey::Construct(CCustomCmdTestSecurityPinCheck* aCustomCmdTestSecurityPinCheck)
+	{
+	// Define a property for stopping active scheduler 
+ 	TInt r = RProperty::Define(KCustomcmdServerPropertyKey, RProperty::EInt,ECapability_None, ECapability_None);								
+	iCustomCmdTestSecurityPinCheck = aCustomCmdTestSecurityPinCheck;
+	}
+		
+void CStopSimulatekey::Start()
+	{  
+	iProperty.Attach(KCustomcmdServerSID,KCustomcmdServerPropertyKey);
+	iProperty.Subscribe(iStatus);
+	SetActive();				
+	}	
+ 
+void CStopSimulatekey::RunL()
+	{	
+	TInt value;
+	TInt err = RProperty::Get(RProcess().SecureId(),KCustomcmdServerPropertyKey,value);	
+	
+	if( value == ERPropertyValForSecCustCmdCancelRequest)		
+		{
+		RDebug::Printf("CStopSimulatekey::RunL() CustCmdCancelRequest)");
+		iCustomCmdTestSecurityPinCheck->CancelSwpRequest();				
+		}	
+	else if( value == ERPropertyValForStopSchedulerCmdDeferredWaitForSignal && iCustomCmdTestSecurityPinCheck->GetExecutionBehaviour() == ESsmDeferredWaitForSignal)		
+		{
+		RDebug::Printf("CStopSimulatekey::RunL() ExecutionBehaviour = ESsmDeferredWaitForSignal");
+		iCustomCmdTestSecurityPinCheck->StopScheduler();		
+		}
+	else if( value == ERPropertyValForStopSchedulerCmdWaitForSignal && iCustomCmdTestSecurityPinCheck->GetExecutionBehaviour() == ESsmWaitForSignal)
+		{
+		RDebug::Printf("iCustomCmdTestSecurityPinCheck->StopScheduler()if( CStopSimulatekey::RunL() ExecutionBehaviour = ESsmWaitForSignal");
+		iCustomCmdTestSecurityPinCheck->StopScheduler();		
+		}
+	else if( value == ERPropertyValForStopSchedulerCmdFireAndForget && iCustomCmdTestSecurityPinCheck->GetExecutionBehaviour() == ESsmFireAndForget )	
+		{
+		RDebug::Printf("CStopSimulatekey::RunL() ExecutionBehaviour = FireAndForget");		
+		User::After(5000000); // Wait 5sec to allow transitions to fully complete
+		User::After(5000000); // Wait 5sec to allow transitions to fully complete
+		iCustomCmdTestSecurityPinCheck->StopScheduler();		
+		}	
+	else
+		{
+		Start();
+		}		
+	}
+	
+void CStopSimulatekey::DoCancel()
+	{
+	iProperty.Cancel();
+	}
+
+